@launchsecure/launch-kit 0.0.38 → 0.0.40

package/dist/server/init-entry.js

@@ -274,6 +274,11 @@ function writeScripts() {
   fs4.writeFileSync(WRAPPER_PATH, readScaffold("statusline-wrapper.sh"), { mode: 493 });
   fs4.writeFileSync(CHIP_PATH, readScaffold("statusline-mcp.sh"), { mode: 493 });
 }
+function writeBaseScript() {
+  fs4.mkdirSync(LK_DIR, { recursive: true });
+  fs4.writeFileSync(BASE_PATH, readScaffold("statusline-base.sh"), { mode: 493 });
+  return `bash ${BASE_PATH}`;
+}
 function wrapperCommand(opts) {
   const env = [];
   if (opts.show) env.push(`LK_STATUSLINE_SHOW=${opts.show}`);
@@ -282,10 +287,7 @@ function wrapperCommand(opts) {
   return `${prefix}bash ${WRAPPER_PATH}`;
 }
 function activateStatusline(opts = {}) {
-  const settings = readSettings();
-  if (!settings) {
-    return { ok: false, outcome: "no-settings", message: `no ~/.claude/settings.json \u2014 nothing to wrap` };
-  }
+  const settings = readSettings() ?? {};
   const currentCmd = settings.statusLine?.command;
   const alreadyWrapped = typeof currentCmd === "string" && currentCmd.includes(WRAPPER_PATH);
   if (alreadyWrapped) {
@@ -304,20 +306,22 @@ function activateStatusline(opts = {}) {
     }
     return { ok: true, outcome: "refreshed", message: "statusline already wrapped \u2014 refreshed chip scripts only" };
   }
-  if (!currentCmd) {
-    return { ok: false, outcome: "no-statusline", message: "no statusLine.command in ~/.claude/settings.json \u2014 launch-kit only extends an existing statusline" };
-  }
   writeScripts();
+  const scaffolded = !currentCmd;
+  const original = scaffolded ? { type: "command", command: writeBaseScript() } : settings.statusLine;
   const wrapped = {
     ...settings,
     statusLine: { type: "command", command: wrapperCommand(opts) },
-    [ORIGINAL_KEY]: settings.statusLine
+    [ORIGINAL_KEY]: original
   };
   writeSettings(wrapped);
   const modeParts = [];
   if (opts.show) modeParts.push(`chips: ${opts.show}`);
   if (opts.compact) modeParts.push("compact mode");
   const modeDesc = modeParts.length > 0 ? ` (${modeParts.join(", ")})` : "";
+  if (scaffolded) {
+    return { ok: true, outcome: "scaffolded", message: `no statusline found \u2014 scaffolded Claude Code's default base line and wrapped it with chips${modeDesc}; base stashed under ${ORIGINAL_KEY}` };
+  }
   return { ok: true, outcome: "activated", message: `wrapped statusLine.command${modeDesc}; original stashed under ${ORIGINAL_KEY}` };
 }
 function deactivateStatusline() {
@@ -327,18 +331,26 @@ function deactivateStatusline() {
   if (!original) {
     return { ok: false, outcome: "not-active", message: `no ${ORIGINAL_KEY} in settings.json \u2014 statusline isn't wrapped by launch-kit` };
   }
-  const restored = { ...settings, statusLine: original };
+  const wasScaffolded = original.command?.includes(BASE_PATH) ?? false;
+  const restored = { ...settings };
+  if (wasScaffolded) delete restored.statusLine;
+  else restored.statusLine = original;
   delete restored[ORIGINAL_KEY];
   writeSettings(restored);
-  for (const p of [WRAPPER_PATH, CHIP_PATH]) {
+  const toRemove = wasScaffolded ? [WRAPPER_PATH, CHIP_PATH, BASE_PATH] : [WRAPPER_PATH, CHIP_PATH];
+  for (const p of toRemove) {
     try {
       fs4.unlinkSync(p);
     } catch {
     }
   }
-  return { ok: true, outcome: "deactivated", message: "restored original statusLine.command" };
+  return {
+    ok: true,
+    outcome: "deactivated",
+    message: wasScaffolded ? "removed launch-kit statusline and scaffolded base line \u2014 back to no statusline" : "restored original statusLine.command"
+  };
 }
-var fs4, path4, import_node_os, LK_DIR, WRAPPER_PATH, CHIP_PATH, SETTINGS_PATH, ORIGINAL_KEY;
+var fs4, path4, import_node_os, LK_DIR, WRAPPER_PATH, CHIP_PATH, BASE_PATH, SETTINGS_PATH, ORIGINAL_KEY;
 var init_statusline_install = __esm({
   "src/server/statusline-install.ts"() {
     "use strict";
@@ -348,6 +360,7 @@ var init_statusline_install = __esm({
     LK_DIR = path4.join((0, import_node_os.homedir)(), ".launchsecure");
     WRAPPER_PATH = path4.join(LK_DIR, "statusline-wrapper.sh");
     CHIP_PATH = path4.join(LK_DIR, "statusline-mcp.sh");
+    BASE_PATH = path4.join(LK_DIR, "statusline-base.sh");
     SETTINGS_PATH = path4.join((0, import_node_os.homedir)(), ".claude", "settings.json");
     ORIGINAL_KEY = "_launchKitStatuslineOriginal";
   }
@@ -1621,6 +1634,7 @@ var ALL_STEP_IDS = [
   "migrate-safety",
   "ls-marketplace",
   "recall-hook",
+  "project-info",
   "statusline"
 ];
 var PRESETS = {
@@ -1628,6 +1642,7 @@ var PRESETS = {
   refresh: ["resolve", "clone", "install", "onboard", "recall"]
 };
 var LAUNCH_KIT_PKG = "@launchsecure/launch-kit";
+var LAUNCH_KIT_PKG_LATEST = `${LAUNCH_KIT_PKG}@latest`;
 var LAUNCH_KIT_TOOLS_GUIDE_STATIC_HEAD = `
 Wired in Claude Code (.mcp.json):
   launch-secure   \u2014 LS API: work items, comms, secrets, members, board
@@ -1698,6 +1713,7 @@ var KNOWN_BOOL_FLAGS = /* @__PURE__ */ new Set([
   "--no-migrate-safety",
   "--no-ls-marketplace",
   "--no-recall-hook",
+  "--no-project-info",
   "--refresh-scaffolds",
   "--quiet",
   "--force",
@@ -1731,6 +1747,7 @@ function parseArgs(argv) {
     noMigrateSafety: false,
     noLsMarketplace: false,
     noRecallHook: false,
+    noProjectInfo: false,
     refreshScaffolds: false,
     quiet: false,
     force: false,
@@ -1775,6 +1792,10 @@ function parseArgs(argv) {
       args.noRecallHook = true;
       continue;
     }
+    if (raw === "--no-project-info") {
+      args.noProjectInfo = true;
+      continue;
+    }
     if (raw === "--refresh-scaffolds") {
       args.refreshScaffolds = true;
       continue;
@@ -1909,6 +1930,8 @@ Options:
   --no-migrate-safety      Skip refreshing the migrate-safety scaffold.
   --no-ls-marketplace      Skip refreshing the launch-secure marketplace.
   --no-recall-hook         Skip refreshing the recall-hook scaffold.
+  --no-project-info        Skip wiring the gitignored CLAUDE.md-imported
+                           project-info snapshot (/kit:project-info refreshes it).
   --refresh-scaffolds      Force-overwrite migrate-safety files (default is to
                            preserve user edits). Use this to pull updates
                            published to @launchsecure/launch-kit.
@@ -1944,8 +1967,8 @@ Subcommands:
                         Env resolved from --env \u2192 $LS_ENV \u2192 server-side project default \u2192
                         single-env auto-pick. See \`launch-kit secrets --help\`.
   statusline activate   Wrap ~/.claude/settings.json's statusLine.command so MCP daemon
-                        chips (recall, chart, deck, council) get appended. Refuses to
-                        create one if none exists \u2014 additive only.
+                        chips (recall, chart, deck, council) get appended. If no
+                        statusline exists, scaffolds Claude Code's default base line first.
   statusline deactivate Restore the original statusLine.command and remove kit scripts.
 
 Usage:
@@ -2016,7 +2039,7 @@ Options:
 
 Step selection (one-command flow \u2014 compose over the preset):
   Steps: resolve, clone, cred, mcp, gitignore, install, onboard, recall,
-         migrate-safety, ls-marketplace, recall-hook, statusline
+         migrate-safety, ls-marketplace, recall-hook, project-info, statusline
   --preset=<name>          init (everything) or refresh (skips resolve/clone/
                            install/onboard/recall). Default: init. \`init\` and
                            \`refresh\` subcommands just select this.
@@ -2322,19 +2345,19 @@ function buildLaunchKitMcpEntries(cfg) {
     },
     "launch-chart": {
       command: "npx",
-      args: ["-y", "-p", LAUNCH_KIT_PKG, "launch-chart"]
+      args: ["-y", "-p", LAUNCH_KIT_PKG_LATEST, "launch-chart"]
     },
     "launch-deck": {
       command: "npx",
-      args: ["-y", "-p", LAUNCH_KIT_PKG, "launch-deck"]
+      args: ["-y", "-p", LAUNCH_KIT_PKG_LATEST, "launch-deck"]
     },
     "launch-orbit": {
       command: "npx",
-      args: ["-y", "-p", LAUNCH_KIT_PKG, "launch-orbit", "mcp"]
+      args: ["-y", "-p", LAUNCH_KIT_PKG_LATEST, "launch-orbit", "mcp"]
     },
     "launch-recall": {
       command: "npx",
-      args: ["-y", "-p", LAUNCH_KIT_PKG, "launch-recall", "mcp"]
+      args: ["-y", "-p", LAUNCH_KIT_PKG_LATEST, "launch-recall", "mcp"]
     }
   };
 }
@@ -2354,6 +2377,18 @@ function mergeMcpEntry(existing, ours) {
   }
   return merged;
 }
+function pinLaunchKitLatest(servers) {
+  const fixed = [];
+  for (const [name, entry] of Object.entries(servers)) {
+    if (entry.command !== "npx" || !Array.isArray(entry.args)) continue;
+    const i = entry.args.indexOf(LAUNCH_KIT_PKG);
+    if (i !== -1) {
+      entry.args[i] = LAUNCH_KIT_PKG_LATEST;
+      fixed.push(name);
+    }
+  }
+  return fixed;
+}
 function mergeMcpFile(targetDir, launchKitEntries) {
   const p = path5.join(targetDir, ".mcp.json");
   const hadExisting = fs5.existsSync(p);
@@ -2379,12 +2414,14 @@ function mergeMcpFile(targetDir, launchKitEntries) {
       merged.mcpServers[name] = entry;
     }
   }
+  const pinned = pinLaunchKitLatest(merged.mcpServers);
   if (DRY_RUN) {
     const action = hadExisting && existingServerCount > 0 ? "would merge into" : "would write";
-    dryNote(`${action} .mcp.json \u2014 overwriting [${overwrites.join(", ") || "none"}], adding [${additions.join(", ") || "none"}]`);
+    dryNote(`${action} .mcp.json \u2014 overwriting [${overwrites.join(", ") || "none"}], adding [${additions.join(", ") || "none"}], pinning @latest on [${pinned.join(", ") || "none"}]`);
     return { status: "skipped", summary: "(dry-run)" };
   }
   fs5.writeFileSync(p, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  if (pinned.length > 0) info(`pinned @latest on ${pinned.length} launch-kit MCP entr${pinned.length === 1 ? "y" : "ies"}: ${pinned.join(", ")}`);
   const verb = hadExisting && existingServerCount > 0 ? "merged" : "wrote";
   ok(`${verb === "merged" ? "merged into" : "wrote"} .mcp.json (${Object.keys(launchKitEntries).length} launch-kit entries)`);
   const total = Object.keys(launchKitEntries).length;
@@ -2470,14 +2507,14 @@ function runRecallInit(repoDir) {
   const recallEntry = path5.resolve(__dirname, "recall-entry.js");
   const useSibling = fs5.existsSync(recallEntry);
   const cmd = useSibling ? process.execPath : "npx";
-  const args = useSibling ? [recallEntry, "init"] : ["-y", "-p", LAUNCH_KIT_PKG, "launch-recall", "init"];
+  const args = useSibling ? [recallEntry, "init"] : ["-y", "-p", LAUNCH_KIT_PKG_LATEST, "launch-recall", "init"];
   if (DRY_RUN) {
     dryNote(`would run launch-recall init: ${cmd} ${args.join(" ")} (cwd: ${repoDir})`);
     return;
   }
   const res = (0, import_node_child_process3.spawnSync)(cmd, args, { cwd: repoDir, stdio: "inherit" });
   if (res.status !== 0) {
-    info(`\u26A0 launch-recall init failed (exit ${res.status}). Main onboarding is complete \u2014 you can retry later: cd ${path5.basename(repoDir)} && npx -y -p ${LAUNCH_KIT_PKG} launch-recall init`);
+    info(`\u26A0 launch-recall init failed (exit ${res.status}). Main onboarding is complete \u2014 you can retry later: cd ${path5.basename(repoDir)} && npx -y -p ${LAUNCH_KIT_PKG_LATEST} launch-recall init`);
     return;
   }
   ok(`launch-recall ready (shadow git initialized)`);
@@ -2768,7 +2805,7 @@ function wireRecallHook(targetDir) {
 }
 function tryActivateStatusline() {
   if (DRY_RUN) {
-    dryNote(`would wrap ~/.claude/settings.json statusLine.command with launch-kit's MCP chip wrapper (skips silently if no statusline configured)`);
+    dryNote(`would wrap ~/.claude/settings.json statusLine.command with launch-kit's MCP chip wrapper (scaffolds Claude Code's default base line first if none is configured)`);
     return { status: "skipped", summary: "(dry-run)" };
   }
   const res = activateStatusline();
@@ -2776,6 +2813,10 @@ function tryActivateStatusline() {
     ok(`statusline wrapped \u2014 MCP chips will render alongside your existing statusline next session`);
     return { status: "ok", summary: "wrapped \u2014 MCP chips render next session" };
   }
+  if (res.ok && res.outcome === "scaffolded") {
+    ok(`no statusline found \u2014 scaffolded Claude Code's default base line; MCP chips render alongside it next session`);
+    return { status: "ok", summary: "scaffolded default base line + chips" };
+  }
   if (res.ok && res.outcome === "refreshed") {
     info(`statusline already wrapped \u2014 refreshed chip scripts`);
     return { status: "ok", summary: "chip scripts refreshed" };
@@ -2834,8 +2875,8 @@ async function main2() {
     if (action === "activate") res = activateStatusline2({ show: showArg, compact: compactArg });
     else if (action === "deactivate") res = deactivateStatusline2();
     else fail3(`Unknown statusline action: "${action}". Supported: activate, deactivate.`);
-    if (res.ok) ok(`statusline ${res.outcome} \u2014 ${res.message}`);
-    else info(`statusline ${res.outcome} \u2014 ${res.message}`);
+    const mark = res.ok ? "\u2713" : "\u2717";
+    console.log(`[launch-kit] ${mark} statusline ${res.outcome} \u2014 ${res.message}`);
     return;
   }
   if (subcommand === "secrets") {
@@ -2913,6 +2954,7 @@ function resolveEnabledSteps(args) {
   if (args.noMigrateSafety) enabled.delete("migrate-safety");
   if (args.noLsMarketplace) enabled.delete("ls-marketplace");
   if (args.noRecallHook) enabled.delete("recall-hook");
+  if (args.noProjectInfo) enabled.delete("project-info");
   return enabled;
 }
 async function stepResolve(ctx) {
@@ -3142,6 +3184,90 @@ function stepStatusline(_ctx) {
   const slR = tryActivateStatusline();
   if (slR) phase("statusline", slR);
 }
+var PROJECT_INFO_REL = ".claude/launch-kit/project-info.md";
+function ensureClaudeMdImport(targetDir) {
+  const p = path5.join(targetDir, "CLAUDE.md");
+  const importLine = `@${PROJECT_INFO_REL}`;
+  const block = `<!-- launch-kit:project-info \u2014 generated import; safe to move, keep the line -->
+${importLine}
+<!-- /launch-kit:project-info -->
+`;
+  if (fs5.existsSync(p)) {
+    const content = fs5.readFileSync(p, "utf-8");
+    if (content.includes(importLine)) return "in-sync";
+    if (DRY_RUN) {
+      dryNote(`would add ${importLine} import to CLAUDE.md`);
+      return "added";
+    }
+    fs5.writeFileSync(p, content + (content.endsWith("\n") ? "" : "\n") + "\n" + block, "utf-8");
+    return "added";
+  }
+  if (DRY_RUN) {
+    dryNote(`would create CLAUDE.md with ${importLine} import`);
+    return "created";
+  }
+  fs5.writeFileSync(p, `# CLAUDE.md
+
+${block}`, "utf-8");
+  return "created";
+}
+function renderProjectInfoSkeleton(ctx) {
+  const cfg = ctx.cfg;
+  const projectName = ctx.resolved?.projectName ?? cfg.projectSlug;
+  const repo = ctx.resolved?.repositoryUrl ?? "\u2014";
+  const todo = "_Not populated yet \u2014 run `/kit:project-info` in Claude Code._";
+  return [
+    `# Project Info \u2014 ${projectName}`,
+    ``,
+    `<!-- launch-kit:generated \u2014 local, git-ignored snapshot. NOT a source of truth. -->`,
+    `> Wired by \`launch-kit\` init. This is a **local, git-ignored snapshot** of`,
+    `> project facts so Claude doesn't re-query them every session. Members,`,
+    `> providers, and environments are filled from LaunchSecure by the`,
+    `> \`/kit:project-info\` skill \u2014 run it to populate or refresh. Treat as a`,
+    `> cache: it can go stale, so re-run after team/provider/env changes.`,
+    ``,
+    `## Identity`,
+    `- **Org:** ${cfg.orgSlug}`,
+    `- **Project:** ${projectName} (\`${cfg.projectSlug}\`)`,
+    `- **Server:** ${cfg.serverUrl}`,
+    `- **Course:** ${ctx.courseName ?? "\u2014"}`,
+    `- **Repo:** ${repo}`,
+    ``,
+    `## Members`,
+    todo,
+    ``,
+    `## Providers / integrations`,
+    todo,
+    ``,
+    `## Environments`,
+    todo,
+    ``
+  ].join("\n");
+}
+function stepProjectInfo(ctx) {
+  if (!ctx.cfg) {
+    phase("project-info", { status: "skipped", summary: "no cred resolved" });
+    return;
+  }
+  ensureGitignoreLine(ctx.targetDir, PROJECT_INFO_REL);
+  const importResult = ensureClaudeMdImport(ctx.targetDir);
+  const dest = path5.join(ctx.targetDir, PROJECT_INFO_REL);
+  const existed = fs5.existsSync(dest);
+  if (!existed) {
+    if (DRY_RUN) {
+      dryNote(`would write ${PROJECT_INFO_REL} identity skeleton`);
+    } else {
+      fs5.mkdirSync(path5.dirname(dest), { recursive: true });
+      fs5.writeFileSync(dest, renderProjectInfoSkeleton(ctx), "utf-8");
+      ok(`wrote ${PROJECT_INFO_REL}`);
+    }
+  }
+  const summary = existed ? `kept file \xB7 CLAUDE.md ${importResult} \xB7 /kit:project-info to refresh` : `wrote skeleton \xB7 CLAUDE.md ${importResult} \xB7 /kit:project-info to populate`;
+  phase("project-info", {
+    status: existed && importResult === "in-sync" ? "in-sync" : "ok",
+    summary
+  });
+}
 var STEPS = [
   { id: "resolve", run: stepResolve },
   { id: "clone", requires: ["resolve"], run: stepClone },
@@ -3154,6 +3280,7 @@ var STEPS = [
   { id: "migrate-safety", run: stepMigrateSafety },
   { id: "ls-marketplace", run: stepLsMarketplace },
   { id: "recall-hook", run: stepRecallHook },
+  { id: "project-info", requires: ["cred"], run: stepProjectInfo },
   { id: "statusline", run: stepStatusline }
 ];
 function buildCtx(args, enabled) {

package/dist/server/orbit-entry.js

@@ -1385,7 +1385,7 @@ function rewriteEnvFile(filePath, rewrites) {
   const out = lines.map((line) => {
     const m = LINE_RE.exec(line);
     if (!m) return line;
-    const [, indent, key, sep, rawValue] = m;
+    const [, indent, key, sep2, rawValue] = m;
     if (!(key in rewrites)) return line;
     touched.add(key);
     const { quote, inner } = stripQuotes2(rawValue);
@@ -1396,7 +1396,7 @@ function rewriteEnvFile(filePath, rewrites) {
       return line;
     }
     result.changed.push(key);
-    return `${indent}${key}${sep}${quote}${next2}${quote}`;
+    return `${indent}${key}${sep2}${quote}${next2}${quote}`;
   });
   for (const key of Object.keys(rewrites)) {
     if (!touched.has(key)) result.missing.push(key);
@@ -3060,10 +3060,93 @@ var init_orbit_mcp = __esm({
 });
 
 // src/server/orbit-entry.ts
-var import_node_fs13 = require("node:fs");
-var import_node_path10 = require("node:path");
+var import_node_fs14 = require("node:fs");
+var import_node_path11 = require("node:path");
 init_orchestrator();
 init_logger();
+
+// src/server/prune-npx-cache.ts
+var import_node_fs13 = require("node:fs");
+var import_node_os5 = require("node:os");
+var import_node_path10 = require("node:path");
+var import_node_util = require("node:util");
+var PKG = "@launchsecure/launch-kit";
+var readFileAsync = (0, import_node_util.promisify)(import_node_fs13.readFile);
+var readdirAsync = (0, import_node_util.promisify)(import_node_fs13.readdir);
+var rmAsync = (0, import_node_util.promisify)(import_node_fs13.rm);
+var realpathAsync = (0, import_node_util.promisify)(import_node_fs13.realpath);
+function npxCacheRoot() {
+  const cache = process.env.npm_config_cache;
+  if (cache && cache.trim()) return (0, import_node_path10.join)(cache, "_npx");
+  if (process.platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA;
+    if (localAppData) return (0, import_node_path10.join)(localAppData, "npm-cache", "_npx");
+  }
+  return (0, import_node_path10.join)((0, import_node_os5.homedir)(), ".npm", "_npx");
+}
+function ownVersion() {
+  let dir = __dirname;
+  for (let i = 0; i < 8; i++) {
+    try {
+      const pkg = JSON.parse((0, import_node_fs13.readFileSync)((0, import_node_path10.join)(dir, "package.json"), "utf8"));
+      if (pkg && pkg.name === PKG) return typeof pkg.version === "string" ? pkg.version : null;
+    } catch {
+    }
+    const parent = (0, import_node_path10.dirname)(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+async function pruneStaleNpxCache() {
+  try {
+    const version = ownVersion();
+    if (!version) return;
+    const root = npxCacheRoot();
+    let hashes;
+    try {
+      hashes = await readdirAsync(root);
+    } catch {
+      return;
+    }
+    const selfPath = await realpathAsync(process.argv[1] || __dirname).catch(() => __dirname);
+    let reaped = 0;
+    for (const hash of hashes) {
+      const dir = (0, import_node_path10.join)(root, hash);
+      if (selfPath === dir || selfPath.startsWith(dir + import_node_path10.sep)) continue;
+      let ver;
+      try {
+        const lkPkg = JSON.parse(
+          await readFileAsync((0, import_node_path10.join)(dir, "node_modules", PKG, "package.json"), "utf8")
+        );
+        ver = lkPkg.version;
+      } catch {
+        continue;
+      }
+      if (ver === version) continue;
+      try {
+        const top = JSON.parse(await readFileAsync((0, import_node_path10.join)(dir, "package.json"), "utf8"));
+        const spec = top?.dependencies?.[PKG];
+        if (typeof spec === "string" && spec.startsWith("file:")) continue;
+      } catch {
+      }
+      try {
+        await rmAsync(dir, { recursive: true, force: true });
+        reaped++;
+      } catch {
+      }
+    }
+    if (reaped > 0) {
+      process.stderr.write(
+        `[launch-kit] npx-cache: reaped ${reaped} stale copy(ies), kept v${version}
+`
+      );
+    }
+  } catch {
+  }
+}
+
+// src/server/orbit-entry.ts
 function parseFlags(argv) {
   const positional = [];
   const flags = { emitCd: false, noBackup: false, skipGates: [], deep: false, all: false, json: false, force: false };
@@ -3099,6 +3182,7 @@ function parseFlags(argv) {
   return { positional, flags };
 }
 async function main() {
+  void pruneStaleNpxCache();
   const argv = process.argv.slice(2);
   const subcommand = argv[0];
   if (!subcommand || subcommand === "mcp") {
@@ -3328,8 +3412,8 @@ function formatRollup(reports) {
   return out.join("\n") + "\n";
 }
 function runInit(projectRoot) {
-  const path = (0, import_node_path10.join)(projectRoot, "orbit.json");
-  if ((0, import_node_fs13.existsSync)(path)) {
+  const path = (0, import_node_path11.join)(projectRoot, "orbit.json");
+  if ((0, import_node_fs14.existsSync)(path)) {
     process.stderr.write(`[launch-orbit] orbit.json already exists at ${path}
 `);
     process.exit(1);
@@ -3384,7 +3468,7 @@ function runInit(projectRoot) {
       full: { resources: ["db", "ports"] }
     }
   };
-  (0, import_node_fs13.writeFileSync)(path, JSON.stringify(starter, null, 2) + "\n", "utf-8");
+  (0, import_node_fs14.writeFileSync)(path, JSON.stringify(starter, null, 2) + "\n", "utf-8");
   process.stdout.write(`\u2713 wrote ${path}
 `);
 }