@clearlydev/nx-archweave 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 nx-archweave contributors
+
+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

@@ -1,3 +1,266 @@
-# Temporary Holding Version
+# @clearlydev/nx-archweave
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Nx generators that get a workspace ready to work on with one preset:
+
+- FSD Lite structure with enforced module boundaries
+- AI agent rules
+- GitHub templates
+- optional AI PR review (Claude, Gemini, GPT, Cursor)
+
+Starting a brand-new workspace instead? Use [`create-nx-archweave`](https://www.npmjs.com/package/create-nx-archweave). It creates the workspace, installs this plugin, and runs `init`, all in one command.
+
+## Install
+
+Run one of these at the workspace root, with the workspace's package manager:
+
+```bash
+npm install -D @clearlydev/nx-archweave        # npm
+pnpm add -D -w @clearlydev/nx-archweave        # pnpm
+yarn add -D @clearlydev/nx-archweave           # yarn berry (yarn 1: add -W)
+bun add -d @clearlydev/nx-archweave            # bun
+```
+
+Then confirm the install. `doctor` is read-only:
+
+```bash
+npm exec nx -- g @clearlydev/nx-archweave:doctor   # npm
+pnpm nx g @clearlydev/nx-archweave:doctor          # pnpm
+yarn nx g @clearlydev/nx-archweave:doctor          # yarn
+bun nx g @clearlydev/nx-archweave:doctor           # bun
+```
+
+- **Requirements:** Node >= 22.18, plus one of npm, pnpm >= 10, yarn (classic or berry) or bun. All four package managers are first-class.
+- Generators detect the workspace's real package manager from its lockfiles.
+- The examples below use `pnpm nx g`. With another package manager, run the same generator the way the `doctor` commands above show.
+- The package ships as a self-contained bundle. Its only runtime dependency is `@nx/devkit`.
+
+## Quick start
+
+Preview the full run first. This writes nothing:
+
+```bash
+pnpm nx g @clearlydev/nx-archweave:init --preset=team --frontend=next --dryRun
+```
+
+Then run it for real:
+
+```bash
+pnpm nx g @clearlydev/nx-archweave:init --preset=team --frontend=next
+```
+
+- `init` runs the content generators below according to the preset (`quick-start` | `solo` | `team`).
+- `init` requires a clean git working tree. That way you can always undo a partial run with a single `git restore .`.
+- `--allowDirty` opts out of the clean-tree check. The report then warns you that the rollback scope is wider.
+- `--locale=ko|en` sets the language of generated content. Reports are always in English.
+
+## Generators
+
+| Generator | What it does |
+| --- | --- |
+| `init` | Runs the five `add-*` generators by preset |
+| `doctor` | Read-only diagnosis; never writes |
+| `add-fsd-lite` | Wires in the FSD boundaries ESLint rule |
+| `add-agent-rules` | Writes rules into each AI host's file |
+| `add-github-templates` | Issue Forms, PR template, CODEOWNERS |
+| `add-review` | AI PR review workflow |
+| `add-backend` | Wires a backend app in |
+| `page` / `widget` / `feature` / `entity` / `shared` | Scaffold an FSD slice or segment |
+| `add-integration` | Previews a catalog plugin's install flow |
+| `install-integration` | Installs a catalog plugin (with `--apply`) |
+| `record-integration` | Records a plugin you installed by hand |
+| `allow-builds` | pnpm only: allows skipped build scripts |
+
+In the option lists below:
+
+- \* marks a required option.
+- † marks an option that's required until `init` has recorded it in `toolkit.config.json`. After that, if you leave it out, the generator uses the recorded value.
+
+### `init`
+
+A preset-driven pipeline over the five `add-*` generators: `add-fsd-lite`, `add-agent-rules`, `add-github-templates`, `add-review` and `add-backend`. After the run, `init` does a best-effort validation (actionlint, `nx graph`).
+
+Options: `--preset`†, `--frontend`†, `--backend`, `--packageManager`, `--locale`, `--aiHosts`, `--reviewProvider`, `--fsd`, `--agentRules`, `--githubTemplates`, `--review`, `--applyEslint`, `--allowDirty`, `--dryRun`
+
+### `doctor`
+
+A read-only diagnosis. `doctor` never writes. It checks:
+
+- workspace, package manager and framework detection
+- the nx version range
+- whether the boundary tags exist
+- FSD-like structure
+- review consistency
+- drift states
+
+Options: `--liveIntegrations`, `--json`
+
+### `add-fsd-lite`
+
+Wires the `archweave/fsd-boundaries` ESLint rule into the frontend app's config. The rule ships as `@clearlydev/nx-archweave/eslint`.
+
+- With `--applyEslint`, the generator writes the config. Without it, you get a paste-ready snippet.
+- An unrecognized config is never edited.
+- Prints the layer guide (Next.js: `pages` → `_pages/`).
+- Creates no folders.
+- `--steiger` adds the official FSD linter as an opt-in `fsd-check` target (Node ≥ 22.18).
+
+Options: `--frontend`†, `--project`, `--enforcement`, `--applyEslint`, `--steiger`, `--locale`, `--dryRun`
+
+### `add-agent-rules`
+
+Writes nx-archweave's rules as one marked block in the file each AI host reads:
+
+- `CLAUDE.md` for Claude Code
+- `AGENTS.md` for Codex, Cursor and Gemini CLI
+
+The generator never touches the text around the block.
+
+Options: `--hosts`, `--teamRules`, `--locale`, `--dryRun`
+
+### `add-github-templates`
+
+Adds GitHub Issue Forms, a PR template and CODEOWNERS. The generator always skips files that already exist.
+
+Options: `--issue`, `--pr`, `--codeowners`, `--locale`, `--dryRun`
+
+### `add-review`
+
+Installs the AI PR review workflow and the `review` field in `toolkit.config.json`.
+
+- `--provider`, `--mode`, `--maxRounds`: if you leave one out, the generator uses the value already recorded
+- `--onConflict`, `--locale`, `--dryRun`
+
+### `add-backend`
+
+Wires a backend app in:
+
+- a `shared-types` lib
+- `scope:` tags
+- boundary constraints (written only with `--applyEslint`)
+
+If the `api` project is missing, the generator refuses and gives you the official commands to copy and paste.
+
+Options: `--backend`\*, `--apiName`, `--frontendProject`, `--applyEslint`, `--dryRun`
+
+### `page` / `widget` / `feature` / `entity` / `shared`
+
+`page`, `widget`, `feature` and `entity` scaffold a slice: `index.ts` + `model/`, plus `--segments` extras. `shared` scaffolds a purpose-named segment instead. Each generator writes to its own layer in the app:
+
+- `page` → `src/pages` (`_pages` on Next.js)
+- `widget` → `src/widgets`
+- `feature` → `src/features`
+- `entity` → `src/entities`
+- `shared` → `src/shared`
+
+All five generators create the layer directory if it's missing, skip slices that have the same name, and check that `--publicApiName` is a usable identifier.
+
+- Options: `--name`\*, `--publicApiName`, `--segments`, `--project`, `--locale`, `--dryRun`
+- `--segments` isn't available on `shared`, because there the segment is the name.
+- `page` also takes `--frontend`.
+
+### `add-integration`
+
+**Preview only.** Shows a catalog plugin's official install flow: source, license, manual steps and uninstall. `add-integration` installs nothing and writes nothing.
+
+Options: `--tool`\*, `--target`, `--scope`, `--versionRange`, `--dryRun`
+
+### `install-integration`
+
+With `--apply`, `install-integration`:
+
+- runs the host's official CLI install of a catalog plugin (project scope by default)
+- re-verifies the install live
+- records the manifest entry
+- declares the tool in `toolkit.config.json`
+
+Without `--apply`, you get a preview.
+
+Options: `--tool`\*, `--target`, `--scope`, `--versionRange`, `--apply`
+
+### `record-integration`
+
+Verifies a manually completed install live. With `--apply`, it records exactly one entry in `archweave-integrations.json`, and only when the authoritative signal succeeds.
+
+Options: `--tool`\*, `--target`, `--apply`
+
+### `allow-builds`
+
+pnpm only. Allows dependency build scripts that pnpm skipped or was told to deny. With `--apply`, `allow-builds` sets those packages to `true` in `pnpm-workspace.yaml` and runs `pnpm rebuild`. Without `--apply`, you get a preview.
+
+Options: `--packages`\*, `--apply`
+
+## Presets
+
+| | `quick-start` | `solo` | `team` |
+| --- | --- | --- | --- |
+| FSD Lite | on | on | on |
+| FSD rule severity | `warn` | `warn` | `error` |
+| Agent rules | the AI hosts' files | the AI hosts' files | the AI hosts' files + Team Rules section |
+| GitHub templates | PR only | PR only | Issue + PR |
+| Review default | off (opt-in) | on | on |
+| Review mode | `fast` | `fast` | `standard` |
+
+Explicit flags always win over preset defaults.
+
+## AI PR review
+
+Review is fully optional and isn't tied to one provider.
+
+- If review is disabled, zero review artifacts are generated.
+- If review is enabled, the workflow **green-skips** (it never fails) until you register the provider's secret.
+- A round marker stops the workflow after `--maxRounds` reviews per PR (1–5, default 3).
+
+| `--provider` | Workflow file | Required secret |
+| --- | --- | --- |
+| `claude` (default) | `.github/workflows/claude-code-review.yml` | `CLAUDE_CODE_OAUTH_TOKEN` |
+| `gemini` | `.github/workflows/gemini-code-review.yml` | `GEMINI_API_KEY` |
+| `gpt` | `.github/workflows/gpt-code-review.yml` | `OPENAI_API_KEY` |
+| `cursor` | `.github/workflows/cursor-code-review.yml` | `CURSOR_API_KEY` |
+
+Modes:
+
+- `fast` and `standard` review correctness & security.
+- `thorough` adds an over-engineering pass.
+
+Findings are prioritized P0–P3/Nit per the bundled review policy.
+
+## Behavioral contracts
+
+Every generator keeps four promises:
+
+- `--dryRun` previews fully and writes nothing.
+- Running it again against identical content reports "no change".
+- A failed precondition produces a refusal report, not an exception.
+- Conflicts are never silently overwritten.
+
+## Optional plugins per AI host (experimental)
+
+Three generators work with plugins from a reviewed **catalog**:
+
+- `add-integration` previews a plugin.
+- `install-integration` installs a plugin (with `--apply`).
+- `record-integration` records a plugin.
+
+Installs go through the AI host's own official installer, in project scope by default.
+
+- The catalog is data. Claude Code is the only host with an adapter today, and [ponytail](https://github.com/DietrichGebert/ponytail) is its first entry.
+- Recording requires the live `claude plugin list --json` signal to confirm that the plugin is installed **and** enabled.
+- A disabled plugin, an ambiguous match or a CLI error produces zero writes, never a false "verified".
+- `doctor` reports the declared, recorded and detected state of each plugin. `--liveIntegrations` re-verifies live.
+- Nothing here runs unless you ask.
+
+## More
+
+Full documentation and the Korean README live in the [repository](https://github.com/clearlydev/nx-archweave).
+
+## Contributing
+
+- `nx build @clearlydev/nx-archweave` runs tsc, for local dev and typecheck.
+- `nx test` runs Jest.
+- `nx bundle` (depends on `build`) produces the publishable esbuild bundle in `dist/`. Internal workspace packages are inlined, so the tarball carries no `workspace:` deps.
+- `prepack` re-runs `bundle` and strips `workspace:` ranges from the packed manifest only. It's interruption-safe: `postpack` restores the on-disk `package.json`.
+- To verify a release candidate, run `node tools/verify-tarball.mjs` at the repo root.
+
+## License
+
+MIT

package/dist/bin/review-verdict.js

@@ -0,0 +1,330 @@
+#!/usr/bin/env node
+
+// src/bin/review-verdict.ts
+import { spawnSync } from "node:child_process";
+import { realpathSync } from "node:fs";
+
+// ../review-policy/dist/schema/review-finding.js
+function computeVerdict(findings) {
+  if (findings.some((f) => f.priority === "P0" || f.priority === "P1"))
+    return "BLOCK";
+  if (findings.some((f) => f.priority === "P2"))
+    return "CHANGES_RECOMMENDED";
+  if (findings.length > 0)
+    return "APPROVE_WITH_NOTES";
+  return "APPROVE";
+}
+
+// ../review-policy/dist/verdict-gate/findings-block.js
+var FINDINGS_MARKER = "<!-- archweave-findings-v1 -->";
+var FINDINGS_SCHEMA_ID = "archweave/findings@1";
+var PRIORITIES = ["P0", "P1", "P2", "P3", "Nit"];
+function findingKey(f) {
+  return `${f.file}:${f.lineRange.start}:${f.category}`;
+}
+function extractFindingsBlock(commentBody) {
+  const markerIndex = commentBody.lastIndexOf(FINDINGS_MARKER);
+  if (markerIndex === -1)
+    return { status: "missing" };
+  const after = commentBody.slice(markerIndex + FINDINGS_MARKER.length);
+  const open = /```json[ \t]*\r?\n/.exec(after);
+  if (!open)
+    return { status: "invalid" };
+  const contentStart = open.index + open[0].length;
+  let parsed;
+  let found = false;
+  for (let close = after.indexOf("```", contentStart); close !== -1; close = after.indexOf("```", close + 3)) {
+    try {
+      parsed = JSON.parse(after.slice(contentStart, close));
+      found = true;
+      break;
+    } catch {
+    }
+  }
+  if (!found)
+    return { status: "invalid" };
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+    return { status: "invalid" };
+  const obj = parsed;
+  if (obj.schema !== FINDINGS_SCHEMA_ID || !Array.isArray(obj.findings))
+    return { status: "invalid" };
+  const findings = [];
+  for (const raw of obj.findings) {
+    const finding = normalizeFinding(raw);
+    if (finding === null)
+      return { status: "invalid" };
+    findings.push(finding);
+  }
+  return { status: "ok", findings };
+}
+function normalizeFinding(raw) {
+  if (raw === null || typeof raw !== "object")
+    return null;
+  const r = raw;
+  const lineRange = r["lineRange"];
+  if (!PRIORITIES.includes(r["priority"]) || typeof r["category"] !== "string" || typeof r["title"] !== "string" || typeof r["file"] !== "string" || lineRange === null || lineRange === void 0 || typeof lineRange !== "object" || typeof lineRange.start !== "number" || !Number.isInteger(lineRange.start) || lineRange.start < 1) {
+    return null;
+  }
+  const str = (value) => typeof value === "string" ? value : "";
+  return {
+    priority: r["priority"],
+    category: r["category"],
+    title: r["title"],
+    file: r["file"],
+    lineRange: { start: lineRange.start, ...typeof lineRange.end === "number" ? { end: lineRange.end } : {} },
+    evidence: str(r["evidence"]),
+    impact: str(r["impact"]),
+    reproductionCondition: str(r["reproductionCondition"]),
+    recommendation: str(r["recommendation"]),
+    confidence: r["confidence"] === "plausible" ? "plausible" : "confirmed"
+  };
+}
+
+// ../review-policy/dist/renderers/render-review-comment.js
+var COPY = {
+  en: {
+    terminationBanner: (maxRounds) => `> \u26A0\uFE0F **Automated review ended.** The maximum of ${maxRounds} review rounds has been reached with blocking findings (P0/P1) still open. Human review is required.`,
+    verdictLines: {
+      BLOCK: "**Verdict: BLOCK** \u2014 P0/P1 findings must be resolved before this change can merge.",
+      CHANGES_RECOMMENDED: "**Verdict: CHANGES_RECOMMENDED** \u2014 P2 findings should be addressed.",
+      APPROVE_WITH_NOTES: "**Verdict: APPROVE_WITH_NOTES** \u2014 only advisory notes below; safe to merge.",
+      APPROVE: "**Verdict: APPROVE** \u2014 no findings."
+    },
+    mainSection: "## Correctness & Security",
+    overEngineeringSection: "## Over-engineering",
+    nitSection: "## Nits",
+    roundHistoryHeading: "**Round history:**",
+    roundLine: (round, fixed, remaining) => `- round ${round}: ${fixed} fixed, ${remaining} remaining`,
+    fieldLabels: {
+      file: "File",
+      evidence: "Evidence",
+      impact: "Impact",
+      reproduction: "Reproduction",
+      recommendation: "Recommendation",
+      confidence: "Confidence"
+    }
+  },
+  ko: {
+    terminationBanner: (maxRounds) => `> \u26A0\uFE0F **\uC790\uB3D9 \uB9AC\uBDF0 \uC885\uB8CC.** \uCD5C\uB300 ${maxRounds}\uD68C\uC758 \uB9AC\uBDF0 \uB77C\uC6B4\uB4DC\uC5D0 \uB3C4\uB2EC\uD588\uC9C0\uB9CC \uBCD1\uD569\uC744 \uB9C9\uB294 finding(P0/P1)\uC774 \uB0A8\uC544 \uC788\uC2B5\uB2C8\uB2E4. \uC0AC\uB78C\uC758 \uB9AC\uBDF0\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4.`,
+    verdictLines: {
+      BLOCK: "**\uD310\uC815: BLOCK** \u2014 \uBCD1\uD569 \uC804\uC5D0 P0/P1 finding\uC744 \uD574\uACB0\uD574\uC57C \uD569\uB2C8\uB2E4.",
+      CHANGES_RECOMMENDED: "**\uD310\uC815: CHANGES_RECOMMENDED** \u2014 P2 finding\uC744 \uD574\uACB0\uD558\uB294 \uAC83\uC744 \uAD8C\uC7A5\uD569\uB2C8\uB2E4.",
+      APPROVE_WITH_NOTES: "**\uD310\uC815: APPROVE_WITH_NOTES** \u2014 \uCC38\uACE0\uC6A9 \uB178\uD2B8\uB9CC \uC788\uC2B5\uB2C8\uB2E4. \uBCD1\uD569\uD574\uB3C4 \uC548\uC804\uD569\uB2C8\uB2E4.",
+      APPROVE: "**\uD310\uC815: APPROVE** \u2014 finding\uC774 \uC5C6\uC2B5\uB2C8\uB2E4."
+    },
+    mainSection: "## \uC815\uD655\uC131 & \uBCF4\uC548",
+    overEngineeringSection: "## \uACFC\uC789 \uC124\uACC4",
+    nitSection: "## \uC0AC\uC18C\uD55C \uC9C0\uC801 (Nit)",
+    roundHistoryHeading: "**\uB77C\uC6B4\uB4DC \uC774\uB825:**",
+    roundLine: (round, fixed, remaining) => `- ${round}\uB77C\uC6B4\uB4DC: \uD574\uACB0 ${fixed}\uAC74, \uBBF8\uD574\uACB0 ${remaining}\uAC74`,
+    fieldLabels: {
+      file: "\uD30C\uC77C",
+      evidence: "\uADFC\uAC70",
+      impact: "\uC601\uD5A5",
+      reproduction: "\uC7AC\uD604 \uC870\uAC74",
+      recommendation: "\uAD8C\uC7A5 \uC870\uCE58",
+      confidence: "\uD655\uC2E0\uB3C4"
+    }
+  }
+};
+function verdictLine(verdict, locale) {
+  return COPY[locale].verdictLines[verdict];
+}
+function terminationBannerLine(maxRounds, locale) {
+  return COPY[locale].terminationBanner(maxRounds);
+}
+
+// ../review-policy/dist/verdict-gate/verdict-comment.js
+var VERDICT_MARKER = "<!-- archweave-verdict -->";
+var HISTORY_HEADING = { en: "**Round history:**", ko: "**\uB77C\uC6B4\uB4DC \uC774\uB825:**" };
+var ROUND_LINE = {
+  en: (round, fixed, remaining) => `- round ${round}: ${fixed} fixed, ${remaining} remaining`,
+  ko: (round, fixed, remaining) => `- ${round}\uCC28: ${fixed}\uAC74 \uD574\uACB0, ${remaining}\uAC74 \uC794\uC874`
+};
+var UNPARSEABLE_NOTICE = {
+  en: "\u26A0\uFE0F The review comment could not be machine-read (missing or invalid findings block). The verdict gate stays green; please review this PR manually.",
+  ko: "\u26A0\uFE0F \uB9AC\uBDF0 \uCF54\uBA58\uD2B8\uB97C \uAE30\uACC4 \uD310\uB3C5\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4(findings \uBE14\uB85D \uB204\uB77D \uB610\uB294 \uC190\uC0C1). verdict \uAC8C\uC774\uD2B8\uB294 \uB179\uC0C9\uC73C\uB85C \uB450\uB2C8 \uC774 PR\uC740 \uC0AC\uB78C\uC774 \uC9C1\uC811 \uB9AC\uBDF0\uD574 \uC8FC\uC138\uC694."
+};
+var NO_ROUND_NOTICE = {
+  en: "\u26A0\uFE0F This run of the review posted no summary comment for the current commit, so there is no verdict for it (an earlier round is never reused). The verdict gate stays green; please review this PR manually.",
+  ko: "\u26A0\uFE0F \uC774\uBC88 \uB9AC\uBDF0 \uC2E4\uD589\uC774 \uD604\uC7AC \uCEE4\uBC0B\uC5D0 \uB300\uD55C \uC694\uC57D \uCF54\uBA58\uD2B8\uB97C \uAC8C\uC2DC\uD558\uC9C0 \uC54A\uC544 verdict\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4(\uC774\uC804 \uB77C\uC6B4\uB4DC\uB294 \uC7AC\uC0AC\uC6A9\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4). verdict \uAC8C\uC774\uD2B8\uB294 \uB179\uC0C9\uC73C\uB85C \uB450\uB2C8 \uC774 PR\uC740 \uC0AC\uB78C\uC774 \uC9C1\uC811 \uB9AC\uBDF0\uD574 \uC8FC\uC138\uC694."
+};
+var HEAD_LINE = {
+  en: (sha) => `<sub>Commit \`${sha.slice(0, 7)}\` \xB7 this comment is updated on every review round.</sub>`,
+  ko: (sha) => `<sub>\uCEE4\uBC0B \`${sha.slice(0, 7)}\` \xB7 \uC774 \uCF54\uBA58\uD2B8\uB294 \uB9AC\uBDF0 \uB77C\uC6B4\uB4DC\uB9C8\uB2E4 \uAC31\uC2E0\uB429\uB2C8\uB2E4.</sub>`
+};
+function withHead(lines, locale, headSha) {
+  return (headSha === void 0 ? lines : [...lines, "", HEAD_LINE[locale](headSha)]).join("\n");
+}
+function renderUnparseableNotice(locale, headSha) {
+  return withHead([VERDICT_MARKER, UNPARSEABLE_NOTICE[locale]], locale, headSha);
+}
+function renderNoRoundNotice(locale, headSha) {
+  return withHead([VERDICT_MARKER, NO_ROUND_NOTICE[locale]], locale, headSha);
+}
+function renderVerdictComment(input) {
+  const lines = [VERDICT_MARKER];
+  if (input.isFinalRound && input.verdict === "BLOCK") {
+    lines.push(terminationBannerLine(input.maxRounds, input.locale), "");
+  }
+  lines.push(verdictLine(input.verdict, input.locale));
+  if (input.history.length > 1) {
+    lines.push("", HISTORY_HEADING[input.locale]);
+    for (let i = 0; i < input.history.length; i++) {
+      if (i === 0)
+        continue;
+      const entry = input.history[i];
+      lines.push(ROUND_LINE[input.locale](entry.round, entry.fixedFindingKeys.length, entry.remainingFindingKeys.length));
+    }
+  }
+  return withHead(lines, input.locale, input.headSha);
+}
+
+// ../review-policy/dist/verdict-gate/verdict-gate.js
+var ROUND_MARKER = "<!-- archweave-review-round -->";
+function collectRounds(comments) {
+  return comments.filter((c) => c.body.includes(ROUND_MARKER) && !c.body.includes(VERDICT_MARKER)).map((c, index) => ({ round: index + 1, id: c.id, extraction: extractFindingsBlock(c.body) }));
+}
+function computeRoundHistory(rounds) {
+  const parsed = rounds.filter((r) => r.extraction.status === "ok");
+  const history = [];
+  for (let i = 0; i < parsed.length; i++) {
+    const keys = new Set(parsed[i].extraction.findings.map(findingKey));
+    if (i === 0) {
+      history.push({ round: parsed[i].round, fixedFindingKeys: [], remainingFindingKeys: [...keys] });
+      continue;
+    }
+    const previous = new Set(parsed[i - 1].extraction.findings.map(findingKey));
+    history.push({
+      round: parsed[i].round,
+      fixedFindingKeys: [...previous].filter((key) => !keys.has(key)),
+      remainingFindingKeys: [...keys]
+    });
+  }
+  return history;
+}
+function runVerdictGate(input) {
+  const rounds = collectRounds(input.comments);
+  if (rounds.length === 0)
+    return { kind: "no-review" };
+  const latest = rounds[rounds.length - 1];
+  if (input.roundAfterId !== void 0 && (latest.id === void 0 || latest.id <= input.roundAfterId)) {
+    return { kind: "no-round", commentBody: renderNoRoundNotice(input.locale, input.headSha) };
+  }
+  if (latest.extraction.status !== "ok") {
+    return { kind: "unparseable", commentBody: renderUnparseableNotice(input.locale, input.headSha) };
+  }
+  const verdict = computeVerdict(latest.extraction.findings);
+  const commentBody = renderVerdictComment({
+    verdict,
+    history: computeRoundHistory(rounds),
+    maxRounds: input.maxRounds,
+    locale: input.locale,
+    isFinalRound: rounds.length >= input.maxRounds,
+    headSha: input.headSha
+  });
+  return { kind: "verdict", verdict, commentBody, exitCode: verdict === "BLOCK" ? 1 : 0 };
+}
+
+// src/bin/review-verdict.ts
+var realExec = (command, args, stdin) => {
+  const result = spawnSync(command, args, { encoding: "utf-8", input: stdin });
+  return { status: result.status ?? null, stdout: result.stdout ?? "" };
+};
+function runReviewVerdictBin(env, exec) {
+  const logs = [];
+  const repo = env["GITHUB_REPOSITORY"];
+  const pr = env["ARCHWEAVE_PR_NUMBER"];
+  const maxRounds = Number(env["ARCHWEAVE_MAX_ROUNDS"]);
+  const locale = env["ARCHWEAVE_LOCALE"] === "ko" ? "ko" : "en";
+  if (!repo || !pr || !Number.isInteger(maxRounds) || maxRounds < 1) {
+    logs.push("verdict gate: required environment missing or malformed \u2014 skipping (check stays green).");
+    return { exitCode: 0, logs };
+  }
+  const watermark = env["ARCHWEAVE_ROUND_AFTER_ID"];
+  const roundAfterId = watermark !== void 0 && /^\d+$/.test(watermark) ? Number(watermark) : void 0;
+  const sha = env["ARCHWEAVE_HEAD_SHA"];
+  const headSha = sha !== void 0 && /^[0-9a-f]{7,40}$/i.test(sha) ? sha : void 0;
+  const fetched = exec("gh", ["api", `repos/${repo}/issues/${pr}/comments`, "--paginate"]);
+  if (fetched.status !== 0) {
+    logs.push("verdict gate: could not fetch PR comments via gh \u2014 skipping (check stays green).");
+    return { exitCode: 0, logs };
+  }
+  const pages = splitConcatenatedJson(fetched.stdout);
+  if (pages === null) {
+    logs.push("verdict gate: unexpected gh output \u2014 skipping (check stays green).");
+    return { exitCode: 0, logs };
+  }
+  const comments = pages.flatMap((page) => Array.isArray(page) ? page : []).filter(
+    (c) => c !== null && typeof c === "object" && typeof c.body === "string" && c.user?.type === "Bot"
+  ).map((c) => ({ body: c.body, id: typeof c.id === "number" ? c.id : void 0 }));
+  const result = runVerdictGate({ comments, maxRounds, locale, roundAfterId, headSha });
+  if (result.kind === "no-review") {
+    logs.push("verdict gate: no review rounds found on this PR \u2014 nothing to judge.");
+    return { exitCode: 0, logs };
+  }
+  const previous = [...comments].reverse().find((c) => c.body.includes(VERDICT_MARKER) && c.id !== void 0);
+  const payload = JSON.stringify({ body: result.commentBody });
+  const updated = previous !== void 0 && exec("gh", ["api", "-X", "PATCH", `repos/${repo}/issues/comments/${previous.id}`, "--input", "-"], payload).status === 0;
+  if (!updated) {
+    const post = exec("gh", ["api", "-X", "POST", `repos/${repo}/issues/${pr}/comments`, "--input", "-"], payload);
+    if (post.status !== 0) logs.push("verdict gate: could not post the verdict comment (continuing).");
+  }
+  if (result.kind === "no-round") {
+    logs.push("verdict gate: this run posted no review round for the current commit \u2014 earlier rounds are not judged again; check stays green.");
+    return { exitCode: 0, logs };
+  }
+  if (result.kind === "unparseable") {
+    logs.push("verdict gate: review output was not machine-readable \u2014 human review requested, check stays green.");
+    return { exitCode: 0, logs };
+  }
+  logs.push(`verdict gate: ${result.verdict}`);
+  return { exitCode: result.exitCode, logs };
+}
+function splitConcatenatedJson(stdout) {
+  const text = stdout.trim();
+  if (text === "") return [];
+  const values = [];
+  let depth = 0;
+  let start = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') inString = true;
+    else if (ch === "[" || ch === "{") depth++;
+    else if (ch === "]" || ch === "}") {
+      depth--;
+      if (depth === 0) {
+        try {
+          values.push(JSON.parse(text.slice(start, i + 1)));
+        } catch {
+          return null;
+        }
+        start = i + 1;
+      }
+    }
+  }
+  if (depth !== 0 || text.slice(start).trim() !== "") return null;
+  return values;
+}
+var invokedAsBin = false;
+try {
+  invokedAsBin = process.argv[1] !== void 0 && realpathSync(process.argv[1]).endsWith("review-verdict.js");
+} catch {
+  invokedAsBin = false;
+}
+if (invokedAsBin) {
+  const { exitCode, logs } = runReviewVerdictBin(process.env, realExec);
+  for (const line of logs) console.log(line);
+  process.exit(exitCode);
+}
+export {
+  runReviewVerdictBin
+};