agent-method 1.5.12

package/lib/init.js

@@ -0,0 +1,692 @@
+/**
+ * Interactive project setup — Node.js port of setup.sh.
+ *
+ * Creates a new methodology instance from templates with interactive
+ * prompts for project configuration.
+ */
+
+import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, copyFileSync, writeFileSync } from "node:fs";
+import { resolve, join, dirname, basename, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import { safeCopyFile, safeWriteFile } from "./cli/helpers.js";
+import { buildDefaultNodes, buildDefaultEdges } from "./dependencies.js";
+
+/** Entry point filenames that bypass the extension-based safety check. */
+const ENTRY_POINT_NAMES = new Set(["CLAUDE.md", ".cursorrules", "AGENT.md"]);
+
+/** Write file — allows entry points (e.g. .cursorrules) plus safe extensions. */
+function writeInitFile(filePath, content, encoding = "utf-8") {
+  const name = basename(filePath);
+  if (ENTRY_POINT_NAMES.has(name)) {
+    writeFileSync(filePath, content, encoding);
+  } else {
+    safeWriteFile(filePath, content, encoding);
+  }
+}
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const EXTENSION_MAP = {
+  code: "code-project.md",
+  data: "data-exploration.md",
+  analytical: "analytical-system.md",
+};
+
+const FRIENDLY_NAMES = {
+  code: "Code project",
+  data: "Data exploration",
+  analytical: "Analytical/prompt system",
+  mixed: "Multi-type project",
+  general: "General project",
+};
+
+const RUNTIME_ENTRY_POINTS = {
+  claude: "CLAUDE.md",
+  cursor: ".cursorrules",
+  all: null, // keep all
+};
+
+/**
+ * Set up a new project with methodology templates.
+ */
+export async function initProject(projectType, directory, opts = {}) {
+  const { tier = "starter", runtime = "all", profile = "standard", onboarding = "auto", registryPath } = opts;
+  const targetDir = resolve(directory);
+  const methodRoot = resolve(__dirname, "..");
+
+  const templateDir = join(methodRoot, "templates", tier);
+  if (!existsSync(templateDir)) {
+    console.error(`Template directory not found: ${templateDir}`);
+    process.exit(1);
+  }
+
+  console.log(`\nSetting up ${FRIENDLY_NAMES[projectType] || projectType} project`);
+  console.log(`  Template:   ${tier}`);
+  console.log(`  Profile:    ${profile}`);
+  console.log(`  Runtime:    ${runtime}`);
+  console.log(`  Onboarding: ${onboarding}`);
+  console.log(`  Target:     ${targetDir}\n`);
+
+  // Determine brownfield mode from user selection or auto-detection
+  let isBrownfield;
+  if (onboarding === "brownfield") {
+    isBrownfield = true;
+  } else if (onboarding === "greenfield") {
+    isBrownfield = false;
+  } else {
+    // auto — detect from existing files
+    isBrownfield = detectBrownfield(targetDir);
+  }
+
+  if (isBrownfield) {
+    console.log("  Brownfield mode — will append to existing entry points, not overwrite.\n");
+  }
+
+  // Create target directory
+  mkdirSync(targetDir, { recursive: true });
+
+  // Copy template files
+  const copied = [];
+  const skipped = [];
+  copyTemplateDir(templateDir, targetDir, copied, skipped, isBrownfield, runtime);
+
+  // Phase 7q: Ensure .context/ exists with PROTOCOL and DOCS-MAP (avoid post-init validation failures)
+  ensureContextDirectory(methodRoot, templateDir, targetDir, tier, copied);
+
+  // Apply extensions based on project type
+  const extensions = getExtensions(projectType);
+  for (const ext of extensions) {
+    const extFile = join(methodRoot, "templates", "extensions", ext);
+    if (existsSync(extFile)) {
+      mergeExtension(extFile, targetDir, isBrownfield);
+      copied.push(`extension: ${ext}`);
+    }
+  }
+
+  // Copy feature-registry.yaml to user project (populated, from package)
+  copyFeatureRegistry(methodRoot, targetDir, copied);
+
+  // Create project-specific doc-tokens.yaml with initial values
+  createProjectTokens(targetDir, projectType, tier, profile, onboarding, copied);
+
+  // Post-process PROTOCOL.yaml and INDEX.yaml (replace date placeholders)
+  postProcessYamlFiles(targetDir, projectType, tier);
+
+  // Replace placeholders in entry points (Phase 7q: project name and description)
+  replacePlaceholders(targetDir, projectType, tier, opts);
+
+  // Set integration profile in entry points
+  setProfile(targetDir, profile);
+
+  // Set onboarding scenario in PROJECT-PROFILE.md
+  setOnboardingScenario(targetDir, onboarding, isBrownfield, projectType);
+
+  // Phase 7r: Persist brownfield questionnaire to PROJECT-PROFILE.md when provided
+  if (opts.brownfieldQuestionnaire) {
+    persistBrownfieldQuestionnaire(targetDir, opts.brownfieldQuestionnaire);
+  }
+
+  // Remove unused entry points based on runtime choice
+  const removed = removeUnusedEntryPoints(targetDir, runtime, isBrownfield);
+
+  // Report
+  console.log(`  Files created: ${copied.length}`);
+  for (const f of copied) console.log(`    + ${f}`);
+  if (removed.length > 0) {
+    console.log(`  Entry points removed: ${removed.length}`);
+    for (const f of removed) console.log(`    - ${f}`);
+  }
+  if (skipped.length > 0) {
+    console.log(`  Files skipped (already exist): ${skipped.length}`);
+    for (const f of skipped) console.log(`    ~ ${f}`);
+  }
+
+  // Determine which entry point the user kept
+  const keptEntry = runtime === "claude" ? "CLAUDE.md"
+    : runtime === "cursor" ? ".cursorrules"
+    : "CLAUDE.md / .cursorrules / AGENT.md";
+
+  console.log(`\nNext steps:`);
+  let step = 1;
+  console.log(`  ${step++}. cd ${relative(process.cwd(), targetDir) || "."}`);
+  if (runtime === "all") {
+    console.log(`  ${step++}. Delete the two entry point files you don't use`);
+    console.log(`     (keep CLAUDE.md, .cursorrules, or AGENT.md)`);
+  }
+  console.log(`  ${step++}. Start a conversation with your agent — it reads ${keptEntry} automatically`);
+  if (isBrownfield) {
+    console.log(`     The agent will scan your codebase and walk you through 5 onboarding stages`);
+    console.log(`     (scan → clarify → map → organize → starting state)`);
+  } else {
+    console.log(`     The agent will walk you through 4 onboarding stages`);
+    console.log(`     (vision → architecture → goals → starting state)`);
+  }
+  console.log(`\nVerify: wwa check`);
+}
+
+function detectBrownfield(dir) {
+  if (!existsSync(dir)) return false;
+  const indicators = ["CLAUDE.md", ".cursorrules", "AGENT.md", "STATE.md", ".context"];
+  let count = 0;
+  for (const ind of indicators) {
+    if (existsSync(join(dir, ind))) count++;
+  }
+  return count >= 2;
+}
+
+/** Phase 7q: Ensure .context/ exists with PROTOCOL.yaml and DOCS-MAP.md so wwa check can pass. */
+function ensureContextDirectory(methodRoot, templateDir, targetDir, tier, copied) {
+  const contextDir = join(targetDir, ".context");
+  mkdirSync(contextDir, { recursive: true });
+
+  const protocolPath = join(targetDir, ".context", "PROTOCOL.yaml");
+  if (!existsSync(protocolPath)) {
+    const srcProtocol = join(templateDir, ".context", "PROTOCOL.yaml");
+    if (existsSync(srcProtocol)) {
+      safeCopyFile(srcProtocol, protocolPath);
+      copied.push(".context/PROTOCOL.yaml (created)");
+    }
+  }
+
+  const docsMapPath = join(targetDir, ".context", "DOCS-MAP.md");
+  if (!existsSync(docsMapPath)) {
+    const docsMapContent = [
+      "# DOCS-MAP — component-to-docs mapping",
+      "",
+      "Populated during first-session onboarding. See METHODOLOGY.md for scaffolding rules.",
+      "",
+      "| Component | Docs path |",
+      "|-----------|-----------|",
+      "| (add during onboarding) | docs/ |",
+      "",
+    ].join("\n");
+    safeWriteFile(docsMapPath, docsMapContent, "utf-8");
+    copied.push(".context/DOCS-MAP.md (created)");
+  }
+}
+
+function copyTemplateDir(src, dst, copied, skipped, isBrownfield, runtime) {
+  if (!existsSync(src)) return;
+  mkdirSync(dst, { recursive: true });
+
+  for (const entry of readdirSync(src, { withFileTypes: true })) {
+    const srcPath = join(src, entry.name);
+    const dstPath = join(dst, entry.name);
+
+    if (entry.isDirectory()) {
+      copyTemplateDir(srcPath, dstPath, copied, skipped, isBrownfield, runtime);
+    } else {
+      // Entry points: special handling in brownfield
+      const isEntryPoint = ["CLAUDE.md", ".cursorrules", "AGENT.md"].includes(entry.name);
+
+      // Skip entry points that won't be kept (avoids safety invariant issue with .cursorrules)
+      if (isEntryPoint && runtime !== "all" && !isBrownfield) {
+        const keep = RUNTIME_ENTRY_POINTS[runtime];
+        if (keep && entry.name !== keep) continue;
+      }
+
+      // Defer heavy infrastructure files in brownfield to reduce first-session load
+      const isDeferredInBrownfield = isBrownfield && entry.name === "REGISTRY.md";
+      if (isDeferredInBrownfield) {
+        skipped.push(`${relative(dst, dstPath)} (deferred — created on first file split)`);
+        continue;
+      }
+
+      if (existsSync(dstPath)) {
+        if (isEntryPoint && isBrownfield) {
+          // Append methodology sections to existing entry point
+          appendToEntryPoint(srcPath, dstPath);
+          copied.push(`${relative(dst, dstPath)} (merged)`);
+        } else {
+          skipped.push(relative(dst, dstPath));
+        }
+      } else if (isEntryPoint) {
+        // Entry points bypass safeCopyFile (e.g. .cursorrules has no .md extension)
+        copyFileSync(srcPath, dstPath);
+        copied.push(relative(dst, dstPath));
+      } else {
+        safeCopyFile(srcPath, dstPath);
+        copied.push(relative(dst, dstPath));
+      }
+    }
+  }
+}
+
+function appendToEntryPoint(srcPath, dstPath) {
+  const srcContent = readFileSync(srcPath, "utf-8");
+  let dstContent = readFileSync(dstPath, "utf-8");
+
+  // Extract sections from template that don't exist in target
+  const sections = ["## Scoping rules", "## Dependency cascade", "## Conventions", "## Do not"];
+  for (const section of sections) {
+    if (!dstContent.includes(section) && srcContent.includes(section)) {
+      const idx = srcContent.indexOf(section);
+      // Find the next section or end
+      let endIdx = srcContent.length;
+      for (const nextSection of sections) {
+        const nextIdx = srcContent.indexOf(nextSection, idx + section.length);
+        if (nextIdx > idx && nextIdx < endIdx) {
+          endIdx = nextIdx;
+        }
+      }
+      const sectionContent = srcContent.slice(idx, endIdx).trim();
+      dstContent += "\n\n" + sectionContent;
+    }
+  }
+
+  writeInitFile(dstPath, dstContent, "utf-8");
+}
+
+function getExtensions(projectType) {
+  if (projectType === "mixed") {
+    return Object.values(EXTENSION_MAP);
+  }
+  const ext = EXTENSION_MAP[projectType];
+  return ext ? [ext] : [];
+}
+
+function mergeExtension(extFile, targetDir, isBrownfield) {
+  const content = readFileSync(extFile, "utf-8");
+
+  // Extract scoping rows and cascade rows from extension file
+  const scopingRows = [];
+  const cascadeRows = [];
+  let inScoping = false;
+  let inCascade = false;
+
+  for (const line of content.split("\n")) {
+    if (line.includes("## Scoping")) inScoping = true;
+    if (line.includes("## Cascade") || line.includes("## Dependency cascade"))
+      inCascade = true;
+    if (line.startsWith("## ") && !line.includes("Scoping") && !line.includes("Cascade")) {
+      inScoping = false;
+      inCascade = false;
+    }
+
+    if (inScoping && line.startsWith("|") && !line.startsWith("| Query") && !line.startsWith("|--")) {
+      scopingRows.push(line);
+    }
+    if (inCascade && line.startsWith("|") && !line.startsWith("| When") && !line.startsWith("|--")) {
+      cascadeRows.push(line);
+    }
+  }
+
+  // Inject rows into entry points
+  for (const epName of ["CLAUDE.md", ".cursorrules", "AGENT.md"]) {
+    const epPath = join(targetDir, epName);
+    if (!existsSync(epPath)) continue;
+
+    let epContent = readFileSync(epPath, "utf-8");
+
+    // Inject scoping rows before the instruction comment or at end of table
+    if (scopingRows.length > 0) {
+      const placeholder = "<!-- INSTRUCTION: Add project-specific scoping";
+      if (epContent.includes(placeholder)) {
+        epContent = epContent.replace(
+          placeholder,
+          scopingRows.join("\n") + "\n" + placeholder
+        );
+      }
+    }
+
+    // Inject cascade rows
+    if (cascadeRows.length > 0) {
+      const placeholder = "<!-- INSTRUCTION: Add project-specific cascade";
+      if (epContent.includes(placeholder)) {
+        epContent = epContent.replace(
+          placeholder,
+          cascadeRows.join("\n") + "\n" + placeholder
+        );
+      }
+    }
+
+    writeInitFile(epPath, epContent, "utf-8");
+  }
+}
+
+function replacePlaceholders(targetDir, projectType, tier, opts = {}) {
+  const projectName = opts.projectName || `${FRIENDLY_NAMES[projectType] || projectType} project`;
+  const defaultDescriptions = {
+    code: "Software project with AI-agent-assisted development (wwa methodology).",
+    data: "Data exploration and indexing project with AI-agent-assisted development.",
+    analytical: "Analytical/prompt system with chains, evaluation, and composition (wwa methodology).",
+    context: "Analytical/prompt system with chains, evaluation, and composition (wwa methodology).",
+    mixed: "Multi-type project with AI-agent-assisted development.",
+    general: "Project using wwa methodology for agent-assisted development.",
+  };
+  const description = opts.description || defaultDescriptions[projectType] || "AI-agent-assisted project using wwa methodology.";
+
+  for (const epName of ["CLAUDE.md", ".cursorrules", "AGENT.md"]) {
+    const epPath = join(targetDir, epName);
+    if (!existsSync(epPath)) continue;
+
+    let content = readFileSync(epPath, "utf-8");
+
+    // Replace project type placeholder
+    content = content.replace(/\{your-project-type\}/g, projectType);
+    content = content.replace(/\{your-domain-type\}/g, projectType);
+
+    // Set template tier
+    content = content.replace(/template_tier:\s*\S+/, `template_tier: ${tier}`);
+    // Phase 7q: Reduce placeholder text in entry point
+    content = content.replace(/\{Project Name\}/g, projectName);
+    content = content.replace(/\{Describe what your project does[^}]*\}/g, description);
+    content = content.replace(/\{Describe what your project does, its architecture, and key technologies\.\}/g, description);
+
+    writeInitFile(epPath, content, "utf-8");
+  }
+}
+
+function setProfile(targetDir, profile) {
+  for (const epName of ["CLAUDE.md", ".cursorrules", "AGENT.md"]) {
+    const epPath = join(targetDir, epName);
+    if (!existsSync(epPath)) continue;
+
+    let content = readFileSync(epPath, "utf-8");
+    content = content.replace(/tier:\s*(lite|standard|full)/, `tier: ${profile}`);
+    writeInitFile(epPath, content, "utf-8");
+  }
+}
+
+function setOnboardingScenario(targetDir, onboarding, isBrownfield, projectType) {
+  const profilePath = join(targetDir, "PROJECT-PROFILE.md");
+  if (!existsSync(profilePath)) return;
+
+  let content = readFileSync(profilePath, "utf-8");
+
+  // Set lifecycle stage based on scenario
+  const stage = isBrownfield ? "discovery" : "design";
+  content = content.replace(/\*\*Stage\*\*:\s*\{stage\}/, `**Stage**: ${stage}`);
+  content = content.replace(/\*\*Maturity\*\*:\s*\{maturity\}/, `**Maturity**: new`);
+
+  const today = new Date().toISOString().slice(0, 10);
+  content = content.replace(
+    /\*\*Last transition\*\*:\s*\{date\}.*$/m,
+    `**Last transition**: ${today} (setup -> ${stage})`
+  );
+
+  // Set project type
+  content = content.replace(/\[{project-type}\]/, `[${projectType}]`);
+
+  // Set onboarding hint so the agent knows which first-session flow
+  const scenario = onboarding === "auto"
+    ? (isBrownfield ? "brownfield (auto-detected)" : "greenfield (auto-detected)")
+    : onboarding;
+
+  // Add onboarding scenario after lifecycle section
+  if (!content.includes("**Onboarding**")) {
+    content = content.replace(
+      /(\*\*Last transition\*\*:.*$)/m,
+      `$1\n- **Onboarding**: ${scenario}`
+    );
+  }
+
+  // Set extension stack
+  const extensions = getExtensions(projectType);
+  const extNames = extensions.map(e => e.replace(".md", ""));
+  content = content.replace(/\[{extensions-applied}\]/, `[${extNames.join(", ") || "none"}]`);
+
+  for (const ext of ["code-project", "data-exploration", "analytical-system"]) {
+    const isActive = extNames.includes(ext) ? "yes" : "no";
+    const source = extNames.includes(ext) ? "wwa init" : "—";
+    content = content.replace(
+      new RegExp(`\\| ${ext} \\| \\{yes/no\\} \\| \\{setup\\.sh / manual\\} \\|`),
+      `| ${ext} | ${isActive} | ${source} |`
+    );
+  }
+
+  safeWriteFile(profilePath, content, "utf-8");
+}
+
+/**
+ * Append Brownfield setup section to PROJECT-PROFILE.md (Phase 7r).
+ * @param {string} targetDir - Project root
+ * @param {{ projectPurpose: string, audience: string, specLocation: string }} q - Questionnaire answers
+ */
+function persistBrownfieldQuestionnaire(targetDir, q) {
+  const profilePath = join(targetDir, "PROJECT-PROFILE.md");
+  if (!existsSync(profilePath) || !q) return;
+
+  const section = `
+
+## Brownfield setup
+
+- **Project purpose**: ${q.projectPurpose}
+- **Primary audience**: ${q.audience}
+- **Methodology spec**: ${q.specLocation}
+`;
+  const content = readFileSync(profilePath, "utf-8");
+  if (content.includes("## Brownfield setup")) return;
+  safeWriteFile(profilePath, content.trimEnd() + section + "\n", "utf-8");
+}
+
+function createProjectTokens(targetDir, projectType, tier, profile, onboarding, copied) {
+  const regDir = join(targetDir, "registry");
+  mkdirSync(regDir, { recursive: true });
+  const dst = join(regDir, "doc-tokens.yaml");
+  if (existsSync(dst)) return; // don't overwrite
+
+  const today = new Date().toISOString().slice(0, 10);
+
+  // Count files that were actually created
+  const mdFiles = [];
+  const countMdFiles = (dir) => {
+    if (!existsSync(dir)) return;
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const p = join(dir, entry.name);
+      if (entry.isDirectory()) countMdFiles(p);
+      else if (entry.name.endsWith(".md") || entry.name.endsWith(".yaml") || entry.name.endsWith(".yml")) {
+        mdFiles.push(relative(targetDir, p).replace(/\\/g, "/"));
+      }
+    }
+  };
+  countMdFiles(targetDir);
+
+  const content = [
+    "# Project Token Registry",
+    "# Computed by wwa init. Updated by wwa close.",
+    "# Used by wwa casestudy for methodology reference data.",
+    "#",
+    "# Agent: read this before writing docs. Check values are current.",
+    "",
+    "tokens:",
+    "",
+    "  # --- Project identity ---",
+    `  project_type: ${projectType}`,
+    `  template_tier: ${tier}`,
+    `  integration_profile: ${profile}`,
+    `  onboarding: ${onboarding}`,
+    `  created: "${today}"`,
+    `  last_close: "${today}"`,
+    "",
+    "  # --- File counts (updated at close) ---",
+    `  methodology_file_count: ${mdFiles.length}`,
+    "  docs_file_count: 0",
+    "  context_file_count: 0",
+    "",
+    "  # --- Session metrics (updated at close) ---",
+    "  session_count: 0",
+    "  decision_count: 0",
+    "  total_features_referenced: 0",
+    "",
+    "  # --- Scale indicators (updated at close) ---",
+    "  files_near_threshold: 0           # files with 250+ lines",
+    "  files_over_threshold: 0           # files with 300+ lines (need splitting)",
+    "",
+    "  # --- Docs coverage (updated at close) ---",
+    "  docs_inventory_count: 0",
+    "  docs_on_disk: 0",
+    "  docs_missing: 0",
+    "  component_mappings: 0",
+    "",
+    "# --- Document dependency graph (built at init, refined during onboarding, updated at close) ---",
+    "doc_graph:",
+    `  last_scan: "${today}"`,
+    `  defaults_applied: ${projectType}`,
+    "",
+    "  nodes:",
+  ];
+
+  // Seed nodes from methodology file inventory
+  const defaultNodes = buildDefaultNodes(tier);
+  for (const node of defaultNodes) {
+    content.push(`    - {path: "${node.path}", category: "${node.category}", role: "${node.role}"}`);
+  }
+
+  content.push("", "  edges:");
+
+  // Seed edges from project-type defaults
+  const defaultEdges = buildDefaultEdges(projectType);
+  for (const edge of defaultEdges) {
+    let line = `    - {from: "${edge.from}", to: "${edge.to}", type: "${edge.type}"`;
+    if (edge.trigger) line += `, trigger: "${edge.trigger}"`;
+    line += "}";
+    content.push(line);
+  }
+
+  content.push(
+    "",
+    "# --- Project-specific terminology (populated during brownfield onboarding) ---",
+    "project_names:",
+    "  modules: []",
+    "  apis: []",
+    "  entities: []",
+    "  conventions: []",
+    "",
+  );
+
+  const finalContent = content.join("\n");
+
+  safeWriteFile(dst, finalContent, "utf-8");
+  copied.push("registry/doc-tokens.yaml");
+}
+
+function postProcessYamlFiles(targetDir, projectType, tier) {
+  const today = new Date().toISOString().slice(0, 10);
+
+  // Post-process PROTOCOL.yaml — replace {date}, enable boundaries (Phase 7q), add analytical scoping if needed
+  const protocolPath = join(targetDir, ".context", "PROTOCOL.yaml");
+  if (existsSync(protocolPath)) {
+    let content = readFileSync(protocolPath, "utf-8");
+    content = content.replace(/"\{date\}"/g, `"${today}"`);
+    content = content.replace(/\{date\}/g, today);
+    // Phase 7q: Auto-enable boundaries so V-11 passes (paths match init-created files)
+    content = enableBoundariesInProtocol(content, tier);
+    // Phase 7q: Add project-type-specific scoping for analytical
+    if (projectType === "analytical" || projectType === "context") {
+      content = addAnalyticalScopingToProtocol(content);
+    }
+    safeWriteFile(protocolPath, content, "utf-8");
+  }
+
+  // Post-process INDEX.yaml — replace placeholders
+  const indexPath = join(targetDir, ".context", "INDEX.yaml");
+  if (existsSync(indexPath)) {
+    let content = readFileSync(indexPath, "utf-8");
+    content = content.replace(/"\{Project Name\}"/g, `"${projectType} project"`);
+    content = content.replace(/\{Project Name\}/g, `${projectType} project`);
+    content = content.replace(/type: general/,
+      `type: ${projectType === "context" ? "analytical" : projectType}`);
+    content = content.replace(/tier: (standard|full)/,
+      `tier: ${tier}`);
+    safeWriteFile(indexPath, content, "utf-8");
+  }
+}
+
+/** Phase 7q: Uncomment boundaries in PROTOCOL so validator can resolve registry paths. */
+function enableBoundariesInProtocol(content, tier) {
+  const commentedBlock = /# === BOUNDARIES: path resolution[\s\S]*?#       exclude: \[".context\/", "docs\/internal\/"\]\n?/;
+  const fullTier = tier === "full";
+  const boundariesYaml = [
+    "# === BOUNDARIES: path resolution, visibility, distribution (enabled by wwa init) ===",
+    "boundaries:",
+    "  registries:",
+    '    tokens: "registry/doc-tokens.yaml"',
+    '    feature_registry: "registry/feature-registry.yaml"',
+    '    docs_map: ".context/DOCS-MAP.md"',
+    '    output: "docs/internal/"',
+    "  visibility:",
+    fullTier
+      ? '    internal: [".context/", "registry/", "research/", "todos/", "docs/internal/"]'
+      : '    internal: [".context/", "research/", "todos/", "docs/internal/"]',
+    fullTier
+      ? '    release: ["docs/architecture/", "docs/workflow/", "docs/guides/", "templates/"]'
+      : '    release: ["docs/architecture/", "docs/workflow/", "docs/guides/", "templates/"]',
+    "  scan:",
+    fullTier
+      ? '    include: ["docs/", ".context/", "registry/", "templates/"]'
+      : '    include: ["docs/", ".context/", "templates/"]',
+    '    exclude: ["node_modules/", ".git/"]',
+    "  distribution:",
+    "    git:",
+    '      exclude: ["STATE.md", "PLAN.md", ".context/", "research/", "todos/"]',
+    "    npm:",
+    '      include: ["bin/", "lib/", "templates/"]',
+    '      exclude: [".context/", "docs/internal/"]',
+    "",
+  ].join("\n");
+  return content.replace(commentedBlock, boundariesYaml);
+}
+
+/** Phase 7q: Add analytical query types to PROTOCOL scoping (chain_work, evaluation, composition, domain_research). */
+function addAnalyticalScopingToProtocol(content) {
+  const injectBefore = "  # CUSTOMIZE: add project-specific query types below";
+  const analyticalBlock = [
+    "  chain_work:",
+    "    reads: [.context/BASE.md, .context/EXECUTION.md, pipeline config]",
+    "    writes: [.context/EXECUTION.md, .context/BASE.md]",
+    "  evaluation:",
+    "    reads: [.context/BASE.md, .context/EVALUATION.md, scoring rubrics]",
+    "    writes: [.context/EVALUATION.md]",
+    "  composition:",
+    "    reads: [.context/BASE.md, .context/COMPOSITION.md, existing templates]",
+    "    writes: [.context/COMPOSITION.md]",
+    "  domain_research:",
+    "    reads: [.context/BASE.md, .context/DOMAIN.md]",
+    "    writes: [.context/DOMAIN.md, STATE.md]",
+    "  ",
+    injectBefore,
+  ].join("\n");
+  if (content.includes(injectBefore) && !content.includes("chain_work:")) {
+    content = content.replace(injectBefore, analyticalBlock);
+  }
+  return content;
+}
+
+function copyFeatureRegistry(methodRoot, targetDir, copied) {
+  // Split registry ships in templates — already copied by copyTemplateDir().
+  // Only need to handle fallback if registry/ wasn't in the template.
+  const splitIndex = join(targetDir, "registry", "feature-registry.yaml");
+  if (existsSync(splitIndex)) return; // already copied from template
+
+  // Fallback: copy monolithic file to registry/ (for older templates)
+  const src = join(methodRoot, "docs", "internal", "feature-registry.yaml");
+  if (!existsSync(src)) return;
+  const regDir = join(targetDir, "registry");
+  mkdirSync(regDir, { recursive: true });
+  const dst = join(regDir, "feature-registry.yaml");
+  if (existsSync(dst)) return;
+  safeCopyFile(src, dst);
+  copied.push("registry/feature-registry.yaml");
+}
+
+function removeUnusedEntryPoints(targetDir, runtime, isBrownfield) {
+  if (runtime === "all" || isBrownfield) return [];
+
+  const allEntryPoints = ["CLAUDE.md", ".cursorrules", "AGENT.md"];
+  const keep = RUNTIME_ENTRY_POINTS[runtime];
+  if (!keep) return [];
+
+  const removed = [];
+  for (const ep of allEntryPoints) {
+    if (ep !== keep) {
+      const epPath = join(targetDir, ep);
+      if (existsSync(epPath)) {
+        unlinkSync(epPath);
+        removed.push(ep);
+      }
+    }
+  }
+  return removed;
+}