@clearlydev/nx-archweave 0.0.0-stage → 0.1.0

package/dist/generators/doctor/generator.js

@@ -0,0 +1,2462 @@
+// ../shared/dist/lib/doctor-report.js
+function createDoctorCheck(input) {
+  return { suggestedAction: void 0, ...input };
+}
+function computeOverallStatus(checks) {
+  if (checks.some((c) => c.status === "error"))
+    return "conflict";
+  if (checks.some((c) => c.status === "warning"))
+    return "manual-review-required";
+  return "safe";
+}
+var DOCTOR_REPORT_SCHEMA_ID = "archweave/doctor-report@1";
+function serializeDoctorReport(report) {
+  const count = (status) => report.checks.filter((c) => c.status === status).length;
+  const body = {
+    schema: DOCTOR_REPORT_SCHEMA_ID,
+    overallStatus: report.overallStatus,
+    summary: {
+      pass: count("pass"),
+      warning: count("warning"),
+      error: count("error"),
+      notApplicable: count("not-applicable")
+    },
+    checks: report.checks.map((c) => ({
+      id: c.id,
+      label: c.label,
+      status: c.status,
+      message: c.message,
+      evidence: c.evidence,
+      ...c.suggestedAction !== void 0 ? { suggestedAction: c.suggestedAction } : {}
+    }))
+  };
+  return `${JSON.stringify(body, null, 2)}
+`;
+}
+
+// ../shared/dist/lib/spawnable-command.js
+import { statSync } from "node:fs";
+import { win32 } from "node:path";
+function isFile(path) {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+var DEFAULT_ENV = { platform: process.platform, env: process.env, isFile };
+function envValue(env, name) {
+  const key = Object.keys(env).find((candidate) => candidate.toUpperCase() === name);
+  return key === void 0 ? void 0 : env[key];
+}
+function resolveWindowsCommand(command, environment) {
+  const exts = (envValue(environment.env, "PATHEXT") ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean);
+  const candidates = (base) => win32.extname(base) !== "" ? [base] : exts.map((ext) => base + ext);
+  if (win32.isAbsolute(command) || /[\\/]/.test(command)) {
+    return candidates(command).find(environment.isFile);
+  }
+  const dirs = (envValue(environment.env, "PATH") ?? "").split(";").filter(Boolean);
+  for (const dir of dirs) {
+    const found = candidates(win32.join(dir, command)).find(environment.isFile);
+    if (found !== void 0)
+      return found;
+  }
+  return void 0;
+}
+var META_CHARS = /([()\][%!^"`<>&|;, *?])/g;
+var BIN_SHIM = /node_modules[\\/]\.bin[\\/][^\\/]+\.cmd$/i;
+function escapeCmdArgument(arg, doubleEscape = false) {
+  let quoted = arg.replace(/(\\*)"/g, '$1$1\\"');
+  quoted = quoted.replace(/(\\*)$/, "$1$1");
+  const escaped = `"${quoted}"`.replace(META_CHARS, "^$1");
+  return doubleEscape ? escaped.replace(META_CHARS, "^$1") : escaped;
+}
+function spawnableCommand(command, args, environment = DEFAULT_ENV) {
+  if (environment.platform !== "win32")
+    return { command, args: [...args] };
+  const resolved = resolveWindowsCommand(command, environment);
+  if (resolved === void 0 || !/\.(cmd|bat)$/i.test(resolved))
+    return { command, args: [...args] };
+  const doubleEscape = BIN_SHIM.test(resolved);
+  const line = [resolved.replace(META_CHARS, "^$1"), ...args.map((arg) => escapeCmdArgument(arg, doubleEscape))].join(" ");
+  return {
+    command: envValue(environment.env, "COMSPEC") ?? "cmd.exe",
+    args: ["/d", "/s", "/c", `"${line}"`],
+    windowsVerbatimArguments: true
+  };
+}
+
+// src/generators/doctor/render.ts
+function renderDoctorReport(report) {
+  const lines = [`Overall status: ${report.overallStatus}`, ""];
+  for (const check of report.checks) {
+    lines.push(`[${check.status.toUpperCase()}] ${check.label}: ${check.message}`);
+    if (check.suggestedAction) {
+      lines.push(`  \u2192 ${check.suggestedAction}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// ../template-engine/dist/doctor/detect-environment.js
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// ../template-engine/dist/environment/package-manager.js
+var LOCKFILES = [
+  ["yarn", ["yarn.lock"]],
+  ["bun", ["bun.lock", "bun.lockb"]],
+  ["npm", ["package-lock.json"]]
+];
+function detectWorkspacePackageManager(exists, read = () => void 0) {
+  if (exists("pnpm-lock.yaml") || exists("pnpm-workspace.yaml"))
+    return "pnpm";
+  const found = LOCKFILES.filter(([, files]) => files.some((file) => exists(file))).map(([pm]) => pm);
+  if (found.length <= 1)
+    return found[0] ?? null;
+  const declared = /"packageManager"\s*:\s*"(npm|yarn|bun)@/.exec(read("package.json") ?? "")?.[1];
+  const named = found.find((pm) => pm === declared);
+  if (named)
+    return named;
+  return found.includes("npm") ? "npm" : found[0];
+}
+function packageManagerCommands(pm, flavor = "classic") {
+  switch (pm) {
+    case "pnpm":
+      return { addDevAtRoot: (spec) => `pnpm add -D -w ${spec}`, addAtRoot: (spec) => `pnpm add -w ${spec}`, runNx: "pnpm nx", install: "pnpm install", workspaceRegistration: "pnpm-workspace.yaml" };
+    case "yarn":
+      return {
+        addDevAtRoot: (spec) => flavor === "berry" ? `yarn add -D ${spec}` : `yarn add -D -W ${spec}`,
+        addAtRoot: (spec) => flavor === "berry" ? `yarn add ${spec}` : `yarn add -W ${spec}`,
+        runNx: "yarn nx",
+        install: "yarn install",
+        workspaceRegistration: "package.json workspaces"
+      };
+    case "bun":
+      return { addDevAtRoot: (spec) => `bun add -d ${spec}`, addAtRoot: (spec) => `bun add ${spec}`, runNx: "bun nx", install: "bun install", workspaceRegistration: "package.json workspaces" };
+    case "npm":
+      return { addDevAtRoot: (spec) => `npm install -D ${spec}`, addAtRoot: (spec) => `npm install ${spec}`, runNx: "npm exec nx --", install: "npm install", workspaceRegistration: "package.json workspaces" };
+  }
+}
+
+// ../template-engine/dist/doctor/detect-environment.js
+function detectEnvironment(root) {
+  const hasNxWorkspace = existsSync(join(root, "nx.json"));
+  if (!hasNxWorkspace) {
+    return { hasNxWorkspace: false };
+  }
+  let nxVersion;
+  let rootPackageJson;
+  let rootPackageJsonError;
+  const packageJsonPath = join(root, "package.json");
+  if (existsSync(packageJsonPath)) {
+    try {
+      rootPackageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+      const deps = rootPackageJson?.["devDependencies"];
+      const deps2 = rootPackageJson?.["dependencies"];
+      nxVersion = deps?.["nx"] ?? deps2?.["nx"];
+    } catch (error) {
+      rootPackageJsonError = error instanceof Error ? error.message : String(error);
+    }
+  }
+  const exists = (path) => existsSync(join(root, path));
+  const packageManager = detectWorkspacePackageManager(exists, (path) => exists(path) ? readFileSync(join(root, path), "utf-8") : void 0) ?? void 0;
+  return { hasNxWorkspace, nxVersion, packageManager, rootPackageJson, rootPackageJsonError };
+}
+
+// ../template-engine/dist/doctor/run-doctor-checks.js
+import { existsSync as existsSync6 } from "node:fs";
+import { join as join6 } from "node:path";
+
+// ../template-engine/dist/doctor/review-checks.js
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+
+// ../review-policy/dist/modes/review-modes.js
+var REVIEW_MODES = {
+  fast: {
+    mode: "fast",
+    promptStyle: "fast-condensed",
+    includesCorrectnessSecurity: true,
+    includesOverEngineering: false
+  },
+  standard: {
+    mode: "standard",
+    promptStyle: "sectioned",
+    includesCorrectnessSecurity: true,
+    includesOverEngineering: false
+  },
+  thorough: {
+    mode: "thorough",
+    promptStyle: "sectioned",
+    includesCorrectnessSecurity: true,
+    includesOverEngineering: true
+  }
+};
+
+// ../review-policy/dist/verdict-gate/findings-block.js
+var FINDINGS_MARKER = "<!-- archweave-findings-v1 -->";
+var FINDINGS_SCHEMA_ID = "archweave/findings@1";
+
+// ../review-policy/dist/prompts/prompt-shared.js
+function renderFindingSchemaInstruction(locale, priorities) {
+  const intro = locale === "en" ? "For every finding, fill in every field of this schema:" : "\uBAA8\uB4E0 finding\uC5D0 \uB300\uD574 \uC544\uB798 \uC2A4\uD0A4\uB9C8\uC758 \uBAA8\uB4E0 \uD544\uB4DC\uB97C \uCC44\uC6B0\uC138\uC694:";
+  return [
+    intro,
+    `- priority: ${priorities.join(" | ")}`,
+    "- category: kebab-case category name",
+    "- title: one-line summary",
+    "- file: path of the affected file",
+    "- lineRange: { start, end? }",
+    "- evidence: what in the code proves the problem",
+    "- impact: what goes wrong and for whom",
+    "- reproductionCondition: the exact input/state that triggers it",
+    "- recommendation: the concrete fix",
+    "- confidence: confirmed | plausible"
+  ].join("\n");
+}
+function renderFindingsBlockInstruction(locale) {
+  const lines = locale === "en" ? [
+    "At the END of the top-level summary comment, append the machine-readable findings block:",
+    `the literal marker line ${FINDINGS_MARKER}, then a fenced \`\`\`json block containing`,
+    `{ "schema": "${FINDINGS_SCHEMA_ID}", "findings": [ ... ] } with one entry per finding,`,
+    "using exactly the finding schema above. If there are no findings, still append the block with an empty findings array."
+  ] : [
+    "top-level \uC694\uC57D \uCF54\uBA58\uD2B8\uC758 \uB9E8 \uB05D\uC5D0 \uAE30\uACC4 \uD310\uB3C5\uC6A9 findings \uBE14\uB85D\uC744 \uB367\uBD99\uC774\uC138\uC694:",
+    `\uB9AC\uD130\uB7F4 \uB9C8\uCEE4 \uC904 ${FINDINGS_MARKER} \uB2E4\uC74C\uC5D0 fenced \`\`\`json \uBE14\uB85D\uC73C\uB85C`,
+    `{ "schema": "${FINDINGS_SCHEMA_ID}", "findings": [ ... ] }\uB97C, finding\uB9C8\uB2E4 \uD55C \uC6D0\uC18C\uC529, \uC704 finding \uC2A4\uD0A4\uB9C8 \uADF8\uB300\uB85C \uC791\uC131\uD558\uC138\uC694.`,
+    "finding\uC774 \uC5C6\uC5B4\uB3C4 \uBE48 \uBC30\uC5F4\uB85C \uBE14\uB85D\uC744 \uBC18\uB4DC\uC2DC \uD3EC\uD568\uD558\uC138\uC694."
+  ];
+  return lines.join("\n");
+}
+function renderDedupInstruction(locale) {
+  return locale === "en" ? "If multiple findings share the same root cause, merge them into a single finding instead of reporting duplicates." : "\uAC19\uC740 \uC6D0\uC778\uC5D0\uC11C \uB098\uC628 finding\uC774 \uC5EC\uB7EC \uAC1C\uB77C\uBA74 \uC911\uBCF5 \uBCF4\uACE0\uD558\uC9C0 \uB9D0\uACE0 \uD558\uB098\uC758 finding\uC73C\uB85C \uD569\uCCD0\uC11C \uBCF4\uACE0\uD558\uC138\uC694.";
+}
+
+// ../review-policy/dist/prompts/correctness-security-prompt.js
+var CORRECTNESS_SECURITY_PRIORITIES = ["P0", "P1", "P2", "Nit"];
+var FAST_PRIORITIES = ["P0", "P1", "P2"];
+function buildCorrectnessSecurityPrompt(locale, style = "sectioned") {
+  if (style === "fast-condensed") {
+    const fastBody = locale === "en" ? [
+      "You are a code reviewer focused on correctness and security.",
+      "",
+      "Review the provided diff and report only the most critical problems. Skip minor style and taste remarks entirely \u2014 report nothing below P2.",
+      "",
+      `Only report findings with priority ${FAST_PRIORITIES.join(", ")}. Do NOT report P3 (over-engineering) findings \u2014 they are out of scope here.`
+    ] : [
+      "\uB2F9\uC2E0\uC740 \uC815\uD655\uC131(correctness)\uACFC \uBCF4\uC548(security)\uC5D0 \uC9D1\uC911\uD558\uB294 \uCF54\uB4DC \uB9AC\uBDF0\uC5B4\uC785\uB2C8\uB2E4.",
+      "",
+      "\uC8FC\uC5B4\uC9C4 diff\uC5D0\uC11C \uAC00\uC7A5 \uCE58\uBA85\uC801\uC778 \uBB38\uC81C\uB9CC \uBCF4\uACE0\uD558\uC138\uC694. \uC0AC\uC18C\uD55C \uC2A4\uD0C0\uC77C\xB7\uCDE8\uD5A5 \uC9C0\uC801\uC740 \uC644\uC804\uD788 \uC0DD\uB7B5\uD558\uACE0, P2 \uBBF8\uB9CC\uC740 \uBCF4\uACE0\uD558\uC9C0 \uB9C8\uC138\uC694.",
+      "",
+      `\uC6B0\uC120\uC21C\uC704 ${FAST_PRIORITIES.join(", ")}\uC5D0 \uD574\uB2F9\uD558\uB294 finding\uB9CC \uBCF4\uACE0\uD558\uC138\uC694. P3(\uACFC\uC789 \uC124\uACC4)\uB294 \uBCF4\uACE0\uD558\uC9C0 \uB9C8\uC138\uC694 \u2014 \uC774 \uB9AC\uBDF0\uC758 \uBC94\uC704 \uBC16\uC785\uB2C8\uB2E4.`
+    ];
+    return [...fastBody, "", renderFindingSchemaInstruction(locale, FAST_PRIORITIES), "", renderDedupInstruction(locale)].join("\n");
+  }
+  const body = locale === "en" ? [
+    "You are a code reviewer focused on correctness and security.",
+    "",
+    'Review the provided diff and report findings in two explicitly separated top-level sections: "Correctness" and "Security". Never mix the two.',
+    "",
+    `Only report findings with priority ${CORRECTNESS_SECURITY_PRIORITIES.join(", ")}. Do NOT report P3 (over-engineering) findings \u2014 they are covered by a separate reviewer and are out of scope here.`
+  ] : [
+    "\uB2F9\uC2E0\uC740 \uC815\uD655\uC131(correctness)\uACFC \uBCF4\uC548(security)\uC5D0 \uC9D1\uC911\uD558\uB294 \uCF54\uB4DC \uB9AC\uBDF0\uC5B4\uC785\uB2C8\uB2E4.",
+    "",
+    '\uC8FC\uC5B4\uC9C4 diff\uB97C \uB9AC\uBDF0\uD558\uACE0, finding\uC744 "Correctness"\uC640 "Security" \uB450 \uAC1C\uC758 \uCD5C\uC0C1\uC704 \uC139\uC158\uC73C\uB85C \uBD84\uB9AC\uD574 \uBCF4\uACE0\uD558\uC138\uC694. \uB450 \uC139\uC158\uC744 \uC808\uB300 \uC11E\uC9C0 \uB9C8\uC138\uC694.',
+    "",
+    `\uC6B0\uC120\uC21C\uC704 ${CORRECTNESS_SECURITY_PRIORITIES.join(", ")}\uC5D0 \uD574\uB2F9\uD558\uB294 finding\uB9CC \uBCF4\uACE0\uD558\uC138\uC694. P3\uB294 \uBCF4\uACE0\uD558\uC9C0 \uB9C8\uC138\uC694 \u2014 P3(\uACFC\uC789 \uC124\uACC4)\uB294 \uBCC4\uB3C4\uC758 \uB9AC\uBDF0\uC5B4\uAC00 \uB2F4\uB2F9\uD558\uBBC0\uB85C \uC774 \uB9AC\uBDF0\uC758 \uBC94\uC704 \uBC16\uC785\uB2C8\uB2E4.`
+  ];
+  return [...body, "", renderFindingSchemaInstruction(locale, CORRECTNESS_SECURITY_PRIORITIES), "", renderDedupInstruction(locale)].join("\n");
+}
+
+// ../review-policy/dist/prompts/over-engineering-prompt.js
+var OVER_ENGINEERING_PRIORITIES = ["P3"];
+function buildOverEngineeringPrompt(locale) {
+  const body = locale === "en" ? [
+    "You are a code reviewer focused exclusively on over-engineering.",
+    "",
+    "Review the provided diff and report findings with priority P3 only. Do NOT report P0, P1, P2, or Nit findings \u2014 correctness and security are covered by a separate reviewer.",
+    "",
+    'Report your findings in their own top-level section titled "Over-engineering"; never mix them into correctness or security sections.'
+  ] : [
+    "\uB2F9\uC2E0\uC740 \uACFC\uC789 \uC124\uACC4(over-engineering)\uB9CC\uC744 \uC804\uB2F4\uD558\uB294 \uCF54\uB4DC \uB9AC\uBDF0\uC5B4\uC785\uB2C8\uB2E4.",
+    "",
+    "\uC8FC\uC5B4\uC9C4 diff\uB97C \uB9AC\uBDF0\uD558\uACE0 \uC6B0\uC120\uC21C\uC704 P3\uB9CC \uBCF4\uACE0\uD558\uC138\uC694. P0, P1, P2, Nit\uC740 \uBCF4\uACE0\uD558\uC9C0 \uB9C8\uC138\uC694 \u2014 \uC815\uD655\uC131\uACFC \uBCF4\uC548\uC740 \uBCC4\uB3C4\uC758 \uB9AC\uBDF0\uC5B4\uAC00 \uB2F4\uB2F9\uD569\uB2C8\uB2E4.",
+    "",
+    'finding\uC740 "Over-engineering"\uC774\uB77C\uB294 \uBCC4\uB3C4\uC758 \uCD5C\uC0C1\uC704 \uC139\uC158\uC73C\uB85C \uBCF4\uACE0\uD558\uACE0, correctness/security \uC139\uC158\uACFC \uC808\uB300 \uC11E\uC9C0 \uB9C8\uC138\uC694.'
+  ];
+  return [...body, "", renderFindingSchemaInstruction(locale, OVER_ENGINEERING_PRIORITIES), "", renderDedupInstruction(locale)].join("\n");
+}
+
+// ../review-policy/dist/verdict-gate/verdict-gate.js
+var ROUND_MARKER = "<!-- archweave-review-round -->";
+
+// ../template-engine/dist/review/workflow-skeleton.js
+function indentBlock(text, spaces) {
+  const pad = " ".repeat(spaces);
+  return text.split("\n").map((line) => line.length === 0 ? line : pad + line).join("\n");
+}
+function renderTriggerBlock() {
+  return ["on:", "  pull_request:", "    types: [opened, synchronize, ready_for_review, reopened]"].join("\n");
+}
+function renderConcurrencyBlock() {
+  return [
+    "concurrency:",
+    "  group: archweave-review-${{ github.event.pull_request.number }}",
+    "  cancel-in-progress: false"
+  ].join("\n");
+}
+function renderPermissionsBlock() {
+  return ["permissions:", "  contents: read", "  pull-requests: write", "  id-token: write"].join("\n");
+}
+function renderSecretGateStep(secretName) {
+  return [
+    "- name: Check review secret",
+    "  id: secret-gate",
+    "  env:",
+    `    REVIEW_SECRET: \${{ secrets.${secretName} }}`,
+    "  run: |",
+    '    if [ -z "$REVIEW_SECRET" ]; then',
+    `      echo "AI review is not active: register the ${secretName} secret to enable it."`,
+    '      echo "enabled=false" >> "$GITHUB_OUTPUT"',
+    "    else",
+    '      echo "enabled=true" >> "$GITHUB_OUTPUT"',
+    "    fi"
+  ].join("\n");
+}
+function renderRoundGateStep(maxRounds) {
+  return [
+    "- name: Check review round limit",
+    "  id: round-gate",
+    "  if: steps.secret-gate.outputs.enabled == 'true'",
+    "  env:",
+    "    GH_TOKEN: ${{ github.token }}",
+    "  run: |",
+    `    counts=$(gh api "repos/\${{ github.repository }}/issues/\${{ github.event.pull_request.number }}/comments" --paginate --jq '[([.[] | select(.body | contains("${ROUND_MARKER}"))] | length), ([.[].id] | max // 0)]' | jq -s -r '[(map(.[0]) | add // 0), (map(.[1]) | max // 0)] | @tsv')`,
+    `    rounds=$(printf '%s' "$counts" | cut -f1)`,
+    `    echo "last-comment-id=$(printf '%s' "$counts" | cut -f2)" >> "$GITHUB_OUTPUT"`,
+    `    if [ "$rounds" -ge ${maxRounds} ]; then`,
+    `      echo "Automated review round limit (${maxRounds}) reached for this PR; skipping."`,
+    '      echo "allowed=false" >> "$GITHUB_OUTPUT"',
+    "    else",
+    '      echo "allowed=true" >> "$GITHUB_OUTPUT"',
+    "    fi"
+  ].join("\n");
+}
+function renderVerdictGateStep(maxRounds, locale) {
+  return [
+    "- name: Compute review verdict",
+    "  if: steps.secret-gate.outputs.enabled == 'true' && steps.round-gate.outputs.allowed == 'true'",
+    "  env:",
+    "    GH_TOKEN: ${{ github.token }}",
+    "    GITHUB_REPOSITORY: ${{ github.repository }}",
+    "    ARCHWEAVE_PR_NUMBER: ${{ github.event.pull_request.number }}",
+    `    ARCHWEAVE_MAX_ROUNDS: '${maxRounds}'`,
+    `    ARCHWEAVE_LOCALE: '${locale}'`,
+    "    ARCHWEAVE_HEAD_SHA: ${{ github.event.pull_request.head.sha }}",
+    "    ARCHWEAVE_ROUND_AFTER_ID: ${{ steps.round-gate.outputs.last-comment-id }}",
+    "  run: |",
+    "    if [ -x node_modules/.bin/archweave-review-verdict ]; then",
+    "      node_modules/.bin/archweave-review-verdict",
+    "    else",
+    '      echo "nx-archweave is not installed in this workspace - skipping the verdict gate."',
+    "    fi"
+  ].join("\n");
+}
+var SETUP_NODE_VERSION = "22";
+var SETUP_PNPM_VERSION = "10";
+var SETUP_BUN_ACTION = "oven-sh/setup-bun@v2";
+var INSTALL_LINES = {
+  pnpm: ["    pnpm install --frozen-lockfile"],
+  npm: ["    npm ci"],
+  yarn: [
+    "    corepack enable yarn",
+    '    if [ "$(yarn --version | cut -d. -f1)" -ge 2 ]; then yarn install --immutable; else yarn install --frozen-lockfile; fi'
+  ],
+  bun: ["    bun install --frozen-lockfile"]
+};
+function renderWorkspaceSetupSteps(packageManager) {
+  const gate = "  if: steps.secret-gate.outputs.enabled == 'true' && steps.round-gate.outputs.allowed == 'true'";
+  const steps = [];
+  if (packageManager === "pnpm") {
+    steps.push(["- name: Set up pnpm", gate, "  uses: pnpm/action-setup@v4", "  with:", `    version: ${SETUP_PNPM_VERSION}`].join("\n"));
+  }
+  if (packageManager === "bun") {
+    steps.push(["- name: Set up bun", gate, `  uses: ${SETUP_BUN_ACTION}`].join("\n"));
+  }
+  steps.push([
+    "- name: Set up Node",
+    gate,
+    "  uses: actions/setup-node@v4",
+    "  with:",
+    `    node-version: ${SETUP_NODE_VERSION}`,
+    // yarn: no setup-node cache — it would query the runner's global yarn 1 even in a
+    // berry project. Corepack (shipped with Node) provides the project's own yarn below.
+    // bun: setup-node has no bun cache. Node is still set up — nx and the verdict bin
+    // run on it.
+    ...packageManager === "yarn" || packageManager === "bun" ? [] : [`    cache: ${packageManager}`]
+  ].join("\n"));
+  steps.push([
+    "- name: Install workspace dependencies",
+    gate,
+    "  run: |",
+    ...INSTALL_LINES[packageManager]
+  ].join("\n"));
+  return steps.join("\n\n");
+}
+
+// ../template-engine/dist/review/claude/claude-provider.js
+var SECRET_NAME = "CLAUDE_CODE_OAUTH_TOKEN";
+var ALLOWED_TOOLS = "mcp__github_inline_comment__create_inline_comment,Bash(gh pr comment:*),Bash(gh pr diff:*),Bash(gh pr view:*)";
+function renderWorkflowInstructions(locale) {
+  const lines = locale === "en" ? [
+    "Review the diff of this pull request using `gh pr diff` and `gh pr view`.",
+    "Post specific findings as inline comments and exactly one top-level summary comment.",
+    `Always include the literal marker ${ROUND_MARKER} in the top-level summary comment.`,
+    "If there are no findings that require action, post exactly one top-level comment saying so (and still include the marker).",
+    "Do not modify any code, and never approve or merge the pull request.",
+    "Write summaries and explanations in English; keep file names, function names, and identifiers verbatim."
+  ] : [
+    "\uC774 pull request\uC758 diff\uB97C `gh pr diff`\uC640 `gh pr view`\uB85C \uD655\uC778\uD558\uACE0 \uB9AC\uBDF0\uD558\uC138\uC694.",
+    "\uAD6C\uCCB4\uC801 \uC9C0\uC801\uC740 inline comment\uB85C, \uC804\uCCB4 \uC694\uC57D\uC740 \uC815\uD655\uD788 \uD55C \uAC1C\uC758 top-level comment\uB85C \uAC8C\uC2DC\uD558\uC138\uC694.",
+    `top-level \uC694\uC57D \uCF54\uBA58\uD2B8\uC5D0\uB294 \uBC18\uB4DC\uC2DC \uB9AC\uD130\uB7F4 \uB9C8\uCEE4 ${ROUND_MARKER}\uB97C \uD3EC\uD568\uD558\uC138\uC694.`,
+    '\uC870\uCE58\uAC00 \uD544\uC694\uD55C \uBB38\uC81C\uAC00 \uC5C6\uC73C\uBA74 "\uC870\uCE58\uAC00 \uD544\uC694\uD55C \uBB38\uC81C\uB97C \uCC3E\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4."\uB77C\uB294 top-level comment\uB97C \uC815\uD655\uD788 \uD55C \uAC1C \uAC8C\uC2DC\uD558\uC138\uC694(\uC774\uB54C\uB3C4 \uB9C8\uCEE4\uB294 \uD3EC\uD568).',
+    "\uCF54\uB4DC\uB97C \uC218\uC815\uD558\uC9C0 \uB9C8\uC138\uC694(Do not modify any code). PR\uC744 \uC2B9\uC778\uD558\uAC70\uB098 \uBCD1\uD569\uD558\uC9C0 \uB9C8\uC138\uC694(never approve or merge).",
+    "\uC694\uC57D\uACFC \uC124\uBA85\uC740 \uD55C\uAD6D\uC5B4\uB85C \uC4F0\uB418, \uD30C\uC77C\uBA85\xB7\uD568\uC218\uBA85\xB7\uC2DD\uBCC4\uC790\uB294 \uC6D0\uBB38 \uADF8\uB300\uB85C \uC720\uC9C0\uD558\uC138\uC694."
+  ];
+  return lines.join("\n");
+}
+function composePrompt(input) {
+  const mode = REVIEW_MODES[input.mode];
+  const sections = [renderWorkflowInstructions(input.locale), buildCorrectnessSecurityPrompt(input.locale, mode.promptStyle)];
+  if (mode.includesOverEngineering) {
+    sections.push(buildOverEngineeringPrompt(input.locale));
+  }
+  sections.push(renderFindingsBlockInstruction(input.locale));
+  return sections.join("\n\n---\n\n");
+}
+function buildWorkflowYaml(input) {
+  const steps = [
+    renderSecretGateStep(SECRET_NAME),
+    renderRoundGateStep(input.maxRounds),
+    [
+      "- name: Checkout repository",
+      "  if: steps.secret-gate.outputs.enabled == 'true' && steps.round-gate.outputs.allowed == 'true'",
+      "  uses: actions/checkout@v4",
+      "  with:",
+      "    fetch-depth: 1"
+    ].join("\n"),
+    [
+      "- name: Run Claude review",
+      "  if: steps.secret-gate.outputs.enabled == 'true' && steps.round-gate.outputs.allowed == 'true'",
+      "  uses: anthropics/claude-code-action@v1",
+      "  with:",
+      `    claude_code_oauth_token: \${{ secrets.${SECRET_NAME} }}`,
+      "    prompt: |",
+      indentBlock(composePrompt(input), 6),
+      "    claude_args: |",
+      `      --allowedTools "${ALLOWED_TOOLS}"`
+    ].join("\n"),
+    renderWorkspaceSetupSteps(input.packageManager),
+    renderVerdictGateStep(input.maxRounds, input.locale)
+  ];
+  return [
+    "name: Claude Code Review",
+    "",
+    renderTriggerBlock(),
+    "",
+    renderConcurrencyBlock(),
+    "",
+    renderPermissionsBlock(),
+    "",
+    "jobs:",
+    "  review:",
+    "    runs-on: ubuntu-latest",
+    "    steps:",
+    indentBlock(steps.join("\n\n"), 6),
+    ""
+  ].join("\n");
+}
+var claudeProvider = {
+  id: "claude",
+  workflowFileName: ".github/workflows/claude-code-review.yml",
+  requiredSecretName: SECRET_NAME,
+  buildWorkflowYaml
+};
+
+// ../template-engine/dist/review/cursor/cursor-provider.js
+var SECRET_NAME2 = "CURSOR_API_KEY";
+var PROMPT_HEREDOC_DELIMITER = "ARCHWEAVE_CURSOR_REVIEW_PROMPT";
+function renderWorkflowInstructions2(locale) {
+  const lines = locale === "en" ? [
+    "Review the diff of this pull request using `gh pr diff` and `gh pr view`.",
+    "Post specific findings as inline comments and exactly one top-level summary comment.",
+    `Always include the literal marker ${ROUND_MARKER} in the top-level summary comment.`,
+    "If there are no findings that require action, post exactly one top-level comment saying so (and still include the marker).",
+    "Do not modify any code, and never approve or merge the pull request.",
+    "Write summaries and explanations in English; keep file names, function names, and identifiers verbatim."
+  ] : [
+    "\uC774 pull request\uC758 diff\uB97C `gh pr diff`\uC640 `gh pr view`\uB85C \uD655\uC778\uD558\uACE0 \uB9AC\uBDF0\uD558\uC138\uC694.",
+    "\uAD6C\uCCB4\uC801 \uC9C0\uC801\uC740 inline comment\uB85C, \uC804\uCCB4 \uC694\uC57D\uC740 \uC815\uD655\uD788 \uD55C \uAC1C\uC758 top-level comment\uB85C \uAC8C\uC2DC\uD558\uC138\uC694.",
+    `top-level \uC694\uC57D \uCF54\uBA58\uD2B8\uC5D0\uB294 \uBC18\uB4DC\uC2DC \uB9AC\uD130\uB7F4 \uB9C8\uCEE4 ${ROUND_MARKER}\uB97C \uD3EC\uD568\uD558\uC138\uC694.`,
+    '\uC870\uCE58\uAC00 \uD544\uC694\uD55C \uBB38\uC81C\uAC00 \uC5C6\uC73C\uBA74 "\uC870\uCE58\uAC00 \uD544\uC694\uD55C \uBB38\uC81C\uB97C \uCC3E\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4."\uB77C\uB294 top-level comment\uB97C \uC815\uD655\uD788 \uD55C \uAC1C \uAC8C\uC2DC\uD558\uC138\uC694(\uC774\uB54C\uB3C4 \uB9C8\uCEE4\uB294 \uD3EC\uD568).',
+    "\uCF54\uB4DC\uB97C \uC218\uC815\uD558\uC9C0 \uB9C8\uC138\uC694(Do not modify any code). PR\uC744 \uC2B9\uC778\uD558\uAC70\uB098 \uBCD1\uD569\uD558\uC9C0 \uB9C8\uC138\uC694(never approve or merge).",
+    "\uC694\uC57D\uACFC \uC124\uBA85\uC740 \uD55C\uAD6D\uC5B4\uB85C \uC4F0\uB418, \uD30C\uC77C\uBA85\xB7\uD568\uC218\uBA85\xB7\uC2DD\uBCC4\uC790\uB294 \uC6D0\uBB38 \uADF8\uB300\uB85C \uC720\uC9C0\uD558\uC138\uC694."
+  ];
+  return lines.join("\n");
+}
+function composePrompt2(input) {
+  const mode = REVIEW_MODES[input.mode];
+  const sections = [renderWorkflowInstructions2(input.locale), buildCorrectnessSecurityPrompt(input.locale, mode.promptStyle)];
+  if (mode.includesOverEngineering) {
+    sections.push(buildOverEngineeringPrompt(input.locale));
+  }
+  sections.push(renderFindingsBlockInstruction(input.locale));
+  return sections.join("\n\n---\n\n");
+}
+function buildWorkflowYaml2(input) {
+  const gateCondition = "steps.secret-gate.outputs.enabled == 'true' && steps.round-gate.outputs.allowed == 'true'";
+  const steps = [
+    renderSecretGateStep(SECRET_NAME2),
+    renderRoundGateStep(input.maxRounds),
+    [
+      "- name: Checkout repository",
+      `  if: ${gateCondition}`,
+      "  uses: actions/checkout@v4",
+      "  with:",
+      "    fetch-depth: 1"
+    ].join("\n"),
+    [
+      "- name: Install cursor-agent CLI",
+      `  if: ${gateCondition}`,
+      "  run: |",
+      "    curl https://cursor.com/install -fsS | bash",
+      '    echo "$HOME/.cursor/bin" >> "$GITHUB_PATH"'
+    ].join("\n"),
+    [
+      "- name: Run Cursor review",
+      `  if: ${gateCondition}`,
+      "  env:",
+      `    CURSOR_API_KEY: \${{ secrets.${SECRET_NAME2} }}`,
+      "    GH_TOKEN: ${{ github.token }}",
+      "  run: |",
+      `    agent -p "$(cat <<'${PROMPT_HEREDOC_DELIMITER}'`,
+      indentBlock(composePrompt2(input), 4),
+      `    ${PROMPT_HEREDOC_DELIMITER}`,
+      '    )"'
+    ].join("\n"),
+    renderWorkspaceSetupSteps(input.packageManager),
+    renderVerdictGateStep(input.maxRounds, input.locale)
+  ];
+  return [
+    "name: Cursor Code Review",
+    "",
+    renderTriggerBlock(),
+    "",
+    renderConcurrencyBlock(),
+    "",
+    renderPermissionsBlock(),
+    "",
+    "jobs:",
+    "  review:",
+    "    runs-on: ubuntu-latest",
+    "    steps:",
+    indentBlock(steps.join("\n\n"), 6),
+    ""
+  ].join("\n");
+}
+var cursorProvider = {
+  id: "cursor",
+  workflowFileName: ".github/workflows/cursor-code-review.yml",
+  requiredSecretName: SECRET_NAME2,
+  buildWorkflowYaml: buildWorkflowYaml2
+};
+
+// ../template-engine/dist/review/gemini/gemini-provider.js
+var SECRET_NAME3 = "GEMINI_API_KEY";
+function renderWorkflowInstructions3(locale) {
+  const lines = locale === "en" ? [
+    "Review the diff of this pull request using `gh pr diff` and `gh pr view`.",
+    "Post specific findings as inline comments and exactly one top-level summary comment.",
+    `Always include the literal marker ${ROUND_MARKER} in the top-level summary comment.`,
+    "If there are no findings that require action, post exactly one top-level comment saying so (and still include the marker).",
+    "Do not modify any code, and never approve or merge the pull request.",
+    "Write summaries and explanations in English; keep file names, function names, and identifiers verbatim."
+  ] : [
+    "\uC774 pull request\uC758 diff\uB97C `gh pr diff`\uC640 `gh pr view`\uB85C \uD655\uC778\uD558\uACE0 \uB9AC\uBDF0\uD558\uC138\uC694.",
+    "\uAD6C\uCCB4\uC801 \uC9C0\uC801\uC740 inline comment\uB85C, \uC804\uCCB4 \uC694\uC57D\uC740 \uC815\uD655\uD788 \uD55C \uAC1C\uC758 top-level comment\uB85C \uAC8C\uC2DC\uD558\uC138\uC694.",
+    `top-level \uC694\uC57D \uCF54\uBA58\uD2B8\uC5D0\uB294 \uBC18\uB4DC\uC2DC \uB9AC\uD130\uB7F4 \uB9C8\uCEE4 ${ROUND_MARKER}\uB97C \uD3EC\uD568\uD558\uC138\uC694.`,
+    '\uC870\uCE58\uAC00 \uD544\uC694\uD55C \uBB38\uC81C\uAC00 \uC5C6\uC73C\uBA74 "\uC870\uCE58\uAC00 \uD544\uC694\uD55C \uBB38\uC81C\uB97C \uCC3E\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4."\uB77C\uB294 top-level comment\uB97C \uC815\uD655\uD788 \uD55C \uAC1C \uAC8C\uC2DC\uD558\uC138\uC694(\uC774\uB54C\uB3C4 \uB9C8\uCEE4\uB294 \uD3EC\uD568).',
+    "\uCF54\uB4DC\uB97C \uC218\uC815\uD558\uC9C0 \uB9C8\uC138\uC694(Do not modify any code). PR\uC744 \uC2B9\uC778\uD558\uAC70\uB098 \uBCD1\uD569\uD558\uC9C0 \uB9C8\uC138\uC694(never approve or merge).",
+    "\uC694\uC57D\uACFC \uC124\uBA85\uC740 \uD55C\uAD6D\uC5B4\uB85C \uC4F0\uB418, \uD30C\uC77C\uBA85\xB7\uD568\uC218\uBA85\xB7\uC2DD\uBCC4\uC790\uB294 \uC6D0\uBB38 \uADF8\uB300\uB85C \uC720\uC9C0\uD558\uC138\uC694."
+  ];
+  return lines.join("\n");
+}
+function composePrompt3(input) {
+  const mode = REVIEW_MODES[input.mode];
+  const sections = [renderWorkflowInstructions3(input.locale), buildCorrectnessSecurityPrompt(input.locale, mode.promptStyle)];
+  if (mode.includesOverEngineering) {
+    sections.push(buildOverEngineeringPrompt(input.locale));
+  }
+  sections.push(renderFindingsBlockInstruction(input.locale));
+  return sections.join("\n\n---\n\n");
+}
+function buildWorkflowYaml3(input) {
+  const steps = [
+    renderSecretGateStep(SECRET_NAME3),
+    renderRoundGateStep(input.maxRounds),
+    [
+      "- name: Checkout repository",
+      "  if: steps.secret-gate.outputs.enabled == 'true' && steps.round-gate.outputs.allowed == 'true'",
+      "  uses: actions/checkout@v4",
+      "  with:",
+      "    fetch-depth: 1"
+    ].join("\n"),
+    [
+      "- name: Run Gemini review",
+      "  if: steps.secret-gate.outputs.enabled == 'true' && steps.round-gate.outputs.allowed == 'true'",
+      "  uses: google-github-actions/run-gemini-cli@v0",
+      "  env:",
+      "    GITHUB_TOKEN: ${{ github.token }}",
+      "  with:",
+      `    gemini_api_key: \${{ secrets.${SECRET_NAME3} }}`,
+      "    prompt: |",
+      indentBlock(composePrompt3(input), 6)
+    ].join("\n"),
+    renderWorkspaceSetupSteps(input.packageManager),
+    renderVerdictGateStep(input.maxRounds, input.locale)
+  ];
+  return [
+    "name: Gemini Code Review",
+    "",
+    renderTriggerBlock(),
+    "",
+    renderConcurrencyBlock(),
+    "",
+    renderPermissionsBlock(),
+    "",
+    "jobs:",
+    "  review:",
+    "    runs-on: ubuntu-latest",
+    "    steps:",
+    indentBlock(steps.join("\n\n"), 6),
+    ""
+  ].join("\n");
+}
+var geminiProvider = {
+  id: "gemini",
+  workflowFileName: ".github/workflows/gemini-code-review.yml",
+  requiredSecretName: SECRET_NAME3,
+  buildWorkflowYaml: buildWorkflowYaml3
+};
+
+// ../template-engine/dist/review/gpt/gpt-provider.js
+var SECRET_NAME4 = "OPENAI_API_KEY";
+function renderWorkflowInstructions4(locale) {
+  const lines = locale === "en" ? [
+    "Review ONLY the changes introduced by this pull request. The base and head commits are already fetched under fixed ref names: run `git diff origin/pr-base...origin/pr-head` (and `git log origin/pr-base..origin/pr-head` for commit context) \u2014 this sandboxed step has no network access, so do not attempt to run `gh` or reach the GitHub API.",
+    "Write your entire response as a single message: report specific findings, then close with one overall summary.",
+    `Always include the literal marker ${ROUND_MARKER} in your message.`,
+    "If there are no findings that require action, write exactly one message saying so (and still include the marker).",
+    "Do not modify any code, and never approve or merge the pull request.",
+    "Write summaries and explanations in English; keep file names, function names, and identifiers verbatim."
+  ] : [
+    "\uC774 pull request\uAC00 \uB3C4\uC785\uD55C \uBCC0\uACBD \uC0AC\uD56D\uB9CC \uB9AC\uBDF0\uD558\uC138\uC694. base/head \uCEE4\uBC0B\uC740 \uACE0\uC815 ref \uC774\uB984\uC73C\uB85C \uC774\uBBF8 fetch\uB418\uC5B4 \uC788\uC2B5\uB2C8\uB2E4: `git diff origin/pr-base...origin/pr-head`\uB85C \uBE44\uAD50\uD558\uACE0, \uCEE4\uBC0B \uB9E5\uB77D\uC740 `git log origin/pr-base..origin/pr-head`\uB85C \uD655\uC778\uD558\uC138\uC694(\uC774 \uC0CC\uB4DC\uBC15\uC2A4 \uC2A4\uD15D\uC740 \uB124\uD2B8\uC6CC\uD06C\uAC00 \uC5C6\uC73C\uBBC0\uB85C `gh`\uB098 GitHub API\uB97C \uD638\uCD9C\uD558\uC9C0 \uB9C8\uC138\uC694).",
+    "\uC804\uCCB4 \uC751\uB2F5\uC744 \uD558\uB098\uC758 \uBA54\uC2DC\uC9C0\uB85C \uC791\uC131\uD558\uC138\uC694: \uAD6C\uCCB4\uC801 \uC9C0\uC801\uC744 \uC801\uC740 \uB4A4 \uB9C8\uC9C0\uB9C9\uC5D0 \uC804\uCCB4 \uC694\uC57D\uC744 \uD55C \uBC88 \uB354 \uB0A8\uAE30\uC138\uC694.",
+    `\uBA54\uC2DC\uC9C0\uC5D0\uB294 \uBC18\uB4DC\uC2DC \uB9AC\uD130\uB7F4 \uB9C8\uCEE4 ${ROUND_MARKER}\uB97C \uD3EC\uD568\uD558\uC138\uC694.`,
+    '\uC870\uCE58\uAC00 \uD544\uC694\uD55C \uBB38\uC81C\uAC00 \uC5C6\uC73C\uBA74 "\uC870\uCE58\uAC00 \uD544\uC694\uD55C \uBB38\uC81C\uB97C \uCC3E\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4."\uB77C\uB294 \uBA54\uC2DC\uC9C0\uB97C \uC815\uD655\uD788 \uD55C \uAC1C \uC791\uC131\uD558\uC138\uC694(\uC774\uB54C\uB3C4 \uB9C8\uCEE4\uB294 \uD3EC\uD568).',
+    "\uCF54\uB4DC\uB97C \uC218\uC815\uD558\uC9C0 \uB9C8\uC138\uC694(Do not modify any code). PR\uC744 \uC2B9\uC778\uD558\uAC70\uB098 \uBCD1\uD569\uD558\uC9C0 \uB9C8\uC138\uC694(never approve or merge).",
+    "\uC694\uC57D\uACFC \uC124\uBA85\uC740 \uD55C\uAD6D\uC5B4\uB85C \uC4F0\uB418, \uD30C\uC77C\uBA85\xB7\uD568\uC218\uBA85\xB7\uC2DD\uBCC4\uC790\uB294 \uC6D0\uBB38 \uADF8\uB300\uB85C \uC720\uC9C0\uD558\uC138\uC694."
+  ];
+  return lines.join("\n");
+}
+function composePrompt4(input) {
+  const mode = REVIEW_MODES[input.mode];
+  const sections = [renderWorkflowInstructions4(input.locale), buildCorrectnessSecurityPrompt(input.locale, mode.promptStyle)];
+  if (mode.includesOverEngineering) {
+    sections.push(buildOverEngineeringPrompt(input.locale));
+  }
+  sections.push(renderFindingsBlockInstruction(input.locale));
+  return sections.join("\n\n---\n\n");
+}
+function buildWorkflowYaml4(input) {
+  const gateCondition = "steps.secret-gate.outputs.enabled == 'true' && steps.round-gate.outputs.allowed == 'true'";
+  const steps = [
+    renderSecretGateStep(SECRET_NAME4),
+    renderRoundGateStep(input.maxRounds),
+    [
+      "- name: Checkout repository",
+      `  if: ${gateCondition}`,
+      "  uses: actions/checkout@v4",
+      "  with:",
+      "    ref: refs/pull/${{ github.event.pull_request.number }}/merge",
+      "    fetch-depth: 1",
+      "    persist-credentials: false"
+    ].join("\n"),
+    [
+      "- name: Fetch base and head refs for the PR",
+      `  if: ${gateCondition}`,
+      "  env:",
+      "    PR_BASE_REF: ${{ github.event.pull_request.base.ref }}",
+      "    PR_NUMBER: ${{ github.event.pull_request.number }}",
+      "  run: |",
+      "    # Explicit destinations: the sandboxed review step has no network, so both sides",
+      "    # of the diff must survive as stable local refs (FETCH_HEAD alone is ambiguous).",
+      "    git fetch --no-tags origin \\",
+      '      "+refs/heads/$PR_BASE_REF:refs/remotes/origin/pr-base" \\',
+      '      "+refs/pull/$PR_NUMBER/head:refs/remotes/origin/pr-head"'
+    ].join("\n"),
+    [
+      "- name: Run Codex review",
+      "  id: codex-review",
+      `  if: ${gateCondition}`,
+      "  uses: openai/codex-action@v1",
+      "  with:",
+      `    openai-api-key: \${{ secrets.${SECRET_NAME4} }}`,
+      '    permission-profile: ":read-only"',
+      "    prompt: |",
+      indentBlock(composePrompt4(input), 6)
+    ].join("\n"),
+    [
+      "- name: Post review comment",
+      `  if: ${gateCondition}`,
+      "  env:",
+      "    GH_TOKEN: ${{ github.token }}",
+      "    PR_NUMBER: ${{ github.event.pull_request.number }}",
+      "    REVIEW_BODY: ${{ steps.codex-review.outputs.final-message }}",
+      "  run: |",
+      '    printf %s "$REVIEW_BODY" | gh pr comment "$PR_NUMBER" --body-file -'
+    ].join("\n"),
+    renderWorkspaceSetupSteps(input.packageManager),
+    renderVerdictGateStep(input.maxRounds, input.locale)
+  ];
+  return [
+    "name: GPT Code Review",
+    "",
+    renderTriggerBlock(),
+    "",
+    renderConcurrencyBlock(),
+    "",
+    renderPermissionsBlock(),
+    "",
+    "jobs:",
+    "  review:",
+    "    runs-on: ubuntu-latest",
+    "    steps:",
+    indentBlock(steps.join("\n\n"), 6),
+    ""
+  ].join("\n");
+}
+var gptProvider = {
+  id: "gpt",
+  workflowFileName: ".github/workflows/gpt-code-review.yml",
+  requiredSecretName: SECRET_NAME4,
+  buildWorkflowYaml: buildWorkflowYaml4
+};
+
+// ../template-engine/dist/review/provider.js
+var REVIEW_PROVIDERS = {
+  claude: claudeProvider,
+  gemini: geminiProvider,
+  gpt: gptProvider,
+  cursor: cursorProvider
+};
+
+// ../template-engine/dist/review/conflict.js
+function judgeReviewFileConflict(existing, generated) {
+  if (existing === null)
+    return { kind: "create" };
+  if (existing === generated)
+    return { kind: "unchanged" };
+  return { kind: "merge-proposal", existing, generated };
+}
+
+// ../template-engine/dist/doctor/review-checks.js
+var CONFIG_PATH = "toolkit.config.json";
+var DEFAULT_PROVIDER_ID = "claude";
+function deriveAltWorkflowPath(mainWorkflowPath) {
+  return mainWorkflowPath.replace(/\.yml$/, ".archweave.yml");
+}
+function resolveProviderId(config) {
+  if (config.parseError || typeof config.review !== "object" || config.review === null) {
+    return DEFAULT_PROVIDER_ID;
+  }
+  const provider = config.review["provider"];
+  if (typeof provider === "string" && provider in REVIEW_PROVIDERS) {
+    return provider;
+  }
+  return DEFAULT_PROVIDER_ID;
+}
+var REVIEW_MODE_IDS = Object.keys(REVIEW_MODES);
+var REVIEW_LOCALES = ["ko", "en"];
+var REVIEW_MAX_ROUNDS = [1, 2, 3, 4, 5];
+function readToolkitConfigState(root) {
+  const path = join2(root, CONFIG_PATH);
+  if (!existsSync2(path))
+    return { parseError: false, review: void 0 };
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return { parseError: true, review: void 0 };
+    }
+    return { parseError: false, review: parsed["review"] };
+  } catch {
+    return { parseError: true, review: void 0 };
+  }
+}
+function isReviewEnabledTrue(review) {
+  return typeof review === "object" && review !== null && review["enabled"] === true;
+}
+function validateReviewConfig(review) {
+  if (typeof review !== "object" || review === null)
+    return null;
+  const r = review;
+  const { provider, mode, locale, maxRounds } = r;
+  if (typeof provider !== "string" || !(provider in REVIEW_PROVIDERS))
+    return null;
+  if (typeof mode !== "string" || !REVIEW_MODE_IDS.includes(mode))
+    return null;
+  if (typeof locale !== "string" || !REVIEW_LOCALES.includes(locale))
+    return null;
+  if (typeof maxRounds !== "number" || !REVIEW_MAX_ROUNDS.includes(maxRounds))
+    return null;
+  return {
+    provider,
+    mode,
+    locale,
+    maxRounds
+  };
+}
+var REVIEW_CHECK_IDS = [
+  "review-workflow-present",
+  "review-alt-file-coexistence",
+  "review-config-consistency"
+];
+function buildReviewChecks(root) {
+  const config = readToolkitConfigState(root);
+  const mainWorkflowPath = REVIEW_PROVIDERS[resolveProviderId(config)].workflowFileName;
+  const altWorkflowPath = deriveAltWorkflowPath(mainWorkflowPath);
+  const mainExists = existsSync2(join2(root, mainWorkflowPath));
+  const altExists = existsSync2(join2(root, altWorkflowPath));
+  return [
+    buildReviewWorkflowPresentCheck(mainWorkflowPath, mainExists, config),
+    buildReviewAltFileCoexistenceCheck(mainWorkflowPath, altWorkflowPath, mainExists, altExists),
+    buildReviewConfigConsistencyCheck(root, mainWorkflowPath, mainExists, config)
+  ];
+}
+function buildReviewWorkflowPresentCheck(mainWorkflowPath, mainExists, config) {
+  if (mainExists) {
+    return createDoctorCheck({
+      id: "review-workflow-present",
+      label: "Review workflow installed",
+      status: "pass",
+      message: `${mainWorkflowPath} found`,
+      evidence: [mainWorkflowPath]
+    });
+  }
+  const claimsEnabled = !config.parseError && isReviewEnabledTrue(config.review);
+  if (claimsEnabled) {
+    return createDoctorCheck({
+      id: "review-workflow-present",
+      label: "Review workflow installed",
+      status: "warning",
+      message: `${CONFIG_PATH} declares review.enabled: true, but ${mainWorkflowPath} was not found`,
+      evidence: [CONFIG_PATH],
+      suggestedAction: `Run the add-review generator to install ${mainWorkflowPath}, or remove the review.enabled claim from ${CONFIG_PATH} if review is no longer intended.`
+    });
+  }
+  return createDoctorCheck({
+    id: "review-workflow-present",
+    label: "Review workflow installed",
+    status: "not-applicable",
+    message: `${mainWorkflowPath} not found \u2014 review is not installed`,
+    evidence: []
+  });
+}
+function buildReviewAltFileCoexistenceCheck(mainWorkflowPath, altWorkflowPath, mainExists, altExists) {
+  if (!altExists) {
+    return createDoctorCheck({
+      id: "review-alt-file-coexistence",
+      label: "Review alternate workflow file",
+      status: "not-applicable",
+      message: `${altWorkflowPath} not found`,
+      evidence: []
+    });
+  }
+  if (mainExists) {
+    return createDoctorCheck({
+      id: "review-alt-file-coexistence",
+      label: "Review alternate workflow file",
+      status: "warning",
+      message: `Both ${mainWorkflowPath} and ${altWorkflowPath} exist`,
+      evidence: [mainWorkflowPath, altWorkflowPath],
+      suggestedAction: `Review ${altWorkflowPath} and, if it reflects the options you want, manually swap it in for ${mainWorkflowPath} \u2014 then delete the alternate file. Do not let both run side by side.`
+    });
+  }
+  return createDoctorCheck({
+    id: "review-alt-file-coexistence",
+    label: "Review alternate workflow file",
+    status: "warning",
+    message: `${altWorkflowPath} exists without ${mainWorkflowPath} \u2014 orphaned alternate file`,
+    evidence: [altWorkflowPath],
+    suggestedAction: `Review ${altWorkflowPath} and either rename it to ${mainWorkflowPath} to use it, or delete it.`
+  });
+}
+function buildReviewConfigConsistencyCheck(root, mainWorkflowPath, mainExists, config) {
+  if (!mainExists) {
+    return createDoctorCheck({
+      id: "review-config-consistency",
+      label: "Review config/workflow consistency",
+      status: "not-applicable",
+      message: `${mainWorkflowPath} not found \u2014 nothing to compare against ${CONFIG_PATH}`,
+      evidence: []
+    });
+  }
+  if (config.parseError) {
+    return createDoctorCheck({
+      id: "review-config-consistency",
+      label: "Review config/workflow consistency",
+      status: "error",
+      message: `${CONFIG_PATH} could not be parsed \u2014 cannot verify it matches ${mainWorkflowPath}`,
+      evidence: [CONFIG_PATH],
+      suggestedAction: `Fix the JSON syntax in ${CONFIG_PATH} before running add-review, then re-run doctor.`
+    });
+  }
+  if (config.review === void 0) {
+    return createDoctorCheck({
+      id: "review-config-consistency",
+      label: "Review config/workflow consistency",
+      status: "not-applicable",
+      message: `${CONFIG_PATH} has no review field \u2014 nothing to compare against ${mainWorkflowPath}`,
+      evidence: []
+    });
+  }
+  const validated = validateReviewConfig(config.review);
+  if (validated === null) {
+    return createDoctorCheck({
+      id: "review-config-consistency",
+      label: "Review config/workflow consistency",
+      status: "warning",
+      message: `${CONFIG_PATH}'s review field has an unrecognized shape \u2014 cannot verify it matches ${mainWorkflowPath}`,
+      evidence: [CONFIG_PATH],
+      suggestedAction: `Fix the review field (provider/mode/locale/maxRounds) in ${CONFIG_PATH} and re-run doctor.`
+    });
+  }
+  const workflowContent = readFileSync2(join2(root, mainWorkflowPath), "utf8");
+  const generated = REVIEW_PROVIDERS[validated.provider].buildWorkflowYaml({
+    ...validated,
+    // The expected workflow is rendered for the DETECTED
+    // package manager — detection is the truth, config drift is its own check.
+    packageManager: detectWorkspacePackageManager((p) => existsSync2(join2(root, p)), (p) => existsSync2(join2(root, p)) ? readFileSync2(join2(root, p), "utf-8") : void 0) ?? "pnpm"
+  });
+  const verdict = judgeReviewFileConflict(workflowContent, generated);
+  if (verdict.kind === "unchanged") {
+    return createDoctorCheck({
+      id: "review-config-consistency",
+      label: "Review config/workflow consistency",
+      status: "pass",
+      message: `${mainWorkflowPath} matches ${CONFIG_PATH}'s review options`,
+      evidence: [mainWorkflowPath, CONFIG_PATH]
+    });
+  }
+  return createDoctorCheck({
+    id: "review-config-consistency",
+    label: "Review config/workflow consistency",
+    status: "warning",
+    message: `${mainWorkflowPath} differs from what ${CONFIG_PATH}'s review options would generate`,
+    evidence: [mainWorkflowPath, CONFIG_PATH],
+    suggestedAction: `Re-run the add-review generator with --onConflict=overwrite to re-sync ${mainWorkflowPath} with ${CONFIG_PATH}, or update ${CONFIG_PATH} to match the installed file.`
+  });
+}
+
+// ../template-engine/dist/doctor/backend-checks.js
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3 } from "node:fs";
+import { join as join3 } from "node:path";
+
+// ../template-engine/dist/backend/eslint-boundaries.js
+var ESLINT_CONFIG_CANDIDATES = ["eslint.config.mjs", "eslint.config.js", "eslint.config.cjs"];
+var APPLIED_MARKER = "sourceTag: 'scope:frontend'";
+var ALLOW_ALL_BLOCK = /depConstraints:\s*\[\s*\{\s*sourceTag:\s*'\*',\s*onlyDependOnLibsWithTags:\s*\[\s*'\*'\s*\],?\s*\},?\s*\]/g;
+function maskComments(text) {
+  const out = text.split("");
+  let mode = "code";
+  let quote = "";
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    const d = text[i + 1];
+    if (mode === "code") {
+      if (c === "'" || c === '"' || c === "`") {
+        mode = "string";
+        quote = c;
+      } else if (c === "/" && d === "/") {
+        mode = "line";
+        out[i] = " ";
+      } else if (c === "/" && d === "*") {
+        mode = "block";
+        out[i] = " ";
+      }
+    } else if (mode === "string") {
+      if (c === "\\") {
+        i++;
+      } else if (c === quote) {
+        mode = "code";
+      }
+    } else if (mode === "line") {
+      if (c === "\n") {
+        mode = "code";
+      } else {
+        out[i] = " ";
+      }
+    } else {
+      if (c === "*" && d === "/") {
+        out[i] = " ";
+        out[i + 1] = " ";
+        i++;
+        mode = "code";
+      } else if (c !== "\n") {
+        out[i] = " ";
+      }
+    }
+  }
+  return out.join("");
+}
+function findAllowAllMatches(masked) {
+  const matches = [];
+  ALLOW_ALL_BLOCK.lastIndex = 0;
+  for (let m = ALLOW_ALL_BLOCK.exec(masked); m !== null; m = ALLOW_ALL_BLOCK.exec(masked)) {
+    matches.push({ index: m.index, length: m[0].length });
+  }
+  return matches;
+}
+function classifyBoundaryConstraints(configText) {
+  const masked = maskComments(configText);
+  if (masked.includes(APPLIED_MARKER))
+    return "enforced";
+  if (findAllowAllMatches(masked).length > 0)
+    return "allow-all";
+  return "unknown";
+}
+
+// ../template-engine/dist/doctor/backend-checks.js
+var CONFIG_PATH2 = "toolkit.config.json";
+var SHARED_TYPES_PACKAGE = "libs/shared-types/package.json";
+var SHARED_TYPES_LEGACY = "libs/shared-types/project.json";
+var BACKEND_CHECK_IDS = [
+  "backend-framework",
+  "backend-config-consistency",
+  "shared-types-lib",
+  "boundary-constraints-applied",
+  "boundary-tags-exist"
+];
+var CHECK_LABELS = {
+  "backend-framework": "Backend framework (root package.json only)",
+  "backend-config-consistency": "Backend config consistency",
+  "shared-types-lib": "shared-types library",
+  "boundary-constraints-applied": "Module-boundary constraints",
+  "boundary-tags-exist": "Boundary tags exist"
+};
+function collectScopeTags(root) {
+  const tags = /* @__PURE__ */ new Set();
+  const dirsIn = (rel) => {
+    try {
+      return readdirSync(join3(root, rel), { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => `${rel}/${entry.name}`);
+    } catch {
+      return [];
+    }
+  };
+  const apps = dirsIn("apps");
+  const libs = dirsIn("libs");
+  const packages = dirsIn("packages");
+  const roots = [
+    ...apps,
+    ...apps.flatMap((p) => dirsIn(p)),
+    ...libs,
+    ...libs.flatMap((p) => dirsIn(p)),
+    ...packages,
+    ...packages.flatMap((p) => dirsIn(p))
+  ];
+  for (const projectRoot of roots) {
+    for (const [file, path] of [
+      ["project.json", ["tags"]],
+      ["package.json", ["nx", "tags"]]
+    ]) {
+      try {
+        let node = JSON.parse(readFileSync3(join3(root, projectRoot, file), "utf-8"));
+        for (const key of path)
+          node = node?.[key];
+        if (Array.isArray(node)) {
+          for (const tag of node)
+            if (typeof tag === "string")
+              tags.add(tag);
+        }
+      } catch {
+      }
+    }
+  }
+  return tags;
+}
+function notApplicable(message) {
+  return BACKEND_CHECK_IDS.map((id) => createDoctorCheck({ id, label: CHECK_LABELS[id], status: "not-applicable", message, evidence: [] }));
+}
+function readsBackendOnly(root) {
+  try {
+    return JSON.parse(readFileSync3(join3(root, CONFIG_PATH2), "utf-8")).frontend === "none";
+  } catch {
+    return false;
+  }
+}
+function readConfiguredBackend(root) {
+  const configPath = join3(root, CONFIG_PATH2);
+  if (!existsSync3(configPath))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync3(configPath, "utf-8"));
+    const backend = parsed.backend;
+    if (backend === void 0 || backend === "none")
+      return null;
+    if (backend === "express" || backend === "nest")
+      return backend;
+    return "invalid";
+  } catch {
+    return null;
+  }
+}
+function buildBackendChecks(root) {
+  const backend = readConfiguredBackend(root);
+  if (backend === null) {
+    return notApplicable("Skipped \u2014 no backend configured in toolkit.config.json");
+  }
+  const checks = [];
+  if (backend === "invalid") {
+    checks.push(createDoctorCheck({
+      id: "backend-framework",
+      label: CHECK_LABELS["backend-framework"],
+      status: "not-applicable",
+      message: "Skipped \u2014 backend value in toolkit.config.json is not recognized",
+      evidence: [CONFIG_PATH2]
+    }), createDoctorCheck({
+      id: "backend-config-consistency",
+      label: CHECK_LABELS["backend-config-consistency"],
+      status: "error",
+      message: "toolkit.config.json declares an unknown backend (expected 'express', 'nest', or 'none')",
+      evidence: [CONFIG_PATH2],
+      suggestedAction: "Fix the backend field, then re-run doctor."
+    }));
+  } else {
+    let hasDependency = false;
+    try {
+      const pkg = JSON.parse(readFileSync3(join3(root, "package.json"), "utf-8"));
+      const packageName = backend === "nest" ? "@nestjs/core" : "express";
+      hasDependency = Boolean(pkg.dependencies?.[packageName] ?? pkg.devDependencies?.[packageName]);
+    } catch {
+      hasDependency = false;
+    }
+    checks.push(createDoctorCheck({
+      id: "backend-framework",
+      label: CHECK_LABELS["backend-framework"],
+      status: hasDependency ? "pass" : "warning",
+      message: hasDependency ? `${backend} dependency detected in the root package.json` : `backend is configured as ${backend} but its dependency was not found in the root package.json`,
+      evidence: hasDependency ? ["package.json"] : [],
+      suggestedAction: hasDependency ? void 0 : "Run the official generator commands shown by add-backend."
+    }), createDoctorCheck({
+      id: "backend-config-consistency",
+      label: CHECK_LABELS["backend-config-consistency"],
+      status: "pass",
+      message: `backend '${backend}' is a recognized value`,
+      evidence: [CONFIG_PATH2]
+    }));
+  }
+  const sharedTypesCurrent = existsSync3(join3(root, SHARED_TYPES_PACKAGE));
+  const sharedTypesLegacy = !sharedTypesCurrent && existsSync3(join3(root, SHARED_TYPES_LEGACY));
+  const sharedTypesExists = sharedTypesCurrent || sharedTypesLegacy;
+  checks.push(createDoctorCheck({
+    id: "shared-types-lib",
+    label: CHECK_LABELS["shared-types-lib"],
+    status: sharedTypesExists ? "pass" : "warning",
+    message: sharedTypesCurrent ? "libs/shared-types present" : sharedTypesLegacy ? "libs/shared-types present (legacy project.json shape)" : "libs/shared-types not found \u2014 run add-backend to wire it",
+    evidence: sharedTypesCurrent ? [SHARED_TYPES_PACKAGE] : sharedTypesLegacy ? [SHARED_TYPES_LEGACY] : []
+  }));
+  const eslintPath = ESLINT_CONFIG_CANDIDATES.find((candidate) => existsSync3(join3(root, candidate)));
+  const classification = eslintPath ? classifyBoundaryConstraints(readFileSync3(join3(root, eslintPath), "utf-8")) : "unknown";
+  checks.push(createDoctorCheck({
+    id: "boundary-constraints-applied",
+    label: CHECK_LABELS["boundary-constraints-applied"],
+    status: classification === "enforced" ? "pass" : "warning",
+    message: classification === "enforced" ? "scope depConstraints are enforced" : classification === "allow-all" ? "ESLint still has the allow-all default \u2014 boundaries are NOT enforced" : "could not verify the ESLint config (missing or unrecognized shape)",
+    evidence: eslintPath ? [eslintPath] : [],
+    suggestedAction: classification === "enforced" ? void 0 : "Run add-backend with --applyEslint, or merge its snippet yourself."
+  }));
+  if (classification !== "enforced") {
+    checks.push(createDoctorCheck({
+      id: "boundary-tags-exist",
+      label: CHECK_LABELS["boundary-tags-exist"],
+      status: "not-applicable",
+      message: "Skipped \u2014 boundary constraints are not enforced (see boundary-constraints-applied)",
+      evidence: []
+    }));
+  } else {
+    const tags = collectScopeTags(root);
+    const required = readsBackendOnly(root) ? ["scope:backend"] : ["scope:frontend", "scope:backend"];
+    const missing = required.filter((tag) => !tags.has(tag));
+    checks.push(createDoctorCheck({
+      id: "boundary-tags-exist",
+      label: CHECK_LABELS["boundary-tags-exist"],
+      status: missing.length === 0 ? "pass" : "warning",
+      message: missing.length === 0 ? required.length === 1 ? "scope:backend is carried by at least one project (backend-only workspace \u2014 no frontend to tag)" : "both scope:frontend and scope:backend are carried by at least one project" : `the toolkit's enforced deny rules reference ${missing.join(" and ")}, but no project in the scanned directories (apps/, libs/, packages/) carries ${missing.length === 1 ? "it" : "them"} \u2014 the boundary is a dead letter`,
+      evidence: missing.length === 0 ? [] : missing,
+      suggestedAction: missing.length === 0 ? void 0 : "Add the missing scope tag(s) to the app project.json tags or package.json nx.tags (add-backend does this for the two apps)."
+    }));
+  }
+  return checks;
+}
+
+// ../template-engine/dist/doctor/fsd-like-check.js
+import { existsSync as existsSync4, readdirSync as readdirSync2 } from "node:fs";
+import { join as join4 } from "node:path";
+var FSD_LAYERS = ["app", "_app", "pages", "_pages", "widgets", "features", "entities", "shared"];
+function buildFsdLikeCheck(root) {
+  const scanRoots = ["src"];
+  try {
+    for (const entry of readdirSync2(join4(root, "apps"), { withFileTypes: true })) {
+      if (entry.isDirectory())
+        scanRoots.push(`apps/${entry.name}/src`);
+    }
+  } catch {
+  }
+  const found = [];
+  for (const scanRoot of scanRoots) {
+    for (const layer of FSD_LAYERS) {
+      if (existsSync4(join4(root, scanRoot, layer)))
+        found.push(`${scanRoot}/${layer}`);
+    }
+  }
+  if (existsSync4(join4(root, "toolkit.config.json"))) {
+    return createDoctorCheck({
+      id: "fsd-like-structure",
+      label: "FSD-like structure",
+      status: "pass",
+      message: found.length > 0 ? "FSD-like layers found, but this workspace is already managed by the toolkit" : "no FSD-like layers found; workspace is toolkit-managed",
+      evidence: found
+    });
+  }
+  if (found.length >= 2) {
+    return createDoctorCheck({
+      id: "fsd-like-structure",
+      label: "FSD-like structure",
+      status: "warning",
+      message: `an existing FSD-like layout was found (${found.length} layer directories) \u2014 init's FSD section may overlap it`,
+      evidence: found,
+      suggestedAction: "Review the existing structure before running init, or run init with --fsd=false."
+    });
+  }
+  return createDoctorCheck({
+    id: "fsd-like-structure",
+    label: "FSD-like structure",
+    status: "pass",
+    message: "no collision signal \u2014 fewer than two FSD layer directories found",
+    evidence: found
+  });
+}
+
+// ../template-engine/dist/doctor/fsd-enforcement-check.js
+import { existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync4 } from "node:fs";
+import { join as join5 } from "node:path";
+
+// ../templates/dist/fsd/fsd-eslint.js
+var FSD_ESLINT_MODULE = "@clearlydev/nx-archweave/eslint";
+
+// ../template-engine/dist/fsd/fsd-eslint-config.js
+function classifyFsdEslintConfig(configText) {
+  return maskComments(configText).includes(FSD_ESLINT_MODULE) ? "applied" : "absent";
+}
+
+// ../template-engine/dist/doctor/fsd-enforcement-check.js
+function fsdEnabledPerConfig(root) {
+  const path = join5(root, "toolkit.config.json");
+  if (!existsSync5(path))
+    return null;
+  try {
+    const config = JSON.parse(readFileSync4(path, "utf-8"));
+    const fsd = config["fsd"];
+    if (typeof fsd === "object" && fsd !== null && typeof fsd["enabled"] === "boolean") {
+      return fsd["enabled"];
+    }
+    return typeof config["frontend"] === "string" && config["frontend"] !== "none";
+  } catch {
+    return null;
+  }
+}
+function eslintConfigPaths(root) {
+  const dirsIn = (rel) => {
+    try {
+      return readdirSync3(join5(root, rel), { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => rel === "" ? entry.name : `${rel}/${entry.name}`);
+    } catch {
+      return [];
+    }
+  };
+  const apps = dirsIn("apps");
+  const dirs = ["", ...apps, ...apps.flatMap((app) => dirsIn(app))];
+  return dirs.flatMap((dir) => ESLINT_CONFIG_CANDIDATES.map((name) => dir === "" ? name : `${dir}/${name}`)).filter((rel) => existsSync5(join5(root, rel)));
+}
+function buildFsdEnforcementCheck(root) {
+  const id = "fsd-enforcement-applied";
+  const label = "FSD layer rule applied";
+  const enabled = fsdEnabledPerConfig(root);
+  if (enabled !== true) {
+    return createDoctorCheck({
+      id,
+      label,
+      status: "pass",
+      message: enabled === null ? "not a toolkit-managed workspace \u2014 nothing to verify" : "FSD is off for this workspace",
+      evidence: []
+    });
+  }
+  const applied = eslintConfigPaths(root).filter((rel) => classifyFsdEslintConfig(readFileSync4(join5(root, rel), "utf-8")) === "applied");
+  if (applied.length > 0) {
+    return createDoctorCheck({ id, label, status: "pass", message: "the archweave/fsd-boundaries rule is wired into an ESLint config", evidence: applied });
+  }
+  return createDoctorCheck({
+    id,
+    label,
+    status: "warning",
+    message: "no ESLint config imports @clearlydev/nx-archweave/eslint \u2014 FSD layer rules are NOT enforced",
+    evidence: [],
+    suggestedAction: "Run add-fsd-lite --applyEslint (or paste the snippet it prints into the frontend app's eslint.config.mjs)."
+  });
+}
+
+// ../template-engine/dist/doctor/run-doctor-checks.js
+var NOT_APPLICABLE_IDS = [
+  "fsd-like-structure",
+  "fsd-enforcement-applied",
+  "nx-version",
+  "package-manager",
+  "workspace-root",
+  "framework-react-vite",
+  "framework-next",
+  "existing-config",
+  "agent-rules-files",
+  "github-templates",
+  "integration-manifest",
+  ...REVIEW_CHECK_IDS,
+  ...BACKEND_CHECK_IDS
+];
+function runDoctorChecks(root) {
+  const env = detectEnvironment(root);
+  if (!env.hasNxWorkspace) {
+    const checks2 = [
+      createDoctorCheck({
+        id: "nx-workspace-detected",
+        label: "Nx workspace detected",
+        status: "error",
+        message: "nx.json not found \u2014 this is not an Nx workspace.",
+        evidence: [],
+        suggestedAction: "Run this command from the root of an Nx workspace."
+      }),
+      ...NOT_APPLICABLE_IDS.map((id) => createDoctorCheck({
+        id,
+        label: id,
+        status: "not-applicable",
+        message: "Skipped \u2014 not an Nx workspace",
+        evidence: []
+      }))
+    ];
+    return { checks: checks2, overallStatus: "unsupported" };
+  }
+  const checks = [
+    createDoctorCheck({
+      id: "nx-workspace-detected",
+      label: "Nx workspace detected",
+      status: "pass",
+      message: "nx.json found",
+      evidence: ["nx.json"]
+    }),
+    buildNxVersionCheck(env),
+    buildFsdLikeCheck(root),
+    buildFsdEnforcementCheck(root),
+    createDoctorCheck({
+      id: "package-manager",
+      label: "Package manager",
+      status: env.packageManager ? "pass" : "warning",
+      message: env.packageManager ? `${env.packageManager} detected` : "Unknown package manager",
+      evidence: env.packageManager ? [env.packageManager] : []
+    }),
+    createDoctorCheck({
+      id: "workspace-root",
+      label: "Workspace root",
+      status: "pass",
+      message: root,
+      evidence: [root]
+    }),
+    ...buildFrameworkChecks(env),
+    buildExistingConfigCheck(root),
+    buildAgentRulesCheck(root),
+    buildGithubTemplatesCheck(root),
+    buildIntegrationManifestCheck(root),
+    ...buildReviewChecks(root),
+    ...buildBackendChecks(root)
+  ];
+  const overallStatus = computeOverallStatus(checks);
+  return { checks, overallStatus };
+}
+var VALIDATED_NX_MAJOR = 23;
+function extractMajor(version) {
+  const match = /(\d+)/.exec(version);
+  return match ? Number(match[1]) : null;
+}
+function buildNxVersionCheck(env) {
+  if (env.rootPackageJsonError) {
+    return createDoctorCheck({
+      id: "nx-version",
+      label: "Nx version",
+      status: "error",
+      message: `Could not read root package.json: ${env.rootPackageJsonError}`,
+      evidence: ["package.json"],
+      suggestedAction: "Fix the JSON syntax in the root package.json and re-run doctor."
+    });
+  }
+  if (!env.nxVersion) {
+    return createDoctorCheck({
+      id: "nx-version",
+      label: "Nx version",
+      status: "warning",
+      message: "Could not determine Nx version",
+      evidence: []
+    });
+  }
+  const major = extractMajor(env.nxVersion);
+  if (major === null) {
+    return createDoctorCheck({
+      id: "nx-version",
+      label: "Nx version",
+      status: "warning",
+      message: `Nx version "${env.nxVersion}" could not be parsed \u2014 range judgment skipped`,
+      evidence: [`nx@${env.nxVersion}`]
+    });
+  }
+  if (major === VALIDATED_NX_MAJOR) {
+    return createDoctorCheck({
+      id: "nx-version",
+      label: "Nx version",
+      status: "pass",
+      message: `Nx ${env.nxVersion} \u2014 within the toolkit-validated range (${VALIDATED_NX_MAJOR}.x)`,
+      evidence: [`nx@${env.nxVersion}`]
+    });
+  }
+  if (major < VALIDATED_NX_MAJOR) {
+    return createDoctorCheck({
+      id: "nx-version",
+      label: "Nx version",
+      status: "warning",
+      message: `Nx ${env.nxVersion} is below the toolkit-validated range (${VALIDATED_NX_MAJOR}.x) \u2014 generator behavior is not guaranteed`,
+      evidence: [`nx@${env.nxVersion}`],
+      suggestedAction: `Upgrade the workspace to Nx ${VALIDATED_NX_MAJOR}.x before running the generators.`
+    });
+  }
+  return createDoctorCheck({
+    id: "nx-version",
+    label: "Nx version",
+    status: "warning",
+    message: `Nx ${env.nxVersion} is above the toolkit-validated range (${VALIDATED_NX_MAJOR}.x) \u2014 may work, unvalidated`,
+    evidence: [`nx@${env.nxVersion}`],
+    suggestedAction: "Proceed with care and report issues; validation for newer majors lands with toolkit updates."
+  });
+}
+function buildFrameworkChecks(env) {
+  if (env.rootPackageJsonError) {
+    const message = `Could not read root package.json: ${env.rootPackageJsonError}`;
+    return [
+      createDoctorCheck({
+        id: "framework-react-vite",
+        label: "React + Vite (root package.json only)",
+        status: "error",
+        message,
+        evidence: ["package.json"]
+      }),
+      createDoctorCheck({
+        id: "framework-next",
+        label: "Next.js (root package.json only)",
+        status: "error",
+        message,
+        evidence: ["package.json"]
+      })
+    ];
+  }
+  const dependencies = env.rootPackageJson?.["dependencies"] ?? {};
+  const devDependencies = env.rootPackageJson?.["devDependencies"] ?? {};
+  const allDeps = { ...dependencies, ...devDependencies };
+  const hasReactVite = Boolean(allDeps.vite && allDeps.react);
+  const hasNext = Boolean(allDeps.next);
+  return [
+    createDoctorCheck({
+      id: "framework-react-vite",
+      label: "React + Vite (root package.json only)",
+      status: hasReactVite ? "pass" : "not-applicable",
+      message: hasReactVite ? "react + vite dependencies detected in the root package.json" : "Not detected in the root package.json (sub-packages are not scanned)",
+      evidence: hasReactVite ? ["package.json"] : []
+    }),
+    createDoctorCheck({
+      id: "framework-next",
+      label: "Next.js (root package.json only)",
+      status: hasNext ? "pass" : "not-applicable",
+      message: hasNext ? "next dependency detected in the root package.json" : "Not detected in the root package.json (sub-packages are not scanned)",
+      evidence: hasNext ? ["package.json"] : []
+    })
+  ];
+}
+function isToolkitManaged(root) {
+  return existsSync6(join6(root, "toolkit.config.json"));
+}
+function buildExistingConfigCheck(root) {
+  const exists = isToolkitManaged(root);
+  return createDoctorCheck({
+    id: "existing-config",
+    label: "toolkit.config.json",
+    status: "pass",
+    message: exists ? "Found \u2014 the workspace is managed by nx-archweave; init and the generators merge into it, changing only their own fields" : "Not found \u2014 init creates it",
+    evidence: exists ? ["toolkit.config.json"] : []
+  });
+}
+function buildIntegrationManifestCheck(root) {
+  const exists = existsSync6(join6(root, "archweave-integrations.json"));
+  return createDoctorCheck({
+    id: "integration-manifest",
+    label: "Integration manifest",
+    status: "pass",
+    message: exists ? "Found \u2014 nx-archweave's record of installed integrations (checked against what is installed below)" : "Not found \u2014 written when an integration is installed",
+    evidence: exists ? ["archweave-integrations.json"] : []
+  });
+}
+function buildAgentRulesCheck(root) {
+  const claudeExists = existsSync6(join6(root, "CLAUDE.md"));
+  const agentsExists = existsSync6(join6(root, "AGENTS.md"));
+  const exists = claudeExists || agentsExists;
+  const evidence = [claudeExists && "CLAUDE.md", agentsExists && "AGENTS.md"].filter(Boolean);
+  return createDoctorCheck({
+    id: "agent-rules-files",
+    label: "CLAUDE.md / AGENTS.md",
+    status: "pass",
+    message: exists ? "Existing agent rules file(s) found \u2014 nx-archweave adds or updates only its own marked block" : "Not found \u2014 safe to create",
+    evidence
+  });
+}
+function buildGithubTemplatesCheck(root) {
+  const issueTemplateExists = existsSync6(join6(root, ".github", "ISSUE_TEMPLATE"));
+  const prTemplateExists = existsSync6(join6(root, ".github", "PULL_REQUEST_TEMPLATE.md"));
+  const exists = issueTemplateExists || prTemplateExists;
+  const managed = isToolkitManaged(root);
+  return createDoctorCheck({
+    id: "github-templates",
+    label: "GitHub Issue/PR templates",
+    status: exists && !managed ? "warning" : "pass",
+    message: !exists ? "Not found \u2014 safe to create" : managed ? "Found \u2014 kept as they are (add-github-templates never overwrites a template); the workspace is managed by nx-archweave" : "Existing template(s) found \u2014 add-github-templates keeps them as they are (it never overwrites a template)",
+    evidence: [issueTemplateExists && ".github/ISSUE_TEMPLATE", prTemplateExists && ".github/PULL_REQUEST_TEMPLATE.md"].filter(Boolean)
+  });
+}
+
+// ../integrations/dist/registry/integration-registry.js
+function createIntegrationRegistry(integrations) {
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const integration of integrations) {
+    if (seenIds.has(integration.id)) {
+      throw new Error(`Duplicate integration id: "${integration.id}"`);
+    }
+    seenIds.add(integration.id);
+  }
+  return integrations;
+}
+function listIntegrations(registry) {
+  return registry;
+}
+function getIntegration(registry, id) {
+  return registry.find((integration) => integration.id === id);
+}
+
+// ../integrations/dist/manifest/manifest.js
+import { existsSync as existsSync7, lstatSync, readFileSync as readFileSync5, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { join as join7 } from "node:path";
+var MANIFEST_FILENAME = "archweave-integrations.json";
+function createEmptyManifest() {
+  return { integrations: {} };
+}
+function loadManifest(root) {
+  const manifestPath = join7(root, MANIFEST_FILENAME);
+  if (!existsSync7(manifestPath)) {
+    return createEmptyManifest();
+  }
+  try {
+    const parsed = JSON.parse(readFileSync5(manifestPath, "utf8"));
+    if (parsed && typeof parsed === "object" && typeof parsed.integrations === "object") {
+      return { integrations: parsed.integrations ?? {} };
+    }
+    return createEmptyManifest();
+  } catch {
+    return createEmptyManifest();
+  }
+}
+
+// ../integrations/dist/doctor/detect-drift.js
+function classifyIntegrationDrift(input) {
+  const { id, declared, manifestEntry, detected } = input;
+  const nxG = `${input.runNx ?? "pnpm nx"} g`;
+  if (!declared && !manifestEntry && !detected.installed) {
+    return {
+      id,
+      status: "not-installed",
+      reason: "Not declared in ToolkitConfig.integrations.enabled, no manifest entry, and not detected in this workspace."
+    };
+  }
+  if (!declared) {
+    if (manifestEntry) {
+      return {
+        id,
+        status: "undeclared-leftover",
+        reason: "The configuration no longer declares this integration, but its install record remains.",
+        suggestedAction: "Either re-declare it in ToolkitConfig.integrations.enabled or clean up the leftover installation and manifest entry.",
+        source: manifestEntry.source,
+        verification: manifestEntry.verification
+      };
+    }
+    return {
+      id,
+      status: "externally-installed",
+      reason: "Detected live, but neither declared in ToolkitConfig.integrations.enabled nor recorded in the manifest \u2014 installed outside nx-archweave.",
+      suggestedAction: "Adopt it by declaring it in ToolkitConfig.integrations.enabled, or leave it unmanaged (doctor will keep noting it)."
+    };
+  }
+  if (manifestEntry && manifestEntry.verification === "passed") {
+    return {
+      id,
+      status: "configured",
+      reason: "Declared and installed; the last verification passed.",
+      source: manifestEntry.source,
+      verification: "passed"
+    };
+  }
+  if (manifestEntry) {
+    return {
+      id,
+      status: "verification-failed",
+      reason: `Declared and an install record exists, but the last verification did not pass (status: ${manifestEntry.verification}).`,
+      suggestedAction: "Inspect the tool installation and re-run its verification (or reinstall the integration).",
+      source: manifestEntry.source,
+      verification: manifestEntry.verification
+    };
+  }
+  if (detected.installed) {
+    return {
+      id,
+      status: "declared-missing",
+      reason: "Declared and detected as installed, but no install record exists \u2014 the installation happened outside nx-archweave bookkeeping.",
+      suggestedAction: `Adopt the existing installation into the manifest: ${nxG} @clearlydev/nx-archweave:record-integration --tool=${id} --apply`
+    };
+  }
+  return {
+    id,
+    status: "declared-missing",
+    reason: "Declared in ToolkitConfig.integrations.enabled, but no install record exists \u2014 the installation never happened or was removed.",
+    suggestedAction: input.installable ? `Install it: ${nxG} @clearlydev/nx-archweave:install-integration --tool=${id} --apply \u2014 or remove the declaration if it is no longer wanted.` : "Re-install the integration, or remove the declaration if it is no longer wanted (nx-archweave has no installer for this id \u2014 check it for a typo)."
+  };
+}
+async function detectIntegrationsDrift(input) {
+  const manifest = loadManifest(input.workspaceRoot);
+  const ids = /* @__PURE__ */ new Set([
+    ...input.declaredIds,
+    ...Object.keys(manifest.integrations),
+    ...input.integrations.map((integration) => integration.id)
+  ]);
+  const context = {
+    workspaceRoot: input.workspaceRoot,
+    targetEnvironment: input.targetEnvironment
+  };
+  const results = [];
+  for (const id of ids) {
+    const integration = input.integrations.find((candidate) => candidate.id === id);
+    const detected = integration ? await integration.detect(context) : { installed: false, managedBy: "unknown", evidence: [] };
+    results.push(classifyIntegrationDrift({
+      id,
+      installable: integration !== void 0,
+      declared: input.declaredIds.includes(id),
+      manifestEntry: manifest.integrations[id],
+      detected,
+      ...input.runNx === void 0 ? {} : { runNx: input.runNx }
+    }));
+  }
+  return results;
+}
+
+// ../integrations/dist/doctor/integration-doctor-checks.js
+function buildIntegrationDoctorChecks(results) {
+  return results.map((result) => {
+    const evidence = [
+      result.source && `manifest source: ${result.source}`,
+      result.verification && `verification: ${result.verification}`
+    ].filter(Boolean);
+    const status = (() => {
+      switch (result.status) {
+        case "not-installed":
+          return "not-applicable";
+        case "declared-missing":
+        case "undeclared-leftover":
+        case "externally-installed":
+          return "warning";
+        case "verification-failed":
+          return "error";
+        case "configured":
+          return "pass";
+        default:
+          return result.status;
+      }
+    })();
+    return createDoctorCheck({
+      id: `integration-${result.id}`,
+      label: `Integration: ${result.id}`,
+      status,
+      message: result.reason,
+      evidence,
+      suggestedAction: result.suggestedAction
+    });
+  });
+}
+
+// ../integrations/dist/config/read-enabled-integrations.js
+import { existsSync as existsSync8, readFileSync as readFileSync6 } from "node:fs";
+import { join as join8 } from "node:path";
+var CONFIG_FILENAME = "toolkit.config.json";
+function readEnabledIntegrationIds(root) {
+  const configPath = join8(root, CONFIG_FILENAME);
+  if (!existsSync8(configPath)) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(readFileSync6(configPath, "utf8"));
+    const enabled = parsed?.integrations?.enabled;
+    return Array.isArray(enabled) && enabled.every((id) => typeof id === "string") ? enabled : [];
+  } catch {
+    return [];
+  }
+}
+
+// ../integrations/dist/process/read-only-command-runner.js
+var CLAUDE_CLI_TIMEOUT_MS = 5e3;
+var CLAUDE_CLI_STDOUT_LIMIT_BYTES = 1048576;
+var CLAUDE_CLI_STDERR_LIMIT_BYTES = 65536;
+
+// ../integrations/dist/catalog/plugin-catalog.js
+var PLUGIN_HOSTS = ["claude-code"];
+var PLUGIN_CATALOG = [
+  {
+    // Researched 2026-07-15. The claude-code values are the ones the manifest and verifier
+    // were measured with. ponytail documents official installs for ~20 hosts; only claude-code
+    // has an adapter.
+    id: "ponytail",
+    displayName: "ponytail",
+    // The project's own tagline.
+    description: 'over-engineering review rules and skills \u2014 "makes your AI agent think like the laziest senior dev in the room"',
+    homepage: "https://ponytail.dev",
+    repository: "https://github.com/DietrichGebert/ponytail",
+    license: "MIT",
+    npmPackage: "@dietrichgebert/ponytail",
+    installDocs: "https://github.com/DietrichGebert/ponytail#install",
+    uninstallSteps: [
+      "Run this from a clone of https://github.com/DietrichGebert/ponytail (or before removing the plugin below \u2014 the script is itself a plugin file, so removing the plugin first deletes it): node scripts/uninstall.js",
+      "Then remove the plugin via your host's own command, e.g. in Claude Code: /plugin uninstall ponytail@ponytail (or use the Claude Code Desktop app: Customize > manage marketplaces > remove plugin).",
+      "See https://github.com/DietrichGebert/ponytail#uninstall for the full, current official instructions."
+    ],
+    hosts: {
+      "claude-code": { name: "ponytail", marketplace: "DietrichGebert/ponytail", pluginId: "ponytail@ponytail" }
+    }
+  }
+];
+var PLUGIN_IDS = PLUGIN_CATALOG.map((entry) => entry.id);
+
+// ../integrations/dist/catalog/resolve-version.js
+import { get } from "node:https";
+function resolveVersionFromNpmRegistry(npmPackage) {
+  const registryUrl = `https://registry.npmjs.org/${encodeURIComponent(npmPackage)}`;
+  return new Promise((resolve2, reject) => {
+    get(registryUrl, (response) => {
+      let body = "";
+      response.on("data", (chunk) => {
+        body += chunk;
+      });
+      response.on("end", () => {
+        try {
+          const parsed = JSON.parse(body);
+          const latest = parsed?.["dist-tags"]?.["latest"];
+          if (typeof latest !== "string") {
+            reject(new Error(`Could not resolve the latest version of ${npmPackage} from the npm registry.`));
+            return;
+          }
+          resolve2(latest);
+        } catch (error) {
+          reject(error instanceof Error ? error : new Error(String(error)));
+        }
+      });
+    }).on("error", reject);
+  });
+}
+
+// ../integrations/dist/hosts/claude-code/detect.js
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "node:fs";
+import { join as join9 } from "node:path";
+async function detectWorkspacePackage(entry, context) {
+  const npmPackage = entry.npmPackage;
+  if (npmPackage === void 0) {
+    return { installed: false, managedBy: "unknown", evidence: [] };
+  }
+  const packageJsonPath = join9(context.workspaceRoot, "package.json");
+  if (!existsSync9(packageJsonPath)) {
+    return { installed: false, managedBy: "unknown", evidence: [] };
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(readFileSync7(packageJsonPath, "utf8"));
+  } catch {
+    return { installed: false, managedBy: "unknown", evidence: [] };
+  }
+  const deps = pkg["dependencies"] ?? {};
+  const devDeps = pkg["devDependencies"] ?? {};
+  const version = deps[npmPackage] ?? devDeps[npmPackage];
+  if (!version) {
+    return { installed: false, managedBy: "unknown", evidence: [] };
+  }
+  return {
+    installed: true,
+    installedVersion: version,
+    managedBy: "external-tool",
+    evidence: [`package.json: ${npmPackage}@${version}`]
+  };
+}
+
+// ../integrations/dist/hosts/claude-code/plan.js
+var VERSION_DECIDED_BY_MARKETPLACE = "latest (decided by the marketplace)";
+var WORKSPACE_FILES_BY_SCOPE = {
+  user: [],
+  project: [".claude/settings.json"],
+  local: [".claude/settings.local.json"]
+};
+var DEFAULT_PLUGIN_SCOPE = "project";
+function createClaudeMarketplacePlan(entry, deps) {
+  return async (options) => {
+    const distribution = entry.hosts["claude-code"];
+    if (options.targetEnvironment !== "claude-code" || distribution === void 0) {
+      const supported = Object.entries(entry.hosts).filter(([, value]) => value !== void 0).map(([host]) => host).join(", ");
+      throw new Error(`Target environment "${options.targetEnvironment}" is not supported by this integration. Supported: ${supported}.`);
+    }
+    const resolvedVersion = options.versionRange ?? (options.resolveLatestVersion === false ? VERSION_DECIDED_BY_MARKETPLACE : await deps.resolveVersion(options.versionRange));
+    const scope = options.scope ?? DEFAULT_PLUGIN_SCOPE;
+    return {
+      officialCommand: {
+        executable: "claude",
+        args: [
+          "plugin",
+          "install",
+          distribution.name,
+          "--marketplace",
+          distribution.marketplace,
+          "--scope",
+          scope,
+          "--json"
+        ]
+      },
+      resolvedVersion,
+      filesCreated: [],
+      // project/local scope: Claude Code records the plugin in the workspace's own
+      // .claude settings — shown before approval as the files that will change.
+      filesModified: [...WORKSPACE_FILES_BY_SCOPE[scope]],
+      conflicts: [],
+      sourceRepository: entry.repository,
+      officialHomepage: entry.homepage,
+      license: entry.license,
+      requiresManualExecution: false
+    };
+  };
+}
+
+// ../integrations/dist/hosts/claude-code/install.js
+import { homedir } from "node:os";
+function manualInstallSteps(entry) {
+  const distribution = entry.hosts["claude-code"];
+  if (distribution === void 0)
+    return [`See ${entry.installDocs} for the official instructions.`];
+  return [
+    `In Claude Code, send this as its own prompt: /plugin marketplace add ${distribution.marketplace}`,
+    `Then, as a second separate prompt: /plugin install ${distribution.pluginId}`,
+    `See ${entry.installDocs} for the official instructions.`
+  ];
+}
+var CLAUDE_CLI_INSTALL_TIMEOUT_MS = 12e4;
+var CLAUDE_CLI_INSTALL_STDOUT_LIMIT_BYTES = 1048576;
+var CLAUDE_CLI_INSTALL_STDERR_LIMIT_BYTES = 262144;
+function defaultRerunCommand(entry, runNx = "pnpm nx") {
+  return `${runNx} g @clearlydev/nx-archweave:install-integration --tool=${entry.id} --apply`;
+}
+function chatAlternative(entry) {
+  return ["Alternatively, inside a Claude Code session (the chat path):", ...manualInstallSteps(entry)];
+}
+var MARKETPLACE_NOTE = "If the marketplace was registered before the failure, it stays in your user settings \u2014 see `claude plugin marketplace list`.";
+function claudeCliNotFoundSteps(entry, rerunCommand) {
+  return [
+    "The claude CLI was not found on PATH. Install the Claude Code CLI from your terminal: npm install -g @anthropic-ai/claude-code (setup guide: https://code.claude.com/docs/en/setup)",
+    `Then rerun: ${rerunCommand}`,
+    ...chatAlternative(entry)
+  ];
+}
+function claudeCliUnsupportedSteps(entry, rerunCommand, cliSaid) {
+  return [
+    `Your claude CLI does not know this command (it said: ${cliSaid}). Scriptable plugin install needs Claude Code 2.1.285 or newer: run \`claude update\`, or reinstall it with npm install -g @anthropic-ai/claude-code@latest`,
+    `Then rerun: ${rerunCommand}`,
+    ...chatAlternative(entry)
+  ];
+}
+var TAIL_CHARS = 500;
+var UNSUPPORTED_CLI_PATTERN = /error: unknown (command|option) '(plugin|install|marketplace|--json|--marketplace|--scope)'/;
+function tail(text) {
+  const trimmed = text.trim();
+  return trimmed.length > TAIL_CHARS ? trimmed.slice(-TAIL_CHARS) : trimmed;
+}
+var ESCAPED_HOME = homedir().replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var HOME_PATTERN = new RegExp(`${ESCAPED_HOME}(?=[/\\\\\\s'"\`]|$)`, "g");
+function redactHomePaths(text) {
+  let out = ESCAPED_HOME.length > 1 ? text.replace(HOME_PATTERN, "~") : text;
+  out = out.replace(/\/(?:Users|home)\/[^/\s'"`]+/g, "~");
+  out = out.replace(/[A-Za-z]:\\Users\\[^\\\s'"`]+/g, "~");
+  out = out.replace(/\/root(?=[/\s'"`]|$)/g, "~");
+  return out;
+}
+function parseLastJsonObject(stdout) {
+  const lines = stdout.split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i].trim();
+    if (!line.startsWith("{"))
+      continue;
+    try {
+      const parsed = JSON.parse(line);
+      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed))
+        return parsed;
+    } catch {
+    }
+  }
+  return null;
+}
+function renderUserCommand(command) {
+  return [command.executable, ...command.args.filter((arg) => arg !== "--json")].join(" ");
+}
+async function classifyRun(runner, command, cwd) {
+  let raw;
+  try {
+    raw = await runner.run({
+      executable: command.executable,
+      argv: command.args,
+      ...cwd === void 0 ? {} : { cwd },
+      timeoutMs: CLAUDE_CLI_INSTALL_TIMEOUT_MS,
+      stdoutLimitBytes: CLAUDE_CLI_INSTALL_STDOUT_LIMIT_BYTES,
+      stderrLimitBytes: CLAUDE_CLI_INSTALL_STDERR_LIMIT_BYTES
+    });
+  } catch (error) {
+    const code = typeof error?.code === "string" ? error.code : "unknown";
+    return code === "ENOENT" ? { kind: "cli-not-found" } : { kind: "failed-to-start", code };
+  }
+  if (raw.timedOut)
+    return { kind: "timeout" };
+  if (raw.outputExceeded)
+    return { kind: "output-too-large" };
+  const json = parseLastJsonObject(raw.stdout);
+  const jsonSaysFailed = json !== null && json["outcome"] === "failed";
+  if (raw.exitCode === 0 && !jsonSaysFailed)
+    return { kind: "executed" };
+  if (json !== null) {
+    const message = redactHomePaths(typeof json["message"] === "string" ? json["message"] : `the claude CLI exited with code ${raw.exitCode}`);
+    const failureCode = typeof json["failureCode"] === "string" ? json["failureCode"] : void 0;
+    const shown = json["shownCommand"];
+    if (typeof shown === "object" && shown !== null)
+      return { kind: "confirmation-required", message };
+    return failureCode === void 0 ? { kind: "failed", message } : { kind: "failed", failureCode, message };
+  }
+  if (UNSUPPORTED_CLI_PATTERN.test(raw.stderr)) {
+    const line = raw.stderr.split("\n").find((l) => UNSUPPORTED_CLI_PATTERN.test(l)) ?? "";
+    return { kind: "cli-unsupported", stderrTail: redactHomePaths(line.trim()) };
+  }
+  const said = redactHomePaths(tail(raw.stderr.length > 0 ? raw.stderr : raw.stdout));
+  return { kind: "failed", message: said.length > 0 ? said : `the claude CLI exited with code ${raw.exitCode}` };
+}
+function manualStepsFor(entry, detail, command, rerunCommand) {
+  const chat = chatAlternative(entry);
+  const userCommand = command === null ? "" : renderUserCommand(command);
+  const rerun = `Once resolved, rerun to install, verify and record it: ${rerunCommand}`;
+  switch (detail.kind) {
+    case "executed":
+      return [];
+    case "manual-only":
+      return manualInstallSteps(entry);
+    case "cli-not-found":
+      return claudeCliNotFoundSteps(entry, rerunCommand);
+    case "failed-to-start":
+      return [
+        `The claude CLI was found but could not be started (${detail.code}) \u2014 check its permissions and your system limits.`,
+        rerun,
+        ...chat
+      ];
+    case "cli-unsupported":
+      return claudeCliUnsupportedSteps(entry, rerunCommand, detail.stderrTail);
+    case "confirmation-required":
+      return [
+        `The marketplace declares a command that must be confirmed by a person; nx-archweave never accepts it for you (${detail.message})`,
+        `Review it and run the install yourself: ${userCommand}`,
+        rerun,
+        ...chat
+      ];
+    case "failed":
+      return [`The install command did not succeed: ${detail.message}`, MARKETPLACE_NOTE, rerun, ...chat];
+    case "timeout":
+      return [
+        `The install command did not finish within ${CLAUDE_CLI_INSTALL_TIMEOUT_MS / 1e3} s and was stopped.`,
+        MARKETPLACE_NOTE,
+        rerun,
+        ...chat
+      ];
+    case "output-too-large":
+      return [
+        "The install command produced more output than nx-archweave is willing to buffer and was stopped.",
+        `Run it yourself to see the full output: ${userCommand}`,
+        rerun,
+        ...chat
+      ];
+  }
+}
+async function installClaudeMarketplacePlugin(entry, deps, plan, options = {}) {
+  const rerunCommand = options.rerunCommand ?? defaultRerunCommand(entry);
+  const detail = plan.officialCommand === null ? { kind: "manual-only" } : await classifyRun(deps.runner, plan.officialCommand, options.cwd);
+  const executed = detail.kind === "executed";
+  const result = {
+    executed,
+    // One command: it either reached exit 0 or it did not. What a failed run may
+    // have left behind is re-checked live by install-integration, not guessed here.
+    partialFailure: false,
+    filesCreated: [],
+    // The workspace files the plan said the host would change (project/local scope);
+    // Claude's own plugin store is outside the workspace and never listed.
+    filesModified: executed ? [...plan.filesModified] : [],
+    manualStepsRemaining: manualStepsFor(entry, detail, plan.officialCommand, rerunCommand)
+  };
+  return { result, detail };
+}
+function createClaudeMarketplaceInstall(entry, deps) {
+  return async (plan) => (await installClaudeMarketplacePlugin(entry, deps, plan)).result;
+}
+
+// ../integrations/dist/hosts/claude-code/verify-via-claude-cli.js
+import { realpathSync } from "node:fs";
+import { resolve } from "node:path";
+
+// ../integrations/dist/hosts/claude-code/parse-claude-plugin-list.js
+var KNOWN_SCOPES = /* @__PURE__ */ new Set(["user", "project", "local", "managed"]);
+function isKnownScope(scope) {
+  return KNOWN_SCOPES.has(scope);
+}
+function isValidEntry(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const record = value;
+  if (typeof record["id"] !== "string") {
+    return false;
+  }
+  if (typeof record["enabled"] !== "boolean") {
+    return false;
+  }
+  if (typeof record["scope"] !== "string" || record["scope"].length === 0) {
+    return false;
+  }
+  if (record["version"] !== void 0 && typeof record["version"] !== "string") {
+    return false;
+  }
+  return true;
+}
+function parseClaudePluginList(rawStdout, options = {}) {
+  let parsed;
+  try {
+    parsed = JSON.parse(rawStdout);
+  } catch {
+    return { ok: false, reason: "invalid-json" };
+  }
+  if (!Array.isArray(parsed)) {
+    return { ok: false, reason: "non-array" };
+  }
+  const entries = [];
+  const otherScopeIds = [];
+  for (const item of parsed) {
+    if (!isValidEntry(item)) {
+      return { ok: false, reason: "missing-fields" };
+    }
+    if (typeof item.projectPath === "string" && options.isThisWorkspace && !options.isThisWorkspace(item.projectPath)) {
+      continue;
+    }
+    const scope = item.scope;
+    if (!isKnownScope(scope)) {
+      otherScopeIds.push(item.id);
+      continue;
+    }
+    entries.push({
+      id: item.id,
+      version: item.version,
+      scope,
+      enabled: item.enabled
+    });
+  }
+  return { ok: true, entries, otherScopeIds };
+}
+
+// ../integrations/dist/hosts/claude-code/match-claude-plugin.js
+function matchClaudePlugin(entries, pluginId) {
+  const matches = entries.filter((candidate) => candidate.id === pluginId);
+  if (matches.length === 0) {
+    return { kind: "absent" };
+  }
+  if (matches.length > 1) {
+    return { kind: "ambiguous", entries: matches };
+  }
+  return { kind: "matched", entry: matches[0] };
+}
+
+// ../integrations/dist/hosts/claude-code/claude-cli-verification-result.js
+function evaluateClaudeCliMatch(match) {
+  switch (match.kind) {
+    case "matched":
+      return match.entry.enabled ? { status: "verified", version: match.entry.version, scope: match.entry.scope } : { status: "installed-but-disabled", scope: match.entry.scope };
+    case "absent":
+      return { status: "absent" };
+    case "ambiguous":
+      return { status: "ambiguous" };
+  }
+}
+
+// ../integrations/dist/hosts/claude-code/verify-via-claude-cli.js
+async function verifyViaClaudeCli(runner, pluginId, cwd) {
+  let raw;
+  try {
+    raw = await runner.run({
+      executable: "claude",
+      argv: ["plugin", "list", "--json"],
+      ...cwd === void 0 ? {} : { cwd },
+      timeoutMs: CLAUDE_CLI_TIMEOUT_MS,
+      stdoutLimitBytes: CLAUDE_CLI_STDOUT_LIMIT_BYTES,
+      stderrLimitBytes: CLAUDE_CLI_STDERR_LIMIT_BYTES
+    });
+  } catch {
+    return { source: "claude-cli-unavailable", reason: "not-found" };
+  }
+  if (raw.timedOut) {
+    return { source: "claude-cli-unavailable", reason: "timeout" };
+  }
+  if (raw.outputExceeded) {
+    return { source: "claude-cli-unavailable", reason: "output-too-large" };
+  }
+  if (raw.exitCode !== 0) {
+    return { source: "claude-cli-unavailable", reason: "non-zero-exit" };
+  }
+  const parsed = parseClaudePluginList(raw.stdout, cwd === void 0 ? {} : { isThisWorkspace: samePathAs(cwd) });
+  if (!parsed.ok) {
+    return {
+      source: "claude-cli-unavailable",
+      reason: parsed.reason === "invalid-json" ? "invalid-json" : "unexpected-schema"
+    };
+  }
+  const match = matchClaudePlugin(parsed.entries, pluginId);
+  if (parsed.otherScopeIds.includes(pluginId)) {
+    return match.kind === "absent" ? { source: "claude-cli-unavailable", reason: "unexpected-schema" } : { source: "claude-cli", outcome: { status: "ambiguous" } };
+  }
+  return { source: "claude-cli", outcome: evaluateClaudeCliMatch(match) };
+}
+function canonical(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return resolve(path);
+  }
+}
+function samePathAs(workspaceRoot) {
+  const root = canonical(workspaceRoot);
+  return (projectPath) => canonical(projectPath) === root;
+}
+
+// ../integrations/dist/hosts/claude-code/verify.js
+async function verifyClaudeMarketplacePlugin(entry, deps, context) {
+  const detect = deps.detect ?? detectWorkspacePackage;
+  const pluginId = entry.hosts["claude-code"]?.pluginId;
+  if (pluginId === void 0) {
+    throw new Error(`${entry.displayName} has no Claude Code distribution \u2014 it cannot be verified through the claude CLI.`);
+  }
+  const cliResult = await verifyViaClaudeCli(deps.runner, pluginId, context.workspaceRoot);
+  if (cliResult.source === "claude-cli") {
+    switch (cliResult.outcome.status) {
+      case "verified":
+        return {
+          source: "claude-cli",
+          result: { verified: true, resolvedVersion: cliResult.outcome.version, problems: [] }
+        };
+      case "installed-but-disabled":
+        return {
+          source: "claude-cli",
+          result: {
+            verified: false,
+            problems: [
+              `${entry.displayName} is installed (scope: ${cliResult.outcome.scope}) but currently disabled in Claude Code.`,
+              "Enable it before recording this integration \u2014 a disabled plugin is never recorded as verified."
+            ]
+          }
+        };
+      case "absent":
+        return {
+          source: "claude-cli",
+          result: {
+            verified: false,
+            problems: [
+              `${pluginId} was not found in the installed Claude Code plugin list.`,
+              `Install it (${defaultRerunCommand(entry)}) or complete the manual Claude Code steps, then try again.`
+            ]
+          }
+        };
+      case "ambiguous":
+        return {
+          source: "claude-cli",
+          result: {
+            verified: false,
+            problems: [
+              `Verification error: more than one installed plugin matches ${pluginId} exactly. This is ambiguous and cannot be safely resolved automatically.`
+            ]
+          }
+        };
+    }
+  }
+  if (cliResult.reason === "not-found") {
+    const detected = await detect(entry, context);
+    if (detected.installed) {
+      return {
+        source: "package-json",
+        result: { verified: true, resolvedVersion: detected.installedVersion, problems: [] }
+      };
+    }
+    return {
+      source: "package-json",
+      result: {
+        verified: false,
+        problems: [
+          `The claude CLI was not found, and ${entry.displayName} was not found as a workspace dependency either.`,
+          `Install the Claude Code CLI to use the authoritative verification signal, or add ${entry.displayName} as a workspace dependency for the weaker fallback signal.`
+        ]
+      }
+    };
+  }
+  return {
+    source: "claude-cli",
+    result: {
+      verified: false,
+      problems: [`Verification error: the claude CLI returned an unexpected result (${cliResult.reason}).`]
+    }
+  };
+}
+function createClaudeMarketplaceVerifier(entry, deps) {
+  return async (context) => (await verifyClaudeMarketplacePlugin(entry, deps, context)).result;
+}
+
+// ../integrations/dist/catalog/create-catalog-integration.js
+function defaultResolveVersion(entry) {
+  const npmPackage = entry.npmPackage;
+  return npmPackage === void 0 ? async () => VERSION_DECIDED_BY_MARKETPLACE : () => resolveVersionFromNpmRegistry(npmPackage);
+}
+function createCatalogIntegration(entry, deps) {
+  return {
+    id: entry.id,
+    displayName: entry.displayName,
+    homepage: entry.homepage,
+    repository: entry.repository,
+    license: entry.license,
+    supportedEnvironments: PLUGIN_HOSTS.filter((host) => entry.hosts[host] !== void 0),
+    detect: (context) => detectWorkspacePackage(entry, context),
+    plan: createClaudeMarketplacePlan(entry, { resolveVersion: deps.resolveVersion ?? defaultResolveVersion(entry) }),
+    install: createClaudeMarketplaceInstall(entry, { runner: deps.runner }),
+    verify: createClaudeMarketplaceVerifier(entry, { runner: deps.runner }),
+    uninstallInstructions: async () => [...entry.uninstallSteps]
+  };
+}
+function createCatalogIntegrations(deps) {
+  return PLUGIN_CATALOG.map((entry) => createCatalogIntegration(entry, deps));
+}
+
+// src/runtime/node-command-runner.ts
+import { spawn } from "node:child_process";
+var KILL_GRACE_MS = 500;
+var NodeCommandRunner = class {
+  run(input) {
+    return new Promise((resolve2, reject) => {
+      let stdout = "";
+      let stderr = "";
+      let timedOut = false;
+      let outputExceeded = false;
+      let settled = false;
+      let killTimer;
+      const spawnable = spawnableCommand(input.executable, input.argv);
+      const child = spawn(spawnable.command, spawnable.args, {
+        cwd: input.cwd,
+        shell: false,
+        windowsVerbatimArguments: spawnable.windowsVerbatimArguments,
+        windowsHide: true,
+        // No stdin: nothing here ever answers a prompt (a command that wants
+        // confirmation must fail fast instead of waiting on an open pipe).
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      const terminate = () => {
+        child.kill("SIGTERM");
+        killTimer = setTimeout(() => {
+          child.kill("SIGKILL");
+        }, KILL_GRACE_MS);
+      };
+      const timer = setTimeout(() => {
+        timedOut = true;
+        terminate();
+      }, input.timeoutMs);
+      child.stdout.on("data", (chunk) => {
+        stdout += chunk.toString("utf8");
+        if (Buffer.byteLength(stdout, "utf8") > input.stdoutLimitBytes) {
+          outputExceeded = true;
+          terminate();
+        }
+      });
+      child.stderr.on("data", (chunk) => {
+        stderr += chunk.toString("utf8");
+        if (Buffer.byteLength(stderr, "utf8") > input.stderrLimitBytes) {
+          outputExceeded = true;
+          terminate();
+        }
+      });
+      child.on("error", (error) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        clearTimeout(killTimer);
+        reject(error);
+      });
+      child.on("close", (code) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        clearTimeout(killTimer);
+        resolve2({ stdout, stderr, exitCode: code, timedOut, outputExceeded });
+      });
+    });
+  }
+};
+
+// src/runtime/integrations-composition-root.ts
+function createIntegrationsCompositionRoot(deps = {}) {
+  const runner = deps.runner ?? new NodeCommandRunner();
+  const registry = createIntegrationRegistry(createCatalogIntegrations({ runner, resolveVersion: deps.resolveVersion }));
+  return {
+    registry,
+    runner,
+    getIntegration: (id) => getIntegration(registry, id),
+    listIntegrations: () => listIntegrations(registry)
+  };
+}
+
+// src/generators/shared/run-nx.ts
+import { existsSync as existsSync10, readFileSync as readFileSync8 } from "node:fs";
+import { join as join10 } from "node:path";
+
+// src/generators/shared/toolkit-config-file.ts
+var TOOLKIT_CONFIG_PATH = "toolkit.config.json";
+function recordedChoice(config, key, allowed) {
+  const value = config?.[key];
+  return typeof value === "string" && allowed.includes(value) ? value : void 0;
+}
+var RECORDED_PACKAGE_MANAGERS = ["pnpm", "npm", "yarn", "bun"];
+function workspacePackageManager(exists, read, config) {
+  return detectWorkspacePackageManager(exists, read) ?? recordedChoice(config, "packageManager", RECORDED_PACKAGE_MANAGERS) ?? null;
+}
+
+// src/generators/shared/run-nx.ts
+function runNxFor(exists, read) {
+  let config = null;
+  try {
+    const parsed = JSON.parse(read(TOOLKIT_CONFIG_PATH) ?? "null");
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) config = parsed;
+  } catch {
+  }
+  return packageManagerCommands(workspacePackageManager(exists, read, config) ?? "pnpm").runNx;
+}
+function diskRunNx(root) {
+  return runNxFor(
+    (path) => existsSync10(join10(root, path)),
+    (path) => existsSync10(join10(root, path)) ? readFileSync8(join10(root, path), "utf-8") : void 0
+  );
+}
+
+// src/generators/doctor/integration-report.ts
+var DOCTOR_TARGET_ENVIRONMENT = "claude-code";
+async function buildDoctorReportWithIntegrations(root, options = {}, deps = {}) {
+  const integrationsRoot = deps.integrationsRoot ?? createIntegrationsCompositionRoot();
+  const baseReport = runDoctorChecks(root);
+  const declaredIds = readEnabledIntegrationIds(root);
+  const runNx = diskRunNx(root);
+  const driftResults = await detectIntegrationsDrift({
+    workspaceRoot: root,
+    targetEnvironment: DOCTOR_TARGET_ENVIRONMENT,
+    declaredIds,
+    integrations: integrationsRoot.listIntegrations(),
+    runNx
+  });
+  const finalDriftResults = options.liveIntegrations ? await applyLiveVerification(driftResults, {
+    root,
+    declaredIds,
+    runner: integrationsRoot.runner,
+    runNx
+  }) : driftResults;
+  const integrationChecks = buildIntegrationDoctorChecks(finalDriftResults);
+  const checks = [...baseReport.checks, ...integrationChecks];
+  return { checks, overallStatus: computeOverallStatus(checks) };
+}
+async function applyLiveVerification(driftResults, ctx) {
+  const context = { workspaceRoot: ctx.root, targetEnvironment: DOCTOR_TARGET_ENVIRONMENT };
+  const manifest = loadManifest(ctx.root);
+  const live = /* @__PURE__ */ new Map();
+  const reported = new Set(driftResults.map((result) => result.id));
+  for (const entry of PLUGIN_CATALOG) {
+    if (!reported.has(entry.id) || entry.hosts[DOCTOR_TARGET_ENVIRONMENT] === void 0) continue;
+    const existingEntry = manifest.integrations[entry.id];
+    const detected = await detectWorkspacePackage(entry, context);
+    const { result: liveVerification } = await verifyClaudeMarketplacePlugin(entry, { runner: ctx.runner }, context);
+    const liveEntry = existingEntry ? { ...existingEntry, verification: liveVerification.verified ? "passed" : "failed" } : existingEntry;
+    live.set(
+      entry.id,
+      classifyIntegrationDrift({
+        id: entry.id,
+        installable: true,
+        declared: ctx.declaredIds.includes(entry.id),
+        manifestEntry: liveEntry,
+        detected,
+        runNx: ctx.runNx
+      })
+    );
+  }
+  return driftResults.map((result) => live.get(result.id) ?? result);
+}
+
+// src/generators/doctor/generator.ts
+async function doctorGenerator(tree, options) {
+  const report = await buildDoctorReportWithIntegrations(tree.root, {
+    liveIntegrations: options.liveIntegrations ?? false
+  });
+  if (options.json ?? false) {
+    console.log(serializeDoctorReport(report).trimEnd());
+    return;
+  }
+  console.log(renderDoctorReport(report));
+  console.log("\n(read-only \u2014 no files were changed)");
+}
+var generator_default = doctorGenerator;
+export {
+  generator_default as default,
+  doctorGenerator
+};