codebyplan 1.13.38 → 1.13.39

package/dist/cli.js

@@ -14,7 +14,7 @@ var VERSION, PACKAGE_NAME;
 var init_version = __esm({
   "src/lib/version.ts"() {
     "use strict";
-    VERSION = "1.13.38";
+    VERSION = "1.13.39";
     PACKAGE_NAME = "codebyplan";
   }
 });
@@ -3134,6 +3134,11 @@ async function writeCodebyplanDirectory(projectPath, selectedRepo, deviceId) {
     JSON.stringify({}, null, 2) + "\n",
     "utf-8"
   );
+  await writeFile7(
+    join12(codebyplanDir, "architecture.json"),
+    JSON.stringify({ version: 1, modules: [] }, null, 2) + "\n",
+    "utf-8"
+  );
   const statuslinePath = join12(codebyplanDir, "statusline.json");
   let statuslineExists = false;
   try {
@@ -3151,7 +3156,7 @@ async function writeCodebyplanDirectory(projectPath, selectedRepo, deviceId) {
   await writeLocalConfig(projectPath, { device_id: deviceId });
   console.log(`  Created ${codebyplanDir}/`);
   console.log(
-    `    repo.json, server.json, git.json, shipment.json, vendor.json, e2e.json, eslint.json, statusline.json`
+    `    repo.json, server.json, git.json, shipment.json, vendor.json, e2e.json, eslint.json, architecture.json, statusline.json`
   );
   console.log(`    device.local.json (gitignored)`);
   const gitignoreAction = await ensureManagedGitignoreBlock(projectPath);
@@ -7142,6 +7147,425 @@ var init_upload_e2e_images = __esm({
   }
 });
 
+// src/cli/arch-map.ts
+var arch_map_exports = {};
+__export(arch_map_exports, {
+  mapFileSlug: () => mapFileSlug,
+  runArchMapCommand: () => runArchMapCommand,
+  updateFrontmatterFields: () => updateFrontmatterFields
+});
+import { readFile as readFile17, writeFile as writeFile13 } from "node:fs/promises";
+import { existsSync as existsSync5, readdirSync as readdirSync2 } from "node:fs";
+import { join as join23 } from "node:path";
+import { spawnSync as spawnSync7 } from "node:child_process";
+function normalizeModulePath(modulePath) {
+  return modulePath.replace(/\/+$/, "");
+}
+function repoRootFromCodebyplanDir(codebyplanDir) {
+  return codebyplanDir.endsWith("/.codebyplan") ? codebyplanDir.slice(0, codebyplanDir.lastIndexOf("/")) : codebyplanDir;
+}
+function mapFileSlug(modulePath) {
+  const slug = modulePath.replace(/\//g, "-").replace(/^\./, "dot-");
+  return `${slug}.md`;
+}
+async function resolveCodebyplanDir(startDir) {
+  try {
+    const found = await findCodebyplanConfig(startDir);
+    if (!found) return null;
+    if (found.path.endsWith("/repo.json")) {
+      return found.path.slice(0, found.path.lastIndexOf("/"));
+    }
+    return found.path.slice(0, found.path.lastIndexOf("/"));
+  } catch {
+    return null;
+  }
+}
+async function readArchitectureConfig(codebyplanDir) {
+  const filePath = join23(codebyplanDir, "architecture.json");
+  try {
+    const raw = await readFile17(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.modules)) {
+      return { version: 1, modules: [] };
+    }
+    return parsed;
+  } catch {
+    return { version: 1, modules: [] };
+  }
+}
+async function writeArchitectureConfig(codebyplanDir, config) {
+  const filePath = join23(codebyplanDir, "architecture.json");
+  await writeFile13(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function resolveGitSha(modulePath, cwd) {
+  try {
+    const result = spawnSync7(
+      "git",
+      ["log", "--format=%H", "-1", "--", modulePath],
+      { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    );
+    if (result.status !== 0 || result.error) return null;
+    const sha = (result.stdout ?? "").trim();
+    return sha.length > 0 ? sha : null;
+  } catch {
+    return null;
+  }
+}
+async function discoverModulePaths(projectRoot) {
+  const paths = [];
+  const workspacePath = join23(projectRoot, "pnpm-workspace.yaml");
+  let patterns = [];
+  try {
+    const raw = await readFile17(workspacePath, "utf-8");
+    const lines = raw.split("\n");
+    let inPackages = false;
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.split("#")[0].trim() === "packages:") {
+        inPackages = true;
+        continue;
+      }
+      if (inPackages) {
+        if (trimmed.startsWith("-")) {
+          const pat = trimmed.slice(1).trim().replace(/['"]/g, "");
+          patterns.push(pat);
+        } else if (trimmed && !trimmed.startsWith("#")) {
+          break;
+        }
+      }
+    }
+  } catch {
+    patterns = ["apps/*", "packages/*"];
+  }
+  for (const pattern of patterns) {
+    if (pattern.endsWith("/*")) {
+      const dir = pattern.slice(0, -2);
+      const absDir = join23(projectRoot, dir);
+      try {
+        if (existsSync5(absDir)) {
+          const entries = readdirSync2(absDir, { withFileTypes: true });
+          for (const entry of entries) {
+            if (entry.isDirectory()) {
+              paths.push(`${dir}/${entry.name}`);
+            }
+          }
+        }
+      } catch {
+      }
+    } else if (!pattern.includes("*")) {
+      const absPath = join23(projectRoot, pattern);
+      if (existsSync5(absPath)) {
+        paths.push(pattern);
+      }
+    }
+  }
+  const crossCutting = ["supabase", ".github", "scripts"];
+  for (const dir of crossCutting) {
+    const absPath = join23(projectRoot, dir);
+    try {
+      if (existsSync5(absPath)) {
+        paths.push(dir);
+      }
+    } catch {
+    }
+  }
+  return paths;
+}
+async function runStatus(projectRoot) {
+  console.log("\n  CodeByPlan arch-map status\n");
+  try {
+    const codebyplanDir = await resolveCodebyplanDir(projectRoot);
+    const repoRoot = codebyplanDir ? repoRootFromCodebyplanDir(codebyplanDir) : projectRoot;
+    const config = codebyplanDir ? await readArchitectureConfig(codebyplanDir) : { version: 1, modules: [] };
+    const manifestByPath = /* @__PURE__ */ new Map();
+    for (const entry of config.modules) {
+      manifestByPath.set(normalizeModulePath(entry.path), entry);
+    }
+    let modulePaths = [];
+    try {
+      modulePaths = await discoverModulePaths(repoRoot);
+    } catch {
+      console.warn("  Warning: could not discover modules from workspace");
+    }
+    if (modulePaths.length === 0 && config.modules.length === 0) {
+      console.log("  No modules found.\n");
+      return;
+    }
+    const allPaths = /* @__PURE__ */ new Set([
+      ...modulePaths.map(normalizeModulePath),
+      ...config.modules.map((e) => normalizeModulePath(e.path))
+    ]);
+    console.log(
+      "  Module".padEnd(40) + "Map".padEnd(8) + "Stamped".padEnd(12) + "Status"
+    );
+    console.log("  " + "-".repeat(70));
+    for (const modPath of allPaths) {
+      const entry = manifestByPath.get(modPath);
+      const hasMap = !!entry;
+      const stamped = entry?.generated_from_sha != null;
+      let freshness = "-";
+      if (stamped && entry) {
+        const currentSha = resolveGitSha(modPath, repoRoot);
+        if (currentSha == null) {
+          freshness = "unknown";
+        } else if (currentSha === entry.generated_from_sha) {
+          freshness = "fresh";
+        } else {
+          freshness = "stale";
+        }
+      }
+      console.log(
+        "  " + modPath.padEnd(38) + (hasMap ? "yes" : "no").padEnd(8) + (stamped ? "yes" : "no").padEnd(12) + freshness
+      );
+    }
+    console.log();
+  } catch (err) {
+    console.warn(
+      `  Warning: arch-map status error: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+async function runDrift(projectRoot) {
+  console.log("\n  CodeByPlan arch-map drift\n");
+  try {
+    const codebyplanDir = await resolveCodebyplanDir(projectRoot);
+    if (!codebyplanDir) {
+      console.log("  No .codebyplan/ directory found \u2014 no manifest to check.");
+      console.log();
+      return;
+    }
+    const repoRoot = repoRootFromCodebyplanDir(codebyplanDir);
+    const config = await readArchitectureConfig(codebyplanDir);
+    const stamped = config.modules.filter((e) => e.generated_from_sha != null);
+    if (stamped.length === 0) {
+      console.log("  No stamped modules found \u2014 run arch-map stamp first.");
+      console.log();
+      return;
+    }
+    let driftCount = 0;
+    for (const entry of stamped) {
+      const currentSha = resolveGitSha(entry.path, repoRoot);
+      if (currentSha == null) {
+        console.log(
+          `  ? ${entry.path} \u2014 could not resolve current SHA (git unavailable or path not tracked)`
+        );
+        continue;
+      }
+      if (currentSha !== entry.generated_from_sha) {
+        console.log(`  DRIFTED  ${entry.path}`);
+        console.log(`           stamped: ${entry.generated_from_sha}`);
+        console.log(`           current: ${currentSha}`);
+        driftCount++;
+      }
+    }
+    if (driftCount === 0) {
+      console.log("  All stamped modules are fresh.");
+    } else {
+      console.log(`
+  ${driftCount} module(s) have drifted since last stamp.`);
+    }
+    console.log();
+  } catch (err) {
+    console.warn(
+      `  Warning: arch-map drift error: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+function updateFrontmatterFields(content, fields) {
+  const lines = content.split("\n");
+  if (lines.length === 0 || lines[0] !== "---") {
+    return null;
+  }
+  let closeIndex = -1;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i] === "---") {
+      closeIndex = i;
+      break;
+    }
+  }
+  if (closeIndex === -1) {
+    return null;
+  }
+  const result = lines.map((line, idx) => {
+    if (idx === 0 || idx >= closeIndex) {
+      return line;
+    }
+    if (/^generated_from_sha:\s*/.test(line)) {
+      return `generated_from_sha: ${fields.generated_from_sha}`;
+    }
+    if (/^generated_at:\s*/.test(line)) {
+      return `generated_at: ${fields.generated_at}`;
+    }
+    if (fields.depth !== void 0 && /^depth:\s*/.test(line)) {
+      return `depth: ${fields.depth}`;
+    }
+    return line;
+  });
+  return result.join("\n");
+}
+async function runStamp(modulePath, sha, depthArg, projectRoot) {
+  const codebyplanDir = await resolveCodebyplanDir(projectRoot);
+  if (!codebyplanDir) {
+    process.stderr.write(
+      "  Error: no .codebyplan/ directory found. Run `codebyplan setup` first.\n"
+    );
+    process.exit(1);
+  }
+  const repoRoot = repoRootFromCodebyplanDir(codebyplanDir);
+  let resolvedSha = sha;
+  if (!resolvedSha) {
+    resolvedSha = resolveGitSha(modulePath, repoRoot);
+    if (!resolvedSha) {
+      process.stderr.write(
+        `  Error: could not resolve SHA for ${modulePath}. Provide --sha <value>.
+`
+      );
+      process.exit(1);
+    }
+  }
+  const config = await readArchitectureConfig(codebyplanDir);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const mapFile = mapFileSlug(modulePath);
+  const mapFilePath = `.claude/architecture/${mapFile}`;
+  const existingIndex = config.modules.findIndex((e) => e.path === modulePath);
+  if (existingIndex >= 0) {
+    config.modules[existingIndex] = {
+      ...config.modules[existingIndex],
+      map_file: mapFilePath,
+      generated_from_sha: resolvedSha,
+      generated_at: now,
+      ...depthArg !== null ? { depth: depthArg } : {}
+    };
+  } else {
+    config.modules.push({
+      path: modulePath,
+      map_file: mapFilePath,
+      generated_from_sha: resolvedSha,
+      depth: depthArg ?? "skeleton",
+      generated_at: now
+    });
+  }
+  await writeArchitectureConfig(codebyplanDir, config);
+  const stampedEntry = existingIndex >= 0 ? config.modules[existingIndex] : config.modules[config.modules.length - 1];
+  const mapAbsPath = join23(repoRoot, stampedEntry.map_file);
+  let mapContent = null;
+  try {
+    mapContent = await readFile17(mapAbsPath, "utf-8");
+  } catch {
+    console.warn(
+      "  Warning: map file " + stampedEntry.map_file + " not found \u2014 stamped manifest only"
+    );
+  }
+  if (mapContent !== null) {
+    const updated = updateFrontmatterFields(mapContent, {
+      generated_from_sha: resolvedSha,
+      generated_at: now,
+      ...depthArg !== null ? { depth: depthArg } : {}
+    });
+    if (updated === null) {
+      console.warn(
+        "  Warning: no frontmatter block in " + stampedEntry.map_file + " \u2014 stamped manifest only"
+      );
+    } else if (!updated.includes(`generated_from_sha: ${resolvedSha}`) || !updated.includes(`generated_at: ${now}`)) {
+      console.warn(
+        "  Warning: " + stampedEntry.map_file + " frontmatter missing generated_from_sha/generated_at \u2014 not mirrored (manifest stamped)"
+      );
+    } else {
+      try {
+        await writeFile13(mapAbsPath, updated, "utf-8");
+      } catch (writeErr) {
+        console.warn(
+          "  Warning: could not write map file " + stampedEntry.map_file + " \u2014 " + (writeErr instanceof Error ? writeErr.message : String(writeErr)) + " \u2014 stamped manifest only"
+        );
+      }
+    }
+  }
+  console.log(`  Stamped ${modulePath} @ ${resolvedSha.slice(0, 8)} (${now})`);
+}
+async function runArchMapCommand(rest) {
+  const subcommand = rest[0];
+  const projectRoot = process.cwd();
+  if (subcommand === "status") {
+    await runStatus(projectRoot);
+    return;
+  }
+  if (subcommand === "drift") {
+    await runDrift(projectRoot);
+    return;
+  }
+  if (subcommand === "stamp") {
+    const rawModulePath = rest[1];
+    if (!rawModulePath) {
+      process.stderr.write(
+        "  Usage: codebyplan arch-map stamp <module> [--sha <value>]\n"
+      );
+      process.exit(1);
+    }
+    if (rawModulePath.startsWith("/")) {
+      process.stderr.write(
+        "  Error: module path must be relative to the repo root (e.g. apps/web), not absolute.\n"
+      );
+      process.exit(1);
+    }
+    const modulePath = normalizeModulePath(rawModulePath);
+    if (modulePath.split("/").length > 2) {
+      console.warn(
+        `  Warning: ${modulePath} has more than 2 path segments; expected a top-level module path (e.g. apps/web).`
+      );
+    }
+    let sha = null;
+    const shaIdx = rest.indexOf("--sha");
+    if (shaIdx !== -1) {
+      const shaVal = rest[shaIdx + 1];
+      if (!shaVal || shaVal.startsWith("--")) {
+        process.stderr.write("  Error: --sha requires a value.\n");
+        process.exit(1);
+      }
+      if (!/^[0-9a-f]{40}$/i.test(shaVal)) {
+        process.stderr.write(
+          "  Error: --sha value does not look like a git SHA (expected 40 hex chars).\n"
+        );
+        process.exit(1);
+      }
+      sha = shaVal;
+    }
+    let depthArg = null;
+    const depthIdx = rest.indexOf("--depth");
+    if (depthIdx !== -1) {
+      const depthVal = rest[depthIdx + 1];
+      if (!depthVal || depthVal.startsWith("--")) {
+        process.stderr.write("  Error: --depth requires a value.\n");
+        process.exit(1);
+      }
+      if (depthVal !== "skeleton" && depthVal !== "deep") {
+        process.stderr.write("  Error: --depth must be skeleton or deep.\n");
+        process.exit(1);
+      }
+      depthArg = depthVal;
+    }
+    await runStamp(modulePath, sha, depthArg, projectRoot);
+    return;
+  }
+  console.log(`
+  codebyplan arch-map \u2014 Architecture map pipeline
+
+  Note: arch-map commands are intended to run from the repo root.
+
+  Usage:
+    codebyplan arch-map status              List all modules and map freshness
+    codebyplan arch-map drift               Report modules drifted since last stamp
+    codebyplan arch-map stamp <module>      Stamp a module with its current git SHA
+    codebyplan arch-map stamp <module> --sha <sha>  Stamp with an explicit SHA
+    codebyplan arch-map stamp <module> --depth <skeleton|deep>  Stamp with an explicit depth
+`);
+}
+var init_arch_map = __esm({
+  "src/cli/arch-map.ts"() {
+    "use strict";
+    init_flags();
+  }
+});
+
 // src/lib/worktree-port-resolver.ts
 async function resolveWorktreePortAllocations(repoId, projectPath) {
   let resolvedWorktreeId;
@@ -7231,19 +7655,19 @@ var init_worktree_port_resolver = __esm({
 });
 
 // src/lib/migrate-local-config.ts
-import { mkdir as mkdir7, readFile as readFile17, unlink as unlink3, writeFile as writeFile13 } from "node:fs/promises";
-import { join as join23 } from "node:path";
+import { mkdir as mkdir7, readFile as readFile18, unlink as unlink3, writeFile as writeFile14 } from "node:fs/promises";
+import { join as join24 } from "node:path";
 function legacySharedPath(projectPath) {
-  return join23(projectPath, ".codebyplan.json");
+  return join24(projectPath, ".codebyplan.json");
 }
 function legacyLocalPath(projectPath) {
-  return join23(projectPath, ".codebyplan.local.json");
+  return join24(projectPath, ".codebyplan.local.json");
 }
 function newDirPath(projectPath) {
-  return join23(projectPath, ".codebyplan");
+  return join24(projectPath, ".codebyplan");
 }
 function sentinelPath(projectPath) {
-  return join23(projectPath, ".codebyplan", "repo.json");
+  return join24(projectPath, ".codebyplan", "repo.json");
 }
 async function statSafe(p) {
   const { stat: stat2 } = await import("node:fs/promises");
@@ -7282,7 +7706,7 @@ async function runLocalMigration(projectPath) {
   }
   let legacyRaw;
   try {
-    legacyRaw = await readFile17(legacySharedPath(projectPath), "utf-8");
+    legacyRaw = await readFile18(legacySharedPath(projectPath), "utf-8");
   } catch {
     return {
       migrated: true,
@@ -7309,7 +7733,7 @@ async function runLocalMigration(projectPath) {
   let deviceId;
   let deviceWrittenByHelper = false;
   try {
-    const localRaw = await readFile17(legacyLocalPath(projectPath), "utf-8");
+    const localRaw = await readFile18(legacyLocalPath(projectPath), "utf-8");
     const localParsed = JSON.parse(localRaw);
     if (typeof localParsed.device_id === "string") {
       deviceId = localParsed.device_id;
@@ -7336,8 +7760,8 @@ async function runLocalMigration(projectPath) {
   if ("repo_id" in cfg) repoJson.repo_id = cfg.repo_id;
   if ("organization_id" in cfg) repoJson.organization_id = cfg.organization_id;
   if ("project_id" in cfg) repoJson.project_id = cfg.project_id;
-  await writeFile13(
-    join23(projectPath, ".codebyplan", "repo.json"),
+  await writeFile14(
+    join24(projectPath, ".codebyplan", "repo.json"),
     JSON.stringify(repoJson, null, 2) + "\n",
     "utf-8"
   );
@@ -7349,8 +7773,8 @@ async function runLocalMigration(projectPath) {
     serverJson.auto_push_enabled = cfg.auto_push_enabled;
   if ("port_allocations" in cfg)
     serverJson.port_allocations = cfg.port_allocations;
-  await writeFile13(
-    join23(projectPath, ".codebyplan", "server.json"),
+  await writeFile14(
+    join24(projectPath, ".codebyplan", "server.json"),
     JSON.stringify(serverJson, null, 2) + "\n",
     "utf-8"
   );
@@ -7358,44 +7782,44 @@ async function runLocalMigration(projectPath) {
   const gitJson = {};
   if ("git_branch" in cfg) gitJson.git_branch = cfg.git_branch;
   if ("branch_config" in cfg) gitJson.branch_config = cfg.branch_config;
-  await writeFile13(
-    join23(projectPath, ".codebyplan", "git.json"),
+  await writeFile14(
+    join24(projectPath, ".codebyplan", "git.json"),
     JSON.stringify(gitJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/git.json");
   const shipmentJson = {};
   if ("shipment" in cfg) shipmentJson.shipment = cfg.shipment;
-  await writeFile13(
-    join23(projectPath, ".codebyplan", "shipment.json"),
+  await writeFile14(
+    join24(projectPath, ".codebyplan", "shipment.json"),
     JSON.stringify(shipmentJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/shipment.json");
   const vendorJson = {};
-  await writeFile13(
-    join23(projectPath, ".codebyplan", "vendor.json"),
+  await writeFile14(
+    join24(projectPath, ".codebyplan", "vendor.json"),
     JSON.stringify(vendorJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/vendor.json");
   const e2eJson = {};
-  await writeFile13(
-    join23(projectPath, ".codebyplan", "e2e.json"),
+  await writeFile14(
+    join24(projectPath, ".codebyplan", "e2e.json"),
     JSON.stringify(e2eJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/e2e.json");
   const eslintJson = {};
-  await writeFile13(
-    join23(projectPath, ".codebyplan", "eslint.json"),
+  await writeFile14(
+    join24(projectPath, ".codebyplan", "eslint.json"),
     JSON.stringify(eslintJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/eslint.json");
   if (!deviceWrittenByHelper) {
-    await writeFile13(
-      join23(projectPath, ".codebyplan", "device.local.json"),
+    await writeFile14(
+      join24(projectPath, ".codebyplan", "device.local.json"),
       JSON.stringify({ device_id: deviceId }, null, 2) + "\n",
       "utf-8"
     );
@@ -7407,9 +7831,9 @@ async function runLocalMigration(projectPath) {
       "Migration write incomplete: .codebyplan/repo.json was not persisted. Re-run migration to retry from a clean state."
     );
   }
-  const gitignorePath = join23(projectPath, ".gitignore");
+  const gitignorePath = join24(projectPath, ".gitignore");
   try {
-    const gitignoreContent = await readFile17(gitignorePath, "utf-8");
+    const gitignoreContent = await readFile18(gitignorePath, "utf-8");
     const legacyLine = ".codebyplan.local.json";
     const newLine = ".codebyplan/device.local.json";
     const hasLegacy = gitignoreContent.split("\n").some((l) => l.trimEnd() === legacyLine);
@@ -7428,7 +7852,7 @@ async function runLocalMigration(projectPath) {
       updated = gitignoreContent;
     }
     if (updated !== gitignoreContent) {
-      await writeFile13(gitignorePath, updated, "utf-8");
+      await writeFile14(gitignorePath, updated, "utf-8");
       filesChanged.push(".gitignore");
     }
   } catch {
@@ -7469,8 +7893,8 @@ __export(config_exports, {
   readVendorConfig: () => readVendorConfig,
   runConfig: () => runConfig
 });
-import { mkdir as mkdir8, readFile as readFile18, writeFile as writeFile14 } from "node:fs/promises";
-import { join as join24 } from "node:path";
+import { mkdir as mkdir8, readFile as readFile19, writeFile as writeFile15 } from "node:fs/promises";
+import { join as join25 } from "node:path";
 async function runConfig() {
   const flags = parseFlags(3);
   const dryRun = hasFlag("dry-run", 3);
@@ -7503,7 +7927,7 @@ async function runConfig() {
   console.log("\n  Config complete.\n");
 }
 async function syncConfigToFile(repoId, projectPath, dryRun) {
-  const codebyplanDir = join24(projectPath, ".codebyplan");
+  const codebyplanDir = join25(projectPath, ".codebyplan");
   const {
     resolvedWorktreeId,
     portAllocations,
@@ -7571,6 +7995,10 @@ async function syncConfigToFile(repoId, projectPath, dryRun) {
   const vendorPayload = {};
   const e2ePayload = {};
   const eslintPayload = {};
+  const architecturePayload = {
+    version: 1,
+    modules: []
+  };
   if (dryRun) {
     console.log("  Config would be updated (dry-run).");
     return;
@@ -7583,20 +8011,25 @@ async function syncConfigToFile(repoId, projectPath, dryRun) {
     { name: "shipment.json", payload: shipmentPayload },
     { name: "vendor.json", payload: vendorPayload },
     { name: "e2e.json", payload: e2ePayload, createOnly: true },
-    { name: "eslint.json", payload: eslintPayload, createOnly: true }
+    { name: "eslint.json", payload: eslintPayload, createOnly: true },
+    {
+      name: "architecture.json",
+      payload: architecturePayload,
+      createOnly: true
+    }
   ];
   let anyUpdated = false;
   for (const { name, payload, createOnly } of files) {
-    const filePath = join24(codebyplanDir, name);
+    const filePath = join25(codebyplanDir, name);
     const newJson = JSON.stringify(payload, null, 2) + "\n";
     let currentJson = "";
     try {
-      currentJson = await readFile18(filePath, "utf-8");
+      currentJson = await readFile19(filePath, "utf-8");
     } catch {
     }
     if (createOnly && currentJson !== "") continue;
     if (currentJson === newJson) continue;
-    await writeFile14(filePath, newJson, "utf-8");
+    await writeFile15(filePath, newJson, "utf-8");
     console.log(`  Updated .codebyplan/${name}`);
     anyUpdated = true;
   }
@@ -7606,8 +8039,8 @@ async function syncConfigToFile(repoId, projectPath, dryRun) {
 }
 async function readRepoConfig(projectPath) {
   try {
-    const raw = await readFile18(
-      join24(projectPath, ".codebyplan", "repo.json"),
+    const raw = await readFile19(
+      join25(projectPath, ".codebyplan", "repo.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -7617,8 +8050,8 @@ async function readRepoConfig(projectPath) {
 }
 async function readServerConfig(projectPath) {
   try {
-    const raw = await readFile18(
-      join24(projectPath, ".codebyplan", "server.json"),
+    const raw = await readFile19(
+      join25(projectPath, ".codebyplan", "server.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -7628,8 +8061,8 @@ async function readServerConfig(projectPath) {
 }
 async function readGitConfig(projectPath) {
   try {
-    const raw = await readFile18(
-      join24(projectPath, ".codebyplan", "git.json"),
+    const raw = await readFile19(
+      join25(projectPath, ".codebyplan", "git.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -7639,8 +8072,8 @@ async function readGitConfig(projectPath) {
 }
 async function readShipmentConfig(projectPath) {
   try {
-    const raw = await readFile18(
-      join24(projectPath, ".codebyplan", "shipment.json"),
+    const raw = await readFile19(
+      join25(projectPath, ".codebyplan", "shipment.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -7650,8 +8083,8 @@ async function readShipmentConfig(projectPath) {
 }
 async function readVendorConfig(projectPath) {
   try {
-    const raw = await readFile18(
-      join24(projectPath, ".codebyplan", "vendor.json"),
+    const raw = await readFile19(
+      join25(projectPath, ".codebyplan", "vendor.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -7661,8 +8094,8 @@ async function readVendorConfig(projectPath) {
 }
 async function readE2eConfig2(projectPath) {
   try {
-    const raw = await readFile18(
-      join24(projectPath, ".codebyplan", "e2e.json"),
+    const raw = await readFile19(
+      join25(projectPath, ".codebyplan", "e2e.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -7672,8 +8105,8 @@ async function readE2eConfig2(projectPath) {
 }
 async function readServerLocalConfig(projectPath) {
   try {
-    const raw = await readFile18(
-      join24(projectPath, ".codebyplan", "server.local.json"),
+    const raw = await readFile19(
+      join25(projectPath, ".codebyplan", "server.local.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -7728,14 +8161,14 @@ var init_server_detect = __esm({
 });
 
 // src/lib/port-verify.ts
-import { readFile as readFile19 } from "node:fs/promises";
+import { readFile as readFile20 } from "node:fs/promises";
 async function verifyPorts(projectPath, portAllocations) {
   const mismatches = [];
   const allocatedPorts = new Set(portAllocations.map((a) => a.port));
   const packageJsonPaths = await findPackageJsonFiles(projectPath, projectPath);
   for (const pkgPath of packageJsonPaths) {
     try {
-      const raw = await readFile19(pkgPath, "utf-8");
+      const raw = await readFile20(pkgPath, "utf-8");
       const pkg = JSON.parse(raw);
       const scriptPort = detectPortFromScripts(pkg);
       if (scriptPort !== null && !allocatedPorts.has(scriptPort)) {
@@ -7798,7 +8231,7 @@ async function findUnallocatedApps(projectPath, portAllocations) {
     }
     let pkg;
     try {
-      const raw = await readFile19(`${app.absPath}/package.json`, "utf-8");
+      const raw = await readFile20(`${app.absPath}/package.json`, "utf-8");
       pkg = JSON.parse(raw);
     } catch {
       continue;
@@ -7848,8 +8281,8 @@ __export(ports_exports, {
   parseEnvFile: () => parseEnvFile,
   runPorts: () => runPorts
 });
-import { mkdir as mkdir9, readFile as readFile20, writeFile as writeFile15 } from "node:fs/promises";
-import { join as join25 } from "node:path";
+import { mkdir as mkdir9, readFile as readFile21, writeFile as writeFile16 } from "node:fs/promises";
+import { join as join26 } from "node:path";
 async function runPorts() {
   const flags = parseFlags(3);
   const dryRun = hasFlag("dry-run", 3);
@@ -7970,12 +8403,12 @@ async function writeServerLocalConfig(repoId, projectPath, dryRun) {
     // and ServerLocalConfig.port_allocations is typed the same — honest end-to-end.
     port_allocations: portAllocations
   };
-  const codebyplanDir = join25(projectPath, ".codebyplan");
-  const filePath = join25(codebyplanDir, "server.local.json");
+  const codebyplanDir = join26(projectPath, ".codebyplan");
+  const filePath = join26(codebyplanDir, "server.local.json");
   const newJson = JSON.stringify(payload, null, 2) + "\n";
   let currentJson = "";
   try {
-    currentJson = await readFile20(filePath, "utf-8");
+    currentJson = await readFile21(filePath, "utf-8");
   } catch {
   }
   if (currentJson === newJson) {
@@ -7987,17 +8420,17 @@ async function writeServerLocalConfig(repoId, projectPath, dryRun) {
     return;
   }
   await mkdir9(codebyplanDir, { recursive: true });
-  await writeFile15(filePath, newJson, "utf-8");
+  await writeFile16(filePath, newJson, "utf-8");
   console.log(
     `  Updated .codebyplan/server.local.json (worktree ${resolvedWorktreeId ?? "\u2014"}, ${portAllocations.length} allocation${portAllocations.length === 1 ? "" : "s"}).`
   );
 }
 async function provisionE2eEnv(projectPath, dryRun) {
-  const relSource = join25("apps", "web", ".env.local");
-  const sourcePath = join25(projectPath, relSource);
+  const relSource = join26("apps", "web", ".env.local");
+  const sourcePath = join26(projectPath, relSource);
   let sourceRaw;
   try {
-    sourceRaw = await readFile20(sourcePath, "utf-8");
+    sourceRaw = await readFile21(sourcePath, "utf-8");
   } catch {
     console.warn(
       `  Skipped .codebyplan/e2e.env \u2014 source ${relSource} not found.`
@@ -8026,12 +8459,12 @@ async function provisionE2eEnv(projectPath, dryRun) {
     );
     return;
   }
-  const codebyplanDir = join25(projectPath, ".codebyplan");
-  const filePath = join25(codebyplanDir, "e2e.env");
+  const codebyplanDir = join26(projectPath, ".codebyplan");
+  const filePath = join26(codebyplanDir, "e2e.env");
   const newContent = lines.join("\n") + "\n";
   let currentContent = "";
   try {
-    currentContent = await readFile20(filePath, "utf-8");
+    currentContent = await readFile21(filePath, "utf-8");
   } catch {
   }
   if (currentContent === newContent) {
@@ -8043,7 +8476,7 @@ async function provisionE2eEnv(projectPath, dryRun) {
     return;
   }
   await mkdir9(codebyplanDir, { recursive: true });
-  await writeFile15(filePath, newContent, "utf-8");
+  await writeFile16(filePath, newContent, "utf-8");
   console.log(
     `  Provisioned .codebyplan/e2e.env (${lines.length} var${lines.length === 1 ? "" : "s"}).`
   );
@@ -8093,7 +8526,7 @@ __export(tech_stack_exports, {
   runFullTechStack: () => runFullTechStack,
   runTechStack: () => runTechStack
 });
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync6 } from "node:fs";
 async function runTechStack() {
   const flags = parseFlags(3);
   const dryRun = hasFlag("dry-run", 3);
@@ -8266,7 +8699,7 @@ async function runFullTechStack(dryRun) {
       continue;
     }
     const localWorktrees = worktrees.filter(
-      (wt) => wt.path ? existsSync5(wt.path) : false
+      (wt) => wt.path ? existsSync6(wt.path) : false
     );
     if (localWorktrees.length === 0) {
       console.log(`  skipping ${repo.name} \u2014 no local worktree on this device`);
@@ -8366,7 +8799,7 @@ var init_claude_plan = __esm({
 // src/cli/claude/status.ts
 var status_exports = {};
 __export(status_exports, {
-  runStatus: () => runStatus
+  runStatus: () => runStatus2
 });
 import * as fs6 from "node:fs";
 import * as path7 from "node:path";
@@ -8433,7 +8866,7 @@ function resolveCurrentBranch2() {
     }
   }
 }
-async function runStatus(argv) {
+async function runStatus2(argv) {
   const checked_at = (/* @__PURE__ */ new Date()).toISOString();
   const writeCache = argv.includes("--write-cache");
   const quiet = argv.includes("--quiet");
@@ -9618,11 +10051,11 @@ var generate_exports = {};
 __export(generate_exports, {
   runGenerate: () => runGenerate
 });
-import { readFile as readFile21, mkdir as mkdir10, writeFile as writeFile16 } from "node:fs/promises";
-import { join as join30, resolve as resolve8 } from "node:path";
+import { readFile as readFile22, mkdir as mkdir10, writeFile as writeFile17 } from "node:fs/promises";
+import { join as join31, resolve as resolve8 } from "node:path";
 async function readJsonFile3(filePath) {
   try {
-    const raw = await readFile21(filePath, "utf-8");
+    const raw = await readFile22(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -9630,7 +10063,7 @@ async function readJsonFile3(filePath) {
 }
 async function readPkgName(absPath) {
   try {
-    const raw = await readFile21(join30(absPath, "package.json"), "utf-8");
+    const raw = await readFile22(join31(absPath, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     return typeof pkg.name === "string" ? pkg.name : null;
   } catch {
@@ -9644,7 +10077,7 @@ async function runGenerate(opts) {
   const rootDir = resolve8(projectDir);
   let packageManager;
   try {
-    const raw = await readFile21(join30(rootDir, "package.json"), "utf-8");
+    const raw = await readFile22(join31(rootDir, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     if (typeof pkg.packageManager === "string") {
       packageManager = pkg.packageManager;
@@ -9652,7 +10085,7 @@ async function runGenerate(opts) {
   } catch {
   }
   const serverJson = await readJsonFile3(
-    join30(rootDir, ".codebyplan", "server.json")
+    join31(rootDir, ".codebyplan", "server.json")
   );
   const ports = [];
   for (const alloc of serverJson?.port_allocations ?? []) {
@@ -9665,7 +10098,7 @@ async function runGenerate(opts) {
     }
   }
   const gitJson = await readJsonFile3(
-    join30(rootDir, ".codebyplan", "git.json")
+    join31(rootDir, ".codebyplan", "git.json")
   );
   const branchModel = gitJson?.branch_config?.production ? {
     production: gitJson.branch_config.production,
@@ -9674,7 +10107,7 @@ async function runGenerate(opts) {
     )
   } : void 0;
   const shipmentJson = await readJsonFile3(
-    join30(rootDir, ".codebyplan", "shipment.json")
+    join31(rootDir, ".codebyplan", "shipment.json")
   );
   const shipmentSurfaces = [];
   const rawSurfaces = shipmentJson?.shipment?.surfaces ?? shipmentJson?.surfaces ?? {};
@@ -9745,10 +10178,10 @@ async function runGenerate(opts) {
   const structureMdContent = generateStructureMd(config);
   const agentsContent = generateAgentsMd(structureMdContent);
   if (check) {
-    const agentsMdPath2 = join30(rootDir, "AGENTS.md");
+    const agentsMdPath2 = join31(rootDir, "AGENTS.md");
     let existingAgents = null;
     try {
-      existingAgents = await readFile21(agentsMdPath2, "utf-8");
+      existingAgents = await readFile22(agentsMdPath2, "utf-8");
     } catch {
       existingAgents = null;
     }
@@ -9784,16 +10217,16 @@ async function runGenerate(opts) {
     process.stdout.write(agentsContent);
     return;
   }
-  const outputDir = join30(rootDir, ".claude", "generated");
+  const outputDir = join31(rootDir, ".claude", "generated");
   await mkdir10(outputDir, { recursive: true });
-  const outputPath = join30(outputDir, "structure.md");
-  await writeFile16(outputPath, structureMdContent, "utf-8");
+  const outputPath = join31(outputDir, "structure.md");
+  await writeFile17(outputPath, structureMdContent, "utf-8");
   process.stdout.write(`Wrote: .claude/generated/structure.md
 `);
-  const agentsMdPath = join30(rootDir, "AGENTS.md");
+  const agentsMdPath = join31(rootDir, "AGENTS.md");
   let existingAgentsContent = null;
   try {
-    existingAgentsContent = await readFile21(agentsMdPath, "utf-8");
+    existingAgentsContent = await readFile22(agentsMdPath, "utf-8");
   } catch {
     existingAgentsContent = null;
   }
@@ -9801,7 +10234,7 @@ async function runGenerate(opts) {
     process.stdout.write(`Up to date: AGENTS.md
 `);
   } else {
-    await writeFile16(agentsMdPath, agentsContent, "utf-8");
+    await writeFile17(agentsMdPath, agentsContent, "utf-8");
     process.stdout.write(`Wrote: AGENTS.md
 `);
   }
@@ -9821,11 +10254,11 @@ __export(readme_exports, {
   runReadme: () => runReadme,
   runReadmeCommand: () => runReadmeCommand
 });
-import { readFile as readFile22, writeFile as writeFile17 } from "node:fs/promises";
-import { join as join31, resolve as resolve9, relative as relative8 } from "node:path";
+import { readFile as readFile23, writeFile as writeFile18 } from "node:fs/promises";
+import { join as join32, resolve as resolve9, relative as relative8 } from "node:path";
 async function readJsonFile4(filePath) {
   try {
-    const raw = await readFile22(filePath, "utf-8");
+    const raw = await readFile23(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -9894,7 +10327,7 @@ async function discoverUnits(rootDir, rootPkgJson) {
   const discovered = await discoverMonorepoApps(rootDir);
   for (const app of discovered) {
     const pkgJson = await readJsonFile4(
-      join31(app.absPath, "package.json")
+      join32(app.absPath, "package.json")
     );
     pkgJsonByPath.set(app.absPath, pkgJson);
     allPackages.push({
@@ -9920,7 +10353,7 @@ async function runReadme(opts) {
   const init = opts.init ?? opts["init"] ?? false;
   const rootDir = resolve9(projectDir);
   const rootPkgJson = await readJsonFile4(
-    join31(rootDir, "package.json")
+    join32(rootDir, "package.json")
   );
   const { units, allPackages, pkgJsonByPath } = await discoverUnits(
     rootDir,
@@ -9929,11 +10362,11 @@ async function runReadme(opts) {
   const driftUnits = [];
   const missingUnits = [];
   for (const unit of units) {
-    const readmePath = join31(unit.absPath, "README.md");
-    const relPath = unit.isRoot ? "README.md" : join31(relative8(rootDir, unit.absPath), "README.md");
+    const readmePath = join32(unit.absPath, "README.md");
+    const relPath = unit.isRoot ? "README.md" : join32(relative8(rootDir, unit.absPath), "README.md");
     let existingContent = null;
     try {
-      existingContent = await readFile22(readmePath, "utf-8");
+      existingContent = await readFile23(readmePath, "utf-8");
     } catch {
       existingContent = null;
     }
@@ -9968,7 +10401,7 @@ ${newContent}
 `
         );
       } else {
-        await writeFile17(readmePath, newContent, "utf-8");
+        await writeFile18(readmePath, newContent, "utf-8");
         process.stdout.write(`Wrote (scaffold): ${relPath}
 `);
       }
@@ -10006,7 +10439,7 @@ ${newContent}
 `
         );
       } else {
-        await writeFile17(readmePath, newContent, "utf-8");
+        await writeFile18(readmePath, newContent, "utf-8");
         process.stdout.write(`Wrote (refresh): ${relPath}
 `);
       }
@@ -10025,7 +10458,7 @@ ${newContent}
 `
           );
         } else {
-          await writeFile17(readmePath, newContent, "utf-8");
+          await writeFile18(readmePath, newContent, "utf-8");
           process.stdout.write(`Wrote (init): ${relPath}
 `);
         }
@@ -10113,15 +10546,15 @@ __export(migrate_memory_exports, {
   runMigrateMemory: () => runMigrateMemory
 });
 import {
-  readFile as readFile23,
-  writeFile as writeFile18,
+  readFile as readFile24,
+  writeFile as writeFile19,
   mkdir as mkdir11,
   unlink as unlink4,
   rmdir,
   readdir as readdir4
 } from "node:fs/promises";
-import { existsSync as existsSync10 } from "node:fs";
-import { join as join32, resolve as resolve10, dirname as dirname11, sep as sep2 } from "node:path";
+import { existsSync as existsSync11 } from "node:fs";
+import { join as join33, resolve as resolve10, dirname as dirname11, sep as sep2 } from "node:path";
 import { homedir as homedir8 } from "node:os";
 function encodeProjectPath(absPath) {
   return resolve10(absPath).replace(/[/\\]/g, "-");
@@ -10132,7 +10565,7 @@ function resolveAutoMemoryDir(opts) {
   }
   const projectDir = opts.projectDir ?? process.cwd();
   const encoded = encodeProjectPath(projectDir);
-  return join32(homedir8(), ".claude", "projects", encoded, "memory");
+  return join33(homedir8(), ".claude", "projects", encoded, "memory");
 }
 function parseFrontmatter(content) {
   content = content.replace(/\r\n/g, "\n");
@@ -10198,10 +10631,10 @@ async function inventoryFiles(dir) {
   }
   const results = [];
   for (const filename of filenames) {
-    const sourcePath = join32(dir, filename);
+    const sourcePath = join33(dir, filename);
     let raw;
     try {
-      raw = await readFile23(sourcePath, "utf-8");
+      raw = await readFile24(sourcePath, "utf-8");
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       results.push({
@@ -10287,8 +10720,8 @@ async function applyPlan(plan, opts) {
     if (entry.suggested_action !== "keep") continue;
     if (!entry.suggested_target?.startsWith("nested:")) continue;
     const relPath = entry.suggested_target.slice("nested:".length);
-    const targetDir = resolve10(join32(projectDir, relPath));
-    const targetFile = join32(targetDir, "CLAUDE.md");
+    const targetDir = resolve10(join33(projectDir, relPath));
+    const targetFile = join33(targetDir, "CLAUDE.md");
     if (!targetDir.startsWith(resolve10(projectDir) + sep2)) {
       process.stderr.write(
         `migrate-memory: skipping unsafe suggested_target "${entry.suggested_target}" \u2014 resolves outside projectDir
@@ -10320,11 +10753,11 @@ ${anchor}
     await mkdir11(targetDir, { recursive: true });
     let existing = "";
     try {
-      existing = await readFile23(targetFile, "utf-8");
+      existing = await readFile24(targetFile, "utf-8");
     } catch {
     }
     if (!existing.includes(anchor)) {
-      await writeFile18(targetFile, existing + appendContent, "utf-8");
+      await writeFile19(targetFile, existing + appendContent, "utf-8");
     }
     if (resolve10(entry.source_path).startsWith(resolve10(plan.auto_memory_dir) + sep2)) {
       try {
@@ -10338,7 +10771,7 @@ ${anchor}
       );
     }
   }
-  const rootClaudeMd = join32(projectDir, ".claude", "CLAUDE.md");
+  const rootClaudeMd = join33(projectDir, ".claude", "CLAUDE.md");
   if (dryRun) {
     process.stdout.write(
       `[dry-run] Would ensure ${rootClaudeMd} contains: ${IMPORT_LINE}
@@ -10347,12 +10780,12 @@ ${anchor}
   } else {
     let claudeMdContent = "";
     try {
-      claudeMdContent = await readFile23(rootClaudeMd, "utf-8");
+      claudeMdContent = await readFile24(rootClaudeMd, "utf-8");
     } catch {
       await mkdir11(dirname11(rootClaudeMd), { recursive: true });
     }
     if (!claudeMdContent.includes(IMPORT_LINE)) {
-      await writeFile18(
+      await writeFile19(
         rootClaudeMd,
         claudeMdContent + `
 ${IMPORT_LINE}
@@ -10382,8 +10815,8 @@ ${IMPORT_LINE}
     } catch {
     }
   }
-  const memoryMd = join32(plan.auto_memory_dir, "MEMORY.md");
-  const safeRmdirBase = join32(homedir8(), ".claude", "projects");
+  const memoryMd = join33(plan.auto_memory_dir, "MEMORY.md");
+  const safeRmdirBase = join33(homedir8(), ".claude", "projects");
   if (dryRun) {
     process.stdout.write(`[dry-run] Would delete MEMORY.md: ${memoryMd}
 `);
@@ -10436,7 +10869,7 @@ async function runMigrateMemory(opts) {
   if (applyFile) {
     let planJson;
     try {
-      planJson = await readFile23(resolve10(applyFile), "utf-8");
+      planJson = await readFile24(resolve10(applyFile), "utf-8");
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       process.stderr.write(
@@ -10464,7 +10897,7 @@ async function runMigrateMemory(opts) {
     );
     return;
   }
-  if (!existsSync10(autoMemoryDir)) {
+  if (!existsSync11(autoMemoryDir)) {
     process.stdout.write(
       JSON.stringify(
         {
@@ -10651,6 +11084,12 @@ void (async () => {
     await runUploadE2eImagesCommand2(rest);
     process.exit(0);
   }
+  if (arg === "arch-map") {
+    const { runArchMapCommand: runArchMapCommand2 } = await Promise.resolve().then(() => (init_arch_map(), arch_map_exports));
+    const rest = process.argv.slice(3);
+    await runArchMapCommand2(rest);
+    process.exit(0);
+  }
   if (arg === "config") {
     const { runConfig: runConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
     await runConfig2();
@@ -10676,8 +11115,8 @@ void (async () => {
     const flagArgs = process.argv.slice(3);
     const parsed = parseClaudeFlags(flagArgs);
     if (subcommand === "status") {
-      const { runStatus: runStatus2 } = await Promise.resolve().then(() => (init_status(), status_exports));
-      await runStatus2(process.argv.slice(4));
+      const { runStatus: runStatus3 } = await Promise.resolve().then(() => (init_status(), status_exports));
+      await runStatus3(process.argv.slice(4));
       return;
     }
     if (subcommand === "install") {
@@ -10795,6 +11234,7 @@ void (async () => {
     codebyplan create-project        Create a new project within an organization (interactive prompt)
     codebyplan create-repo           Create a new repository within a project (interactive prompt)
     codebyplan config                Sync repo config from DB to .codebyplan/ files
+    codebyplan arch-map              Map architecture modules (status/drift/stamp)
     codebyplan ports                 Verify port allocations against local package.json scripts
     codebyplan tech-stack            Detect and sync tech stack dependencies
                                      (--full-tech-stack: sync every local worktree on this device)