@clearlydev/nx-archweave 0.1.1 → 0.2.1

package/dist/generators/init/generator.js

@@ -243,6 +243,20 @@ function buildReviewConfigSnippet(input) {
   };
 }
 
+// ../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);
@@ -261,6 +275,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",
@@ -284,7 +309,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`,
@@ -316,8 +341,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"],
@@ -327,19 +351,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
@@ -391,17 +435,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: |",
@@ -471,13 +509,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}`,
@@ -557,17 +589,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:",
@@ -636,15 +662,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}`,
@@ -662,7 +680,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"',
@@ -737,13 +755,26 @@ function judgeReviewFileConflict(existing, generated) {
 }
 
 // ../template-engine/dist/backend/eslint-boundaries.js
-var SCOPE_CONSTRAINTS = [
-  { sourceTag: "scope:frontend", notDependOnLibsWithTags: ["scope:backend"] },
-  { sourceTag: "scope:backend", notDependOnLibsWithTags: ["scope:frontend"] },
-  { sourceTag: "scope:shared", notDependOnLibsWithTags: ["scope:frontend", "scope:backend"] }
-];
+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("");
@@ -796,17 +827,17 @@ 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";
 }
-function renderConstraintsBlock(indent, eol) {
-  const renderList = (tags) => tags.map((t) => `'${t}'`).join(", ");
-  const inner = SCOPE_CONSTRAINTS.map((c) => {
+function renderConstraintsBlock(indent, eol, tags) {
+  const renderList = (list) => list.map((t) => `'${t}'`).join(", ");
+  const inner = scopeConstraints(tags).map((c) => {
     const field = c.notDependOnLibsWithTags ? `notDependOnLibsWithTags: [${renderList(c.notDependOnLibsWithTags)}]` : `onlyDependOnLibsWithTags: [${renderList(c.onlyDependOnLibsWithTags ?? [])}]`;
     return [`${indent}  {`, `${indent}    sourceTag: '${c.sourceTag}',`, `${indent}    ${field},`, `${indent}  },`].join(eol);
   }).join(eol);
@@ -824,8 +855,8 @@ function renderConstraintsBlock(indent, eol) {
     `${indent}]`
   ].join(eol);
 }
-function applyBoundaryConstraints(configText) {
-  const classification = classifyBoundaryConstraints(configText);
+function applyBoundaryConstraints(configText, tags = DEFAULT_BOUNDARY_TAGS) {
+  const classification = classifyBoundaryConstraints(configText, tags);
   if (classification === "enforced")
     return { status: "already-applied" };
   if (classification === "unknown")
@@ -839,17 +870,17 @@ function applyBoundaryConstraints(configText) {
   const eol = configText.includes("\r\n") ? "\r\n" : "\n";
   const lineStart = configText.lastIndexOf("\n", match.index) + 1;
   const indent = /^[ \t]*/.exec(configText.slice(lineStart, match.index))?.[0] ?? "";
-  const replacement = renderConstraintsBlock(indent, eol);
+  const replacement = renderConstraintsBlock(indent, eol, tags);
   const text = configText.slice(0, match.index) + replacement + configText.slice(match.index + match.length);
   return { status: "applied", text };
 }
-function buildBoundarySnippet() {
+function buildBoundarySnippet(tags = DEFAULT_BOUNDARY_TAGS) {
   return [
     "// nx-archweave project boundaries \u2014 merge these entries into the depConstraints",
     "// array of the '@nx/enforce-module-boundaries' rule in your root ESLint config.",
     "// They ride on top of your existing entries: constraints apply conjunctively,",
     "// so the allow-all baseline can stay.",
-    renderConstraintsBlock("", "\n")
+    renderConstraintsBlock("", "\n", tags)
   ].join("\n");
 }
 
@@ -1140,25 +1171,53 @@ var AGENT_RULE_SECTIONS = {
   ko: KO_SECTIONS
 };
 
+// ../templates/dist/agents/fsd-policy-notes.js
+var NOTES = {
+  en: {
+    heading: "This workspace also configures:",
+    groups: "- A folder that only groups slices (`features/mypage/{order,claims}`) holds no code and no `index.ts`; each slice in it is separate, and slices in one group never import each other either. Create one with `--group=<name>`.",
+    component: "- `shared` exposes each component through its own `index.ts` (`shared/ui/button`); import that, not the files inside it.",
+    file: "- Inside `shared`, files may be imported directly (`shared/lib/format/currency`); `shared` still never imports a layer above it.",
+    tests: "- Test files (`*.spec.ts`, `*.test.ts`, `__tests__/`) may import another slice's internals; upward imports stay forbidden there too."
+  },
+  ko: {
+    heading: "\uC774 \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4\uB294 \uB2E4\uC74C\uB3C4 \uC124\uC815\uD588\uB2E4:",
+    groups: "- \uC2AC\uB77C\uC774\uC2A4\uB97C \uBB36\uAE30\uB9CC \uD558\uB294 \uD3F4\uB354(`features/mypage/{order,claims}`)\uC5D0\uB294 \uCF54\uB4DC\uB3C4 `index.ts`\uB3C4 \uB450\uC9C0 \uC54A\uB294\uB2E4. \uADF8 \uC548\uC758 \uC2AC\uB77C\uC774\uC2A4\uB294 \uAC01\uAC01 \uB3C5\uB9BD\uC774\uB77C, \uAC19\uC740 \uADF8\uB8F9 \uC548\uC5D0\uC11C\uB3C4 \uC11C\uB85C import\uD558\uC9C0 \uC54A\uB294\uB2E4. \uADF8\uB8F9 \uC548\uC5D0 \uB9CC\uB4E4 \uB54C\uB294 `--group=<\uC774\uB984>`\uC744 \uC4F4\uB2E4.",
+    component: "- `shared`\uB294 \uCEF4\uD3EC\uB10C\uD2B8\uB9C8\uB2E4 \uC790\uAE30 `index.ts`\uB85C \uACF5\uAC1C\uD55C\uB2E4(`shared/ui/button`). \uADF8 index\uB97C import\uD558\uACE0, \uC548\uCABD \uD30C\uC77C\uC5D0\uB294 \uB2FF\uC9C0 \uC54A\uB294\uB2E4.",
+    file: "- `shared` \uC548\uC758 \uD30C\uC77C\uC740 \uC9C1\uC811 import\uD574\uB3C4 \uB41C\uB2E4(`shared/lib/format/currency`). \uB2E4\uB9CC `shared`\uB294 \uC5EC\uC804\uD788 \uC704 \uB808\uC774\uC5B4\uB97C import\uD558\uC9C0 \uC54A\uB294\uB2E4.",
+    tests: "- \uD14C\uC2A4\uD2B8 \uD30C\uC77C(`*.spec.ts`, `*.test.ts`, `__tests__/`)\uC740 \uB2E4\uB978 \uC2AC\uB77C\uC774\uC2A4\uC758 \uB0B4\uBD80 \uD30C\uC77C\uC744 import\uD574\uB3C4 \uB41C\uB2E4. \uC704 \uB808\uC774\uC5B4 import\uB294 \uD14C\uC2A4\uD2B8\uC5D0\uC11C\uB3C4 \uAE08\uC9C0\uB2E4."
+  }
+};
+function buildFsdPolicyNotes(locale, notes) {
+  const text = NOTES[locale];
+  const lines = [
+    ...notes.sliceGroups ? [text.groups] : [],
+    ...notes.sharedPublicApi === "component" ? [text.component] : notes.sharedPublicApi === "file" ? [text.file] : [],
+    ...notes.testFiles ? [text.tests] : []
+  ];
+  return lines.length === 0 ? "" : [text.heading, ...lines].join("\n");
+}
+
 // ../templates/dist/fsd/fsd-eslint.js
 var FSD_ESLINT_MODULE = "@clearlydev/nx-archweave/eslint";
 function buildFsdEslintImportLine() {
   return `import { fsdBoundaries } from '${FSD_ESLINT_MODULE}';`;
 }
-function buildFsdEslintEntry(severity) {
-  return `...fsdBoundaries({ severity: '${severity}' }),`;
+function buildFsdEslintEntry(severity, root = "src", framework = {}) {
+  const list = (key, values) => values === void 0 || values.length === 0 ? "" : `, ${key}: [${values.map((value) => `'${value}'`).join(", ")}]`;
+  return `...fsdBoundaries({ severity: '${severity}', cwd: import.meta.dirname, root: '${root}'${list("platformSuffixes", framework.platformSuffixes)}${list("routerDirs", framework.routerDirs)} }),`;
 }
-function buildFsdEslintSnippet({ severity, locale }) {
+function buildFsdEslintSnippet({ severity, locale, root, framework }) {
   const lines = locale === "ko" ? [
     "// nx-archweave FSD \uB808\uC774\uC5B4 \uADDC\uCE59 \u2014 \uD504\uB860\uD2B8\uC5D4\uB4DC \uC571\uC758 eslint.config.mjs\uC5D0 \uC9C1\uC811 \uB123\uC73C\uC138\uC694:",
     "// 1) \uB9C8\uC9C0\uB9C9 import \uB4A4\uC5D0 \uC544\uB798 import\uB97C,",
-    "// 2) export default [...] \uBC30\uC5F4\uC758 \uB9C8\uC9C0\uB9C9 \uD56D\uBAA9\uC73C\uB85C \uC544\uB798 spread\uB97C \uCD94\uAC00\uD569\uB2C8\uB2E4."
+    "// 2) \uC124\uC815 \uBC30\uC5F4(export default [...], \uB610\uB294 export default \uD558\uB294 \uBCC0\uC218\uC758 \uBC30\uC5F4)\uC758 \uB9C8\uC9C0\uB9C9 \uD56D\uBAA9\uC73C\uB85C \uC544\uB798 spread\uB97C \uCD94\uAC00\uD569\uB2C8\uB2E4."
   ] : [
     "// nx-archweave FSD layer rules \u2014 add these to the frontend app's eslint.config.mjs yourself:",
     "// 1) the import after the last import,",
-    "// 2) the spread as the last element of the export default [...] array."
+    "// 2) the spread as the last element of the config array (export default [...], or the array your config exports by name)."
   ];
-  return [...lines, buildFsdEslintImportLine(), buildFsdEslintEntry(severity)].join("\n");
+  return [...lines, buildFsdEslintImportLine(), buildFsdEslintEntry(severity, root, framework)].join("\n");
 }
 var LAYER_GUIDE_EN = {
   app: "composition root: providers, routing, global styles (the framework entry point lives here)",
@@ -1204,7 +1263,7 @@ var FSD_CHECK_TARGET = "fsd-check";
 function buildFsdCheckTarget(sourceRootName = "src") {
   return { command: `steiger ${sourceRootName}`, options: { cwd: "{projectRoot}" } };
 }
-function buildSteigerConfig({ frontend, locale }) {
+function buildSteigerConfig({ renamedLayerDirs, locale }) {
   const ko = locale === "ko";
   const lines = [
     "import { defineConfig } from 'steiger';",
@@ -1217,8 +1276,8 @@ function buildSteigerConfig({ frontend, locale }) {
     "    rules: {",
     ko ? "      // \uC544\uBB34\uB3C4 \uCC38\uC870\uD558\uC9C0 \uC54A\uB294 \uC2AC\uB77C\uC774\uC2A4 = \uBC29\uAE08 \uC0DD\uC131\uD55C \uC2AC\uB77C\uC774\uC2A4. \uACBD\uACE0\uB85C \uBCF4\uC774\uB418 \uAC80\uC0AC\uB97C \uB9C9\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4." : "      // a slice nothing references yet is every freshly generated slice: visible, not blocking",
     "      'fsd/insignificant-slice': 'warn',",
-    ...frontend === "next" ? [
-      ko ? "      // Next.js: pages \uB808\uC774\uC5B4\uB294 _pages/ (FSD \uACF5\uC2DD Next.js \uAC00\uC774\uB4DC) \u2014 steiger 0.7\uC740 \uC544\uC9C1 \uC624\uD0C0\uB85C \uBD05\uB2C8\uB2E4." : "      // Next.js: the pages layer is _pages/ (FSD's own Next.js guide) \u2014 steiger 0.7 still reads it as a typo",
+    ...renamedLayerDirs.length > 0 ? [
+      ko ? `      // ${renamedLayerDirs.join(", ")}: \uD504\uB808\uC784\uC6CC\uD06C \uB77C\uC6B0\uD130\uC640 \uACB9\uCE58\uC9C0 \uC54A\uAC8C \uC774\uB984\uC744 \uBC14\uAFBC \uB808\uC774\uC5B4 (FSD \uACF5\uC2DD \uBA85\uBA85) \u2014 steiger 0.7\uC740 \uC544\uC9C1 \uC624\uD0C0\uB85C \uBD05\uB2C8\uB2E4.` : `      // ${renamedLayerDirs.join(", ")}: layers renamed out of the framework router's way (FSD's own naming) \u2014 steiger 0.7 still reads them as typos`,
       "      'fsd/typo-in-layer-name': 'off',"
     ] : [],
     "    },",
@@ -1245,7 +1304,7 @@ function sharedTypesApiTypesContent() {
     ""
   ].join("\n");
 }
-function sharedTypesPackageJsonContent(packageName) {
+function sharedTypesPackageJsonContent(packageName, sharedTag = "scope:shared") {
   return `${JSON.stringify({
     name: packageName,
     version: "0.0.1",
@@ -1262,13 +1321,296 @@ function sharedTypesPackageJsonContent(packageName) {
     },
     nx: {
       projectType: "library",
-      tags: ["scope:shared"],
+      tags: [sharedTag],
       targets: {}
     }
   }, null, 2)}
 `;
 }
 
+// ../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 };
+}
+function composeBackendWiring(input) {
+  const scoped = /^@([^/]+)\//.exec(input.workspaceName);
+  const scope = scoped ? `@${scoped[1]}` : `@${input.workspaceName.split("/").pop() || "workspace"}`;
+  const sharedTypesRoot = input.sharedTypes?.path ?? DEFAULT_SHARED_TYPES_ROOT;
+  const sharedTypesPackageName = input.sharedTypes?.importPath ?? `${scope}/shared-types`;
+  const tagByRole = input.tags ?? DEFAULT_BOUNDARY_TAGS;
+  return {
+    sharedTypesFiles: [
+      { filePath: `${sharedTypesRoot}/package.json`, content: sharedTypesPackageJsonContent(sharedTypesPackageName, tagByRole.shared) },
+      { filePath: `${sharedTypesRoot}/src/index.ts`, content: sharedTypesIndexContent() },
+      { filePath: `${sharedTypesRoot}/src/lib/api-types.ts`, content: sharedTypesApiTypesContent() }
+    ],
+    sharedTypesPackageName,
+    sharedTypesRoot,
+    tagByRole
+  };
+}
+function addSharedTypesNpmWorkspace(packageJsonText, entry = DEFAULT_SHARED_TYPES_ROOT) {
+  let parsed;
+  try {
+    parsed = JSON.parse(packageJsonText);
+  } catch {
+    return { status: "unrecognized" };
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+    return { status: "unrecognized" };
+  const pkg = parsed;
+  const field = pkg["workspaces"];
+  let target;
+  if (field === void 0) {
+    target = [];
+  } else if (Array.isArray(field)) {
+    target = field;
+  } else if (field !== null && typeof field === "object" && Array.isArray(field.packages)) {
+    target = field.packages;
+  } else {
+    return { status: "unrecognized" };
+  }
+  const parentGlob = `${entry.split("/").slice(0, -1).join("/")}/*`;
+  if (target.some((existing) => existing === entry || existing === parentGlob))
+    return { status: "present" };
+  const surgical = insertSharedTypesWorkspace(packageJsonText, field === void 0 ? "absent" : Array.isArray(field) ? "array" : "object", JSON.stringify(entry));
+  if (surgical !== null)
+    return { status: "added", text: surgical };
+  if (field === void 0)
+    pkg["workspaces"] = target;
+  target.push(entry);
+  const indent = /\n([ \t]+)"/.exec(packageJsonText)?.[1] ?? "  ";
+  const trailing = packageJsonText.endsWith("\n") ? "\n" : "";
+  return { status: "added", text: `${JSON.stringify(pkg, null, indent)}${trailing}` };
+}
+function skipJsonValue(text, start) {
+  if (text[start] === '"') {
+    let i = start + 1;
+    while (i < text.length && text[i] !== '"')
+      i += text[i] === "\\" ? 2 : 1;
+    return i + 1;
+  }
+  if (text[start] === "[" || text[start] === "{") {
+    let depth = 0;
+    let i = start;
+    while (i < text.length) {
+      const c = text[i];
+      if (c === '"') {
+        i = skipJsonValue(text, i);
+        continue;
+      }
+      if (c === "[" || c === "{")
+        depth++;
+      if (c === "]" || c === "}") {
+        depth--;
+        if (depth === 0)
+          return i + 1;
+      }
+      i++;
+    }
+    return -1;
+  }
+  const literal = /^[^,}\]\s]+/.exec(text.slice(start));
+  return literal ? start + literal[0].length : -1;
+}
+function objectMembers(text, open) {
+  const members = [];
+  let i = open + 1;
+  for (; ; ) {
+    while (/[\s,]/.test(text[i] ?? ""))
+      i++;
+    if (text[i] === "}")
+      return members;
+    if (text[i] !== '"')
+      return null;
+    const keyEnd = skipJsonValue(text, i);
+    const key = JSON.parse(text.slice(i, keyEnd));
+    i = keyEnd;
+    while (/\s/.test(text[i] ?? ""))
+      i++;
+    if (text[i] !== ":")
+      return null;
+    i++;
+    while (/\s/.test(text[i] ?? ""))
+      i++;
+    const valueEnd = skipJsonValue(text, i);
+    if (valueEnd === -1)
+      return null;
+    members.push({ key, valueStart: i, valueEnd });
+    i = valueEnd;
+  }
+}
+function appendToArray(text, open, close, eol, quoted) {
+  const inner = text.slice(open + 1, close - 1);
+  if (inner.trim() === "")
+    return `${text.slice(0, open + 1)}${quoted}${text.slice(close - 1)}`;
+  if (!inner.includes("\n")) {
+    const body = inner.replace(/\s+$/, "");
+    return `${text.slice(0, open + 1)}${body}, ${quoted}${inner.slice(body.length)}${text.slice(close - 1)}`;
+  }
+  const lastEntryLineStart = text.lastIndexOf("\n", open + 1 + inner.trimEnd().length - 1) + 1;
+  const itemIndent = /^[ \t]*/.exec(text.slice(lastEntryLineStart))?.[0] ?? "  ";
+  const bodyEnd = open + 1 + inner.trimEnd().length;
+  return `${text.slice(0, bodyEnd)},${eol}${itemIndent}${quoted}${text.slice(bodyEnd)}`;
+}
+function insertSharedTypesWorkspace(text, form, quoted) {
+  const eol = text.includes("\r\n") ? "\r\n" : "\n";
+  const rootOpen = text.indexOf("{");
+  if (rootOpen === -1)
+    return null;
+  const members = objectMembers(text, rootOpen);
+  if (members === null)
+    return null;
+  const workspaces = members.find((member) => member.key === "workspaces");
+  if (form === "absent") {
+    const last = members[members.length - 1];
+    const indent = /\n([ \t]+)"/.exec(text)?.[1] ?? "  ";
+    if (last === void 0) {
+      const close = skipJsonValue(text, rootOpen) - 1;
+      return `${text.slice(0, rootOpen + 1)}${eol}${indent}"workspaces": [${quoted}]${eol}${text.slice(close)}`;
+    }
+    return `${text.slice(0, last.valueEnd)},${eol}${indent}"workspaces": [${quoted}]${text.slice(last.valueEnd)}`;
+  }
+  if (workspaces === void 0)
+    return null;
+  if (form === "array") {
+    if (text[workspaces.valueStart] !== "[")
+      return null;
+    return appendToArray(text, workspaces.valueStart, workspaces.valueEnd, eol, quoted);
+  }
+  if (text[workspaces.valueStart] !== "{")
+    return null;
+  const packages = objectMembers(text, workspaces.valueStart)?.find((member) => member.key === "packages");
+  if (packages === void 0 || text[packages.valueStart] !== "[")
+    return null;
+  return appendToArray(text, packages.valueStart, packages.valueEnd, eol, quoted);
+}
+function addSharedTypesWorkspaceGlob(yamlText, entry = DEFAULT_SHARED_TYPES_ROOT) {
+  const escape = (value) => value.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+  const parentGlob = `${entry.split("/").slice(0, -1).join("/")}/*`;
+  if (new RegExp(`^\\s*-\\s*['"]?(${escape(entry)}|${escape(parentGlob)})['"]?\\s*$`, "m").test(yamlText)) {
+    return { status: "present" };
+  }
+  const lines = yamlText.split("\n");
+  const packagesIndex = lines.findIndex((line) => /^packages:\s*$/.test(line));
+  if (packagesIndex === -1)
+    return { status: "unrecognized" };
+  let lastEntry = packagesIndex;
+  for (let i = packagesIndex + 1; i < lines.length; i++) {
+    if (/^\s+-\s+\S/.test(lines[i])) {
+      lastEntry = i;
+    } else if (lines[i].trim() === "") {
+      continue;
+    } else {
+      break;
+    }
+  }
+  if (lastEntry === packagesIndex)
+    return { status: "unrecognized" };
+  const indent = /^(\s+)-/.exec(lines[lastEntry])?.[1] ?? "  ";
+  lines.splice(lastEntry + 1, 0, `${indent}- '${entry}'`);
+  return { status: "added", text: lines.join("\n") };
+}
+
+// ../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 PROFILES = { next: NEXT, "react-vite": REACT_VITE, expo: EXPO_ROUTER, generic: GENERIC };
+function profileById(id) {
+  return PROFILES[id];
+}
+function allFrameworkProfiles() {
+  return Object.values(PROFILES);
+}
+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";
@@ -1276,21 +1618,47 @@ function classifyFsdEslintConfig(configText) {
 var EXPORT_DEFAULT_ARRAY = /export\s+default\s+\[/g;
 var IMPORT_STATEMENT = /^import\b[^;]*?\bfrom\s+['"][^'"]+['"]\s*;?[ \t]*$/gm;
 var CLOSING_BRACKET = /\]\s*;?\s*$/;
-function applyFsdEslintConfig(configText, severity) {
+function closingBracketOf(masked, open) {
+  let depth = 0;
+  for (let i = open; i < masked.length; i++) {
+    const ch = masked[i];
+    if (ch === '"' || ch === "'" || ch === "`") {
+      for (i++; i < masked.length && masked[i] !== ch; i++)
+        if (masked[i] === "\\")
+          i++;
+      continue;
+    }
+    if (ch === "[")
+      depth++;
+    else if (ch === "]" && --depth === 0)
+      return i;
+  }
+  return -1;
+}
+function namedConfigArrayEnd(masked) {
+  const exported = [...masked.matchAll(/export\s+default\s+([A-Za-z_$][\w$]*)\s*;?/g)];
+  if (exported.length !== 1)
+    return -1;
+  const declaration = new RegExp(`(?:const|let|var)\\s+${exported[0][1].replace(/\$/g, "\\$")}\\s*=\\s*(?:defineConfig\\s*\\(\\s*)?\\[`).exec(masked);
+  if (declaration === null)
+    return -1;
+  return closingBracketOf(masked, declaration.index + declaration[0].length - 1);
+}
+function applyFsdEslintConfig(configText, severity, root = "src", framework = {}) {
   if (classifyFsdEslintConfig(configText) === "applied")
     return { status: "already-applied" };
   const masked = maskComments(configText);
   EXPORT_DEFAULT_ARRAY.lastIndex = 0;
   const exportMatches = masked.match(EXPORT_DEFAULT_ARRAY) ?? [];
   const closing = CLOSING_BRACKET.exec(masked);
-  if (exportMatches.length !== 1 || closing === null)
+  const closingIndex = exportMatches.length === 1 && closing !== null ? closing.index : namedConfigArrayEnd(masked);
+  if (closingIndex === -1)
     return { status: "unrecognized" };
   const eol = configText.includes("\r\n") ? "\r\n" : "\n";
-  const closingIndex = closing.index;
   const before = configText.slice(0, closingIndex);
   const lastNonSpace = before.replace(/\s+$/, "");
   const needsComma = !lastNonSpace.endsWith(",") && !lastNonSpace.endsWith("[");
-  const entryText = `${needsComma ? "," : ""}${eol}  ${buildFsdEslintEntry(severity)}${eol}`;
+  const entryText = `${needsComma ? "," : ""}${eol}  ${buildFsdEslintEntry(severity, root, framework)}${eol}`;
   const withEntry = `${lastNonSpace}${entryText}${configText.slice(closingIndex)}`;
   IMPORT_STATEMENT.lastIndex = 0;
   let lastImportEnd = -1;
@@ -1302,20 +1670,12 @@ function applyFsdEslintConfig(configText, severity) {
   const text = lastImportEnd === -1 ? `${importLine}${eol}${eol}${withEntry}` : `${withEntry.slice(0, lastImportEnd)}${eol}${importLine}${withEntry.slice(lastImportEnd)}`;
   return { status: "applied", text };
 }
-function buildFsdEslintPasteSnippet(severity, locale) {
-  return buildFsdEslintSnippet({ severity, locale });
-}
-var REACT_VITE_LAYERS = ["app", "pages", "features", "entities", "shared"];
-var NEXT_LAYERS = ["pages", "features", "entities", "shared"];
-function fsdLayerDirName(frontend, layer) {
-  return frontend === "next" && (layer === "pages" || layer === "app") ? `_${layer}` : layer;
-}
-function fsdLayersFor(frontend) {
-  return frontend === "next" ? [...NEXT_LAYERS] : [...REACT_VITE_LAYERS];
+function buildFsdEslintPasteSnippet(severity, locale, root = "src", framework = {}) {
+  return buildFsdEslintSnippet({ severity, locale, root, framework });
 }
-function composeFsdLayerGuide({ frontend, sourceRoot, locale }) {
-  const layers = fsdLayersFor(frontend);
-  return buildFsdLayerGuide({ layers, directories: layers.map((layer) => fsdLayerDirName(frontend, layer)), sourceRoot, locale });
+function composeFsdLayerGuide({ profile, sourceRoot, locale }) {
+  const layers = [...profile.layers];
+  return buildFsdLayerGuide({ layers, directories: layers.map((layer) => profile.layerDirs[layer] ?? layer), sourceRoot, locale });
 }
 
 // ../template-engine/dist/ai-hosts/ai-hosts.js
@@ -1346,18 +1706,13 @@ function reviewProviderFor(hosts) {
 }
 
 // ../template-engine/dist/presets/preset-config.js
-var REACT_VITE_LAYERS2 = ["app", "pages", "features", "entities", "shared"];
-var NEXT_LAYERS2 = ["pages", "features", "entities", "shared"];
 function buildFsdConfig(enforcement, frontend) {
   return {
     // All three presets enable FSD — it is on whenever there is a
     // frontend; a backend-only workspace has none to structure.
     enabled: frontend !== "none",
     enforcement,
-    layerMapping: {
-      "react-vite": REACT_VITE_LAYERS2,
-      next: NEXT_LAYERS2
-    }
+    layerMapping: Object.fromEntries(allFrameworkProfiles().map((profile) => [profile.id, [...profile.layers]]))
   };
 }
 var PRESET_DEFAULTS = {
@@ -1459,7 +1814,13 @@ ${section.body}`).join("\n\n")}
 }
 function composeAgentRules(input) {
   const sectionIds = input.sections ?? resolveDefaultAgentSectionIds(input.teamRules ?? false, input.fsdStructure ?? false);
-  const sections = sectionIds.map((id) => AGENT_RULE_SECTIONS[input.locale][id]);
+  const notes = input.fsdPolicy === void 0 ? "" : buildFsdPolicyNotes(input.locale, input.fsdPolicy);
+  const sections = sectionIds.map((id) => {
+    const section = AGENT_RULE_SECTIONS[input.locale][id];
+    return id === FSD_AGENT_SECTION_ID && notes !== "" ? { ...section, body: `${section.body}
+
+${notes}` } : section;
+  });
   const content = renderSections(sections);
   return input.files.map((filePath) => ({ filePath, content }));
 }
@@ -1475,297 +1836,1102 @@ function validateAgentRules(content, extraRequired = []) {
 }
 
 // ../template-engine/dist/agent-rules/marker-block.js
+import { createHash } from "node:crypto";
 var AGENT_RULES_BLOCK_START = "<!-- nx-archweave:agent-rules start -->";
 var AGENT_RULES_BLOCK_END = "<!-- nx-archweave:agent-rules end -->";
+var START_MARKER = /<!-- nx-archweave:agent-rules start(?: hash=([0-9a-f]{12}))? -->/g;
+function normalizeForHash(text) {
+  return text.replace(/\r\n/g, "\n").replace(/[ \t]+$/gm, "");
+}
+function hashOf(body) {
+  return createHash("sha256").update(normalizeForHash(body)).digest("hex").slice(0, 12);
+}
+function withFinalNewline(body) {
+  return body.endsWith("\n") ? body : `${body}
+`;
+}
 function renderAgentRulesBlock(body, eol = "\n") {
-  const lines = `${AGENT_RULES_BLOCK_START}
-${body.endsWith("\n") ? body : `${body}
-`}${AGENT_RULES_BLOCK_END}`;
+  const content = withFinalNewline(normalizeForHash(body));
+  const lines = `<!-- nx-archweave:agent-rules start hash=${hashOf(content)} -->
+${content}${AGENT_RULES_BLOCK_END}`;
   return eol === "\n" ? lines : lines.replace(/\r?\n/g, eol);
 }
 function countOf(text, needle) {
   return text.split(needle).length - 1;
 }
-function applyAgentRulesBlock(existing, body) {
+function applyAgentRulesBlock(existing, body, options = {}) {
   if (existing === null || existing.length === 0)
     return { kind: "create", text: `${renderAgentRulesBlock(body)}
 ` };
   const eol = existing.includes("\r\n") ? "\r\n" : "\n";
   const block = renderAgentRulesBlock(body, eol);
-  const starts = countOf(existing, AGENT_RULES_BLOCK_START);
+  const starts = [...existing.matchAll(START_MARKER)];
   const ends = countOf(existing, AGENT_RULES_BLOCK_END);
-  if (starts === 0 && ends === 0) {
+  if (starts.length === 0 && ends === 0) {
     const head = existing.endsWith("\n") ? existing : `${existing}${eol}`;
     return { kind: "append", text: `${head}${eol}${block}${eol}` };
   }
-  if (starts !== 1 || ends !== 1) {
+  if (starts.length !== 1 || ends !== 1) {
     return {
       kind: "unrecognized",
-      reason: `expected one ${AGENT_RULES_BLOCK_START} \u2026 ${AGENT_RULES_BLOCK_END} pair, found ${starts} start and ${ends} end marker(s)`
+      reason: `expected one ${AGENT_RULES_BLOCK_START} \u2026 ${AGENT_RULES_BLOCK_END} pair, found ${starts.length} start and ${ends} end marker(s)`
     };
   }
-  const start = existing.indexOf(AGENT_RULES_BLOCK_START);
+  const startMatch = starts[0];
+  const start = startMatch.index ?? 0;
   const end = existing.indexOf(AGENT_RULES_BLOCK_END);
   if (end < start)
     return { kind: "unrecognized", reason: "the end marker comes before the start marker" };
   const text = existing.slice(0, start) + block + existing.slice(end + AGENT_RULES_BLOCK_END.length);
-  return text === existing ? { kind: "unchanged" } : { kind: "replace", text };
+  if (text === existing)
+    return { kind: "unchanged" };
+  const bodyStart = start + startMatch[0].length + (existing.startsWith("\r\n", start + startMatch[0].length) ? 2 : 1);
+  const existingBody = normalizeForHash(existing.slice(bodyStart, end));
+  const generatedBody = withFinalNewline(normalizeForHash(body));
+  const recordedHash = startMatch[1];
+  const untouched = recordedHash !== void 0 ? hashOf(existingBody) === recordedHash : existingBody === generatedBody;
+  if (!untouched && options.overwrite !== true)
+    return { kind: "user-modified", existingBody, generatedBody };
+  return { kind: "replace", text };
 }
 
-// ../template-engine/dist/backend/compose-backend-wiring.js
-function composeBackendWiring(input) {
-  const scoped = /^@([^/]+)\//.exec(input.workspaceName);
-  const scope = scoped ? `@${scoped[1]}` : `@${input.workspaceName.split("/").pop() || "workspace"}`;
-  const sharedTypesPackageName = `${scope}/shared-types`;
-  return {
-    sharedTypesFiles: [
-      { filePath: "libs/shared-types/package.json", content: sharedTypesPackageJsonContent(sharedTypesPackageName) },
-      { filePath: "libs/shared-types/src/index.ts", content: sharedTypesIndexContent() },
-      { filePath: "libs/shared-types/src/lib/api-types.ts", content: sharedTypesApiTypesContent() }
-    ],
-    sharedTypesPackageName,
-    tagByRole: { frontend: "scope:frontend", backend: "scope:backend", shared: "scope:shared" }
-  };
+// src/generators/add-fsd-lite/generator.ts
+import { posix } from "node:path";
+
+// src/generators/shared/dry-run.ts
+function resolveDryRun(options) {
+  return process.env["NX_DRY_RUN"] === "true" || (options.dryRun ?? false);
 }
-function addSharedTypesNpmWorkspace(packageJsonText) {
-  let parsed;
-  try {
-    parsed = JSON.parse(packageJsonText);
-  } catch {
-    return { status: "unrecognized" };
-  }
-  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
-    return { status: "unrecognized" };
-  const pkg = parsed;
-  const field = pkg["workspaces"];
-  let target;
-  if (field === void 0) {
-    target = [];
-  } else if (Array.isArray(field)) {
-    target = field;
-  } else if (field !== null && typeof field === "object" && Array.isArray(field.packages)) {
-    target = field.packages;
-  } else {
-    return { status: "unrecognized" };
+
+// src/generators/shared/frontend-app.ts
+import { getProjects } from "@nx/devkit";
+
+// ../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js
+function createScanner(text, ignoreTrivia = false) {
+  const len = text.length;
+  let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+  function scanHexDigits(count, exact) {
+    let digits = 0;
+    let value2 = 0;
+    while (digits < count || !exact) {
+      let ch = text.charCodeAt(pos);
+      if (ch >= 48 && ch <= 57) {
+        value2 = value2 * 16 + ch - 48;
+      } else if (ch >= 65 && ch <= 70) {
+        value2 = value2 * 16 + ch - 65 + 10;
+      } else if (ch >= 97 && ch <= 102) {
+        value2 = value2 * 16 + ch - 97 + 10;
+      } else {
+        break;
+      }
+      pos++;
+      digits++;
+    }
+    if (digits < count) {
+      value2 = -1;
+    }
+    return value2;
   }
-  if (target.some((entry) => entry === "libs/shared-types" || entry === "libs/*"))
-    return { status: "present" };
-  const surgical = insertSharedTypesWorkspace(packageJsonText, field === void 0 ? "absent" : Array.isArray(field) ? "array" : "object");
-  if (surgical !== null)
-    return { status: "added", text: surgical };
-  if (field === void 0)
-    pkg["workspaces"] = target;
-  target.push("libs/shared-types");
-  const indent = /\n([ \t]+)"/.exec(packageJsonText)?.[1] ?? "  ";
-  const trailing = packageJsonText.endsWith("\n") ? "\n" : "";
-  return { status: "added", text: `${JSON.stringify(pkg, null, indent)}${trailing}` };
-}
-var SHARED_TYPES_ENTRY = '"libs/shared-types"';
-function skipJsonValue(text, start) {
-  if (text[start] === '"') {
-    let i = start + 1;
-    while (i < text.length && text[i] !== '"')
-      i += text[i] === "\\" ? 2 : 1;
-    return i + 1;
+  function setPosition(newPosition) {
+    pos = newPosition;
+    value = "";
+    tokenOffset = 0;
+    token = 16;
+    scanError = 0;
   }
-  if (text[start] === "[" || text[start] === "{") {
-    let depth = 0;
-    let i = start;
-    while (i < text.length) {
-      const c = text[i];
-      if (c === '"') {
-        i = skipJsonValue(text, i);
+  function scanNumber() {
+    let start = pos;
+    if (text.charCodeAt(pos) === 48) {
+      pos++;
+    } else {
+      pos++;
+      while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+      }
+    }
+    if (pos < text.length && text.charCodeAt(pos) === 46) {
+      pos++;
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+      } else {
+        scanError = 3;
+        return text.substring(start, pos);
+      }
+    }
+    let end = pos;
+    if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+      pos++;
+      if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
+        pos++;
+      }
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+        end = pos;
+      } else {
+        scanError = 3;
+      }
+    }
+    return text.substring(start, end);
+  }
+  function scanString() {
+    let result = "", start = pos;
+    while (true) {
+      if (pos >= len) {
+        result += text.substring(start, pos);
+        scanError = 2;
+        break;
+      }
+      const ch = text.charCodeAt(pos);
+      if (ch === 34) {
+        result += text.substring(start, pos);
+        pos++;
+        break;
+      }
+      if (ch === 92) {
+        result += text.substring(start, pos);
+        pos++;
+        if (pos >= len) {
+          scanError = 2;
+          break;
+        }
+        const ch2 = text.charCodeAt(pos++);
+        switch (ch2) {
+          case 34:
+            result += '"';
+            break;
+          case 92:
+            result += "\\";
+            break;
+          case 47:
+            result += "/";
+            break;
+          case 98:
+            result += "\b";
+            break;
+          case 102:
+            result += "\f";
+            break;
+          case 110:
+            result += "\n";
+            break;
+          case 114:
+            result += "\r";
+            break;
+          case 116:
+            result += "	";
+            break;
+          case 117:
+            const ch3 = scanHexDigits(4, true);
+            if (ch3 >= 0) {
+              result += String.fromCharCode(ch3);
+            } else {
+              scanError = 4;
+            }
+            break;
+          default:
+            scanError = 5;
+        }
+        start = pos;
         continue;
       }
-      if (c === "[" || c === "{")
-        depth++;
-      if (c === "]" || c === "}") {
-        depth--;
-        if (depth === 0)
-          return i + 1;
+      if (ch >= 0 && ch <= 31) {
+        if (isLineBreak(ch)) {
+          result += text.substring(start, pos);
+          scanError = 2;
+          break;
+        } else {
+          scanError = 6;
+        }
       }
-      i++;
+      pos++;
     }
-    return -1;
+    return result;
   }
-  const literal = /^[^,}\]\s]+/.exec(text.slice(start));
-  return literal ? start + literal[0].length : -1;
-}
-function objectMembers(text, open) {
-  const members = [];
-  let i = open + 1;
-  for (; ; ) {
-    while (/[\s,]/.test(text[i] ?? ""))
-      i++;
-    if (text[i] === "}")
-      return members;
-    if (text[i] !== '"')
-      return null;
-    const keyEnd = skipJsonValue(text, i);
-    const key = JSON.parse(text.slice(i, keyEnd));
-    i = keyEnd;
-    while (/\s/.test(text[i] ?? ""))
-      i++;
-    if (text[i] !== ":")
-      return null;
-    i++;
-    while (/\s/.test(text[i] ?? ""))
-      i++;
-    const valueEnd = skipJsonValue(text, i);
-    if (valueEnd === -1)
-      return null;
-    members.push({ key, valueStart: i, valueEnd });
-    i = valueEnd;
+  function scanNext() {
+    value = "";
+    scanError = 0;
+    tokenOffset = pos;
+    lineStartOffset = lineNumber;
+    prevTokenLineStartOffset = tokenLineStartOffset;
+    if (pos >= len) {
+      tokenOffset = len;
+      return token = 17;
+    }
+    let code = text.charCodeAt(pos);
+    if (isWhiteSpace(code)) {
+      do {
+        pos++;
+        value += String.fromCharCode(code);
+        code = text.charCodeAt(pos);
+      } while (isWhiteSpace(code));
+      return token = 15;
+    }
+    if (isLineBreak(code)) {
+      pos++;
+      value += String.fromCharCode(code);
+      if (code === 13 && text.charCodeAt(pos) === 10) {
+        pos++;
+        value += "\n";
+      }
+      lineNumber++;
+      tokenLineStartOffset = pos;
+      return token = 14;
+    }
+    switch (code) {
+      // tokens: []{}:,
+      case 123:
+        pos++;
+        return token = 1;
+      case 125:
+        pos++;
+        return token = 2;
+      case 91:
+        pos++;
+        return token = 3;
+      case 93:
+        pos++;
+        return token = 4;
+      case 58:
+        pos++;
+        return token = 6;
+      case 44:
+        pos++;
+        return token = 5;
+      // strings
+      case 34:
+        pos++;
+        value = scanString();
+        return token = 10;
+      // comments
+      case 47:
+        const start = pos - 1;
+        if (text.charCodeAt(pos + 1) === 47) {
+          pos += 2;
+          while (pos < len) {
+            if (isLineBreak(text.charCodeAt(pos))) {
+              break;
+            }
+            pos++;
+          }
+          value = text.substring(start, pos);
+          return token = 12;
+        }
+        if (text.charCodeAt(pos + 1) === 42) {
+          pos += 2;
+          const safeLength = len - 1;
+          let commentClosed = false;
+          while (pos < safeLength) {
+            const ch = text.charCodeAt(pos);
+            if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+              pos += 2;
+              commentClosed = true;
+              break;
+            }
+            pos++;
+            if (isLineBreak(ch)) {
+              if (ch === 13 && text.charCodeAt(pos) === 10) {
+                pos++;
+              }
+              lineNumber++;
+              tokenLineStartOffset = pos;
+            }
+          }
+          if (!commentClosed) {
+            pos++;
+            scanError = 1;
+          }
+          value = text.substring(start, pos);
+          return token = 13;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+      // numbers
+      case 45:
+        value += String.fromCharCode(code);
+        pos++;
+        if (pos === len || !isDigit(text.charCodeAt(pos))) {
+          return token = 16;
+        }
+      // found a minus, followed by a number so
+      // we fall through to proceed with scanning
+      // numbers
+      case 48:
+      case 49:
+      case 50:
+      case 51:
+      case 52:
+      case 53:
+      case 54:
+      case 55:
+      case 56:
+      case 57:
+        value += scanNumber();
+        return token = 11;
+      // literals and unknown symbols
+      default:
+        while (pos < len && isUnknownContentCharacter(code)) {
+          pos++;
+          code = text.charCodeAt(pos);
+        }
+        if (tokenOffset !== pos) {
+          value = text.substring(tokenOffset, pos);
+          switch (value) {
+            case "true":
+              return token = 8;
+            case "false":
+              return token = 9;
+            case "null":
+              return token = 7;
+          }
+          return token = 16;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+    }
   }
-}
-function appendToArray(text, open, close, eol) {
-  const inner = text.slice(open + 1, close - 1);
-  if (inner.trim() === "")
-    return `${text.slice(0, open + 1)}${SHARED_TYPES_ENTRY}${text.slice(close - 1)}`;
-  if (!inner.includes("\n")) {
-    const body = inner.replace(/\s+$/, "");
-    return `${text.slice(0, open + 1)}${body}, ${SHARED_TYPES_ENTRY}${inner.slice(body.length)}${text.slice(close - 1)}`;
+  function isUnknownContentCharacter(code) {
+    if (isWhiteSpace(code) || isLineBreak(code)) {
+      return false;
+    }
+    switch (code) {
+      case 125:
+      case 93:
+      case 123:
+      case 91:
+      case 34:
+      case 58:
+      case 44:
+      case 47:
+        return false;
+    }
+    return true;
   }
-  const lastEntryLineStart = text.lastIndexOf("\n", open + 1 + inner.trimEnd().length - 1) + 1;
-  const itemIndent = /^[ \t]*/.exec(text.slice(lastEntryLineStart))?.[0] ?? "  ";
-  const bodyEnd = open + 1 + inner.trimEnd().length;
-  return `${text.slice(0, bodyEnd)},${eol}${itemIndent}${SHARED_TYPES_ENTRY}${text.slice(bodyEnd)}`;
+  function scanNextNonTrivia() {
+    let result;
+    do {
+      result = scanNext();
+    } while (result >= 12 && result <= 15);
+    return result;
+  }
+  return {
+    setPosition,
+    getPosition: () => pos,
+    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+    getToken: () => token,
+    getTokenValue: () => value,
+    getTokenOffset: () => tokenOffset,
+    getTokenLength: () => pos - tokenOffset,
+    getTokenStartLine: () => lineStartOffset,
+    getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+    getTokenError: () => scanError
+  };
 }
-function insertSharedTypesWorkspace(text, form) {
-  const eol = text.includes("\r\n") ? "\r\n" : "\n";
-  const rootOpen = text.indexOf("{");
-  if (rootOpen === -1)
-    return null;
-  const members = objectMembers(text, rootOpen);
-  if (members === null)
-    return null;
-  const workspaces = members.find((member) => member.key === "workspaces");
-  if (form === "absent") {
-    const last = members[members.length - 1];
-    const indent = /\n([ \t]+)"/.exec(text)?.[1] ?? "  ";
-    if (last === void 0) {
-      const close = skipJsonValue(text, rootOpen) - 1;
-      return `${text.slice(0, rootOpen + 1)}${eol}${indent}"workspaces": [${SHARED_TYPES_ENTRY}]${eol}${text.slice(close)}`;
+function isWhiteSpace(ch) {
+  return ch === 32 || ch === 9;
+}
+function isLineBreak(ch) {
+  return ch === 10 || ch === 13;
+}
+function isDigit(ch) {
+  return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+(function(CharacterCodes2) {
+  CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
+  CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
+  CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
+  CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
+  CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
+  CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
+  CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
+  CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
+  CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
+  CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
+  CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
+  CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
+  CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
+  CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
+  CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
+  CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
+  CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
+  CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
+  CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
+  CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
+  CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
+  CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
+  CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
+  CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
+  CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
+  CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
+  CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
+  CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
+  CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
+  CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
+  CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
+  CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
+  CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
+  CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
+  CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
+  CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
+  CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
+  CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
+  CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
+  CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
+  CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
+  CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
+  CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
+  CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
+  CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
+  CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
+  CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
+  CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
+  CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
+  CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
+  CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
+  CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
+  CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
+  CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
+  CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
+  CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
+  CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
+  CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
+  CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
+  CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
+  CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
+  CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
+  CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
+  CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
+  CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
+  CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
+  CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
+  CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
+  CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
+  CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
+  CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
+  CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
+  CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
+  CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
+  CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
+  CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
+  CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
+  CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
+  CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
+  CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+
+// ../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/string-intern.js
+var cachedSpaces = new Array(20).fill(0).map((_, index) => {
+  return " ".repeat(index);
+});
+var maxCachedValues = 200;
+var cachedBreakLinesWithSpaces = {
+  " ": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\n" + " ".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + " ".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r\n" + " ".repeat(index);
+    })
+  },
+  "	": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\n" + "	".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + "	".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r\n" + "	".repeat(index);
+    })
+  }
+};
+
+// ../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions2) {
+  ParseOptions2.DEFAULT = {
+    allowTrailingComma: false
+  };
+})(ParseOptions || (ParseOptions = {}));
+function parseTree(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentParent = { type: "array", offset: -1, length: -1, children: [], parent: void 0 };
+  function ensurePropertyComplete(endOffset) {
+    if (currentParent.type === "property") {
+      currentParent.length = endOffset - currentParent.offset;
+      currentParent = currentParent.parent;
     }
-    return `${text.slice(0, last.valueEnd)},${eol}${indent}"workspaces": [${SHARED_TYPES_ENTRY}]${text.slice(last.valueEnd)}`;
   }
-  if (workspaces === void 0)
-    return null;
-  if (form === "array") {
-    if (text[workspaces.valueStart] !== "[")
-      return null;
-    return appendToArray(text, workspaces.valueStart, workspaces.valueEnd, eol);
+  function onValue(valueNode) {
+    currentParent.children.push(valueNode);
+    return valueNode;
   }
-  if (text[workspaces.valueStart] !== "{")
-    return null;
-  const packages = objectMembers(text, workspaces.valueStart)?.find((member) => member.key === "packages");
-  if (packages === void 0 || text[packages.valueStart] !== "[")
-    return null;
-  return appendToArray(text, packages.valueStart, packages.valueEnd, eol);
+  const visitor = {
+    onObjectBegin: (offset) => {
+      currentParent = onValue({ type: "object", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onObjectProperty: (name, offset, length) => {
+      currentParent = onValue({ type: "property", offset, length: -1, parent: currentParent, children: [] });
+      currentParent.children.push({ type: "string", value: name, offset, length, parent: currentParent });
+    },
+    onObjectEnd: (offset, length) => {
+      ensurePropertyComplete(offset + length);
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onArrayBegin: (offset, length) => {
+      currentParent = onValue({ type: "array", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onArrayEnd: (offset, length) => {
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onLiteralValue: (value, offset, length) => {
+      onValue({ type: getNodeType(value), offset, length, parent: currentParent, value });
+      ensurePropertyComplete(offset + length);
+    },
+    onSeparator: (sep, offset, length) => {
+      if (currentParent.type === "property") {
+        if (sep === ":") {
+          currentParent.colonOffset = offset;
+        } else if (sep === ",") {
+          ensurePropertyComplete(offset);
+        }
+      }
+    },
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  const result = currentParent.children[0];
+  if (result) {
+    delete result.parent;
+  }
+  return result;
 }
-function addSharedTypesWorkspaceGlob(yamlText) {
-  if (/^\s*-\s*['"]?(libs\/shared-types|libs\/\*)['"]?\s*$/m.test(yamlText)) {
-    return { status: "present" };
+function findNodeAtLocation(root, path) {
+  if (!root) {
+    return void 0;
   }
-  const lines = yamlText.split("\n");
-  const packagesIndex = lines.findIndex((line) => /^packages:\s*$/.test(line));
-  if (packagesIndex === -1)
-    return { status: "unrecognized" };
-  let lastEntry = packagesIndex;
-  for (let i = packagesIndex + 1; i < lines.length; i++) {
-    if (/^\s+-\s+\S/.test(lines[i])) {
-      lastEntry = i;
-    } else if (lines[i].trim() === "") {
-      continue;
+  let node = root;
+  for (let segment of path) {
+    if (typeof segment === "string") {
+      if (node.type !== "object" || !Array.isArray(node.children)) {
+        return void 0;
+      }
+      let found = false;
+      for (const propertyNode of node.children) {
+        if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment && propertyNode.children.length === 2) {
+          node = propertyNode.children[1];
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        return void 0;
+      }
     } else {
-      break;
+      const index = segment;
+      if (node.type !== "array" || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {
+        return void 0;
+      }
+      node = node.children[index];
     }
   }
-  if (lastEntry === packagesIndex)
-    return { status: "unrecognized" };
-  const indent = /^(\s+)-/.exec(lines[lastEntry])?.[1] ?? "  ";
-  lines.splice(lastEntry + 1, 0, `${indent}- 'libs/shared-types'`);
-  return { status: "added", text: lines.join("\n") };
-}
-
-// src/generators/shared/dry-run.ts
-function resolveDryRun(options) {
-  return process.env["NX_DRY_RUN"] === "true" || (options.dryRun ?? false);
+  return node;
+}
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+  const _scanner = createScanner(text, false);
+  const _jsonPath = [];
+  let suppressedCallbacks = 0;
+  function toNoArgVisit(visitFunction) {
+    return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisit(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisitWithPath(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+  }
+  function toBeginVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks++;
+      } else {
+        let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
+        if (cbReturn === false) {
+          suppressedCallbacks = 1;
+        }
+      }
+    } : () => true;
+  }
+  function toEndVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks--;
+      }
+      if (suppressedCallbacks === 0) {
+        visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+      }
+    } : () => true;
+  }
+  const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+  const disallowComments = options && options.disallowComments;
+  const allowTrailingComma = options && options.allowTrailingComma;
+  function scanNext() {
+    while (true) {
+      const token = _scanner.scan();
+      switch (_scanner.getTokenError()) {
+        case 4:
+          handleError(
+            14
+            /* ParseErrorCode.InvalidUnicode */
+          );
+          break;
+        case 5:
+          handleError(
+            15
+            /* ParseErrorCode.InvalidEscapeCharacter */
+          );
+          break;
+        case 3:
+          handleError(
+            13
+            /* ParseErrorCode.UnexpectedEndOfNumber */
+          );
+          break;
+        case 1:
+          if (!disallowComments) {
+            handleError(
+              11
+              /* ParseErrorCode.UnexpectedEndOfComment */
+            );
+          }
+          break;
+        case 2:
+          handleError(
+            12
+            /* ParseErrorCode.UnexpectedEndOfString */
+          );
+          break;
+        case 6:
+          handleError(
+            16
+            /* ParseErrorCode.InvalidCharacter */
+          );
+          break;
+      }
+      switch (token) {
+        case 12:
+        case 13:
+          if (disallowComments) {
+            handleError(
+              10
+              /* ParseErrorCode.InvalidCommentToken */
+            );
+          } else {
+            onComment();
+          }
+          break;
+        case 16:
+          handleError(
+            1
+            /* ParseErrorCode.InvalidSymbol */
+          );
+          break;
+        case 15:
+        case 14:
+          break;
+        default:
+          return token;
+      }
+    }
+  }
+  function handleError(error, skipUntilAfter = [], skipUntil = []) {
+    onError(error);
+    if (skipUntilAfter.length + skipUntil.length > 0) {
+      let token = _scanner.getToken();
+      while (token !== 17) {
+        if (skipUntilAfter.indexOf(token) !== -1) {
+          scanNext();
+          break;
+        } else if (skipUntil.indexOf(token) !== -1) {
+          break;
+        }
+        token = scanNext();
+      }
+    }
+  }
+  function parseString(isValue) {
+    const value = _scanner.getTokenValue();
+    if (isValue) {
+      onLiteralValue(value);
+    } else {
+      onObjectProperty(value);
+      _jsonPath.push(value);
+    }
+    scanNext();
+    return true;
+  }
+  function parseLiteral() {
+    switch (_scanner.getToken()) {
+      case 11:
+        const tokenValue = _scanner.getTokenValue();
+        let value = Number(tokenValue);
+        if (isNaN(value)) {
+          handleError(
+            2
+            /* ParseErrorCode.InvalidNumberFormat */
+          );
+          value = 0;
+        }
+        onLiteralValue(value);
+        break;
+      case 7:
+        onLiteralValue(null);
+        break;
+      case 8:
+        onLiteralValue(true);
+        break;
+      case 9:
+        onLiteralValue(false);
+        break;
+      default:
+        return false;
+    }
+    scanNext();
+    return true;
+  }
+  function parseProperty() {
+    if (_scanner.getToken() !== 10) {
+      handleError(3, [], [
+        2,
+        5
+        /* SyntaxKind.CommaToken */
+      ]);
+      return false;
+    }
+    parseString(false);
+    if (_scanner.getToken() === 6) {
+      onSeparator(":");
+      scanNext();
+      if (!parseValue()) {
+        handleError(4, [], [
+          2,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+    } else {
+      handleError(5, [], [
+        2,
+        5
+        /* SyntaxKind.CommaToken */
+      ]);
+    }
+    _jsonPath.pop();
+    return true;
+  }
+  function parseObject() {
+    onObjectBegin();
+    scanNext();
+    let needsComma = false;
+    while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 2 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (!parseProperty()) {
+        handleError(4, [], [
+          2,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+      needsComma = true;
+    }
+    onObjectEnd();
+    if (_scanner.getToken() !== 2) {
+      handleError(7, [
+        2
+        /* SyntaxKind.CloseBraceToken */
+      ], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseArray() {
+    onArrayBegin();
+    scanNext();
+    let isFirstElement = true;
+    let needsComma = false;
+    while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 4 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (isFirstElement) {
+        _jsonPath.push(0);
+        isFirstElement = false;
+      } else {
+        _jsonPath[_jsonPath.length - 1]++;
+      }
+      if (!parseValue()) {
+        handleError(4, [], [
+          4,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+      needsComma = true;
+    }
+    onArrayEnd();
+    if (!isFirstElement) {
+      _jsonPath.pop();
+    }
+    if (_scanner.getToken() !== 4) {
+      handleError(8, [
+        4
+        /* SyntaxKind.CloseBracketToken */
+      ], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseValue() {
+    switch (_scanner.getToken()) {
+      case 3:
+        return parseArray();
+      case 1:
+        return parseObject();
+      case 10:
+        return parseString(true);
+      default:
+        return parseLiteral();
+    }
+  }
+  scanNext();
+  if (_scanner.getToken() === 17) {
+    if (options.allowEmptyContent) {
+      return true;
+    }
+    handleError(4, [], []);
+    return false;
+  }
+  if (!parseValue()) {
+    handleError(4, [], []);
+    return false;
+  }
+  if (_scanner.getToken() !== 17) {
+    handleError(9, [], []);
+  }
+  return true;
+}
+function getNodeType(value) {
+  switch (typeof value) {
+    case "boolean":
+      return "boolean";
+    case "number":
+      return "number";
+    case "string":
+      return "string";
+    case "object": {
+      if (!value) {
+        return "null";
+      } else if (Array.isArray(value)) {
+        return "array";
+      }
+      return "object";
+    }
+    default:
+      return "null";
+  }
 }
 
-// src/generators/shared/frontend-app.ts
-import { getProjects } from "@nx/devkit";
+// ../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/main.js
+var ScanError;
+(function(ScanError2) {
+  ScanError2[ScanError2["None"] = 0] = "None";
+  ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+  ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+  ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+  ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+  ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+  ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind2) {
+  SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+  SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+  SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+  SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+  SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+  SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+  SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+  SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+  SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+  SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+  SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+  SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+  SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+  SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+  SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+  SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+  SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+var parseTree2 = parseTree;
+var findNodeAtLocation2 = findNodeAtLocation;
+var ParseErrorCode;
+(function(ParseErrorCode2) {
+  ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+  ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+  ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+  ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+  ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+  ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+  ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+  ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+  ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+  ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+  ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
 
-// 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 {
+// src/generators/shared/json-edit.ts
+function detectIndent(raw) {
+  for (const line of raw.split("\n")) {
+    const match = /^(\t+| +)/.exec(line);
+    if (match) return match[1];
   }
-  return "library";
+  return "  ";
 }
-
-// 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 styleOf(raw) {
+  return { eol: raw.includes("\r\n") ? "\r\n" : "\n", unit: detectIndent(raw) };
 }
-function isBackend(root, config) {
-  return baseNameOf(root) === "api" || (config.tags ?? []).includes("scope:backend");
+function lineIndentAt(raw, offset) {
+  const lineStart = raw.lastIndexOf("\n", offset - 1) + 1;
+  return /^[ \t]*/.exec(raw.slice(lineStart))?.[0] ?? "";
 }
-function sourceRootOf(config) {
-  if (config.sourceRoot) return config.sourceRoot;
-  return config.root === "" || config.root === "." ? "src" : `${config.root}/src`;
+function isMultiline(raw, node) {
+  return raw.slice(node.offset, node.offset + node.length).includes("\n");
 }
-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 };
+function isPrimitive(value) {
+  return value === null || ["string", "number", "boolean"].includes(typeof value);
+}
+function renderValue(value, indent, style) {
+  if (isPrimitive(value)) return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    if (value.every(isPrimitive)) return `[${value.map((item) => JSON.stringify(item)).join(", ")}]`;
+    const inner2 = `${indent}${style.unit}`;
+    return `[${style.eol}${value.map((item) => `${inner2}${renderValue(item, inner2, style)}`).join(`,${style.eol}`)}${style.eol}${indent}]`;
   }
-  const found = (project2, config2) => ({
-    kind: "found",
-    project: project2,
-    root: config2.root,
-    sourceRoot: sourceRootOf(config2)
-  });
-  if (explicitProject !== void 0) {
-    const config2 = projects.get(explicitProject);
-    return config2 ? found(explicitProject, config2) : { kind: "not-found", project: explicitProject };
+  const entries = Object.entries(value);
+  if (entries.length === 0) return "{}";
+  const inner = `${indent}${style.unit}`;
+  const body = entries.map(([key, item]) => `${inner}${JSON.stringify(key)}: ${renderValue(item, inner, style)}`).join(`,${style.eol}`);
+  return `{${style.eol}${body}${style.eol}${indent}}`;
+}
+function splice(raw, start, end, text) {
+  return raw.slice(0, start) + text + raw.slice(end);
+}
+function nest(keys, value) {
+  return keys.reduceRight((inner, key) => ({ [key]: inner }), value);
+}
+function insertProperty(raw, object, key, value, style) {
+  const properties = object.children ?? [];
+  const objectIndent = lineIndentAt(raw, object.offset);
+  if (properties.length === 0) {
+    const inner = `${objectIndent}${style.unit}`;
+    const text = `{${style.eol}${inner}${JSON.stringify(String(key))}: ${renderValue(value, inner, style)}${style.eol}${objectIndent}}`;
+    return splice(raw, object.offset, object.offset + object.length, text);
   }
-  const eligible = [...projects.entries()].filter(([, config2]) => !isEndToEnd(config2.root) && !isBackend(config2.root, config2));
-  const declared = eligible.filter(([, config2]) => config2.projectType === "application");
-  const inferred = eligible.filter(
-    ([, config2]) => config2.projectType === void 0 && config2.root !== "" && config2.root !== "." && resolveProjectType(tree, config2.root, void 0) === "application"
-  );
-  const candidates = (declared.length > 0 ? declared : inferred).sort(([a], [b]) => a.localeCompare(b));
-  if (candidates.length === 0) return { kind: "none" };
-  if (candidates.length > 1) return { kind: "ambiguous", candidates: candidates.map(([name]) => name) };
-  const [project, config] = candidates[0];
-  return found(project, config);
+  const last = properties[properties.length - 1];
+  const end = last.offset + last.length;
+  if (!isMultiline(raw, object)) {
+    return splice(raw, end, end, `, ${JSON.stringify(String(key))}: ${renderValue(value, "", style)}`);
+  }
+  const indent = lineIndentAt(raw, last.offset);
+  return splice(raw, end, end, `,${style.eol}${indent}${JSON.stringify(String(key))}: ${renderValue(value, indent, style)}`);
+}
+function setJsonValue(raw, path, value) {
+  const style = styleOf(raw);
+  const root = parseTree2(raw);
+  if (root === void 0) throw new Error("setJsonValue: not a JSON document");
+  const existing = findNodeAtLocation2(root, path);
+  if (existing !== void 0) {
+    return splice(raw, existing.offset, existing.offset + existing.length, renderValue(value, lineIndentAt(raw, existing.offset), style));
+  }
+  for (let depth = path.length - 1; depth >= 0; depth--) {
+    const parent = depth === 0 ? root : findNodeAtLocation2(root, path.slice(0, depth));
+    if (parent === void 0) continue;
+    if (parent.type !== "object") throw new Error(`setJsonValue: ${path.slice(0, depth).join(".") || "the root"} is not an object`);
+    return insertProperty(raw, parent, path[depth], nest(path.slice(depth + 1), value), style);
+  }
+  throw new Error("setJsonValue: unreachable");
+}
+function appendJsonArrayItem(raw, path, item) {
+  const style = styleOf(raw);
+  const root = parseTree2(raw);
+  const array = root === void 0 ? void 0 : findNodeAtLocation2(root, path);
+  if (array === void 0) return setJsonValue(raw, path, [item]);
+  if (array.type !== "array") throw new Error(`appendJsonArrayItem: ${path.join(".")} is not an array`);
+  const items = array.children ?? [];
+  if (items.length === 0) return splice(raw, array.offset, array.offset + array.length, renderValue([item], "", style));
+  const last = items[items.length - 1];
+  const end = last.offset + last.length;
+  if (!isMultiline(raw, array)) {
+    const separator = items.length >= 2 ? raw.slice(items[0].offset + items[0].length, items[1].offset) : ", ";
+    return splice(raw, end, end, `${separator}${renderValue(item, "", style)}`);
+  }
+  const indent = lineIndentAt(raw, last.offset);
+  return splice(raw, end, end, `,${style.eol}${indent}${renderValue(item, indent, style)}`);
+}
+function applyJsonEdits(raw, edits) {
+  if (raw === null) {
+    let text = "{}\n";
+    for (const [path, value] of edits) text = setJsonValue(text, path, value);
+    return text;
+  }
+  return edits.reduce((text, [path, value]) => setJsonValue(text, path, value), raw);
 }
 
 // src/generators/shared/toolkit-config-file.ts
 var TOOLKIT_CONFIG_PATH = "toolkit.config.json";
-function detectIndent(raw) {
-  for (const line of raw.split("\n")) {
-    const match = /^(\t+| +)/.exec(line);
-    if (match) return match[1];
-  }
-  return "  ";
-}
 function readToolkitConfigFile(tree) {
   const raw = tree.read(TOOLKIT_CONFIG_PATH, "utf-8");
   if (raw === null) return { raw: null, parsed: null };
@@ -1791,18 +2957,18 @@ function recordedChoice(config, key, allowed) {
   const value = config?.[key];
   return typeof value === "string" && allowed.includes(value) ? value : void 0;
 }
-var RECORDED_FRONTENDS = ["react-vite", "next", "none"];
+var RECORDED_FRONTENDS = ["react-vite", "next", "expo", "generic", "none"];
 var RECORDED_BACKENDS = ["express", "nest", "none"];
 var RECORDED_PRESETS = ["quick-start", "solo", "team"];
 var RECORDED_PACKAGE_MANAGERS = ["pnpm", "npm", "yarn", "bun"];
 function resolveFrontendOption(option, config, generator) {
   const frontend = option ?? recordedChoice(config, "frontend", RECORDED_FRONTENDS);
   if (frontend === void 0) {
-    throw new Error(`${generator}: pass --frontend=react-vite|next (toolkit.config.json records none \u2014 init writes it).`);
+    throw new Error(`${generator}: pass --frontend=react-vite|next|expo|generic (toolkit.config.json records none \u2014 init writes it).`);
   }
   if (frontend === "none") {
     throw new Error(
-      `${generator}: this is a backend-only workspace (toolkit.config.json frontend: none) \u2014 FSD structures a frontend app. Pass --frontend=react-vite|next if you added one.`
+      `${generator}: this is a backend-only workspace (toolkit.config.json frontend: none) \u2014 FSD structures a frontend app. Pass --frontend=react-vite|next|expo|generic if you added one.`
     );
   }
   return frontend;
@@ -1810,7 +2976,7 @@ function resolveFrontendOption(option, config, generator) {
 function resolveInitFrontend(option, config) {
   const frontend = option ?? recordedChoice(config, "frontend", RECORDED_FRONTENDS);
   if (frontend === void 0) {
-    throw new Error("init: pass --frontend=react-vite|next|none (toolkit.config.json records none \u2014 init writes it).");
+    throw new Error("init: pass --frontend=react-vite|next|expo|generic|none (toolkit.config.json records none \u2014 init writes it).");
   }
   return frontend;
 }
@@ -1826,21 +2992,123 @@ function resolveAiHostsOption(option, config) {
   const fromConfig = Array.isArray(recorded) ? [...new Set(recorded.filter(isAiHost))] : [];
   return fromConfig.length > 0 ? fromConfig : [...DEFAULT_AI_HOSTS];
 }
-function recordAiHosts(tree, hosts, write) {
-  const { raw, parsed } = readToolkitConfigFile(tree);
-  if (raw !== null && parsed === null) return "unrecognized";
-  const existing = parsed ?? {};
-  const recorded = existing["aiHosts"];
-  if (Array.isArray(recorded) && recorded.length === hosts.length && recorded.every((id, index) => id === hosts[index])) {
-    return "unchanged";
+function recordAiHosts(tree, hosts, write) {
+  const { raw, parsed } = readToolkitConfigFile(tree);
+  if (raw !== null && parsed === null) return "unrecognized";
+  const existing = parsed ?? {};
+  const recorded = existing["aiHosts"];
+  if (Array.isArray(recorded) && recorded.length === hosts.length && recorded.every((id, index) => id === hosts[index])) {
+    return "unchanged";
+  }
+  if (write) tree.write(TOOLKIT_CONFIG_PATH, applyJsonEdits(raw, [[["aiHosts"], [...hosts]]]));
+  return raw === null ? "created" : "updated";
+}
+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/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 };
   }
-  if (write) {
-    const indent = raw === null ? "  " : detectIndent(raw);
-    const body = JSON.stringify({ ...existing, aiHosts: [...hosts] }, null, indent);
-    tree.write(TOOLKIT_CONFIG_PATH, raw === null || raw.endsWith("\n") ? `${body}
-` : body);
+  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 };
   }
-  return raw === null ? "created" : "updated";
+  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/add-fsd-lite/render.ts
@@ -1859,8 +3127,11 @@ function renderAddFsdLiteReport(report) {
         for (const name of refusal.candidates) lines.push(`      - ${name}`);
       } else if (refusal.reason === "invalid-project-json") {
         lines.push(`    a project.json could not be parsed (${refusal.detail}) \u2014 fix it, then rerun.`);
+      } else if (refusal.otherProjects.length > 0) {
+        lines.push("    no project was recognised as a frontend app. If one of these is it, rerun with --project=<name>:");
+        for (const name of refusal.otherProjects) lines.push(`      - ${name}`);
       } else {
-        lines.push("    the workspace has no frontend application \u2014 create one (e.g. nx g @nx/react:app) or pass --project.");
+        lines.push("    the workspace has no projects \u2014 create one (e.g. nx g @nx/react:app or nx g @nx/next:app), then rerun.");
       }
     }
     return lines.join("\n");
@@ -1870,6 +3141,9 @@ function renderAddFsdLiteReport(report) {
     lines.push("");
   }
   lines.push(`FSD layers (in ${report.project}, ${report.sourceRoot}):`);
+  if (report.layerGuide !== null && report.frontend === "generic") {
+    lines.push("Frontend: framework not recognised \u2014 the common FSD rules apply, with no framework-specific layer names.");
+  }
   if (report.layerGuide !== null) lines.push(report.layerGuide);
   lines.push("");
   const where = report.eslintPath ?? `${report.project}'s eslint.config.mjs`;
@@ -1921,26 +3195,31 @@ function runAddFsdLite(tree, options) {
   const frontend = resolveFrontendOption(options.frontend, config, "add-fsd-lite");
   const dryRun = options.dryRun ?? false;
   const applyEslint = options.applyEslint ?? false;
-  const snippet = buildFsdEslintPasteSnippet(enforcement, locale);
   const app = resolveFrontendApp(tree, options.project);
   if (app.kind !== "found") {
-    const appRefusal = app.kind === "not-found" ? { reason: "project-not-found", project: app.project } : app.kind === "ambiguous" ? { reason: "ambiguous-frontend", candidates: app.candidates } : app.kind === "invalid-project-json" ? { reason: "invalid-project-json", detail: app.detail } : { reason: "no-frontend-app" };
-    return { dryRun, aborted: true, appRefusal, project: null, sourceRoot: null, enforcement, eslint: "not-applied", eslintPath: null, snippet, layerGuide: null, steiger: null };
+    const snippet2 = buildFsdEslintPasteSnippet(enforcement, locale);
+    const appRefusal = app.kind === "not-found" ? { reason: "project-not-found", project: app.project } : app.kind === "ambiguous" ? { reason: "ambiguous-frontend", candidates: app.candidates } : app.kind === "invalid-project-json" ? { reason: "invalid-project-json", detail: app.detail } : { reason: "no-frontend-app", otherProjects: app.otherProjects };
+    return { dryRun, aborted: true, appRefusal, project: null, sourceRoot: null, enforcement, frontend, eslint: "not-applied", eslintPath: null, snippet: snippet2, layerGuide: null, steiger: null };
   }
   const appDir = app.root === "" || app.root === "." ? "" : `${app.root}/`;
+  const eslintRoot = posix.relative(app.root === "" ? "." : app.root, app.sourceRoot) || ".";
+  const profile = app.framework === frontend ? app.profile : profileById(frontend);
+  const { platformSuffixes, routerDirs } = profile;
+  const framework = { platformSuffixes, routerDirs };
+  const snippet = buildFsdEslintPasteSnippet(enforcement, locale, eslintRoot, framework);
   const eslintPath = ESLINT_CONFIG_CANDIDATES.map((name) => `${appDir}${name}`).find((path) => tree.exists(path)) ?? null;
   const configText = eslintPath === null ? null : tree.read(eslintPath, "utf-8");
   let eslint;
   if (!applyEslint) {
-    eslint = configText !== null && applyFsdEslintConfig(configText, enforcement).status === "already-applied" ? "already-applied" : "snippet-only";
+    eslint = configText !== null && applyFsdEslintConfig(configText, enforcement, eslintRoot, framework).status === "already-applied" ? "already-applied" : "snippet-only";
   } else if (configText === null) {
     eslint = "degraded-unrecognized";
   } else {
-    const result = applyFsdEslintConfig(configText, enforcement);
+    const result = applyFsdEslintConfig(configText, enforcement, eslintRoot, framework);
     eslint = result.status === "applied" ? "applied" : result.status === "already-applied" ? "already-applied" : "degraded-unrecognized";
     if (result.status === "applied" && !dryRun && eslintPath !== null) tree.write(eslintPath, result.text);
   }
-  const steiger = options.steiger ? addSteiger(tree, { appDir, appRoot: app.root, sourceRoot: app.sourceRoot, frontend, locale, write: !dryRun, config }) : null;
+  const steiger = options.steiger ? addSteiger(tree, { appDir, appRoot: app.root, sourceRoot: app.sourceRoot, profile, locale, write: !dryRun, config }) : null;
   return {
     dryRun,
     aborted: false,
@@ -1949,10 +3228,11 @@ function runAddFsdLite(tree, options) {
     sourceRoot: app.sourceRoot,
     steiger,
     enforcement,
+    frontend,
     eslint,
     eslintPath,
     snippet: eslint === "applied" || eslint === "already-applied" ? null : snippet,
-    layerGuide: composeFsdLayerGuide({ frontend, sourceRoot: app.sourceRoot, locale })
+    layerGuide: composeFsdLayerGuide({ profile, sourceRoot: app.sourceRoot, locale })
   };
 }
 function readJsonObject(tree, path) {
@@ -1967,7 +3247,7 @@ function readJsonObject(tree, path) {
 }
 function addSteiger(tree, input) {
   const configPath = `${input.appDir}${STEIGER_CONFIG_FILE}`;
-  const configText = buildSteigerConfig({ frontend: input.frontend, locale: input.locale });
+  const configText = buildSteigerConfig({ renamedLayerDirs: Object.values(input.profile.layerDirs), locale: input.locale });
   const existing = tree.read(configPath, "utf-8");
   let configAction;
   if (existing === null) {
@@ -1994,8 +3274,8 @@ function addSteiger(tree, input) {
     } else {
       targets[FSD_CHECK_TARGET] = target;
       targetAction = "added";
-      if (input.write) tree.write(candidate, `${JSON.stringify(file.parsed, null, detectIndent(file.raw))}
-`);
+      const path = candidate.endsWith("project.json") ? ["targets", FSD_CHECK_TARGET] : ["nx", "targets", FSD_CHECK_TARGET];
+      if (input.write) tree.write(candidate, setJsonValue(file.raw, path, target));
     }
     break;
   }
@@ -2010,8 +3290,8 @@ function addSteiger(tree, input) {
     } else {
       for (const [name, range] of missing) devDependencies[name] = range;
       dependenciesAction = "added";
-      if (input.write) tree.write("package.json", `${JSON.stringify(rootPackage.parsed, null, detectIndent(rootPackage.raw))}
-`);
+      const edited = applyJsonEdits(rootPackage.raw, missing.map(([name, range]) => [["devDependencies", name], range]));
+      if (input.write) tree.write("package.json", edited);
     }
   }
   const pm = treePackageManager(tree, input.config) ?? "pnpm";
@@ -2033,7 +3313,8 @@ var ACTION_LINE = {
   appended: (result) => `${result.filePath}: nx-archweave block added after the existing content (nothing else changed)`,
   updated: (result) => `${result.filePath}: nx-archweave block updated (nothing outside it changed)`,
   unchanged: (result) => `${result.filePath}: unchanged`,
-  unrecognized: (result) => `${result.filePath}: not written \u2014 ${result.reason ?? "the nx-archweave markers could not be placed"}`
+  unrecognized: (result) => `${result.filePath}: not written \u2014 ${result.reason ?? "the nx-archweave markers could not be placed"}`,
+  "user-modified": (result) => `${result.filePath}: not written \u2014 the nx-archweave block was edited by hand, so it is kept`
 };
 function renderAddAgentRulesReport(report) {
   const lines = [];
@@ -2044,6 +3325,11 @@ function renderAddAgentRulesReport(report) {
   lines.push("");
   for (const file of report.files) {
     lines.push(`  ${ACTION_LINE[file.action](file)}`);
+    if (file.action === "user-modified") {
+      lines.push("    What this run would write instead (your block \u2192 generated):");
+      for (const line of (file.diff ?? "").split("\n")) lines.push(`    ${line}`);
+      lines.push("    Rerun with --overwriteBlock to replace the block with the generated one.");
+    }
   }
   const RECORD_LINE = {
     created: "toolkit.config.json: aiHosts recorded (file created)",
@@ -2057,7 +3343,7 @@ function renderAddAgentRulesReport(report) {
   if (recordLine !== null) lines.push(`  ${recordLine}`);
   if (report.files.some((file) => file.action === "unrecognized")) {
     lines.push("");
-    lines.push('Manual fix needed: keep exactly one "<!-- nx-archweave:agent-rules start -->" \u2026 "<!-- nx-archweave:agent-rules end -->"');
+    lines.push('Manual fix needed: keep exactly one "<!-- nx-archweave:agent-rules start \u2026 -->" \u2026 "<!-- nx-archweave:agent-rules end -->"');
     lines.push("pair in the file (or remove both markers), then rerun add-agent-rules.");
   }
   if (report.dryRun) {
@@ -2073,6 +3359,158 @@ function renderAddAgentRulesReport(report) {
   return lines.join("\n");
 }
 
+// src/generators/add-review/render.ts
+var DEPENDABOT_PATH = ".github/dependabot.yml";
+function renderLineDiff(existing, generated) {
+  const a = existing.split("\n");
+  const b = generated.split("\n");
+  const m = a.length;
+  const n = b.length;
+  const lcs = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i2 = m - 1; i2 >= 0; i2--) {
+    for (let j2 = n - 1; j2 >= 0; j2--) {
+      lcs[i2][j2] = a[i2] === b[j2] ? lcs[i2 + 1][j2 + 1] + 1 : Math.max(lcs[i2 + 1][j2], lcs[i2][j2 + 1]);
+    }
+  }
+  const out = ["--- existing", "+++ generated"];
+  let i = 0;
+  let j = 0;
+  while (i < m && j < n) {
+    if (a[i] === b[j]) {
+      out.push(`  ${a[i]}`);
+      i++;
+      j++;
+    } else if (lcs[i + 1][j] >= lcs[i][j + 1]) {
+      out.push(`- ${a[i]}`);
+      i++;
+    } else {
+      out.push(`+ ${b[j]}`);
+      j++;
+    }
+  }
+  while (i < m) out.push(`- ${a[i++]}`);
+  while (j < n) out.push(`+ ${b[j++]}`);
+  return out.join("\n");
+}
+var WORKFLOW_ACTION_LINES = {
+  created: "created",
+  overwritten: "overwritten with the generated version (per --onConflict=overwrite)",
+  unchanged: "unchanged (already matches the generated version)",
+  proposed: "NOT written \u2014 differs from the generated version (merge proposal below)",
+  skipped: "left as-is (per --onConflict=skip)",
+  alternate: "generated alongside the existing file",
+  aborted: "NOT written"
+};
+var CONFIG_ACTION_LINES = {
+  created: "created with the review field",
+  updated: "review field updated",
+  unchanged: "review field unchanged",
+  "not-updated": "NOT updated \u2014 kept consistent with the workflow file that is actually in effect",
+  aborted: "NOT updated"
+};
+function renderAddReviewReport(report) {
+  const lines = [];
+  if (report.packageManagerNote !== void 0) {
+    lines.push(`Note: ${report.packageManagerNote}`);
+  }
+  if (report.workflowAction === "aborted") {
+    lines.push("add-review aborted \u2014 nothing was written.");
+    lines.push(`  toolkit.config.json: ${report.configError ?? "unusable"}`);
+    lines.push("  Fix the config file manually, then rerun the generator.");
+    return lines.join("\n");
+  }
+  if (report.dryRun) {
+    lines.push("add-review dry-run \u2014 no files were written.");
+    lines.push("");
+    lines.push("Generated workflow YAML:");
+    lines.push(report.workflowYaml ?? "");
+    lines.push("");
+    lines.push("toolkit.config.json review field:");
+    lines.push(report.configSnippetJson ?? "");
+    lines.push("");
+    lines.push("Effective decision:");
+  }
+  lines.push(`  ${report.workflowPath}: ${WORKFLOW_ACTION_LINES[report.workflowAction]}`);
+  lines.push(`  toolkit.config.json: ${CONFIG_ACTION_LINES[report.configAction]}`);
+  if (report.workflowAction === "proposed" && report.diff) {
+    lines.push("");
+    lines.push(report.diff);
+    lines.push("");
+    lines.push("To resolve, rerun with one of:");
+    lines.push("  --onConflict=overwrite            replace the existing file with the generated version");
+    lines.push("  --onConflict=skip                 keep the existing file");
+    lines.push("  --onConflict=alternate-filename   write the generated version alongside it");
+  }
+  if (report.dependabot === "created") {
+    lines.push(`  ${DEPENDABOT_PATH}: created \u2014 Dependabot proposes newer pins for the workflow's actions`);
+  } else if (report.dependabot === "present") {
+    lines.push(`  ${DEPENDABOT_PATH}: already updates github-actions`);
+  } else if (report.dependabot === "proposed") {
+    lines.push(`  ${DEPENDABOT_PATH}: NOT changed \u2014 it has no github-actions entry. The workflow pins each action`);
+    lines.push("  to a commit SHA; add this entry under `updates:` so those pins get update pull requests:");
+    lines.push("");
+    lines.push(report.dependabotProposal ?? "");
+  }
+  if (report.workflowAction === "alternate") {
+    lines.push("");
+    lines.push("  Review the generated file, then replace the main workflow file with it yourself;");
+    lines.push("  the config stays pointing at the workflow that is actually in effect until you do.");
+  }
+  lines.push("");
+  lines.push(`Note: the review workflow stays green-skipped until you register the ${report.requiredSecretName} secret.`);
+  lines.push("Note: this workflow runs with elevated permissions only after it is merged to the default branch \u2014");
+  lines.push("merging is the first real validation.");
+  return lines.join("\n");
+}
+
+// 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/generators/add-agent-rules/generator.ts
 function resolveTeamRules(option, config) {
   if (option !== void 0) return option;
@@ -2087,6 +3525,13 @@ function resolveFsdStructure(config) {
   const frontend = config?.["frontend"];
   return typeof frontend === "string" && frontend !== "none";
 }
+var POLICY_KEYS = ["preset", "sliceGroups", "sharedPublicApi", "testFiles"];
+function resolveFsdPolicyNotes(config) {
+  const fsd = config?.["fsd"];
+  if (typeof fsd !== "object" || fsd === null || !POLICY_KEYS.some((key) => key in fsd)) return void 0;
+  const policy = resolveFsdPolicy(fsd);
+  return { sliceGroups: policy.sliceGroups !== false, sharedPublicApi: policy.sharedPublicApi, testFiles: policy.testFiles !== false };
+}
 function runAddAgentRules(tree, options, { recordHosts = true, fsdStructure } = {}) {
   const config = readToolkitConfig(tree);
   const hosts = resolveAiHostsOption(options.hosts, config);
@@ -2094,7 +3539,7 @@ function runAddAgentRules(tree, options, { recordHosts = true, fsdStructure } =
   const locale = resolveLocaleOption(options.locale, config);
   const teamRules = resolveTeamRules(options.teamRules, config);
   const dryRun = options.dryRun ?? false;
-  const composed = composeAgentRules({ files, locale, teamRules, fsdStructure: fsdStructure ?? resolveFsdStructure(config) });
+  const composed = composeAgentRules({ files, locale, teamRules, fsdStructure: fsdStructure ?? resolveFsdStructure(config), fsdPolicy: resolveFsdPolicyNotes(config) });
   const results = composed.map(({ filePath, content }) => {
     if (!validateAgentRules(content, teamRules ? ["team-rules"] : [])) {
       throw new Error(
@@ -2102,12 +3547,20 @@ function runAddAgentRules(tree, options, { recordHosts = true, fsdStructure } =
       );
     }
     const existing = tree.read(filePath, "utf-8");
-    const outcome = applyAgentRulesBlock(existing, content);
+    const outcome = applyAgentRulesBlock(existing, content, { overwrite: options.overwriteBlock === true });
     switch (outcome.kind) {
       case "unchanged":
         return { filePath, action: "unchanged", reason: null, content: null };
       case "unrecognized":
         return { filePath, action: "unrecognized", reason: outcome.reason, content: null };
+      case "user-modified":
+        return {
+          filePath,
+          action: "user-modified",
+          reason: null,
+          content: null,
+          diff: renderLineDiff(outcome.existingBody, outcome.generatedBody)
+        };
       case "create":
       case "append":
       case "replace": {
@@ -2203,99 +3656,6 @@ function runAddGithubTemplates(tree, options) {
   return { dryRun, files };
 }
 
-// src/generators/add-review/render.ts
-function renderLineDiff(existing, generated) {
-  const a = existing.split("\n");
-  const b = generated.split("\n");
-  const m = a.length;
-  const n = b.length;
-  const lcs = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
-  for (let i2 = m - 1; i2 >= 0; i2--) {
-    for (let j2 = n - 1; j2 >= 0; j2--) {
-      lcs[i2][j2] = a[i2] === b[j2] ? lcs[i2 + 1][j2 + 1] + 1 : Math.max(lcs[i2 + 1][j2], lcs[i2][j2 + 1]);
-    }
-  }
-  const out = ["--- existing", "+++ generated"];
-  let i = 0;
-  let j = 0;
-  while (i < m && j < n) {
-    if (a[i] === b[j]) {
-      out.push(`  ${a[i]}`);
-      i++;
-      j++;
-    } else if (lcs[i + 1][j] >= lcs[i][j + 1]) {
-      out.push(`- ${a[i]}`);
-      i++;
-    } else {
-      out.push(`+ ${b[j]}`);
-      j++;
-    }
-  }
-  while (i < m) out.push(`- ${a[i++]}`);
-  while (j < n) out.push(`+ ${b[j++]}`);
-  return out.join("\n");
-}
-var WORKFLOW_ACTION_LINES = {
-  created: "created",
-  overwritten: "overwritten with the generated version (per --onConflict=overwrite)",
-  unchanged: "unchanged (already matches the generated version)",
-  proposed: "NOT written \u2014 differs from the generated version (merge proposal below)",
-  skipped: "left as-is (per --onConflict=skip)",
-  alternate: "generated alongside the existing file",
-  aborted: "NOT written"
-};
-var CONFIG_ACTION_LINES = {
-  created: "created with the review field",
-  updated: "review field updated",
-  unchanged: "review field unchanged",
-  "not-updated": "NOT updated \u2014 kept consistent with the workflow file that is actually in effect",
-  aborted: "NOT updated"
-};
-function renderAddReviewReport(report) {
-  const lines = [];
-  if (report.packageManagerNote !== void 0) {
-    lines.push(`Note: ${report.packageManagerNote}`);
-  }
-  if (report.workflowAction === "aborted") {
-    lines.push("add-review aborted \u2014 nothing was written.");
-    lines.push(`  toolkit.config.json: ${report.configError ?? "unusable"}`);
-    lines.push("  Fix the config file manually, then rerun the generator.");
-    return lines.join("\n");
-  }
-  if (report.dryRun) {
-    lines.push("add-review dry-run \u2014 no files were written.");
-    lines.push("");
-    lines.push("Generated workflow YAML:");
-    lines.push(report.workflowYaml ?? "");
-    lines.push("");
-    lines.push("toolkit.config.json review field:");
-    lines.push(report.configSnippetJson ?? "");
-    lines.push("");
-    lines.push("Effective decision:");
-  }
-  lines.push(`  ${report.workflowPath}: ${WORKFLOW_ACTION_LINES[report.workflowAction]}`);
-  lines.push(`  toolkit.config.json: ${CONFIG_ACTION_LINES[report.configAction]}`);
-  if (report.workflowAction === "proposed" && report.diff) {
-    lines.push("");
-    lines.push(report.diff);
-    lines.push("");
-    lines.push("To resolve, rerun with one of:");
-    lines.push("  --onConflict=overwrite            replace the existing file with the generated version");
-    lines.push("  --onConflict=skip                 keep the existing file");
-    lines.push("  --onConflict=alternate-filename   write the generated version alongside it");
-  }
-  if (report.workflowAction === "alternate") {
-    lines.push("");
-    lines.push("  Review the generated file, then replace the main workflow file with it yourself;");
-    lines.push("  the config stays pointing at the workflow that is actually in effect until you do.");
-  }
-  lines.push("");
-  lines.push(`Note: the review workflow stays green-skipped until you register the ${report.requiredSecretName} secret.`);
-  lines.push("Note: this workflow runs with elevated permissions only after it is merged to the default branch \u2014");
-  lines.push("merging is the first real validation.");
-  return lines.join("\n");
-}
-
 // src/generators/add-review/generator.ts
 var CONFIG_PATH = "toolkit.config.json";
 function deriveAltWorkflowPath(mainWorkflowPath) {
@@ -2369,7 +3729,9 @@ function runAddReview(tree, options) {
       diff: null,
       workflowYaml: null,
       configSnippetJson: null,
-      configError: config.error
+      configError: config.error,
+      dependabot: "not-applied",
+      dependabotProposal: null
     };
   }
   const existing = tree.read(plan.workflowFilePath, "utf-8");
@@ -2421,17 +3783,17 @@ function runAddReview(tree, options) {
       configAction = "unchanged";
     } else {
       configAction = config.raw === null ? "created" : "updated";
-      const indent = config.raw === null ? "  " : detectIndent(config.raw);
-      const trailingNewline = config.raw === null || config.raw.endsWith("\n");
-      const body = JSON.stringify({ ...config.parsed ?? {}, review: plan.configSnippet }, null, indent);
-      newConfigContent = trailingNewline ? `${body}
-` : body;
+      newConfigContent = applyJsonEdits(config.raw, [[["review"], plan.configSnippet]]);
     }
   }
+  const [dependabotFile] = renderTemplateFiles(generatorFilesDir("add-review", import.meta.url), ".github", {});
+  const existingDependabot = tree.read(DEPENDABOT_PATH, "utf-8");
+  const dependabot = existingDependabot === null ? "created" : /github-actions/.test(existingDependabot) ? "present" : "proposed";
   const dryRun = options.dryRun ?? false;
   if (!dryRun) {
     if (writeWorkflowTo !== null) tree.write(writeWorkflowTo, plan.workflowYaml);
     if (newConfigContent !== null) tree.write(CONFIG_PATH, newConfigContent);
+    if (dependabot === "created") tree.write(DEPENDABOT_PATH, dependabotFile.content);
   }
   return {
     dryRun,
@@ -2443,6 +3805,8 @@ function runAddReview(tree, options) {
     workflowYaml: dryRun ? plan.workflowYaml : null,
     configSnippetJson: dryRun ? JSON.stringify(plan.configSnippet, null, 2) : null,
     configError: null,
+    dependabot,
+    dependabotProposal: dependabot === "proposed" ? dependabotFile.content : null,
     ...packageManagerNote !== void 0 ? { packageManagerNote } : {}
   };
 }
@@ -2492,8 +3856,9 @@ function renderAddBackendBody(report) {
   }
   if (report.packageManagerNote !== void 0) lines.push(`  note: ${report.packageManagerNote}`);
   lines.push(`  frontend project: ${report.frontendProject ?? "none (backend-only workspace)"}`);
+  const libPath = report.sharedTypesRoot ?? "libs/shared-types";
   lines.push(
-    report.sharedTypes === "created" ? `  libs/shared-types: created (import it as ${report.sharedTypesPackage})` : "  libs/shared-types: already exists \u2014 skipped"
+    report.sharedTypes === "created" ? `  ${libPath}: created (import it as ${report.sharedTypesPackage})` : report.sharedTypes === "disabled" ? "  shared-types lib: none (sharedTypes: false in toolkit.config.json)" : `  ${libPath}: already exists \u2014 skipped`
   );
   if (report.config !== void 0 && report.config !== "unchanged") {
     lines.push(`  toolkit.config.json: backend "${report.backend}" recorded (${report.config}) \u2014 doctor's backend checks now run`);
@@ -2503,11 +3868,11 @@ function renderAddBackendBody(report) {
     const registry = packageManagerCommands(pmName).workspaceRegistration;
     lines.push(
       {
-        added: `  ${registry}: 'libs/shared-types' registered \u2014 run \`${pmName} install\` once to link it`,
-        present: `  ${registry}: already covers libs/shared-types`,
+        added: `  ${registry}: '${libPath}' registered \u2014 run \`${pmName} install\` once to link it`,
+        present: `  ${registry}: already covers ${libPath}`,
         unrecognized: (
           // an integrated layout lists no workspace packages: the paths alias below links it
-          report.tsconfigPaths === "added" || report.tsconfigPaths === "present" ? `  ${registry}: no workspace package list (integrated layout) \u2014 the tsconfig paths alias links libs/shared-types` : `  ${registry}: shape not recognized \u2014 add 'libs/shared-types' to its workspace list yourself`
+          report.tsconfigPaths === "added" || report.tsconfigPaths === "present" ? `  ${registry}: no workspace package list (integrated layout) \u2014 the tsconfig paths alias links ${libPath}` : `  ${registry}: shape not recognized \u2014 add '${libPath}' to its workspace list yourself`
         )
       }[report.workspaceGlob]
     );
@@ -2520,7 +3885,8 @@ function renderAddBackendBody(report) {
       added: `  tsconfig.base.json paths: ${report.sharedTypesPackage} added (a classic or integrated setup \u2014 libs resolve through paths)`,
       present: "  tsconfig.base.json paths: already wired",
       "workspace-link": "  tsconfig paths: not needed \u2014 the workspace package link is the wiring",
-      unrecognized: "  tsconfig.base.json: could not be parsed \u2014 left untouched"
+      unrecognized: "  tsconfig.base.json: could not be parsed \u2014 left untouched",
+      none: "  tsconfig paths: nothing to wire (no shared-types lib)"
     }[report.tsconfigPaths]
   );
   switch (report.eslint) {
@@ -2547,7 +3913,6 @@ function renderAddBackendBody(report) {
 }
 
 // src/generators/add-backend/generator.ts
-var SHARED_TYPES_ROOT = "libs/shared-types";
 function runAddBackend(tree, options) {
   const backend = options.backend;
   const apiName = options.apiName ?? "api";
@@ -2622,8 +3987,9 @@ function runAddBackend(tree, options) {
       } catch {
       }
     }
-    const frontendParent = (projects.get(frontendProject)?.root ?? "").split("/").slice(0, -1).join("/");
-    const apiDirectory = `${frontendParent === "" || frontendParent === "." ? "apps" : frontendParent}/${apiName}`;
+    const frontendRoot = projects.get(frontendProject)?.root ?? "";
+    const frontendParent = frontendRoot.split("/").slice(0, -1).join("/");
+    const apiDirectory = frontendRoot === "" || frontendRoot === "." ? `apps/${apiName}` : `${frontendParent === "" ? "" : `${frontendParent}/`}${apiName}`;
     const expressAlignment = backend === "express" && !expressDeclared ? readExpressPeerRange(tree) : void 0;
     const quotedExpress = expressAlignment ? `"express@${expressAlignment}"` : void 0;
     return {
@@ -2639,16 +4005,21 @@ function runAddBackend(tree, options) {
       ...refusalShape
     };
   }
-  const sharedTypesExists = tree.exists(`${SHARED_TYPES_ROOT}/package.json`) || tree.exists(`${SHARED_TYPES_ROOT}/project.json`);
+  const recordedConfig = readToolkitConfigFile(tree).parsed;
+  const boundaryTags = readBoundaryTags(recordedConfig);
+  const sharedTypesConfig = readSharedTypesConfig(recordedConfig);
+  const withSharedTypes = sharedTypesConfig !== false;
+  const sharedTypesRoot = sharedTypesConfig === false ? "" : sharedTypesConfig.path;
+  const sharedTypesExists = withSharedTypes && (tree.exists(`${sharedTypesRoot}/package.json`) || tree.exists(`${sharedTypesRoot}/project.json`));
   const rootPackageJson = tree.read("package.json", "utf-8");
   const workspaceName = rootPackageJson ? JSON.parse(rootPackageJson).name ?? "workspace" : "workspace";
-  const wiring = composeBackendWiring({ workspaceName });
+  const wiring = composeBackendWiring({ workspaceName, tags: boundaryTags, ...sharedTypesConfig === false ? {} : { sharedTypes: sharedTypesConfig } });
   const [apiProjectName, apiConfig] = apiEntry;
   const tagTargets = [
     ...frontendProject === void 0 ? [] : [{ project: frontendProject, root: projects.get(frontendProject)?.root ?? `apps/${frontendProject}` }],
     { project: apiProjectName, root: apiConfig.root }
   ];
-  if (sharedTypesExists) tagTargets.push({ project: wiring.sharedTypesPackageName, root: SHARED_TYPES_ROOT });
+  if (sharedTypesExists) tagTargets.push({ project: wiring.sharedTypesPackageName, root: sharedTypesRoot });
   const parsedTargets = /* @__PURE__ */ new Map();
   const invalidProjects = [];
   for (const target of tagTargets) {
@@ -2670,7 +4041,7 @@ function runAddBackend(tree, options) {
   if (invalidProjects.length > 0) {
     return { ...base, refused: "invalid-project-json", frontendProject, invalidProjects, ...refusalShape };
   }
-  const sharedTypes = sharedTypesExists ? "skipped" : "created";
+  const sharedTypes = !withSharedTypes ? "disabled" : sharedTypesExists ? "skipped" : "created";
   if (sharedTypes === "created" && write) {
     for (const file of wiring.sharedTypesFiles) tree.write(file.filePath, file.content);
   }
@@ -2681,20 +4052,19 @@ function runAddBackend(tree, options) {
     const existing = configParsed ?? {};
     if (parseOk && existing["backend"] !== backend) {
       configOutcome = configRaw === null ? "created" : "updated";
-      const indent = configRaw === null ? "  " : detectIndent(configRaw);
-      if (write) tree.write(TOOLKIT_CONFIG_PATH, `${JSON.stringify({ ...existing, backend }, null, indent)}
-`);
+      if (write) tree.write(TOOLKIT_CONFIG_PATH, applyJsonEdits(configRaw, [[["backend"], backend]]));
     }
   }
-  let workspaceGlob = "unrecognized";
-  const workspaceYaml = tree.read("pnpm-workspace.yaml", "utf-8");
-  if (workspaceYaml !== null) {
-    const globResult = addSharedTypesWorkspaceGlob(workspaceYaml);
+  let workspaceGlob = withSharedTypes ? "unrecognized" : void 0;
+  const workspaceYaml = withSharedTypes ? tree.read("pnpm-workspace.yaml", "utf-8") : null;
+  if (!withSharedTypes) {
+  } else if (workspaceYaml !== null) {
+    const globResult = addSharedTypesWorkspaceGlob(workspaceYaml, sharedTypesRoot);
     workspaceGlob = globResult.status;
     if (globResult.status === "added" && write) tree.write("pnpm-workspace.yaml", globResult.text);
   } else if ((detectedPm === "npm" || detectedPm === "yarn" || detectedPm === "bun") && rootPackageJson !== null) {
     const yarnNeedsPrivate = detectedPm === "yarn" && JSON.parse(rootPackageJson).private !== true;
-    const npmResult = yarnNeedsPrivate ? { status: "unrecognized" } : addSharedTypesNpmWorkspace(rootPackageJson);
+    const npmResult = yarnNeedsPrivate ? { status: "unrecognized" } : addSharedTypesNpmWorkspace(rootPackageJson, sharedTypesRoot);
     workspaceGlob = npmResult.status;
     if (npmResult.status === "added" && write) tree.write("package.json", npmResult.text);
   }
@@ -2705,17 +4075,17 @@ function runAddBackend(tree, options) {
     const tags2 = holder.tags ?? [];
     if (tags2.includes(tag)) return { project, action: "present" };
     holder.tags = [...tags2, tag];
-    if (write) tree.write(target.path, `${JSON.stringify(target.parsed, null, detectIndent(target.raw))}
-`);
+    target.raw = appendJsonArrayItem(target.raw, target.kind === "project" ? ["tags"] : ["nx", "tags"], tag);
+    if (write) tree.write(target.path, target.raw);
     return { project, action: "added" };
   };
   const tags = [
     ...frontendProject === void 0 ? [] : [mergeTag(frontendProject, wiring.tagByRole.frontend)],
     mergeTag(apiProjectName, wiring.tagByRole.backend),
-    mergeTag(wiring.sharedTypesPackageName, wiring.tagByRole.shared)
+    ...withSharedTypes ? [mergeTag(wiring.sharedTypesPackageName, wiring.tagByRole.shared)] : []
   ];
-  let tsconfigPaths = "workspace-link";
-  const tsconfigRaw = tree.read("tsconfig.base.json", "utf-8");
+  let tsconfigPaths = withSharedTypes ? "workspace-link" : "none";
+  const tsconfigRaw = withSharedTypes ? tree.read("tsconfig.base.json", "utf-8") : null;
   if (tsconfigRaw !== null) {
     try {
       const tsconfig = JSON.parse(tsconfigRaw);
@@ -2726,10 +4096,8 @@ function runAddBackend(tree, options) {
           tsconfigPaths = "present";
         } else {
           tsconfigPaths = "added";
-          paths[wiring.sharedTypesPackageName] = [`${baseUrl ? "" : "./"}${SHARED_TYPES_ROOT}/src/index.ts`];
-          tsconfig.compilerOptions.paths = paths;
-          if (write) tree.write("tsconfig.base.json", `${JSON.stringify(tsconfig, null, detectIndent(tsconfigRaw))}
-`);
+          const entry = [`${baseUrl ? "" : "./"}${sharedTypesRoot}/src/index.ts`];
+          if (write) tree.write("tsconfig.base.json", setJsonValue(tsconfigRaw, ["compilerOptions", "paths", wiring.sharedTypesPackageName], entry));
         }
       }
     } catch {
@@ -2740,11 +4108,11 @@ function runAddBackend(tree, options) {
   let snippet;
   if (!applyEslint) {
     eslint = "snippet-only";
-    snippet = buildBoundarySnippet();
+    snippet = buildBoundarySnippet(boundaryTags);
   } else {
     const configPath = ESLINT_CONFIG_CANDIDATES.find((candidate) => tree.exists(candidate));
     const configText = configPath ? tree.read(configPath, "utf-8") : null;
-    const result = configText !== null ? applyBoundaryConstraints(configText) : { status: "unrecognized" };
+    const result = configText !== null ? applyBoundaryConstraints(configText, boundaryTags) : { status: "unrecognized" };
     if (result.status === "applied") {
       eslint = "applied";
       if (write && configPath) tree.write(configPath, result.text);
@@ -2752,7 +4120,7 @@ function runAddBackend(tree, options) {
       eslint = "already-applied";
     } else {
       eslint = "degraded-unrecognized";
-      snippet = buildBoundarySnippet();
+      snippet = buildBoundarySnippet(boundaryTags);
     }
   }
   return {
@@ -2764,7 +4132,8 @@ function runAddBackend(tree, options) {
     tsconfigPaths,
     eslint,
     snippet,
-    sharedTypesPackage: wiring.sharedTypesPackageName,
+    sharedTypesPackage: withSharedTypes ? wiring.sharedTypesPackageName : void 0,
+    sharedTypesRoot: withSharedTypes ? sharedTypesRoot : void 0,
     config: configOutcome,
     packageManager,
     ...packageManagerNote !== void 0 ? { packageManagerNote } : {}
@@ -2808,8 +4177,12 @@ function sectionAborted(section) {
   if (section.report === null) return false;
   if (section.report.kind === "fsd") return section.report.report.aborted;
   if (section.report.kind === "review") return section.report.report.workflowAction === "aborted";
+  if (section.report.kind === "backend") return section.report.report.refused !== void 0;
   return false;
 }
+function failedSections(report) {
+  return report.sections.filter(sectionAborted).map((section) => SECTION_TITLES[section.id]);
+}
 function renderInitReport(report) {
   const lines = [];
   const backendSuffix = report.backend === "none" ? "" : `, backend: ${report.backend}`;
@@ -2818,8 +4191,8 @@ function renderInitReport(report) {
   if (report.refused) {
     lines.push("");
     lines.push("Refused: the working tree has uncommitted changes.");
-    lines.push("  init only runs against a clean working tree, so a partial run can always be undone");
-    lines.push("  with a single `git restore .` \u2014 commit or stash your changes, then rerun.");
+    lines.push("  init only runs against a clean working tree, so a partial run can be rolled back exactly");
+    lines.push("  to what was committed \u2014 commit or stash your changes, then rerun.");
     return lines.join("\n");
   }
   for (const section of report.sections) {
@@ -2871,21 +4244,20 @@ function renderInitReport(report) {
   if (ranDirty) {
     lines.push("");
     lines.push("Note: --allowDirty was set and the working tree already had uncommitted changes \u2014");
-    lines.push("`git restore .` also reverts those pre-existing changes, not only what this run wrote.");
+    lines.push("restoring the files this run modified also reverts your earlier changes to them.");
   }
   const hadAbort = report.sections.some(sectionAborted);
   if (!report.dryRun && hadAbort) {
     lines.push("");
-    if (ranDirty) {
-      lines.push("One or more sections aborted. Everything this run wrote can be undone with:");
-      lines.push("  git restore .");
-      lines.push("  (--allowDirty: this also reverts the pre-existing uncommitted changes noted above.)");
-    } else {
-      lines.push(
-        "One or more sections aborted. init never runs against a dirty tree (see above), so everything"
-      );
-      lines.push("this run wrote can be undone in one step:");
-      lines.push("  git restore .");
+    lines.push("One or more sections aborted. To undo what this run wrote:");
+    const written = report.written ?? { created: [], modified: [] };
+    if (written.modified.length > 0) {
+      lines.push(`  git restore -- ${written.modified.join(" ")}`);
+      if (ranDirty) lines.push("  (--allowDirty: this also reverts the uncommitted changes those files already had.)");
+    }
+    if (written.created.length > 0) {
+      lines.push("  Created by this run (untracked \u2014 delete them yourself; `git clean -n` lists them):");
+      for (const path of written.created) lines.push(`    ${path}`);
     }
   }
   return lines.join("\n");
@@ -2958,48 +4330,34 @@ function recordPresetChoices(tree, choices, notRecorded, write) {
   if (choices.enforcement !== void 0) fields.push("fsd.enforcement");
   if (choices.teamRules !== void 0) fields.push("agentRules.teamRules");
   if (choices.aiHosts !== void 0) fields.push("aiHosts");
+  if (choices.frontends !== void 0) fields.push("frontends");
   if (fields.length === 0) return { action: "skipped", fields, notRecorded };
   const { raw, parsed } = readToolkitConfigFile(tree);
   if (raw !== null && parsed === null) return { action: "unrecognized", fields, notRecorded };
   const existing = parsed ?? {};
-  const asObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
-  const next = { ...existing };
-  let changed = false;
+  const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+  const edits = [];
   for (const key of topLevel) {
-    if (existing[key] !== choices[key]) {
-      next[key] = choices[key];
-      changed = true;
-    }
-  }
-  if (choices.enforcement !== void 0) {
-    const fsd = asObject(existing["fsd"]);
-    if (fsd["enforcement"] !== choices.enforcement) {
-      next["fsd"] = { ...fsd, enforcement: choices.enforcement };
-      changed = true;
-    }
-  }
-  if (choices.teamRules !== void 0) {
-    const agentRules = asObject(existing["agentRules"]);
-    if (agentRules["teamRules"] !== choices.teamRules) {
-      next["agentRules"] = { ...agentRules, teamRules: choices.teamRules };
-      changed = true;
-    }
+    if (existing[key] !== choices[key]) edits.push([[key], choices[key]]);
   }
+  const nested = (parent, key, value) => {
+    const holder = existing[parent];
+    if (isObject(holder) && holder[key] === value) return;
+    edits.push(isObject(holder) ? [[parent, key], value] : [[parent], { [key]: value }]);
+  };
+  if (choices.enforcement !== void 0) nested("fsd", "enforcement", choices.enforcement);
+  if (choices.teamRules !== void 0) nested("agentRules", "teamRules", choices.teamRules);
   if (choices.aiHosts !== void 0) {
     const recorded = existing["aiHosts"];
     if (!Array.isArray(recorded) || recorded.join("\0") !== choices.aiHosts.join("\0")) {
-      next["aiHosts"] = [...choices.aiHosts];
-      changed = true;
+      edits.push([["aiHosts"], [...choices.aiHosts]]);
     }
   }
-  if (!changed) return { action: "unchanged", fields, notRecorded };
-  if (write) {
-    const indent = raw === null ? "  " : detectIndent(raw);
-    const trailingNewline = raw === null || raw.endsWith("\n");
-    const body = JSON.stringify(next, null, indent);
-    tree.write(TOOLKIT_CONFIG_PATH, trailingNewline ? `${body}
-` : body);
+  if (choices.frontends !== void 0 && JSON.stringify(existing["frontends"]) !== JSON.stringify(choices.frontends)) {
+    edits.push([["frontends"], choices.frontends]);
   }
+  if (edits.length === 0) return { action: "unchanged", fields, notRecorded };
+  if (write) tree.write(TOOLKIT_CONFIG_PATH, applyJsonEdits(raw, edits));
   return { action: raw === null ? "created" : "updated", fields, notRecorded };
 }
 function keptReviewProvider(option, config) {
@@ -3007,13 +4365,32 @@ function keptReviewProvider(option, config) {
   const hosts = resolveAiHostsOption(option, config);
   return hosts[0] === recordedHosts[0] ? recordedReview(config).provider : void 0;
 }
+function pendingContents(tree) {
+  return new Map(tree.listChanges().map((change) => [change.path, change.content?.toString("utf-8") ?? null]));
+}
+function writtenSince(before, tree) {
+  const created = [];
+  const modified = [];
+  for (const change of tree.listChanges()) {
+    if (change.type === "DELETE") continue;
+    if (!before.has(change.path)) {
+      (change.type === "CREATE" ? created : modified).push(change.path);
+    } else if (before.get(change.path) !== (change.content?.toString("utf-8") ?? null)) {
+      modified.push(change.path);
+    }
+  }
+  return { created: created.sort(), modified: modified.sort() };
+}
 function runInit(tree, options, deps) {
+  const before = pendingContents(tree);
   const recorded = readToolkitConfigFile(tree).parsed;
   const preset = options.preset ?? recordedChoice(recorded, "preset", RECORDED_PRESETS);
   if (preset === void 0) {
     throw new Error("init: pass --preset=quick-start|solo|team (toolkit.config.json records none).");
   }
-  const frontend = resolveInitFrontend(options.frontend, recorded);
+  const app = options.frontend === void 0 && recordedChoice(recorded, "frontend", RECORDED_FRONTENDS) === void 0 ? resolveFrontendApp(tree, void 0) : null;
+  const detected = app?.kind === "found" && app.framework !== "generic" ? app.framework : void 0;
+  const frontend = resolveInitFrontend(options.frontend ?? detected, recorded);
   const backend = options.backend ?? recordedChoice(recorded, "backend", RECORDED_BACKENDS) ?? "none";
   if (frontend === "none" && backend === "none") {
     throw new Error("init: --frontend=none is a backend-only workspace \u2014 pass --backend=express|nest.");
@@ -3043,17 +4420,30 @@ function runInit(tree, options, deps) {
   });
   const sections = [];
   const fsdEnabled = frontend !== "none" && (options.fsd ?? config.fsd.enabled);
+  const passedProjects = (Array.isArray(options.project) ? options.project : (options.project ?? "").split(",")).map((name) => name.trim()).filter((name) => name !== "");
+  const projects = passedProjects.length > 0 ? passedProjects : recordedFrontends(recorded);
   if (fsdEnabled) {
-    try {
-      const report = runAddFsdLite(tree, { frontend, locale, dryRun, enforcement: config.fsd.enforcement, applyEslint: options.applyEslint ?? false });
-      sections.push({ id: "fsd", enabled: true, report: { kind: "fsd", report } });
-    } catch (error) {
-      sections.push({
-        id: "fsd",
-        enabled: true,
-        report: null,
-        thrownError: error instanceof Error ? error.message : String(error)
-      });
+    for (const project of projects.length === 0 ? [void 0] : projects) {
+      const found = project === void 0 ? null : resolveFrontendApp(tree, project);
+      const appFrontend = found?.kind === "found" && found.framework !== "generic" ? found.framework : frontend;
+      try {
+        const report = runAddFsdLite(tree, {
+          frontend: appFrontend,
+          locale,
+          dryRun,
+          enforcement: config.fsd.enforcement,
+          applyEslint: options.applyEslint ?? false,
+          ...project === void 0 ? {} : { project }
+        });
+        sections.push({ id: "fsd", enabled: true, report: { kind: "fsd", report } });
+      } catch (error) {
+        sections.push({
+          id: "fsd",
+          enabled: true,
+          report: null,
+          thrownError: error instanceof Error ? error.message : String(error)
+        });
+      }
     }
   } else {
     sections.push({ id: "fsd", enabled: false, report: null });
@@ -3093,7 +4483,9 @@ function runInit(tree, options, deps) {
     const report = runAddBackend(tree, {
       backend: config.backend,
       applyEslint: options.applyEslint ?? false,
-      dryRun
+      dryRun,
+      // add-backend wires one frontend: the one --project names, when it names one
+      ...projects.length === 1 ? { frontendProject: projects[0] } : {}
     });
     sections.push({ id: "backend", enabled: true, report: { kind: "backend", report } });
   } else {
@@ -3115,12 +4507,13 @@ function runInit(tree, options, deps) {
   } else {
     sections.push({ id: "review", enabled: false, report: null });
   }
-  const fsdSection = sections.find((s) => s.id === "fsd");
-  const fsdRan = fsdSection?.enabled === true;
-  const fsdApplied = fsdSection?.report?.kind === "fsd" && !fsdSection.report.report.aborted;
+  const fsdSections = sections.filter((s) => s.id === "fsd");
+  const fsdRan = fsdSections.some((s) => s.enabled);
+  const fsdApplied = fsdRan && fsdSections.every((s) => s.report?.kind === "fsd" && !s.report.report.aborted);
   const agentRulesSection = sections.find((s) => s.id === "agentRules");
   const agentRulesRan = agentRulesSection?.enabled === true;
-  const agentRulesApplied = agentRulesSection?.report?.kind === "agentRules" && agentRulesSection.report.report.files.every((f) => f.action !== "unrecognized");
+  const agentRulesApplied = agentRulesSection?.report?.kind === "agentRules" && // a block kept because the user edited it does not carry this run's choices either
+  agentRulesSection.report.report.files.every((f) => f.action !== "unrecognized" && f.action !== "user-modified");
   const reviewSection = sections.find((s) => s.id === "review");
   const reviewApplied = reviewSection?.report?.kind === "review" && ["created", "updated", "unchanged"].includes(reviewSection.report.report.configAction);
   const anyChoiceApplied = fsdApplied || agentRulesApplied || reviewApplied;
@@ -3149,7 +4542,11 @@ function runInit(tree, options, deps) {
       packageManager: anyChoiceApplied && knownPackageManager !== null ? knownPackageManager : void 0,
       enforcement: fsdApplied ? config.fsd.enforcement : void 0,
       teamRules: agentRulesApplied ? config.agentRules.teamRules : void 0,
-      aiHosts: agentRulesApplied ? config.aiHosts : void 0
+      aiHosts: agentRulesApplied ? config.aiHosts : void 0,
+      // with --project, the apps each FSD section set up
+      frontends: fsdApplied && projects.length > 0 ? fsdSections.flatMap(
+        (s) => s.report?.kind === "fsd" && s.report.report.project !== null && s.report.report.sourceRoot !== null ? [{ project: s.report.report.project, framework: s.report.report.frontend, sourceRoot: s.report.report.sourceRoot }] : []
+      ) : void 0
     },
     notRecorded,
     !dryRun
@@ -3164,7 +4561,8 @@ function runInit(tree, options, deps) {
     allowDirty,
     refused: false,
     sections,
-    config: configOutcome
+    config: configOutcome,
+    written: dryRun ? void 0 : writtenSince(before, tree)
   };
 }
 function gitIsWorkingTreeClean(root) {
@@ -3194,13 +4592,21 @@ async function initGenerator(tree, options, deps = { isWorkingTreeClean: gitIsWo
   const changesBefore = tree.listChanges().length;
   const report = runInit(tree, { ...options, dryRun: resolveDryRun(options) }, deps);
   console.log(renderInitReport(report));
+  const failed = options.strict === true ? report.refused ? ["the dirty-tree check"] : failedSections(report) : [];
+  const strictFailure = failed.length === 0 ? null : new Error(`init --strict: a section aborted (${failed.join(", ")}) \u2014 see the report above.`);
+  if (strictFailure !== null && (report.dryRun || report.refused)) throw strictFailure;
   if (report.dryRun || report.refused) return;
-  if (tree.listChanges().length === changesBefore) return;
+  const wrote = tree.listChanges().length !== changesBefore;
+  if (!wrote) {
+    if (strictFailure !== null) throw strictFailure;
+    return;
+  }
   const workflowPaths = collectWrittenWorkflowPaths(report);
   const root = tree.root;
   const graphOutputFile = join2(tmpdir(), `nx-archweave-init-graph-${Date.now()}.json`);
   return () => {
     runPostInitValidation({ root, workflowPaths, graphOutputFile }, createProcessExec());
+    if (strictFailure !== null) throw strictFailure;
   };
 }
 var generator_default = initGenerator;