@archme/cli 0.4.5 → 0.5.1

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
     });
@@ -8877,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;
         }
@@ -9022,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);
@@ -9256,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);
@@ -9320,7 +9327,7 @@ async function tailLog(opts = {}) {
     const handleSigint = () => {
       fileWatcher?.close();
       dirWatcher?.close();
-      resolve5();
+      resolve6();
     };
     process.once("SIGINT", handleSigint);
   });
@@ -12131,21 +12138,32 @@ var init_affected = __esm({
   }
 });
 
+// ../shared/storyNaming.ts
+var STORY_NAMING_GUIDANCE;
+var init_storyNaming = __esm({
+  "../shared/storyNaming.ts"() {
+    STORY_NAMING_GUIDANCE = `Story titles:
+- **Leaves are actions.** A leaf story is a flow, so title it verb + object, imperative: \`sign up with email\`, \`refund a charge\`, \`retry a failed job\`. Not the noun phrase for the same flow (\`email signup\`, \`charge refunds\`, \`failed job retry\`).
+- **Groups are areas.** A parent story is a feature area, so title it as a noun phrase naming what its leaves have in common: \`auth\`, \`billing\`, \`job queue\`. Not an action (\`authenticate users\`).
+- Keep both as short as the hierarchy allows \u2014 the group supplies the context, so a leaf never restates it.
+  - Good: "web app" > "auth" > "sign up with email"
+  - Bad: "new user signs up with email on the web app"
+- **An existing convention wins.** If a story's siblings already agree on a different form, match them \u2014 cohesion across the tree is the goal, and the rules above are only the default when there is nothing to match. Restyle only titles you are already editing for another reason; a rename lands in someone's diff, so never sweep the tree for form alone.`;
+  }
+});
+
 // ../shared/scanPrompts.ts
 function buildFormatRefStories(opts) {
   const draftBlock = opts.persistentDrafts ? FORMAT_REF_DRAFT_STORIES_BLOCK : "";
   const uncoveredSubFlowRule = opts.persistentDrafts ? CROSS_REF_UNCOVERED_DRAFT_STUB : CROSS_REF_UNCOVERED_REAL_STORY;
-  const hierarchyExample = opts.persistentDrafts ? `- Example: storyUpdates: [{add: [{id: "auth", title: "Authentication", description: "User auth flows", draft: true, userStories: [{id: "login", title: "Login Flow", draft: true, acceptanceCriteria: ["< 1s response"]}]}]}]` : `- Example: storyUpdates: [{add: [{id: "auth", title: "Authentication", description: "User auth flows", userStories: [{id: "login", title: "Login Flow", acceptanceCriteria: ["< 1s response"], sequence: "sequenceDiagram\\n    ..."}]}]}]`;
+  const hierarchyExample = opts.persistentDrafts ? `- Example: storyUpdates: [{add: [{id: "auth", title: "Authentication", description: "User auth flows", draft: true, userStories: [{id: "login", title: "log in with email", draft: true, acceptanceCriteria: ["< 1s response"]}]}]}]` : `- Example: storyUpdates: [{add: [{id: "auth", title: "Authentication", description: "User auth flows", userStories: [{id: "login", title: "log in with email", acceptanceCriteria: ["< 1s response"], sequence: "sequenceDiagram\\n    ..."}]}]}]`;
   return `Recursive story hierarchy:
 - Stories can contain child stories via userStories: [...] \u2014 parent stories act as feature groups
 - Use top-level stories with description, links, and nested children to organize by feature area
 ${hierarchyExample}
 - Removing a parent story cascades to all descendants
 
-Story titles:
-- Keep titles as short as possible \u2014 rely on the parent group for context.
-- Good: "web app" > "auth" > "sign up with email"
-- Bad: "new user signs up with email on the web app"
+${STORY_NAMING_GUIDANCE}
 
 Story description format (markdown, 1-4 sentences \u2014 render target is a narrow side panel):
 - Write for someone who knows the product but isn't reading the code. Say what the system does and what the user/operator experiences at the highest useful altitude, not how it's implemented. A tl;dr, not a rehash.
@@ -12198,14 +12216,15 @@ storyUpdates targeting:
   - add: stories to add or update (merged by ID if story already exists)
   - remove: story IDs to remove
 - Examples:
-  - Add at root: storyUpdates: [{add: [{id: "us1", title: "Login", ...}]}]
-  - Add under story group: storyUpdates: [{under: "auth", add: [{id: "login", title: "Login Flow", ...}]}]
+  - Add at root: storyUpdates: [{add: [{id: "us1", title: "log in", ...}]}]
+  - Add under story group: storyUpdates: [{under: "auth", add: [{id: "login", title: "log in with email", ...}]}]
   - Remove: storyUpdates: [{remove: ["old_story"]}]
   - Combined: storyUpdates: [{under: "auth", add: [{id: "new_flow", ...}], remove: ["old_flow"]}]`;
 }
 var ANCHOR_RULES, ANCHOR_DISCOVERY, ANCHOR_VERIFICATION, FORMAT_REF_COMPONENTS, FORMAT_REF_CONNECTIONS, FORMAT_REF_DRAFT_STORIES_BLOCK, CROSS_REF_UNCOVERED_DRAFT_STUB, CROSS_REF_UNCOVERED_REAL_STORY, FORMAT_REF_STORIES;
 var init_scanPrompts = __esm({
   "../shared/scanPrompts.ts"() {
+    init_storyNaming();
     ANCHOR_RULES = `Every component must have either \`anchors\` (non-empty array) or \`unanchored: true\`. No bare components.
 
 Pick the anchor kind based on how the component lives in code:
@@ -12630,12 +12649,15 @@ async function getLanguage(lang, cacheRoot = defaultCacheRoot()) {
   return language;
 }
 async function getParser(lang, cacheRoot) {
+  const cached = parserCache.get(lang);
+  if (cached) return cached;
   const language = await getLanguage(lang, cacheRoot);
   const parser = new Parser();
   parser.setLanguage(language);
+  parserCache.set(lang, parser);
   return parser;
 }
-var initialized, languageCache;
+var initialized, languageCache, parserCache;
 var init_parser = __esm({
   "src/analyze/tree-sitter/parser.ts"() {
     "use strict";
@@ -12643,6 +12665,7 @@ var init_parser = __esm({
     init_grammars();
     initialized = false;
     languageCache = /* @__PURE__ */ new Map();
+    parserCache = /* @__PURE__ */ new Map();
   }
 });
 
@@ -12970,22 +12993,34 @@ var init_extract = __esm({
 
 // src/analyze/tree-sitter/symbols.ts
 import { Query } from "web-tree-sitter";
+async function getQuery(lang) {
+  const cached = queryCache.get(lang);
+  if (cached) return cached;
+  const query = new Query(await getLanguage(lang), SYMBOL_QUERIES[lang]);
+  queryCache.set(lang, query);
+  return query;
+}
 async function extractSymbols(lang, source) {
   const parser = await getParser(lang);
   const tree = parser.parse(source);
   if (!tree) {
     return [];
   }
-  const language = await getLanguage(lang);
-  const query = new Query(language, SYMBOL_QUERIES[lang]);
-  return symbolsFromMatches(query.matches(tree.rootNode));
+  try {
+    const query = await getQuery(lang);
+    return symbolsFromMatches(query.matches(tree.rootNode));
+  } finally {
+    tree.delete();
+  }
 }
+var queryCache;
 var init_symbols = __esm({
   "src/analyze/tree-sitter/symbols.ts"() {
     "use strict";
     init_parser();
     init_queries();
     init_extract();
+    queryCache = /* @__PURE__ */ new Map();
   }
 });
 
@@ -14258,7 +14293,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;
@@ -16118,12 +16153,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
@@ -16657,8 +16692,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;
@@ -16685,7 +16720,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;
@@ -16693,7 +16728,7 @@ async function runJob(ctx, job, claimDeviceId) {
       ctx,
       job.id,
       deviceId,
-      summary,
+      summary2,
       outcome.kind,
       changed,
       metrics,
@@ -18164,14 +18199,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);
@@ -18270,7 +18305,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 {
@@ -18281,8 +18316,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");
@@ -18348,7 +18383,7 @@ async function runScan(opts, deps = {}) {
       orgSlug: resolved2.orgSlug,
       projectSlug: resolved2.projectSlug,
       webUrl,
-      summary
+      summary: summary2
     };
   } finally {
     await cleanupMcp().catch(() => {
@@ -18959,6 +18994,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 {
@@ -19241,9 +19279,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,
@@ -19253,8 +19291,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;
@@ -19494,22 +19532,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>`
@@ -19518,8 +19556,8 @@ async function runInit(opts, deps = {}) {
     fullSlug = defaultProjectSlug(orgSlug, repoPath);
   }
   const project = await resolveProject(
-    authed.supabase,
-    authed.userId,
+    authed2.supabase,
+    authed2.userId,
     fullSlug
   );
   log(
@@ -19527,7 +19565,7 @@ async function runInit(opts, deps = {}) {
   );
   const scanBranch = initScanBranch(project.defaultBranch);
   const detail = await fetchArchitecture(
-    authed.supabase,
+    authed2.supabase,
     project.projectId,
     scanBranch
   );
@@ -19541,8 +19579,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,
@@ -19609,18 +19647,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,
@@ -19642,8 +19680,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,
@@ -19852,12 +19890,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
@@ -19947,12 +20548,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) {
@@ -19966,13 +20567,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]+$/;
   }
@@ -19980,7 +20581,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);
@@ -19996,7 +20597,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));
@@ -20064,17 +20665,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("/");
@@ -20360,18 +20961,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) {
@@ -20403,11 +21004,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);
@@ -20423,17 +21024,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({
@@ -20446,13 +21047,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();
@@ -20460,9 +21061,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;
   }
 });
 
@@ -20520,6 +21121,7 @@ var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "keys",
   "scan",
   "init",
+  "uninstall",
   "local-watch",
   "doctor"
 ]);
@@ -20618,12 +21220,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": {
@@ -20650,6 +21256,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.5",
+  "version": "0.5.1",
   "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",