@archme/cli 0.4.4 → 0.5.0

package/README.md

@@ -42,6 +42,28 @@ Watching a repo needs the ArchMe GitHub App installed on it; `archme init` tells
 you if that step is still missing. Not up for hosting the agent yourself? Get in
 touch at [archme.io](https://archme.io) and we'll run it for you.
 
+## 3. Remove it
+
+```bash
+archme uninstall
+```
+
+From inside the repo. It lists everything it will change and asks before doing
+any of it:
+
+- **The agent config** — the `archme` MCP server from `.mcp.json`, the ArchMe
+  block from `CLAUDE.md`, the architecture skill. Your own config in those files
+  is left alone, and a file we created is deleted rather than left empty.
+- **Watching** — so commits stop updating the architecture. Removing the config
+  on its own would leave the board moving while looking uninstalled, which is
+  why this is the default; `--keep-watching` opts out.
+- **The daemon** — but only if no other repo is left for it to serve. It's one
+  service per account, so uninstalling one repo never stops the others.
+
+Your architecture on archme.io and this machine's login survive (`archme logout`
+for the latter). The ArchMe GitHub App installation is org-wide, so it stays —
+remove it on github.com if you want it gone.
+
 ---
 
 ## Other commands
@@ -49,6 +71,7 @@ touch at [archme.io](https://archme.io) and we'll run it for you.
 | Command | Purpose |
 |---|---|
 | `archme init [repo-path]` | Guided setup + scan (see above); `--force` re-scans |
+| `archme uninstall [repo-path]` | Stop ArchMe for a repo: agent config, watching, and the daemon if idle |
 | `archme scan <repo-path>` | Low-level single-pass scan into an explicit `--project` / `--branch` |
 | `archme daemon <sub>` | `start` · `stop` · `restart` · `status` · `logs` · `enable` · `disable` · `install` · `uninstall` · `run` |
 | `archme analyze <sub>` | Tree-sitter code analysis: `outline` · `repo` · `diff` · `match` · `prefetch` |
@@ -61,6 +84,9 @@ Every command takes `--help`. Useful flags:
   (scans are interactive by default, so you can steer them as they go).
 - `archme daemon status` — is it installed, running, and signed in?
   `archme daemon logs -f` follows the log.
+- `archme uninstall --keep-watching` — removes the agent config but leaves the
+  repo watched and the daemon running (see above); `--yes` skips the
+  confirmation. Run it from anywhere in the repo — it resolves the repo root.
 - `archme analyze outline <file>` — JSON symbol outline for one file; `repo`
   outlines everything, `diff <range>` only what a git range touched. Supports
   TypeScript, TSX, JavaScript, Python, Go, Java, Ruby, Rust, Swift, and Kotlin.

package/dist/cli.js

@@ -1091,12 +1091,12 @@ var require_isexe = __commonJS({
         if (typeof Promise !== "function") {
           throw new TypeError("callback not provided");
         }
-        return new Promise(function(resolve5, reject) {
+        return new Promise(function(resolve6, reject) {
           isexe(path7, options || {}, function(er, is) {
             if (er) {
               reject(er);
             } else {
-              resolve5(is);
+              resolve6(is);
             }
           });
         });
@@ -1162,27 +1162,27 @@ var require_which = __commonJS({
         opt = {};
       const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
       const found = [];
-      const step = (i2) => new Promise((resolve5, reject) => {
+      const step = (i2) => new Promise((resolve6, reject) => {
         if (i2 === pathEnv.length)
-          return opt.all && found.length ? resolve5(found) : reject(getNotFoundError(cmd));
+          return opt.all && found.length ? resolve6(found) : reject(getNotFoundError(cmd));
         const ppRaw = pathEnv[i2];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
         const pCmd = path7.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-        resolve5(subStep(p, i2, 0));
+        resolve6(subStep(p, i2, 0));
       });
-      const subStep = (p, i2, ii) => new Promise((resolve5, reject) => {
+      const subStep = (p, i2, ii) => new Promise((resolve6, reject) => {
         if (ii === pathExt.length)
-          return resolve5(step(i2 + 1));
+          return resolve6(step(i2 + 1));
         const ext2 = pathExt[ii];
         isexe(p + ext2, { pathExt: pathExtExe }, (er, is) => {
           if (!er && is) {
             if (opt.all)
               found.push(p + ext2);
             else
-              return resolve5(p + ext2);
+              return resolve6(p + ext2);
           }
-          return resolve5(subStep(p, i2, ii + 1));
+          return resolve6(subStep(p, i2, ii + 1));
         });
       });
       return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
@@ -2262,8 +2262,8 @@ var init_deferred = __esm({
   "node_modules/execa/lib/utils/deferred.js"() {
     createDeferred = () => {
       const methods = {};
-      const promise = new Promise((resolve5, reject) => {
-        Object.assign(methods, { resolve: resolve5, reject });
+      const promise = new Promise((resolve6, reject) => {
+        Object.assign(methods, { resolve: resolve6, reject });
       });
       return Object.assign(promise, methods);
     };
@@ -7560,11 +7560,11 @@ var init_concurrent = __esm({
       const promises = weakMap.get(stream);
       const promise = createDeferred();
       promises.push(promise);
-      const resolve5 = promise.resolve.bind(promise);
-      return { resolve: resolve5, promises };
+      const resolve6 = promise.resolve.bind(promise);
+      return { resolve: resolve6, promises };
     };
-    waitForConcurrentStreams = async ({ resolve: resolve5, promises }, subprocess) => {
-      resolve5();
+    waitForConcurrentStreams = async ({ resolve: resolve6, promises }, subprocess) => {
+      resolve6();
       const [isSubprocessExit] = await Promise.race([
         Promise.allSettled([true, subprocess]),
         Promise.all([false, ...promises])
@@ -8636,7 +8636,7 @@ async function runLogin() {
   const expiresAt = Date.now() + data.expires_in * 1e3;
   let intervalMs = Math.max(data.interval, 1) * 1e3;
   while (Date.now() < expiresAt) {
-    await new Promise((resolve5) => setTimeout(resolve5, intervalMs));
+    await new Promise((resolve6) => setTimeout(resolve6, intervalMs));
     const poll = await postJson("/poll", {
       device_code: data.device_code
     });
@@ -8666,12 +8666,6 @@ var init_enroll = __esm({
     init_execa();
     init_credentials();
     init_defaults();
-    if (import.meta.url === `file://${process.argv[1]}`) {
-      runLogin().catch((err2) => {
-        console.error(err2 instanceof Error ? err2.message : err2);
-        process.exit(1);
-      });
-    }
   }
 });
 
@@ -8726,13 +8720,43 @@ var init_paths = __esm({
   }
 });
 
+// src/daemon/supervision.ts
+function isSupervised(env) {
+  return env[SUPERVISED_ENV_VAR] === "1";
+}
+function resolveExitCode(code, env) {
+  return isSupervised(env) && PERMANENT_EXIT_CODES.has(code) ? 0 : code;
+}
+function supervisedStopNotice(code, env) {
+  if (!isSupervised(env) || !PERMANENT_EXIT_CODES.has(code)) return null;
+  return "this cannot be fixed by restarting, so the service is stopping rather than retrying; re-run `archme daemon start` once resolved";
+}
+var PERMANENT_EXIT_CODES, SUPERVISED_ENV_VAR;
+var init_supervision = __esm({
+  "src/daemon/supervision.ts"() {
+    "use strict";
+    PERMANENT_EXIT_CODES = /* @__PURE__ */ new Set([
+      1,
+      // missing/unreadable config
+      2,
+      // no stored credentials — needs `archme login`
+      78
+      // several accounts on one machine — needs a human to choose
+    ]);
+    SUPERVISED_ENV_VAR = "ARCHME_SUPERVISED";
+  }
+});
+
 // src/daemon/service/unitFiles.ts
+function unitEnv(env) {
+  return { ...env, [SUPERVISED_ENV_VAR]: "1" };
+}
 function xmlEscape(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
 function renderLaunchdPlist(opts) {
   const argLines = [opts.nodeBin, opts.cliEntry, "daemon", "run"].map((a2) => `        <string>${xmlEscape(a2)}</string>`).join("\n");
-  const envLines = Object.entries(opts.env).map(
+  const envLines = Object.entries(unitEnv(opts.env)).map(
     ([k, v]) => `        <key>${xmlEscape(k)}</key>
         <string>${xmlEscape(v)}</string>`
   ).join("\n");
@@ -8750,8 +8774,8 @@ ${argLines}
     <true/>
     <key>KeepAlive</key>
     <dict>
-        <key>Crashed</key>
-        <true/>
+        <key>SuccessfulExit</key>
+        <false/>
     </dict>
     <key>ThrottleInterval</key>
     <integer>10</integer>
@@ -8774,7 +8798,7 @@ function systemdArgQuote(s) {
   return `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
 }
 function renderSystemdUnit(opts) {
-  const envLines = Object.entries(opts.env).map(([k, v]) => `Environment="${k}=${systemdEnvEscape(v)}"`).join("\n");
+  const envLines = Object.entries(unitEnv(opts.env)).map(([k, v]) => `Environment="${k}=${systemdEnvEscape(v)}"`).join("\n");
   const execStart = [
     systemdArgQuote(opts.nodeBin),
     systemdArgQuote(opts.cliEntry),
@@ -8801,6 +8825,7 @@ var init_unitFiles = __esm({
   "src/daemon/service/unitFiles.ts"() {
     "use strict";
     init_paths();
+    init_supervision();
   }
 });
 
@@ -8852,7 +8877,7 @@ var init_launchctl = __esm({
         if (r.exitCode === 0 || r.exitCode === 17) return;
         if (r.exitCode === 5) {
           await this.opts.spawner.run("launchctl", ["bootout", SERVICE_TARGET(this.opts.uid)]);
-          await new Promise((resolve5) => setTimeout(resolve5, 500));
+          await new Promise((resolve6) => setTimeout(resolve6, 500));
           r = await bootstrap();
           if (r.exitCode === 0 || r.exitCode === 17) return;
         }
@@ -8997,6 +9022,13 @@ var init_systemctl = __esm({
 });
 
 // src/daemon/service/serviceController.ts
+var serviceController_exports = {};
+__export(serviceController_exports, {
+  orchestrateStart: () => orchestrateStart,
+  orchestrateStop: () => orchestrateStop,
+  pickController: () => pickController,
+  reinstallIfChanged: () => reinstallIfChanged
+});
 import { userInfo } from "node:os";
 function pickController(platform3 = process.platform, env = process.env, spawner = execaSpawner) {
   const unitPath = resolveUnitPath(platform3, env);
@@ -9231,7 +9263,7 @@ async function tailLog(opts = {}) {
     }
   }
   if (!opts.follow) return;
-  await new Promise((resolve5, reject) => {
+  await new Promise((resolve6, reject) => {
     let fileWatcher = null;
     let dirWatcher = null;
     const dir = dirname6(path7);
@@ -9295,7 +9327,7 @@ async function tailLog(opts = {}) {
     const handleSigint = () => {
       fileWatcher?.close();
       dirWatcher?.close();
-      resolve5();
+      resolve6();
     };
     process.once("SIGINT", handleSigint);
   });
@@ -14192,15 +14224,17 @@ async function acquireSingleInstanceLock(pidfile) {
     }
   };
 }
-var SingleInstanceLockedError;
+var SINGLE_INSTANCE_EXIT_CODE, LOCK_HELD_MESSAGE, SingleInstanceLockedError;
 var init_singleInstanceLock = __esm({
   "src/daemon/service/singleInstanceLock.ts"() {
     "use strict";
+    SINGLE_INSTANCE_EXIT_CODE = 64;
+    LOCK_HELD_MESSAGE = "already holds";
     SingleInstanceLockedError = class extends Error {
       heldByPid;
       constructor(pidfile, heldByPid) {
         super(
-          heldByPid != null ? `another archme daemon already holds ${pidfile} (pid ${heldByPid})` : `another archme daemon already holds ${pidfile}`
+          heldByPid != null ? `another archme daemon ${LOCK_HELD_MESSAGE} ${pidfile} (pid ${heldByPid})` : `another archme daemon ${LOCK_HELD_MESSAGE} ${pidfile}`
         );
         this.heldByPid = heldByPid;
         this.name = "SingleInstanceLockedError";
@@ -14231,7 +14265,7 @@ var init_semaphore = __esm({
       acquire() {
         const slot = this.tryAcquire();
         if (slot) return Promise.resolve(slot);
-        return new Promise((resolve5) => this.waiters.push(resolve5));
+        return new Promise((resolve6) => this.waiters.push(resolve6));
       }
       makeRelease() {
         let released = false;
@@ -15687,7 +15721,6 @@ import { randomUUID } from "node:crypto";
 import { mkdtemp as mkdtemp3, mkdir as mkdir10, writeFile as writeFile10, rm as rm6, stat as stat8, chmod as chmod3 } from "node:fs/promises";
 import { tmpdir as tmpdir3 } from "node:os";
 import { join as join18 } from "node:path";
-import { pathToFileURL } from "node:url";
 import { homedir as homedir5 } from "node:os";
 function attributeKillCause(result, recorded) {
   if (recorded) return recorded;
@@ -16092,12 +16125,12 @@ async function rpcHeartbeat(ctx, jobId, deviceId) {
   );
   if (error) console.error(`[${jobId}] heartbeat error:`, error.message);
 }
-async function rpcComplete(ctx, jobId, deviceId, summary, kind, changed, metrics, logs, advanceMarker = true, affected) {
+async function rpcComplete(ctx, jobId, deviceId, summary2, kind, changed, metrics, logs, advanceMarker = true, affected) {
   const extra = {
     // `kind` drives lifecycle (squash, marker, retry). `changed` is the
     // decoupled what-changed verdict the Check Run / sticky comment render
     // (migration 083): a structural-only job is kind=applied but changed=false.
-    result: { summary, kind, changed },
+    result: { summary: summary2, kind, changed },
     metrics,
     logs,
     advance_marker: advanceMarker
@@ -16631,8 +16664,8 @@ async function runJob(ctx, job, claimDeviceId) {
     if (runResult.isError) {
       throw new Error(`claude reported is_error in its JSON result (no successful completion)`);
     }
-    const summary = runResult.summary.trim().slice(0, 4e3);
-    if (summary) log(`claude> ${summary.slice(0, 500).replace(/\n/g, " ")}`);
+    const summary2 = runResult.summary.trim().slice(0, 4e3);
+    if (summary2) log(`claude> ${summary2.slice(0, 500).replace(/\n/g, " ")}`);
     metrics.model_served = runResult.modelServed;
     metrics.usage = runResult.usage;
     metrics.cost_usd = runResult.costUsd;
@@ -16659,7 +16692,7 @@ async function runJob(ctx, job, claimDeviceId) {
       throw new Error(outcome.reason);
     }
     const changed = outcome.changed;
-    log(`done (${outcome.kind}, changed=${changed}, ${writes} commit(s) [${diffWrites} diff / ${structuralWrites} structural], ${reads ?? "?"} mcp tool call(s)): ${summary.slice(0, 200).replace(/\n/g, " ")}`);
+    log(`done (${outcome.kind}, changed=${changed}, ${writes} commit(s) [${diffWrites} diff / ${structuralWrites} structural], ${reads ?? "?"} mcp tool call(s)): ${summary2.slice(0, 200).replace(/\n/g, " ")}`);
     const totalMs = Date.now() - startedAt;
     markPhase("complete", { kind: outcome.kind, changed, total_ms: totalMs });
     metrics.total_ms = totalMs;
@@ -16667,7 +16700,7 @@ async function runJob(ctx, job, claimDeviceId) {
       ctx,
       job.id,
       deviceId,
-      summary,
+      summary2,
       outcome.kind,
       changed,
       metrics,
@@ -16876,6 +16909,11 @@ async function signInAccount(creds, makeAuth) {
   }
   return { active, lastErr, usedFallback };
 }
+function exitDaemon(code) {
+  const notice = supervisedStopNotice(code, process.env);
+  if (notice) console.error(notice);
+  process.exit(resolveExitCode(code, process.env));
+}
 async function runDaemon() {
   let lockHandle = null;
   try {
@@ -16883,7 +16921,7 @@ async function runDaemon() {
   } catch (err2) {
     if (err2 instanceof SingleInstanceLockedError) {
       console.error(String(err2.message));
-      process.exit(64);
+      process.exit(SINGLE_INSTANCE_EXIT_CODE);
     }
     throw err2;
   }
@@ -16899,7 +16937,7 @@ async function runDaemon() {
         } catch {
         }
       }
-      process.exit(1);
+      exitDaemon(1);
     }
     throw err2;
   }
@@ -16930,7 +16968,7 @@ async function runDaemon() {
       } catch {
       }
     }
-    process.exit(2);
+    exitDaemon(2);
   }
   let credentials;
   try {
@@ -16944,7 +16982,7 @@ async function runDaemon() {
         } catch {
         }
       }
-      process.exit(78);
+      exitDaemon(78);
     }
     throw err2;
   }
@@ -16959,7 +16997,7 @@ async function runDaemon() {
       } catch {
       }
     }
-    process.exit(75);
+    exitDaemon(75);
   }
   const auth = active.auth;
   const client = createClient(SUPABASE_URL, SUPABASE_ANON_KEY, {
@@ -17141,6 +17179,7 @@ var init_run = __esm({
     init_dispatch();
     init_defaults();
     init_singleInstanceLock();
+    init_supervision();
     init_paths();
     init_semaphore();
     init_bearer();
@@ -17341,12 +17380,6 @@ ${ANCHOR_VERIFICATION}`;
         return daemonVersion;
       }
     };
-    if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
-      runDaemon().catch((err2) => {
-        console.error("fatal:", err2);
-        process.exit(1);
-      });
-    }
   }
 });
 
@@ -18138,14 +18171,14 @@ async function runScan(opts, deps = {}) {
   log(`  supabase: ${supabaseUrl}`);
   log(`  mcp base: ${mcpUrl}`);
   log(`  repo:     ${opts.repoPath}`);
-  const authed = await createAuthedClient({
+  const authed2 = await createAuthedClient({
     supabaseUrl,
     supabaseAnonKey: supabaseAnon,
     clientId,
     preSpawnMinLifetimeMs: SCAN_PRE_SPAWN_TOKEN_MIN_LIFETIME_MS
   });
-  log(`  signed in as ${authed.identity}`);
-  const { supabase, userId } = authed;
+  log(`  signed in as ${authed2.identity}`);
+  const { supabase, userId } = authed2;
   let headSha;
   try {
     headSha = await repoHeadSha(opts.repoPath);
@@ -18244,7 +18277,7 @@ async function runScan(opts, deps = {}) {
     const result = await proc;
     const exitCode = result.exitCode ?? 0;
     const signal = result.signal ?? null;
-    const summary = (finalResultText || (result.stdout ? String(result.stdout) : "")).trim().slice(-4e3);
+    const summary2 = (finalResultText || (result.stdout ? String(result.stdout) : "")).trim().slice(-4e3);
     if (signal) {
       log(`claude exited ${exitCode} (signal: ${signal})`);
     } else {
@@ -18255,8 +18288,8 @@ async function runScan(opts, deps = {}) {
     log(`  stories:    ${counts.stories}`);
     let signals2 = null;
     try {
-      await new Promise((resolve5, reject) => {
-        transcriptStream.end((err2) => err2 ? reject(err2) : resolve5());
+      await new Promise((resolve6, reject) => {
+        transcriptStream.end((err2) => err2 ? reject(err2) : resolve6());
       });
       const reportPath = join19(transcriptDir, "report.json");
       const orphansTxtPath = join19(transcriptDir, "orphans.txt");
@@ -18322,7 +18355,7 @@ async function runScan(opts, deps = {}) {
       orgSlug: resolved2.orgSlug,
       projectSlug: resolved2.projectSlug,
       webUrl,
-      summary
+      summary: summary2
     };
   } finally {
     await cleanupMcp().catch(() => {
@@ -18933,6 +18966,9 @@ var init_githubAppSetup = __esm({
 
 // src/daemon/prompt.ts
 import { createInterface } from "node:readline/promises";
+function stdinIsInteractive() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
 async function withReadline(fn) {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
   try {
@@ -19215,9 +19251,9 @@ async function runLocalWatch(opts) {
   log(`  repo:   ${target.repo}`);
   log(`  branch: ${target.repoBranch} \u2192 archme branch ${target.archmeBranch}`);
   const cfg = resolveConfig();
-  let authed;
+  let authed2;
   try {
-    authed = await createAuthedClient({
+    authed2 = await createAuthedClient({
       supabaseUrl: cfg.supabaseUrl,
       supabaseAnonKey: cfg.supabaseAnonKey,
       clientId: cfg.archmeDaemonClientId,
@@ -19227,8 +19263,8 @@ async function runLocalWatch(opts) {
     console.error(`archme local-watch: ${err2 instanceof Error ? err2.message : String(err2)}`);
     return 3;
   }
-  const { supabase, userId } = authed;
-  const orgId = authed.orgId;
+  const { supabase, userId } = authed2;
+  const orgId = authed2.orgId;
   if (!orgId) {
     console.error("archme local-watch: this login is not paired with an org \u2014 run `archme login`");
     return 3;
@@ -19468,22 +19504,22 @@ async function runInit(opts, deps = {}) {
   } else {
     log("\u2713 already signed in");
   }
-  const authed = await authenticate({
+  const authed2 = await authenticate({
     supabaseUrl: cfg.supabaseUrl,
     supabaseAnonKey: cfg.supabaseAnonKey,
     clientId: cfg.archmeDaemonClientId,
     preSpawnMinLifetimeMs: SCAN_PRE_SPAWN_TOKEN_MIN_LIFETIME_MS
   });
-  log(`  signed in as ${authed.identity}`);
+  log(`  signed in as ${authed2.identity}`);
   let fullSlug = opts.project;
   if (!fullSlug) {
-    const orgId = authed.orgId;
+    const orgId = authed2.orgId;
     if (!orgId) {
       throw new Error(
         "could not resolve your organization \u2014 run `archme login` again, or pass --project <org>/<slug>"
       );
     }
-    const orgSlug = await resolveOrgSlug(authed.supabase, orgId);
+    const orgSlug = await resolveOrgSlug(authed2.supabase, orgId);
     if (!orgSlug) {
       throw new Error(
         `paired org ${orgId} no longer exists \u2014 run \`archme login\` again, or pass --project <org>/<slug>`
@@ -19492,8 +19528,8 @@ async function runInit(opts, deps = {}) {
     fullSlug = defaultProjectSlug(orgSlug, repoPath);
   }
   const project = await resolveProject(
-    authed.supabase,
-    authed.userId,
+    authed2.supabase,
+    authed2.userId,
     fullSlug
   );
   log(
@@ -19501,7 +19537,7 @@ async function runInit(opts, deps = {}) {
   );
   const scanBranch = initScanBranch(project.defaultBranch);
   const detail = await fetchArchitecture(
-    authed.supabase,
+    authed2.supabase,
     project.projectId,
     scanBranch
   );
@@ -19515,8 +19551,8 @@ async function runInit(opts, deps = {}) {
   await runInstallScript(script, repoPath);
   ran.push("agent-config");
   const watched = await watchRepo({
-    supabase: authed.supabase,
-    orgId: authed.orgId,
+    supabase: authed2.supabase,
+    orgId: authed2.orgId,
     projectId: project.projectId,
     repoSlug: git4.repoSlug,
     branch: git4.branch,
@@ -19583,18 +19619,18 @@ Your board: ${webUrl}`);
         startGitHubAppInstall: () => (deps.buildInstallUrl ?? buildInstallUrl)({
           supabaseUrl: cfg.supabaseUrl,
           accessToken: getCurrentAccessToken() ?? "",
-          orgId: authed.orgId
+          orgId: authed2.orgId
         }),
         waitForInstallation: () => (deps.waitForInstallation ?? waitForInstallation)({
-          hasInstallation: () => (deps.orgHasInstallation ?? orgHasInstallation)(authed.supabase, authed.orgId),
+          hasInstallation: () => (deps.orgHasInstallation ?? orgHasInstallation)(authed2.supabase, authed2.orgId),
           sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
           now: () => Date.now(),
           log
         }),
         watchRepo: async () => {
           const w = await watchRepo({
-            supabase: authed.supabase,
-            orgId: authed.orgId,
+            supabase: authed2.supabase,
+            orgId: authed2.orgId,
             projectId: project.projectId,
             repoSlug: git4.repoSlug,
             branch: git4.branch,
@@ -19616,8 +19652,8 @@ Your board: ${webUrl}`);
           });
           if (!target.ok) return { ok: false, reason: target.error };
           const res = await (deps.registerLocalWatch ?? registerLocalWatch)({
-            supabase: authed.supabase,
-            orgId: authed.orgId,
+            supabase: authed2.supabase,
+            orgId: authed2.orgId,
             projectId: project.projectId,
             repoPath: git4.root,
             originUrl: git4.originUrl,
@@ -19826,12 +19862,575 @@ var init_dispatch4 = __esm({
   }
 });
 
+// src/uninstall/edits.ts
+function stripArchmeClaudeBlock(content) {
+  const start = content.indexOf(START_MARKER);
+  if (start === -1) return UNCHANGED;
+  const end = content.indexOf(END_MARKER, start);
+  if (end === -1) return UNCHANGED;
+  const before = content.slice(0, start).replace(/\n+$/, "");
+  const after = content.slice(end + END_MARKER.length).replace(/^\n+/, "");
+  if (!before.trim() && !after.trim()) return { kind: "delete" };
+  if (!before.trim()) return { kind: "rewrite", content: `${after.replace(/\n*$/, "")}
+` };
+  if (!after.trim()) return { kind: "rewrite", content: `${before}
+` };
+  return { kind: "rewrite", content: `${before}
+
+${after.replace(/\n*$/, "")}
+` };
+}
+function parseObject(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function render(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function stripArchmeMcpServer(content) {
+  const root = parseObject(content);
+  if (!root) return UNCHANGED;
+  const servers = root.mcpServers;
+  if (!servers || typeof servers !== "object" || Array.isArray(servers)) return UNCHANGED;
+  const entries = servers;
+  if (!(MCP_SERVER_NAME2 in entries)) return UNCHANGED;
+  delete entries[MCP_SERVER_NAME2];
+  const onlyKey = Object.keys(root).length === 1 && "mcpServers" in root;
+  if (onlyKey && Object.keys(entries).length === 0) return { kind: "delete" };
+  return { kind: "rewrite", content: render(root) };
+}
+function isArchmeHook(hook) {
+  const command = hook?.command;
+  return typeof command === "string" && command.includes(NUDGE_HOOK_FILE);
+}
+function stripArchmeHooks(content) {
+  const root = parseObject(content);
+  if (!root) return UNCHANGED;
+  const hooks = root.hooks;
+  if (!hooks || typeof hooks !== "object" || Array.isArray(hooks)) return UNCHANGED;
+  const byEvent = hooks;
+  const pre = byEvent.PreToolUse;
+  if (!Array.isArray(pre)) return UNCHANGED;
+  let changed = false;
+  const kept = [];
+  for (const entry of pre) {
+    const inner = entry?.hooks;
+    if (!Array.isArray(inner) || !inner.some(isArchmeHook)) {
+      kept.push(entry);
+      continue;
+    }
+    changed = true;
+    const survivors = inner.filter((h2) => !isArchmeHook(h2));
+    if (survivors.length > 0) kept.push({ ...entry, hooks: survivors });
+  }
+  if (!changed) return UNCHANGED;
+  if (kept.length > 0) byEvent.PreToolUse = kept;
+  else delete byEvent.PreToolUse;
+  if (Object.keys(byEvent).length === 0) delete root.hooks;
+  if (Object.keys(root).length === 0) return { kind: "delete" };
+  return { kind: "rewrite", content: render(root) };
+}
+var UNCHANGED, START_MARKER, END_MARKER, NUDGE_HOOK_FILE, MCP_SERVER_NAME2;
+var init_edits = __esm({
+  "src/uninstall/edits.ts"() {
+    "use strict";
+    UNCHANGED = { kind: "unchanged" };
+    START_MARKER = "<!-- ARCHME-START -->";
+    END_MARKER = "<!-- ARCHME-END -->";
+    NUDGE_HOOK_FILE = "archme-search-nudge.mjs";
+    MCP_SERVER_NAME2 = "archme";
+  }
+});
+
+// src/uninstall/watching.ts
+function decideDaemonRemoval(input) {
+  if (!input.installed) {
+    return { action: "keep", reason: "no daemon service is installed on this machine" };
+  }
+  if (input.keepWatching) {
+    return { action: "keep", reason: "--keep-watching: this repo is still being watched" };
+  }
+  if (input.remaining.watchedRepos === null) {
+    return {
+      action: "keep",
+      reason: "could not check what else it serves, so it was left running"
+    };
+  }
+  const { watchedRepos, localEntries } = input.remaining;
+  if (watchedRepos > 0 || localEntries > 0) {
+    const parts = [];
+    if (watchedRepos > 0) parts.push(`${watchedRepos} watched repo${watchedRepos === 1 ? "" : "s"}`);
+    if (localEntries > 0) {
+      parts.push(`${localEntries} locally-polled repo${localEntries === 1 ? "" : "s"}`);
+    }
+    return { action: "keep", reason: `still serving ${parts.join(" and ")}` };
+  }
+  return { action: "remove", reason: "nothing is left for it to do" };
+}
+function rowsForSlug(rows, slug) {
+  const wanted = slug.toLowerCase();
+  return rows.filter((r) => r.slug.toLowerCase() === wanted);
+}
+var init_watching = __esm({
+  "src/uninstall/watching.ts"() {
+    "use strict";
+  }
+});
+
+// src/uninstall/backend.ts
+var backend_exports = {};
+__export(backend_exports, {
+  createDefaultBackend: () => createDefaultBackend
+});
+function labelFor(row) {
+  const org = row.projects?.organizations?.slug;
+  const project = row.projects?.slug;
+  const where = org && project ? `${org}/${project}` : `${row.repo_owner}/${row.repo_name}`;
+  return `${where} @ ${row.branch}`;
+}
+function createDefaultBackend() {
+  let clientPromise = null;
+  const supabase = () => clientPromise ??= authed();
+  return {
+    async gitRoot(dir) {
+      try {
+        const { stdout } = await execa("git", ["rev-parse", "--show-toplevel"], { cwd: dir });
+        return stdout.trim() || null;
+      } catch {
+        return null;
+      }
+    },
+    async repoSlug(repoPath) {
+      const origin = await readOriginUrl(repoPath);
+      return origin ? parseGitHubRepo(origin) : null;
+    },
+    async listWatchedRepos() {
+      const { supabase: client } = await supabase();
+      const { data, error } = await client.from("watched_repos").select("id, repo_owner, repo_name, branch, projects(slug, organizations(slug))").is("deleted_at", null);
+      if (error) throw new Error(error.message);
+      return (data ?? []).map((row) => ({
+        id: row.id,
+        slug: `${row.repo_owner}/${row.repo_name}`,
+        label: labelFor(row)
+      }));
+    },
+    async unwatch(ids) {
+      if (ids.length === 0) return;
+      const { supabase: client } = await supabase();
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const { error } = await client.from("watched_repos").update({ deleted_at: now, updated_at: now }).in("id", ids);
+      if (error) throw new Error(error.message);
+    },
+    async localRepoSlugs() {
+      return (await loadLocalRepos()).map((e) => slugOf(e));
+    },
+    async removeLocalRepos(slug) {
+      const repos = await loadLocalRepos();
+      const kept = removeLocalReposBySlug(repos, slug);
+      const dropped = repos.length - kept.length;
+      if (dropped > 0) await saveLocalRepos(kept);
+      return dropped;
+    },
+    async daemonInstalled() {
+      const { pickController: pickController2 } = await Promise.resolve().then(() => (init_serviceController(), serviceController_exports));
+      return await pickController2().unitExists();
+    },
+    async removeDaemon() {
+      const { pickController: pickController2, orchestrateStop: orchestrateStop2 } = await Promise.resolve().then(() => (init_serviceController(), serviceController_exports));
+      const controller = pickController2();
+      await orchestrateStop2(controller);
+      await controller.uninstall();
+    }
+  };
+}
+async function authed() {
+  const cfg = resolveConfig();
+  return await createAuthedClient({
+    supabaseUrl: cfg.supabaseUrl,
+    supabaseAnonKey: cfg.supabaseAnonKey,
+    clientId: cfg.archmeDaemonClientId,
+    preSpawnMinLifetimeMs: SCAN_PRE_SPAWN_TOKEN_MIN_LIFETIME_MS
+  });
+}
+var init_backend = __esm({
+  "src/uninstall/backend.ts"() {
+    "use strict";
+    init_execa();
+    init_authedClient();
+    init_defaults();
+    init_localGit();
+    init_github_remote();
+    init_localRepos();
+  }
+});
+
+// src/uninstall/run-uninstall.ts
+var run_uninstall_exports = {};
+__export(run_uninstall_exports, {
+  EX_OK: () => EX_OK3,
+  EX_USAGE: () => EX_USAGE3,
+  runUninstall: () => runUninstall
+});
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join23 } from "node:path";
+function readIfExists(path7) {
+  try {
+    return existsSync3(path7) ? readFileSync5(path7, "utf8") : null;
+  } catch {
+    return null;
+  }
+}
+function isParseableObject(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return Boolean(parsed) && typeof parsed === "object" && !Array.isArray(parsed);
+  } catch {
+    return false;
+  }
+}
+function applyEdit(absolute, edit) {
+  if (edit.kind === "rewrite") writeFileSync3(absolute, edit.content);
+  else if (edit.kind === "delete") rmSync(absolute, { force: true });
+}
+async function runUninstall(opts) {
+  const log = opts.log ?? ((m) => console.log(m));
+  const error = opts.error ?? ((m) => console.error(m));
+  const backend = opts.backend ?? await defaultBackend();
+  const repoPath = await backend.gitRoot(opts.repoPath).catch(() => null) ?? opts.repoPath;
+  if (repoPath !== opts.repoPath) log(`Using the repo root: ${repoPath}`);
+  const abs = (rel) => join23(repoPath, rel);
+  const actions = [];
+  const skipped = [];
+  const mcpRaw = readIfExists(abs(".mcp.json"));
+  if (mcpRaw !== null) {
+    const edit = stripArchmeMcpServer(mcpRaw);
+    if (edit.kind !== "unchanged") {
+      actions.push({
+        path: ".mcp.json",
+        label: edit.kind === "delete" ? `delete (it holds only the ${MCP_SERVER_NAME2} server)` : `remove the ${MCP_SERVER_NAME2} server`,
+        apply: () => applyEdit(abs(".mcp.json"), edit)
+      });
+    } else if (!isParseableObject(mcpRaw)) {
+      skipped.push(
+        `.mcp.json \u2014 could not be parsed as JSON; if it has an ${MCP_SERVER_NAME2} server, remove it by hand`
+      );
+    }
+  }
+  const claudeRaw = readIfExists(abs("CLAUDE.md"));
+  if (claudeRaw !== null) {
+    const edit = stripArchmeClaudeBlock(claudeRaw);
+    if (edit.kind !== "unchanged") {
+      actions.push({
+        path: "CLAUDE.md",
+        label: edit.kind === "delete" ? "delete (it holds only the ArchitectMe block)" : "remove the ArchitectMe block",
+        apply: () => applyEdit(abs("CLAUDE.md"), edit)
+      });
+    } else if (claudeRaw.includes(START_MARKER)) {
+      skipped.push("CLAUDE.md \u2014 the ArchitectMe block has no closing marker; remove it by hand");
+    }
+  }
+  const skillPath = ".claude/skills/architecture/SKILL.md";
+  if (existsSync3(abs(skillPath))) {
+    actions.push({
+      path: skillPath,
+      label: "delete the architecture skill",
+      apply: () => rmSync(abs(skillPath), { force: true })
+    });
+  }
+  const hookPath = `.claude/hooks/${NUDGE_HOOK_FILE}`;
+  if (existsSync3(abs(hookPath))) {
+    actions.push({
+      path: hookPath,
+      label: "delete the retired search-nudge hook",
+      apply: () => rmSync(abs(hookPath), { force: true })
+    });
+  }
+  const settingsRaw = readIfExists(abs(".claude/settings.json"));
+  if (settingsRaw !== null) {
+    const edit = stripArchmeHooks(settingsRaw);
+    if (edit.kind !== "unchanged") {
+      actions.push({
+        path: ".claude/settings.json",
+        label: edit.kind === "delete" ? "delete (it holds only the ArchitectMe hook)" : "unregister the search-nudge hook",
+        apply: () => applyEdit(abs(".claude/settings.json"), edit)
+      });
+    } else if (!isParseableObject(settingsRaw)) {
+      skipped.push(
+        ".claude/settings.json \u2014 could not be parsed as JSON; if it registers the ArchMe hook, remove that entry by hand"
+      );
+    }
+  }
+  for (const note of skipped) log(`Left alone: ${note}`);
+  const keepWatching = opts.keepWatching ?? false;
+  const slug = keepWatching ? null : await backend.repoSlug(repoPath).catch(() => null);
+  let allWatched = null;
+  let watchLookupError = null;
+  if (slug) {
+    try {
+      allWatched = await backend.listWatchedRepos();
+    } catch (err2) {
+      watchLookupError = err2 instanceof Error ? err2.message : String(err2);
+    }
+  }
+  const toUnwatch = allWatched ? rowsForSlug(allWatched, slug) : [];
+  let localForSlug = 0;
+  let allLocal = [];
+  if (slug) {
+    allLocal = await backend.localRepoSlugs().catch(() => []);
+    localForSlug = allLocal.filter((s) => s.toLowerCase() === slug.toLowerCase()).length;
+  }
+  if (actions.length === 0 && toUnwatch.length === 0 && localForSlug === 0) {
+    log(`No ArchitectMe agent config found in ${repoPath}. Nothing to remove.`);
+    if (watchLookupError) log(watchingUnknownNote(watchLookupError));
+    return { exitCode: EX_OK3, removed: [], unwatched: [] };
+  }
+  const daemonInstalled = await backend.daemonInstalled().catch(() => false);
+  const plan = [
+    ...actions.map((a2) => `  ${a2.path} \u2014 ${a2.label}`),
+    ...toUnwatch.map((r) => `  ${r.label} \u2014 stop watching (no more commits will update it)`),
+    ...localForSlug > 0 ? [`  ${slug} \u2014 stop polling from this machine (${localForSlug} registry entry)`] : [],
+    // Stated up front, not just reported after: a repo-scoped command removing
+    // a machine-wide service is the most surprising thing here. Whether it
+    // actually goes is still decided afterwards, against what really happened.
+    ...daemonInstalled && !keepWatching ? ["  the daemon service \u2014 removed only if this leaves it nothing to serve"] : []
+  ];
+  if (!opts.yes) {
+    const interactive = opts.interactive ?? stdinIsInteractive();
+    if (!interactive && !opts.confirm) {
+      error(
+        "archme uninstall: refusing to edit files without confirmation.\nThere is nobody to ask (stdin is not a terminal). Re-run with --yes."
+      );
+      return { exitCode: EX_USAGE3, removed: [], unwatched: [] };
+    }
+    const confirm = opts.confirm ?? (async (lines) => {
+      log(`This will change, in ${repoPath} and on your ArchMe account:
+`);
+      lines.forEach((l) => log(l));
+      log("");
+      return await promptYesNo("Uninstall ArchitectMe for this repo?");
+    });
+    if (!await confirm(plan)) {
+      log("Cancelled \u2014 nothing was changed.");
+      return { exitCode: EX_OK3, removed: [], unwatched: [] };
+    }
+  }
+  const removed = [];
+  for (const action of actions) {
+    action.apply();
+    removed.push(action.path);
+    log(`Removed: ${action.path} \u2014 ${action.label}`);
+  }
+  for (const dir of PRUNABLE_DIRS) {
+    const path7 = abs(dir);
+    try {
+      if (existsSync3(path7) && readdirSync(path7).length === 0) rmSync(path7, { recursive: true });
+    } catch {
+    }
+  }
+  const unwatched = [];
+  if (toUnwatch.length > 0) {
+    try {
+      await backend.unwatch(toUnwatch.map((r) => r.id));
+      unwatched.push(...toUnwatch.map((r) => r.id));
+      for (const row of toUnwatch) log(`Stopped watching: ${row.label}`);
+    } catch (err2) {
+      watchLookupError = err2 instanceof Error ? err2.message : String(err2);
+    }
+  }
+  let localRemoved = 0;
+  if (slug && localForSlug > 0) {
+    try {
+      localRemoved = await backend.removeLocalRepos(slug);
+      if (localRemoved > 0) log(`Stopped local polling: ${slug}`);
+    } catch {
+      log(`Could not update the local watch registry \u2014 \`archme local-watch --stop ${slug}\` will.`);
+    }
+  }
+  const unwatchFailed = watchLookupError !== null;
+  const remaining = {
+    watchedRepos: allWatched && !unwatchFailed ? allWatched.length - unwatched.length : null,
+    localEntries: allLocal.length - localRemoved
+  };
+  const daemonPlan = decideDaemonRemoval({ installed: daemonInstalled, keepWatching, remaining });
+  if (daemonPlan.action === "remove") {
+    try {
+      await backend.removeDaemon();
+      log(`Removed the daemon service \u2014 ${daemonPlan.reason}.`);
+    } catch (err2) {
+      log(
+        `Could not remove the daemon service (${err2 instanceof Error ? err2.message : String(err2)}).
+  archme daemon uninstall`
+      );
+    }
+  } else {
+    log(`Daemon left in place \u2014 ${daemonPlan.reason}.`);
+  }
+  log(
+    summary({
+      keepWatching,
+      slug,
+      unwatchFailed,
+      watchLookupError,
+      removedConfig: removed.length > 0,
+      checkedAndNotWatched: Boolean(slug) && !unwatchFailed && toUnwatch.length === 0
+    })
+  );
+  return { exitCode: EX_OK3, removed, unwatched };
+}
+function watchingUnknownNote(reason) {
+  return `
+Could not check whether this repo is still being watched (${reason}).
+If it is, commits will keep updating the architecture. Sign in and re-run to stop it:
+  archme login && archme uninstall`;
+}
+function summary(input) {
+  const lines = input.removedConfig ? ["\nArchitectMe agent config removed from this repo."] : ["\nNo ArchitectMe agent config was here to remove."];
+  if (input.keepWatching) {
+    lines.push(
+      "This repo is STILL being watched (--keep-watching), so commits keep updating its architecture."
+    );
+  } else if (input.unwatchFailed && input.watchLookupError) {
+    lines.push(watchingUnknownNote(input.watchLookupError).trimStart());
+  } else if (!input.slug) {
+    lines.push(
+      "No github.com remote here, so there was no watched repo to stop. Check archme.io \u2192 Settings \u2192 Integrations if you expected one."
+    );
+  } else if (input.checkedAndNotWatched) {
+    lines.push(`${input.slug} was not being watched, so no commits were updating it.`);
+  }
+  lines.push(
+    "\nYour architecture on archme.io and this machine's login are untouched:",
+    "  archme logout                            sign this machine out",
+    "\nThe GitHub App installation is org-wide, so it stays. Remove it on github.com if you want it gone."
+  );
+  return lines.join("\n");
+}
+async function defaultBackend() {
+  const { createDefaultBackend: createDefaultBackend2 } = await Promise.resolve().then(() => (init_backend(), backend_exports));
+  return createDefaultBackend2();
+}
+var EX_OK3, EX_USAGE3, PRUNABLE_DIRS;
+var init_run_uninstall = __esm({
+  "src/uninstall/run-uninstall.ts"() {
+    "use strict";
+    init_prompt();
+    init_edits();
+    init_watching();
+    EX_OK3 = 0;
+    EX_USAGE3 = 78;
+    PRUNABLE_DIRS = [
+      ".claude/skills/architecture",
+      ".claude/skills",
+      ".claude/hooks",
+      ".claude"
+    ];
+  }
+});
+
+// src/uninstall/dispatch.ts
+var dispatch_exports5 = {};
+__export(dispatch_exports5, {
+  EX_INFRA: () => EX_INFRA3,
+  EX_OK: () => EX_OK4,
+  EX_USAGE: () => EX_USAGE4,
+  dispatchUninstall: () => dispatchUninstall,
+  parseUninstallArgs: () => parseUninstallArgs,
+  printUninstallHelp: () => printUninstallHelp
+});
+import { resolve as resolve5 } from "node:path";
+function parseUninstallArgs(argv) {
+  if (argv.some((a2) => a2 === "--help" || a2 === "-h" || a2 === "help")) return { kind: "help" };
+  let repoPath;
+  let yes = false;
+  let keepWatching = false;
+  for (const arg of argv) {
+    if (arg === "--yes" || arg === "-y") {
+      yes = true;
+    } else if (arg === "--keep-watching") {
+      keepWatching = true;
+    } else if (arg.startsWith("-")) {
+      return { kind: "error", message: `unknown option '${arg}'` };
+    } else if (repoPath === void 0) {
+      repoPath = arg;
+    } else {
+      return { kind: "error", message: `unexpected argument '${arg}'` };
+    }
+  }
+  return { kind: "run", repoPath, yes, keepWatching };
+}
+function printUninstallHelp() {
+  console.log(`archme uninstall \u2014 stop ArchitectMe for a repo
+
+Undoes what \`archme init\` set up, and shows you the whole list before it does:
+
+  1. Agent config \u2014 the archme MCP server in .mcp.json, the ArchitectMe block in
+     CLAUDE.md, the architecture skill, and the retired search-nudge hook older
+     versions registered in .claude/settings.json.
+  2. Watching \u2014 stops this repo producing jobs, both via the GitHub App and via
+     local polling. Without this the board keeps updating while looking removed.
+  3. The daemon \u2014 removed only if it has no other repo left to serve. It is one
+     service per account, so uninstalling one repo never stops the others.
+
+Your architecture on archme.io and this machine's login survive. The GitHub App
+installation is org-wide and stays; remove it on github.com if you want it gone.
+
+Usage:
+  archme uninstall [repo-path] [options]
+
+  repo-path              Defaults to the current directory.
+
+Options:
+  -y, --yes              Do not ask for confirmation
+      --keep-watching    Remove the agent config only; leave the repo watched
+                         and the daemon running
+  -h, --help             Show this help`);
+}
+async function dispatchUninstall(argv) {
+  const parsed = parseUninstallArgs(argv);
+  if (parsed.kind === "help") {
+    printUninstallHelp();
+    return EX_OK4;
+  }
+  if (parsed.kind === "error") {
+    console.error(`archme uninstall: ${parsed.message}`);
+    printUninstallHelp();
+    return EX_USAGE4;
+  }
+  try {
+    const { runUninstall: runUninstall2 } = await Promise.resolve().then(() => (init_run_uninstall(), run_uninstall_exports));
+    const result = await runUninstall2({
+      repoPath: resolve5(parsed.repoPath ?? process.cwd()),
+      yes: parsed.yes,
+      keepWatching: parsed.keepWatching
+    });
+    return result.exitCode;
+  } catch (err2) {
+    console.error(`archme uninstall: ${err2 instanceof Error ? err2.message : String(err2)}`);
+    return EX_INFRA3;
+  }
+}
+var EX_OK4, EX_INFRA3, EX_USAGE4;
+var init_dispatch5 = __esm({
+  "src/uninstall/dispatch.ts"() {
+    "use strict";
+    EX_OK4 = 0;
+    EX_INFRA3 = 3;
+    EX_USAGE4 = 78;
+  }
+});
+
 // src/daemon/localWatchDispatch.ts
 var localWatchDispatch_exports = {};
 __export(localWatchDispatch_exports, {
-  EX_INFRA: () => EX_INFRA3,
-  EX_OK: () => EX_OK3,
-  EX_USAGE: () => EX_USAGE3,
+  EX_INFRA: () => EX_INFRA4,
+  EX_OK: () => EX_OK5,
+  EX_USAGE: () => EX_USAGE5,
   dispatchLocalWatch: () => dispatchLocalWatch,
   parseLocalWatchArgs: () => parseLocalWatchArgs,
   printLocalWatchHelp: () => printLocalWatchHelp
@@ -19921,12 +20520,12 @@ async function dispatchLocalWatch(argv) {
   const parsed = parseLocalWatchArgs(argv);
   if (parsed.kind === "help") {
     printLocalWatchHelp();
-    return EX_OK3;
+    return EX_OK5;
   }
   if (parsed.kind === "error") {
     console.error(parsed.message);
     printLocalWatchHelp();
-    return EX_USAGE3;
+    return EX_USAGE5;
   }
   const mod = await Promise.resolve().then(() => (init_localWatch(), localWatch_exports));
   switch (parsed.kind) {
@@ -19940,13 +20539,13 @@ async function dispatchLocalWatch(argv) {
       return await mod.runLocalWatch(parsed);
   }
 }
-var EX_OK3, EX_INFRA3, EX_USAGE3, PROJECT_SLUG_RE3, REPO_SLUG_RE;
+var EX_OK5, EX_INFRA4, EX_USAGE5, PROJECT_SLUG_RE3, REPO_SLUG_RE;
 var init_localWatchDispatch = __esm({
   "src/daemon/localWatchDispatch.ts"() {
     "use strict";
-    EX_OK3 = 0;
-    EX_INFRA3 = 3;
-    EX_USAGE3 = 78;
+    EX_OK5 = 0;
+    EX_INFRA4 = 3;
+    EX_USAGE5 = 78;
     PROJECT_SLUG_RE3 = /^[^/\s]+\/[^/\s]+$/;
     REPO_SLUG_RE = /^[^/\s]+\/[^/\s]+$/;
   }
@@ -19954,7 +20553,7 @@ var init_localWatchDispatch = __esm({
 
 // src/doctor/collect.ts
 import { readFile as readFile13 } from "node:fs/promises";
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 function binaryPresent(name) {
   try {
     requireBinary(name);
@@ -19970,7 +20569,7 @@ async function git3(cwd, args) {
 async function readMcpPin(repoRoot) {
   const empty = { installed: false, pin: { project: null, branch: null } };
   try {
-    const raw = await readFile13(join23(repoRoot, ".mcp.json"), "utf8");
+    const raw = await readFile13(join24(repoRoot, ".mcp.json"), "utf8");
     const parsed = JSON.parse(raw);
     const servers = parsed.mcpServers ?? {};
     const entry = Object.entries(servers).find(([name]) => /archme/i.test(name));
@@ -20038,17 +20637,17 @@ async function collectFacts(cwd) {
   );
   try {
     const cfg = resolveConfig();
-    const authed = await createAuthedClient({
+    const authed2 = await createAuthedClient({
       supabaseUrl: cfg.supabaseUrl,
       supabaseAnonKey: cfg.supabaseAnonKey,
       clientId: cfg.archmeDaemonClientId,
       preSpawnMinLifetimeMs: SCAN_PRE_SPAWN_TOKEN_MIN_LIFETIME_MS
     });
-    if (!authed.orgId) return facts;
+    if (!authed2.orgId) return facts;
     facts.signedIn = true;
-    facts.orgId = authed.orgId;
-    facts.identity = authed.identity;
-    const supabase = authed.supabase;
+    facts.orgId = authed2.orgId;
+    facts.identity = authed2.identity;
+    const supabase = authed2.supabase;
     const slug = facts.pinnedProject;
     if (slug) {
       const [orgSlug, projectSlug] = slug.split("/");
@@ -20334,18 +20933,18 @@ optional.`;
 });
 
 // src/doctor/dispatch.ts
-var dispatch_exports5 = {};
-__export(dispatch_exports5, {
-  EX_INFRA: () => EX_INFRA4,
-  EX_OK: () => EX_OK4,
-  EX_USAGE: () => EX_USAGE4,
+var dispatch_exports6 = {};
+__export(dispatch_exports6, {
+  EX_INFRA: () => EX_INFRA5,
+  EX_OK: () => EX_OK6,
+  EX_USAGE: () => EX_USAGE6,
   dispatchDoctor: () => dispatchDoctor,
   parseDoctorArgs: () => parseDoctorArgs,
   printDoctorHelp: () => printDoctorHelp
 });
 import { mkdtemp as mkdtemp5, rm as rm9, writeFile as writeFile13 } from "node:fs/promises";
 import { tmpdir as tmpdir5 } from "node:os";
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 function parseDoctorArgs(argv) {
   const args = { plain: false, help: false };
   for (const a2 of argv) {
@@ -20377,11 +20976,11 @@ async function dispatchDoctor(argv) {
   if (!parsed.ok) {
     console.error(parsed.message);
     printDoctorHelp();
-    return EX_USAGE4;
+    return EX_USAGE6;
   }
   if (parsed.args.help) {
     printDoctorHelp();
-    return EX_OK4;
+    return EX_OK6;
   }
   const facts = await collectFacts(process.cwd());
   const issues = diagnose(facts);
@@ -20397,17 +20996,17 @@ async function dispatchDoctor(argv) {
       console.log("");
     }
   }
-  if (parsed.args.plain) return EX_OK4;
+  if (parsed.args.plain) return EX_OK6;
   try {
     requireBinary("claude");
   } catch {
     console.log(
       "Install Claude Code to ask about any of this:  npm i -g @anthropic-ai/claude-code"
     );
-    return EX_OK4;
+    return EX_OK6;
   }
-  const dir = await mkdtemp5(join24(tmpdir5(), "archme-doctor-"));
-  const mcpConfigPath = join24(dir, "mcp.json");
+  const dir = await mkdtemp5(join25(tmpdir5(), "archme-doctor-"));
+  const mcpConfigPath = join25(dir, "mcp.json");
   await writeFile13(mcpConfigPath, JSON.stringify({ mcpServers: {} }), { mode: 384 });
   try {
     const result = await spawnClaude({
@@ -20420,13 +21019,13 @@ async function dispatchDoctor(argv) {
       // is a much larger surface than the problem justifies.
       allowedTools: ["Read", "Glob", "Grep"]
     });
-    return result.exitCode === 0 ? EX_OK4 : EX_INFRA4;
+    return result.exitCode === 0 ? EX_OK6 : EX_INFRA5;
   } finally {
     await rm9(dir, { recursive: true, force: true });
   }
 }
-var EX_OK4, EX_INFRA4, EX_USAGE4;
-var init_dispatch5 = __esm({
+var EX_OK6, EX_INFRA5, EX_USAGE6;
+var init_dispatch6 = __esm({
   "src/doctor/dispatch.ts"() {
     "use strict";
     init_collect();
@@ -20434,9 +21033,9 @@ var init_dispatch5 = __esm({
     init_prompt2();
     init_spawn_claude();
     init_preflight();
-    EX_OK4 = 0;
-    EX_INFRA4 = 3;
-    EX_USAGE4 = 78;
+    EX_OK6 = 0;
+    EX_INFRA5 = 3;
+    EX_USAGE6 = 78;
   }
 });
 
@@ -20494,6 +21093,7 @@ var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "keys",
   "scan",
   "init",
+  "uninstall",
   "local-watch",
   "doctor"
 ]);
@@ -20592,12 +21192,16 @@ async function main(argv) {
       const { dispatchInit: dispatchInit2 } = await Promise.resolve().then(() => (init_dispatch4(), dispatch_exports4));
       return await dispatchInit2(r.args);
     }
+    case "uninstall": {
+      const { dispatchUninstall: dispatchUninstall2 } = await Promise.resolve().then(() => (init_dispatch5(), dispatch_exports5));
+      return await dispatchUninstall2(r.args);
+    }
     case "local-watch": {
       const { dispatchLocalWatch: dispatchLocalWatch2 } = await Promise.resolve().then(() => (init_localWatchDispatch(), localWatchDispatch_exports));
       return await dispatchLocalWatch2(r.args);
     }
     case "doctor": {
-      const { dispatchDoctor: dispatchDoctor2 } = await Promise.resolve().then(() => (init_dispatch5(), dispatch_exports5));
+      const { dispatchDoctor: dispatchDoctor2 } = await Promise.resolve().then(() => (init_dispatch6(), dispatch_exports6));
       return await dispatchDoctor2(r.args);
     }
     case "logout": {
@@ -20624,6 +21228,8 @@ Other commands:
   archme scan <repo-path>             Single-pass scan into an explicit project/branch
   archme local-watch [repo-path]      Watch a repo without a GitHub App
                                       (--list|--stop|--resume)
+  archme uninstall [repo-path]        Stop ArchitectMe for a repo: config,
+                                      watching, and the daemon if it's now idle
   archme doctor                       Check this machine's setup and explain it
   archme login | logout               Authenticate with archme
   archme keys list|create|revoke      Manage MCP API keys

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archme/cli",
-  "version": "0.4.4",
+  "version": "0.5.0",
   "description": "Map your codebase into a living architecture diagram: run `archme init` in a repo to scan it, `archme daemon start` to keep it current on every commit.",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE",