@negikirin/repo-pattern 0.1.1

package/scripts/lib/provision.mjs

@@ -0,0 +1,184 @@
+import path from "node:path";
+import { auditProject, printAudit } from "./audit.mjs";
+import { cleanupProject } from "./cleanup.mjs";
+import { generateMcp } from "./mcp.mjs";
+import { setupEcc } from "./ecc.mjs";
+import { doctorProject } from "./doctor.mjs";
+import { applyEccRules } from "./rules.mjs";
+import { appendGitignoreLine, backupPaths, copyRecursive, ensureDir, isTracked, readJson, writeJson, writeIfMissing } from "./fs-utils.mjs";
+import { printSummary, style } from "./prompt.mjs";
+import { applyOptionalSkills } from "./skills.mjs";
+
+const TARGET_CLAUDE_MD = "";
+
+function shellQuote(value) {
+  return `'${String(value).replaceAll("'", `'"'"'`)}'`;
+}
+
+function repoPatternConfig(profile) {
+  return {
+    version: "2.0.0",
+    workflow: "ecc-native",
+    mode: "target",
+    runtime: {
+      localSkills: false,
+      localCommands: false,
+      localHooks: false,
+      localScripts: false,
+      localRules: false,
+      vendoredEccRules: false
+    },
+    ecc: {
+      installMode: "plugin",
+      rulesSync: "repo-pattern-auto-cache",
+      rulesProfile: "auto",
+      rulesScope: "project",
+      hooks: "plugin-managed",
+      copyRuntimeSurfaces: false
+    },
+    mcp: {
+      profile,
+      generated: true
+    }
+  };
+}
+
+function lockConfig(profile) {
+  return {
+    repoPattern: {
+      version: "2.0.0",
+      lastProvisionRun: new Date().toISOString(),
+      lastDoctorRun: null
+    },
+    ecc: {
+      installMode: "plugin",
+      status: "not-run",
+      rulesSyncedBy: null,
+      rulesScope: "project",
+      recommendedRules: [],
+      appliedRules: [],
+      detectedStack: null,
+      rulesAppliedAt: null,
+      hooks: "plugin-managed",
+      syncedAt: null
+    },
+    mcp: {
+      profile,
+      generatedAt: null
+    }
+  };
+}
+
+export function applyAttributionSetting(settings, attributionConfig = { mode: "off" }) {
+  const next = { ...settings };
+  if (attributionConfig.mode === "on") {
+    if (!next.attribution) return next;
+    const { commit, ...rest } = next.attribution;
+    if (Object.keys(rest).length > 0) next.attribution = rest;
+    else delete next.attribution;
+    return next;
+  }
+
+  next.attribution = {
+    ...(next.attribution || {}),
+    commit: attributionConfig.mode === "custom" ? attributionConfig.commit : ""
+  };
+  return next;
+}
+
+async function writeClaudeSettings({ sourceRoot, target, attributionConfig, dryRun }) {
+  const template = await readJson(path.join(sourceRoot, ".claude", "settings.example.json"), {});
+  await writeJson(path.join(target, ".claude", "settings.json"), applyAttributionSetting(template, attributionConfig), { dryRun });
+}
+
+export async function updateClaudeAttribution({ sourceRoot, target, attributionConfig, dryRun }) {
+  if (isTracked(target, ".claude/settings.json")) throw new Error(".claude/settings.json is tracked. Untrack it before writing Claude Code settings.");
+  const file = path.join(target, ".claude", "settings.json");
+  const current = await readJson(file, null);
+  const template = await readJson(path.join(sourceRoot, ".claude", "settings.example.json"), {});
+  await writeJson(file, applyAttributionSetting(current || template, attributionConfig), { dryRun });
+  await appendGitignoreLine(target, ".claude/settings.json", { dryRun });
+}
+
+async function writeLocalSettings({ sourceRoot, target, localSettingsEnv, dryRun }) {
+  if (!localSettingsEnv) return;
+  if (isTracked(target, ".claude/settings.local.json")) throw new Error(".claude/settings.local.json is tracked. Untrack it before writing local provider settings.");
+  const template = await readJson(path.join(sourceRoot, ".claude", "settings.local.example.json"), {});
+  await writeJson(path.join(target, ".claude", "settings.local.json"), {
+    ...template,
+    env: {
+      ...(template.env || {}),
+      ...localSettingsEnv
+    }
+  }, { dryRun });
+  await appendGitignoreLine(target, ".claude/settings.local.json", { dryRun });
+}
+
+export async function provisionProject({ sourceRoot, target, profile = "web", mcpServers = null, mcpValues = {}, dryRun = false, force = false, migrate = false, localSettingsEnv = null, attributionConfig = { mode: "off" }, ruleMode = "auto", rules = null, applyRules = false, optionalSkills = [] }) {
+  printSummary("Provisioning target", [["Target", target]]);
+  const audit = await auditProject(target);
+  printAudit(audit);
+
+  if (audit.state === "LEGACY_VENDOR" && !migrate) {
+    throw new Error("Target has legacy/local Claude runtime surfaces. Re-run setup with --migrate, not --force.");
+  }
+
+  if (audit.state === "LEGACY_VENDOR") {
+    await cleanupProject({ sourceRoot, target, dryRun });
+  } else {
+    await backupPaths(target, ["CLAUDE.md", ".claude", ".mcp.json", ".repo-pattern.json", ".repo-pattern.lock.json"], { dryRun });
+  }
+
+  if (isTracked(target, ".claude/settings.json")) throw new Error(".claude/settings.json is tracked. Untrack it before writing Claude Code settings.");
+  await ensureDir(path.join(target, ".claude"), { dryRun });
+
+  // No templates directory is used. repo-pattern keeps canonical project files in:
+  // - sourceRoot/.claude/*
+  // - sourceRoot/mcp/*
+  // Target CLAUDE.md is created empty when missing so project-specific instructions can be added later. Existing target CLAUDE.md is preserved.
+  await writeIfMissing(path.join(target, "CLAUDE.md"), TARGET_CLAUDE_MD, { dryRun });
+
+  await copyRecursive(
+    path.join(sourceRoot, ".claude", "CLAUDE.md"),
+    path.join(target, ".claude", "CLAUDE.md"),
+    { dryRun }
+  );
+
+  await writeClaudeSettings({ sourceRoot, target, attributionConfig, dryRun });
+  await appendGitignoreLine(target, ".claude/settings.json", { dryRun });
+
+  await writeLocalSettings({ sourceRoot, target, localSettingsEnv, dryRun });
+
+  await writeJson(path.join(target, ".repo-pattern.json"), repoPatternConfig(profile), { dryRun });
+  await writeJson(path.join(target, ".repo-pattern.lock.json"), lockConfig(profile), { dryRun });
+
+  const mcpResult = await generateMcp({ sourceRoot, target, profile, mcpServers, mcpValues, dryRun });
+  const eccStatus = await setupEcc({ sourceRoot, target, dryRun });
+  if (applyRules) await applyEccRules({ target, dryRun, ruleMode, rules });
+  if (optionalSkills.length > 0) await applyOptionalSkills({ target, skills: optionalSkills, dryRun });
+
+  if (dryRun) {
+    console.log("[dry-run] doctor skipped because no files were written.");
+  } else {
+    await doctorProject(target, { updateLock: true, dryRun });
+  }
+
+  const pending = [
+    ...(eccStatus === "manual-plugin-install-required" ? ["ECC plugin"] : []),
+    ...(mcpResult.missingValues.length > 0 ? ["MCP values"] : [])
+  ];
+  const pendingText = pending.length ? `${pending.join(", ")} pending` : style("success", "ready");
+  const next = dryRun
+    ? "review output, then rerun without --dry-run"
+    : pending.length
+      ? `resolve ${pending.join(" and ")}, then run claude`
+      : `cd ${shellQuote(target)} && claude`;
+  printSummary("Setup complete", [
+    ["Status", dryRun ? `preview only; ${pendingText}` : pendingText],
+    ["Target", target],
+    ["Profile", profile],
+    [dryRun ? "Would write" : "Written", `CLAUDE.md (if missing), .claude/, .mcp.json, .repo-pattern.json, .repo-pattern.lock.json${optionalSkills.length ? ", .claude/skills" : ""}`],
+    ["Doctor", dryRun ? "skipped (dry-run)" : style("success", "passed")],
+    ["Next", next]
+  ]);
+}

