repowise 0.1.82 → 0.1.83

package/dist/bin/repowise.js

@@ -3,63 +3,100 @@
 // bin/repowise.ts
 import { readFileSync as readFileSync2 } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { dirname as dirname6, join as join16 } from "path";
+import { dirname as dirname9, join as join22 } from "path";
 import { Command } from "commander";
 
 // ../listener/dist/main.js
-import { readFile as readFile4, writeFile as writeFile5, unlink, mkdir as mkdir5 } from "fs/promises";
-import { homedir as homedir4 } from "os";
-import { join as join6 } from "path";
+import { readFile as readFile5, writeFile as writeFile7, mkdir as mkdir7 } from "fs/promises";
+import { join as join12, dirname as dirname4 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import lockfile2 from "proper-lockfile";
 
-// ../listener/dist/lib/config.js
-import { readFile, writeFile, rename, mkdir, chmod } from "fs/promises";
+// ../../packages/shared/src/config-dir.ts
 import { homedir } from "os";
 import { join } from "path";
-var CONFIG_DIR = join(homedir(), ".repowise");
-var CONFIG_PATH = join(CONFIG_DIR, "config.json");
-var DEFAULT_API_URL = "https://api.repowise.ai";
-var rawConfigCache = null;
+function getConfigDir() {
+  const isStaging = true ? false : false;
+  return join(homedir(), isStaging ? ".repowise-staging" : ".repowise");
+}
+
+// ../listener/dist/lib/config.js
+import { readFile, writeFile, rename, unlink, mkdir, chmod } from "fs/promises";
+import { join as join2 } from "path";
+import lockfile from "proper-lockfile";
+var DEFAULT_API_URL = false ? "https://staging-api.repowise.ai" : "https://api.repowise.ai";
 async function getListenerConfig() {
+  const configDir = getConfigDir();
+  const configPath = join2(configDir, "config.json");
   const apiUrl = process.env["REPOWISE_API_URL"] ?? DEFAULT_API_URL;
   try {
-    const data = await readFile(CONFIG_PATH, "utf-8");
+    const data = await readFile(configPath, "utf-8");
     const raw = JSON.parse(data);
-    rawConfigCache = raw;
     const validRepos = (raw.repos ?? []).filter((r) => typeof r === "object" && r !== null && typeof r.repoId === "string" && typeof r.localPath === "string");
     return {
       defaultApiUrl: raw.apiUrl ?? apiUrl,
-      repos: validRepos
+      repos: validRepos,
+      autoDiscoverRepos: raw.autoDiscoverRepos ?? false,
+      noAutoUpdate: raw.noAutoUpdate ?? false
     };
   } catch {
-    return { defaultApiUrl: apiUrl, repos: [] };
+    return { defaultApiUrl: apiUrl, repos: [], autoDiscoverRepos: false, noAutoUpdate: false };
   }
 }
 async function saveListenerConfig(config2) {
-  await mkdir(CONFIG_DIR, { recursive: true, mode: 448 });
-  const output = {
-    ...rawConfigCache ?? {},
-    apiUrl: config2.defaultApiUrl,
-    repos: config2.repos
-  };
-  const tmpPath = CONFIG_PATH + ".tmp";
-  await writeFile(tmpPath, JSON.stringify(output, null, 2));
-  await chmod(tmpPath, 384);
-  await rename(tmpPath, CONFIG_PATH);
-  rawConfigCache = output;
+  const configDir = getConfigDir();
+  const configPath = join2(configDir, "config.json");
+  await mkdir(configDir, { recursive: true, mode: 448 });
+  try {
+    await writeFile(configPath, "", { flag: "a" });
+  } catch {
+  }
+  let release = null;
+  try {
+    release = await lockfile.lock(configPath, { stale: 1e4, retries: 3, realpath: false });
+    let raw = {};
+    try {
+      const data = await readFile(configPath, "utf-8");
+      raw = JSON.parse(data);
+    } catch {
+    }
+    const output = {
+      ...raw,
+      apiUrl: config2.defaultApiUrl,
+      repos: config2.repos
+    };
+    const tmpPath = configPath + ".tmp";
+    try {
+      await writeFile(tmpPath, JSON.stringify(output, null, 2));
+      await chmod(tmpPath, 384);
+      await rename(tmpPath, configPath);
+    } catch (err) {
+      try {
+        await unlink(tmpPath);
+      } catch {
+      }
+      throw err;
+    }
+  } finally {
+    if (release) {
+      try {
+        await release();
+      } catch {
+      }
+    }
+  }
 }
 
 // ../listener/dist/lib/state.js
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, chmod as chmod2 } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
-var CONFIG_DIR2 = join2(homedir2(), ".repowise");
-var STATE_PATH = join2(CONFIG_DIR2, "listener-state.json");
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, chmod as chmod2, rename as rename2, unlink as unlink2 } from "fs/promises";
+import { join as join3 } from "path";
 function emptyState() {
   return { repos: {} };
 }
 async function loadState() {
+  const statePath = join3(getConfigDir(), "listener-state.json");
   try {
-    const data = await readFile2(STATE_PATH, "utf-8");
+    const data = await readFile2(statePath, "utf-8");
     return JSON.parse(data);
   } catch (err) {
     if (err.code === "ENOENT" || err instanceof SyntaxError) {
@@ -69,19 +106,34 @@ async function loadState() {
   }
 }
 async function saveState(state) {
-  await mkdir2(CONFIG_DIR2, { recursive: true, mode: 448 });
-  await writeFile2(STATE_PATH, JSON.stringify(state, null, 2));
-  await chmod2(STATE_PATH, 384);
+  const configDir = getConfigDir();
+  const statePath = join3(configDir, "listener-state.json");
+  await mkdir2(configDir, { recursive: true, mode: 448 });
+  const tmpPath = statePath + ".tmp";
+  try {
+    await writeFile2(tmpPath, JSON.stringify(state, null, 2));
+    await chmod2(tmpPath, 384);
+    await rename2(tmpPath, statePath);
+  } catch (err) {
+    try {
+      await unlink2(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
 }
 
 // ../listener/dist/lib/reconcile.js
-import { basename, dirname } from "path";
-function reconcileRepos(configRepos, activeRepos, state, apiUrl) {
+import { statSync, readdirSync } from "fs";
+import { basename, dirname, join as join4 } from "path";
+function reconcileRepos(configRepos, activeRepos, state, apiUrl, options) {
   if (activeRepos.length === 0) {
-    return { updated: false, repos: configRepos, changes: [] };
+    return { updated: false, repos: configRepos, changes: [], addedRepos: [] };
   }
   const changes = [];
   let updated = false;
+  const addedRepos = [];
+  const usedPaths = new Set(configRepos.map((r) => r.localPath));
   const updatedRepos = configRepos.map((repo) => {
     if (repo.apiUrl && repo.apiUrl !== apiUrl) {
       return repo;
@@ -151,19 +203,78 @@ function reconcileRepos(configRepos, activeRepos, state, apiUrl) {
     }
     return repo;
   });
-  return { updated, repos: updatedRepos, changes };
+  if (options?.autoDiscover) {
+    const configuredRepoIds = new Set(updatedRepos.map((r) => r.repoId));
+    const unmatchedActiveRepos = activeRepos.filter((ar) => !configuredRepoIds.has(ar.repoId));
+    if (unmatchedActiveRepos.length > 0) {
+      const parentDirs = /* @__PURE__ */ new Set();
+      for (const repo of updatedRepos) {
+        parentDirs.add(dirname(repo.localPath));
+      }
+      for (const activeRepo of unmatchedActiveRepos) {
+        const found = findLocalRepo(activeRepo, parentDirs, usedPaths);
+        if (found) {
+          const newRepo = {
+            repoId: activeRepo.repoId,
+            localPath: found,
+            apiUrl,
+            platform: activeRepo.platform,
+            externalId: activeRepo.externalId
+          };
+          updatedRepos.push(newRepo);
+          addedRepos.push(newRepo);
+          usedPaths.add(found);
+          configuredRepoIds.add(activeRepo.repoId);
+          const twentyFourHoursAgo = new Date(Date.now() - 24 * 60 * 60 * 1e3).toISOString();
+          state.repos[activeRepo.repoId] = {
+            ...state.repos[activeRepo.repoId],
+            lastSyncTimestamp: twentyFourHoursAgo,
+            lastSyncCommitSha: null
+          };
+          changes.push(`[self-heal] Auto-added ${activeRepo.fullName} from ${found}`);
+          updated = true;
+        }
+      }
+    }
+  }
+  return { updated, repos: updatedRepos, changes, addedRepos };
+}
+function findLocalRepo(activeRepo, parentDirs, usedPaths) {
+  const nameParts = activeRepo.fullName.split("/");
+  const repoName = nameParts[nameParts.length - 1];
+  for (const parentDir of parentDirs) {
+    const candidate = join4(parentDir, repoName);
+    if (!usedPaths.has(candidate) && hasContextFolder(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function hasContextFolder(dirPath) {
+  try {
+    const contextPath = join4(dirPath, "repowise-context");
+    const s = statSync(contextPath);
+    if (!s.isDirectory())
+      return false;
+    const entries = readdirSync(contextPath);
+    return entries.length > 0;
+  } catch {
+    return false;
+  }
 }
 function migrateState(state, oldId, newId) {
   const oldState = state.repos[oldId];
   if (oldState) {
     const twentyFourHoursAgo = new Date(Date.now() - 24 * 60 * 60 * 1e3).toISOString();
     state.repos[newId] = {
+      ...state.repos[newId],
       lastSyncTimestamp: twentyFourHoursAgo,
       lastSyncCommitSha: null
     };
     delete state.repos[oldId];
   } else {
     state.repos[newId] = {
+      ...state.repos[newId],
       lastSyncTimestamp: new Date(Date.now() - 24 * 60 * 60 * 1e3).toISOString(),
       lastSyncCommitSha: null
     };
@@ -172,10 +283,7 @@ function migrateState(state, oldId, newId) {
 
 // ../listener/dist/lib/auth.js
 import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3, chmod as chmod3 } from "fs/promises";
-import { homedir as homedir3 } from "os";
-import { join as join3 } from "path";
-var CONFIG_DIR3 = join3(homedir3(), ".repowise");
-var CREDENTIALS_PATH = join3(CONFIG_DIR3, "credentials.json");
+import { join as join5 } from "path";
 function getTokenUrl(creds) {
   const cognito = creds?.cognito;
   const domain = process.env["REPOWISE_COGNITO_DOMAIN"] ?? cognito?.domain ?? "auth-repowise-dev";
@@ -214,7 +322,8 @@ async function refreshTokens(refreshToken, creds) {
 }
 async function getStoredCredentials() {
   try {
-    const data = await readFile3(CREDENTIALS_PATH, "utf-8");
+    const credPath = join5(getConfigDir(), "credentials.json");
+    const data = await readFile3(credPath, "utf-8");
     return JSON.parse(data);
   } catch (err) {
     if (err.code === "ENOENT" || err instanceof SyntaxError) {
@@ -224,9 +333,11 @@ async function getStoredCredentials() {
   }
 }
 async function storeCredentials(credentials) {
-  await mkdir3(CONFIG_DIR3, { recursive: true, mode: 448 });
-  await writeFile3(CREDENTIALS_PATH, JSON.stringify(credentials, null, 2));
-  await chmod3(CREDENTIALS_PATH, 384);
+  const dir = getConfigDir();
+  const credPath = join5(dir, "credentials.json");
+  await mkdir3(dir, { recursive: true, mode: 448 });
+  await writeFile3(credPath, JSON.stringify(credentials, null, 2));
+  await chmod3(credPath, 384);
 }
 async function getValidCredentials(options) {
   const creds = await getStoredCredentials();
@@ -377,15 +488,15 @@ function notifyContextUpdated(repoId, fileCount) {
 // ../listener/dist/context-fetcher.js
 import { execFile } from "child_process";
 import { mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname2, join as join5 } from "path";
+import { dirname as dirname2, join as join7 } from "path";
 import { promisify } from "util";
 
 // ../listener/dist/file-writer.js
 import { access } from "fs/promises";
-import { join as join4 } from "path";
+import { join as join6 } from "path";
 async function verifyContextFolder(localPath) {
   try {
-    await access(join4(localPath, "repowise-context"));
+    await access(join6(localPath, "repowise-context"));
     return true;
   } catch {
     return false;
@@ -473,7 +584,7 @@ async function fetchContextFromServer(repoId, localPath, apiUrl) {
     if (files.length === 0) {
       return { success: true, updatedFiles: [] };
     }
-    const contextDir = join5(localPath, "repowise-context");
+    const contextDir = join7(localPath, "repowise-context");
     await mkdir4(contextDir, { recursive: true });
     const updatedFiles = [];
     for (const file of files) {
@@ -498,7 +609,7 @@ async function fetchContextFromServer(repoId, localPath, apiUrl) {
         continue;
       }
       const content = await contentRes.text();
-      const filePath = join5(contextDir, file.fileName);
+      const filePath = join7(contextDir, file.fileName);
       await mkdir4(dirname2(filePath), { recursive: true });
       await writeFile4(filePath, content, "utf-8");
       updatedFiles.push(file.fileName);
@@ -512,175 +623,819 @@ async function fetchContextFromServer(repoId, localPath, apiUrl) {
   }
 }
 
-// ../listener/dist/main.js
-var TWENTY_FOUR_HOURS_MS = 24 * 60 * 60 * 1e3;
-var PID_PATH = join6(homedir4(), ".repowise", "listener.pid");
-var running = false;
-var sleepResolve = null;
-async function writePidFile() {
-  await mkdir5(join6(homedir4(), ".repowise"), { recursive: true });
-  await writeFile5(PID_PATH, String(process.pid));
+// ../listener/dist/process-manager.js
+import { spawn } from "child_process";
+import { openSync, closeSync } from "fs";
+import { readFile as readFile4, writeFile as writeFile5, mkdir as mkdir5, unlink as unlink3 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join8 } from "path";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+function repowiseDir() {
+  return getConfigDir();
 }
-async function removePidFile() {
+function pidPath() {
+  return join8(repowiseDir(), "listener.pid");
+}
+function logDirPath() {
+  return join8(repowiseDir(), "logs");
+}
+function resolveListenerCommand() {
   try {
-    await unlink(PID_PATH);
+    const require2 = createRequire(import.meta.url);
+    const mainPath = require2.resolve("@repowise/listener/main");
+    return { script: mainPath, args: [] };
   } catch {
+    const bundlePath = fileURLToPath(import.meta.url);
+    return { script: bundlePath, args: ["__listener"] };
   }
 }
-async function handleStalePid() {
+async function readPid() {
   try {
-    const content = await readFile4(PID_PATH, "utf-8");
+    const content = await readFile4(pidPath(), "utf-8");
     const pid = parseInt(content.trim(), 10);
-    if (!Number.isNaN(pid) && pid !== process.pid) {
-      try {
-        process.kill(pid, 0);
-        console.error(`Listener already running (PID: ${pid}). Stop it first with \`repowise stop\`.`);
-        process.exitCode = 1;
-        return true;
-      } catch {
-      }
-    }
-  } catch {
+    return Number.isNaN(pid) ? null : pid;
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return null;
+    throw err;
   }
-  return false;
 }
-function stop() {
-  running = false;
-  if (sleepResolve) {
-    sleepResolve();
-    sleepResolve = null;
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
   }
 }
-function sleep(ms) {
-  return new Promise((resolve) => {
-    sleepResolve = resolve;
-    setTimeout(() => {
-      sleepResolve = null;
-      resolve();
-    }, ms);
+async function startBackground() {
+  if (await isRunning()) {
+    const pid2 = await readPid();
+    if (pid2)
+      return pid2;
+  }
+  const logDir2 = logDirPath();
+  await mkdir5(logDir2, { recursive: true });
+  const cmd = resolveListenerCommand();
+  const stdoutFd = openSync(join8(logDir2, "listener-stdout.log"), "a");
+  const stderrFd = openSync(join8(logDir2, "listener-stderr.log"), "a");
+  const child = spawn(process.execPath, [cmd.script, ...cmd.args], {
+    detached: true,
+    stdio: ["ignore", stdoutFd, stderrFd],
+    cwd: homedir2(),
+    env: { ...process.env }
   });
+  child.unref();
+  closeSync(stdoutFd);
+  closeSync(stderrFd);
+  const pid = child.pid;
+  if (!pid)
+    throw new Error("Failed to spawn listener process");
+  await writeFile5(pidPath(), String(pid));
+  return pid;
 }
-function decodeEmailFromIdToken(idToken) {
+async function stopProcess() {
+  const pid = await readPid();
+  if (pid === null)
+    return;
+  if (!isAlive(pid)) {
+    await removePidFile();
+    return;
+  }
   try {
-    const payload = JSON.parse(Buffer.from(idToken.split(".")[1], "base64url").toString());
-    return typeof payload.email === "string" ? payload.email : null;
+    process.kill(pid, "SIGTERM");
   } catch {
-    return null;
   }
-}
-async function processNotifications(notifications, state, repoLocalPaths, apiUrl) {
-  let updateCount = 0;
-  for (const notif of notifications) {
-    const repoState = state.repos[notif.repoId];
-    if (repoState && notif.createdAt <= repoState.lastSyncTimestamp) {
-      continue;
-    }
-    if (notif.type === "sync.completed") {
-      const localPath = repoLocalPaths.get(notif.repoId);
-      if (localPath) {
-        let result;
-        if (apiUrl) {
-          result = await fetchContextFromServer(notif.repoId, localPath, apiUrl);
-        } else {
-          result = await fetchContextUpdates(localPath);
-        }
-        if (result.success) {
-          updateCount++;
-          notifyContextUpdated(notif.repoId, result.updatedFiles.length);
-          state.repos[notif.repoId] = {
-            lastSyncTimestamp: notif.createdAt,
-            lastSyncCommitSha: notif.commitSha
-          };
-        } else {
-          console.error(`Download failed for repo ${notif.repoId} \u2014 will retry on next poll`);
-        }
-      } else {
-        state.repos[notif.repoId] = {
-          lastSyncTimestamp: notif.createdAt,
-          lastSyncCommitSha: notif.commitSha
-        };
-      }
-    } else {
-      state.repos[notif.repoId] = {
-        lastSyncTimestamp: notif.createdAt,
-        lastSyncCommitSha: notif.commitSha
-      };
+  const deadline = Date.now() + 5e3;
+  while (Date.now() < deadline && isAlive(pid)) {
+    await new Promise((r) => setTimeout(r, 200));
+  }
+  if (isAlive(pid)) {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
     }
   }
-  return updateCount;
+  await removePidFile();
 }
-async function handleCatchUp(offlineState, pollClient, repoIds, state, repoLocalPaths, apiUrl) {
-  if (!offlineState.offlineSince)
-    return;
-  const offlineDuration = Date.now() - new Date(offlineState.offlineSince).getTime();
-  if (offlineDuration >= TWENTY_FOUR_HOURS_MS) {
-    let syncCount = 0;
-    for (const [repoId, localPath] of repoLocalPaths) {
-      let result;
-      if (apiUrl) {
-        result = await fetchContextFromServer(repoId, localPath, apiUrl);
-      } else {
-        result = await fetchContextUpdates(localPath);
-      }
-      if (result.success)
-        syncCount++;
-    }
-    notifyBackOnline(syncCount);
-  } else {
-    const sinceTimestamp = offlineState.offlineSince;
-    const response = await pollClient.poll(repoIds, sinceTimestamp);
-    const updateCount = await processNotifications(response.notifications, state, repoLocalPaths, apiUrl);
-    await saveState(state);
-    notifyBackOnline(updateCount);
+async function isRunning() {
+  const pid = await readPid();
+  if (pid === null)
+    return false;
+  return isAlive(pid);
+}
+async function removePidFile() {
+  try {
+    await unlink3(pidPath());
+  } catch {
   }
 }
-async function startListener(options) {
-  running = true;
-  if (!options?.skipPidCheck) {
-    const alreadyRunning = await handleStalePid();
-    if (alreadyRunning)
-      return;
+
+// ../listener/dist/lib/auto-updater.js
+import { execFile as execFile2 } from "child_process";
+import { access as access2, constants, realpath } from "fs/promises";
+import { dirname as dirname3, join as join9 } from "path";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
+async function installUpdate(currentVersion, packageName, targetVersion) {
+  if (process.env["CI"] === "true")
+    return { updated: false };
+  if (!/^\d+\.\d+\.\d+/.test(targetVersion))
+    return { updated: false };
+  if (!isNewer(targetVersion, currentVersion)) {
+    console.log(`[auto-update] ${targetVersion} is not newer than ${currentVersion} \u2014 skipping`);
+    return { updated: false };
+  }
+  const npmWrapper = join9(dirname3(process.execPath), "npm");
+  const npmScript = await realpath(npmWrapper);
+  const runNpm = (args) => execFileAsync2(process.execPath, [npmScript, ...args], { timeout: 6e4 });
+  try {
+    const { stdout: prefix } = await runNpm(["prefix", "-g"]);
+    const npmDir = join9(prefix.trim(), "lib", "node_modules");
+    const checkDir = process.platform === "win32" ? prefix.trim() : npmDir;
+    await access2(checkDir, constants.W_OK);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.log(`[auto-update] npm global prefix not writable \u2014 skipping update (${msg})`);
+    return { updated: false };
   }
-  await writePidFile();
-  const config2 = await getListenerConfig();
-  if (config2.repos.length === 0) {
-    console.error("No repos configured. Add repos to ~/.repowise/config.json");
-    process.exitCode = 1;
-    return;
+  console.log(`[auto-update] Updating ${packageName} from ${currentVersion} to ${targetVersion}...`);
+  try {
+    await runNpm(["install", "-g", "--ignore-scripts", `${packageName}@${targetVersion}`]);
+    console.log(`[auto-update] Successfully updated to ${targetVersion}`);
+    return { updated: true, latestVersion: targetVersion };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[auto-update] Installation failed: ${msg}`);
+    return { updated: false, error: msg };
   }
-  const credentials = await getValidCredentials();
-  if (!credentials) {
-    console.error("Not logged in. Run `repowise login` first.");
-    process.exitCode = 1;
-    return;
+}
+function isNewer(a, b) {
+  const parseVer = (v) => {
+    const [main, pre] = v.split("-", 2);
+    const parts = main.split(".").map(Number);
+    return { parts, pre: pre ?? "" };
+  };
+  const va = parseVer(a);
+  const vb = parseVer(b);
+  for (let i = 0; i < Math.max(va.parts.length, vb.parts.length); i++) {
+    const na = va.parts[i] ?? 0;
+    const nb = vb.parts[i] ?? 0;
+    if (na > nb)
+      return true;
+    if (na < nb)
+      return false;
   }
-  const state = await loadState();
-  const groupMap = /* @__PURE__ */ new Map();
-  for (const repo of config2.repos) {
-    const apiUrl = repo.apiUrl ?? config2.defaultApiUrl;
-    let group = groupMap.get(apiUrl);
-    if (!group) {
-      group = {
-        apiUrl,
-        pollClient: new PollClient(apiUrl),
-        backoff: new BackoffCalculator(),
-        repoIds: [],
-        repoLocalPaths: /* @__PURE__ */ new Map(),
-        offline: { isOffline: false, offlineSince: null, attemptCount: 0, nextRetryAt: 0 }
-      };
-      groupMap.set(apiUrl, group);
+  if (vb.pre && !va.pre)
+    return true;
+  if (va.pre && vb.pre)
+    return comparePrerelease(va.pre, vb.pre) > 0;
+  return false;
+}
+function comparePrerelease(a, b) {
+  const aParts = a.split(".");
+  const bParts = b.split(".");
+  for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+    const ap = aParts[i];
+    const bp = bParts[i];
+    if (ap === void 0)
+      return -1;
+    if (bp === void 0)
+      return 1;
+    const aNum = /^\d+$/.test(ap) ? parseInt(ap, 10) : NaN;
+    const bNum = /^\d+$/.test(bp) ? parseInt(bp, 10) : NaN;
+    if (!isNaN(aNum) && !isNaN(bNum)) {
+      if (aNum > bNum)
+        return 1;
+      if (aNum < bNum)
+        return -1;
+    } else {
+      if (ap > bp)
+        return 1;
+      if (ap < bp)
+        return -1;
     }
-    group.repoIds.push(repo.repoId);
-    group.repoLocalPaths.set(repo.repoId, repo.localPath);
   }
-  const groups = Array.from(groupMap.values());
-  const allRepoIds = config2.repos.map((r) => r.repoId);
+  return 0;
+}
+
+// ../listener/dist/lifecycle.js
+import { unlink as unlink5 } from "fs/promises";
+import { join as join11 } from "path";
+
+// ../listener/dist/service-installer.js
+import { execFile as execFile3 } from "child_process";
+import { writeFile as writeFile6, mkdir as mkdir6, unlink as unlink4 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { join as join10 } from "path";
+var IS_STAGING = true ? false : false;
+function exec(cmd, args) {
+  return new Promise((resolve, reject) => {
+    execFile3(cmd, args, (err, stdout) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve(String(stdout ?? ""));
+    });
+  });
+}
+var PLIST_LABEL = IS_STAGING ? "com.repowise-staging.listener" : "com.repowise.listener";
+function plistPath() {
+  return join10(homedir3(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+}
+function logDir() {
+  return join10(getConfigDir(), "logs");
+}
+function buildPlist() {
+  const cmd = resolveListenerCommand();
+  const logs = logDir();
+  const programArgs = [process.execPath, cmd.script, ...cmd.args].map((a) => `        <string>${a}</string>`).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${PLIST_LABEL}</string>
+    <key>ProgramArguments</key>
+    <array>
+${programArgs}
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>StandardOutPath</key>
+    <string>${join10(logs, "listener-stdout.log")}</string>
+    <key>StandardErrorPath</key>
+    <string>${join10(logs, "listener-stderr.log")}</string>
+    <key>ProcessType</key>
+    <string>Background</string>
+</dict>
+</plist>`;
+}
+async function darwinInstall() {
+  await mkdir6(logDir(), { recursive: true });
+  await mkdir6(join10(homedir3(), "Library", "LaunchAgents"), { recursive: true });
+  try {
+    await exec("launchctl", ["unload", plistPath()]);
+  } catch {
+  }
+  await writeFile6(plistPath(), buildPlist());
+  await exec("launchctl", ["load", plistPath()]);
+}
+async function darwinUninstall() {
+  try {
+    await exec("launchctl", ["unload", plistPath()]);
+  } catch {
+  }
+  try {
+    await unlink4(plistPath());
+  } catch {
+  }
+}
+async function darwinIsInstalled() {
+  try {
+    const stdout = await exec("launchctl", ["list"]);
+    return stdout.includes(PLIST_LABEL);
+  } catch {
+    return false;
+  }
+}
+var SYSTEMD_SERVICE = IS_STAGING ? "repowise-staging-listener" : "repowise-listener";
+function unitPath() {
+  return join10(homedir3(), ".config", "systemd", "user", `${SYSTEMD_SERVICE}.service`);
+}
+function buildUnit() {
+  const cmd = resolveListenerCommand();
+  const execStart = [process.execPath, cmd.script, ...cmd.args].join(" ");
+  const logs = logDir();
+  return `[Unit]
+Description=RepoWise Listener
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${execStart}
+Restart=always
+RestartSec=10
+StandardOutput=append:${join10(logs, "listener-stdout.log")}
+StandardError=append:${join10(logs, "listener-stderr.log")}
+
+[Install]
+WantedBy=default.target`;
+}
+async function linuxInstall() {
+  await mkdir6(logDir(), { recursive: true });
+  await mkdir6(join10(homedir3(), ".config", "systemd", "user"), { recursive: true });
+  await writeFile6(unitPath(), buildUnit());
+  await exec("systemctl", ["--user", "daemon-reload"]);
+  await exec("systemctl", ["--user", "enable", SYSTEMD_SERVICE]);
+  await exec("systemctl", ["--user", "start", SYSTEMD_SERVICE]);
+}
+async function linuxUninstall() {
+  try {
+    await exec("systemctl", ["--user", "stop", SYSTEMD_SERVICE]);
+  } catch {
+  }
+  try {
+    await exec("systemctl", ["--user", "disable", SYSTEMD_SERVICE]);
+  } catch {
+  }
+  try {
+    await unlink4(unitPath());
+  } catch {
+  }
+  try {
+    await exec("systemctl", ["--user", "daemon-reload"]);
+  } catch {
+  }
+}
+async function linuxIsInstalled() {
+  try {
+    const stdout = await exec("systemctl", ["--user", "is-enabled", SYSTEMD_SERVICE]);
+    return stdout.trim() === "enabled";
+  } catch {
+    return false;
+  }
+}
+var TASK_NAME = IS_STAGING ? "RepoWise Staging Listener" : "RepoWise Listener";
+async function win32Install() {
+  await mkdir6(logDir(), { recursive: true });
+  const cmd = resolveListenerCommand();
+  const taskCmd = [process.execPath, cmd.script, ...cmd.args].map((a) => `"${a}"`).join(" ");
+  await exec("schtasks", [
+    "/create",
+    "/tn",
+    TASK_NAME,
+    "/tr",
+    taskCmd,
+    "/sc",
+    "onlogon",
+    "/ru",
+    process.env.USERNAME ?? "",
+    "/f"
+  ]);
+  await exec("schtasks", ["/run", "/tn", TASK_NAME]);
+}
+async function win32Uninstall() {
+  try {
+    await exec("schtasks", ["/end", "/tn", TASK_NAME]);
+  } catch {
+  }
+  try {
+    await exec("schtasks", ["/delete", "/tn", TASK_NAME, "/f"]);
+  } catch {
+  }
+}
+async function win32IsInstalled() {
+  try {
+    await exec("schtasks", ["/query", "/tn", TASK_NAME]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function darwinStop() {
+  try {
+    await exec("launchctl", ["unload", plistPath()]);
+  } catch {
+  }
+}
+async function linuxStop() {
+  await exec("systemctl", ["--user", "stop", SYSTEMD_SERVICE]);
+}
+async function win32Stop() {
+  await exec("schtasks", ["/end", "/tn", TASK_NAME]);
+}
+async function darwinIsServiceRunning() {
+  try {
+    const stdout = await exec("launchctl", ["list", PLIST_LABEL]);
+    const pidMatch = stdout.match(/"PID"\s*=\s*(\d+)/);
+    return pidMatch !== null && parseInt(pidMatch[1], 10) > 0;
+  } catch {
+    return false;
+  }
+}
+async function linuxIsServiceRunning() {
+  try {
+    const stdout = await exec("systemctl", ["--user", "is-active", SYSTEMD_SERVICE]);
+    return stdout.trim() === "active";
+  } catch {
+    return false;
+  }
+}
+async function win32IsServiceRunning() {
+  try {
+    const stdout = await exec("schtasks", ["/query", "/tn", TASK_NAME, "/fo", "CSV"]);
+    return stdout.includes("Running");
+  } catch {
+    return false;
+  }
+}
+async function stopService() {
+  switch (process.platform) {
+    case "darwin":
+      await darwinStop();
+      break;
+    case "linux":
+      await linuxStop();
+      break;
+    case "win32":
+      await win32Stop();
+      break;
+    default:
+      throw new Error(`Unsupported platform: ${process.platform}`);
+  }
+}
+async function install() {
+  switch (process.platform) {
+    case "darwin":
+      await darwinInstall();
+      break;
+    case "linux":
+      await linuxInstall();
+      break;
+    case "win32":
+      await win32Install();
+      break;
+    default:
+      throw new Error(`Unsupported platform: ${process.platform}`);
+  }
+}
+async function uninstall() {
+  switch (process.platform) {
+    case "darwin":
+      await darwinUninstall();
+      break;
+    case "linux":
+      await linuxUninstall();
+      break;
+    case "win32":
+      await win32Uninstall();
+      break;
+    default:
+      throw new Error(`Unsupported platform: ${process.platform}`);
+  }
+}
+async function isInstalled() {
+  switch (process.platform) {
+    case "darwin":
+      return darwinIsInstalled();
+    case "linux":
+      return linuxIsInstalled();
+    case "win32":
+      return win32IsInstalled();
+    default:
+      return false;
+  }
+}
+async function isServiceRunning() {
+  switch (process.platform) {
+    case "darwin":
+      return darwinIsServiceRunning();
+    case "linux":
+      return linuxIsServiceRunning();
+    case "win32":
+      return win32IsServiceRunning();
+    default:
+      return false;
+  }
+}
+
+// ../listener/dist/lifecycle.js
+async function getListenerStatus() {
+  const pid = await readPid();
+  if (pid !== null) {
+    if (isAlive(pid)) {
+      const serviceInstalled2 = await isInstalled();
+      return { running: true, method: "pid", pid, serviceInstalled: serviceInstalled2 };
+    }
+    try {
+      await unlink5(join11(getConfigDir(), "listener.pid"));
+    } catch {
+    }
+  }
+  try {
+    if (await isServiceRunning()) {
+      return { running: true, method: "service", serviceInstalled: true };
+    }
+  } catch {
+  }
+  const serviceInstalled = await isInstalled();
+  return { running: false, method: "none", serviceInstalled };
+}
+async function ensureListenerRunning() {
+  const currentStatus = await getListenerStatus();
+  if (currentStatus.running)
+    return currentStatus;
+  try {
+    await install();
+    await new Promise((r) => setTimeout(r, 2e3));
+    const postInstall = await getListenerStatus();
+    if (postInstall.running)
+      return postInstall;
+  } catch {
+  }
+  const pid = await startBackground();
+  await new Promise((r) => setTimeout(r, 1e3));
+  if (!isAlive(pid)) {
+    return { running: false, method: "none", serviceInstalled: await isInstalled() };
+  }
+  return { running: true, method: "pid", pid, serviceInstalled: await isInstalled() };
+}
+async function stopListener() {
+  try {
+    await stopProcess();
+  } catch {
+  }
+  try {
+    await stopService();
+  } catch {
+  }
+}
+
+// ../listener/dist/main.js
+var TWENTY_FOUR_HOURS_MS = 24 * 60 * 60 * 1e3;
+var STALE_CHECK_COOLDOWN_MS = 60 * 60 * 1e3;
+var CRASH_LOOP_WINDOW_MS = 3e4;
+var CRASH_LOOP_THRESHOLD = 3;
+var running = false;
+var sleepResolve = null;
+var releaseLock = null;
+function stop() {
+  running = false;
+  if (sleepResolve) {
+    sleepResolve();
+    sleepResolve = null;
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    sleepResolve = resolve;
+    setTimeout(() => {
+      sleepResolve = null;
+      resolve();
+    }, ms);
+  });
+}
+function decodeEmailFromIdToken(idToken) {
+  try {
+    const payload = JSON.parse(Buffer.from(idToken.split(".")[1], "base64url").toString());
+    return typeof payload.email === "string" ? payload.email : null;
+  } catch {
+    return null;
+  }
+}
+async function processNotifications(notifications, state, repoLocalPaths, apiUrl) {
+  let updateCount = 0;
+  for (const notif of notifications) {
+    const repoState = state.repos[notif.repoId];
+    if (repoState && notif.createdAt <= repoState.lastSyncTimestamp) {
+      continue;
+    }
+    if (notif.type === "sync.completed") {
+      if (!notif.commitSha) {
+        console.warn(`sync.completed for ${notif.repoId} has no commitSha`);
+      }
+      const localPath = repoLocalPaths.get(notif.repoId);
+      if (localPath) {
+        let result;
+        if (apiUrl) {
+          result = await fetchContextFromServer(notif.repoId, localPath, apiUrl);
+        } else {
+          result = await fetchContextUpdates(localPath);
+        }
+        if (result.success) {
+          updateCount++;
+          notifyContextUpdated(notif.repoId, result.updatedFiles.length);
+          state.repos[notif.repoId] = {
+            ...state.repos[notif.repoId],
+            lastSyncTimestamp: notif.createdAt,
+            lastSyncCommitSha: notif.commitSha
+          };
+        } else {
+          console.error(`Download failed for repo ${notif.repoId} \u2014 will retry on next poll`);
+        }
+      } else {
+        state.repos[notif.repoId] = {
+          ...state.repos[notif.repoId],
+          lastSyncTimestamp: notif.createdAt,
+          lastSyncCommitSha: notif.commitSha
+        };
+      }
+    } else {
+      state.repos[notif.repoId] = {
+        ...state.repos[notif.repoId],
+        lastSyncTimestamp: notif.createdAt,
+        lastSyncCommitSha: notif.commitSha
+      };
+    }
+  }
+  return updateCount;
+}
+async function handleCatchUp(offlineState, pollClient, repoIds, state, repoLocalPaths, apiUrl) {
+  if (!offlineState.offlineSince)
+    return;
+  const offlineDuration = Date.now() - new Date(offlineState.offlineSince).getTime();
+  if (offlineDuration >= TWENTY_FOUR_HOURS_MS) {
+    let syncCount = 0;
+    for (const [repoId, localPath] of repoLocalPaths) {
+      let result;
+      if (apiUrl) {
+        result = await fetchContextFromServer(repoId, localPath, apiUrl);
+      } else {
+        result = await fetchContextUpdates(localPath);
+      }
+      if (result.success) {
+        syncCount++;
+        state.repos[repoId] = {
+          ...state.repos[repoId],
+          lastSyncTimestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          lastSyncCommitSha: null
+          // unknown from catch-up, but timestamp prevents re-download
+        };
+      }
+    }
+    await saveState(state);
+    notifyBackOnline(syncCount);
+  } else {
+    const sinceTimestamp = offlineState.offlineSince;
+    const response = await pollClient.poll(repoIds, sinceTimestamp);
+    const updateCount = await processNotifications(response.notifications, state, repoLocalPaths, apiUrl);
+    await saveState(state);
+    notifyBackOnline(updateCount);
+  }
+}
+async function checkStaleContext(repos, state, groups) {
+  const now = Date.now();
+  let dirty = false;
+  for (const repo of repos) {
+    const repoState = state.repos[repo.repoId];
+    if (!repoState)
+      continue;
+    if (repoState.lastContextCheckAt) {
+      const lastCheck = new Date(repoState.lastContextCheckAt).getTime();
+      if (now - lastCheck < STALE_CHECK_COOLDOWN_MS)
+        continue;
+    }
+    const apiUrl = repo.apiUrl;
+    const group = groups.find((g) => g.apiUrl === apiUrl);
+    if (group?.offline.isOffline)
+      continue;
+    const { statSync: statSync2, readdirSync: readdirSync2 } = await import("fs");
+    const contextPath = join12(repo.localPath, "repowise-context");
+    let isMissingOrEmpty = false;
+    try {
+      const s = statSync2(contextPath);
+      if (!s.isDirectory()) {
+        isMissingOrEmpty = true;
+      } else {
+        const entries = readdirSync2(contextPath);
+        isMissingOrEmpty = entries.length === 0;
+      }
+    } catch {
+      isMissingOrEmpty = true;
+    }
+    state.repos[repo.repoId] = {
+      ...state.repos[repo.repoId],
+      lastContextCheckAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    dirty = true;
+    if (isMissingOrEmpty && apiUrl) {
+      console.log(`[self-heal] Context missing/empty for ${repo.repoId}, re-downloading...`);
+      const result = await fetchContextFromServer(repo.repoId, repo.localPath, apiUrl);
+      if (result.success && result.updatedFiles.length > 0) {
+        console.log(`[self-heal] Re-downloaded ${result.updatedFiles.length} files for ${repo.repoId}`);
+        notifyContextUpdated(repo.repoId, result.updatedFiles.length);
+      }
+    }
+  }
+  return dirty;
+}
+async function startListener() {
+  running = true;
+  const configDir = getConfigDir();
+  await mkdir7(configDir, { recursive: true });
+  const lockPath = join12(configDir, "listener.lock");
+  await writeFile7(lockPath, "", { flag: "a" });
+  let lockIsHeld = false;
+  try {
+    lockIsHeld = await lockfile2.check(lockPath, { stale: 3e4, realpath: false });
+  } catch {
+  }
+  if (!lockIsHeld) {
+    const existingPid = await readPid();
+    if (existingPid && existingPid !== process.pid && isAlive(existingPid)) {
+      try {
+        process.kill(existingPid, "SIGTERM");
+        await new Promise((r) => setTimeout(r, 1e3));
+      } catch {
+      }
+    }
+  }
+  try {
+    releaseLock = await lockfile2.lock(lockPath, { stale: 3e4, realpath: false });
+  } catch {
+    console.error(`Listener already running. Stop it first with \`${true ? "repowise" : "repowise"} stop\`.`);
+    process.exitCode = 1;
+    return;
+  }
+  const releaseLockAndExit = async () => {
+    if (releaseLock) {
+      try {
+        await releaseLock();
+      } catch {
+      }
+      releaseLock = null;
+    }
+  };
+  let config2;
+  try {
+    config2 = await getListenerConfig();
+  } catch (err) {
+    console.error("Failed to load config:", err);
+    await releaseLockAndExit();
+    process.exitCode = 1;
+    return;
+  }
+  if (config2.repos.length === 0 && !config2.autoDiscoverRepos) {
+    console.error(`No repos configured. Add repos to ${join12(configDir, "config.json")}`);
+    await releaseLockAndExit();
+    process.exitCode = 1;
+    return;
+  }
+  const credentials = await getValidCredentials();
+  if (!credentials) {
+    console.error("Not logged in. Run `repowise login` first.");
+    await releaseLockAndExit();
+    process.exitCode = 1;
+    return;
+  }
+  let state;
+  try {
+    state = await loadState();
+  } catch (err) {
+    console.error("Failed to load state:", err);
+    await releaseLockAndExit();
+    process.exitCode = 1;
+    return;
+  }
+  const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+  const nowMs = Date.now();
+  if (state.lastBootAt) {
+    const lastBootMs = new Date(state.lastBootAt).getTime();
+    if (nowMs - lastBootMs < CRASH_LOOP_WINDOW_MS) {
+      state.crashCount = (state.crashCount ?? 0) + 1;
+    } else {
+      state.crashCount = 0;
+    }
+  }
+  state.lastBootAt = nowIso;
+  const crashLoopDetected = (state.crashCount ?? 0) >= CRASH_LOOP_THRESHOLD;
+  if (crashLoopDetected) {
+    console.warn(`[self-heal] Crash-loop detected (${state.crashCount} rapid restarts). Auto-update disabled until stable.`);
+  }
+  const groupMap = /* @__PURE__ */ new Map();
+  for (const repo of config2.repos) {
+    const apiUrl = repo.apiUrl ?? config2.defaultApiUrl;
+    let group = groupMap.get(apiUrl);
+    if (!group) {
+      group = {
+        apiUrl,
+        pollClient: new PollClient(apiUrl),
+        backoff: new BackoffCalculator(),
+        repoIds: [],
+        repoLocalPaths: /* @__PURE__ */ new Map(),
+        offline: { isOffline: false, offlineSince: null, attemptCount: 0, nextRetryAt: 0 }
+      };
+      groupMap.set(apiUrl, group);
+    }
+    group.repoIds.push(repo.repoId);
+    group.repoLocalPaths.set(repo.repoId, repo.localPath);
+  }
+  const groups = Array.from(groupMap.values());
+  const allRepoIds = config2.repos.map((r) => r.repoId);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   for (const repoId of allRepoIds) {
     if (!state.repos[repoId]) {
       state.repos[repoId] = { lastSyncTimestamp: now, lastSyncCommitSha: null };
     }
   }
+  await saveState(state);
+  const packageName = true ? "repowise" : "repowise";
+  let currentVersion = "";
+  try {
+    const selfDir = dirname4(fileURLToPath2(import.meta.url));
+    const pkgJsonPath = join12(selfDir, "..", "..", "package.json");
+    const pkgJson = JSON.parse(await readFile5(pkgJsonPath, "utf-8"));
+    currentVersion = pkgJson.version;
+  } catch (err) {
+    console.log(`[auto-update] Version detection failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
   let pollIntervalMs = 5e3;
   let pollCycleCount = 0;
   const RECONCILE_EVERY_N_CYCLES = 60;
@@ -700,10 +1455,24 @@ async function startListener(options) {
     console.log("Shutting down...");
     stop();
     await saveState(state);
-    await removePidFile();
+    if (releaseLock) {
+      try {
+        await releaseLock();
+      } catch {
+      }
+      releaseLock = null;
+    }
   };
-  process.on("SIGTERM", () => void shutdown());
-  process.on("SIGINT", () => void shutdown());
+  process.on("SIGTERM", () => {
+    shutdown().catch((err) => {
+      console.error("Shutdown error:", err);
+    }).finally(() => process.exit(0));
+  });
+  process.on("SIGINT", () => {
+    shutdown().catch((err) => {
+      console.error("Shutdown error:", err);
+    }).finally(() => process.exit(0));
+  });
   while (running) {
     let anyAuthError = null;
     let authErrorGroup = null;
@@ -711,6 +1480,7 @@ async function startListener(options) {
     let connectionLostNotified = false;
     pollCycleCount++;
     const shouldReconcile = pollCycleCount % RECONCILE_EVERY_N_CYCLES === 0;
+    let latestCliVersion;
     for (const group of groups) {
       if (!running)
         break;
@@ -725,9 +1495,14 @@ async function startListener(options) {
         const response = await group.pollClient.poll(group.repoIds, sinceTimestamp, {
           includeActiveRepos: shouldReconcile
         });
+        if (response.latestCliVersion) {
+          latestCliVersion = response.latestCliVersion;
+        }
         if (response.activeRepos && response.activeRepos.length > 0) {
           try {
-            const result = reconcileRepos(config2.repos, response.activeRepos, state, group.apiUrl);
+            const result = reconcileRepos(config2.repos, response.activeRepos, state, group.apiUrl, {
+              autoDiscover: config2.autoDiscoverRepos
+            });
             if (result.updated) {
               config2.repos = result.repos;
               await saveListenerConfig(config2);
@@ -742,6 +1517,19 @@ async function startListener(options) {
               for (const change of result.changes) {
                 console.log(`[reconcile] ${change}`);
               }
+              if (result.addedRepos.length > 0) {
+                for (const addedRepo of result.addedRepos) {
+                  const apiUrl = addedRepo.apiUrl ?? config2.defaultApiUrl;
+                  try {
+                    const fetchResult = await fetchContextFromServer(addedRepo.repoId, addedRepo.localPath, apiUrl);
+                    if (fetchResult.success) {
+                      console.log(`[self-heal] Downloaded ${fetchResult.updatedFiles.length} context files for ${addedRepo.repoId}`);
+                    }
+                  } catch (fetchErr) {
+                    console.warn(`[self-heal] Context download failed for ${addedRepo.repoId}:`, fetchErr instanceof Error ? fetchErr.message : String(fetchErr));
+                  }
+                }
+              }
             }
           } catch (reconcileErr) {
             console.warn("Repo reconciliation failed \u2014 will retry next cycle", reconcileErr instanceof Error ? reconcileErr.message : String(reconcileErr));
@@ -783,6 +1571,49 @@ async function startListener(options) {
         console.error(`Poll failed for ${group.apiUrl} (attempt ${group.offline.attemptCount}): ${message}. Retrying in ${Math.round(delay2 / 1e3)}s`);
       }
     }
+    if (shouldReconcile) {
+      try {
+        const staleDirty = await checkStaleContext(config2.repos, state, groups);
+        if (staleDirty) {
+          await saveState(state);
+        }
+      } catch (err) {
+        console.warn("[self-heal] Stale context check failed:", err instanceof Error ? err.message : String(err));
+      }
+    }
+    if (latestCliVersion && currentVersion && !config2.noAutoUpdate && (state.crashCount ?? 0) < CRASH_LOOP_THRESHOLD) {
+      if (latestCliVersion !== state.lastUpdateTargetVersion) {
+        state.updateFailCount = 0;
+        state.lastUpdateAttemptAt = void 0;
+        state.lastUpdateTargetVersion = latestCliVersion;
+      }
+      const backoffMs = Math.min(5 * 60 * 1e3 * Math.pow(2, state.updateFailCount ?? 0), 60 * 60 * 1e3);
+      const lastAttempt = state.lastUpdateAttemptAt ? new Date(state.lastUpdateAttemptAt).getTime() : 0;
+      if (Date.now() - lastAttempt >= backoffMs) {
+        const listenerStatus = await getListenerStatus();
+        state.lastUpdateAttemptAt = (/* @__PURE__ */ new Date()).toISOString();
+        const updateResult = await installUpdate(currentVersion, packageName, latestCliVersion);
+        if (updateResult.updated) {
+          state.updateFailCount = 0;
+          await saveState(state);
+          if (listenerStatus.serviceInstalled) {
+            console.log("[auto-update] Restarting with new version...");
+            await shutdown();
+            process.exit(0);
+          } else {
+            console.log("[auto-update] Spawning new listener with updated version...");
+            await shutdown();
+            await startBackground();
+            process.exit(0);
+          }
+        } else if (updateResult.error) {
+          state.updateFailCount = (state.updateFailCount ?? 0) + 1;
+          await saveState(state);
+        } else {
+          await saveState(state);
+        }
+      }
+    }
     if (anyAuthError) {
       let recovered = false;
       for (let attempt = 1; attempt <= 3; attempt++) {
@@ -812,8 +1643,19 @@ async function startListener(options) {
         } catch {
         }
       }
+      const credentialsPath = join12(getConfigDir(), "credentials.json");
+      let credentialsChanged = false;
+      let watcher = null;
+      try {
+        const fs = await import("fs");
+        watcher = fs.watch(credentialsPath, () => {
+          credentialsChanged = true;
+        });
+      } catch {
+      }
       while (running) {
-        await sleep(5 * 60 * 1e3);
+        await sleep(credentialsChanged ? 0 : 1e4);
+        credentialsChanged = false;
         if (!running)
           break;
         const fresh = await getValidCredentials({ forceRefresh: true });
@@ -822,452 +1664,170 @@ async function startListener(options) {
           break;
         }
       }
+      if (watcher)
+        watcher.close();
       continue;
-    }
-    pollIntervalMs = minPollInterval;
-    await sleep(pollIntervalMs);
-  }
-  await removePidFile();
-}
-var isDirectRun = process.argv[1]?.endsWith("main.js") || process.argv[1]?.endsWith("main.ts");
-if (isDirectRun) {
-  startListener().catch((err) => {
-    console.error("Listener fatal error:", err);
-    process.exitCode = 1;
-  });
-}
-
-// src/lib/env.ts
-var staging = false;
-function setStagingMode(value) {
-  staging = value;
-}
-function isStagingMode() {
-  return staging;
-}
-var PRODUCTION = {
-  apiUrl: "https://api.repowise.ai",
-  cognitoDomain: "auth.repowise.ai",
-  cognitoClientId: "50so1fkmjbqt1ufnsmbhsjbtst",
-  cognitoRegion: "us-east-1",
-  customDomain: true
-};
-var STAGING = {
-  apiUrl: "https://staging-api.repowise.ai",
-  cognitoDomain: "auth-staging.repowise.ai",
-  cognitoClientId: "7h0l0dhjcb1v5erer0gaclv0q6",
-  cognitoRegion: "us-east-1",
-  customDomain: true
-};
-function getEnvConfig() {
-  return staging ? STAGING : PRODUCTION;
-}
-
-// src/lib/welcome.ts
-import chalk from "chalk";
-
-// src/lib/config.ts
-import { readFile as readFile5, writeFile as writeFile6, mkdir as mkdir6 } from "fs/promises";
-import { homedir as homedir5 } from "os";
-import { join as join7 } from "path";
-var CONFIG_DIR4 = join7(homedir5(), ".repowise");
-var CONFIG_PATH2 = join7(CONFIG_DIR4, "config.json");
-async function getConfig() {
-  try {
-    const data = await readFile5(CONFIG_PATH2, "utf-8");
-    return JSON.parse(data);
-  } catch {
-    return {};
-  }
-}
-async function saveConfig(config2) {
-  await mkdir6(CONFIG_DIR4, { recursive: true });
-  await writeFile6(CONFIG_PATH2, JSON.stringify(config2, null, 2));
-}
-
-// src/lib/welcome.ts
-var W = 41;
-function row(styled, visible) {
-  return chalk.cyan("  \u2502") + styled + " ".repeat(W - visible) + chalk.cyan("\u2502");
-}
-async function showWelcome(currentVersion) {
-  try {
-    const config2 = await getConfig();
-    if (config2.lastSeenVersion === currentVersion) return;
-    const isUpgrade = !!config2.lastSeenVersion;
-    const tag = isUpgrade ? "updated" : "installed";
-    const titleText = `RepoWise v${currentVersion}`;
-    const titleStyled = "   " + chalk.bold(titleText) + chalk.green(` \u2713 ${tag}`);
-    const titleVisible = 3 + titleText.length + 3 + tag.length;
-    const border = "\u2500".repeat(W);
-    console.log("");
-    console.log(chalk.cyan(`  \u256D${border}\u256E`));
-    console.log(row("", 0));
-    console.log(row(titleStyled, titleVisible));
-    console.log(row("", 0));
-    console.log(row("   " + chalk.dim("Get started:"), 15));
-    console.log(row("     $ " + chalk.bold("repowise create"), 22));
-    console.log(row("", 0));
-    console.log(row("   " + chalk.dim("Thank you for using RepoWise!"), 32));
-    console.log(row("   " + chalk.dim("https://repowise.ai"), 22));
-    console.log(row("", 0));
-    console.log(chalk.cyan(`  \u2570${border}\u256F`));
-    console.log("");
-    await saveConfig({ ...config2, lastSeenVersion: currentVersion });
-  } catch {
-  }
-}
-
-// src/commands/create.ts
-import { execSync } from "child_process";
-import { mkdirSync, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname4, join as join13 } from "path";
-
-// ../listener/dist/process-manager.js
-import { spawn } from "child_process";
-import { openSync, closeSync } from "fs";
-import { readFile as readFile6, writeFile as writeFile7, mkdir as mkdir7, unlink as unlink2 } from "fs/promises";
-import { homedir as homedir6 } from "os";
-import { join as join8 } from "path";
-import { createRequire } from "module";
-import { fileURLToPath } from "url";
-var REPOWISE_DIR = join8(homedir6(), ".repowise");
-var PID_PATH2 = join8(REPOWISE_DIR, "listener.pid");
-var LOG_DIR = join8(REPOWISE_DIR, "logs");
-function resolveListenerCommand() {
-  try {
-    const require2 = createRequire(import.meta.url);
-    const mainPath = require2.resolve("@repowise/listener/main");
-    return { script: mainPath, args: [] };
-  } catch {
-    const bundlePath = fileURLToPath(import.meta.url);
-    return { script: bundlePath, args: ["__listener"] };
-  }
-}
-async function readPid() {
-  try {
-    const content = await readFile6(PID_PATH2, "utf-8");
-    const pid = parseInt(content.trim(), 10);
-    return Number.isNaN(pid) ? null : pid;
-  } catch (err) {
-    if (err.code === "ENOENT")
-      return null;
-    throw err;
-  }
-}
-function isAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function startBackground() {
-  await mkdir7(LOG_DIR, { recursive: true });
-  const cmd = resolveListenerCommand();
-  const stdoutFd = openSync(join8(LOG_DIR, "listener-stdout.log"), "a");
-  const stderrFd = openSync(join8(LOG_DIR, "listener-stderr.log"), "a");
-  const child = spawn(process.execPath, [cmd.script, ...cmd.args], {
-    detached: true,
-    stdio: ["ignore", stdoutFd, stderrFd],
-    cwd: homedir6(),
-    env: { ...process.env }
-  });
-  child.unref();
-  closeSync(stdoutFd);
-  closeSync(stderrFd);
-  const pid = child.pid;
-  if (!pid)
-    throw new Error("Failed to spawn listener process");
-  await writeFile7(PID_PATH2, String(pid));
-  return pid;
-}
-async function stopProcess() {
-  const pid = await readPid();
-  if (pid === null)
-    return;
-  if (!isAlive(pid)) {
-    await removePidFile2();
-    return;
-  }
-  try {
-    process.kill(pid, "SIGTERM");
-  } catch {
-  }
-  const deadline = Date.now() + 5e3;
-  while (Date.now() < deadline && isAlive(pid)) {
-    await new Promise((r) => setTimeout(r, 200));
+    }
+    pollIntervalMs = minPollInterval;
+    await sleep(pollIntervalMs);
   }
-  if (isAlive(pid)) {
+  if (releaseLock) {
     try {
-      process.kill(pid, "SIGKILL");
+      await releaseLock();
     } catch {
     }
-  }
-  await removePidFile2();
-}
-async function isRunning() {
-  const pid = await readPid();
-  if (pid === null)
-    return false;
-  return isAlive(pid);
-}
-async function getStatus() {
-  const pid = await readPid();
-  if (pid === null)
-    return { running: false, pid: null };
-  const alive = isAlive(pid);
-  return { running: alive, pid: alive ? pid : null };
-}
-async function removePidFile2() {
-  try {
-    await unlink2(PID_PATH2);
-  } catch {
-  }
-}
-
-// ../listener/dist/service-installer.js
-import { execFile as execFile2 } from "child_process";
-import { writeFile as writeFile8, mkdir as mkdir8, unlink as unlink3 } from "fs/promises";
-import { homedir as homedir7 } from "os";
-import { join as join9 } from "path";
-import { createRequire as createRequire2 } from "module";
-import { fileURLToPath as fileURLToPath2 } from "url";
-function resolveListenerCommand2() {
-  try {
-    const require2 = createRequire2(import.meta.url);
-    const mainPath = require2.resolve("@repowise/listener/main");
-    return { script: mainPath, args: [] };
-  } catch {
-    const bundlePath = fileURLToPath2(import.meta.url);
-    return { script: bundlePath, args: ["__listener"] };
+    releaseLock = null;
   }
 }
-function exec(cmd, args) {
-  return new Promise((resolve, reject) => {
-    execFile2(cmd, args, (err, stdout) => {
-      if (err) {
-        reject(err);
-        return;
-      }
-      resolve(String(stdout ?? ""));
-    });
+var isDirectRun = process.argv[1]?.endsWith("main.js") || process.argv[1]?.endsWith("main.ts");
+if (isDirectRun) {
+  startListener().catch((err) => {
+    console.error("Listener fatal error:", err);
+    process.exitCode = 1;
   });
 }
-var PLIST_LABEL = "com.repowise.listener";
-function plistPath() {
-  return join9(homedir7(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
-}
-function logDir() {
-  return join9(homedir7(), ".repowise", "logs");
-}
-function buildPlist() {
-  const cmd = resolveListenerCommand2();
-  const logs = logDir();
-  const programArgs = [process.execPath, cmd.script, ...cmd.args].map((a) => `        <string>${a}</string>`).join("\n");
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
-  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <key>Label</key>
-    <string>${PLIST_LABEL}</string>
-    <key>ProgramArguments</key>
-    <array>
-${programArgs}
-    </array>
-    <key>RunAtLoad</key>
-    <true/>
-    <key>KeepAlive</key>
-    <true/>
-    <key>StandardOutPath</key>
-    <string>${join9(logs, "listener-stdout.log")}</string>
-    <key>StandardErrorPath</key>
-    <string>${join9(logs, "listener-stderr.log")}</string>
-    <key>ProcessType</key>
-    <string>Background</string>
-</dict>
-</plist>`;
-}
-async function darwinInstall() {
-  await mkdir8(logDir(), { recursive: true });
-  await mkdir8(join9(homedir7(), "Library", "LaunchAgents"), { recursive: true });
-  try {
-    await exec("launchctl", ["unload", plistPath()]);
-  } catch {
-  }
-  await writeFile8(plistPath(), buildPlist());
-  await exec("launchctl", ["load", plistPath()]);
-}
-async function darwinUninstall() {
-  try {
-    await exec("launchctl", ["unload", plistPath()]);
-  } catch {
-  }
-  try {
-    await unlink3(plistPath());
-  } catch {
-  }
+
+// src/lib/env.ts
+import { homedir as homedir4 } from "os";
+import { join as join13 } from "path";
+var IS_STAGING2 = true ? false : false;
+var PRODUCTION = {
+  apiUrl: "https://api.repowise.ai",
+  cognitoDomain: "auth.repowise.ai",
+  cognitoClientId: "50so1fkmjbqt1ufnsmbhsjbtst",
+  cognitoRegion: "us-east-1",
+  customDomain: true
+};
+var STAGING = {
+  apiUrl: "https://staging-api.repowise.ai",
+  cognitoDomain: "auth-staging.repowise.ai",
+  cognitoClientId: "7h0l0dhjcb1v5erer0gaclv0q6",
+  cognitoRegion: "us-east-1",
+  customDomain: true
+};
+function getEnvConfig() {
+  return IS_STAGING2 ? STAGING : PRODUCTION;
 }
-async function darwinIsInstalled() {
-  try {
-    const stdout = await exec("launchctl", ["list"]);
-    return stdout.includes(PLIST_LABEL);
-  } catch {
-    return false;
-  }
+function getConfigDir2() {
+  return join13(homedir4(), IS_STAGING2 ? ".repowise-staging" : ".repowise");
 }
-var SYSTEMD_SERVICE = "repowise-listener";
-function unitPath() {
-  return join9(homedir7(), ".config", "systemd", "user", `${SYSTEMD_SERVICE}.service`);
+function getPackageName() {
+  return true ? "repowise" : "repowise";
 }
-function buildUnit() {
-  const cmd = resolveListenerCommand2();
-  const execStart = [process.execPath, cmd.script, ...cmd.args].join(" ");
-  const logs = logDir();
-  return `[Unit]
-Description=RepoWise Listener
-After=network-online.target
-Wants=network-online.target
 
-[Service]
-Type=simple
-ExecStart=${execStart}
-Restart=on-failure
-RestartSec=10
-StandardOutput=append:${join9(logs, "listener-stdout.log")}
-StandardError=append:${join9(logs, "listener-stderr.log")}
+// src/lib/welcome.ts
+import chalk from "chalk";
 
-[Install]
-WantedBy=default.target`;
-}
-async function linuxInstall() {
-  await mkdir8(logDir(), { recursive: true });
-  await mkdir8(join9(homedir7(), ".config", "systemd", "user"), { recursive: true });
-  await writeFile8(unitPath(), buildUnit());
-  await exec("systemctl", ["--user", "daemon-reload"]);
-  await exec("systemctl", ["--user", "enable", SYSTEMD_SERVICE]);
-  await exec("systemctl", ["--user", "start", SYSTEMD_SERVICE]);
-}
-async function linuxUninstall() {
-  try {
-    await exec("systemctl", ["--user", "stop", SYSTEMD_SERVICE]);
-  } catch {
-  }
-  try {
-    await exec("systemctl", ["--user", "disable", SYSTEMD_SERVICE]);
-  } catch {
-  }
-  try {
-    await unlink3(unitPath());
-  } catch {
-  }
+// src/lib/config.ts
+import { readFile as readFile6, writeFile as writeFile8, mkdir as mkdir8, rename as rename3, unlink as unlink6 } from "fs/promises";
+import { join as join14 } from "path";
+import lockfile3 from "proper-lockfile";
+async function getConfig() {
   try {
-    await exec("systemctl", ["--user", "daemon-reload"]);
+    const data = await readFile6(join14(getConfigDir2(), "config.json"), "utf-8");
+    return JSON.parse(data);
   } catch {
+    return {};
   }
 }
-async function linuxIsInstalled() {
+async function saveConfig(config2) {
+  const dir = getConfigDir2();
+  const path = join14(dir, "config.json");
+  await mkdir8(dir, { recursive: true });
+  const tmpPath = path + ".tmp";
   try {
-    const stdout = await exec("systemctl", ["--user", "is-enabled", SYSTEMD_SERVICE]);
-    return stdout.trim() === "enabled";
-  } catch {
-    return false;
+    await writeFile8(tmpPath, JSON.stringify(config2, null, 2));
+    await rename3(tmpPath, path);
+  } catch (err) {
+    try {
+      await unlink6(tmpPath);
+    } catch {
+    }
+    throw err;
   }
 }
-var TASK_NAME = "RepoWise Listener";
-async function win32Install() {
-  await mkdir8(logDir(), { recursive: true });
-  const cmd = resolveListenerCommand2();
-  const taskCmd = [process.execPath, cmd.script, ...cmd.args].map((a) => `"${a}"`).join(" ");
-  await exec("schtasks", [
-    "/create",
-    "/tn",
-    TASK_NAME,
-    "/tr",
-    taskCmd,
-    "/sc",
-    "onlogon",
-    "/ru",
-    process.env.USERNAME ?? "",
-    "/f"
-  ]);
-  await exec("schtasks", ["/run", "/tn", TASK_NAME]);
-}
-async function win32Uninstall() {
-  try {
-    await exec("schtasks", ["/end", "/tn", TASK_NAME]);
-  } catch {
-  }
+async function mergeAndSaveConfig(updates) {
+  const dir = getConfigDir2();
+  const path = join14(dir, "config.json");
+  await mkdir8(dir, { recursive: true });
   try {
-    await exec("schtasks", ["/delete", "/tn", TASK_NAME, "/f"]);
+    await writeFile8(path, "", { flag: "a" });
   } catch {
   }
-}
-async function win32IsInstalled() {
+  let release = null;
   try {
-    await exec("schtasks", ["/query", "/tn", TASK_NAME]);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function install() {
-  switch (process.platform) {
-    case "darwin":
-      await darwinInstall();
-      break;
-    case "linux":
-      await linuxInstall();
-      break;
-    case "win32":
-      await win32Install();
-      break;
-    default:
-      throw new Error(`Unsupported platform: ${process.platform}`);
+    release = await lockfile3.lock(path, { stale: 1e4, retries: 3, realpath: false });
+    let raw = {};
+    try {
+      raw = JSON.parse(await readFile6(path, "utf-8"));
+    } catch {
+    }
+    const merged = { ...raw, ...updates };
+    if (updates.repos) {
+      const existingRepos = Array.isArray(raw["repos"]) ? raw["repos"] : [];
+      const updatedRepoIds = new Set(updates.repos.map((r) => r.repoId));
+      merged.repos = [
+        ...existingRepos.filter((r) => !updatedRepoIds.has(r.repoId)),
+        ...updates.repos
+      ];
+    }
+    await saveConfig(merged);
+  } finally {
+    if (release) {
+      try {
+        await release();
+      } catch {
+      }
+    }
   }
 }
-async function uninstall() {
-  switch (process.platform) {
-    case "darwin":
-      await darwinUninstall();
-      break;
-    case "linux":
-      await linuxUninstall();
-      break;
-    case "win32":
-      await win32Uninstall();
-      break;
-    default:
-      throw new Error(`Unsupported platform: ${process.platform}`);
-  }
+
+// src/lib/welcome.ts
+var W = 41;
+function row(styled, visible) {
+  return chalk.cyan("  \u2502") + styled + " ".repeat(W - visible) + chalk.cyan("\u2502");
 }
-async function isInstalled() {
-  switch (process.platform) {
-    case "darwin":
-      return darwinIsInstalled();
-    case "linux":
-      return linuxIsInstalled();
-    case "win32":
-      return win32IsInstalled();
-    default:
-      return false;
+async function showWelcome(currentVersion) {
+  try {
+    const config2 = await getConfig();
+    if (config2.lastSeenVersion === currentVersion) {
+      return;
+    }
+    const isUpgrade = !!config2.lastSeenVersion;
+    const tag = isUpgrade ? "updated" : "installed";
+    const titleText = `RepoWise v${currentVersion}`;
+    const titleStyled = "   " + chalk.bold(titleText) + chalk.green(` \u2713 ${tag}`);
+    const titleVisible = 3 + titleText.length + 3 + tag.length;
+    const border = "\u2500".repeat(W);
+    console.log("");
+    console.log(chalk.cyan(`  \u256D${border}\u256E`));
+    console.log(row("", 0));
+    console.log(row(titleStyled, titleVisible));
+    console.log(row("", 0));
+    console.log(row("   " + chalk.dim("Get started:"), 15));
+    console.log(row("     $ " + chalk.bold("repowise create"), 22));
+    console.log(row("", 0));
+    console.log(row("   " + chalk.dim("Thank you for using RepoWise!"), 32));
+    console.log(row("   " + chalk.dim("https://repowise.ai"), 22));
+    console.log(row("", 0));
+    console.log(chalk.cyan(`  \u2570${border}\u256F`));
+    console.log("");
+    await mergeAndSaveConfig({ lastSeenVersion: currentVersion });
+  } catch {
   }
 }
 
 // src/commands/create.ts
+import { mkdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname6, join as join18 } from "path";
 import chalk5 from "chalk";
 import ora from "ora";
 
 // src/lib/auth.ts
 import { createHash, randomBytes } from "crypto";
-import { readFile as readFile7, writeFile as writeFile9, mkdir as mkdir9, chmod as chmod4, unlink as unlink4 } from "fs/promises";
+import { readFile as readFile7, writeFile as writeFile9, mkdir as mkdir9, chmod as chmod4, unlink as unlink7 } from "fs/promises";
 import http from "http";
-import { homedir as homedir8 } from "os";
-import { join as join10 } from "path";
-var CONFIG_DIR5 = join10(homedir8(), ".repowise");
-var CREDENTIALS_PATH2 = join10(CONFIG_DIR5, "credentials.json");
+import { join as join15 } from "path";
 var CLI_CALLBACK_PORT = 19876;
 var CALLBACK_TIMEOUT_MS = 12e4;
 function getCognitoConfigForStorage() {
@@ -1433,7 +1993,8 @@ async function refreshTokens2(refreshToken) {
 }
 async function getStoredCredentials2() {
   try {
-    const data = await readFile7(CREDENTIALS_PATH2, "utf-8");
+    const credPath = join15(getConfigDir2(), "credentials.json");
+    const data = await readFile7(credPath, "utf-8");
     return JSON.parse(data);
   } catch (err) {
     if (err.code === "ENOENT" || err instanceof SyntaxError) {
@@ -1443,13 +2004,15 @@ async function getStoredCredentials2() {
   }
 }
 async function storeCredentials2(credentials) {
-  await mkdir9(CONFIG_DIR5, { recursive: true, mode: 448 });
-  await writeFile9(CREDENTIALS_PATH2, JSON.stringify(credentials, null, 2));
-  await chmod4(CREDENTIALS_PATH2, 384);
+  const dir = getConfigDir2();
+  const credPath = join15(dir, "credentials.json");
+  await mkdir9(dir, { recursive: true, mode: 448 });
+  await writeFile9(credPath, JSON.stringify(credentials, null, 2));
+  await chmod4(credPath, 384);
 }
 async function clearCredentials() {
   try {
-    await unlink4(CREDENTIALS_PATH2);
+    await unlink7(join15(getConfigDir2(), "credentials.json"));
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
@@ -1641,7 +2204,7 @@ async function selectAiTools() {
 
 // src/lib/ai-tools.ts
 import { readFile as readFile8, writeFile as writeFile10, mkdir as mkdir10, readdir } from "fs/promises";
-import { join as join11, dirname as dirname3 } from "path";
+import { join as join16, dirname as dirname5 } from "path";
 var AI_TOOL_CONFIG = {
   cursor: {
     label: "Cursor",
@@ -1770,8 +2333,8 @@ function generateReference(tool, repoName, contextFolder, contextFiles) {
 }
 async function updateToolConfig(repoRoot, tool, repoName, contextFolder, contextFiles) {
   const config2 = AI_TOOL_CONFIG[tool];
-  const fullPath = join11(repoRoot, config2.filePath);
-  const dir = dirname3(fullPath);
+  const fullPath = join16(repoRoot, config2.filePath);
+  const dir = dirname5(fullPath);
   if (dir !== repoRoot) {
     await mkdir10(dir, { recursive: true });
   }
@@ -1799,14 +2362,14 @@ async function updateToolConfig(repoRoot, tool, repoName, contextFolder, context
   return { created };
 }
 async function scanLocalContextFiles(repoRoot, contextFolder) {
-  const folderPath = join11(repoRoot, contextFolder);
+  const folderPath = join16(repoRoot, contextFolder);
   try {
     const entries = await readdir(folderPath, { withFileTypes: true, recursive: true });
     const results = [];
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
       const parentDir = entry.parentPath ?? folderPath;
-      const fullPath = join11(parentDir, entry.name);
+      const fullPath = join16(parentDir, entry.name);
       const relFromContext = fullPath.slice(folderPath.length + 1);
       results.push({
         fileName: relFromContext,
@@ -1822,9 +2385,9 @@ async function scanLocalContextFiles(repoRoot, contextFolder) {
 
 // src/lib/gitignore.ts
 import { readFileSync, writeFileSync, existsSync } from "fs";
-import { join as join12 } from "path";
+import { join as join17 } from "path";
 function ensureGitignore(repoRoot, entry) {
-  const gitignorePath = join12(repoRoot, ".gitignore");
+  const gitignorePath = join17(repoRoot, ".gitignore");
   if (existsSync(gitignorePath)) {
     const content = readFileSync(gitignorePath, "utf-8");
     const lines = content.split("\n").map((l) => l.trim());
@@ -1838,6 +2401,24 @@ function ensureGitignore(repoRoot, entry) {
   }
 }
 
+// src/lib/git.ts
+import { execSync } from "child_process";
+function detectRepoRoot() {
+  return execSync("git rev-parse --show-toplevel", { encoding: "utf-8" }).trim();
+}
+function detectRepoName(repoRoot) {
+  try {
+    const remoteUrl = execSync("git remote get-url origin", {
+      encoding: "utf-8",
+      cwd: repoRoot
+    }).trim();
+    const match = remoteUrl.match(/\/([^/]+?)(?:\.git)?$/);
+    if (match?.[1]) return match[1];
+  } catch {
+  }
+  return repoRoot.split("/").pop() ?? "unknown";
+}
+
 // src/lib/interview-handler.ts
 import chalk3 from "chalk";
 import { input } from "@inquirer/prompts";
@@ -2081,7 +2662,9 @@ var ProgressRenderer = class {
       spinner.stop();
       console.log(chalk4.cyan.bold("  \u2500\u2500 Context Generation \u2500\u2500"));
       console.log(
-        chalk4.cyan("  \u2615 This takes a few minutes \u2014 grab a coffee, we'll handle the rest!")
+        chalk4.cyan(
+          "  \u2615 This takes a few minutes \u2014 grab a coffee, we'll handle the rest!"
+        )
       );
       console.log("");
       spinner.start();
@@ -2247,21 +2830,6 @@ var ProgressRenderer = class {
 };
 
 // src/commands/create.ts
-function detectRepoRoot() {
-  return execSync("git rev-parse --show-toplevel", { encoding: "utf-8" }).trim();
-}
-function detectRepoName(repoRoot) {
-  try {
-    const remoteUrl = execSync("git remote get-url origin", {
-      encoding: "utf-8",
-      cwd: repoRoot
-    }).trim();
-    const match = remoteUrl.match(/\/([^/]+?)(?:\.git)?$/);
-    if (match?.[1]) return match[1];
-  } catch {
-  }
-  return repoRoot.split("/").pop() ?? "unknown";
-}
 function formatElapsed(ms) {
   const totalSeconds = Math.round(ms / 1e3);
   const minutes = Math.floor(totalSeconds / 60);
@@ -2354,12 +2922,18 @@ async function create() {
           console.log(
             chalk5.cyan(
               `
-  To trigger a new full scan, visit the dashboard:
-  https://app.repowise.ai/repos/${repoId}
+  If you're a team member, run: ${chalk5.bold("repowise member")}
+  This will download context and configure your AI tools.
+`
+            )
+          );
+          console.log(
+            chalk5.dim(
+              `  To trigger a new full scan, visit: https://app.repowise.ai/repos/${repoId}
+  To sync recent changes, use: repowise sync
 `
             )
           );
-          console.log(chalk5.dim("  To sync recent changes, use: repowise sync\n"));
           process.exitCode = 1;
           return;
         }
@@ -2487,7 +3061,7 @@ async function create() {
         const listResult = await apiRequest(`/v1/repos/${repoId}/context`);
         const files = listResult.data?.files ?? listResult.files ?? [];
         if (files.length > 0) {
-          const contextDir = join13(repoRoot, DEFAULT_CONTEXT_FOLDER);
+          const contextDir = join18(repoRoot, DEFAULT_CONTEXT_FOLDER);
           mkdirSync(contextDir, { recursive: true });
           let downloadedCount = 0;
           let failedCount = 0;
@@ -2501,8 +3075,8 @@ async function create() {
             const response = await fetch(presignedUrl);
             if (response.ok) {
               const content = await response.text();
-              const filePath = join13(contextDir, file.fileName);
-              mkdirSync(dirname4(filePath), { recursive: true });
+              const filePath = join18(contextDir, file.fileName);
+              mkdirSync(dirname6(filePath), { recursive: true });
               writeFileSync2(filePath, content, "utf-8");
               downloadedCount++;
             } else {
@@ -2563,33 +3137,27 @@ Files are stored on our servers (not in git). Retry when online.`
       spinner.succeed("AI tools configured");
       console.log(chalk5.dim(results.join("\n")));
     }
-    const existingConfig = await getConfig();
-    const existingRepos = existingConfig.repos ?? [];
-    const updatedRepos = existingRepos.filter((r) => r.repoId !== repoId);
+    const updatedRepos = [];
     if (repoRoot) {
       const repoEntry = {
         repoId,
-        localPath: repoRoot
+        localPath: repoRoot,
+        apiUrl: getEnvConfig().apiUrl
       };
-      if (isStagingMode()) {
-        repoEntry.apiUrl = getEnvConfig().apiUrl;
-      }
       if (repoPlatform) repoEntry.platform = repoPlatform;
       if (repoExternalId) repoEntry.externalId = repoExternalId;
       updatedRepos.push(repoEntry);
     }
-    await saveConfig({
-      ...existingConfig,
-      aiTools: tools,
-      contextFolder,
-      repos: updatedRepos
-    });
+    const configUpdate = { aiTools: tools, contextFolder };
+    if (updatedRepos.length > 0) configUpdate.repos = updatedRepos;
+    await mergeAndSaveConfig(configUpdate);
     let listenerRunning = false;
     try {
-      await install();
-      await startBackground();
+      await ensureListenerRunning();
       listenerRunning = true;
     } catch {
+    }
+    if (!listenerRunning) {
       console.log(
         chalk5.yellow(
           "Warning: Could not start listener automatically. Run the following to enable it:"
@@ -2626,11 +3194,255 @@ Files are stored on our servers (not in git). Retry when online.`
   }
 }
 
-// src/commands/login.ts
+// src/commands/member.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname7, join as join19 } from "path";
 import chalk6 from "chalk";
 import ora2 from "ora";
+var DEFAULT_CONTEXT_FOLDER2 = "repowise-context";
+function formatElapsed2(ms) {
+  const totalSeconds = Math.round(ms / 1e3);
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (minutes === 0) return `${seconds}s`;
+  return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
+}
+async function member() {
+  const startTime = Date.now();
+  const spinner = ora2("Checking authentication...").start();
+  try {
+    let credentials = await getValidCredentials2();
+    if (!credentials) {
+      spinner.info(chalk6.yellow("Not logged in. Opening browser to authenticate..."));
+      credentials = await performLogin();
+      const { email } = decodeIdToken(credentials.idToken);
+      spinner.succeed(chalk6.green(`Authenticated as ${chalk6.bold(email)}`));
+    } else {
+      spinner.succeed("Authenticated");
+    }
+    let repoId;
+    let repoName;
+    let repoRoot;
+    let repoPlatform;
+    let repoExternalId;
+    spinner.start("Checking for pending repository...");
+    try {
+      const pending = await apiRequest("/v1/onboarding/pending");
+      if (pending?.repoId) {
+        repoId = pending.repoId;
+        repoName = pending.repoName;
+        spinner.succeed(`Found pending repository: ${chalk6.bold(repoName)}`);
+        apiRequest("/v1/onboarding/pending", { method: "DELETE" }).catch(() => {
+        });
+      }
+    } catch {
+    }
+    if (!repoId) {
+      spinner.text = "Detecting repository...";
+      try {
+        repoRoot = detectRepoRoot();
+        repoName = detectRepoName(repoRoot);
+        spinner.succeed(`Repository: ${chalk6.bold(repoName)}`);
+      } catch {
+        spinner.fail(
+          chalk6.red("Not in a git repository. Run this command from your project directory.")
+        );
+        process.exitCode = 1;
+        return;
+      }
+    } else {
+      try {
+        repoRoot = detectRepoRoot();
+        const localRepoName = detectRepoName(repoRoot);
+        if (repoName && localRepoName !== repoName && !repoName.endsWith(`/${localRepoName}`)) {
+          spinner.warn(
+            chalk6.yellow(
+              `Pending repo is ${chalk6.bold(repoName)} but you're in ${chalk6.bold(localRepoName)}.
+  Make sure you're in the right project directory, or the context files will be saved here.`
+            )
+          );
+        }
+      } catch {
+        spinner.fail(
+          chalk6.red(
+            "Please navigate to your project directory first, then run `repowise member` again."
+          )
+        );
+        process.exitCode = 1;
+        return;
+      }
+    }
+    if (!repoId || !repoPlatform) {
+      spinner.start("Looking up repository...");
+      try {
+        const repos = await apiRequest("/v1/repos");
+        const match = repos.find(
+          (r) => r.repoId === repoId || r.name === repoName || r.fullName.endsWith(`/${repoName}`)
+        );
+        if (match) {
+          repoId = match.repoId;
+          repoPlatform = match.platform;
+          repoExternalId = match.externalId;
+          if (!repoName) repoName = match.fullName;
+          spinner.succeed(`Repository: ${chalk6.bold(match.fullName)}`);
+        }
+      } catch {
+      }
+    }
+    if (!repoId) {
+      spinner.fail(
+        chalk6.red(
+          "This repository is not connected to your team. Ask your team admin to add it on the dashboard."
+        )
+      );
+      process.exitCode = 1;
+      return;
+    }
+    spinner.start("Checking for context files...");
+    let files = [];
+    try {
+      const listResult = await apiRequest(`/v1/repos/${repoId}/context`);
+      files = listResult.data?.files ?? listResult.files ?? [];
+    } catch {
+      spinner.fail(chalk6.red("Failed to check context files on server."));
+      process.exitCode = 1;
+      return;
+    }
+    if (files.length === 0) {
+      spinner.fail(
+        chalk6.red(
+          "No context files found for this repository. Your team admin needs to run the initial scan first."
+        )
+      );
+      process.exitCode = 1;
+      return;
+    }
+    spinner.succeed(`Found ${chalk6.bold(files.length)} context files on server`);
+    const { tools } = await selectAiTools();
+    spinner.start("Downloading context files...");
+    const contextDir = join19(repoRoot, DEFAULT_CONTEXT_FOLDER2);
+    mkdirSync2(contextDir, { recursive: true });
+    let downloadedCount = 0;
+    let failedCount = 0;
+    for (const file of files) {
+      if (file.fileName.includes("..")) {
+        failedCount++;
+        continue;
+      }
+      try {
+        const urlResult = await apiRequest(`/v1/repos/${repoId}/context/files/${file.fileName}`);
+        const presignedUrl = urlResult.data?.url ?? urlResult.url;
+        const response = await fetch(presignedUrl);
+        if (response.ok) {
+          const content = await response.text();
+          const filePath = join19(contextDir, file.fileName);
+          mkdirSync2(dirname7(filePath), { recursive: true });
+          writeFileSync3(filePath, content, "utf-8");
+          downloadedCount++;
+        } else {
+          failedCount++;
+        }
+      } catch {
+        failedCount++;
+      }
+    }
+    if (failedCount > 0) {
+      spinner.warn(
+        `Downloaded ${downloadedCount}/${files.length} files to ./${DEFAULT_CONTEXT_FOLDER2}/ (${failedCount} failed)`
+      );
+    } else {
+      spinner.succeed(`Downloaded ${downloadedCount} files to ./${DEFAULT_CONTEXT_FOLDER2}/`);
+    }
+    try {
+      ensureGitignore(repoRoot, DEFAULT_CONTEXT_FOLDER2);
+    } catch {
+    }
+    if (tools.length > 0) {
+      spinner.start("Configuring AI tools...");
+      const contextFiles = await scanLocalContextFiles(repoRoot, DEFAULT_CONTEXT_FOLDER2);
+      const configured = [];
+      for (const tool of tools) {
+        const { created } = await updateToolConfig(
+          repoRoot,
+          tool,
+          repoName,
+          DEFAULT_CONTEXT_FOLDER2,
+          contextFiles
+        );
+        const config2 = AI_TOOL_CONFIG[tool];
+        configured.push(`${created ? "Created" : "Updated"} ${config2.filePath}`);
+      }
+      spinner.succeed("AI tools configured");
+      for (const msg of configured) {
+        console.log(chalk6.dim(`  ${msg}`));
+      }
+    }
+    spinner.start("Saving configuration...");
+    const repoEntry = {
+      repoId,
+      localPath: repoRoot,
+      apiUrl: getEnvConfig().apiUrl
+    };
+    if (repoPlatform) repoEntry.platform = repoPlatform;
+    if (repoExternalId) repoEntry.externalId = repoExternalId;
+    await mergeAndSaveConfig({
+      aiTools: tools,
+      contextFolder: DEFAULT_CONTEXT_FOLDER2,
+      repos: [repoEntry]
+    });
+    spinner.succeed("Configuration saved");
+    let listenerRunning = false;
+    try {
+      await ensureListenerRunning();
+      listenerRunning = true;
+    } catch {
+    }
+    try {
+      await apiRequest("/v1/onboarding/complete", {
+        method: "POST",
+        body: JSON.stringify({ repoId })
+      });
+    } catch {
+    }
+    const elapsed = formatElapsed2(Date.now() - startTime);
+    console.log("");
+    console.log(chalk6.green.bold("All done! Context downloaded and configured."));
+    console.log("");
+    console.log(`Your AI tools now have access to project context for ${chalk6.bold(repoName)}.`);
+    console.log(
+      `Downloaded ${chalk6.bold(downloadedCount)} context files to ./${DEFAULT_CONTEXT_FOLDER2}/`
+    );
+    console.log("");
+    if (listenerRunning) {
+      console.log(
+        chalk6.dim(
+          "The RepoWise listener is running in the background \u2014\nyour context will stay in sync automatically."
+        )
+      );
+    } else {
+      console.log(
+        chalk6.yellow(
+          "Could not start listener automatically. Run `repowise listen --install` to enable auto-sync."
+        )
+      );
+    }
+    console.log("");
+    console.log(
+      chalk6.dim(`Head back to the dashboard and click "Complete Onboarding" to finish setup.`)
+    );
+    console.log(chalk6.dim(`Total time: ${elapsed}`));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    spinner.fail(chalk6.red(`Setup failed: ${message}`));
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/login.ts
+import chalk7 from "chalk";
+import ora3 from "ora";
 async function login(options = {}) {
-  const spinner = ora2("Preparing login...").start();
+  const spinner = ora3("Preparing login...").start();
   try {
     const codeVerifier = generateCodeVerifier();
     const codeChallenge = generateCodeChallenge(codeVerifier);
@@ -2642,7 +3454,7 @@ async function login(options = {}) {
       console.log(`
 Open this URL in your browser to authenticate:
 `);
-      console.log(chalk6.cyan(authorizeUrl));
+      console.log(chalk7.cyan(authorizeUrl));
       console.log(`
 Waiting for authentication...`);
     } else {
@@ -2656,7 +3468,7 @@ Waiting for authentication...`);
         console.log(`
 Could not open browser automatically. Open this URL:
 `);
-        console.log(chalk6.cyan(authorizeUrl));
+        console.log(chalk7.cyan(authorizeUrl));
         console.log(`
 Waiting for authentication...`);
       }
@@ -2670,60 +3482,50 @@ Waiting for authentication...`);
     credentials.cognito = getCognitoConfigForStorage();
     await storeCredentials2(credentials);
     const { email } = decodeIdToken(credentials.idToken);
-    spinner.succeed(chalk6.green(`Logged in as ${chalk6.bold(email)}`));
+    spinner.succeed(chalk7.green(`Logged in as ${chalk7.bold(email)}`));
   } catch (err) {
     const message = err instanceof Error ? err.message : "Login failed";
-    spinner.fail(chalk6.red(message));
+    spinner.fail(chalk7.red(message));
     process.exitCode = 1;
   }
 }
 
 // src/commands/logout.ts
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 async function logout() {
   const creds = await getStoredCredentials2();
   if (!creds) {
-    console.log(chalk7.yellow("Not logged in."));
+    console.log(chalk8.yellow("Not logged in."));
     return;
   }
   await clearCredentials();
-  console.log(chalk7.green("Logged out successfully."));
+  console.log(chalk8.green("Logged out successfully."));
 }
 
 // src/commands/status.ts
 import { readFile as readFile9 } from "fs/promises";
-import { homedir as homedir9 } from "os";
-import { basename as basename2, join as join14 } from "path";
-var STATE_PATH2 = join14(homedir9(), ".repowise", "listener-state.json");
-var CONFIG_PATH3 = join14(homedir9(), ".repowise", "config.json");
+import { basename as basename2, join as join20 } from "path";
 async function status() {
+  const configDir = getConfigDir2();
+  const STATE_PATH = join20(configDir, "listener-state.json");
+  const CONFIG_PATH = join20(configDir, "config.json");
   let state = null;
   try {
-    const data = await readFile9(STATE_PATH2, "utf-8");
+    const data = await readFile9(STATE_PATH, "utf-8");
     state = JSON.parse(data);
   } catch {
   }
-  let processRunning = false;
-  let pid = null;
-  try {
-    const processStatus = await getStatus();
-    processRunning = processStatus.running;
-    pid = processStatus.pid;
-  } catch {
-  }
-  let serviceInstalled = false;
-  try {
-    serviceInstalled = await isInstalled();
-  } catch {
-  }
+  const listenerStatus = await getListenerStatus();
   console.log("RepoWise Status");
   console.log("===============");
-  if (processRunning) {
-    console.log(`Listener: running (PID: ${pid})`);
+  if (listenerStatus.running) {
+    console.log(
+      listenerStatus.method === "service" ? "Listener: running (managed by system service)" : `Listener: running (PID: ${listenerStatus.pid})`
+    );
   } else {
     console.log("Listener: stopped");
   }
-  if (serviceInstalled) {
+  if (listenerStatus.serviceInstalled) {
     console.log("Auto-start: enabled");
   } else {
     console.log("Auto-start: disabled");
@@ -2735,7 +3537,7 @@ async function status() {
   }
   const repoNames = /* @__PURE__ */ new Map();
   try {
-    const configData = await readFile9(CONFIG_PATH3, "utf-8");
+    const configData = await readFile9(CONFIG_PATH, "utf-8");
     const config2 = JSON.parse(configData);
     for (const repo of config2.repos ?? []) {
       repoNames.set(repo.repoId, basename2(repo.localPath));
@@ -2753,30 +3555,14 @@ async function status() {
 }
 
 // src/commands/sync.ts
-import { execSync as execSync2 } from "child_process";
-import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname5, join as join15 } from "path";
-import chalk8 from "chalk";
-import ora3 from "ora";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname8, join as join21 } from "path";
+import chalk9 from "chalk";
+import ora4 from "ora";
 var POLL_INTERVAL_MS2 = 3e3;
 var MAX_POLL_ATTEMPTS2 = 7200;
-var DEFAULT_CONTEXT_FOLDER2 = "repowise-context";
-function detectRepoRoot2() {
-  return execSync2("git rev-parse --show-toplevel", { encoding: "utf-8" }).trim();
-}
-function detectRepoName2(repoRoot) {
-  try {
-    const remoteUrl = execSync2("git remote get-url origin", {
-      encoding: "utf-8",
-      cwd: repoRoot
-    }).trim();
-    const match = remoteUrl.match(/\/([^/]+?)(?:\.git)?$/);
-    if (match?.[1]) return match[1];
-  } catch {
-  }
-  return repoRoot.split("/").pop() ?? "unknown";
-}
-function formatElapsed2(ms) {
+var DEFAULT_CONTEXT_FOLDER3 = "repowise-context";
+function formatElapsed3(ms) {
   const totalSeconds = Math.round(ms / 1e3);
   const minutes = Math.floor(totalSeconds / 60);
   const seconds = totalSeconds % 60;
@@ -2785,14 +3571,14 @@ function formatElapsed2(ms) {
 }
 async function sync() {
   const startTime = Date.now();
-  const spinner = ora3("Checking authentication...").start();
+  const spinner = ora4("Checking authentication...").start();
   try {
     let credentials = await getValidCredentials2();
     if (!credentials) {
-      spinner.info(chalk8.yellow("Not logged in. Opening browser to authenticate..."));
+      spinner.info(chalk9.yellow("Not logged in. Opening browser to authenticate..."));
       credentials = await performLogin();
       const { email } = decodeIdToken(credentials.idToken);
-      spinner.succeed(chalk8.green(`Authenticated as ${chalk8.bold(email)}`));
+      spinner.succeed(chalk9.green(`Authenticated as ${chalk9.bold(email)}`));
     } else {
       spinner.succeed("Authenticated");
     }
@@ -2800,12 +3586,12 @@ async function sync() {
     let repoName;
     spinner.start("Detecting repository...");
     try {
-      repoRoot = detectRepoRoot2();
-      repoName = detectRepoName2(repoRoot);
-      spinner.succeed(`Repository: ${chalk8.bold(repoName)}`);
+      repoRoot = detectRepoRoot();
+      repoName = detectRepoName(repoRoot);
+      spinner.succeed(`Repository: ${chalk9.bold(repoName)}`);
     } catch {
       spinner.fail(
-        chalk8.red("Not in a git repository. Run this command from your repo directory.")
+        chalk9.red("Not in a git repository. Run this command from your repo directory.")
       );
       process.exitCode = 1;
       return;
@@ -2826,7 +3612,7 @@ async function sync() {
     }
     if (!repoId) {
       spinner.fail(
-        chalk8.red(
+        chalk9.red(
           "Could not find this repository in your RepoWise account. Run `repowise create` first."
         )
       );
@@ -2863,7 +3649,7 @@ async function sync() {
         syncId = retryResult.syncId;
       } else {
         syncId = active.syncId;
-        spinner.info(chalk8.cyan("Resuming existing sync..."));
+        spinner.info(chalk9.cyan("Resuming existing sync..."));
         spinner.start();
       }
     }
@@ -2871,7 +3657,7 @@ async function sync() {
     const progressRenderer = new ProgressRenderer();
     while (true) {
       if (++pollAttempts > MAX_POLL_ATTEMPTS2) {
-        spinner.fail(chalk8.red("Sync timed out. Check dashboard for status."));
+        spinner.fail(chalk9.red("Sync timed out. Check dashboard for status."));
         process.exitCode = 1;
         return;
       }
@@ -2895,15 +3681,15 @@ async function sync() {
         const generatedFiles = syncResult.filesGenerated ?? [];
         const fileCount = generatedFiles.length;
         if (fileCount > 0) {
-          spinner.succeed(chalk8.green(`Incremental update complete \u2014 ${fileCount} files updated`));
+          spinner.succeed(chalk9.green(`Incremental update complete \u2014 ${fileCount} files updated`));
         } else {
-          spinner.succeed(chalk8.green("Incremental sync complete \u2014 no files needed updating"));
+          spinner.succeed(chalk9.green("Incremental sync complete \u2014 no files needed updating"));
         }
         break;
       }
       if (syncResult.status === "failed") {
         progressRenderer.finalize();
-        spinner.fail(chalk8.red(`Sync failed: ${syncResult.error ?? "Unknown error"}`));
+        spinner.fail(chalk9.red(`Sync failed: ${syncResult.error ?? "Unknown error"}`));
         process.exitCode = 1;
         return;
       }
@@ -2913,8 +3699,8 @@ async function sync() {
       const listResult = await apiRequest(`/v1/repos/${repoId}/context`);
       const files = listResult.data?.files ?? listResult.files ?? [];
       if (files.length > 0) {
-        const contextDir = join15(repoRoot, DEFAULT_CONTEXT_FOLDER2);
-        mkdirSync2(contextDir, { recursive: true });
+        const contextDir = join21(repoRoot, DEFAULT_CONTEXT_FOLDER3);
+        mkdirSync3(contextDir, { recursive: true });
         let downloadedCount = 0;
         let failedCount = 0;
         for (const file of files) {
@@ -2927,9 +3713,9 @@ async function sync() {
           const response = await fetch(presignedUrl);
           if (response.ok) {
             const content = await response.text();
-            const filePath = join15(contextDir, file.fileName);
-            mkdirSync2(dirname5(filePath), { recursive: true });
-            writeFileSync3(filePath, content, "utf-8");
+            const filePath = join21(contextDir, file.fileName);
+            mkdirSync3(dirname8(filePath), { recursive: true });
+            writeFileSync4(filePath, content, "utf-8");
             downloadedCount++;
           } else {
             failedCount++;
@@ -2937,13 +3723,13 @@ async function sync() {
         }
         if (failedCount > 0) {
           spinner.warn(
-            `Downloaded ${downloadedCount}/${files.length} files to ./${DEFAULT_CONTEXT_FOLDER2}/ (${failedCount} failed)`
+            `Downloaded ${downloadedCount}/${files.length} files to ./${DEFAULT_CONTEXT_FOLDER3}/ (${failedCount} failed)`
           );
         } else {
-          spinner.succeed(`Context files downloaded to ./${DEFAULT_CONTEXT_FOLDER2}/`);
+          spinner.succeed(`Context files downloaded to ./${DEFAULT_CONTEXT_FOLDER3}/`);
         }
         try {
-          ensureGitignore(repoRoot, DEFAULT_CONTEXT_FOLDER2);
+          ensureGitignore(repoRoot, DEFAULT_CONTEXT_FOLDER3);
         } catch {
         }
       } else {
@@ -2951,7 +3737,7 @@ async function sync() {
       }
     } catch (err) {
       const msg = err instanceof Error ? err.message : "Unknown error";
-      spinner.warn(chalk8.yellow(`Could not download context files: ${msg}
+      spinner.warn(chalk9.yellow(`Could not download context files: ${msg}
 Retry when online.`));
     }
     if (repoRoot && repoId) {
@@ -2959,29 +3745,24 @@ Retry when online.`));
         const existingConfig = await getConfig();
         const existingRepos = existingConfig.repos ?? [];
         if (!existingRepos.some((r) => r.repoId === repoId)) {
-          const repoEntry = { repoId, localPath: repoRoot };
-          if (isStagingMode()) {
-            repoEntry.apiUrl = getEnvConfig().apiUrl;
-          }
+          const repoEntry = { repoId, localPath: repoRoot, apiUrl: getEnvConfig().apiUrl };
           if (repoPlatform) repoEntry.platform = repoPlatform;
           if (repoExternalId) repoEntry.externalId = repoExternalId;
-          existingRepos.push(repoEntry);
-          await saveConfig({ ...existingConfig, repos: existingRepos });
+          await mergeAndSaveConfig({ repos: [repoEntry] });
         }
       } catch {
       }
       try {
-        await install();
-        await startBackground();
+        await ensureListenerRunning();
       } catch {
       }
     }
-    const elapsed = formatElapsed2(Date.now() - startTime);
-    console.log(chalk8.dim(`
+    const elapsed = formatElapsed3(Date.now() - startTime);
+    console.log(chalk9.dim(`
   Total time: ${elapsed}`));
   } catch (err) {
     const message = err instanceof Error ? err.message : "Sync failed";
-    spinner.fail(chalk8.red(message));
+    spinner.fail(chalk9.red(message));
     process.exitCode = 1;
   }
 }
@@ -3029,12 +3810,15 @@ async function listen(options) {
 // src/commands/start.ts
 async function start() {
   try {
-    if (await isRunning()) {
+    const status2 = await getListenerStatus();
+    if (status2.running) {
       console.log("Listener is already running.");
       return;
     }
-    const pid = await startBackground();
-    console.log(`Listener started (PID: ${pid}).`);
+    const result = await ensureListenerRunning();
+    console.log(
+      result.method === "service" ? "Listener service installed and started." : `Listener started (PID: ${result.pid}).`
+    );
   } catch (err) {
     const message = err instanceof Error ? err.message : "Unknown error";
     console.error(`Failed to start listener: ${message}`);
@@ -3045,11 +3829,12 @@ async function start() {
 // src/commands/stop.ts
 async function stop2() {
   try {
-    if (!await isRunning()) {
+    const status2 = await getListenerStatus();
+    if (!status2.running) {
       console.log("Listener is not running.");
       return;
     }
-    await stopProcess();
+    await stopListener();
     console.log("Listener stopped.");
   } catch (err) {
     const message = err instanceof Error ? err.message : "Unknown error";
@@ -3059,18 +3844,18 @@ async function stop2() {
 }
 
 // src/commands/config.ts
-import chalk9 from "chalk";
-import ora4 from "ora";
+import chalk10 from "chalk";
+import ora5 from "ora";
 import { select } from "@inquirer/prompts";
 async function config() {
-  const spinner = ora4("Checking authentication...").start();
+  const spinner = ora5("Checking authentication...").start();
   try {
     let credentials = await getValidCredentials2();
     if (!credentials) {
-      spinner.info(chalk9.yellow("Not logged in. Opening browser to authenticate..."));
+      spinner.info(chalk10.yellow("Not logged in. Opening browser to authenticate..."));
       credentials = await performLogin();
       const { email } = decodeIdToken(credentials.idToken);
-      spinner.succeed(chalk9.green(`Authenticated as ${chalk9.bold(email)}`));
+      spinner.succeed(chalk10.green(`Authenticated as ${chalk10.bold(email)}`));
     } else {
       spinner.succeed("Authenticated");
     }
@@ -3078,7 +3863,7 @@ async function config() {
     const repos = await apiRequest("/v1/repos");
     spinner.stop();
     if (repos.length === 0) {
-      console.log(chalk9.yellow("No repositories connected. Run `repowise create` first."));
+      console.log(chalk10.yellow("No repositories connected. Run `repowise create` first."));
       return;
     }
     const repoId = await select({
@@ -3092,10 +3877,10 @@ async function config() {
     const currentDelivery = repo.deliveryMode ?? "direct";
     const currentBranch = repo.monitoredBranch ?? repo.defaultBranch;
     console.log("");
-    console.log(chalk9.bold(`Settings for ${repo.fullName}`));
-    console.log(chalk9.dim(`  Context storage: RepoWise servers`));
-    console.log(chalk9.dim(`  Delivery mode:   ${currentDelivery}`));
-    console.log(chalk9.dim(`  Monitored branch: ${currentBranch}`));
+    console.log(chalk10.bold(`Settings for ${repo.fullName}`));
+    console.log(chalk10.dim(`  Context storage: RepoWise servers`));
+    console.log(chalk10.dim(`  Delivery mode:   ${currentDelivery}`));
+    console.log(chalk10.dim(`  Monitored branch: ${currentBranch}`));
     console.log("");
     const setting = await select({
       message: "What would you like to change?",
@@ -3115,7 +3900,7 @@ async function config() {
         default: currentDelivery
       });
       if (newMode === currentDelivery) {
-        console.log(chalk9.dim("No change."));
+        console.log(chalk10.dim("No change."));
         return;
       }
       patch.deliveryMode = newMode;
@@ -3126,7 +3911,7 @@ async function config() {
         default: currentBranch
       });
       if (newBranch === currentBranch) {
-        console.log(chalk9.dim("No change."));
+        console.log(chalk10.dim("No change."));
         return;
       }
       patch.monitoredBranch = newBranch;
@@ -3136,29 +3921,29 @@ async function config() {
       method: "PATCH",
       body: JSON.stringify(patch)
     });
-    spinner.succeed(chalk9.green("Setting updated"));
+    spinner.succeed(chalk10.green("Setting updated"));
   } catch (err) {
     spinner.stop();
     const message = err instanceof Error ? err.message : "Config failed";
-    console.error(chalk9.red(message));
+    console.error(chalk10.red(message));
     process.exitCode = 1;
   }
 }
 
 // bin/repowise.ts
 var __filename = fileURLToPath3(import.meta.url);
-var __dirname = dirname6(__filename);
-var pkg = JSON.parse(readFileSync2(join16(__dirname, "..", "..", "package.json"), "utf-8"));
+var __dirname = dirname9(__filename);
+var pkg = JSON.parse(readFileSync2(join22(__dirname, "..", "..", "package.json"), "utf-8"));
 var program = new Command();
-program.name("repowise").description("AI-optimized codebase context generator").version(pkg.version).option("--staging", "Use the staging environment").hook("preAction", async () => {
-  if (program.opts()["staging"]) {
-    setStagingMode(true);
-  }
+program.name(getPackageName()).description("AI-optimized codebase context generator").version(pkg.version).hook("preAction", async () => {
   await showWelcome(pkg.version);
 });
 program.command("create").description("Create context for a repository").action(async () => {
   await create();
 });
+program.command("member").description("Download context and configure AI tools (for team members)").action(async () => {
+  await member();
+});
 program.command("login").description("Authenticate with RepoWise").option("--no-browser", "Print login URL instead of opening browser").action(async (options) => {
   await login(options);
 });
@@ -3190,7 +3975,7 @@ if (process.argv[2] === "__listener") {
   process.on("unhandledRejection", (reason) => {
     console.error("Listener unhandled rejection:", reason);
   });
-  startListener({ skipPidCheck: true }).catch((err) => {
+  startListener().catch((err) => {
     console.error("Listener fatal error:", err);
     process.exitCode = 1;
   });