create-egregore 0.16.2 → 0.17.0

package/bin/cli.js

@@ -10,10 +10,13 @@
  *   npx create-egregore join <org>         (local mode — join existing)
  */
 
+const fs = require("node:fs");
+const path = require("node:path");
 const ui = require("../lib/ui");
 const { EgregoreAPI } = require("../lib/api");
 const { deviceFlow } = require("../lib/auth");
 const { install, ghApi } = require("../lib/setup");
+const { detectContext, isWritable, isSystemDir } = require("../lib/context");
 
 const API_URL = process.env.EGREGORE_API_URL || "https://egregore-production-55f2.up.railway.app";
 
@@ -29,6 +32,8 @@ function parseArgs(argv) {
       args.api = argv[++i];
     } else if (argv[i] === "--open") {
       args.open = true;
+    } else if (argv[i] === "--force") {
+      args.force = true;
     } else if (argv[i] === "--help" || argv[i] === "-h") {
       args.help = true;
     } else if (!argv[i].startsWith("-")) {
@@ -42,6 +47,104 @@ function parseArgs(argv) {
   return args;
 }
 
+/**
+ * If cwd is inside a git repo, show the "sibling shell" notice and offer a
+ * redirect. Returns { targetDir, prefilledRepo } — prefilledRepo is non-null
+ * only when we detected a repo. Caller passes both through to downstream flows.
+ *
+ * Bypassed entirely by --force.
+ */
+async function maybeRedirect(force) {
+  if (force) return { targetDir: process.cwd(), prefilledRepo: null };
+
+  const ctx = detectContext();
+  if (!ctx) return { targetDir: process.cwd(), prefilledRepo: null };
+
+  const { repoName, parentDir, originOwner, originName } = ctx;
+
+  // Non-TTY guard: we can't prompt. Fail loudly so CI/Docker/piped scripts
+  // don't hang forever on readline.
+  if (!process.stdin.isTTY) {
+    console.log("");
+    ui.error(`Detected a git repo at ./${repoName} but stdin is not a TTY — cannot prompt.`);
+    ui.info("Re-run from outside the repo, or pass --force to install here anyway.");
+    process.exit(1);
+  }
+
+  const parentWritable = isWritable(parentDir);
+  const parentIsSystem = isSystemDir(parentDir);
+
+  console.log("");
+  ui.warn(`You're inside a git repo: ${ui.bold(`./${repoName}`)}`);
+  console.log("");
+  ui.info("Egregore lives as a sibling shell that manages your repos,");
+  ui.info("not inside them. Your repo stays where it is.");
+
+  if (parentIsSystem) {
+    console.log("");
+    ui.warn(`The parent directory (${parentDir}) looks like a system or home root — not a good place for an Egregore workspace.`);
+  }
+
+  const choices = [];
+  // Offer the parent redirect only if it's writable AND not a system dir.
+  if (parentWritable && !parentIsSystem) {
+    choices.push({
+      label: `Install in ${parentDir}`,
+      description: `Set up alongside ${repoName} and add it to managed repos (Recommended)`,
+      action: "parent",
+    });
+  }
+  choices.push({
+    label: "Pick a different directory",
+    description: "Choose where to install Egregore",
+    action: "pick",
+  });
+  choices.push({
+    label: "Cancel",
+    description: "Exit without changes",
+    action: "cancel",
+  });
+
+  const choice = await ui.choose("How would you like to proceed?", choices);
+
+  if (choice.action === "cancel") {
+    console.log("");
+    ui.info("Cancelled. Run from a clean directory, or pass --force to override.");
+    process.exit(0);
+  }
+
+  let targetDir = parentDir;
+  if (choice.action === "pick") {
+    const answer = await ui.prompt("Install directory (absolute path):");
+    if (!answer) {
+      ui.error("No directory provided");
+      process.exit(1);
+    }
+    targetDir = path.resolve(answer);
+    if (isSystemDir(targetDir)) {
+      ui.error(`${targetDir} looks like a system directory — pick something under your home or projects folder.`);
+      process.exit(1);
+    }
+    try {
+      if (!fs.existsSync(targetDir)) fs.mkdirSync(targetDir, { recursive: true });
+      fs.accessSync(targetDir, fs.constants.W_OK);
+    } catch (err) {
+      ui.error(`Cannot write to ${targetDir}: ${err.message}`);
+      process.exit(1);
+    }
+  }
+
+  return {
+    targetDir,
+    prefilledRepo: {
+      name: originName || repoName,
+      owner: originOwner,
+      localName: repoName,
+      toplevel: ctx.toplevel,
+    },
+  };
+}
+
 function showHelp() {
   ui.banner();
   ui.info("Usage:");
@@ -51,9 +154,10 @@ function showHelp() {
   ui.info("  npx create-egregore --token <setup-token>    Install from website");
   ui.info("");
   ui.info("Options:");
-  ui.info("  --open           Local mode — no API server needed");
+  ui.info("  --open            Local mode — no API server needed");
   ui.info("  --token <token>   Setup token from egregore.xyz");
   ui.info("  --api <url>       API URL override");
+  ui.info("  --force           Skip the in-repo detection check");
   ui.info("  -h, --help        Show this help");
   ui.info("");
 }
@@ -68,10 +172,12 @@ async function main() {
 
   ui.banner();
 
+  const ctx = await maybeRedirect(args.force);
+
   if (args.token) {
-    // ===== Connected mode: token provided (unchanged) =====
+    // ===== Connected mode: token provided =====
     const api = new EgregoreAPI(args.api || API_URL);
-    await tokenFlow(api, args.token);
+    await tokenFlow(api, args.token, ctx);
   } else if (args.subcommand === "join") {
     // ===== Local mode: join existing =====
     if (!args.joinOrg) {
@@ -79,19 +185,19 @@ async function main() {
       process.exit(1);
     }
     const { localJoinFlow } = require("../lib/local");
-    await localJoinFlow(args.joinOrg, ui);
+    await localJoinFlow(args.joinOrg, ui, ctx);
   } else if (args.open) {
     // ===== Local mode: founder (explicit opt-in) =====
     const { localFounderFlow } = require("../lib/local");
-    await localFounderFlow(ui);
+    await localFounderFlow(ui, ctx);
   } else {
     // ===== Interactive API flow (default — existing behavior) =====
     const api = new EgregoreAPI(args.api || API_URL);
-    await interactiveFlow(api);
+    await interactiveFlow(api, ctx);
   }
 }
 
-async function tokenFlow(api, token) {
+async function tokenFlow(api, token, ctx) {
   const s = ui.spinner("Claiming setup token...");
   let data;
   try {
@@ -119,15 +225,30 @@ async function tokenFlow(api, token) {
     }
   }
 
+  // Token-mode setups already have their repo list baked in server-side. If
+  // the user's current working repo happens to match a managed-repo name, skip
+  // the clone/pull/configure step for it so we don't clobber uncommitted work.
+  const skipRepos = new Set();
+  if (ctx.prefilledRepo && Array.isArray(data.repos)) {
+    for (const r of data.repos) {
+      const n = typeof r === "string" ? r : r && r.name;
+      if (n && n === ctx.prefilledRepo.name) skipRepos.add(n);
+    }
+  }
   try {
-    await install(data, ui);
+    await install(data, ui, ctx.targetDir, { skipRepos });
+    if (ctx.prefilledRepo && skipRepos.size === 0) {
+      console.log("");
+      ui.info(`Tip: add your current repo to managed_repos with:`);
+      ui.info(`  /add ${ctx.prefilledRepo.toplevel || `../${ctx.prefilledRepo.localName}`}`);
+    }
   } catch (err) {
     ui.error(`Install failed: ${err.message}`);
     process.exit(1);
   }
 }
 
-async function interactiveFlow(api) {
+async function interactiveFlow(api, ctx) {
   // 1. GitHub auth
   ui.info("Let's set up Egregore. First, sign in with GitHub.\n");
   let githubToken;
@@ -227,13 +348,13 @@ async function interactiveFlow(api) {
   // 5. Execute
   console.log("");
   if (choice.action === "join") {
-    await joinFlow(api, githubToken, choice);
+    await joinFlow(api, githubToken, choice, ctx);
   } else {
-    await setupFlow(api, githubToken, choice);
+    await setupFlow(api, githubToken, choice, ctx);
   }
 }
 
-async function setupFlow(api, githubToken, choice) {
+async function setupFlow(api, githubToken, choice, ctx) {
   const orgName = await ui.prompt(`Organization display name [${choice.login}]:`);
   const name = orgName || choice.login;
 
@@ -241,19 +362,37 @@ async function setupFlow(api, githubToken, choice) {
   const instanceInput = await ui.prompt(`Instance name (e.g. "ops", "research") [leave blank for default]:`);
   const instanceName = instanceInput || undefined;
 
+  // If user was inside a repo owned by the chosen org, auto-adopt it.
+  const autoAdopt =
+    ctx.prefilledRepo &&
+    ctx.prefilledRepo.owner &&
+    ctx.prefilledRepo.owner.toLowerCase() === choice.login.toLowerCase()
+      ? ctx.prefilledRepo.name
+      : null;
+
   // Repo picker — show org repos for selection
   let selectedRepos = [];
   try {
     const repoData = await api.getOrgRepos(githubToken, choice.login);
     if (repoData.repos && repoData.repos.length > 0) {
+      const filtered = autoAdopt
+        ? repoData.repos.filter((r) => r.name !== autoAdopt)
+        : repoData.repos;
+      if (autoAdopt) {
+        console.log("");
+        ui.info(`${ui.cyan(autoAdopt)} will be managed automatically (your current repo)`);
+      }
       selectedRepos = await ui.multiSelect(
-        "Which repos should Egregore manage?",
-        repoData.repos,
+        "Which other repos should Egregore manage?",
+        filtered,
       );
     }
   } catch {
     // Non-fatal — continue without repos
   }
+  if (autoAdopt && !selectedRepos.includes(autoAdopt)) {
+    selectedRepos.unshift(autoAdopt);
+  }
 
   // Offer to create a new project repo
   console.log("");
@@ -306,7 +445,8 @@ async function setupFlow(api, githubToken, choice) {
 
     // Claim the token immediately
     const data = await api.claimToken(result.setup_token);
-    await install(data, ui);
+    const skipRepos = autoAdopt ? new Set([autoAdopt]) : new Set();
+    await install(data, ui, ctx.targetDir, { skipRepos });
 
     if (result.telegram_invite_link) {
       console.log("");
@@ -319,7 +459,7 @@ async function setupFlow(api, githubToken, choice) {
   }
 }
 
-async function joinFlow(api, githubToken, choice) {
+async function joinFlow(api, githubToken, choice, ctx) {
   const displayName = choice.repo_name ? `${choice.login} (${choice.repo_name})` : choice.login;
   const s = ui.spinner(`Joining ${ui.bold(displayName)}...`);
   try {
@@ -330,7 +470,14 @@ async function joinFlow(api, githubToken, choice) {
     s.stop("Joined");
 
     const data = await api.claimToken(result.setup_token);
-    await install(data, ui);
+    const skipRepos = new Set();
+    if (ctx.prefilledRepo && Array.isArray(data.repos)) {
+      for (const r of data.repos) {
+        const n = typeof r === "string" ? r : r && r.name;
+        if (n && n === ctx.prefilledRepo.name) skipRepos.add(n);
+      }
+    }
+    await install(data, ui, ctx.targetDir, { skipRepos });
   } catch (err) {
     s.fail("Join failed");
     ui.error(err.message);

package/lib/auth.js

@@ -7,6 +7,7 @@ const https = require("node:https");
 
 const GITHUB_APP_CLIENT_ID = "Iv23li2obNsAjakoK2RE";   // GitHub App — founder flow (clean install screen)
 const OAUTH_APP_CLIENT_ID = "Ov23liYZjJbbbNgnJ9vH";    // OAuth App — join flow (repo:invite only)
+const SUPPORT_URL = "https://github.com/egregore-labs/egregore";
 
 function post(url, body) {
   return new Promise((resolve, reject) => {
@@ -45,6 +46,26 @@ function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 
+/**
+ * POST with retry + exponential backoff. Handles transient network errors
+ * (ECONNREFUSED, ECONNRESET, ETIMEDOUT) by retrying up to `retries` times
+ * with a 1s / 2s / 4s backoff. Throws the last error if all retries fail.
+ */
+async function postWithRetry(url, body, retries = 3) {
+  let lastErr;
+  for (let attempt = 0; attempt < retries; attempt++) {
+    try {
+      return await post(url, body);
+    } catch (err) {
+      lastErr = err;
+      if (attempt < retries - 1) {
+        await sleep(1000 * Math.pow(2, attempt));
+      }
+    }
+  }
+  throw lastErr;
+}
+
 function openBrowser(url) {
   const { execFile } = require("node:child_process");
   if (process.platform === "darwin") {
@@ -81,14 +102,27 @@ async function deviceFlow(ui, opts = {}) {
   const clientId = isJoin ? OAUTH_APP_CLIENT_ID : GITHUB_APP_CLIENT_ID;
   const scope = isJoin ? "repo:invite" : "";
 
-  // 1. Request device code
-  const codeResp = await post("https://github.com/login/device/code", {
-    client_id: clientId,
-    scope,
-  });
+  // 1. Request device code (with retry — handles transient network hiccups
+  //    and GitHub edge server blips that caused ECONNREFUSED in the field)
+  let codeResp;
+  try {
+    codeResp = await postWithRetry("https://github.com/login/device/code", {
+      client_id: clientId,
+      scope,
+    });
+  } catch (err) {
+    throw new Error(
+      `Could not reach GitHub after 3 attempts: ${err.message}\n` +
+      `Check your internet connection and try again.\n` +
+      `If this keeps happening, report it at ${SUPPORT_URL}/issues`
+    );
+  }
 
   if (!codeResp.device_code) {
-    throw new Error("Failed to start GitHub device flow");
+    throw new Error(
+      `GitHub device flow did not return a code.\n` +
+      `This is unusual — please report at ${SUPPORT_URL}/issues`
+    );
   }
 
   const { device_code, user_code, verification_uri, interval: pollInterval } = codeResp;
@@ -109,19 +143,40 @@ async function deviceFlow(ui, opts = {}) {
   ui.info("");
   openBrowser(verifyUrl);
 
-  // 3. Poll for token
+  // 3. Poll for token. Transient network errors (one bad packet, WiFi blip,
+  //    GitHub edge restart) must NOT kill the whole flow — the user might
+  //    be mid-authorize on the browser side. Catch per-poll errors and
+  //    continue; the outer 5-minute timeout handles genuinely broken networks.
   let interval = (pollInterval || 5) * 1000;
   const timeout = 300000; // 5 minutes
   const start = Date.now();
+  let consecutiveNetworkErrors = 0;
+  let networkWarningShown = false;
 
   while (Date.now() - start < timeout) {
     await sleep(interval);
 
-    const tokenResp = await post("https://github.com/login/oauth/access_token", {
-      client_id: clientId,
-      device_code,
-      grant_type: "urn:ietf:params:oauth:grant-type:device_code",
-    });
+    let tokenResp;
+    try {
+      tokenResp = await post("https://github.com/login/oauth/access_token", {
+        client_id: clientId,
+        device_code,
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+      });
+      consecutiveNetworkErrors = 0;
+    } catch (err) {
+      consecutiveNetworkErrors++;
+      // After 3 consecutive failures, surface a note so the user knows
+      // something is off — but keep polling until the outer timeout.
+      if (consecutiveNetworkErrors >= 3 && !networkWarningShown) {
+        ui.warn(
+          `Network trouble reaching GitHub (${err.message}). Still trying.\n` +
+          `If this persists, report at ${SUPPORT_URL}/issues`
+        );
+        networkWarningShown = true;
+      }
+      continue;
+    }
 
     if (tokenResp.access_token) {
       return tokenResp.access_token;
@@ -135,10 +190,17 @@ async function deviceFlow(ui, opts = {}) {
       continue;
     }
 
-    throw new Error(tokenResp.error_description || tokenResp.error || "Auth failed");
+    throw new Error(
+      `${tokenResp.error_description || tokenResp.error || "Auth failed"}\n` +
+      `If you need help, see ${SUPPORT_URL}`
+    );
   }
 
-  throw new Error("Timed out waiting for authorization (5 minutes)");
+  throw new Error(
+    `Timed out waiting for authorization (5 minutes).\n` +
+    `If the browser tab didn't open, visit the verification URL manually and enter your code.\n` +
+    `If this keeps happening, report at ${SUPPORT_URL}/issues`
+  );
 }
 
 module.exports = { deviceFlow, openBrowser };

package/lib/context.js

@@ -0,0 +1,107 @@
+/**
+ * Detect whether cwd is inside a git work-tree.
+ *
+ * Egregore installs as a sibling shell alongside managed repos. If a user runs
+ * `npx create-egregore` from inside an existing git repo, we want to redirect
+ * them to the repo's parent directory and auto-adopt their repo as a managed
+ * repo. This module is the single source of truth for that detection.
+ */
+
+const { execFileSync } = require("node:child_process");
+const path = require("node:path");
+const fs = require("node:fs");
+
+function gitOut(args, cwd) {
+  try {
+    return execFileSync("git", args, {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf-8",
+      timeout: 5000,
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * @param {string} [cwd=process.cwd()]
+ * @returns {null | { toplevel: string, repoName: string, parentDir: string, originOwner: string|null, originName: string|null }}
+ */
+function detectContext(cwd = process.cwd()) {
+  let toplevel = gitOut(["rev-parse", "--show-toplevel"], cwd);
+  if (!toplevel) return null;
+
+  // Submodule → resolve to superproject
+  const sup = gitOut(["rev-parse", "--show-superproject-working-tree"], cwd);
+  if (sup) toplevel = sup;
+
+  // Worktree → resolve to main work-tree so parentDir isn't under .git/worktrees
+  const commonDir = gitOut(["rev-parse", "--git-common-dir"], toplevel);
+  if (commonDir) {
+    const absCommon = path.isAbsolute(commonDir) ? commonDir : path.resolve(toplevel, commonDir);
+    if (path.basename(absCommon) === ".git") {
+      const mainWorktree = path.dirname(absCommon);
+      if (mainWorktree && mainWorktree !== toplevel && fs.existsSync(mainWorktree)) {
+        toplevel = mainWorktree;
+      }
+    }
+  }
+
+  const repoName = path.basename(toplevel);
+  const parentDir = path.dirname(toplevel);
+
+  let originOwner = null;
+  let originName = null;
+  const origin = gitOut(["-C", toplevel, "remote", "get-url", "origin"]);
+  if (origin) {
+    const m = origin.match(/(?:github\.com[:/])([^/]+)\/([^/.]+?)(?:\.git)?$/);
+    if (m) {
+      originOwner = m[1];
+      originName = m[2];
+    }
+  }
+
+  return { toplevel, repoName, parentDir, originOwner, originName };
+}
+
+function isWritable(dir) {
+  try {
+    fs.accessSync(dir, fs.constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Return true if `dir` looks like a system or shared location where planting
+ * an egregore instance + memory repo + managed-repo clones would be disruptive
+ * or confusing. Detected: filesystem root, OS user roots, tmp/opt/usr/var,
+ * and the user's $HOME itself (which happens when someone runs `git init ~`
+ * for dotfile management).
+ */
+function isSystemDir(dir) {
+  if (!dir) return true;
+  const resolved = path.resolve(dir);
+  const blocklist = new Set([
+    "/",
+    "/Users",
+    "/home",
+    "/root",
+    "/tmp",
+    "/private/tmp",
+    "/opt",
+    "/usr",
+    "/usr/local",
+    "/var",
+    "/etc",
+    "/private/var",
+  ]);
+  if (blocklist.has(resolved)) return true;
+  const home = require("node:os").homedir();
+  if (home && path.resolve(home) === resolved) return true;
+  return false;
+}
+
+module.exports = { detectContext, isWritable, isSystemDir };

package/lib/local.js

@@ -250,7 +250,9 @@ const APP_INSTALL_URL = "https://github.com/apps/egregore-labs/installations/new
 
 // ── Flow 1: Founder (local mode) ───────────────────────────────────
 
-async function localFounderFlow(ui) {
+async function localFounderFlow(ui, ctx = {}) {
+  // Names of repos already on disk as the user's own workdir — skip clone/pull.
+  const skipRepos = ctx.skipRepos instanceof Set ? new Set(ctx.skipRepos) : new Set();
   // 1. Install GitHub App — user picks which repos/accounts to grant access to
   ui.info("Let's set up Egregore.\n");
   ui.info("First, install the Egregore app on your GitHub account.");
@@ -325,19 +327,36 @@ async function localFounderFlow(ui) {
     orgName = nameInput || githubOrg;
     description = "";
 
+    // Auto-adopt the user's current repo if it's under the chosen GitHub owner.
+    const autoAdopt =
+      ctx.prefilledRepo &&
+      ctx.prefilledRepo.owner &&
+      ctx.prefilledRepo.owner.toLowerCase() === githubOrg.toLowerCase()
+        ? ctx.prefilledRepo.name
+        : null;
+
     // Multi-select repos to manage
     const s0 = ui.spinner("Loading repos...");
     try {
       const repos = await listOrgRepos(githubToken, githubOrg, isOrg);
       s0.stop("Loaded repos");
       if (repos.length > 0) {
-        selectedRepos = await ui.multiSelect("Which repos should Egregore manage?", repos);
+        const filtered = autoAdopt ? repos.filter((r) => r.name !== autoAdopt) : repos;
+        if (autoAdopt) {
+          console.log("");
+          ui.info(`${ui.cyan(autoAdopt)} will be managed automatically (your current repo)`);
+        }
+        selectedRepos = await ui.multiSelect("Which other repos should Egregore manage?", filtered);
       } else {
         ui.info("No repos found yet.");
       }
     } catch {
       s0.stop("Could not load repos");
     }
+    if (autoAdopt && !selectedRepos.includes(autoAdopt)) {
+      selectedRepos.unshift(autoAdopt);
+    }
+    if (autoAdopt) skipRepos.add(autoAdopt);
 
     // Detect default branch for each selected repo and convert to {name, base_branch} format
     if (selectedRepos.length > 0) {
@@ -503,7 +522,7 @@ async function localFounderFlow(ui) {
   }
 
   // 10. Clone locally
-  const base = process.cwd();
+  const base = ctx.targetDir || process.cwd();
   const egregoreDir = path.join(base, repoName);
   const memoryDir = path.join(base, memoryRepoName);
   const forkUrl = `https://github.com/${githubOrg}/${repoName}.git`;
@@ -574,11 +593,16 @@ async function localFounderFlow(ui) {
     } catch {}
   }
 
-  // 16. Clone managed repos
+  // 16. Clone managed repos — skipRepos contains the user's current working
+  // repo if auto-adopted, so we don't pull/reconfigure their live workdir.
   for (let i = 0; i < selectedRepos.length; i++) {
     const entry = selectedRepos[i];
     const mrName = typeof entry === "string" ? entry : entry.name;
     ui.step(5 + i, totalSteps, `Cloning ${mrName}...`);
+    if (skipRepos.has(mrName)) {
+      ui.success(`Using existing ${mrName}/ (your current repo)`);
+      continue;
+    }
     const repoDir = path.join(base, mrName);
     try {
       const repoUrl = `https://github.com/${githubOrg}/${mrName}.git`;
@@ -659,7 +683,7 @@ async function localFounderFlow(ui) {
 
 // ── Flow 2: Join (local mode) ──────────────────────────────────────
 
-async function localJoinFlow(orgArg, ui) {
+async function localJoinFlow(orgArg, ui, ctx = {}) {
   // Parse org/repo if provided (e.g., "acme-org/ops-team")
   let orgLogin, explicitRepo;
   if (orgArg.includes("/")) {
@@ -698,7 +722,7 @@ async function localJoinFlow(orgArg, ui) {
 
   // 5. Clone repos using git credentials (SSH keys / gh CLI / credential helper)
   //    The OAuth token only has repo:invite scope — cloning uses the joiner's own git setup.
-  const base = process.cwd();
+  const base = ctx.targetDir || process.cwd();
   const egregoreDir = path.join(base, repoName);
 
   console.log("");

package/lib/setup.js

@@ -101,11 +101,16 @@ async function acceptPendingInvitations(githubToken, githubOrg, ui) {
  *
  * @param {object} data - from /api/org/claim/{token}
  * @param {object} ui - UI module for output
- * @param {string} targetDir - where to install (default: cwd)
+ * @param {string} [targetDir] - where to install (default: cwd)
+ * @param {object} [opts] - optional { skipRepos: Set<string> } — names of managed
+ *   repos that already exist on disk as the user's own working repo. Skipped
+ *   entirely (no clone, no pull, no config writes, no develop-branch push) to
+ *   avoid clobbering uncommitted work or pushing branches to their origin.
  */
-async function install(data, ui, targetDir) {
+async function install(data, ui, targetDir, opts = {}) {
   const { fork_url, memory_url, github_token, org_name, github_org, slug, api_key, repos = [], telegram_group_link, github_username, github_name, transcript_sharing } = data;
   const base = targetDir || process.cwd();
+  const skipRepos = opts.skipRepos instanceof Set ? opts.skipRepos : new Set();
 
   // Directory name from fork URL (what git clone would use), e.g. "egregore-core"
   const forkDirName = fork_url.split("/").pop().replace(/\.git$/, "");
@@ -233,6 +238,12 @@ async function install(data, ui, targetDir) {
     const repoName = typeof repoEntry === 'string' ? repoEntry : repoEntry.name;
     ui.step(6 + i, totalSteps, `Cloning ${repoName}...`);
     const repoDir = path.join(base, repoName);
+    // Auto-adopted from user's current working repo — already on disk, don't touch it.
+    if (skipRepos.has(repoName)) {
+      ui.success(`Using existing ${repoName}/ (your current repo)`);
+      clonedRepos.push(repoName);
+      continue;
+    }
     try {
       if (fs.existsSync(repoDir)) {
         ui.warn(`${repoName}/ already exists — pulling latest`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-egregore",
-  "version": "0.16.2",
+  "version": "0.17.0",
   "description": "Set up Egregore for your team in one command",
   "license": "MIT",
   "bin": {