@clearlydev/nx-archweave 0.1.1 → 0.2.1

package/dist/generators/doctor/generator.js

@@ -169,7 +169,7 @@ 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 { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2 } from "node:fs";
 import { join as join2 } from "node:path";
 
 // ../review-policy/dist/modes/review-modes.js
@@ -291,6 +291,20 @@ function buildOverEngineeringPrompt(locale) {
 // ../review-policy/dist/verdict-gate/verdict-gate.js
 var ROUND_MARKER = "<!-- archweave-review-round -->";
 
+// ../template-engine/dist/review/action-pins.js
+var ACTION_PINS = {
+  "actions/checkout": "actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1",
+  "actions/setup-node": "actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0",
+  "pnpm/action-setup": "pnpm/action-setup@ea17c68df8912ef543352723c149a84f56e3d413 # v6.1.0",
+  "oven-sh/setup-bun": "oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2.2.0",
+  "anthropics/claude-code-action": "anthropics/claude-code-action@6b6870e649b5ff408753befeaee5fc7989d4e6a9 # v1.0.258",
+  "google-github-actions/run-gemini-cli": "google-github-actions/run-gemini-cli@f77273f4c914e4bf38440cf36a0369cb64a37489 # v0.1.22",
+  "openai/codex-action": "openai/codex-action@bdf19a4a223ec2549a3e2274a0cf61556bc07675 # v1.13"
+};
+function pinnedUses(action) {
+  return ACTION_PINS[action];
+}
+
 // ../template-engine/dist/review/workflow-skeleton.js
 function indentBlock(text, spaces) {
   const pad = " ".repeat(spaces);
@@ -309,6 +323,17 @@ function renderConcurrencyBlock() {
 function renderPermissionsBlock() {
   return ["permissions:", "  contents: read", "  pull-requests: write", "  id-token: write"].join("\n");
 }
+function renderCheckoutStep(gateCondition, extraWith = []) {
+  return [
+    "- name: Checkout repository",
+    `  if: ${gateCondition}`,
+    `  uses: ${pinnedUses("actions/checkout")}`,
+    "  with:",
+    ...extraWith.map((line) => `    ${line}`),
+    "    fetch-depth: 1",
+    "    persist-credentials: false"
+  ].join("\n");
+}
 function renderSecretGateStep(secretName) {
   return [
     "- name: Check review secret",
@@ -332,7 +357,7 @@ function renderRoundGateStep(maxRounds) {
     "  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')`,
+    `    counts=$(gh api "repos/\${{ github.repository }}/issues/\${{ github.event.pull_request.number }}/comments" --paginate --jq '[([.[] | select(.user.type == "Bot") | 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`,
@@ -364,8 +389,7 @@ function renderVerdictGateStep(maxRounds, locale) {
   ].join("\n");
 }
 var SETUP_NODE_VERSION = "22";
-var SETUP_PNPM_VERSION = "10";
-var SETUP_BUN_ACTION = "oven-sh/setup-bun@v2";
+var FALLBACK_PNPM_VERSION = "10";
 var INSTALL_LINES = {
   pnpm: ["    pnpm install --frozen-lockfile"],
   npm: ["    npm ci"],
@@ -375,19 +399,39 @@ var INSTALL_LINES = {
   ],
   bun: ["    bun install --frozen-lockfile"]
 };
+function renderPnpmVersionStep(gate) {
+  return [
+    "- name: Detect pnpm version",
+    "  id: pnpm-version",
+    gate,
+    "  run: |",
+    `    if [ -n "$(jq -r '.packageManager // empty' package.json)" ]; then`,
+    '      echo "version=" >> "$GITHUB_OUTPUT"',
+    "    else",
+    `      echo "version=${FALLBACK_PNPM_VERSION}" >> "$GITHUB_OUTPUT"`,
+    "    fi"
+  ].join("\n");
+}
 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"));
+    steps.push(renderPnpmVersionStep(gate));
+    steps.push([
+      "- name: Set up pnpm",
+      gate,
+      `  uses: ${pinnedUses("pnpm/action-setup")}`,
+      "  with:",
+      "    version: ${{ steps.pnpm-version.outputs.version }}"
+    ].join("\n"));
   }
   if (packageManager === "bun") {
-    steps.push(["- name: Set up bun", gate, `  uses: ${SETUP_BUN_ACTION}`].join("\n"));
+    steps.push(["- name: Set up bun", gate, `  uses: ${pinnedUses("oven-sh/setup-bun")}`].join("\n"));
   }
   steps.push([
     "- name: Set up Node",
     gate,
-    "  uses: actions/setup-node@v4",
+    `  uses: ${pinnedUses("actions/setup-node")}`,
     "  with:",
     `    node-version: ${SETUP_NODE_VERSION}`,
     // yarn: no setup-node cache — it would query the runner's global yarn 1 even in a
@@ -439,17 +483,11 @@ 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"),
+    renderCheckoutStep("steps.secret-gate.outputs.enabled == 'true' && steps.round-gate.outputs.allowed == 'true'"),
     [
       "- name: Run Claude review",
       "  if: steps.secret-gate.outputs.enabled == 'true' && steps.round-gate.outputs.allowed == 'true'",
-      "  uses: anthropics/claude-code-action@v1",
+      `  uses: ${pinnedUses("anthropics/claude-code-action")}`,
       "  with:",
       `    claude_code_oauth_token: \${{ secrets.${SECRET_NAME} }}`,
       "    prompt: |",
@@ -519,13 +557,7 @@ function buildWorkflowYaml2(input) {
   const steps = [
     renderSecretGateStep(SECRET_NAME2),
     renderRoundGateStep(input.maxRounds),
-    [
-      "- name: Checkout repository",
-      `  if: ${gateCondition}`,
-      "  uses: actions/checkout@v4",
-      "  with:",
-      "    fetch-depth: 1"
-    ].join("\n"),
+    renderCheckoutStep(gateCondition),
     [
       "- name: Install cursor-agent CLI",
       `  if: ${gateCondition}`,
@@ -605,17 +637,11 @@ 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"),
+    renderCheckoutStep("steps.secret-gate.outputs.enabled == 'true' && steps.round-gate.outputs.allowed == 'true'"),
     [
       "- 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",
+      `  uses: ${pinnedUses("google-github-actions/run-gemini-cli")}`,
       "  env:",
       "    GITHUB_TOKEN: ${{ github.token }}",
       "  with:",
@@ -684,15 +710,7 @@ function buildWorkflowYaml4(input) {
   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"),
+    renderCheckoutStep(gateCondition, ["ref: refs/pull/${{ github.event.pull_request.number }}/merge"]),
     [
       "- name: Fetch base and head refs for the PR",
       `  if: ${gateCondition}`,
@@ -710,7 +728,7 @@ function buildWorkflowYaml4(input) {
       "- name: Run Codex review",
       "  id: codex-review",
       `  if: ${gateCondition}`,
-      "  uses: openai/codex-action@v1",
+      `  uses: ${pinnedUses("openai/codex-action")}`,
       "  with:",
       `    openai-api-key: \${{ secrets.${SECRET_NAME4} }}`,
       '    permission-profile: ":read-only"',
@@ -830,27 +848,88 @@ function validateReviewConfig(review) {
 var REVIEW_CHECK_IDS = [
   "review-workflow-present",
   "review-alt-file-coexistence",
-  "review-config-consistency"
+  "review-config-consistency",
+  "review-workflow-providers",
+  "review-workflow-pnpm"
 ];
+var WORKFLOWS_DIR = ".github/workflows";
+function archweaveWorkflows(root) {
+  let names;
+  try {
+    names = readdirSync(join2(root, WORKFLOWS_DIR));
+  } catch {
+    return [];
+  }
+  return names.filter((name) => /\.ya?ml$/.test(name)).map((name) => `${WORKFLOWS_DIR}/${name}`).filter((path) => readFileSync2(join2(root, path), "utf-8").includes(ROUND_MARKER)).sort();
+}
+function providerOfWorkflow(path) {
+  const main = path.replace(/\.archweave\.yml$/, ".yml");
+  return Object.values(REVIEW_PROVIDERS).find((provider) => provider.workflowFileName === main)?.id ?? null;
+}
+function buildReviewProvidersCheck(workflows) {
+  const id = "review-workflow-providers";
+  const label = "One review provider";
+  const providers = new Set(workflows.map(providerOfWorkflow).filter((provider) => provider !== null));
+  if (workflows.length === 0)
+    return createDoctorCheck({ id, label, status: "not-applicable", message: "no nx-archweave review workflow", evidence: [] });
+  if (providers.size <= 1)
+    return createDoctorCheck({ id, label, status: "pass", message: "one provider's review workflow", evidence: workflows });
+  return createDoctorCheck({
+    id,
+    label,
+    status: "warning",
+    message: `review workflows of ${providers.size} providers (${[...providers].join(", ")}) \u2014 each runs on every pull request`,
+    evidence: workflows,
+    suggestedAction: "Delete the workflow of the provider you no longer use."
+  });
+}
+function buildReviewPnpmCheck(root, workflows) {
+  const id = "review-workflow-pnpm";
+  const label = "Review workflow pnpm setup";
+  const fixed = workflows.filter((path) => /pnpm\/action-setup@[^\n]*\n\s*with:\s*\n\s*version:\s*['"]?\d/.test(readFileSync2(join2(root, path), "utf-8")));
+  if (fixed.length === 0)
+    return createDoctorCheck({ id, label, status: "not-applicable", message: "no review workflow pins a pnpm version", evidence: [] });
+  let packageManager;
+  try {
+    packageManager = JSON.parse(readFileSync2(join2(root, "package.json"), "utf-8"))["packageManager"];
+  } catch {
+    packageManager = void 0;
+  }
+  if (typeof packageManager !== "string") {
+    return createDoctorCheck({ id, label, status: "pass", message: "the workflow pins pnpm and package.json has no packageManager field", evidence: fixed });
+  }
+  return createDoctorCheck({
+    id,
+    label,
+    status: "warning",
+    message: `the review workflow pins a pnpm version while package.json says "${packageManager}" \u2014 pnpm/action-setup fails on the mismatch`,
+    evidence: fixed,
+    suggestedAction: "Regenerate the workflow: nx g @clearlydev/nx-archweave:add-review --onConflict=overwrite."
+  });
+}
 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));
+  const workflows = archweaveWorkflows(root);
+  const mainIsOurs = workflows.includes(mainWorkflowPath);
   return [
-    buildReviewWorkflowPresentCheck(mainWorkflowPath, mainExists, config),
+    buildReviewWorkflowPresentCheck(mainWorkflowPath, mainExists, mainIsOurs, config),
     buildReviewAltFileCoexistenceCheck(mainWorkflowPath, altWorkflowPath, mainExists, altExists),
-    buildReviewConfigConsistencyCheck(root, mainWorkflowPath, mainExists, config)
+    buildReviewConfigConsistencyCheck(root, mainWorkflowPath, mainExists, config),
+    buildReviewProvidersCheck(workflows),
+    buildReviewPnpmCheck(root, workflows)
   ];
 }
-function buildReviewWorkflowPresentCheck(mainWorkflowPath, mainExists, config) {
+function buildReviewWorkflowPresentCheck(mainWorkflowPath, mainExists, mainIsOurs, config) {
   if (mainExists) {
     return createDoctorCheck({
       id: "review-workflow-present",
       label: "Review workflow installed",
       status: "pass",
-      message: `${mainWorkflowPath} found`,
+      message: mainIsOurs ? `${mainWorkflowPath} found (generated by nx-archweave)` : `${mainWorkflowPath} found, but not generated by nx-archweave (it has no review round marker) \u2014 doctor reports on it, add-review proposes changes to it but never overwrites it`,
       evidence: [mainWorkflowPath]
     });
   }
@@ -970,12 +1049,30 @@ function buildReviewConfigConsistencyCheck(root, mainWorkflowPath, mainExists, c
 }
 
 // ../template-engine/dist/doctor/backend-checks.js
-import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3 } from "node:fs";
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "node:fs";
 import { join as join3 } from "node:path";
 
 // ../template-engine/dist/backend/eslint-boundaries.js
+var DEFAULT_BOUNDARY_TAGS = { frontend: "scope:frontend", backend: "scope:backend", shared: "scope:shared" };
+function readBoundaryTags(config) {
+  const boundaries = config?.["boundaries"];
+  const tags = typeof boundaries === "object" && boundaries !== null ? boundaries["tags"] : void 0;
+  const pick = (role) => {
+    const value = typeof tags === "object" && tags !== null ? tags[role] : void 0;
+    return typeof value === "string" && value.trim() !== "" ? value : DEFAULT_BOUNDARY_TAGS[role];
+  };
+  return { frontend: pick("frontend"), backend: pick("backend"), shared: pick("shared") };
+}
+function scopeConstraints(tags = DEFAULT_BOUNDARY_TAGS) {
+  return [
+    { sourceTag: tags.frontend, notDependOnLibsWithTags: [tags.backend] },
+    { sourceTag: tags.backend, notDependOnLibsWithTags: [tags.frontend] },
+    { sourceTag: tags.shared, notDependOnLibsWithTags: [tags.frontend, tags.backend] }
+  ];
+}
+var SCOPE_CONSTRAINTS = scopeConstraints();
 var ESLINT_CONFIG_CANDIDATES = ["eslint.config.mjs", "eslint.config.js", "eslint.config.cjs"];
-var APPLIED_MARKER = "sourceTag: 'scope:frontend'";
+var appliedMarker = (tags) => `sourceTag: '${tags.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("");
@@ -1028,19 +1125,34 @@ function findAllowAllMatches(masked) {
   }
   return matches;
 }
-function classifyBoundaryConstraints(configText) {
+function classifyBoundaryConstraints(configText, tags = DEFAULT_BOUNDARY_TAGS) {
   const masked = maskComments(configText);
-  if (masked.includes(APPLIED_MARKER))
+  if (masked.includes(appliedMarker(tags)))
     return "enforced";
   if (findAllowAllMatches(masked).length > 0)
     return "allow-all";
   return "unknown";
 }
 
+// ../templates/dist/fsd/fsd-eslint.js
+var FSD_ESLINT_MODULE = "@clearlydev/nx-archweave/eslint";
+
+// ../template-engine/dist/backend/compose-backend-wiring.js
+var DEFAULT_SHARED_TYPES_ROOT = "libs/shared-types";
+function readSharedTypesConfig(config) {
+  const value = config?.["sharedTypes"];
+  if (value === false)
+    return false;
+  if (typeof value !== "object" || value === null)
+    return { path: DEFAULT_SHARED_TYPES_ROOT };
+  const record = value;
+  const path = typeof record["path"] === "string" && record["path"].trim() !== "" ? record["path"].replace(/\/+$/, "") : DEFAULT_SHARED_TYPES_ROOT;
+  const importPath = typeof record["importPath"] === "string" && record["importPath"].trim() !== "" ? record["importPath"] : void 0;
+  return importPath === void 0 ? { path } : { path, importPath };
+}
+
 // ../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",
@@ -1055,11 +1167,13 @@ var CHECK_LABELS = {
   "boundary-constraints-applied": "Module-boundary constraints",
   "boundary-tags-exist": "Boundary tags exist"
 };
-function collectScopeTags(root) {
+function collectScopeTags(root, projects) {
+  if (projects !== void 0)
+    return new Set(projects.flatMap((project) => project.tags));
   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}`);
+      return readdirSync2(join3(root, rel), { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => `${rel}/${entry.name}`);
     } catch {
       return [];
     }
@@ -1098,6 +1212,14 @@ function collectScopeTags(root) {
 function notApplicable(message) {
   return BACKEND_CHECK_IDS.map((id) => createDoctorCheck({ id, label: CHECK_LABELS[id], status: "not-applicable", message, evidence: [] }));
 }
+function readConfigObject(root) {
+  try {
+    const parsed = JSON.parse(readFileSync3(join3(root, CONFIG_PATH2), "utf-8"));
+    return typeof parsed === "object" && parsed !== null ? parsed : null;
+  } catch {
+    return null;
+  }
+}
 function readsBackendOnly(root) {
   try {
     return JSON.parse(readFileSync3(join3(root, CONFIG_PATH2), "utf-8")).frontend === "none";
@@ -1121,7 +1243,7 @@ function readConfiguredBackend(root) {
     return null;
   }
 }
-function buildBackendChecks(root) {
+function buildBackendChecks(root, projects) {
   const backend = readConfiguredBackend(root);
   if (backend === null) {
     return notApplicable("Skipped \u2014 no backend configured in toolkit.config.json");
@@ -1143,21 +1265,21 @@ function buildBackendChecks(root) {
       suggestedAction: "Fix the backend field, then re-run doctor."
     }));
   } else {
-    let hasDependency = false;
+    let hasDependency2 = 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]);
+      hasDependency2 = Boolean(pkg.dependencies?.[packageName] ?? pkg.devDependencies?.[packageName]);
     } catch {
-      hasDependency = false;
+      hasDependency2 = 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."
+      status: hasDependency2 ? "pass" : "warning",
+      message: hasDependency2 ? `${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: hasDependency2 ? ["package.json"] : [],
+      suggestedAction: hasDependency2 ? void 0 : "Run the official generator commands shown by add-backend."
     }), createDoctorCheck({
       id: "backend-config-consistency",
       label: CHECK_LABELS["backend-config-consistency"],
@@ -1166,23 +1288,37 @@ function buildBackendChecks(root) {
       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 config = readConfigObject(root);
+  const sharedTypesConfig = readSharedTypesConfig(config);
+  if (sharedTypesConfig === false) {
+    checks.push(createDoctorCheck({
+      id: "shared-types-lib",
+      label: CHECK_LABELS["shared-types-lib"],
+      status: "not-applicable",
+      message: "no shared-types lib (sharedTypes: false in toolkit.config.json)",
+      evidence: [CONFIG_PATH2]
+    }));
+  } else {
+    const current = `${sharedTypesConfig.path}/package.json`;
+    const legacy = `${sharedTypesConfig.path}/project.json`;
+    const sharedTypesCurrent = existsSync3(join3(root, current));
+    const sharedTypesLegacy = !sharedTypesCurrent && existsSync3(join3(root, legacy));
+    checks.push(createDoctorCheck({
+      id: "shared-types-lib",
+      label: CHECK_LABELS["shared-types-lib"],
+      status: sharedTypesCurrent || sharedTypesLegacy ? "pass" : "warning",
+      message: sharedTypesCurrent ? `${sharedTypesConfig.path} present` : sharedTypesLegacy ? `${sharedTypesConfig.path} present (legacy project.json shape)` : `${sharedTypesConfig.path} not found \u2014 run add-backend to wire it`,
+      evidence: sharedTypesCurrent ? [current] : sharedTypesLegacy ? [legacy] : []
+    }));
+  }
+  const boundaryTags = readBoundaryTags(config);
   const eslintPath = ESLINT_CONFIG_CANDIDATES.find((candidate) => existsSync3(join3(root, candidate)));
-  const classification = eslintPath ? classifyBoundaryConstraints(readFileSync3(join3(root, eslintPath), "utf-8")) : "unknown";
+  const classification = eslintPath ? classifyBoundaryConstraints(readFileSync3(join3(root, eslintPath), "utf-8"), boundaryTags) : "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)",
+    message: classification === "enforced" ? `${boundaryTags.frontend} / ${boundaryTags.backend} 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."
   }));
@@ -1195,41 +1331,46 @@ function buildBackendChecks(root) {
       evidence: []
     }));
   } else {
-    const tags = collectScopeTags(root);
-    const required = readsBackendOnly(root) ? ["scope:backend"] : ["scope:frontend", "scope:backend"];
+    const tags = collectScopeTags(root, projects);
+    const required = readsBackendOnly(root) ? [boundaryTags.backend] : [boundaryTags.frontend, boundaryTags.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`,
+      message: missing.length === 0 ? required.length === 1 ? `${boundaryTags.backend} is carried by at least one project (backend-only workspace \u2014 no frontend to tag)` : `both ${boundaryTags.frontend} and ${boundaryTags.backend} are carried by at least one project` : `the toolkit's enforced deny rules reference ${missing.join(" and ")}, but no project ${projects === void 0 ? "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)."
+      suggestedAction: missing.length === 0 ? void 0 : "Add the missing 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 { existsSync as existsSync4, readdirSync as readdirSync3 } from "node:fs";
 import { join as join4 } from "node:path";
 var FSD_LAYERS = ["app", "_app", "pages", "_pages", "widgets", "features", "entities", "shared"];
-function buildFsdLikeCheck(root) {
+function conventionalSourceRoots(root) {
   const scanRoots = ["src"];
   try {
-    for (const entry of readdirSync2(join4(root, "apps"), { withFileTypes: true })) {
+    for (const entry of readdirSync3(join4(root, "apps"), { withFileTypes: true })) {
       if (entry.isDirectory())
         scanRoots.push(`apps/${entry.name}/src`);
     }
   } catch {
   }
-  const found = [];
+  return scanRoots;
+}
+function buildFsdLikeCheck(root, projects) {
+  const scanRoots = projects === void 0 ? conventionalSourceRoots(root) : [...new Set(projects.map((project) => project.sourceRoot))].sort();
+  let found = [];
   for (const scanRoot of scanRoots) {
     for (const layer of FSD_LAYERS) {
       if (existsSync4(join4(root, scanRoot, layer)))
-        found.push(`${scanRoot}/${layer}`);
+        found.push(scanRoot === "." || scanRoot === "" ? layer : `${scanRoot}/${layer}`);
     }
   }
+  found = found.sort();
   if (existsSync4(join4(root, "toolkit.config.json"))) {
     return createDoctorCheck({
       id: "fsd-like-structure",
@@ -1259,17 +1400,102 @@ function buildFsdLikeCheck(root) {
 }
 
 // ../template-engine/dist/doctor/fsd-enforcement-check.js
-import { existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync4 } from "node:fs";
+import { existsSync as existsSync5, readdirSync as readdirSync4, 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/frameworks/profiles.js
+var ALL_LAYERS = ["app", "pages", "features", "entities", "shared"];
+var NEXT = {
+  id: "next",
+  recognised: true,
+  // Next.js's own app/ (App Router) directory is the composition root; FSD's Next.js guide
+  // names the FSD app and pages layers _app and _pages, since Next.js reads src/app and
+  // src/pages as its routers.
+  layers: ["pages", "features", "entities", "shared"],
+  layerDirs: { app: "_app", pages: "_pages" },
+  buildOutputDirs: [".next", "out"],
+  platformSuffixes: [],
+  routerDirs: ["pages"]
+};
+var REACT_VITE = {
+  id: "react-vite",
+  recognised: true,
+  layers: ALL_LAYERS,
+  layerDirs: {},
+  buildOutputDirs: ["dist"],
+  platformSuffixes: [],
+  routerDirs: []
+};
+var EXPO_ROUTER = {
+  id: "expo",
+  recognised: true,
+  layers: ALL_LAYERS,
+  layerDirs: { app: "_app" },
+  buildOutputDirs: [".expo", "dist"],
+  platformSuffixes: ["ios", "android", "native", "web"],
+  routerDirs: []
+};
+var EXPO = { ...EXPO_ROUTER, layerDirs: {} };
+var GENERIC = {
+  id: "generic",
+  recognised: false,
+  layers: ALL_LAYERS,
+  layerDirs: {},
+  buildOutputDirs: ["dist", "build"],
+  platformSuffixes: [],
+  routerDirs: []
+};
+var NEXT_CONFIGS = ["next.config.js", "next.config.mjs", "next.config.ts", "next.config.cjs"];
+var VITE_CONFIGS = ["vite.config.ts", "vite.config.mts", "vite.config.js", "vite.config.mjs"];
+var EXPO_CONFIGS = ["app.config.ts", "app.config.js", "app.config.mjs"];
+function hasExpoKey(input, file) {
+  const text = input.read(file);
+  if (typeof text !== "string")
+    return false;
+  try {
+    return typeof JSON.parse(text)["expo"] === "object";
+  } catch {
+    return false;
+  }
+}
+function dependsOn(input, manifest, name) {
+  const text = input.read(manifest);
+  if (typeof text !== "string")
+    return false;
+  try {
+    const parsed = JSON.parse(text);
+    return ["dependencies", "devDependencies", "peerDependencies"].some((field) => parsed[field]?.[name] !== void 0);
+  } catch {
+    return false;
+  }
+}
+function detectFramework(input) {
+  const prefix = input.projectRoot === "" || input.projectRoot === "." ? "" : `${input.projectRoot}/`;
+  const executors = input.executors ?? [];
+  if (NEXT_CONFIGS.some((file) => input.exists(`${prefix}${file}`)) || executors.some((executor) => executor.startsWith("@nx/next:"))) {
+    return NEXT;
+  }
+  const dependsAnywhere = (name) => dependsOn(input, `${prefix}package.json`, name) || dependsOn(input, "package.json", name);
+  const usesExpo = executors.some((executor) => executor.startsWith("@nx/expo:")) || hasExpoKey(input, `${prefix}app.json`) || EXPO_CONFIGS.some((file) => input.exists(`${prefix}${file}`)) || dependsOn(input, `${prefix}package.json`, "expo");
+  if (usesExpo)
+    return dependsAnywhere("expo-router") ? EXPO_ROUTER : EXPO;
+  const usesReact = dependsAnywhere("react");
+  const usesVite = VITE_CONFIGS.some((file) => input.exists(`${prefix}${file}`)) || executors.some((executor) => executor.startsWith("@nx/vite:"));
+  if (usesVite && usesReact)
+    return REACT_VITE;
+  return GENERIC;
+}
 
 // ../template-engine/dist/fsd/fsd-eslint-config.js
 function classifyFsdEslintConfig(configText) {
   return maskComments(configText).includes(FSD_ESLINT_MODULE) ? "applied" : "absent";
 }
 
+// ../template-engine/dist/doctor/doctor-projects.js
+function projectPrefix(root) {
+  return root === "" || root === "." ? "" : `${root}/`;
+}
+
 // ../template-engine/dist/doctor/fsd-enforcement-check.js
 function fsdEnabledPerConfig(root) {
   const path = join5(root, "toolkit.config.json");
@@ -1286,10 +1512,14 @@ function fsdEnabledPerConfig(root) {
     return null;
   }
 }
-function eslintConfigPaths(root) {
+function eslintConfigPaths(root, projects) {
+  if (projects !== void 0) {
+    const dirs2 = ["", ...projects.map((project) => projectPrefix(project.root))];
+    return [...new Set(dirs2.flatMap((dir) => ESLINT_CONFIG_CANDIDATES.map((name) => `${dir}${name}`)))].filter((rel) => existsSync5(join5(root, rel)));
+  }
   const dirsIn = (rel) => {
     try {
-      return readdirSync3(join5(root, rel), { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => rel === "" ? entry.name : `${rel}/${entry.name}`);
+      return readdirSync4(join5(root, rel), { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => rel === "" ? entry.name : `${rel}/${entry.name}`);
     } catch {
       return [];
     }
@@ -1298,7 +1528,7 @@ function eslintConfigPaths(root) {
   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) {
+function buildFsdEnforcementCheck(root, projects) {
   const id = "fsd-enforcement-applied";
   const label = "FSD layer rule applied";
   const enabled = fsdEnabledPerConfig(root);
@@ -1311,7 +1541,7 @@ function buildFsdEnforcementCheck(root) {
       evidence: []
     });
   }
-  const applied = eslintConfigPaths(root).filter((rel) => classifyFsdEslintConfig(readFileSync4(join5(root, rel), "utf-8")) === "applied");
+  const applied = appliedFsdConfigs(root, projects);
   if (applied.length > 0) {
     return createDoctorCheck({ id, label, status: "pass", message: "the archweave/fsd-boundaries rule is wired into an ESLint config", evidence: applied });
   }
@@ -1324,11 +1554,35 @@ function buildFsdEnforcementCheck(root) {
     suggestedAction: "Run add-fsd-lite --applyEslint (or paste the snippet it prints into the frontend app's eslint.config.mjs)."
   });
 }
+function appliedFsdConfigs(root, projects) {
+  return eslintConfigPaths(root, projects).filter((rel) => classifyFsdEslintConfig(readFileSync4(join5(root, rel), "utf-8")) === "applied");
+}
+function buildFsdRuleAnchoredCheck(root, projects) {
+  const id = "fsd-rule-anchored";
+  const label = "FSD rule anchored to its config";
+  const applied = appliedFsdConfigs(root, projects);
+  if (applied.length === 0) {
+    return createDoctorCheck({ id, label, status: "not-applicable", message: "no ESLint config wires the FSD rule", evidence: [] });
+  }
+  const unanchored = applied.filter((rel) => !/fsdBoundaries\(\s*\{[^}]*\bcwd\s*:/s.test(maskComments(readFileSync4(join5(root, rel), "utf-8"))));
+  if (unanchored.length === 0) {
+    return createDoctorCheck({ id, label, status: "pass", message: "every FSD rule config passes cwd", evidence: applied });
+  }
+  return createDoctorCheck({
+    id,
+    label,
+    status: "warning",
+    message: "fsdBoundaries() is called without cwd \u2014 run from the workspace root or an editor, the rule checks no file",
+    evidence: unanchored,
+    suggestedAction: "Pass the config's own directory: fsdBoundaries({ severity, cwd: import.meta.dirname, root: '<source root>' })."
+  });
+}
 
 // ../template-engine/dist/doctor/run-doctor-checks.js
 var NOT_APPLICABLE_IDS = [
   "fsd-like-structure",
   "fsd-enforcement-applied",
+  "fsd-rule-anchored",
   "nx-version",
   "package-manager",
   "workspace-root",
@@ -1341,7 +1595,7 @@ var NOT_APPLICABLE_IDS = [
   ...REVIEW_CHECK_IDS,
   ...BACKEND_CHECK_IDS
 ];
-function runDoctorChecks(root) {
+function runDoctorChecks(root, projects) {
   const env = detectEnvironment(root);
   if (!env.hasNxWorkspace) {
     const checks2 = [
@@ -1372,8 +1626,9 @@ function runDoctorChecks(root) {
       evidence: ["nx.json"]
     }),
     buildNxVersionCheck(env),
-    buildFsdLikeCheck(root),
-    buildFsdEnforcementCheck(root),
+    buildFsdLikeCheck(root, projects),
+    buildFsdEnforcementCheck(root, projects),
+    buildFsdRuleAnchoredCheck(root, projects),
     createDoctorCheck({
       id: "package-manager",
       label: "Package manager",
@@ -1394,7 +1649,7 @@ function runDoctorChecks(root) {
     buildGithubTemplatesCheck(root),
     buildIntegrationManifestCheck(root),
     ...buildReviewChecks(root),
-    ...buildBackendChecks(root)
+    ...buildBackendChecks(root, projects)
   ];
   const overallStatus = computeOverallStatus(checks);
   return { checks, overallStatus };
@@ -2336,6 +2591,22 @@ import { join as join10 } from "node:path";
 
 // src/generators/shared/toolkit-config-file.ts
 var TOOLKIT_CONFIG_PATH = "toolkit.config.json";
+function readToolkitConfigFile(tree) {
+  const raw = tree.read(TOOLKIT_CONFIG_PATH, "utf-8");
+  if (raw === null) return { raw: null, parsed: null };
+  try {
+    const parsed = JSON.parse(raw);
+    return {
+      raw,
+      parsed: typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : null
+    };
+  } catch {
+    return { raw, parsed: null };
+  }
+}
+function readToolkitConfig(tree) {
+  return readToolkitConfigFile(tree).parsed;
+}
 function recordedChoice(config, key, allowed) {
   const value = config?.[key];
   return typeof value === "string" && allowed.includes(value) ? value : void 0;
@@ -2344,6 +2615,13 @@ var RECORDED_PACKAGE_MANAGERS = ["pnpm", "npm", "yarn", "bun"];
 function workspacePackageManager(exists, read, config) {
   return detectWorkspacePackageManager(exists, read) ?? recordedChoice(config, "packageManager", RECORDED_PACKAGE_MANAGERS) ?? null;
 }
+function recordedFrontends(config) {
+  const frontends = config?.["frontends"];
+  if (!Array.isArray(frontends)) return [];
+  return frontends.flatMap(
+    (entry) => typeof entry === "object" && entry !== null && typeof entry["project"] === "string" ? [entry.project] : []
+  );
+}
 
 // src/generators/shared/run-nx.ts
 function runNxFor(exists, read) {
@@ -2366,7 +2644,7 @@ function diskRunNx(root) {
 var DOCTOR_TARGET_ENVIRONMENT = "claude-code";
 async function buildDoctorReportWithIntegrations(root, options = {}, deps = {}) {
   const integrationsRoot = deps.integrationsRoot ?? createIntegrationsCompositionRoot();
-  const baseReport = runDoctorChecks(root);
+  const baseReport = runDoctorChecks(root, options.projects);
   const declaredIds = readEnabledIntegrationIds(root);
   const runNx = diskRunNx(root);
   const driftResults = await detectIntegrationsDrift({
@@ -2412,11 +2690,417 @@ async function applyLiveVerification(driftResults, ctx) {
   return driftResults.map((result) => live.get(result.id) ?? result);
 }
 
+// src/generators/doctor/workspace-checks.ts
+import { getProjects as getProjects2, joinPathFragments } from "@nx/devkit";
+
+// src/eslint/fsd-policy.ts
+var PRESETS = {
+  basic: {
+    sliceGroups: { auto: true, include: [], exclude: [] },
+    sharedPublicApi: "segment",
+    testFiles: false,
+    segments: [],
+    platformSuffixes: [],
+    routerDirs: []
+  },
+  practical: {
+    sliceGroups: { auto: true, include: [], exclude: [] },
+    sharedPublicApi: "file",
+    testFiles: ["**/*.{spec,test}.*", "**/__tests__/**"],
+    segments: [],
+    platformSuffixes: [],
+    routerDirs: []
+  }
+};
+var isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+function resolveFsdPolicy(recorded, overrides = {}) {
+  const fsd = typeof recorded === "object" && recorded !== null ? recorded : {};
+  const preset = fsd["preset"] === "practical" ? "practical" : "basic";
+  const policy = { ...PRESETS[preset] };
+  const groups = fsd["sliceGroups"];
+  if (groups === false) policy.sliceGroups = false;
+  else if (groups === "auto") policy.sliceGroups = { auto: true, include: [], exclude: [] };
+  else if (typeof groups === "object" && groups !== null) {
+    const value = groups;
+    policy.sliceGroups = {
+      auto: value["auto"] !== false,
+      include: isStringArray(value["include"]) ? value["include"] : [],
+      exclude: isStringArray(value["exclude"]) ? value["exclude"] : []
+    };
+  }
+  const shared = fsd["sharedPublicApi"];
+  if (shared === "segment" || shared === "component" || shared === "file") policy.sharedPublicApi = shared;
+  const tests = fsd["testFiles"];
+  if (tests === false || isStringArray(tests)) policy.testFiles = tests;
+  if (isStringArray(fsd["segments"])) policy.segments = fsd["segments"];
+  if (isStringArray(fsd["platformSuffixes"])) policy.platformSuffixes = fsd["platformSuffixes"];
+  if (isStringArray(fsd["routerDirs"])) policy.routerDirs = fsd["routerDirs"];
+  for (const [key, value] of Object.entries(overrides)) {
+    if (value !== void 0) policy[key] = value;
+  }
+  return policy;
+}
+
+// src/eslint/slice-groups.ts
+import { readdirSync as readdirSync5, statSync as statSync2 } from "node:fs";
+import { join as join11 } from "node:path";
+var SEGMENTS = [
+  "ui",
+  "model",
+  "api",
+  "lib",
+  "config",
+  "components",
+  "hooks",
+  "types",
+  "utils",
+  "helpers",
+  "constants",
+  "consts",
+  "store",
+  "stores",
+  "styles",
+  "assets",
+  "services",
+  "context"
+];
+var IGNORED = /^(\.|readme(\.|$))/i;
+var listings = /* @__PURE__ */ new Map();
+function list(dir) {
+  let mtimeMs;
+  try {
+    mtimeMs = statSync2(dir).mtimeMs;
+  } catch {
+    listings.delete(dir);
+    return null;
+  }
+  const cached = listings.get(dir);
+  if (cached !== void 0 && cached.mtimeMs === mtimeMs) return cached.entries;
+  try {
+    const entries = readdirSync5(dir, { withFileTypes: true }).map((entry) => ({ name: entry.name, directory: entry.isDirectory() }));
+    listings.set(dir, { mtimeMs, entries });
+    return entries;
+  } catch {
+    return null;
+  }
+}
+function createGroupDetector(rootAbsolute, policy, isIndexFile, listDirectory = list) {
+  const groups = policy.sliceGroups;
+  if (groups === false) return () => false;
+  const segments = /* @__PURE__ */ new Set([...SEGMENTS, ...policy.segments]);
+  return (layerDir, name) => {
+    const key = `${layerDir}/${name}`;
+    if (groups.include.includes(key)) return true;
+    if (groups.exclude.includes(key) || !groups.auto) return false;
+    const entries = listDirectory(join11(rootAbsolute, layerDir, name))?.filter((entry) => !IGNORED.test(entry.name)) ?? null;
+    if (entries === null || entries.length === 0) return false;
+    if (entries.some((entry) => !entry.directory || segments.has(entry.name))) return false;
+    return entries.some((entry) => listDirectory(join11(rootAbsolute, layerDir, name, entry.name))?.some((child) => !child.directory && isIndexFile(child.name)) ?? false);
+  };
+}
+
+// src/eslint/fsd-boundaries.ts
+function indexFilePattern(platformSuffixes) {
+  const platforms = platformSuffixes.length === 0 ? "" : `(\\.(${platformSuffixes.map((suffix) => suffix.replace(/[^a-z0-9-]/gi, "")).join("|")}))?`;
+  return new RegExp(`^index${platforms}(\\.[cm]?[jt]sx?)?$`);
+}
+var DEFAULT_POLICY = resolveFsdPolicy(void 0);
+
+// src/generators/shared/frontend-app.ts
+import { getProjects } from "@nx/devkit";
+
+// src/generators/shared/project-type.ts
+import { parseJson } from "@nx/devkit";
+function resolveProjectType(tree, root, declared) {
+  if (declared) return declared === "library" ? "library" : "application";
+  const prefix = root === "" || root === "." ? "" : `${root}/`;
+  if (tree.exists(`${prefix}tsconfig.lib.json`)) return "library";
+  if (tree.exists(`${prefix}tsconfig.app.json`)) return "application";
+  const raw = tree.read(`${prefix}package.json`, "utf-8");
+  if (raw === null) return "library";
+  try {
+    const manifest = parseJson(raw);
+    if (manifest && !["exports", "main", "module", "bin"].some((key) => Boolean(manifest[key]))) return "application";
+  } catch {
+  }
+  return "library";
+}
+
+// src/generators/shared/frontend-app.ts
+var baseNameOf = (root) => root.split("/").pop() ?? root;
+function isEndToEnd(root) {
+  const dir = baseNameOf(root);
+  return dir === "e2e" || dir.endsWith("-e2e");
+}
+function isBackend(root, config, backendTag) {
+  return baseNameOf(root) === "api" || (config.tags ?? []).includes(backendTag);
+}
+function prefixOf(root) {
+  return root === "" || root === "." ? "" : `${root}/`;
+}
+function sourceRootOf(tree, config) {
+  const prefix = prefixOf(config.root);
+  const declared = config.sourceRoot?.replace(/\/$/, "");
+  const atRoot = declared !== void 0 && (declared === config.root || prefix === "" && (declared === "." || declared === ""));
+  if (declared && !atRoot) return declared;
+  if (atRoot && !tree.exists(`${prefix}src`)) return prefix === "" ? "." : config.root;
+  return `${prefix}src`;
+}
+function frameworkOf(tree, config) {
+  return detectFramework({
+    exists: (path) => tree.exists(path),
+    read: (path) => tree.read(path, "utf-8"),
+    projectRoot: config.root,
+    executors: Object.values(config.targets ?? {}).flatMap((target) => target.executor ? [target.executor] : [])
+  });
+}
+function resolveFrontendApp(tree, explicitProject) {
+  let projects;
+  try {
+    projects = getProjects(tree);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const pathMatch = /Cannot parse ([^:]+):/.exec(message);
+    return { kind: "invalid-project-json", detail: pathMatch ? pathMatch[1] : message };
+  }
+  const found = (project2, config2) => {
+    const profile = frameworkOf(tree, config2);
+    return { kind: "found", project: project2, root: config2.root, sourceRoot: sourceRootOf(tree, config2), framework: profile.id, profile };
+  };
+  if (explicitProject !== void 0) {
+    const config2 = projects.get(explicitProject);
+    if (config2) return found(explicitProject, config2);
+    const rootApp = inferredRootApp(tree, projects);
+    return rootApp?.kind === "found" && rootApp.project === explicitProject ? rootApp : { kind: "not-found", project: explicitProject };
+  }
+  const backendTag = readBoundaryTags(readToolkitConfig(tree)).backend;
+  const eligible = [...projects.entries()].filter(([, config2]) => !isEndToEnd(config2.root) && !isBackend(config2.root, config2, backendTag));
+  const declared = eligible.filter(([, config2]) => config2.projectType === "application");
+  const inferred = eligible.filter(([, config2]) => {
+    if (config2.projectType !== void 0) return false;
+    if (config2.root === "" || config2.root === ".") return frameworkOf(tree, config2).recognised;
+    return resolveProjectType(tree, config2.root, void 0) === "application";
+  });
+  const candidates = (declared.length > 0 ? declared : inferred).sort(([a], [b]) => a.localeCompare(b));
+  if (candidates.length === 0) {
+    const rootApp = inferredRootApp(tree, projects);
+    if (rootApp !== null) return rootApp;
+    const otherProjects = [...projects.keys()].filter((name) => !isEndToEnd(projects.get(name)?.root ?? "")).sort();
+    return { kind: "none", otherProjects };
+  }
+  if (candidates.length > 1) return { kind: "ambiguous", candidates: candidates.map(([name]) => name) };
+  const [project, config] = candidates[0];
+  return found(project, config);
+}
+function inferredRootApp(tree, projects) {
+  if ([...projects.values()].some((config2) => config2.root === "" || config2.root === ".")) return null;
+  const raw = tree.read("package.json", "utf-8");
+  if (raw === null) return null;
+  let name;
+  try {
+    name = JSON.parse(raw).name;
+  } catch {
+    return null;
+  }
+  if (typeof name !== "string" || name === "") return null;
+  const config = { name, root: "." };
+  const framework = frameworkOf(tree, config);
+  if (!framework.recognised) return null;
+  return { kind: "found", project: name, root: ".", sourceRoot: sourceRootOf(tree, config), framework: framework.id, profile: framework, inferredRoot: true };
+}
+
+// src/generators/slice/core.ts
+function hasDependency(tree, manifest, name) {
+  const raw = tree.read(manifest, "utf-8");
+  if (raw === null) return false;
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed["dependencies"]?.[name] !== void 0 || parsed["devDependencies"]?.[name] !== void 0;
+  } catch {
+    return false;
+  }
+}
+function detectUnitTestRunner(tree, projectRoot) {
+  const prefix = projectRoot === "" || projectRoot === "." ? "" : `${projectRoot}/`;
+  const project = tree.read(`${prefix}project.json`, "utf-8");
+  if (project !== null) {
+    try {
+      const targets = JSON.parse(project).targets ?? {};
+      for (const target of Object.values(targets)) {
+        if (target?.executor?.startsWith("@nx/jest:")) return "jest";
+        if (target?.executor?.startsWith("@nx/vite:test") || target?.executor?.startsWith("@nx/vitest:")) return "vitest";
+      }
+    } catch {
+    }
+  }
+  for (const dir of prefix === "" ? [""] : [prefix, ""]) {
+    if (["ts", "mts", "cts", "js", "mjs", "cjs"].some((ext) => tree.exists(`${dir}jest.config.${ext}`))) return "jest";
+    if (["ts", "mts", "js", "mjs"].some((ext) => tree.exists(`${dir}vitest.config.${ext}`) || tree.exists(`${dir}vitest.workspace.${ext}`))) return "vitest";
+    for (const ext of ["ts", "mts", "js", "mjs"]) {
+      const vite = tree.read(`${dir}vite.config.${ext}`, "utf-8");
+      if (vite !== null && /\btest\s*:/.test(vite)) return "vitest";
+    }
+  }
+  for (const manifest of prefix === "" ? ["package.json"] : [`${prefix}package.json`, "package.json"]) {
+    if (hasDependency(tree, manifest, "vitest")) return "vitest";
+    if (hasDependency(tree, manifest, "jest")) return "jest";
+  }
+  return "none";
+}
+
+// src/generators/doctor/workspace-checks.ts
+function doctorProjects(tree) {
+  try {
+    return [...getProjects2(tree).entries()].map(([name, config]) => ({ name, root: config.root, sourceRoot: sourceRootOf(tree, config), tags: config.tags ?? [] })).sort((a, b) => a.name.localeCompare(b.name));
+  } catch {
+    return void 0;
+  }
+}
+var SLICED_LAYER_DIRS = ["pages", "_pages", "widgets", "features", "entities"];
+var SOURCE_FILE = /\.(?:[cm]?[jt]sx?)$/;
+var SCAN_LIMIT = 2e3;
+function sourceFiles(tree, dir, out = []) {
+  for (const name of tree.children(dir)) {
+    if (out.length >= SCAN_LIMIT) break;
+    if (name === "node_modules" || name.startsWith(".")) continue;
+    const path = joinPathFragments(dir, name);
+    if (tree.isFile(path)) {
+      if (SOURCE_FILE.test(name)) out.push(path);
+    } else {
+      sourceFiles(tree, path, out);
+    }
+  }
+  return out;
+}
+function buildWorkspaceChecks(tree) {
+  const config = readToolkitConfig(tree);
+  if (config?.["frontend"] === "none") return [];
+  const app = resolveFrontendApp(tree, void 0);
+  const recorded = recordedFrontends(config);
+  if (app.kind === "ambiguous" && app.candidates.every((name) => recorded.includes(name))) {
+    return [
+      createDoctorCheck({
+        id: "frontend-resolution",
+        label: "Frontend app",
+        status: "pass",
+        message: `${app.candidates.length} frontend apps, recorded in toolkit.config.json's frontends (pass --project to the slice generators)`,
+        evidence: app.candidates
+      })
+    ];
+  }
+  if (app.kind !== "found") {
+    const resolution = app.kind === "ambiguous" ? createDoctorCheck({
+      id: "frontend-resolution",
+      label: "Frontend app",
+      status: "warning",
+      message: `${app.candidates.length} frontend apps \u2014 the FSD generators and init need to be told which one`,
+      evidence: app.candidates,
+      suggestedAction: `Pass --project=<name> to add-fsd-lite and the slice generators (e.g. --project=${app.candidates[0]}).`
+    }) : app.kind === "none" ? createDoctorCheck({
+      id: "frontend-resolution",
+      label: "Frontend app",
+      status: "warning",
+      message: "no project was recognised as a frontend app",
+      evidence: app.otherProjects,
+      suggestedAction: app.otherProjects.length > 0 ? "If one of the listed projects is the app, pass --project=<name>." : "Create a frontend app (nx g @nx/react:app or @nx/next:app)."
+    }) : createDoctorCheck({
+      id: "frontend-resolution",
+      label: "Frontend app",
+      status: "error",
+      message: app.kind === "invalid-project-json" ? `a project file could not be parsed (${app.detail})` : `--project ${app.project} not found`,
+      evidence: []
+    });
+    return [resolution];
+  }
+  const checks = [
+    createDoctorCheck({
+      id: "frontend-resolution",
+      label: "Frontend app",
+      status: "pass",
+      message: `${app.project}${app.inferredRoot ? " (the workspace root package)" : ""} \u2014 FSD layers live in ${app.sourceRoot}`,
+      evidence: [app.project]
+    }),
+    app.framework === "generic" ? createDoctorCheck({
+      id: "framework-profile",
+      label: "Frontend framework",
+      status: "warning",
+      message: "framework not recognised \u2014 the common FSD rules apply, with no framework-specific layer names",
+      evidence: [app.project],
+      suggestedAction: "If it is React on Vite or Next.js, pass --frontend=react-vite|next (init records it)."
+    }) : createDoctorCheck({ id: "framework-profile", label: "Frontend framework", status: "pass", message: app.framework, evidence: [app.project] })
+  ];
+  const policy = resolveFsdPolicy(config?.["fsd"]);
+  if (policy.sliceGroups !== false) {
+    const lister = (dir) => tree.exists(dir) ? tree.children(dir).map((name) => ({ name, directory: !tree.isFile(joinPathFragments(dir, name)) })) : null;
+    const isGroup = createGroupDetector(app.sourceRoot, policy, (name) => indexFilePattern(policy.platformSuffixes).test(name), lister);
+    const groups = SLICED_LAYER_DIRS.flatMap(
+      (layer) => tree.exists(joinPathFragments(app.sourceRoot, layer)) ? tree.children(joinPathFragments(app.sourceRoot, layer)).filter((name) => isGroup(layer, name)).map((name) => `${layer}/${name}`) : []
+    );
+    checks.push(
+      createDoctorCheck({
+        id: "slice-groups",
+        label: "Slice groups",
+        status: "pass",
+        message: groups.length === 0 ? "no slice groups found" : `the FSD rule treats ${groups.length === 1 ? "this folder" : "these folders"} as groups of separate slices`,
+        evidence: groups
+      })
+    );
+  }
+  const runner = detectUnitTestRunner(tree, app.root);
+  checks.push(
+    runner === "none" ? createDoctorCheck({
+      id: "test-runner",
+      label: "Test runner",
+      status: "warning",
+      message: "no jest or vitest found \u2014 the slice generators write no .spec.ts",
+      evidence: [],
+      suggestedAction: "Add a test runner, or pass --unitTestRunner=jest|vitest to the slice generators."
+    }) : createDoctorCheck({ id: "test-runner", label: "Test runner", status: "pass", message: `${runner} \u2014 the slice generators write a .spec.ts`, evidence: [] })
+  );
+  checks.push(buildPolicySuggestion(tree, app.sourceRoot, policy.sharedPublicApi));
+  return checks;
+}
+function buildPolicySuggestion(tree, sourceRoot, current) {
+  const id = "fsd-policy-suggestion";
+  const label = "Shared public API";
+  let atSegment = 0;
+  let deeper = 0;
+  let examples = [];
+  for (const file of sourceFiles(tree, sourceRoot)) {
+    if (/(^|\/)shared\//.test(file.slice(sourceRoot.length))) continue;
+    const text = tree.read(file, "utf-8") ?? "";
+    for (const [, specifier] of text.matchAll(/\bfrom\s+['"]([^'"]+)['"]/g)) {
+      const match = /(?:^|\/|@\/)shared\/(.+)$/.exec(specifier);
+      if (match === null) continue;
+      const parts = match[1].split("/").filter((part) => part !== "" && !/^index(\.[\w.]+)?$/.test(part));
+      if (parts.length <= 1) atSegment++;
+      else {
+        deeper++;
+        if (examples.length < 3) examples = [...examples, specifier];
+      }
+    }
+  }
+  if (current !== "segment" || deeper === 0 || deeper < atSegment) {
+    return createDoctorCheck({ id, label, status: "pass", message: `sharedPublicApi: ${current} fits the imports found`, evidence: [] });
+  }
+  return createDoctorCheck({
+    id,
+    label,
+    status: "warning",
+    message: `${deeper} of ${deeper + atSegment} imports into shared reach past a segment's index \u2014 with sharedPublicApi: segment the FSD rule reports each`,
+    evidence: examples,
+    suggestedAction: 'If that is how this code is meant to be organised, set "fsd": { "sharedPublicApi": "file" } (or "component") in toolkit.config.json.'
+  });
+}
+
 // src/generators/doctor/generator.ts
 async function doctorGenerator(tree, options) {
-  const report = await buildDoctorReportWithIntegrations(tree.root, {
-    liveIntegrations: options.liveIntegrations ?? false
+  const base = await buildDoctorReportWithIntegrations(tree.root, {
+    liveIntegrations: options.liveIntegrations ?? false,
+    projects: doctorProjects(tree)
   });
+  const checks = base.overallStatus === "unsupported" ? base.checks : [...base.checks, ...buildWorkspaceChecks(tree)];
+  const report = { checks, overallStatus: base.overallStatus === "unsupported" ? base.overallStatus : computeOverallStatus(checks) };
   if (options.json ?? false) {
     console.log(serializeDoctorReport(report).trimEnd());
     return;