package/scripts/lib/rules.mjs

@@ -0,0 +1,142 @@
+import path from "node:path";
+import { execFile, execFileSync } from "node:child_process";
+import { promisify } from "node:util";
+import { appendGitignoreLine, backupPaths, copyRecursive, ensureDir, exists, readJson, removePath, writeJson } from "./fs-utils.mjs";
+import { detectProject } from "./project-detect.mjs";
+import { selectEccRules, normalizeEccRules, invalidEccRules } from "./ecc-rules.mjs";
+import { isInteractive, printSummary, withSpinner } from "./prompt.mjs";
+
+const ECC_REPO_URL = "https://github.com/affaan-m/ECC.git";
+const execFileAsync = promisify(execFile);
+
+function runGit(args, cwd, { quiet = false } = {}) {
+  execFileSync("git", args, {
+    cwd,
+    stdio: quiet ? "ignore" : "inherit"
+  });
+}
+
+async function runGitAsync(args, cwd) {
+  await execFileAsync("git", args, { cwd });
+}
+
+function list(values, fallback = "none detected") {
+  return values.length ? values.join(", ") : fallback;
+}
+
+async function ensureEccCache(target, { dryRun = false } = {}) {
+  const cacheRoot = path.join(target, ".repo-pattern", "cache");
+  const eccCache = path.join(cacheRoot, "ECC");
+  const rulesDir = path.join(eccCache, "rules");
+
+  if (exists(rulesDir)) {
+    if (!dryRun && exists(path.join(eccCache, ".git"))) {
+      try {
+        runGit(["pull", "--ff-only", "--quiet"], eccCache);
+      } catch {
+        console.warn("WARN: ECC cache exists but git pull failed. Using existing cache.");
+      }
+    }
+    return eccCache;
+  }
+
+  if (dryRun) {
+    console.log(`[dry-run] git clone --depth 1 ${ECC_REPO_URL} ${eccCache}`);
+    return eccCache;
+  }
+
+  await ensureDir(cacheRoot);
+  if (isInteractive()) {
+    await withSpinner("Syncing ECC rules", async () => {
+      await runGitAsync(["clone", "--depth", "1", "--quiet", ECC_REPO_URL, eccCache], target);
+    });
+  } else {
+    console.log(`Syncing ECC rules from ${ECC_REPO_URL}`);
+    runGit(["clone", "--depth", "1", ECC_REPO_URL, eccCache], target);
+  }
+  return eccCache;
+}
+
+export async function applyEccRules({ target, dryRun = false, ruleMode = "auto", rules = null }) {
+  const detection = await detectProject(target);
+  const invalidRules = ruleMode === "manual" ? invalidEccRules(rules) : [];
+  if (invalidRules.length > 0) throw new Error(`Unknown ECC rule pack(s): ${invalidRules.join(", ")}`);
+
+  const selectedRules = ruleMode === "manual" ? normalizeEccRules(rules) : selectEccRules(detection);
+
+  printSummary("Detected stack", [
+    ["Repo type", detection.repoType],
+    ["Languages", list(detection.languages)],
+    ["Frameworks", list(detection.frameworks)],
+    ["Tools", list(detection.tools)],
+    ["Package manager", detection.packageManager || "unknown"],
+    ["Monorepo", detection.monorepo ? "yes" : "no"]
+  ]);
+  printSummary("Selected ECC rules", [["Rules", selectedRules.join(", ")]]);
+
+  const internalRoot = path.join(target, ".repo-pattern");
+  const cacheRoot = path.join(internalRoot, "cache");
+  const eccCache = await ensureEccCache(target, { dryRun });
+  await appendGitignoreLine(target, ".repo-pattern/", { dryRun });
+  const sourceRulesRoot = path.join(eccCache, "rules");
+  const destRoot = path.join(target, ".claude", "rules", "ecc");
+
+  await backupPaths(target, [".claude/rules/ecc"], { dryRun });
+  await removePath(destRoot, { dryRun });
+  await ensureDir(destRoot, { dryRun });
+
+  for (const rule of selectedRules) {
+    const src = path.join(sourceRulesRoot, rule);
+    const dest = path.join(destRoot, rule);
+
+    if (!dryRun && !exists(src)) {
+      throw new Error(`ECC rule pack not found in cache: ${rule}`);
+    }
+
+    await copyRecursive(src, dest, { dryRun });
+  }
+
+  if (dryRun) console.log(`[dry-run] rm -rf ${internalRoot}`);
+  else await removePath(internalRoot);
+
+  const repoConfigPath = path.join(target, ".repo-pattern.json");
+  const repoConfig = await readJson(repoConfigPath, {});
+  repoConfig.ecc = {
+    ...(repoConfig.ecc || {}),
+    rulesSync: "repo-pattern-auto-cache",
+    rulesProfile: ruleMode,
+    rulesScope: "project",
+    copyRuntimeSurfaces: false
+  };
+  await writeJson(repoConfigPath, repoConfig, { dryRun });
+
+  const lockPath = path.join(target, ".repo-pattern.lock.json");
+  const lock = await readJson(lockPath, {});
+  lock.ecc = {
+    ...(lock.ecc || {}),
+    rulesSyncedBy: "repo-pattern-auto-cache",
+    rulesProfile: ruleMode,
+    rulesScope: "project",
+    recommendedRules: selectedRules,
+    appliedRules: selectedRules,
+    detectedStack: detection,
+    rulesSource: ECC_REPO_URL,
+    rulesCache: null,
+    rulesAppliedAt: new Date().toISOString()
+  };
+  await writeJson(lockPath, lock, { dryRun });
+
+  printSummary("Applied ECC rules", [
+    ["Path", path.relative(target, destRoot)],
+    ["Rules", selectedRules.join(", ")],
+    ["Internal dir", ".repo-pattern/ removed"]
+  ]);
+
+  return {
+    detection,
+    selectedRules,
+    destRoot,
+    rulesSource: ECC_REPO_URL,
+    rulesCache: null
+  };
+}

package/scripts/lib/setup.mjs

@@ -0,0 +1,299 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { auditProject, printAudit } from "./audit.mjs";
+import { detectProject } from "./project-detect.mjs";
+import { provisionProject, updateClaudeAttribution } from "./provision.mjs";
+import { doctorProject } from "./doctor.mjs";
+import { collectMcpValues, generateMcp, listAvailableMcpServers, readMcpConfig } from "./mcp.mjs";
+import { askConfirm, askPassword, askText, isInteractive, printBox, printLogo, printSummary, selectMany, selectOne, style } from "./prompt.mjs";
+import { ECC_RULE_PACKS, selectEccRules } from "./ecc-rules.mjs";
+import { applyOptionalSkills, OPTIONAL_SKILLS } from "./skills.mjs";
+
+const execFileAsync = promisify(execFile);
+
+const PROFILE_NAMES = ["web", "minimal", "backend", "research", "full"];
+
+async function profileOptions(sourceRoot) {
+  const options = await Promise.all(PROFILE_NAMES.map(async (name) => {
+    const { profileServers } = await readMcpConfig({ sourceRoot, profile: name });
+    return { value: name, label: name, description: profileServers.join(", ") };
+  }));
+  return [...options, { value: "custom", label: "custom", description: "choose exact MCP servers" }];
+}
+
+function validateRequired(value) {
+  return String(value || "").trim() ? true : "Required";
+}
+
+function validateUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:" ? true : "Use http:// or https://.";
+  } catch {
+    return "Use a valid URL.";
+  }
+}
+
+const LOCAL_SETTINGS_FIELDS = [
+  ["ANTHROPIC_BASE_URL", "https://example.com/v1", askText, validateUrl],
+  ["ANTHROPIC_AUTH_TOKEN", "", askPassword, null],
+  ["ANTHROPIC_DEFAULT_OPUS_MODEL", "claude-opus-4-8", askText, validateRequired],
+  ["ANTHROPIC_DEFAULT_SONNET_MODEL", "claude-sonnet-4-6", askText, validateRequired],
+  ["ANTHROPIC_DEFAULT_HAIKU_MODEL", "claude-haiku-4-5", askText, validateRequired]
+];
+
+function suggestedProfile(detection, fallback) {
+  if (fallback && fallback !== "web") return fallback;
+  if (["frontend", "fullstack", "node"].includes(detection.repoType)) return "web";
+  if (detection.repoType === "backend") return "backend";
+  return "minimal";
+}
+
+async function checkClaudeCode() {
+  try {
+    const { stdout } = await execFileAsync("claude", ["--version"]);
+    printBox("Claude Code", [`version: ${stdout.trim()}`]);
+  } catch {
+    throw new Error("Claude Code CLI is required. Install/login to Claude Code, then rerun setup.");
+  }
+}
+
+async function chooseProfile(sourceRoot, profile, detection) {
+  return selectOne({
+    message: "Step 1/5 — Choose MCP profile",
+    options: await profileOptions(sourceRoot),
+    initialValue: suggestedProfile(detection, profile)
+  });
+}
+
+async function chooseMcpConfig(sourceRoot, profile) {
+  if (profile !== "custom") return { profile, mcpServers: null };
+  const mcpServers = await selectMany({
+    message: "Choose MCP servers",
+    options: await listAvailableMcpServers(sourceRoot),
+    initialValues: ["context7", "filesystem"]
+  });
+  if (mcpServers.length === 0) throw new Error("Custom MCP profile requires at least one server.");
+  return { profile, mcpServers };
+}
+
+async function chooseMcpValues(sourceRoot, mcpConfig) {
+  const { mcpServers } = await readMcpConfig({ sourceRoot, profile: mcpConfig.profile, mcpServers: mcpConfig.mcpServers });
+  return collectMcpValues(mcpServers);
+}
+
+async function chooseRuleConfig(detection) {
+  const autoRules = selectEccRules(detection);
+  const ruleMode = await selectOne({
+    message: "Step 2/5 — Choose ECC rule detection mode",
+    options: [
+      { value: "auto", label: "auto", description: `detect from project (${autoRules.join(", ")})` },
+      { value: "manual", label: "manual", description: "choose rule packs by type" },
+      { value: "none", label: "none", description: "do not install project-local ECC rules" }
+    ],
+    initialValue: "auto"
+  });
+
+  if (ruleMode === "none") return { applyRules: false, ruleMode: "auto", rules: [] };
+  if (ruleMode !== "manual") return { applyRules: true, ruleMode, rules: autoRules };
+
+  return {
+    applyRules: true,
+    ruleMode,
+    rules: await selectMany({
+      message: "Choose ECC rule packs",
+      options: ECC_RULE_PACKS,
+      initialValues: autoRules
+    })
+  };
+}
+
+async function chooseOptionalSkills(initialValues = []) {
+  return selectMany({
+    message: "Step 3/5 — Optional external skills",
+    options: OPTIONAL_SKILLS,
+    initialValues
+  });
+}
+
+async function chooseLocalSettingsEnv() {
+  printBox("Step 4/5 — Local Claude provider settings", ["These values are written to .claude/settings.local.json and gitignored."]);
+  const env = {};
+  for (const [name, fallback, ask, validate] of LOCAL_SETTINGS_FIELDS) {
+    env[name] = await ask(name, { initial: process.env[name] || fallback, validate });
+  }
+  return env;
+}
+
+async function chooseAttributionConfig() {
+  printBox("Step 5/5 — Claude Code commit attribution", ["Controls .claude/settings.json attribution.commit."]);
+  const mode = await selectOne({
+    message: "Commit attribution?",
+    options: [
+      { value: "off", label: "off", description: "disable Co-Authored-By trailer" },
+      { value: "on", label: "on", description: "use Claude Code default" },
+      { value: "custom", label: "custom", description: "write your own commit attribution" }
+    ],
+    initialValue: "off"
+  });
+  if (mode !== "custom") return { mode };
+  return {
+    mode,
+    commit: await askText("Custom commit attribution", {
+      initial: "Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>",
+      validate: validateRequired
+    })
+  };
+}
+
+function attributionSummary(attributionConfig) {
+  if (attributionConfig.mode === "on") return "Claude Code default";
+  if (attributionConfig.mode === "custom") return attributionConfig.commit;
+  return "off (commit: \"\")";
+}
+
+async function confirmSummary({ action, target, mcpConfig, mcpValues, ruleConfig, optionalSkills, localSettingsEnv, attributionConfig, dryRun }) {
+  printSummary("Setup summary", [
+    ["Action", action],
+    ["Target", target],
+    ["Profile", mcpConfig.profile],
+    ["MCP servers", mcpConfig.mcpServers?.join(", ") || "from profile"],
+    ["MCP values", Object.keys(mcpValues).length ? Object.keys(mcpValues).join(", ") : "none"],
+    ["Rules", ruleConfig.applyRules ? ruleConfig.rules.join(", ") : "none"],
+    ["Optional skills", optionalSkills.length ? optionalSkills.join(", ") : "none"],
+    ["Local settings", ".claude/settings.local.json"],
+    ["Base URL", localSettingsEnv.ANTHROPIC_BASE_URL],
+    ["Opus", localSettingsEnv.ANTHROPIC_DEFAULT_OPUS_MODEL],
+    ["Sonnet", localSettingsEnv.ANTHROPIC_DEFAULT_SONNET_MODEL],
+    ["Haiku", localSettingsEnv.ANTHROPIC_DEFAULT_HAIKU_MODEL],
+    ["Auth token", style("dim", "[hidden]")],
+    ["Commit attribution", attributionSummary(attributionConfig)],
+    ["Dry-run", dryRun ? "yes" : "no"],
+    ["Will write", `CLAUDE.md (if missing), .claude/CLAUDE.md, .claude/settings.json, .claude/settings.local.json, .mcp.json, .repo-pattern.json, .repo-pattern.lock.json${optionalSkills.length ? ", .claude/skills" : ""}`],
+    ["Will not write", optionalSkills.length ? ".claude/commands, .claude/hooks, .claude/scripts" : ".claude/skills, .claude/commands, .claude/hooks, .claude/scripts"]
+  ]);
+
+  const answer = await selectOne({
+    message: "Run setup now?",
+    options: [
+      { value: "yes", label: "Yes" },
+      { value: "no", label: "No" }
+    ],
+    initialValue: "yes"
+  });
+  return answer === "yes";
+}
+
+async function handleInitialized({ sourceRoot, target, profile, dryRun }) {
+  printBox("Already initialized", ["This target already looks like repo-pattern ECC-native setup."]);
+
+  const action = await selectOne({
+    message: "What do you want to do?",
+    options: [
+      { value: "doctor", label: "Run doctor" },
+      { value: "mcp", label: "Regenerate MCP profile" },
+      { value: "skills", label: "Add optional skills" },
+      { value: "attribution", label: "Update commit attribution" },
+      { value: "exit", label: "Exit" }
+    ],
+    initialValue: "doctor"
+  });
+
+  if (action === "doctor") await doctorProject(target, { dryRun });
+  if (action === "mcp") {
+    const detection = await detectProject(target);
+    const chosenProfile = await chooseProfile(sourceRoot, profile, detection);
+    const mcpConfig = await chooseMcpConfig(sourceRoot, chosenProfile);
+    const mcpValues = await chooseMcpValues(sourceRoot, mcpConfig);
+    await generateMcp({ sourceRoot, target, profile: mcpConfig.profile, mcpServers: mcpConfig.mcpServers, mcpValues, dryRun });
+  }
+  if (action === "skills") {
+    const optionalSkills = await chooseOptionalSkills();
+    await applyOptionalSkills({ target, skills: optionalSkills, dryRun });
+    if (!dryRun) await doctorProject(target, { updateLock: true, dryRun });
+  }
+  if (action === "attribution") {
+    await updateClaudeAttribution({ sourceRoot, target, attributionConfig: await chooseAttributionConfig(), dryRun });
+    if (!dryRun) await doctorProject(target, { updateLock: true, dryRun });
+  }
+}
+
+export async function setupProject({ sourceRoot, target, profile = "web", dryRun = false, force = false, migrate = false, yes = false, applyRules = false, optionalSkills = [] }) {
+  if (!isInteractive()) {
+    if (!yes) throw new Error("setup requires an interactive terminal, or pass --yes for scriptable mode.");
+    if (profile === "custom") throw new Error("setup --yes cannot use the custom profile; choose a named profile.");
+
+    const audit = await auditProject(target);
+    if (audit.state === "ECC_NATIVE_MINIMAL" && !force && optionalSkills.length === 0) {
+      await doctorProject(target, { dryRun });
+      return;
+    }
+
+    if (audit.state === "ECC_NATIVE_MINIMAL" && optionalSkills.length > 0) {
+      await applyOptionalSkills({ target, skills: optionalSkills, dryRun });
+      if (!dryRun) await doctorProject(target, { updateLock: true, dryRun });
+      return;
+    }
+
+    await provisionProject({ sourceRoot, target, profile, dryRun, force, migrate, applyRules, optionalSkills });
+    return;
+  }
+
+  printLogo();
+  await checkClaudeCode();
+
+  const detection = await detectProject(target);
+  const chosenProfile = await chooseProfile(sourceRoot, profile, detection);
+  const mcpConfig = await chooseMcpConfig(sourceRoot, chosenProfile);
+  const ruleConfig = await chooseRuleConfig(detection);
+  const selectedOptionalSkills = await chooseOptionalSkills(optionalSkills);
+
+  const audit = await auditProject(target);
+  printAudit(audit);
+
+  if (audit.state === "LEGACY_VENDOR" && force && !migrate) {
+    throw new Error("Target has legacy/local Claude runtime surfaces. Re-run setup with --migrate, not --force.");
+  }
+
+  if (audit.state === "ECC_NATIVE_MINIMAL") {
+    if (selectedOptionalSkills.length > 0) {
+      await applyOptionalSkills({ target, skills: selectedOptionalSkills, dryRun });
+      if (!dryRun) await doctorProject(target, { updateLock: true, dryRun });
+    } else {
+      await handleInitialized({ sourceRoot, target, profile: chosenProfile, dryRun });
+    }
+    return;
+  }
+
+  const action = audit.state === "LEGACY_VENDOR" ? "migrate" : "setup";
+  if (action === "migrate" && !migrate) {
+    printBox("Migration required", ["Legacy/local Claude runtime surfaces detected.", "Recommended action: migrate, with backups."]);
+    const confirmed = await askConfirm("Run migrate?", false);
+    if (!confirmed) throw new Error("Setup cancelled.");
+  }
+
+  const mcpValues = await chooseMcpValues(sourceRoot, mcpConfig);
+  const localSettingsEnv = await chooseLocalSettingsEnv();
+  const attributionConfig = await chooseAttributionConfig();
+
+  if (!await confirmSummary({ action, target, mcpConfig, mcpValues, ruleConfig, optionalSkills: selectedOptionalSkills, localSettingsEnv, attributionConfig, dryRun })) {
+    throw new Error("Setup cancelled.");
+  }
+
+  await provisionProject({
+    sourceRoot,
+    target,
+    profile: mcpConfig.profile,
+    mcpServers: mcpConfig.mcpServers,
+    mcpValues,
+    dryRun,
+    force: false,
+    migrate: action === "migrate",
+    ruleMode: ruleConfig.ruleMode,
+    rules: ruleConfig.rules,
+    applyRules: ruleConfig.applyRules,
+    optionalSkills: selectedOptionalSkills,
+    localSettingsEnv,
+    attributionConfig
+  });
+}