memgineering 0.4.1 → 0.5.0

package/dist/index.js

@@ -1164,12 +1164,12 @@ function findConflicts(memories, relations, claimsById) {
 }
 function missingCounterparts(included, all, relations) {
   const inSet = new Set(included.map((m) => m.id));
-  const exists2 = new Set(all.map((m) => m.id));
+  const exists3 = new Set(all.map((m) => m.id));
   const wanted = /* @__PURE__ */ new Set();
   for (const rel of relations) {
     if (rel.type !== "contradicts") continue;
-    if (inSet.has(rel.from) && !inSet.has(rel.to) && exists2.has(rel.to)) wanted.add(rel.to);
-    if (inSet.has(rel.to) && !inSet.has(rel.from) && exists2.has(rel.from)) wanted.add(rel.from);
+    if (inSet.has(rel.from) && !inSet.has(rel.to) && exists3.has(rel.to)) wanted.add(rel.to);
+    if (inSet.has(rel.to) && !inSet.has(rel.from) && exists3.has(rel.from)) wanted.add(rel.from);
   }
   return [...wanted].sort();
 }
@@ -1734,6 +1734,120 @@ var init_commit = __esm({
   }
 });
 
+// ../../packages/memory-engine/src/capture/curate.ts
+function asSingleMatch(entry, now = /* @__PURE__ */ new Date()) {
+  return {
+    candidate: {
+      subject: entry.memory.title,
+      scope: entry.memory.scope,
+      kind: entry.memory.type,
+      candidate_claim: entry.memory.summary ?? entry.memory.title,
+      entities: [],
+      importance: "normal"
+    },
+    matches: [
+      {
+        id: entry.memory.id,
+        title: entry.memory.title,
+        summary: entry.memory.summary,
+        path: entry.path,
+        revision: entry.revision,
+        freshness: freshnessOf(entry.memory, entry.claims, now),
+        score: 1
+      }
+    ],
+    contradicts: [],
+    scopes: entry.memory.scope ? [entry.memory.scope] : []
+  };
+}
+function reviseInput(entry, intent) {
+  const action = intent.action;
+  return {
+    action,
+    memory_id: entry.memory.id,
+    claim: {
+      text: intent.claim,
+      scope: entry.memory.scope,
+      valid_from: validFrom(entry, intent),
+      confidence: "stated",
+      summary: action === "conflict" ? null : intent.summary ?? intent.claim,
+      // Never defaulted from the claim, unlike the summary. A summary that is
+      // missing makes the change invisible, so filling it in is a rescue; a
+      // title that is missing simply means the author's heading still fits, and
+      // overwriting it would be rewriting their classification uninvited.
+      title: action === "conflict" ? null : intent.title ?? null
+    },
+    relations: {
+      depends_on: [],
+      relates_to: [],
+      contradicts: [...intent.contradicts ?? []]
+    },
+    reason: intent.reason ?? NO_REASON_GIVEN,
+    // The engine refuses to submit without an excerpt, because approving a diff
+    // on an assertion alone is not consent. Nothing here is approved by a
+    // person, but the requirement still earns its keep: it forces the record to
+    // say what the change was based on rather than only what it did.
+    source_excerpt: intent.because ?? entry.memory.summary ?? entry.memory.title,
+    target_path: entry.path
+  };
+}
+function lifecycleInput(entry, action, reason) {
+  return {
+    action,
+    memory_id: entry.memory.id,
+    claim: null,
+    reason: reason ?? noLifecycleReason(action),
+    // For a standing change the memory's own summary IS the passage the
+    // decision is about: it is what the note currently says, and it is what
+    // stops being current.
+    source_excerpt: entry.memory.summary ?? entry.memory.title,
+    target_path: entry.path
+  };
+}
+function saysNothingNew(entry, input, normalize) {
+  const norm = (v) => normalize(v ?? "").trim();
+  const claim = input.claim;
+  if (!claim || norm(claim.text) === "") return false;
+  if (norm(claim.text) !== norm(previousClaim(entry))) return false;
+  if (claim.summary != null && norm(claim.summary) !== norm(entry.memory.summary)) return false;
+  if (claim.title != null && norm(claim.title) !== norm(entry.memory.title)) return false;
+  const declared = new Set(
+    entry.relations.filter((r) => r.type === "contradicts").map((r) => r.to)
+  );
+  return (input.relations?.contradicts ?? []).every((id) => declared.has(id));
+}
+function bodyStillAsserts(content, oldClaim, newClaim, normalize) {
+  if (oldClaim === null) return null;
+  const line = normalize(oldClaim.split("\n")[0] ?? "").trim();
+  if (line === "") return null;
+  if (line === normalize(newClaim?.split("\n")[0] ?? "").trim()) return null;
+  return bodyOf(content).includes(line) ? line : null;
+}
+function bodyOf(content) {
+  const stripped = content.replace(/^/, "");
+  const fence = /^---[ \t]*\r?\n[\s\S]*?\r?\n---[ \t]*(\r?\n|$)/.exec(stripped);
+  return fence ? stripped.slice(fence[0].length) : stripped;
+}
+function previousClaim(entry) {
+  const current = entry.claims.find((claim) => claim.id === entry.memory.current_claim) ?? entry.claims[0];
+  return current?.text ?? null;
+}
+function validFrom(entry, intent) {
+  if (intent.validFrom) return intent.validFrom;
+  if (intent.action === "supersede") return (intent.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const declared = entry.claims.find((c2) => c2.valid_from)?.valid_from;
+  return declared ?? null;
+}
+var NO_REASON_GIVEN, noLifecycleReason;
+var init_curate = __esm({
+  "../../packages/memory-engine/src/capture/curate.ts"() {
+    "use strict";
+    init_planner();
+    NO_REASON_GIVEN = "revised directly";
+    noLifecycleReason = (action) => `${action}d directly`;
+  }
+});
+
 // ../../packages/memory-engine/src/proposal/patch.ts
 import { parseDocument, parse as parseYaml2, stringify as stringifyYaml } from "yaml";
 function inlineValueOf(keyLine) {
@@ -2069,6 +2183,109 @@ var init_apply = __esm({
   }
 });
 
+// ../../packages/memory-engine/src/resurface/rank.ts
+function rank(entries, events, opts) {
+  const recalls = events.filter((e) => e.verb !== "resurface");
+  const here = opts.here ? recalls.filter((e) => opts.here(e)) : [];
+  const countIn = (source) => {
+    const counts = /* @__PURE__ */ new Map();
+    for (const event of source) {
+      for (const id of event.returned_ids) counts.set(id, (counts.get(id) ?? 0) + 1);
+      if (event.opened_id) counts.set(event.opened_id, (counts.get(event.opened_id) ?? 0) + 1);
+    }
+    return counts;
+  };
+  const hereCounts = countIn(here);
+  const anyCounts = countIn(recalls);
+  const lastTouched = /* @__PURE__ */ new Map();
+  for (const event of recalls) {
+    const t = Date.parse(event.ts);
+    if (!Number.isFinite(t)) continue;
+    for (const id of [...event.returned_ids, event.opened_id].filter(Boolean)) {
+      lastTouched.set(id, Math.max(lastTouched.get(id) ?? 0, t));
+    }
+  }
+  const hasBase = entries.some((e) => e.path.startsWith("01_BASE/"));
+  const scored = [];
+  for (const entry of entries) {
+    const id = entry.memory.id;
+    const freshness = freshnessOf(entry.memory, entry.claims, opts.now);
+    if (freshness === "retired") continue;
+    const why = [];
+    let score = 0;
+    const hereCount = hereCounts.get(id) ?? 0;
+    if (hereCount > 0) {
+      score += WEIGHT.contextRecall * Math.log2(1 + hereCount);
+      why.push(`recalled ${hereCount}\xD7 in this folder`);
+    }
+    const anyCount = (anyCounts.get(id) ?? 0) - hereCount;
+    if (anyCount > 0) {
+      score += WEIGHT.anyRecall * Math.log2(1 + anyCount);
+      if (hereCount === 0) why.push(`recalled ${anyCount}\xD7 elsewhere`);
+    }
+    const touched = lastTouched.get(id);
+    if (touched !== void 0) {
+      const days = (opts.now.getTime() - touched) / 864e5;
+      score += WEIGHT.recency * Math.pow(0.5, days / 7);
+    }
+    if (hasBase && entry.path.startsWith("01_BASE/")) {
+      const days = touched === void 0 ? Number.POSITIVE_INFINITY : (opts.now.getTime() - touched) / 864e5;
+      if (days > STALE_BASE_DAYS) {
+        score += WEIGHT.staleBase;
+        why.push(
+          touched === void 0 ? "never read this session" : `not read in ${Math.floor(days)} days`
+        );
+      }
+    }
+    if (score === 0 && !entry.path.startsWith("01_BASE/")) {
+      score += WEIGHT.neverReached;
+      why.push("never surfaced yet");
+    }
+    if (freshness !== "current") why.push(freshness);
+    if (score > 0) scored.push({ entry, score, why });
+  }
+  return scored.sort(
+    (a, b) => b.score - a.score || a.entry.memory.id.localeCompare(b.entry.memory.id)
+  );
+}
+var WEIGHT, STALE_BASE_DAYS;
+var init_rank = __esm({
+  "../../packages/memory-engine/src/resurface/rank.ts"() {
+    "use strict";
+    init_planner();
+    WEIGHT = {
+      contextRecall: 3,
+      anyRecall: 1,
+      recency: 2,
+      staleBase: 4,
+      /**
+       * A note nobody has reached for yet.
+       *
+       * Everything above scores a note for having been USED — recalled here,
+       * recalled anywhere, touched lately. A note that has only ever been written
+       * scores none of them, and the filter at the end drops anything at zero. So
+       * on a brain whose notes have not been recalled yet, `resurface` could return
+       * nothing but `01_BASE/` templates: the two real notes in a three-note brain
+       * were invisible at `--limit 8`, while `recall` found them immediately.
+       *
+       * That is a loop with no way in. `resurface` runs at session start and is the
+       * answer to "what should I already know here" — a question asked precisely
+       * when nobody knows what to search for. If a note has to be recalled before
+       * it can be surfaced, and surfacing is how you learn it exists, it never
+       * surfaces. Measured: an agent given such a brain saw five "not filled in
+       * yet" placeholders, concluded there was nothing in it, and never called
+       * memgineering again in that session.
+       *
+       * Smallest weight on the board on purpose — anything with real evidence
+       * behind it still outranks this, and this only decides what fills the rest of
+       * the page instead of leaving it blank.
+       */
+      neverReached: 0.5
+    };
+    STALE_BASE_DAYS = 30;
+  }
+});
+
 // ../../packages/memory-engine/src/index.ts
 var init_src = __esm({
   "../../packages/memory-engine/src/index.ts"() {
@@ -2086,8 +2303,10 @@ var init_src = __esm({
     init_store();
     init_prepare();
     init_commit();
+    init_curate();
     init_patch();
     init_apply();
+    init_rank();
   }
 });
 
@@ -2672,6 +2891,24 @@ var init_config = __esm({
     ConfigSchema = z6.object({
       brain: z6.object({
         brains: z6.array(BrainSchema).default([]),
+        /**
+         * The hosted brain this machine is pointed at, when there is one.
+         *
+         * Its presence is what makes a command look at the server instead of the
+         * disk, so it is set deliberately — by `push`, or by picking one — and
+         * never inferred from being signed in. Somebody with an account and no
+         * hosted brain keeps working exactly as they did.
+         *
+         * `api_url` is stored beside the id for the same reason the token is:
+         * a brain id means nothing to a different server, and pointing
+         * `MEMGINEERING_API_URL` somewhere else must read as "no hosted brain
+         * here" rather than as a request for a stranger's brain.
+         */
+        cloud: z6.object({
+          id: z6.string().min(1),
+          name: z6.string().min(1),
+          api_url: z6.string().min(1)
+        }).optional(),
         /**
          * The brain to use when nothing else says which — root path, or absent.
          *
@@ -2850,9 +3087,237 @@ var init_index_build = __esm({
   }
 });
 
+// src/lib/credentials.ts
+import { mkdir as mkdir7, readFile as readFile12, unlink, writeFile as writeFile6 } from "fs/promises";
+import { join as join11 } from "path";
+import { z as z8 } from "zod";
+function credentialsPath() {
+  return join11(brandHome(), "credentials.json");
+}
+async function readCredentials() {
+  try {
+    const parsed = CredentialsSchema.safeParse(
+      JSON.parse(await readFile12(credentialsPath(), "utf8"))
+    );
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+async function saveCredentials(credentials) {
+  await mkdir7(brandHome(), { recursive: true });
+  await unlink(credentialsPath()).catch(() => void 0);
+  await writeFile6(credentialsPath(), JSON.stringify(credentials, null, 2) + "\n", {
+    encoding: "utf8",
+    mode: 384
+  });
+}
+async function clearCredentials() {
+  await unlink(credentialsPath()).catch(() => void 0);
+}
+var CredentialsSchema;
+var init_credentials = __esm({
+  "src/lib/credentials.ts"() {
+    "use strict";
+    init_brand();
+    CredentialsSchema = z8.object({
+      /** The server that issued this token. Compared before the token is ever sent. */
+      api_url: z8.string().min(1),
+      token: z8.string().min(1),
+      account_id: z8.string().min(1),
+      display_name: z8.string().nullable().default(null),
+      signed_in_at: z8.string().min(1)
+    });
+  }
+});
+
+// src/lib/pending-login.ts
+import { mkdir as mkdir8, readFile as readFile13, unlink as unlink2, writeFile as writeFile7 } from "fs/promises";
+import { join as join12 } from "path";
+import { z as z9 } from "zod";
+function pendingLoginPath() {
+  return join12(brandHome(), "pending-login.json");
+}
+async function readPendingLogin() {
+  try {
+    const parsed = PendingLoginSchema.safeParse(
+      JSON.parse(await readFile13(pendingLoginPath(), "utf8"))
+    );
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+async function savePendingLogin(pending) {
+  await mkdir8(brandHome(), { recursive: true });
+  await unlink2(pendingLoginPath()).catch(() => void 0);
+  await writeFile7(pendingLoginPath(), JSON.stringify(pending, null, 2) + "\n", {
+    encoding: "utf8",
+    mode: 384
+  });
+}
+async function clearPendingLogin() {
+  await unlink2(pendingLoginPath()).catch(() => void 0);
+}
+function pendingExpired(pending, now = Date.now()) {
+  return Math.floor(now / 1e3) >= pending.expires_at_epoch;
+}
+var PendingLoginSchema;
+var init_pending_login = __esm({
+  "src/lib/pending-login.ts"() {
+    "use strict";
+    init_brand();
+    PendingLoginSchema = z9.object({
+      /** Which server this pairing belongs to. */
+      api_url: z9.string().min(1),
+      device_code: z9.string().min(1),
+      /** Shown again if the agent needs to re-display it. */
+      user_code: z9.string().min(1),
+      verification_url: z9.string().min(1),
+      /** Unix seconds. Past it, the pairing is gone server-side too. */
+      expires_at_epoch: z9.number().int().positive()
+    });
+  }
+});
+
+// src/lib/api-client.ts
+function apiUrl(env = process.env) {
+  const raw = env["MEMGINEERING_API_URL"]?.trim();
+  return (raw && raw !== "" ? raw : DEFAULT_API_URL).replace(/\/+$/, "");
+}
+async function apiRequest(args) {
+  const base = args.baseUrl ?? apiUrl();
+  const url = `${base}${args.path}`;
+  let res;
+  try {
+    res = await fetch(url, {
+      method: args.method,
+      headers: {
+        accept: "application/json",
+        ...args.body === void 0 ? {} : { "content-type": "application/json" },
+        ...args.token ? { authorization: `Bearer ${args.token}` } : {}
+      },
+      ...args.body === void 0 ? {} : { body: JSON.stringify(args.body) },
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+    });
+  } catch (err) {
+    throw memgError(
+      "server_unreachable",
+      `could not reach ${base}`,
+      `Nothing was sent or changed. Check the connection, or set MEMGINEERING_API_URL if the brain server is somewhere else. Underlying cause: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  let parsed = null;
+  const text = await res.text().catch(() => "");
+  if (text !== "") {
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      parsed = null;
+    }
+  }
+  if (res.ok || args.expect?.includes(res.status)) {
+    return { status: res.status, body: parsed };
+  }
+  const envelope = parsed?.error;
+  if (envelope && typeof envelope.message === "string" && typeof envelope.hint === "string") {
+    throw new MemgError({
+      code: typeof envelope.code === "string" ? envelope.code : "server_refused",
+      message: envelope.message,
+      hint: envelope.hint
+    });
+  }
+  throw memgError(
+    "server_refused",
+    `${base} answered ${res.status} with no readable error`,
+    `This is not a shape this CLI knows. If MEMGINEERING_API_URL points at something other than a memgineering brain server, that would explain it. First 200 characters of the response: ${text.slice(0, 200)}`
+  );
+}
+async function claimPendingLogin(baseUrl = apiUrl()) {
+  const pending = await readPendingLogin();
+  if (!pending) return null;
+  if (pending.api_url !== baseUrl) return null;
+  if (pendingExpired(pending)) {
+    await clearPendingLogin();
+    return null;
+  }
+  return claimOnce(pending, baseUrl);
+}
+async function claimOnce(pending, baseUrl = apiUrl()) {
+  let res;
+  try {
+    res = await apiRequest({
+      method: "POST",
+      path: "/v1/auth/device/token",
+      body: { device_code: pending.device_code },
+      baseUrl,
+      expect: [425]
+    });
+  } catch (err) {
+    if (err instanceof MemgError && err.code !== "server_unreachable") {
+      await clearPendingLogin();
+    }
+    throw err;
+  }
+  if (res.status === 425) return null;
+  const token = res.body?.token;
+  if (typeof token !== "string" || token === "") {
+    await clearPendingLogin();
+    throw memgError(
+      "server_refused",
+      "the sign-in completed but no token came back",
+      "Nothing is stored. Run `memgineering login` again; if it repeats, the brain server is answering in a shape this version does not understand."
+    );
+  }
+  const me = await apiRequest({ method: "GET", path: "/v1/me", token, baseUrl });
+  const credentials = {
+    api_url: baseUrl,
+    token,
+    account_id: me.body?.account?.id ?? "",
+    display_name: me.body?.account?.display_name ?? null,
+    signed_in_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await saveCredentials(credentials);
+  await clearPendingLogin();
+  return credentials;
+}
+async function currentCredentials(baseUrl = apiUrl()) {
+  const stored = await readCredentials();
+  if (stored && stored.api_url === baseUrl) return stored;
+  return claimPendingLogin(baseUrl);
+}
+async function requireCredentials(baseUrl = apiUrl()) {
+  const credentials = await currentCredentials(baseUrl);
+  if (credentials) return credentials;
+  const pending = await readPendingLogin();
+  if (pending && !pendingExpired(pending)) {
+    throw memgError(
+      "login_pending",
+      "a sign-in has been started but nobody has approved it yet",
+      `Show the user this code \u2014 ${pending.user_code} \u2014 and this link: ${pending.verification_url}. They approve there, then run this again and the token is collected automatically.`
+    );
+  }
+  throw memgError(
+    "not_signed_in",
+    `no memgineering account is signed in for ${baseUrl}`,
+    "An account is optional. Everything works on the brain on this machine \u2014 add `--local` to run this against it, and nothing else is needed.\nONLY if the user has asked to connect an account: you lead it \u2014 run `memgineering login --emit-only`, show the code it prints in your reply, and run this again to collect the token.\nDo NOT start one they have not asked for. It opens a Google consent page in their browser, and a sign-in nobody requested is the thing that makes people close the tab."
+  );
+}
+var DEFAULT_API_URL, REQUEST_TIMEOUT_MS;
+var init_api_client = __esm({
+  "src/lib/api-client.ts"() {
+    "use strict";
+    init_errors();
+    init_credentials();
+    init_pending_login();
+    DEFAULT_API_URL = "https://api.memgineering.com";
+    REQUEST_TIMEOUT_MS = 1e4;
+  }
+});
+
 // src/commands/init.ts
-import { mkdir as mkdir8, readdir as readdir5, writeFile as writeFile6 } from "fs/promises";
-import { join as join12, resolve as resolve5 } from "path";
+import { mkdir as mkdir10, readdir as readdir5, writeFile as writeFile8 } from "fs/promises";
+import { join as join14, resolve as resolve5 } from "path";
 import { Command as Command3 } from "commander";
 function initCommand() {
   return new Command3("init").description("create a new brain, laid out and ready to write into").argument("<path>", "where the brain should live").option("--name <name>", "what to call it in the hub", "My brain").action(async (path, opts) => {
@@ -2896,10 +3361,10 @@ async function createBrain(path, name) {
   memgineering link ${path}`
     );
   }
-  await mkdir8(root, { recursive: true });
-  for (const dir of FOLDERS) await mkdir8(join12(root, dir), { recursive: true });
+  await mkdir10(root, { recursive: true });
+  for (const dir of FOLDERS) await mkdir10(join14(root, dir), { recursive: true });
   for (const [file, content] of Object.entries(files(name))) {
-    await writeFile6(join12(root, file), content, "utf8");
+    await writeFile8(join14(root, file), content, "utf8");
   }
   const canonicalRoot2 = await canonicalize(root);
   const adapter = await LocalFileReadAdapter.openVault(canonicalRoot2);
@@ -3046,8 +3511,8 @@ var init_init = __esm({
 });
 
 // src/commands/link.ts
-import { readFile as readFile13 } from "fs/promises";
-import { join as join13 } from "path";
+import { readFile as readFile15 } from "fs/promises";
+import { join as join15 } from "path";
 import { Command as Command5 } from "commander";
 import prompts from "prompts";
 function sameBasename(all, entry) {
@@ -3247,7 +3712,7 @@ async function recordLink(adapter, observationsDir) {
 }
 async function refuseSilentRules(path, denied, excluded, unsupported) {
   const denyEntries = (await LocalFileReadAdapter.readDenyFile(path, ".memgdeny")).entries;
-  const rawDenyLines = await readFile13(join13(path, ".memgdeny"), "utf8").then(
+  const rawDenyLines = await readFile15(join15(path, ".memgdeny"), "utf8").then(
     (t) => t.split("\n").map((l) => l.trim()).filter((l) => l !== "" && !l.startsWith("#"))
   ).catch(() => []);
   const asWritten = (folded) => rawDenyLines.find(
@@ -3417,29 +3882,371 @@ var init_link = __esm({
   }
 });
 
-// src/commands/setup-web-page.ts
-function renderSetupPage() {
-  return `<!doctype html>
-<html lang="ko">
-<head>
-<meta charset="utf-8" />
-<meta name="viewport" content="width=device-width, initial-scale=1" />
-<meta name="referrer" content="no-referrer" />
-<title>memgineering \u2014 \uC124\uCE58</title>
-<style>
-  :root {
-    --bg: #ffffff;
-    --fg: #101114;
-    --muted: #6b7280;
-    --line: #e6e8ec;
-    --accent: #2f6bff;
-    --accent-fg: #ffffff;
-    --card: #ffffff;
-    --soft: #f5f6f8;
-    --warn: #b45309;
-    --ok: #157347;
-  }
-  @media (prefers-color-scheme: dark) {
+// src/lib/open-browser.ts
+import { spawn } from "child_process";
+async function openBrowser(url) {
+  const { file, args } = browserOpener(url);
+  return new Promise((resolve11) => {
+    let settled = false;
+    const finish = (opened) => {
+      if (settled) return;
+      settled = true;
+      resolve11(opened);
+    };
+    const child = spawn(file, args, { detached: true, stdio: "ignore" });
+    child.on("error", () => finish(false));
+    child.on("exit", (code) => {
+      if (code !== null && code !== 0) finish(false);
+    });
+    child.unref();
+    setTimeout(() => finish(true), 300);
+  });
+}
+function browserOpener(url) {
+  if (process.platform === "darwin") return { file: "open", args: [url] };
+  if (process.platform === "win32") return { file: "cmd", args: ["/c", "start", "", url] };
+  return { file: "xdg-open", args: [url] };
+}
+var init_open_browser = __esm({
+  "src/lib/open-browser.ts"() {
+    "use strict";
+  }
+});
+
+// src/commands/login.ts
+import { Command as Command9 } from "commander";
+function loginCommand() {
+  return new Command9("login").description("sign in to a hosted brain").option(
+    "--emit-only",
+    "start the sign-in, open the browser, and return immediately \u2014 THE path an agent should use on a user\u2019s behalf; the next command claims the token automatically. Prefer this over the plain form, whose wait for a human click will outlast an agent\u2019s command timeout"
+  ).option("--no-browser", "do not try to open a browser \u2014 just print the link").option("--print-url", "print the approval link even when a browser opened").addHelpText(
+    "after",
+    "\nAgents: run `login --emit-only`, then SHOW the code in your reply. The\napproval page asks the user to check it against what you showed them,\nand they cannot if you never showed it. Do not ask the user to run a\nlogin command themselves."
+  ).action(async (opts) => {
+    const base = apiUrl();
+    const already = await currentCredentials(base);
+    if (already) {
+      printDual({
+        json: {
+          already_signed_in: true,
+          account: { id: already.account_id, display_name: already.display_name },
+          api_url: base
+        },
+        human: () => {
+          printHuman(
+            `Already signed in${already.display_name ? ` as ${c.bold(already.display_name)}` : ""}.`
+          );
+          printHuman(c.gray("  `memgineering logout` first if you want a different account."));
+        }
+      });
+      return;
+    }
+    const { pending, opened } = await beginSignIn({ browser: opts.browser !== false });
+    const showUrl = !opened || opts.printUrl === true;
+    if (opts.emitOnly) {
+      emit(pending, { base, opened, showUrl, blocking: false });
+      return;
+    }
+    emit(pending, { base, opened, showUrl, blocking: true });
+    await waitForApproval(pending, base);
+  });
+}
+async function beginSignIn(opts) {
+  const pending = await startPairing(apiUrl());
+  const opened = opts.browser ? await openBrowser(pending.verification_url) : false;
+  await savePendingLogin(pending);
+  return { pending, opened };
+}
+async function signInSummary() {
+  const base = apiUrl();
+  const stored = await readCredentials();
+  const pending = await pendingOrNull();
+  return {
+    signedIn: stored !== null && stored.api_url === base,
+    displayName: stored?.api_url === base ? stored?.display_name ?? null : null,
+    pendingUserCode: pending?.api_url === base ? pending.user_code : null,
+    apiUrl: base
+  };
+}
+async function startPairing(base) {
+  const res = await apiRequest({
+    method: "POST",
+    path: "/v1/auth/device/code",
+    baseUrl: base
+  });
+  const { device_code, user_code, verification_url, expires_in } = res.body ?? {};
+  if (!device_code || !user_code || !verification_url) {
+    throw memgError(
+      "server_refused",
+      "the brain server did not return a usable sign-in code",
+      `Nothing is stored. Check that MEMGINEERING_API_URL points at a memgineering brain server \u2014 it is currently ${base}.`
+    );
+  }
+  return {
+    api_url: base,
+    device_code,
+    user_code,
+    verification_url,
+    expires_at_epoch: Math.floor(Date.now() / 1e3) + (expires_in ?? 600)
+  };
+}
+function emit(pending, ctx) {
+  printDual({
+    json: {
+      user_code: pending.user_code,
+      // Always present in JSON, unlike `setup --web`: this link authorizes
+      // nothing on its own. It names a pairing whose only power is to be
+      // approved by somebody who signs in with Google, and an agent that cannot
+      // re-show it leaves a user stuck at a page with no way back to it.
+      verification_url: pending.verification_url,
+      expires_at_epoch: pending.expires_at_epoch,
+      browser_opened: ctx.opened,
+      api_url: ctx.base,
+      waiting: ctx.blocking,
+      next: ctx.blocking ? "Waiting for approval in the browser." : "SHOW user_code to the user in your reply, then run any memgineering command \u2014 the token is claimed automatically once they approve."
+    },
+    human: () => {
+      printHuman("Show this code to whoever is signing in:\n");
+      printHuman(`  ${c.bold().yellow(pending.user_code)}
+`);
+      if (ctx.opened) {
+        printHuman("Opened the approval page in your browser.");
+      } else {
+        printHuman("Open this to approve:\n");
+        printHuman(`  ${c.cyan(pending.verification_url)}`);
+      }
+      if (ctx.opened && ctx.showUrl) {
+        printHuman(c.gray(`  ${pending.verification_url}`));
+      }
+      printHuman(
+        c.gray(
+          "\n  The page asks whether the code above is the one you were shown.\n  If you did not start this, close it \u2014 nothing has been created."
+        )
+      );
+      if (!ctx.blocking) {
+        printHuman(c.gray("\n  Not waiting. The next memgineering command collects the token."));
+      }
+    }
+  });
+}
+async function waitForApproval(pending, base) {
+  const deadline = Date.now() + BLOCKING_TIMEOUT_MS;
+  progress("Waiting for approval");
+  for (; ; ) {
+    if (Date.now() >= deadline || pendingExpired(pending)) {
+      throw memgError(
+        "login_expired",
+        "nobody approved the sign-in in time",
+        "Run `memgineering login` again for a fresh code. Nothing was created."
+      );
+    }
+    await sleep(5e3);
+    let claimed;
+    try {
+      claimed = await claimOnce(pending, base);
+    } catch (err) {
+      if (err instanceof MemgError && err.code === "server_unreachable") continue;
+      throw err;
+    }
+    if (claimed) {
+      printDual({
+        json: {
+          signed_in: true,
+          account: { id: claimed.account_id, display_name: claimed.display_name },
+          api_url: base
+        },
+        human: () => {
+          printHuman(
+            `
+Signed in${claimed.display_name ? ` as ${c.bold(claimed.display_name)}` : ""}.`
+          );
+          printHuman(c.gray("  The token is stored on this machine only, readable by you alone."));
+        }
+      });
+      return;
+    }
+  }
+}
+async function pendingOrNull() {
+  const pending = await readPendingLogin();
+  if (!pending) return null;
+  if (pendingExpired(pending)) {
+    await clearPendingLogin();
+    return null;
+  }
+  return pending;
+}
+var BLOCKING_TIMEOUT_MS, sleep;
+var init_login = __esm({
+  "src/commands/login.ts"() {
+    "use strict";
+    init_errors();
+    init_api_client();
+    init_credentials();
+    init_open_browser();
+    init_pending_login();
+    init_ui();
+    BLOCKING_TIMEOUT_MS = 10 * 60 * 1e3;
+    sleep = (ms) => new Promise((resolve11) => {
+      setTimeout(resolve11, ms).unref?.();
+    });
+  }
+});
+
+// src/commands/setup-signin.ts
+import prompts2 from "prompts";
+async function runSignInStep(opts) {
+  const summary = await signInSummary();
+  if (summary.signedIn) return { status: "signed-in", displayName: summary.displayName };
+  if (summary.pendingUserCode) return { status: "pending", userCode: summary.pendingUserCode };
+  if (opts.login === false) return { status: "skipped" };
+  if (opts.dryRun) {
+    const wouldAsk = opts.interactive || opts.login === true;
+    return wouldAsk ? { status: "would-start" } : { status: "skipped" };
+  }
+  if (!opts.interactive && opts.login !== true) return { status: "skipped" };
+  if (opts.interactive) {
+    printHuman(c.bold("\nmemgineering \u2014 setup\n"));
+    const { wants } = await prompts2({
+      type: "toggle",
+      name: "wants",
+      message: "Sign in to a memgineering account first?",
+      initial: false,
+      active: "sign in",
+      inactive: "later"
+    });
+    if (wants !== true) {
+      printHuman(
+        c.gray("  Skipped. Everything below works on files on this machine, with no account.\n")
+      );
+      return { status: "skipped" };
+    }
+  }
+  try {
+    const { pending, opened } = await beginSignIn({ browser: opts.browser });
+    return {
+      status: "started",
+      userCode: pending.user_code,
+      verificationUrl: pending.verification_url,
+      opened
+    };
+  } catch (err) {
+    return {
+      status: "unavailable",
+      because: err instanceof MemgError ? err.message : String(err)
+    };
+  }
+}
+function printSignInStep(step) {
+  switch (step.status) {
+    case "signed-in":
+      printHuman(c.gray(`  signed in${step.displayName ? ` as ${step.displayName}` : ""}
+`));
+      return;
+    case "started":
+      printHuman("Show this code to whoever is signing in:\n");
+      printHuman(`  ${c.bold().yellow(step.userCode)}
+`);
+      printHuman(
+        step.opened ? c.gray("  The approval page is open in the browser.") : `Open this to approve:
+  ${c.cyan(step.verificationUrl)}`
+      );
+      printHuman(
+        c.gray("  Not waiting \u2014 setup carries on, and the next command collects the token.\n")
+      );
+      return;
+    case "pending":
+      printHuman(c.gray(`  a sign-in is waiting for approval \u2014 code ${step.userCode}
+`));
+      return;
+    case "unavailable":
+      printHuman(c.yellow(`  Could not start a sign-in: ${step.because}`));
+      printHuman(c.gray("  Setup continues \u2014 an account is not needed for any of it.\n"));
+      return;
+    case "would-start":
+      printHuman(c.gray("  would start a sign-in (nothing was asked for \u2014 this is a dry run)\n"));
+      return;
+    case "skipped":
+      printHuman(
+        c.gray("  no account \u2014 this brain lives on this machine only.") + c.gray("\n  To sync it across your devices and tools later: `memgineering login`\n")
+      );
+      return;
+  }
+}
+function signInStepJson(step) {
+  switch (step.status) {
+    case "signed-in":
+      return { account: { signed_in: true, display_name: step.displayName } };
+    case "started":
+      return {
+        account: {
+          signed_in: false,
+          sign_in_started: true,
+          user_code: step.userCode,
+          verification_url: step.verificationUrl,
+          next: "SHOW user_code to the user and have them approve at verification_url. The token is claimed by the next memgineering command."
+        }
+      };
+    case "pending":
+      return {
+        account: {
+          signed_in: false,
+          sign_in_pending: true,
+          user_code: step.userCode,
+          next: "A sign-in is already waiting. SHOW user_code to the user; the token is claimed once they approve."
+        }
+      };
+    case "unavailable":
+      return { account: { signed_in: false, sign_in_unavailable: step.because } };
+    case "would-start":
+      return {
+        account: {
+          signed_in: false,
+          would_start_sign_in: true,
+          next: "A dry run asks nothing of the server. Run without --dry-run to start the sign-in."
+        }
+      };
+    case "skipped":
+      return {
+        account: {
+          signed_in: false,
+          next: "Optional: `memgineering login --emit-only` connects a hosted account. Nothing installed here needs one \u2014 brains are folders on this machine."
+        }
+      };
+  }
+}
+var init_setup_signin = __esm({
+  "src/commands/setup-signin.ts"() {
+    "use strict";
+    init_errors();
+    init_login();
+    init_ui();
+  }
+});
+
+// src/commands/setup-web-page.ts
+function renderSetupPage() {
+  return `<!doctype html>
+<html lang="ko">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<meta name="referrer" content="no-referrer" />
+<title>memgineering \u2014 \uC124\uCE58</title>
+<style>
+  :root {
+    --bg: #ffffff;
+    --fg: #101114;
+    --muted: #6b7280;
+    --line: #e6e8ec;
+    --accent: #2f6bff;
+    --accent-fg: #ffffff;
+    --card: #ffffff;
+    --soft: #f5f6f8;
+    --warn: #b45309;
+    --ok: #157347;
+  }
+  @media (prefers-color-scheme: dark) {
     :root {
       --bg: #0e0f12;
       --fg: #f2f3f5;
@@ -3514,6 +4321,18 @@ function renderSetupPage() {
   .err b { display: block; margin-bottom: 0.35rem; }
   .err span { color: var(--muted); }
   .spinner { color: var(--muted); font-size: 0.9rem; margin-top: 1.2rem; }
+  table.cmp { width: 100%; border-collapse: collapse; margin: 1.4rem 0 0.4rem; font-size: 0.95rem; }
+  table.cmp th, table.cmp td { padding: 0.62rem 0.5rem; border-bottom: 1px solid var(--line); text-align: left; }
+  table.cmp thead th { color: var(--muted); font-weight: 600; font-size: 0.85rem; }
+  table.cmp th:first-child { width: 52%; font-weight: 400; }
+  table.cmp td { text-align: center; width: 24%; }
+  table.cmp td.yes { color: var(--accent); font-weight: 600; }
+  table.cmp td.no { color: var(--muted); }
+  table.cmp td small { display: block; color: var(--muted); font-weight: 400; font-size: 0.78rem; }
+  .lede { font-size: 1.05rem; line-height: 1.65; margin: 0 0 0.2rem; }
+  .terms-body { font-size: 0.9rem; line-height: 1.75; color: var(--muted); }
+  .terms-body h2 { font-size: 1rem; color: var(--fg); margin: 1.6rem 0 0.4rem; }
+  .draft { border-left: 3px solid var(--warn); padding: 0.2rem 0 0.2rem 0.9rem; margin: 0 0 1.4rem; font-size: 0.9rem; }
 </style>
 </head>
 <body>
@@ -3521,6 +4340,72 @@ function renderSetupPage() {
   <div class="brand">memgineering</div>
   <div id="error" class="err" hidden><b id="error-msg"></b><span id="error-hint"></span></div>
 
+  <section id="step-account" hidden>
+    <div class="steps" id="count-account"></div>
+    <h1>\uAE30\uC5B5\uC744 \uC5B4\uB514\uC5D0 \uB458\uAE4C\uC694?</h1>
+    <p class="lede">memgineering\uC740 <b>\uB2F9\uC2E0\uC774 \uC4F0\uB294 AI\uB4E4\uC774 \uD568\uAED8 \uBCF4\uB294 \uAE30\uC5B5</b>\uC785\uB2C8\uB2E4. \uD55C \uBC88 \uB9D0\uD55C \uAC83\uC744 \uB2E4\uC74C \uB300\uD654\uC5D0\uC11C, \uB2E4\uB978 AI\uC5D0\uC11C, \uB0B4\uC77C\uB3C4 \uADF8\uB300\uB85C \uC501\uB2C8\uB2E4. \uB9E4\uBC88 \uCC98\uC74C\uBD80\uD130 \uC124\uBA85\uD558\uC9C0 \uC54A\uC544\uB3C4 \uB429\uB2C8\uB2E4.</p>
+    <p class="sub">\uBE44\uC5B4 \uC788\uB294 \uCC44\uB85C \uC2DC\uC791\uD569\uB2C8\uB2E4. \uC4F0\uB294 \uB3D9\uC548 \uCC44\uC6CC\uC9D1\uB2C8\uB2E4.</p>
+
+    <table class="cmp">
+      <thead>
+        <tr><th></th><th>\uC774 \uCEF4\uD4E8\uD130\uC5D0\uB9CC</th><th>\uACC4\uC815\uC5D0 \uB450\uAE30</th></tr>
+      </thead>
+      <tbody>
+        <tr><th>\uC9C0\uAE08 \uC4F0\uB294 AI\uAC00 \uC77D\uACE0 \uC501\uB2C8\uB2E4</th><td class="yes">\u2713</td><td class="yes">\u2713</td></tr>
+        <tr><th>\uBAA8\uB4E0 \uBCC0\uACBD\uC774 \uAE30\uB85D\uB418\uACE0 \uB418\uB3CC\uB9B4 \uC218 \uC788\uC2B5\uB2C8\uB2E4</th><td class="yes">\u2713</td><td class="yes">\u2713</td></tr>
+        <tr><th>\uAC00\uC785\uD558\uC9C0 \uC54A\uC544\uB3C4 \uC804\uBD80 \uB3D9\uC791\uD569\uB2C8\uB2E4</th><td class="yes">\u2713</td><td class="no">\u2014</td></tr>
+        <tr><th>\uB2E4\uB978 \uCEF4\uD4E8\uD130\uC5D0\uC11C\uB3C4 \uAC19\uC740 \uAE30\uC5B5</th><td class="no">\u2014</td><td class="yes">\u2713</td></tr>
+        <tr><th>\uC774 \uCEF4\uD4E8\uD130\uAC00 \uC5C6\uC5B4\uC838\uB3C4 \uAE30\uC5B5\uC740 \uB0A8\uC2B5\uB2C8\uB2E4</th><td class="no">\u2014</td><td class="yes">\u2713</td></tr>
+        <tr><th>\uC5B8\uC81C\uB4E0 \uD3F4\uB354\uB85C \uB0B4\uB824\uBC1B\uAE30</th><td class="no"><small>\uC6D0\uB798 \uD3F4\uB354\uC785\uB2C8\uB2E4</small></td><td class="yes">\u2713</td></tr>
+        <tr><th>\uBE44\uC6A9</th><td class="no"><small>\uBB34\uB8CC</small></td><td class="yes">\uBB34\uB8CC<small>\uBE0C\uB808\uC778 1\uAC1C</small></td></tr>
+      </tbody>
+    </table>
+
+    <button class="card" id="account-cloud" aria-checked="false"><span class="tick"></span><span><b>\uACC4\uC815\uC5D0 \uB450\uAE30<span class="badge">\uAD8C\uC7A5</span></b><small>\uAD6C\uAE00 \uACC4\uC815\uC73C\uB85C \uB85C\uADF8\uC778\uD569\uB2C8\uB2E4. \uAE30\uC5B5\uC774 \uAE30\uAE30\uC640 \uB3C4\uAD6C\uB97C \uB530\uB77C\uB2E4\uB2D9\uB2C8\uB2E4.</small></span></button>
+    <button class="card" id="account-local" aria-checked="false"><span class="tick"></span><span><b>\uC774 \uCEF4\uD4E8\uD130\uC5D0\uB9CC \uB450\uAE30</b><small>\uAC00\uC785 \uC5C6\uC774 \uC9C0\uAE08 \uBC14\uB85C. \uB098\uC911\uC5D0 \uACC4\uC815\uC73C\uB85C \uC62E\uAE38 \uC218 \uC788\uC2B5\uB2C8\uB2E4.</small></span></button>
+
+    <div class="row">
+      <button class="primary" id="account-next" disabled>\uB2E4\uC74C</button>
+      <button class="ghost" id="account-terms">\uC57D\uAD00 \uBCF4\uAE30</button>
+    </div>
+    <p class="note">\uACC4\uC815\uC744 \uB9CC\uB4E4\uBA74 \uB178\uD2B8\uAC00 memgineering \uC11C\uBC84\uC5D0 \uC800\uC7A5\uB429\uB2C8\uB2E4. \uC5B4\uB290 \uCABD\uC744 \uACE0\uB974\uB4E0 \uC6D0\uBCF8\uC740 \uB9C8\uD06C\uB2E4\uC6B4 \uD30C\uC77C\uC774\uACE0, \uC5B8\uC81C\uB4E0 \uD3F4\uB354\uB85C \uAEBC\uB0BC \uC218 \uC788\uC2B5\uB2C8\uB2E4.</p>
+  </section>
+
+  <section id="step-terms" hidden>
+    <h1>\uC57D\uAD00</h1>
+    <div class="draft">
+      <b>\uCD08\uC548\uC785\uB2C8\uB2E4.</b> \uC544\uC9C1 \uBC95\uB960 \uAC80\uD1A0\uB97C \uAC70\uCE58\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. \uC815\uC2DD \uC57D\uAD00\uC774 \uC900\uBE44\uB418\uBA74 \uC774 \uD654\uBA74\uC774 \uAD50\uCCB4\uB418\uACE0, \uADF8 \uC804\uAE4C\uC9C0\uB294 \uC774 \uB0B4\uC6A9\uC744 \uACC4\uC57D\uC73C\uB85C \uC0BC\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.
+    </div>
+    <div class="terms-body">
+      <h2>\uC774\uC6A9\uC57D\uAD00 (\uCD08\uC548)</h2>
+      <p><b>1. \uC774 \uC11C\uBE44\uC2A4\uAC00 \uD558\uB294 \uC77C.</b> memgineering\uC740 \uC0AC\uC6A9\uC790\uAC00 \uC791\uC131\uD55C \uB178\uD2B8\uB97C \uC800\uC7A5\uD558\uACE0, \uC0AC\uC6A9\uC790\uAC00 \uC5F0\uACB0\uD55C AI \uB3C4\uAD6C\uAC00 \uADF8 \uB178\uD2B8\uB97C \uC77D\uACE0 \uC4F8 \uC218 \uC788\uAC8C \uD569\uB2C8\uB2E4.</p>
+      <p><b>2. \uB178\uD2B8\uC758 \uC18C\uC720\uAD8C.</b> \uC0AC\uC6A9\uC790\uAC00 \uC4F4 \uAC83\uC740 \uC0AC\uC6A9\uC790\uC758 \uAC83\uC785\uB2C8\uB2E4. \uC6B4\uC601\uC790\uB294 \uB178\uD2B8\uC758 \uC18C\uC720\uAD8C\uC744 \uC8FC\uC7A5\uD558\uC9C0 \uC54A\uC73C\uBA70, \uB178\uD2B8\uB97C \uD559\uC2B5\uC5D0 \uC0AC\uC6A9\uD558\uAC70\uB098 \uC81C3\uC790\uC5D0\uAC8C \uD310\uB9E4\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.</p>
+      <p><b>3. \uC5B8\uC81C\uB4E0 \uAC00\uC838\uAC08 \uC218 \uC788\uC2B5\uB2C8\uB2E4.</b> \uC800\uC7A5\uB41C \uB178\uD2B8\uB294 \uC6D0\uB798 \uACBD\uB85C \uADF8\uB300\uB85C \uB9C8\uD06C\uB2E4\uC6B4 \uD30C\uC77C\uB85C \uB0B4\uB824\uBC1B\uC744 \uC218 \uC788\uC2B5\uB2C8\uB2E4. \uC774 \uAD8C\uB9AC\uB97C \uC81C\uD55C\uD558\uB294 \uC870\uAC74\uC740 \uB450\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.</p>
+      <p><b>4. \uC0AD\uC81C.</b> \uBE0C\uB808\uC778\uC744 \uC9C0\uC6B0\uBA74 \uADF8 \uB178\uD2B8\xB7\uAE30\uB85D\xB7\uC77D\uC740 \uC774\uB825\uC774 \uD568\uAED8 \uC0AC\uB77C\uC9D1\uB2C8\uB2E4. \uACC4\uC815\uC744 \uC9C0\uC6B0\uBA74 \uACC4\uC815\uC5D0 \uC18D\uD55C \uBAA8\uB4E0 \uBE0C\uB808\uC778\uC774 \uC0AC\uB77C\uC9D1\uB2C8\uB2E4.</p>
+      <p><b>5. \uBB34\uB8CC \uBC94\uC704.</b> \uBE0C\uB808\uC778 1\uAC1C\uB294 \uACC4\uC18D \uBB34\uB8CC\uC785\uB2C8\uB2E4. \uC720\uB8CC \uD56D\uBAA9\uC774 \uC0DD\uAE30\uBA74 \uBBF8\uB9AC \uC54C\uB9AC\uACE0, \uC774\uBBF8 \uC800\uC7A5\uB41C \uB178\uD2B8\uB97C \uC778\uC9C8\uB85C \uC0BC\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.</p>
+      <p><b>6. \uBCF4\uC99D\uD558\uC9C0 \uC54A\uB294 \uAC83.</b> \uC774 \uC11C\uBE44\uC2A4\uB294 \uD604\uC7AC \uC0C1\uD0DC \uADF8\uB300\uB85C \uC81C\uACF5\uB429\uB2C8\uB2E4. \uB370\uC774\uD130\uAC00 \uC5B4\uB5A4 \uC0C1\uD669\uC5D0\uC11C\uB3C4 \uC0AC\uB77C\uC9C0\uC9C0 \uC54A\uB294\uB2E4\uACE0 \uBCF4\uC99D\uD558\uC9C0 \uC54A\uC73C\uBBC0\uB85C, \uC911\uC694\uD55C \uB178\uD2B8\uB294 \uC0AC\uC6A9\uC790 \uCABD\uC5D0\uB3C4 \uC0AC\uBCF8\uC744 \uB450\uC2DC\uAE30\uB97C \uAD8C\uD569\uB2C8\uB2E4.</p>
+      <p><b>7. \uAE08\uC9C0.</b> \uD0C0\uC778\uC758 \uBE44\uBC00\xB7\uC790\uACA9\uC99D\uBA85\uC744 \uBB34\uB2E8\uC73C\uB85C \uC800\uC7A5\uD558\uAC70\uB098, \uC11C\uBE44\uC2A4\uB97C \uACF5\uACA9\uD558\uAC70\uB098, \uBC95\uC744 \uC5B4\uAE30\uB294 \uB370 \uC4F0\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.</p>
+
+      <h2>\uAC1C\uC778\uC815\uBCF4 \uCC98\uB9AC\uBC29\uCE68 (\uCD08\uC548)</h2>
+      <p><b>1. \uBC1B\uB294 \uAC83.</b> \uAD6C\uAE00 \uB85C\uADF8\uC778\uC73C\uB85C \uBC1B\uB294 \uC774\uBA54\uC77C \uC8FC\uC18C\uC640 \uD45C\uC2DC \uC774\uB984, \uC0AC\uC6A9\uC790\uAC00 \uC800\uC7A5\uD55C \uB178\uD2B8, \uADF8\uB9AC\uACE0 \uBB34\uC5C7\uC744 \uC5B8\uC81C \uD68C\uC0C1\uD588\uB294\uC9C0\uC758 \uAE30\uB85D.</p>
+      <p><b>2. \uD68C\uC0C1 \uAE30\uB85D\uC744 \uB0A8\uAE30\uB294 \uC774\uC720.</b> \uC5B4\uB5A4 \uAE30\uC5B5\uC774 \uC2E4\uC81C\uB85C \uB3C4\uC6C0\uC774 \uB410\uB294\uC9C0\uB97C \uC7AC\uB294 \uC720\uC77C\uD55C \uBC29\uBC95\uC774\uACE0, \uADF8\uAC83\uC73C\uB85C \uB2E4\uC74C \uD68C\uC0C1\uC758 \uC21C\uC11C\uB97C \uC815\uD569\uB2C8\uB2E4. \uC774 \uAE30\uB85D\uC740 \uC0AC\uC6A9\uC790 \uBCF8\uC778\uC758 \uBE0C\uB808\uC778 \uC548\uC5D0\uB9CC \uB0A8\uC2B5\uB2C8\uB2E4.</p>
+      <p><b>3. \uD558\uC9C0 \uC54A\uB294 \uAC83.</b> \uB178\uD2B8\uB97C \uBAA8\uB378 \uD559\uC2B5\uC5D0 \uC4F0\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4. \uB178\uD2B8\uB97C \uAD11\uACE0\uC5D0 \uC4F0\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4. \uB178\uD2B8\uB97C \uC81C3\uC790\uC5D0\uAC8C \uD314\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.</p>
+      <p><b>4. \uC5B4\uB5BB\uAC8C \uC800\uC7A5\uB418\uB294\uAC00.</b> \uACC4\uC815\uC5D0 \uC62C\uB9B0 \uB178\uD2B8\uB294 \uC11C\uBC84\uC5D0 <b>\uD3C9\uBB38\uC73C\uB85C</b> \uC800\uC7A5\uB429\uB2C8\uB2E4. \uC885\uB2E8\uAC04 \uC554\uD638\uD654\uAC00 \uC544\uB2C8\uBA70, \uC11C\uBC84\uB97C \uC6B4\uC601\uD558\uB294 \uC0AC\uB78C\uC740 \uAE30\uC220\uC801\uC73C\uB85C \uB178\uD2B8\uB97C \uC77D\uC744 \uC218 \uC788\uC2B5\uB2C8\uB2E4. \uC77D\uC9C0 \uC54A\uB294 \uAC83\uC740 \uC57D\uC18D\uC774\uC9C0 \uBD88\uAC00\uB2A5\uC774 \uC544\uB2D9\uB2C8\uB2E4. \uADF8\uAC83\uC73C\uB85C \uCDA9\uBD84\uD558\uC9C0 \uC54A\uC740 \uB178\uD2B8\uB294 \uACC4\uC815\uC5D0 \uC62C\uB9AC\uC9C0 \uB9C8\uC2DC\uACE0, \uC774 \uCEF4\uD4E8\uD130\uC5D0\uB9CC \uB450\uC2DC\uAC70\uB098 <code>.memgignore</code>\uB85C \uBE7C\uB450\uC2ED\uC2DC\uC624.</p>
+      <p><b>5. \uC790\uACA9\uC99D\uBA85 \uCC28\uB2E8.</b> API \uD0A4\xB7\uBE44\uBC00\uBC88\uD638\uCC98\uB7FC \uBCF4\uC774\uB294 \uB0B4\uC6A9\uC740 \uC800\uC7A5 \uC804\uC5D0 \uAC70\uBD80\uB429\uB2C8\uB2E4. \uC644\uBCBD\uD55C \uCC28\uB2E8\uC744 \uBCF4\uC99D\uD558\uC9C0\uB294 \uC54A\uC2B5\uB2C8\uB2E4.</p>
+      <p><b>6. \uBCF4\uAD00 \uAE30\uAC04.</b> \uC0AC\uC6A9\uC790\uAC00 \uC9C0\uC6B8 \uB54C\uAE4C\uC9C0 \uBCF4\uAD00\uD569\uB2C8\uB2E4. \uACC4\uC815\uC744 \uC9C0\uC6B0\uBA74 \uD568\uAED8 \uC9C0\uC6C1\uB2C8\uB2E4.</p>
+      <p><b>7. \uBB38\uC758.</b> memgineering@gmail.com</p>
+
+      <h2>\uC544\uC9C1 \uC815\uD558\uC9C0 \uBABB\uD55C \uAC83</h2>
+      <p>\uCD08\uC548\uC5D0 \uC5C6\uB294 \uD56D\uBAA9\uC744 \uC5C6\uB294 \uCC44\uB85C \uB450\uC9C0 \uC54A\uACE0 \uC801\uC5B4 \uB461\uB2C8\uB2E4. \uC544\uB798\uB294 \uC544\uC9C1 \uC815\uD574\uC9C0\uC9C0 \uC54A\uC558\uACE0, \uC815\uC2DD \uC57D\uAD00\uC5D0\uC11C \uB2F5\uD569\uB2C8\uB2E4. \uC9C0\uAE08 \uC774 \uC11C\uBE44\uC2A4\uB97C \uC4F0\uAE30\uB85C \uD558\uC2E0\uB2E4\uBA74 \uC774\uAC83\uB4E4\uC774 \uBBF8\uC815\uC778 \uC0C1\uD0DC\uB85C \uC4F0\uC2DC\uB294 \uAC83\uC785\uB2C8\uB2E4.</p>
+      <p>\xB7 \uC11C\uBE44\uC2A4\uB97C \uC6B4\uC601\uD558\uB294 \uBC95\uC801 \uC8FC\uCCB4\uC640 \uBD84\uC7C1 \uC2DC \uAD00\uD560<br />
+      \xB7 \uC11C\uBC84\uC640 \uB370\uC774\uD130\uAC00 \uC704\uCE58\uD55C \uAD6D\uAC00, \uC678\uBD80 \uCC98\uB9AC\uC5C5\uCCB4<br />
+      \xB7 \uC0AD\uC81C \uC694\uCCAD \uD6C4 \uBC31\uC5C5\uC5D0\uC11C \uC2E4\uC81C\uB85C \uC9C0\uC6CC\uC9C0\uAE30\uAE4C\uC9C0 \uAC78\uB9AC\uB294 \uC2DC\uAC04<br />
+      \xB7 \uBCF4\uC548 \uC0AC\uACE0\uAC00 \uB0AC\uC744 \uB54C \uC54C\uB9AC\uB294 \uBC29\uC2DD\uACFC \uC2DC\uD55C<br />
+      \xB7 \uACC4\uC815 \uC804\uCCB4\uB97C \uC9C0\uC6B0\uB294 \uD654\uBA74 (\uC9C0\uAE08\uC740 \uC694\uCCAD\uC73C\uB85C\uB9CC \uAC00\uB2A5\uD569\uB2C8\uB2E4)</p>
+    </div>
+    <div class="row"><button class="primary" id="terms-back">\uB3CC\uC544\uAC00\uAE30</button></div>
+  </section>
+
   <section id="step-tools" hidden>
     <div class="steps" id="count-tools"></div>
     <h1>\uC5B4\uB5A4 AI\uAC00 \uC774 \uAE30\uC5B5\uC744 \uC4F0\uAC8C \uD560\uAE4C\uC694?</h1>
@@ -3537,26 +4422,26 @@ function renderSetupPage() {
     <h1>\uC790\uB3D9\uC73C\uB85C \uCD5C\uC2E0 \uC0C1\uD0DC\uB97C \uC720\uC9C0\uD560\uAE4C\uC694?</h1>
     <p class="sub">\uD558\uB8E8\uC5D0 \uD55C \uBC88 \uC0C8 \uBC84\uC804\uC774 \uC788\uB294\uC9C0 \uD655\uC778\uD558\uACE0, \uC788\uC73C\uBA74 \uC870\uC6A9\uD788 \uC124\uCE58\uD569\uB2C8\uB2E4.</p>
     <button class="card" id="update-on" aria-checked="false"><span class="tick"></span><span><b>\uB124, \uC54C\uC544\uC11C \uCD5C\uC2E0\uC73C\uB85C<span class="badge">\uAD8C\uC7A5</span></b><small>\uB2E4\uC2DC \uC2E0\uACBD \uC4F0\uC9C0 \uC54A\uC544\uB3C4 \uB429\uB2C8\uB2E4.</small></span></button>
-    <button class="card" id="update-off" aria-checked="false"><span class="tick"></span><span><b>\uC544\uB2C8\uC694, \uC81C\uAC00 \uC9C1\uC811 \uD558\uACA0\uC2B5\uB2C8\uB2E4</b><small>\uC6D0\uD560 \uB54C <code>memgineering update</code> \uB97C \uC2E4\uD589\uD558\uBA74 \uB429\uB2C8\uB2E4.</small></span></button>
+    <button class="card" id="update-off" aria-checked="false"><span class="tick"></span><span><b>\uC544\uB2C8\uC694, \uC81C\uAC00 \uC9C1\uC811 \uD558\uACA0\uC2B5\uB2C8\uB2E4</b><small>\uC0C8 \uBC84\uC804\uC774 \uB098\uC640\uB3C4 \uADF8\uB300\uB85C \uB461\uB2C8\uB2E4. \uB098\uC911\uC5D0 \uC62C\uB9AC\uACE0 \uC2F6\uC73C\uBA74 \uC4F0\uC2DC\uB294 AI\uC5D0\uAC8C \u201Cmemgineering \uCD5C\uC2E0\uC73C\uB85C \uC62C\uB824\uC918\u201D\uB77C\uACE0 \uD558\uC138\uC694.</small></span></button>
 
     <div id="hook-block" hidden>
       <h2>\uB300\uD654\uB97C \uC0C8\uB85C \uC5F4 \uB54C\uB9C8\uB2E4 \uB178\uD2B8 \uC694\uC57D\uC744 \uBA3C\uC800 \uBCF4\uC5EC\uC904\uAE4C\uC694?</h2>
       <p class="sub">Claude Code\uC5D0\uC11C\uB9CC \uC791\uB3D9\uD569\uB2C8\uB2E4. \uC0C8 \uB300\uD654\uB97C \uC2DC\uC791\uD560 \uB54C, \uCD5C\uADFC \uB178\uD2B8 \uC694\uC57D \uBA87 \uAC1C\uB97C \uBB3B\uC9C0 \uC54A\uC544\uB3C4 AI\uC5D0\uAC8C \uBA3C\uC800 \uAC74\uB135\uB2C8\uB2E4.</p>
-      <button class="card" id="hook-on" aria-checked="false"><span class="tick"></span><span><b>\uB124, \uB9E4\uBC88 \uBA3C\uC800 \uAC74\uB124\uC8FC\uC138\uC694<span class="badge">\uAE30\uBCF8</span></b><small>\uC5B4\uB514\uAE4C\uC9C0 \uD588\uB294\uC9C0 AI\uAC00 \uC54C\uACE0 \uC2DC\uC791\uD569\uB2C8\uB2E4.</small></span></button>
+      <button class="card" id="hook-on" aria-checked="false"><span class="tick"></span><span><b>\uB124, \uB9E4\uBC88 \uBA3C\uC800 \uAC74\uB124\uC8FC\uC138\uC694</b><small>\uC5B4\uB514\uAE4C\uC9C0 \uD588\uB294\uC9C0 AI\uAC00 \uC54C\uACE0 \uC2DC\uC791\uD569\uB2C8\uB2E4.</small></span></button>
       <button class="card" id="hook-off" aria-checked="false"><span class="tick"></span><span><b>\uC544\uB2C8\uC694, \uBB3C\uC5B4\uBCFC \uB54C\uB9CC</b><small>\uC81C\uAC00 \uCC3E\uC544\uB2EC\uB77C\uACE0 \uD560 \uB54C\uB9CC \uAE30\uC5B5\uC744 \uAEBC\uB0C5\uB2C8\uB2E4.</small></span></button>
       <div class="warnbox">
         \uC9C1\uC811 \uC4F4 \uAC1C\uC778\uC801\uC778 \uB178\uD2B8\uC758 \uC694\uC57D\uB3C4 \uC5EC\uAE30 \uD3EC\uD568\uB429\uB2C8\uB2E4. \uBB3C\uC5B4\uBCF4\uC9C0 \uC54A\uC544\uB3C4 AI \uC55E\uC5D0 \uB193\uC778\uB2E4\uB294 \uB73B\uC785\uB2C8\uB2E4.
-        \uBCF4\uC774\uACE0 \uC2F6\uC9C0 \uC54A\uC740 \uB178\uD2B8\uB294 <code>memgineering exclude &lt;path&gt;</code> \uB85C \uBE7C\uB458 \uC218 \uC788\uACE0,
-        \uC774 \uC124\uC815\uC740 \uB098\uC911\uC5D0 \uB2E4\uC2DC \uB04C \uC218 \uC788\uC2B5\uB2C8\uB2E4.
+        \uBCF4\uC774\uACE0 \uC2F6\uC9C0 \uC54A\uC740 \uB178\uD2B8\uAC00 \uC788\uC73C\uBA74 \uC4F0\uC2DC\uB294 AI\uC5D0\uAC8C \u201C\uC774 \uB178\uD2B8\uB294 \uBE7C\uC918\u201D\uB77C\uACE0 \uD558\uBA74 \uB429\uB2C8\uB2E4.
+        \uC774 \uC124\uC815\uB3C4 \uB098\uC911\uC5D0 \uB2E4\uC2DC \uB04C \uC218 \uC788\uC2B5\uB2C8\uB2E4.
       </div>
     </div>
 
-    <div class="row"><button class="primary" id="options-next">\uB2E4\uC74C</button><button class="ghost" id="options-back">\uB4A4\uB85C</button></div>
+    <div class="row"><button class="primary" id="options-next" disabled>\uB2E4\uC74C</button><button class="ghost" id="options-back">\uB4A4\uB85C</button></div>
   </section>
 
   <section id="step-brain" hidden>
     <div class="steps" id="count-brain"></div>
-    <h1>\uAE30\uC5B5\uC744 \uC5B4\uB514\uC5D0 \uB2F4\uC744\uAE4C\uC694?</h1>
+    <h1>\uC5B4\uB290 \uD3F4\uB354\uB97C \uC4F8\uAE4C\uC694?</h1>
     <p class="sub">\uC774\uBBF8 \uC4F0\uACE0 \uC788\uB294 \uB178\uD2B8 \uD3F4\uB354\uB97C \uADF8\uB300\uB85C \uC77D\uC2B5\uB2C8\uB2E4. \uD3F4\uB354 \uAD6C\uC870\uB294 \uC190\uB300\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.</p>
 
     <div id="candidate-list"></div>
@@ -3593,12 +4478,13 @@ function renderSetupPage() {
     <h1 id="done-title">\uC124\uCE58\uB97C \uB9C8\uCCE4\uC2B5\uB2C8\uB2E4.</h1>
     <p class="sub"><b>\uC4F0\uACE0 \uC788\uB358 AI \uB300\uD654\uB97C \uAED0\uB2E4\uAC00 \uB2E4\uC2DC \uC2DC\uC791\uD574\uC57C \uC801\uC6A9\uB429\uB2C8\uB2E4.</b> \uC548\uB0B4\uBB38\uC740 \uB300\uD654\uAC00 \uC2DC\uC791\uB420 \uB54C \uD55C \uBC88 \uC77D\uD788\uAE30 \uB54C\uBB38\uC785\uB2C8\uB2E4.</p>
     <ul class="plain" id="done-list"></ul>
+    <div class="facts" id="done-account" hidden></div>
     <div class="facts" id="done-brain" hidden></div>
     <div id="done-nobrain" hidden>
-      <p class="note"><b>\uC544\uC9C1 \uC5F0\uACB0\uB41C \uB178\uD2B8\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.</b> \uD130\uBBF8\uB110\uC5D0\uC11C \uC774\uB807\uAC8C \uC5F0\uACB0\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.</p>
+      <p class="note"><b>\uC544\uC9C1 \uC5F0\uACB0\uB41C \uB178\uD2B8\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.</b> \uC4F0\uC2DC\uB294 AI\uC5D0\uAC8C \uC774\uB807\uAC8C \uB9D0\uD558\uBA74 \uB429\uB2C8\uB2E4.</p>
       <ul class="plain">
-        <li><code>memgineering link &lt;\uB178\uD2B8-\uD3F4\uB354&gt;</code><br /><small>\uBB34\uC5C7\uC774 \uC800\uC7A5\uB418\uB294\uC9C0 \uBA3C\uC800 \uBCF4\uC5EC\uC8FC\uACE0, \uADF8\uB2E4\uC74C \uBB3C\uC5B4\uBD05\uB2C8\uB2E4</small></li>
-        <li><code>memgineering init &lt;\uACBD\uB85C&gt;</code><br /><small>\uC544\uC9C1 \uB178\uD2B8\uAC00 \uC5C6\uB2E4\uBA74 \u2014 \uBF08\uB300\uAE4C\uC9C0 \uAC16\uCD98 \uC0C8 \uAE30\uC5B5\uC744 \uB9CC\uB4ED\uB2C8\uB2E4</small></li>
+        <li>\u201C\uB0B4 \uB178\uD2B8 \uD3F4\uB354 \uC5F0\uACB0\uD574\uC918\u201D<br /><small>\uBB34\uC5C7\uC774 \uC800\uC7A5\uB418\uB294\uC9C0 \uBA3C\uC800 \uBCF4\uC5EC\uC8FC\uACE0, \uADF8\uB2E4\uC74C \uBB3C\uC5B4\uBD05\uB2C8\uB2E4</small></li>
+        <li>\u201C\uC0C8 \uAE30\uC5B5 \uD558\uB098 \uB9CC\uB4E4\uC5B4\uC918\u201D<br /><small>\uC544\uC9C1 \uB178\uD2B8\uAC00 \uC5C6\uB2E4\uBA74 \u2014 \uBF08\uB300\uAE4C\uC9C0 \uAC16\uCD98 \uC0C8 \uAE30\uC5B5\uC744 \uB9CC\uB4ED\uB2C8\uB2E4</small></li>
       </ul>
     </div>
     <p class="note">\uC774 \uD0ED\uC740 \uB2EB\uC73C\uC154\uB3C4 \uB429\uB2C8\uB2E4. \uC124\uCE58 \uD654\uBA74\uC740 \uC774\uBBF8 \uC2A4\uC2A4\uB85C \uC885\uB8CC\uD588\uC2B5\uB2C8\uB2E4.</p>
@@ -3606,7 +4492,7 @@ function renderSetupPage() {
 
   <section id="step-closed" hidden>
     <h1>\uB2EB\uC558\uC2B5\uB2C8\uB2E4.</h1>
-    <p class="sub">\uC544\uBB34\uAC83\uB3C4 \uBC14\uB00C\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. \uC5B8\uC81C\uB4E0 <code>memgineering setup --web</code> \uC744 \uB2E4\uC2DC \uC2E4\uD589\uD558\uBA74 \uB429\uB2C8\uB2E4.</p>
+    <p class="sub">\uC544\uBB34\uAC83\uB3C4 \uBC14\uB00C\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. \uB2E4\uC2DC \uD558\uACE0 \uC2F6\uC73C\uBA74 \uC4F0\uC2DC\uB294 AI\uC5D0\uAC8C \u201Cmemgineering \uC124\uC815 \uD654\uBA74 \uB2E4\uC2DC \uC5F4\uC5B4\uC918\u201D\uB77C\uACE0 \uD558\uC138\uC694.</p>
   </section>
 </main>
 
@@ -3620,8 +4506,9 @@ ${pageScript()}
 function pageScript() {
   return `(function () {
   var token = new URLSearchParams(location.search).get('t') || '';
-  var STEPS = ['step-tools', 'step-options', 'step-brain', 'step-review'];
+  var STEPS = ['step-account', 'step-tools', 'step-options', 'step-brain', 'step-review'];
   var state = {
+    account: null,
     tools: [],
     selected: [],
     autoUpdate: 'on',
@@ -3635,30 +4522,59 @@ function pageScript() {
   function el(id) { return document.getElementById(id); }
   function num(n) { return Number(n || 0).toLocaleString('ko-KR'); }
 
+  /*
+   * The server behind this page is a process on this machine, and it stops:
+   * when the setup is applied, when it has been idle a while, when somebody
+   * presses Ctrl-C in the terminal it was launched from. The page stays on
+   * screen after that, and its next request has nothing to reach.
+   *
+   * The browser calls that "Failed to fetch", and that is what the screen used
+   * to show \u2014 a sentence that reads like a bug in the tool and gives no way
+   * forward. It is not a bug and there is a way forward, so it says so.
+   */
   function api(path, options) {
-    return fetch(path + '?t=' + encodeURIComponent(token), options).then(function (res) {
-      return res.text().then(function (text) {
-        var body = {};
-        try { body = text ? JSON.parse(text) : {}; } catch (e) { body = {}; }
-        if (!res.ok) {
-          throw body.error || { message: '\uC124\uCE58 \uD654\uBA74\uC774 \uADF8 \uC694\uCCAD\uC744 \uAC70\uC808\uD588\uC2B5\uB2C8\uB2E4 (' + res.status + ').', hint: '' };
-        }
-        return body;
-      });
-    });
+    return fetch(path + '?t=' + encodeURIComponent(token), options).then(
+      function (res) {
+        return res.text().then(function (text) {
+          var body = {};
+          try { body = text ? JSON.parse(text) : {}; } catch (e) { body = {}; }
+          if (!res.ok) {
+            throw body.error || { message: '\uC124\uCE58 \uD654\uBA74\uC774 \uADF8 \uC694\uCCAD\uC744 \uAC70\uC808\uD588\uC2B5\uB2C8\uB2E4 (' + res.status + ').', hint: '' };
+          }
+          return body;
+        });
+      },
+      function () {
+        gone = true;
+        throw {
+          message: '\uC774 \uC124\uCE58 \uD654\uBA74\uC740 \uC774\uBBF8 \uB2EB\uD614\uC2B5\uB2C8\uB2E4.',
+          hint: '\uC4F0\uC2DC\uB294 AI\uC5D0\uAC8C \u201Cmemgineering \uC124\uC815 \uD654\uBA74 \uB2E4\uC2DC \uC5F4\uC5B4\uC918\u201D\uB77C\uACE0 \uD558\uBA74 \uC0C8 \uD654\uBA74\uC774 \uC5F4\uB9BD\uB2C8\uB2E4. \uC5EC\uAE30\uC11C \uACE0\uB978 \uAC83\uB4E4\uC740 \uC544\uC9C1 \uC544\uBB34\uAC83\uB3C4 \uC801\uC6A9\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.',
+        };
+      },
+    );
   }
 
+  /* Once the server is gone it does not come back \u2014 nothing here can retry. */
+  var gone = false;
+
   function fail(err) {
     el('error').hidden = false;
     el('error-msg').textContent = (err && err.message) ? err.message : '\uBB38\uC81C\uAC00 \uC0DD\uACBC\uC2B5\uB2C8\uB2E4.';
     el('error-hint').textContent = (err && err.hint) ? err.hint : '';
+    // A dead server cannot be retried into life, so the buttons stop pretending.
+    // Leaving them live invites a second click, a second identical failure, and
+    // the conclusion that the tool is broken rather than finished.
+    if (gone) {
+      var buttons = document.querySelectorAll('button');
+      for (var i = 0; i < buttons.length; i++) buttons[i].disabled = true;
+    }
     window.scrollTo(0, 0);
   }
 
   function clearError() { el('error').hidden = true; }
 
   function show(id) {
-    var all = STEPS.concat(['step-done', 'step-closed']);
+    var all = STEPS.concat(['step-terms', 'step-done', 'step-closed']);
     for (var i = 0; i < all.length; i++) el(all[i]).hidden = all[i] !== id;
   }
 
@@ -3719,11 +4635,33 @@ function pageScript() {
 
   /* ---- step 2: updates, and the session hook ---- */
 
+  /*
+   * Nothing here starts selected, and that is the whole point of the screen.
+   *
+   * Both questions used to arrive pre-answered \u2014 the hook ON whenever a
+   * hook-capable tool was found \u2014 so the screen looked like a question, was
+   * already answered, and got clicked past. The CLI at least says "nobody was
+   * asked about: session-start hook: on" when there is no terminal to ask in.
+   * Here a person is looking straight at it, which makes an unnoticed default
+   * worse rather than better.
+   *
+   * The hook is the one that earns this. It puts note summaries in front of an
+   * agent at the start of every session, and a tester who left it on found a
+   * line from their own journal arriving as card five of every conversation.
+   * Nothing had lied to them; nobody had asked them either.
+   */
   function refreshHookBlock() {
     state.hookCapable = state.tools.some(function (t) {
       return t.hooks && t.detected && state.selected.indexOf(t.id) !== -1;
     });
     el('hook-block').hidden = !state.hookCapable;
+    refreshOptionsNext();
+  }
+
+  /* The next button opens only once both questions here have an answer. */
+  function refreshOptionsNext() {
+    var answered = state.autoUpdateChosen && (!state.hookCapable || state.hookChosen);
+    el('options-next').disabled = !answered;
   }
 
   /* ---- step 3: where the memory lives ---- */
@@ -3763,7 +4701,12 @@ function pageScript() {
       var name = document.createElement('b');
       name.textContent = candidate.label;
       var note = document.createElement('small');
-      note.textContent = candidate.path + (candidate.linked ? ' \xB7 \uC774\uBBF8 \uC5F0\uACB0\uB418\uC5B4 \uC788\uC2B5\uB2C8\uB2E4' : '');
+      /* \uAC1C\uC218\uB97C \uBA3C\uC800 \uB9D0\uD55C\uB2E4. \uC774 \uC904\uC774 \uC65C \uBAA9\uB85D\uC5D0 \uC788\uB294\uC9C0\uAC00 \uADF8 \uB2F5\uC774\uAE30 \uB54C\uBB38\uC774\uB2E4 \u2014
+         \uB178\uD2B8 1\uAC1C\uC9DC\uB9AC \uC0AC\uC9C4 \uD3F4\uB354\uC640 434\uAC1C\uC9DC\uB9AC \uB178\uD2B8 \uD3F4\uB354\uAC00 \uAC19\uC740 \uBAA8\uC591\uC73C\uB85C \uB098\uB780\uD788
+         \uC788\uC73C\uBA74, \uACE0\uB974\uB77C\uB294 \uC694\uAD6C\uAC00 \uB2F5\uD560 \uC218 \uC5C6\uB294 \uC694\uAD6C\uAC00 \uB41C\uB2E4. */
+      var count = candidate.notes >= 40 ? '\uB178\uD2B8 40\uAC1C \uC774\uC0C1' : '\uB178\uD2B8 ' + candidate.notes + '\uAC1C';
+      note.textContent = count + ' \xB7 ' + candidate.path +
+        (candidate.linked ? ' \xB7 \uC774\uBBF8 \uC5F0\uACB0\uB418\uC5B4 \uC788\uC2B5\uB2C8\uB2E4' : '');
       text.appendChild(name);
       text.appendChild(note);
       card.appendChild(tick);
@@ -3867,7 +4810,13 @@ function pageScript() {
 
     if (data.already_linked) addLine(box, '\uC774\uBBF8 \uC5F0\uACB0\uB41C \uD3F4\uB354\uC785\uB2C8\uB2E4. \uB2E4\uC2DC \uC77D\uC5B4 \uCD5C\uC2E0 \uC0C1\uD0DC\uB85C \uB9DE\uCDA5\uB2C8\uB2E4.');
 
-    addLine(box, '\uC800\uC7A5\uB418\uB294 \uAC83: \uAC01 \uB178\uD2B8\uC758 \uC81C\uBAA9\uACFC \uCCAB \uBB38\uB2E8\uC774 \uC4F0\uC778 \uADF8\uB300\uB85C \uC800\uC7A5\uB429\uB2C8\uB2E4. \uB178\uD2B8 \uC804\uCCB4\uAC00 \uC544\uB2C8\uB77C \uCCAB \uBB38\uB2E8\uC774\uC9C0\uB9CC, \uAC1C\uC778\uC801\uC778 \uB178\uD2B8\uC5D0\uC11C\uB294 \uCCAB \uC904\uC774 \uAC00\uC7A5 \uBBFC\uAC10\uD55C \uC904\uC778 \uACBD\uC6B0\uAC00 \uB9CE\uC2B5\uB2C8\uB2E4.');
+    addLine(box, '\uC774 \uCEF4\uD4E8\uD130\uC758 \uAC80\uC0C9 \uBAA9\uB85D\uC5D0 \uC800\uC7A5\uB418\uB294 \uAC83: \uAC01 \uB178\uD2B8\uC758 \uC81C\uBAA9\uACFC \uCCAB \uBB38\uB2E8\uC774 \uC4F0\uC778 \uADF8\uB300\uB85C \uC800\uC7A5\uB429\uB2C8\uB2E4. \uB178\uD2B8 \uC804\uCCB4\uAC00 \uC544\uB2C8\uB77C \uCCAB \uBB38\uB2E8\uC774\uC9C0\uB9CC, \uAC1C\uC778\uC801\uC778 \uB178\uD2B8\uC5D0\uC11C\uB294 \uCCAB \uC904\uC774 \uAC00\uC7A5 \uBBFC\uAC10\uD55C \uC904\uC778 \uACBD\uC6B0\uAC00 \uB9CE\uC2B5\uB2C8\uB2E4.');
+    /* \uACC4\uC815\uC744 \uACE0\uB978 \uC0AC\uB78C\uC5D0\uAC8C\uB294 \uC704 \uBB38\uC7A5\uC774 "\uC11C\uBC84\uC5D0 \uAC00\uB294 \uAC83\uB3C4 \uCCAB \uBB38\uB2E8\uBFD0"\uC73C\uB85C
+       \uC77D\uD78C\uB2E4. \uC0AC\uC2E4\uC774 \uC544\uB2C8\uB2E4 \u2014 \uACC4\uC815\uC5D0 \uC62C\uB9AC\uBA74 \uD30C\uC77C \uC804\uCCB4\uAC00 \uAC04\uB2E4. \uB450 \uAC00\uC9C0\uB97C
+       \uD55C \uD654\uBA74\uC5D0\uC11C \uAC08\uB77C \uB193\uC9C0 \uC54A\uC73C\uBA74 \uADF8\uAC74 \uC624\uD574\uAC00 \uC544\uB2C8\uB77C \uC774 \uD654\uBA74\uC774 \uB9CC\uB4E0 \uAC70\uC9D3\uB9D0\uC774\uB2E4. */
+    if (state.account === 'cloud') {
+      addLine(box, '\uACC4\uC815\uC5D0 \uC62C\uB9B4 \uB54C \uC800\uC7A5\uB418\uB294 \uAC83: \uB178\uD2B8 \uD30C\uC77C \uC804\uCCB4\uC785\uB2C8\uB2E4. \uCCAB \uBB38\uB2E8\uB9CC\uC774 \uC544\uB2D9\uB2C8\uB2E4. \uC62C\uB9AC\uB294 \uAC83\uC740 \uBCC4\uB3C4 \uB2E8\uACC4\uC774\uACE0, \uC9C0\uAE08 \uC774 \uD654\uBA74\uC740 \uC62C\uB9AC\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.');
+    }
 
     if (data.excluded > 0) addLine(box, '\uADDC\uCE59\uC5D0 \uB530\uB77C \uAC74\uB108\uB6F4 \uACBD\uB85C ' + num(data.excluded) + '\uAC1C');
 
@@ -3927,6 +4876,10 @@ function pageScript() {
     list.textContent = '';
     var rows = [];
 
+    rows.push(state.account === 'cloud'
+      ? '\uAE30\uC5B5 \uC800\uC7A5: \uACC4\uC815\uC5D0 \uB450\uAE30 \u2014 \uC801\uC6A9 \uB4A4 \uAD6C\uAE00 \uB85C\uADF8\uC778\uC774 \uC5F4\uB9BD\uB2C8\uB2E4'
+      : '\uAE30\uC5B5 \uC800\uC7A5: \uC774 \uCEF4\uD4E8\uD130\uC5D0\uB9CC \u2014 \uACC4\uC815\uC744 \uB9CC\uB4E4\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4');
+
     state.tools.forEach(function (tool) {
       if (state.selected.indexOf(tool.id) === -1) return;
       rows.push(tool.label + ' \u2014 \uAE30\uC5B5 \uC548\uB0B4\uBB38\uACFC \uC2A4\uD0AC 2\uAC1C\uB97C \uC124\uCE58\uD569\uB2C8\uB2E4');
@@ -3975,6 +4928,7 @@ function pageScript() {
       method: 'POST',
       headers: { 'content-type': 'application/json' },
       body: JSON.stringify({
+        account: state.account,
         tools: state.selected,
         auto_update: state.autoUpdate,
         hook: state.hook,
@@ -4009,6 +4963,51 @@ function pageScript() {
       list.appendChild(row);
     });
 
+    var account = el('done-account');
+    account.textContent = '';
+    account.hidden = true;
+    if (result.account === 'cloud' && result.account_info) {
+      var info = result.account_info;
+      account.hidden = false;
+      var title = document.createElement('div');
+      title.className = 'headline';
+      if (info.signed_in) {
+        title.textContent = '\uACC4\uC815\uC5D0 \uC5F0\uACB0\uB410\uC2B5\uB2C8\uB2E4' + (info.display_name ? ' \u2014 ' + info.display_name : '');
+        account.appendChild(title);
+      } else if (info.user_code) {
+        title.textContent = '\uB85C\uADF8\uC778\uC744 \uB9C8\uCE58\uB824\uBA74 \uC774 \uCF54\uB4DC\uB97C \uD655\uC778\uD574 \uC8FC\uC138\uC694';
+        account.appendChild(title);
+        var code = document.createElement('div');
+        code.style.cssText = 'font:600 1.8rem/1.4 ui-monospace,SFMono-Regular,Menlo,monospace;letter-spacing:0.08em;margin:0.5rem 0';
+        code.textContent = info.user_code;
+        account.appendChild(code);
+        addLine(account, '\uBE0C\uB77C\uC6B0\uC800\uC5D0 \uC5F4\uB9B0 \uC2B9\uC778 \uD654\uBA74\uC5D0\uC11C \uC774 \uCF54\uB4DC\uAC00 \uB9DE\uB294\uC9C0 \uD655\uC778\uD558\uACE0 \uC2B9\uC778\uD558\uC138\uC694.');
+        addLine(account, '\uAE30\uB2E4\uB9AC\uC9C0 \uC54A\uC544\uB3C4 \uB429\uB2C8\uB2E4 \u2014 \uC2B9\uC778\uD558\uBA74 \uB2E4\uC74C \uBA85\uB839\uC5D0\uC11C \uC790\uB3D9\uC73C\uB85C \uC774\uC5B4\uC9D1\uB2C8\uB2E4.');
+      } else {
+        title.textContent = '\uACC4\uC815 \uC5F0\uACB0\uC744 \uC2DC\uC791\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4';
+        account.appendChild(title);
+        addLine(account, info.sign_in_unavailable || '', 'refused');
+        addLine(account, '\uC124\uCE58\uB294 \uB05D\uB0AC\uC2B5\uB2C8\uB2E4. \uACC4\uC815 \uC5C6\uC774\uB3C4 \uC804\uBD80 \uB3D9\uC791\uD569\uB2C8\uB2E4.');
+      }
+
+      /*
+       * \uC9C0\uD0A4\uC9C0 \uBABB\uD55C \uC57D\uC18D\uC744 \uC5EC\uAE30\uC11C \uB9D0\uD55C\uB2E4.
+       *
+       * \uCCAB \uD654\uBA74\uC758 \uBE44\uAD50\uD45C\uB294 \u300C\uACC4\uC815\uC5D0 \uB450\uAE30\u300D \uCE78\uC5D0 "\uB2E4\uB978 \uCEF4\uD4E8\uD130\uC5D0\uC11C\uB3C4 \uAC19\uC740 \uAE30\uC5B5"\uC744
+       * \uCCB4\uD06C\uD574 \uB450\uC5C8\uB2E4. \uADF8\uB7F0\uB370 \uC774 \uD750\uB984\uC774 \uD558\uB294 \uC77C\uC740 \uB85C\uADF8\uC778\uBFD0\uC774\uB2E4 \u2014 \uACC4\uC815\uC5D0
+       * \uBE0C\uB808\uC778\uC744 \uB9CC\uB4E4\uC9C0\uB3C4, \uB178\uD2B8\uB97C \uC62C\uB9AC\uC9C0\uB3C4 \uC54A\uB294\uB2E4. \uADF8 \uC0C1\uD0DC\uB85C \uD654\uBA74\uC744 \uB2EB\uC73C\uBA74
+       * \uC0AC\uC6A9\uC790\uB294 \uC790\uAE30 \uAE30\uC5B5\uC774 \uACC4\uC815\uC5D0 \uC788\uB2E4\uACE0 \uBBFF\uACE0 \uB2E4\uB978 \uCEF4\uD4E8\uD130\uB97C \uCF20\uB2E4.
+       *
+       * \uC62C\uB9AC\uAE30\uB97C \uC5EC\uAE30\uC11C \uC790\uB3D9\uC73C\uB85C \uD558\uC9C0 \uC54A\uB294 \uC774\uC720\uB294 \uB530\uB85C \uC788\uB2E4: \uB0A8\uC758 \uB178\uD2B8\uB97C
+       * \uC11C\uBC84\uB85C \uBCF4\uB0B4\uB294 \uAC83\uC740 \uBB3C\uC5B4\uBCF4\uACE0 \uD560 \uC77C\uC774\uC9C0 \uC124\uCE58\uC758 \uBD80\uC0B0\uBB3C\uB85C \uD560 \uC77C\uC774 \uC544\uB2C8\uB2E4.
+       * \uADF8\uB798\uC11C \uD558\uC9C0 \uC54A\uB418, \uD558\uC9C0 \uC54A\uC558\uB2E4\uACE0 \uB9D0\uD55C\uB2E4.
+       */
+      if (result.brains_linked > 0) {
+        addLine(account, '\uC544\uC9C1 \uC774 \uCEF4\uD4E8\uD130\uC5D0\uB9CC \uC788\uC2B5\uB2C8\uB2E4 \u2014 \uB85C\uADF8\uC778\uC740 \uB410\uC9C0\uB9CC \uB178\uD2B8\uB294 \uC544\uC9C1 \uACC4\uC815\uC5D0 \uC62C\uB77C\uAC00\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.');
+        addLine(account, '\uB2E4\uB978 \uAE30\uAE30\uC5D0\uC11C\uB3C4 \uAC19\uC740 \uAE30\uC5B5\uC744 \uC4F0\uB824\uBA74, \uC4F0\uC2DC\uB294 AI\uC5D0\uAC8C "\uB0B4 \uAE30\uC5B5 \uACC4\uC815\uC5D0 \uC62C\uB824\uC918"\uB77C\uACE0 \uD558\uC138\uC694.');
+      }
+    }
+
     var brain = result.brain;
     var box = el('done-brain');
     box.textContent = '';
@@ -4058,16 +5057,36 @@ function pageScript() {
 
   /* ---- wiring ---- */
 
+  /* ---- step 1: where the memory lives ---- */
+
+  function chooseAccount(which) {
+    state.account = which;
+    pick('account-cloud', 'account-local', which === 'cloud');
+    el('account-next').disabled = false;
+  }
+
+  el('account-cloud').addEventListener('click', function () { chooseAccount('cloud'); });
+  el('account-local').addEventListener('click', function () { chooseAccount('local'); });
+  el('account-next').addEventListener('click', function () { goto(at + 1); });
+  /*
+   * The terms are a screen, not a new tab. A setup flow that sends somebody to
+   * a website mid-install is a setup flow they can lose their place in, and
+   * this page is served by a process that stops \u2014 a tab reopened later would
+   * find nothing there.
+   */
+  el('account-terms').addEventListener('click', function () { clearError(); show('step-terms'); window.scrollTo(0, 0); });
+  el('terms-back').addEventListener('click', function () { goto(at); });
+
   el('tools-next').addEventListener('click', function () { refreshHookBlock(); goto(at + 1); });
   el('tools-cancel').addEventListener('click', function () {
     api('/api/cancel', { method: 'POST' }).catch(function () {});
     show('step-closed');
   });
 
-  el('update-on').addEventListener('click', function () { state.autoUpdate = 'on'; pick('update-on', 'update-off', true); });
-  el('update-off').addEventListener('click', function () { state.autoUpdate = 'off'; pick('update-on', 'update-off', false); });
-  el('hook-on').addEventListener('click', function () { state.hook = true; pick('hook-on', 'hook-off', true); });
-  el('hook-off').addEventListener('click', function () { state.hook = false; pick('hook-on', 'hook-off', false); });
+  el('update-on').addEventListener('click', function () { state.autoUpdate = 'on'; state.autoUpdateChosen = true; pick('update-on', 'update-off', true); refreshOptionsNext(); });
+  el('update-off').addEventListener('click', function () { state.autoUpdate = 'off'; state.autoUpdateChosen = true; pick('update-on', 'update-off', false); refreshOptionsNext(); });
+  el('hook-on').addEventListener('click', function () { state.hook = true; state.hookChosen = true; pick('hook-on', 'hook-off', true); refreshOptionsNext(); });
+  el('hook-off').addEventListener('click', function () { state.hook = false; state.hookChosen = true; pick('hook-on', 'hook-off', false); refreshOptionsNext(); });
   el('options-next').addEventListener('click', function () { goto(at + 1); });
   el('options-back').addEventListener('click', function () { goto(at - 1); });
 
@@ -4100,15 +5119,27 @@ function pageScript() {
       state.selected = state.tools.filter(function (t) { return t.detected; }).map(function (t) { return t.id; });
       state.autoUpdate = (data.defaults && data.defaults.auto_update) || 'on';
       state.hook = !!(data.defaults && data.defaults.hook);
+      /* Already connected: the question is answered, not asked again. */
+      if (data.signed_in) {
+        chooseAccount('cloud');
+        el('account-cloud').querySelector('small').textContent = '\uC774\uBBF8 \uB85C\uADF8\uC778\uB418\uC5B4 \uC788\uC2B5\uB2C8\uB2E4.';
+      } else if (data.preselect_account) {
+        /* A passed --login/--no-login is what they already said. Selected, not
+           submitted \u2014 they can still change it before pressing \uB2E4\uC74C. */
+        chooseAccount(data.preselect_account);
+      }
       renderTools();
+      // Deliberately NOT drawn as selected here. The values above are what the
+      // installer would use, not what anybody has said \u2014 and drawing them as
+      // selected is what turned two questions into two screens people click
+      // through. refreshHookBlock leaves the next button shut until both are
+      // answered.
       refreshHookBlock();
-      pick('update-on', 'update-off', state.autoUpdate === 'on');
-      pick('hook-on', 'hook-off', state.hook);
       goto(0);
     })
     .catch(function (err) {
       fail(err);
-      show('step-tools');
+      show('step-account');
     });
 })();`;
 }
@@ -4122,15 +5153,16 @@ var init_setup_web_page = __esm({
 var setup_web_exports = {};
 __export(setup_web_exports, {
   browserOpener: () => browserOpener,
+  disclosure: () => disclosure,
   runSetupWeb: () => runSetupWeb,
   startSetupWebServer: () => startSetupWebServer
 });
-import { spawn } from "child_process";
+import "child_process";
 import { randomBytes as randomBytes2, timingSafeEqual } from "crypto";
 import { readdir as readdir6, stat as stat3 } from "fs/promises";
 import { createServer } from "http";
 import { homedir as homedir3 } from "os";
-import { basename, isAbsolute as isAbsolute2, join as join14, relative as relative2, resolve as resolve7 } from "path";
+import { basename, isAbsolute as isAbsolute3, join as join17, relative as relative2, resolve as resolve8 } from "path";
 async function startSetupWebServer(opts) {
   const token = randomBytes2(32).toString("hex");
   const idleMs = opts.idleMs ?? IDLE_TIMEOUT_MS;
@@ -4142,11 +5174,11 @@ async function startSetupWebServer(opts) {
     sockets.add(socket);
     socket.on("close", () => sockets.delete(socket));
   });
-  await new Promise((resolve10, reject) => {
+  await new Promise((resolve11, reject) => {
     server.once("error", reject);
     server.listen(0, "127.0.0.1", () => {
       server.off("error", reject);
-      resolve10();
+      resolve11();
     });
   });
   const address = server.address();
@@ -4154,8 +5186,8 @@ async function startSetupWebServer(opts) {
   const origin = `http://127.0.0.1:${port}`;
   const ownOrigins = /* @__PURE__ */ new Set([origin, `http://localhost:${port}`]);
   let resolveDone;
-  const done = new Promise((resolve10) => {
-    resolveDone = resolve10;
+  const done = new Promise((resolve11) => {
+    resolveDone = resolve11;
   });
   let stopped = false;
   let idleTimer;
@@ -4165,8 +5197,8 @@ async function startSetupWebServer(opts) {
     if (idleTimer) clearTimeout(idleTimer);
     clearTimeout(maxTimer);
     process.off("SIGINT", onInterrupt);
-    await new Promise((resolve10) => {
-      server.close(() => resolve10());
+    await new Promise((resolve11) => {
+      server.close(() => resolve11());
       for (const socket of sockets) socket.destroy();
     });
     resolveDone(reason);
@@ -4183,7 +5215,13 @@ async function startSetupWebServer(opts) {
     void stop("interrupted");
   }
   process.once("SIGINT", onInterrupt);
-  const state = { detected: opts.detected, token, ownOrigins, applied: false };
+  const state = {
+    detected: opts.detected,
+    token,
+    ownOrigins,
+    applied: false,
+    ...opts.preselectAccount === void 0 ? {} : { preselectAccount: opts.preselectAccount }
+  };
   server.on("request", (req, res) => {
     void handle(req, res, state, origin, touch).then((outcome) => {
       if (outcome === "applied") setTimeout(() => void stop("applied"), lingerMs).unref();
@@ -4209,21 +5247,40 @@ async function startSetupWebServer(opts) {
   };
 }
 async function runSetupWeb(opts) {
-  const server = await startSetupWebServer({ detected: opts.detected });
+  const server = await startSetupWebServer({
+    detected: opts.detected,
+    ...opts.preselectAccount === void 0 ? {} : { preselectAccount: opts.preselectAccount }
+  });
   const opened = opts.printUrl ? false : await openBrowser(server.url);
   printDual({
-    json: { url: server.url, port: server.port, opened },
+    // The URL carries the key that authorizes reading folders and writing into
+    // `~/.claude`, and it was printed on every run — in `--json` too, so it
+    // landed in the transcript of the agent that ran the command, which may be
+    // stored, synced or sent somewhere. That is a different exposure from the
+    // one everybody thinks of with a local token: not a process on this machine
+    // that could read those files anyway, but a copy of the key leaving it.
+    //
+    // So it is emitted only when it is the way in — the browser did not open,
+    // or `--print-url` asked for it. When the browser DID open, the person is
+    // already looking at the screen and nobody needs the string.
+    json: {
+      ...disclosure(server.url, server.port, opened)
+    },
     human: () => {
       if (opened) {
         printHuman("Opened setup in your browser.\n");
-        printHuman(c.gray(`  If nothing appeared: ${server.url}`));
+        printHuman(
+          c.gray(
+            "  Nothing appeared? Run `memgineering setup --web --print-url` and open\n  the link yourself \u2014 it is not printed here on purpose, because it\n  carries the key that authorizes the install."
+          )
+        );
       } else {
         printHuman("Open this in a browser to finish setting up:\n");
         printHuman(`  ${server.url}`);
       }
       printHuman(
         c.gray(
-          "\n  The link only works on this machine and only once \u2014 it carries a\n  one-time key, and this screen closes when you are done.\n  Ctrl-C to stop waiting."
+          "\n  The link works only on this machine, and only until this screen\n  closes \u2014 applying the setup, closing the tab, or an hour, whichever\n  comes first. Ctrl-C to stop waiting."
         )
       );
     }
@@ -4232,7 +5289,7 @@ async function runSetupWeb(opts) {
   const ending = {
     applied: "Setup applied. Restart your agent session for it to take effect.",
     cancelled: "Closed without applying \u2014 nothing was changed.",
-    idle: "Nothing happened for ten minutes, so the setup screen was closed. Run `memgineering setup --web` again when you are ready.",
+    idle: "Nothing happened for half an hour, so the setup screen was closed. Nothing was changed \u2014 run `memgineering setup --web` again when you are ready.",
     interrupted: "Stopped \u2014 nothing was changed.",
     closed: "Setup screen closed."
   };
@@ -4240,6 +5297,9 @@ async function runSetupWeb(opts) {
   else printHuman(`
 ${reason === "applied" ? c.green(ending[reason]) : c.gray(ending[reason])}`);
 }
+function disclosure(url, port, opened) {
+  return opened ? { port, opened } : { port, opened, url };
+}
 async function handle(req, res, state, origin, touch = () => {
 }) {
   const url = new URL(req.url ?? "/", origin);
@@ -4330,7 +5390,11 @@ async function stateDocument(state) {
       hook: state.detected.some((t) => t.hooks)
     },
     brains: cfg.brain.brains.map((b) => b.root),
-    applied: state.applied
+    applied: state.applied,
+    /** Null unless a flag already answered it. The screen selects it, never submits it. */
+    preselect_account: state.preselectAccount ?? null,
+    /** Already connected, so the screen can say so instead of offering a second sign-in. */
+    signed_in: (await signInSummary()).signedIn
   };
 }
 async function candidateFolders(linked) {
@@ -4341,16 +5405,17 @@ async function candidateFolders(linked) {
     if (out.length >= MAX_CANDIDATES || seen.has(path)) return;
     seen.add(path);
     if (!await isDirectory(path)) return;
-    if (!await holdsNotes(path)) return;
-    out.push({ path, label: basename(path), linked: linked.includes(path) });
+    const notes = await countNotes(path);
+    if (notes === 0) return;
+    out.push({ path, label: basename(path), linked: linked.includes(path), notes });
   };
-  for (const entry of await entriesOf(join14(home, "Documents"))) {
-    await consider(join14(home, "Documents", entry));
+  for (const entry of await entriesOf(join17(home, "Documents"))) {
+    await consider(join17(home, "Documents", entry));
   }
   for (const entry of await entriesOf(home)) {
-    if (/^brain/i.test(entry)) await consider(join14(home, entry));
+    if (/^brain/i.test(entry)) await consider(join17(home, entry));
   }
-  for (const name of ["notes", "Notes"]) await consider(join14(home, name));
+  for (const name of ["notes", "Notes"]) await consider(join17(home, name));
   return out;
 }
 async function entriesOf(dir) {
@@ -4359,21 +5424,24 @@ async function entriesOf(dir) {
 async function isDirectory(path) {
   return stat3(path).then((s) => s.isDirectory()).catch(() => false);
 }
-async function holdsNotes(dir) {
+async function countNotes(dir) {
+  const isNote = (n) => /\.(md|markdown)$/i.test(n);
   const entries = await entriesOf(dir);
-  if (entries.some((n) => /\.(md|markdown)$/i.test(n))) return true;
+  let total = entries.filter(isNote).length;
+  if (total >= COUNT_CAP) return COUNT_CAP;
   for (const entry of entries.slice(0, 40)) {
-    const child = join14(dir, entry);
+    const child = join17(dir, entry);
     if (!await isDirectory(child)) continue;
-    if ((await entriesOf(child)).some((n) => /\.(md|markdown)$/i.test(n))) return true;
+    total += (await entriesOf(child)).filter(isNote).length;
+    if (total >= COUNT_CAP) return COUNT_CAP;
   }
-  return false;
+  return total;
 }
 function isSystemPath(path) {
   return SYSTEM_ROOTS.some((root) => {
     if (root === "/") return path === "/";
     const rel = relative2(root, path);
-    return rel === "" || !rel.startsWith("..") && !isAbsolute2(rel);
+    return rel === "" || !rel.startsWith("..") && !isAbsolute3(rel);
   });
 }
 async function inspectFromScreen(req, res, state) {
@@ -4400,7 +5468,7 @@ async function inspectFromScreen(req, res, state) {
     });
     return "served";
   }
-  const path = resolve7(expandHome(asked.trim()));
+  const path = resolve8(expandHome(asked.trim()));
   if (isSystemPath(path)) {
     sendJson(res, 400, {
       error: {
@@ -4492,14 +5560,41 @@ async function applyFromScreen(req, res, state) {
   const changes = await applySetup(choice.value, false);
   const brain = await connectBrain(choice.brain);
   const cfg = await loadConfig();
+  const signIn = choice.account === "cloud" ? await runSignInStep({ login: true, interactive: false, browser: true, dryRun: false }) : void 0;
+  if (signIn) printSignInStep(signIn);
   sendJson(res, 200, {
     applied: true,
+    /**
+     * The answer, and the sign-in it started, under DIFFERENT keys.
+     *
+     * `signInStepJson` returns `{ account: … }`, so spreading it beside a field
+     * also called `account` silently replaced the string with an object and the
+     * screen's `result.account === 'cloud'` stopped being true. Named apart so
+     * the collision cannot come back.
+     */
+    account: choice.account,
+    ...signIn ? { account_info: signInStepJson(signIn)["account"] } : {},
     tools: choice.value.tools.map((t) => t.id),
     auto_update: choice.value.autoUpdate,
     hook: choice.value.hook,
     changes,
     brain,
     brains_linked: cfg.brain.brains.length,
+    /*
+     * The half the screen cannot do, addressed to the thing that can.
+     *
+     * Choosing "keep it in an account" signs in and nothing more — no hosted
+     * brain is created and no note is uploaded. The comparison table on the
+     * first screen ticks "the same memory on another machine" for that column,
+     * so leaving this unsaid ships a promise the flow does not keep.
+     *
+     * Not done automatically here on purpose: sending somebody's notes to a
+     * server is a thing to ask about, not a side effect of an installer. The
+     * agent is who asks, so the agent is who gets told.
+     */
+    ...choice.account === "cloud" && cfg.brain.brains.length > 0 ? {
+      next: "Signed in, but the notes are still only on this machine \u2014 nothing was uploaded. `memgineering push` carries this brain up to the account, which is what makes it readable from another machine. ASK the user before running it: it sends their notes to a server."
+    } : {},
     ...cfg.brain.brains.length === 0 ? {
       // Same sentence the CLI ends on. Which folder holds someone's notes
       // is the one decision neither surface makes for them, and `link` is
@@ -4539,6 +5634,15 @@ function readChoice(parsed, detected) {
   const body = parsed ?? {};
   const ids = Array.isArray(body.tools) ? body.tools.map(String) : [];
   const known = detected.map((t) => t.id).join(", ");
+  if (body.account !== "cloud" && body.account !== "local") {
+    return {
+      error: {
+        code: "invalid_input",
+        message: "account must be 'cloud' or 'local'",
+        hint: `Received: ${JSON.stringify(body.account)}. This is the first question on the screen \u2014 whether the memory follows you across machines, or stays on this one.`
+      }
+    };
+  }
   if (ids.length === 0) {
     return {
       error: {
@@ -4582,7 +5686,8 @@ function readChoice(parsed, detected) {
       // is not an error, it simply has nowhere to go — same rule as `--hook`.
       hook: body.hook === true && tools.some((t) => t.hooks)
     },
-    brain: brain.value
+    brain: brain.value,
+    account: body.account
   };
 }
 function readBrainChoice(raw) {
@@ -4619,8 +5724,8 @@ function readBrainChoice(raw) {
 }
 function expandHome(input) {
   if (input === "~") return homedir3();
-  if (input.startsWith("~/")) return join14(homedir3(), input.slice(2));
-  return isAbsolute2(input) ? input : resolve7(input);
+  if (input.startsWith("~/")) return join17(homedir3(), input.slice(2));
+  return isAbsolute3(input) ? input : resolve8(input);
 }
 function errorEnvelope(err) {
   if (err instanceof MemgError) return { code: err.code, message: err.message, hint: err.hint };
@@ -4657,7 +5762,7 @@ async function readJsonBody(req, res) {
   }
 }
 async function readBody(req) {
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve11, reject) => {
     let size = 0;
     let refused = false;
     let chunks = [];
@@ -4667,14 +5772,14 @@ async function readBody(req) {
         if (!refused) {
           refused = true;
           chunks = [];
-          resolve10(null);
+          resolve11(null);
         }
         return;
       }
       chunks.push(chunk);
     });
     req.once("end", () => {
-      if (!refused) resolve10(Buffer.concat(chunks).toString("utf8"));
+      if (!refused) resolve11(Buffer.concat(chunks).toString("utf8"));
     });
     req.once("error", reject);
   });
@@ -4719,45 +5824,26 @@ function sendHtml(res, html) {
   });
   res.end(html);
 }
-async function openBrowser(url) {
-  const { file, args } = browserOpener(url);
-  return new Promise((resolve10) => {
-    let settled = false;
-    const finish = (opened) => {
-      if (settled) return;
-      settled = true;
-      resolve10(opened);
-    };
-    const child = spawn(file, args, { detached: true, stdio: "ignore" });
-    child.on("error", () => finish(false));
-    child.on("exit", (code) => {
-      if (code !== null && code !== 0) finish(false);
-    });
-    child.unref();
-    setTimeout(() => finish(true), 300).unref();
-  });
-}
-function browserOpener(url) {
-  if (process.platform === "darwin") return { file: "open", args: [url] };
-  if (process.platform === "win32") return { file: "cmd", args: ["/c", "start", "", url] };
-  return { file: "xdg-open", args: [url] };
-}
-var IDLE_TIMEOUT_MS, MAX_LIFETIME_MS, APPLY_LINGER_MS, MAX_BODY_BYTES, MAX_CANDIDATES, PREVIEW_CAP, SYSTEM_ROOTS;
+var IDLE_TIMEOUT_MS, MAX_LIFETIME_MS, APPLY_LINGER_MS, MAX_BODY_BYTES, MAX_CANDIDATES, COUNT_CAP, PREVIEW_CAP, SYSTEM_ROOTS;
 var init_setup_web = __esm({
   "src/commands/setup-web.ts"() {
     "use strict";
     init_errors();
+    init_open_browser();
+    init_setup_signin();
+    init_login();
     init_config();
     init_ui();
     init_init();
     init_link();
     init_setup();
     init_setup_web_page();
-    IDLE_TIMEOUT_MS = 10 * 60 * 1e3;
+    IDLE_TIMEOUT_MS = 30 * 60 * 1e3;
     MAX_LIFETIME_MS = 60 * 60 * 1e3;
     APPLY_LINGER_MS = 1e3;
     MAX_BODY_BYTES = 64 * 1024;
     MAX_CANDIDATES = 8;
+    COUNT_CAP = 40;
     PREVIEW_CAP = 5e3;
     SYSTEM_ROOTS = [
       "/",
@@ -4776,14 +5862,17 @@ var init_setup_web = __esm({
 });
 
 // src/commands/setup.ts
-import { access, mkdir as mkdir9, readFile as readFile15 } from "fs/promises";
+import { access, mkdir as mkdir12, readFile as readFile18 } from "fs/promises";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname3, join as join15 } from "path";
+import { dirname as dirname4, join as join18 } from "path";
 import { fileURLToPath } from "url";
-import { Command as Command14 } from "commander";
-import prompts2 from "prompts";
+import { Command as Command18 } from "commander";
+import prompts3 from "prompts";
 function setupCommand() {
-  return new Command14("setup").description("install into your agents, and point at a brain").option("--agent", "non-interactive: take every answer from flags").option("--human", "interactive: choose from a list").option("--web", "open a screen in the browser and answer it there").option("--print-url", "with --web: print the URL instead of opening a browser").option("--tools <list>", "comma-separated: claude, codex, gemini (default: all detected)").option("--auto-update <choice>", "on | off  (default: on, recommended)").option("--hook <choice>", "on | off \u2014 SessionStart resurface, Claude Code only").option("--dry-run", "report what would change, write nothing").option("--silent", "only speak if something changed").action(async (opts) => {
+  return new Command18("setup").description("install into your agents, and point at a brain").option("--agent", "non-interactive: take every answer from flags").option("--human", "interactive: choose from a list").option("--web", "open a screen in the browser and answer it there").option("--print-url", "with --web: print the URL instead of opening a browser").option("--tools <list>", "comma-separated: claude, codex, gemini (default: all detected)").option("--auto-update <choice>", "on | off  (default: on, recommended)").option("--hook <choice>", "on | off \u2014 SessionStart resurface, Claude Code only").option("--login", "start a hosted-account sign-in as the first step").option("--no-browser", "with --login: print the approval link instead of opening a browser").option(
+    "--no-login",
+    "skip the sign-in step \u2014 everything installed here works without an account"
+  ).option("--dry-run", "report what would change, write nothing").option("--silent", "only speak if something changed").action(async (opts) => {
     const detected = await detectTools();
     if (detected.length === 0) {
       throw memgError(
@@ -4794,9 +5883,23 @@ function setupCommand() {
     }
     if (opts.web) {
       const { runSetupWeb: runSetupWeb2 } = await Promise.resolve().then(() => (init_setup_web(), setup_web_exports));
-      await runSetupWeb2({ detected, printUrl: opts.printUrl === true });
+      await runSetupWeb2({
+        detected,
+        printUrl: opts.printUrl === true,
+        ...opts.login === void 0 ? {} : { preselectAccount: opts.login ? "cloud" : "local" }
+      });
       return;
     }
+    const signIn = await runSignInStep({
+      ...opts.login === void 0 ? {} : { login: opts.login },
+      // A real terminal, not the `--human` flag. Asking for `--human` says
+      // which mode you want; it does not conjure a screen to draw a prompt
+      // on, and prompting without one hangs until something kills it. The
+      // refusal for that combination lives in `resolveMode`, below.
+      interactive: isInteractive() && opts.agent !== true,
+      browser: opts.browser !== false,
+      dryRun: opts.dryRun === true
+    });
     const mode = await resolveMode(opts);
     const choice = mode.kind === "human" ? await askHuman(detected, opts) : fromFlags(detected, opts);
     const defaultsTaken = !mode.chosen ? [
@@ -4813,6 +5916,7 @@ function setupCommand() {
     printDual({
       json: {
         mode: mode.kind,
+        ...signInStepJson(signIn),
         defaults_used: defaultsTaken,
         dry_run: opts.dryRun === true,
         tools: choice.tools.map((t) => t.id),
@@ -4827,11 +5931,13 @@ function setupCommand() {
       human: () => {
         if (opts.silent && changed.length === 0) return;
         if (opts.dryRun) {
+          printSignInStep(signIn);
           printHuman(`Would change ${changed.length} file(s):
 `);
           for (const r of changed) printHuman(c.gray(`  ${r.tool} \xB7 ${r.what}`));
           return;
         }
+        printSignInStep(signIn);
         printHuman(`Registered with ${choice.tools.map((t) => t.label).join(", ")}.
 `);
         printHuman(c.gray(`  auto-update: ${choice.autoUpdate}`));
@@ -4867,7 +5973,7 @@ function setupCommand() {
       }
     });
     if (mode.kind === "human" && brains.length === 0 && !opts.dryRun && isInteractive()) {
-      const { path } = await prompts2({
+      const { path } = await prompts3({
         type: "text",
         name: "path",
         message: "Path to your notes folder (blank to skip)"
@@ -4887,15 +5993,15 @@ async function applySetup(choice, dryRun) {
     results.push({
       tool: tool.label,
       what: "guide",
-      result: await injectBlock(join15(homedir4(), tool.hubFile), hub, dryRun)
+      result: await injectBlock(join18(homedir4(), tool.hubFile), hub, dryRun)
     });
     for (const skill of BRAND.subSkills) {
-      const content = await loadAsset(join15(skill, "SKILL.md"));
+      const content = await loadAsset(join18(skill, "SKILL.md"));
       results.push({
         tool: tool.label,
         what: skill,
         result: await writeIfDifferent(
-          join15(homedir4(), tool.skillsDir, skill, "SKILL.md"),
+          join18(homedir4(), tool.skillsDir, skill, "SKILL.md"),
           content,
           dryRun
         )
@@ -4931,7 +6037,7 @@ async function resolveMode(opts) {
     return { kind: "human", chosen: true };
   }
   if (!isInteractive() || isJsonMode()) return { kind: "agent", chosen: false };
-  const { mode } = await prompts2({
+  const { mode } = await prompts3({
     type: "select",
     name: "mode",
     message: "How would you like to set this up?",
@@ -4951,7 +6057,7 @@ async function detectTools() {
   const home = homedir4();
   const found = [];
   for (const tool of TOOLS) {
-    if (await exists(join15(home, tool.dir))) found.push(tool);
+    if (await exists2(join18(home, tool.dir))) found.push(tool);
   }
   return found;
 }
@@ -4988,7 +6094,7 @@ async function askHuman(detected, opts) {
   printHuman(c.bold("\nmemgineering \u2014 setup\n"));
   printHuman(c.gray("  Found: ") + detected.map((t) => t.label).join(", "));
   printHuman("");
-  const answers = await prompts2([
+  const answers = await prompts3([
     {
       type: "multiselect",
       name: "tools",
@@ -5028,10 +6134,10 @@ async function injectBlock(filePath, content, dryRun) {
   const block = `${BRAND.hubMarkerStart}
 ${content.trimEnd()}
 ${BRAND.hubMarkerEnd}`;
-  const existing = await readFile15(filePath, "utf8").catch(() => null);
+  const existing = await readFile18(filePath, "utf8").catch(() => null);
   if (existing === null) {
     if (!dryRun) {
-      await mkdir9(dirname3(filePath), { recursive: true });
+      await mkdir12(dirname4(filePath), { recursive: true });
       await writeThenRename(filePath, `${block}
 `);
     }
@@ -5056,17 +6162,17 @@ ${block}
   return "injected";
 }
 async function writeIfDifferent(filePath, content, dryRun) {
-  const existing = await readFile15(filePath, "utf8").catch(() => null);
+  const existing = await readFile18(filePath, "utf8").catch(() => null);
   if (existing === content) return "unchanged";
   if (!dryRun) {
-    await mkdir9(dirname3(filePath), { recursive: true });
+    await mkdir12(dirname4(filePath), { recursive: true });
     await writeThenRename(filePath, content);
   }
   return existing === null ? "injected" : "updated";
 }
 async function installHook(dryRun) {
-  const settingsPath = join15(homedir4(), ".claude", "settings.json");
-  const raw = await readFile15(settingsPath, "utf8").catch(() => null);
+  const settingsPath = join18(homedir4(), ".claude", "settings.json");
+  const raw = await readFile18(settingsPath, "utf8").catch(() => null);
   let settings = {};
   if (raw !== null) {
     try {
@@ -5089,14 +6195,14 @@ async function installHook(dryRun) {
   sessionStart.push({ hooks: [{ type: "command", command }] });
   const next = { ...settings, hooks: { ...hooks, SessionStart: sessionStart } };
   if (!dryRun) {
-    await mkdir9(dirname3(settingsPath), { recursive: true });
+    await mkdir12(dirname4(settingsPath), { recursive: true });
     await writeThenRename(settingsPath, `${JSON.stringify(next, null, 2)}
 `);
   }
   return raw === null ? "injected" : "updated";
 }
 async function loadAsset(relPath) {
-  const raw = await readFile15(join15(await assetRoot(), relPath), "utf8");
+  const raw = await readFile18(join18(await assetRoot(), relPath), "utf8");
   if (relPath === BRAND.hubFileName && raw.startsWith("---")) {
     const end = raw.indexOf("\n---", 4);
     if (end !== -1) return raw.slice(end + 4).trimStart();
@@ -5104,14 +6210,14 @@ async function loadAsset(relPath) {
   return raw;
 }
 async function assetRoot() {
-  const here = dirname3(fileURLToPath(import.meta.url));
-  const bundled = join15(here, "..", "assets");
-  if (await exists(join15(bundled, BRAND.hubFileName))) return bundled;
+  const here = dirname4(fileURLToPath(import.meta.url));
+  const bundled = join18(here, "..", "assets");
+  if (await exists2(join18(bundled, BRAND.hubFileName))) return bundled;
   let dir = here;
   for (; ; ) {
-    const candidate = join15(dir, "packages", "skills");
-    if (await exists(join15(candidate, BRAND.hubFileName))) return candidate;
-    const parent = dirname3(dir);
+    const candidate = join18(dir, "packages", "skills");
+    if (await exists2(join18(candidate, BRAND.hubFileName))) return candidate;
+    const parent = dirname4(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -5121,7 +6227,7 @@ async function assetRoot() {
     "Reinstall with `npm i -g memgineering`. If you are running from a checkout, build first: `pnpm -F memgineering build`."
   );
 }
-async function exists(path) {
+async function exists2(path) {
   try {
     await access(path);
     return true;
@@ -5136,6 +6242,7 @@ var init_setup = __esm({
     init_atomic();
     init_brand();
     init_errors();
+    init_setup_signin();
     init_config();
     init_ui();
     TOOLS = [
@@ -5168,7 +6275,7 @@ var init_setup = __esm({
 });
 
 // src/program.ts
-import { Command as Command18 } from "commander";
+import { Command as Command23 } from "commander";
 
 // src/help.ts
 init_ui();
@@ -5189,6 +6296,11 @@ var COMMAND_GROUPS = [
     blurb: "occasional \u2014 correct what is remembered and what is read",
     commands: ["retire", "unretire", "exclude", "unexclude"]
   },
+  {
+    title: "ACCOUNT",
+    blurb: "optional \u2014 connect a hosted brain; everything above works without it",
+    commands: ["login", "logout", "whoami", "push", "pull"]
+  },
   {
     title: "SYSTEM",
     blurb: "install into your agents, and stay current",
@@ -5199,7 +6311,8 @@ var defaultFormatHelp = Help.prototype.formatHelp;
 var ENV_ROWS = [
   ["MEMGINEERING_HOME=<dir>", "state + derived index (default: ~/.memgineering)"],
   ["MEMGINEERING_JSON=1", "force --json framing without the flag"],
-  ["MEMGINEERING_NO_UPDATE=1", "skip the update check for this run"]
+  ["MEMGINEERING_NO_UPDATE=1", "skip the update check for this run"],
+  ["MEMGINEERING_API_URL=<url>", "hosted brain server (default: https://api.memgineering.com)"]
 ];
 function commandLabel(sub) {
   const args = sub.registeredArguments.map((a) => a.required ? `<${a.name()}>` : `[${a.name()}]`).join(" ");
@@ -5329,7 +6442,16 @@ var OpVerbSchema = z7.enum([
   "retire",
   "unretire",
   "exclude",
-  "unexclude"
+  "unexclude",
+  /**
+   * Written only by the hosted brain, when a note is uploaded at a chosen path.
+   *
+   * This CLI never produces one. It is here so that a ledger which came from a
+   * hosted brain PARSES — a downloaded history containing a verb this schema
+   * rejects would fail to load at all, taking the readable ops down with the
+   * one it did not recognise.
+   */
+  "import"
 ]);
 var OpRecordSchema = z7.object({
   op_id: z7.string().min(1),
@@ -5678,18 +6800,18 @@ async function commit2(root, base, next) {
 function excludesPath(content, relPath) {
   return isExcluded(normalizeName(relPath), false, parseIgnoreFile(content));
 }
-async function addIgnoreEntry(root, relPath, base) {
+function planAddIgnoreEntry(content, relPath) {
   const entry = normalizeName(relPath);
-  if (excludesPath(base.content, relPath)) {
-    return { ok: true, content: base.content, changed: false };
+  if (excludesPath(content, relPath)) {
+    return { content, changed: false };
   }
-  const needsNewline = base.content !== "" && !base.content.endsWith("\n");
-  const next = `${base.content}${needsNewline ? "\n" : ""}${entry}
+  const needsNewline = content !== "" && !content.endsWith("\n");
+  const next = `${content}${needsNewline ? "\n" : ""}${entry}
 `;
   const parsed = parseIgnoreFile(next);
   if (parsed.unsupported.includes(entry)) {
     throw Object.assign(new Error(`${FILE} cannot express a rule for this path: ${relPath}`), {
-      hint: "Paths containing `[` or a backslash are outside what this ignore parser translates. Rename the file, or add the rule by hand and check `kordis memory recall` no longer returns it. Nothing was written."
+      hint: "Paths containing `[` or a backslash are outside what this ignore parser translates. Rename the file, or add the rule by hand and check `memgineering recall` no longer returns it. Nothing was written."
     });
   }
   if (!excludesPath(next, relPath)) {
@@ -5697,24 +6819,32 @@ async function addIgnoreEntry(root, relPath, base) {
       hint: `This is a defect in the editor, not in your ${FILE}. Nothing was written.`
     });
   }
-  assertNothingLost(base.content, next, "excluding");
-  return commit2(root, base, next);
+  assertNothingLost(content, next, "excluding");
+  return { content: next, changed: true };
 }
-async function removeIgnoreEntry(root, relPath, base) {
+function planRemoveIgnoreEntry(content, relPath) {
   const entry = normalizeName(relPath);
-  const lines2 = base.content.split("\n");
+  const lines2 = content.split("\n");
   const kept = lines2.filter((line) => normalizeName(line.trim()) !== entry);
-  if (kept.length === lines2.length) {
-    return { ok: true, content: base.content, changed: false };
-  }
+  if (kept.length === lines2.length) return { content, changed: false };
   const next = kept.join("\n");
   if (excludesPath(next, relPath)) {
     throw Object.assign(new Error(`${relPath} is still excluded after removing its line`), {
       hint: `Another rule in ${FILE} or .gitignore also covers this path. Remove that one by hand \u2014 this command will not delete a rule you did not name. Nothing was written.`
     });
   }
-  assertNothingLost(next, base.content, "un-excluding");
-  return commit2(root, base, next);
+  assertNothingLost(next, content, "un-excluding");
+  return { content: next, changed: true };
+}
+async function addIgnoreEntry(root, relPath, base) {
+  const edit = planAddIgnoreEntry(base.content, relPath);
+  if (!edit.changed) return { ok: true, content: base.content, changed: false };
+  return commit2(root, base, edit.content);
+}
+async function removeIgnoreEntry(root, relPath, base) {
+  const edit = planRemoveIgnoreEntry(base.content, relPath);
+  if (!edit.changed) return { ok: true, content: base.content, changed: false };
+  return commit2(root, base, edit.content);
 }
 
 // ../../packages/storage-adapter/src/local-file/cas-adapter.ts
@@ -6073,6 +7203,124 @@ async function readLock(path) {
 
 // src/commands/curation.ts
 init_index_build();
+
+// src/lib/cloud-brain.ts
+init_api_client();
+async function openCloudBrain(target) {
+  const credentials = await requireCredentials(target.apiUrl);
+  return {
+    brainId: target.brainId,
+    name: target.name,
+    token: credentials.token,
+    apiUrl: target.apiUrl
+  };
+}
+var call = async (brain, method, path, body) => (await apiRequest({
+  method,
+  path: `/v1/brains/${brain.brainId}${path}`,
+  token: brain.token,
+  baseUrl: brain.apiUrl,
+  ...body === void 0 ? {} : { body }
+})).body;
+var cloudRecall = (brain, args) => call(brain, "POST", "/recall", {
+  query: args.query,
+  ...args.limit === void 0 ? {} : { limit: args.limit },
+  ...args.scope === void 0 ? {} : { scope: args.scope }
+});
+var cloudOpen = (brain, ref) => call(brain, "POST", "/open", { ref });
+var cloudEvidence = (brain, ref) => call(brain, "POST", "/evidence", { ref });
+var cloudRemember = (brain, args) => call(brain, "POST", "/remember", {
+  text: args.text,
+  ...args.scope === void 0 ? {} : { scope: args.scope },
+  ...args.reason === void 0 ? {} : { reason: args.reason }
+});
+var cloudUndo = (brain, args) => call(brain, "POST", "/undo", {
+  ...args.opId === void 0 ? {} : { op_id: args.opId },
+  ...args.reason === void 0 ? {} : { reason: args.reason }
+});
+var cloudLog = (brain, args = {}) => {
+  const query = new URLSearchParams();
+  if (args.limit !== void 0) query.set("limit", String(args.limit));
+  if (args.verbose === true) query.set("verbose", "true");
+  const suffix = query.toString();
+  return call(brain, "GET", `/log${suffix ? `?${suffix}` : ""}`);
+};
+var cloudPutNote = (brain, args) => call(brain, "POST", "/notes", args);
+var cloudListNotes = (brain, args = {}) => {
+  const query = new URLSearchParams();
+  if (args.cursor !== void 0) query.set("cursor", args.cursor);
+  if (args.limit !== void 0) query.set("limit", String(args.limit));
+  if (args.content === true) query.set("content", "1");
+  const suffix = query.toString();
+  return call(brain, "GET", `/notes${suffix ? `?${suffix}` : ""}`);
+};
+var cloudRevise = (brain, args) => call(brain, "POST", "/revise", {
+  ref: args.ref,
+  claim: args.claim,
+  ...args.summary === void 0 ? {} : { summary: args.summary },
+  ...args.title === void 0 ? {} : { title: args.title },
+  ...args.validFrom === void 0 ? {} : { valid_from: args.validFrom },
+  ...args.action === void 0 ? {} : { action: args.action },
+  ...args.contradicts === void 0 ? {} : { contradicts: [...args.contradicts] },
+  ...args.reason === void 0 ? {} : { reason: args.reason },
+  ...args.because === void 0 ? {} : { because: args.because },
+  ...args.dryRun === true ? { dry_run: true } : {}
+});
+var cloudLifecycle = (brain, action, args) => call(brain, "POST", `/${action}`, {
+  ref: args.ref,
+  ...args.reason === void 0 ? {} : { reason: args.reason }
+});
+var cloudExclude = (brain, mode, args) => call(brain, "POST", `/${mode}`, {
+  path: args.path,
+  ...args.reason === void 0 ? {} : { reason: args.reason }
+});
+var cloudResurface = (brain, args = {}) => call(brain, "POST", "/resurface", {
+  ...args.limit === void 0 ? {} : { limit: args.limit }
+});
+async function listCloudBrains(token, baseUrl) {
+  const res = await apiRequest({
+    method: "GET",
+    path: "/v1/brains",
+    token,
+    baseUrl
+  });
+  return res.body?.brains ?? [];
+}
+async function createCloudBrain(token, baseUrl, name) {
+  const res = await apiRequest({
+    method: "POST",
+    path: "/v1/brains",
+    token,
+    baseUrl,
+    body: { name }
+  });
+  return res.body;
+}
+
+// src/lib/target.ts
+init_errors();
+init_api_client();
+init_config();
+init_vault();
+async function resolveTarget(opts = {}) {
+  if (opts.local !== true) {
+    const cloud = await cloudTarget();
+    if (cloud) return cloud;
+  }
+  const { brain, via } = await resolveBrain(opts.vault);
+  return { kind: "local", brain, via };
+}
+async function cloudTarget() {
+  const base = apiUrl();
+  const config = await loadConfig();
+  const cloud = config.brain.cloud;
+  if (!cloud || cloud.api_url !== base) return null;
+  const credentials = await currentCredentials(base);
+  if (!credentials) return null;
+  return { kind: "cloud", brainId: cloud.id, name: cloud.name, apiUrl: base };
+}
+
+// src/commands/curation.ts
 init_vault();
 init_ui();
 
@@ -6082,28 +7330,28 @@ init_errors();
 import { Command as Command4 } from "commander";
 
 // src/lib/events.ts
-import { appendFile as appendFile2, mkdir as mkdir7, readFile as readFile12, readdir as readdir4 } from "fs/promises";
-import { join as join11 } from "path";
-import { z as z8 } from "zod";
-var EventSchema = z8.object({
-  ts: z8.string(),
-  verb: z8.enum(["recall", "open", "resurface"]),
+import { appendFile as appendFile2, mkdir as mkdir9, readFile as readFile14, readdir as readdir4 } from "fs/promises";
+import { join as join13 } from "path";
+import { z as z10 } from "zod";
+var EventSchema = z10.object({
+  ts: z10.string(),
+  verb: z10.enum(["recall", "open", "resurface"]),
   /** Absent for resurface, which is the point of it. */
-  query: z8.string().nullable().default(null),
+  query: z10.string().nullable().default(null),
   /** Where the caller was. The signal resurface ranks by. */
-  context_dir: z8.string(),
-  detail: z8.string(),
-  limit: z8.number().int().positive().nullable().default(null),
+  context_dir: z10.string(),
+  detail: z10.string(),
+  limit: z10.number().int().positive().nullable().default(null),
   /** Ids the call returned — the denominator for "was any of this used". */
-  returned_ids: z8.array(z8.string()).default([]),
+  returned_ids: z10.array(z10.string()).default([]),
   /** The one that got opened, when this event is an open. */
-  opened_id: z8.string().nullable().default(null)
+  opened_id: z10.string().nullable().default(null)
 });
 function eventsDir(vaultRoot) {
   return stateDirFor(vaultRoot);
 }
 function eventsFile(vaultRoot, ts) {
-  return join11(eventsDir(vaultRoot), `events-${ts.slice(0, 7)}.jsonl`);
+  return join13(eventsDir(vaultRoot), `events-${ts.slice(0, 7)}.jsonl`);
 }
 async function recordEvent(vaultRoot, event) {
   try {
@@ -6118,7 +7366,7 @@ async function recordEvent(vaultRoot, event) {
       returned_ids: [...event.returnedIds ?? []],
       opened_id: event.openedId ?? null
     });
-    await mkdir7(eventsDir(vaultRoot), { recursive: true });
+    await mkdir9(eventsDir(vaultRoot), { recursive: true });
     await appendFile2(eventsFile(vaultRoot, ts), `${JSON.stringify(parsed)}
 `, {
       encoding: "utf8",
@@ -6136,7 +7384,7 @@ async function readEvents(vaultRoot) {
   }
   const events = [];
   for (const file of files2) {
-    const raw = await readFile12(join11(eventsDir(vaultRoot), file), "utf8");
+    const raw = await readFile14(join13(eventsDir(vaultRoot), file), "utf8");
     for (const line of raw.split("\n")) {
       if (line.trim() === "") continue;
       try {
@@ -6202,7 +7450,7 @@ var BASE_FILES = [
   }
 ];
 var HUB_PATH = "00_HUB/HUB.md";
-function bodyOf(content) {
+function bodyOf2(content) {
   const stripped = content.replace(/^/, "");
   const fence = /^---[ \t]*\r?\n[\s\S]*?\r?\n---[ \t]*(\r?\n|$)/.exec(stripped);
   return (fence ? stripped.slice(fence[0].length) : stripped).trim();
@@ -6210,8 +7458,8 @@ function bodyOf(content) {
 function bodyStillTemplate(path, content) {
   const template = files("brain")[path];
   if (template === void 0) return false;
-  const body = bodyOf(content);
-  return body !== "" && body === bodyOf(template);
+  const body = bodyOf2(content);
+  return body !== "" && body === bodyOf2(template);
 }
 async function scaffoldingAmong(adapter, notes) {
   const basePaths = new Set(BASE_FILES.map((f) => f.path));
@@ -6287,112 +7535,147 @@ async function assembleStage(adapter, entry, detail, sectionName) {
 init_vault();
 init_ui();
 function openCommand() {
-  return new Command4("open").description("open one memory, as deeply as you ask").argument("<ref>", "handle, id, path, or exact title").option("--vault <path>", "which brain to read").option("--detail <level>", "card | summary | chunks | full (default: card)").option("--section <name>", "one section (implies --detail chunks)").action(async (ref, opts) => {
-    const detail = parseDetail(opts.detail, opts.section ? "chunks" : "card");
-    const { brain } = await resolveBrain(opts.vault);
-    const adapter = await openBrainOrExplain(brain.root);
-    const built = await openIndex(adapter, brain.root);
-    const entry = resolveRef(built.entries, ref);
-    await recordEvent(brain.root, {
-      verb: "open",
-      detail,
-      returnedIds: [entry.memory.id],
-      openedId: entry.memory.id
-    });
-    const stage = await assembleStage(adapter, entry, detail, opts.section);
-    const claims = entry.claims;
-    const now = /* @__PURE__ */ new Date();
-    const handle2 = displayHandle(
-      entry.memory.id,
-      built.entries.map((e) => e.memory.id)
-    );
-    const scaffolding = (await scaffoldingAmong(adapter, [{ path: entry.path, title: entry.memory.title }])).has(entry.path);
-    printDual({
-      json: {
-        id: entry.memory.id,
-        handle: handle2,
-        path: entry.path,
+  return new Command4("open").description("open one memory, as deeply as you ask").argument("<ref>", "handle, id, path, or exact title").option("--vault <path>", "which brain to read").option("--local", "read the brain on this machine, even when signed in to a hosted one").option("--detail <level>", "card | summary | chunks | full (default: card)").option("--section <name>", "one section (implies --detail chunks)").action(
+    async (ref, opts) => {
+      const detail = parseDetail(opts.detail, opts.section ? "chunks" : "card");
+      const target = await resolveTarget({
+        ...opts.local === void 0 ? {} : { local: opts.local },
+        ...opts.vault === void 0 ? {} : { vault: opts.vault }
+      });
+      if (target.kind === "cloud") {
+        const cloud = await openCloudBrain(target);
+        const found = await cloudOpen(cloud, ref);
+        printDual({
+          json: {
+            id: found.id,
+            handle: found.handle,
+            path: found.path,
+            revision: found.revision,
+            detail,
+            memory: found.memory,
+            claims: found.claims,
+            relations: found.relations,
+            ...detail === "card" ? {} : { body: found.body },
+            brain: { hosted: true, name: target.name }
+          },
+          human: () => {
+            printHuman(`## ${String(found.memory["title"] ?? found.path)}
+`);
+            const summary = found.memory["summary"];
+            if (typeof summary === "string" && summary !== "") printHuman(`> ${summary}
+`);
+            printHuman(c.gray(`${found.path}  \xB7  ${target.name}`));
+            if (detail !== "card" && found.body !== "") printHuman(`
+${found.body}`);
+          }
+        });
+        return;
+      }
+      const brain = target.brain;
+      const adapter = await openBrainOrExplain(brain.root);
+      const built = await openIndex(adapter, brain.root);
+      const entry = resolveRef(built.entries, ref);
+      await recordEvent(brain.root, {
+        verb: "open",
         detail,
-        scaffolding,
-        memory: entry.memory,
-        claims,
-        relations: entry.relations,
-        ...stage
-      },
-      human: () => {
-        printHuman(`## ${entry.memory.title}
+        returnedIds: [entry.memory.id],
+        openedId: entry.memory.id
+      });
+      const stage = await assembleStage(adapter, entry, detail, opts.section);
+      const claims = entry.claims;
+      const now = /* @__PURE__ */ new Date();
+      const handle2 = displayHandle(
+        entry.memory.id,
+        built.entries.map((e) => e.memory.id)
+      );
+      const scaffolding = (await scaffoldingAmong(adapter, [{ path: entry.path, title: entry.memory.title }])).has(entry.path);
+      printDual({
+        json: {
+          id: entry.memory.id,
+          handle: handle2,
+          path: entry.path,
+          detail,
+          scaffolding,
+          memory: entry.memory,
+          claims,
+          relations: entry.relations,
+          ...stage
+        },
+        human: () => {
+          printHuman(`## ${entry.memory.title}
 `);
-        if (scaffolding) {
-          printHuman(
-            c.yellow("not filled in yet") + c.gray(" \u2014 still the template `init` wrote")
-          );
-        } else {
-          printHuman(
-            `${confidenceOf(entry.memory, claims)} \xB7 ${freshnessOf(entry.memory, claims, now)} \xB7 ${entry.memory.provenance.mapping}`
-          );
-        }
-        printHuman(`
+          if (scaffolding) {
+            printHuman(
+              c.yellow("not filled in yet") + c.gray(" \u2014 still the template `init` wrote")
+            );
+          } else {
+            printHuman(
+              `${confidenceOf(entry.memory, claims)} \xB7 ${freshnessOf(entry.memory, claims, now)} \xB7 ${entry.memory.provenance.mapping}`
+            );
+          }
+          printHuman(`
 \`id: ${entry.memory.id}\`  \xB7  \`${entry.path}\`
 `);
-        if (entry.memory.summary) printHuman(quoteBlock(entry.memory.summary) + "\n");
-        for (const claim of claims) {
-          printHuman(`- ${claim.text}`);
-          printHuman(c.gray(`  ${claim.confidence} \xB7 ${claim.status}`));
-        }
-        if (claims.length === 0 && scaffolding) {
-          printHuman(
-            c.gray(
-              `_Nobody has written this yet. The line above is the prompt \`init\` left, and the
+          if (entry.memory.summary) printHuman(quoteBlock(entry.memory.summary) + "\n");
+          for (const claim of claims) {
+            printHuman(`- ${claim.text}`);
+            printHuman(c.gray(`  ${claim.confidence} \xB7 ${claim.status}`));
+          }
+          if (claims.length === 0 && scaffolding) {
+            printHuman(
+              c.gray(
+                `_Nobody has written this yet. The line above is the prompt \`init\` left, and the
 body is its instructions \u2014 neither is something the user said, so do not answer
 from them._
 
 This one is filled in by asking. \`memgineering onboard\` prints the questions;
 write the body, then record the conclusion:
     memgineering revise ${handle2} --claim "<what they told you>" --summary "<one line>"`
-            )
-          );
-        } else if (claims.length === 0) {
-          printHuman(
-            c.gray(
-              entry.memory.provenance.mapping === "explicit" ? "_The title and summary above came from this note, but it declares no `claim` \u2014 so nothing here states a conclusion. That is what `stated` above refers to: where the fields came from, not that a conclusion exists._" : "_No claim declared \u2014 this card was inferred from the note._"
-            )
-          );
-          printHuman(
-            c.gray(
-              `To state one:
+              )
+            );
+          } else if (claims.length === 0) {
+            printHuman(
+              c.gray(
+                entry.memory.provenance.mapping === "explicit" ? "_The title and summary above came from this note, but it declares no `claim` \u2014 so nothing here states a conclusion. That is what `stated` above refers to: where the fields came from, not that a conclusion exists._" : "_No claim declared \u2014 this card was inferred from the note._"
+              )
+            );
+            printHuman(
+              c.gray(
+                `To state one:
     memgineering revise ${handle2} --claim "<the conclusion>" --summary "<one line>"
 Add --contradicts <id> when it disagrees with another memory; that edge is what
 makes the two surface together as a conflict.`
-            )
-          );
-        }
-        if (stage.outline && stage.outline.length > 0) {
-          printHuman("\n### sections\n");
-          for (const heading of stage.outline) printHuman(`- ${heading}`);
-          printHuman("");
-        }
-        if (stage.sections) {
-          for (const section of stage.sections) {
-            printHuman(`
+              )
+            );
+          }
+          if (stage.outline && stage.outline.length > 0) {
+            printHuman("\n### sections\n");
+            for (const heading of stage.outline) printHuman(`- ${heading}`);
+            printHuman("");
+          }
+          if (stage.sections) {
+            for (const section of stage.sections) {
+              printHuman(`
 ### ${section.label}
 `);
-            printHuman(quoteBlock(section.body));
+              printHuman(quoteBlock(section.body));
+            }
+            printHuman("");
+          }
+          if (stage.body) {
+            printHuman("\n### full\n");
+            printHuman(quoteBlock(stage.body));
+            printHuman("");
+          }
+          if (detail === "card") {
+            printHuman(
+              c.gray(`Deeper: \`memgineering open ${handle2} --detail summary | chunks | full\``)
+            );
           }
-          printHuman("");
-        }
-        if (stage.body) {
-          printHuman("\n### full\n");
-          printHuman(quoteBlock(stage.body));
-          printHuman("");
-        }
-        if (detail === "card") {
-          printHuman(
-            c.gray(`Deeper: \`memgineering open ${handle2} --detail summary | chunks | full\``)
-          );
         }
-      }
-    });
-  });
+      });
+    }
+  );
 }
 function resolveRef(entries, ref) {
   const ids = entries.map((e) => e.memory.id);
@@ -6450,8 +7733,16 @@ init_link();
 function lifecycleCommand(action) {
   return new Command6(action).description(
     action === "retire" ? "mark a memory as no longer current \u2014 the note itself is not changed" : "mark a retired memory as current again"
-  ).argument("<ref>", "handle, id, path, or exact title").option("--reason <text>", "why \u2014 kept in the ledger").option("--vault <path>", "which brain the memory is in").action(async (ref, opts) => {
+  ).argument("<ref>", "handle, id, path, or exact title").option("--reason <text>", "why \u2014 kept in the ledger").option("--vault <path>", "which brain the memory is in").option("--local", "use the brain on this machine, even when signed in to a hosted one").action(async (ref, opts) => {
     const rationale = sanitizeRationale(opts.reason);
+    const where = await resolveTarget({
+      ...opts.local === void 0 ? {} : { local: opts.local },
+      ...opts.vault === void 0 ? {} : { vault: opts.vault }
+    });
+    if (where.kind === "cloud") {
+      await lifecycleHosted(where, action, ref, opts.reason);
+      return;
+    }
     const { brain } = await resolveBrain(opts.vault);
     const adapter = await LocalFileCasAdapter.openVault(brain.root, {
       createPrefix: brain.observationsDir
@@ -6459,40 +7750,8 @@ function lifecycleCommand(action) {
     const built = await openIndex(adapter, brain.root);
     const entry = resolveRef(built.entries, ref);
     const result = commit(
-      {
-        candidate: {
-          subject: entry.memory.title,
-          scope: entry.memory.scope,
-          kind: entry.memory.type,
-          candidate_claim: entry.memory.summary ?? entry.memory.title,
-          entities: [],
-          importance: "normal"
-        },
-        matches: [
-          {
-            id: entry.memory.id,
-            title: entry.memory.title,
-            summary: entry.memory.summary,
-            path: entry.path,
-            revision: entry.revision,
-            freshness: "current",
-            score: 1
-          }
-        ],
-        contradicts: [],
-        scopes: entry.memory.scope ? [entry.memory.scope] : []
-      },
-      {
-        action,
-        memory_id: entry.memory.id,
-        claim: null,
-        reason: opts.reason ?? `${action}d directly`,
-        // For a standing change the memory's own summary IS the passage the
-        // decision is about: it is what the note currently says, and it is
-        // what stops being current.
-        source_excerpt: entry.memory.summary ?? entry.memory.title,
-        target_path: entry.path
-      }
+      asSingleMatch(entry),
+      lifecycleInput(entry, action, opts.reason ?? null)
     );
     if (result.action === "ignore") {
       throw memgError(
@@ -6554,8 +7813,16 @@ Undo: \`${undoHint(record.op_id, opts.vault)}\``));
 function ignoreCommand(mode) {
   return new Command6(mode).description(
     mode === "exclude" ? "stop reading a note entirely \u2014 the note itself is not changed" : "read a note again after excluding it"
-  ).argument("<path>", "path inside the brain, e.g. decisions/launch-date.md").option("--reason <text>", "why \u2014 kept in the ledger").option("--vault <path>", "which brain the note is in").action(async (path, opts) => {
+  ).argument("<path>", "path inside the brain, e.g. decisions/launch-date.md").option("--reason <text>", "why \u2014 kept in the ledger").option("--vault <path>", "which brain the note is in").option("--local", "use the brain on this machine, even when signed in to a hosted one").action(async (path, opts) => {
     const rationale = sanitizeRationale(opts.reason);
+    const where = await resolveTarget({
+      ...opts.local === void 0 ? {} : { local: opts.local },
+      ...opts.vault === void 0 ? {} : { vault: opts.vault }
+    });
+    if (where.kind === "cloud") {
+      await ignoreHosted(where, mode, path, opts.reason);
+      return;
+    }
     const { brain } = await resolveBrain(opts.vault);
     const adapter = await LocalFileCasAdapter.openVault(brain.root, {
       createPrefix: brain.observationsDir
@@ -6608,6 +7875,57 @@ Undo: \`${undoHint(record.op_id, opts.vault)}\``));
     });
   });
 }
+async function lifecycleHosted(where, action, ref, reason) {
+  const brain = await openCloudBrain(where);
+  const result = await cloudLifecycle(brain, action, {
+    ref,
+    ...reason === void 0 ? {} : { reason }
+  });
+  printDual({
+    json: { brain: where.name, ...result },
+    human: () => {
+      printHuman(
+        action === "retire" ? `Retired in **${where.name}**.
+` : `Current again in **${where.name}**.
+`
+      );
+      printHuman(`\`${result.target}\`
+`);
+      printHuman(c.gray(result.note));
+      printHuman(
+        c.gray(
+          `
+To put it back: \`memgineering ${action === "retire" ? "unretire" : "retire"} ${ref}\``
+        )
+      );
+    }
+  });
+}
+async function ignoreHosted(where, mode, path, reason) {
+  const brain = await openCloudBrain(where);
+  const result = await cloudExclude(brain, mode, {
+    path,
+    ...reason === void 0 ? {} : { reason }
+  });
+  printDual({
+    json: { brain: where.name, ...result },
+    human: () => {
+      if (!result.changed) {
+        printHuman(c.gray(result.note));
+        return;
+      }
+      printHuman(
+        mode === "exclude" ? `No longer reading \`${result.path}\` in **${where.name}**.
+` : `Reading \`${result.path}\` again in **${where.name}**.
+`
+      );
+      printHuman(c.gray(result.note));
+      if (result.op_id) printHuman(c.gray(`
+Undo: \`memgineering ${opposite(mode)} ${path}\``));
+    }
+  });
+}
+var opposite = (mode) => mode === "exclude" ? "unexclude" : "exclude";
 async function mustMatchAFile(root, adapter, path) {
   const wanted = path.normalize("NFC").replace(/^\/+/, "");
   const absolute = resolve6(root, wanted);
@@ -6633,8 +7951,31 @@ init_index_build();
 init_vault();
 init_ui();
 function evidenceCommand() {
-  return new Command7("evidence").description("how much a memory has been used, and why it last changed").argument("<ref>", "handle, id, path, or exact title").option("--vault <path>", "which brain to read").action(async (ref, opts) => {
-    const { brain } = await resolveBrain(opts.vault);
+  return new Command7("evidence").description("how much a memory has been used, and why it last changed").argument("<ref>", "handle, id, path, or exact title").option("--vault <path>", "which brain to read").option("--local", "read the brain on this machine, even when signed in to a hosted one").action(async (ref, opts) => {
+    const target = await resolveTarget({
+      ...opts.local === void 0 ? {} : { local: opts.local },
+      ...opts.vault === void 0 ? {} : { vault: opts.vault }
+    });
+    if (target.kind === "cloud") {
+      const cloud = await openCloudBrain(target);
+      const report2 = await cloudEvidence(cloud, ref);
+      printDual({
+        json: { ...report2, brain: { hosted: true, name: target.name } },
+        human: () => {
+          const window = report2["counts_cover_days"];
+          printHuman(
+            `surfaced ${String(report2["surfaced"] ?? 0)} \xB7 opened ${String(report2["opened"] ?? 0)}`
+          );
+          if (typeof window === "number") {
+            printHuman(c.gray(`  counts cover the last ${window} days, not all time`));
+          }
+          const why = report2["last_reason"];
+          if (typeof why === "string" && why !== "") printHuman(c.gray(`  last change: ${why}`));
+        }
+      });
+      return;
+    }
+    const brain = target.brain;
     const adapter = await openBrainOrExplain(brain.root);
     const built = await openIndex(adapter, brain.root);
     const entry = resolveRef(built.entries, ref);
@@ -6798,8 +8139,41 @@ import { Command as Command8 } from "commander";
 init_vault();
 init_ui();
 function logCommand() {
-  return new Command8("log").description("what changed in this brain, and what can still be undone").option("--limit <n>", "how many operations", (v) => parseInt(v, 10), 20).option("--verbose", "include hashes and reverse patches").option("--vault <path>", "which brain to read").action(async (opts) => {
-    const { brain } = await resolveBrain(opts.vault);
+  return new Command8("log").description("what changed in this brain, and what can still be undone").option("--limit <n>", "how many operations", (v) => parseInt(v, 10), 20).option("--verbose", "include hashes and reverse patches").option("--vault <path>", "which brain to read").option("--local", "read the brain on this machine, even when signed in to a hosted one").action(async (opts) => {
+    const target = await resolveTarget({
+      ...opts.local === void 0 ? {} : { local: opts.local },
+      ...opts.vault === void 0 ? {} : { vault: opts.vault }
+    });
+    if (target.kind === "cloud") {
+      const cloud = await openCloudBrain(target);
+      const history = await cloudLog(cloud, {
+        limit: opts.limit,
+        ...opts.verbose === true ? { verbose: true } : {}
+      });
+      printDual({
+        json: { ...history, brain: { hosted: true, name: target.name } },
+        human: () => {
+          const ops2 = history["operations"] ?? [];
+          const diverged2 = history["divergence"] ?? [];
+          printHuman(`## log \u2014 ${target.name}  (${ops2.length} operations)
+`);
+          for (const op of ops2) {
+            printHuman(
+              `${String(op["ts"] ?? "")}  ${String(op["verb"] ?? "")}  ${String(op["target"] ?? "")}`
+            );
+            printHuman(c.gray(`  \`${String(op["op_id"] ?? "")}\``));
+          }
+          if (diverged2.length > 0) {
+            printHuman(
+              c.yellow(`
+${diverged2.length} of these no longer match the note on the server.`)
+            );
+          }
+        }
+      });
+      return;
+    }
+    const brain = target.brain;
     const adapter = await openBrainOrExplain(brain.root);
     const { ops, skipped } = await readOps(brain.root);
     const recent = ops.slice(-opts.limit).reverse();
@@ -6896,12 +8270,111 @@ async function readOrNull(adapter, path) {
   }
 }
 
+// src/program.ts
+init_login();
+
+// src/commands/logout.ts
+init_errors();
+init_api_client();
+init_credentials();
+init_pending_login();
+init_ui();
+import { Command as Command10 } from "commander";
+function logoutCommand() {
+  return new Command10("logout").description("sign out of a hosted brain").option("--all", "revoke every token on the account, not just this machine\u2019s").option(
+    "--local",
+    "forget the token here without telling the server \u2014 only for a server you cannot reach"
+  ).action(async (opts) => {
+    const base = apiUrl();
+    const credentials = await readCredentials();
+    await clearPendingLogin();
+    if (!credentials) {
+      printDual({
+        json: { signed_out: true, was_signed_in: false, api_url: base },
+        human: () => printHuman("Not signed in \u2014 nothing to do.")
+      });
+      return;
+    }
+    if (opts.local) {
+      await clearCredentials();
+      printDual({
+        json: { signed_out: true, revoked_on_server: false, api_url: credentials.api_url },
+        human: () => {
+          printHuman("Forgotten here.");
+          printHuman(
+            c.yellow(
+              "  The token was NOT revoked \u2014 it still works for anyone holding a copy.\n  Run `memgineering logout --all` once the server is reachable."
+            )
+          );
+        }
+      });
+      return;
+    }
+    let revoked = null;
+    try {
+      if (opts.all) {
+        const res = await apiRequest({
+          method: "POST",
+          path: "/v1/tokens/revoke-all",
+          token: credentials.token,
+          baseUrl: credentials.api_url
+        });
+        revoked = res.body?.revoked ?? null;
+      } else {
+        const me = await apiRequest({
+          method: "GET",
+          path: "/v1/me",
+          token: credentials.token,
+          baseUrl: credentials.api_url
+        });
+        const id = me.body?.tokens?.current_id;
+        if (id) {
+          await apiRequest({
+            method: "DELETE",
+            path: `/v1/tokens/${id}`,
+            token: credentials.token,
+            baseUrl: credentials.api_url
+          });
+        }
+        revoked = 1;
+      }
+    } catch (err) {
+      const code = err instanceof MemgError ? err.code : "";
+      if (code !== "not_authenticated" && code !== "not_found") {
+        throw err instanceof MemgError ? new MemgError({
+          code: err.code,
+          message: err.message,
+          hint: `${err.hint} The token is still stored here and still works; nothing was changed. \`memgineering logout --local\` forgets it on this machine without revoking it.`
+        }) : err;
+      }
+    }
+    await clearCredentials();
+    printDual({
+      json: {
+        signed_out: true,
+        revoked_on_server: true,
+        revoked,
+        all: opts.all === true,
+        api_url: credentials.api_url
+      },
+      human: () => {
+        printHuman(opts.all ? "Signed out everywhere." : "Signed out.");
+        printHuman(
+          c.gray(
+            opts.all ? "  Every token on the account is dead. `memgineering login` starts a new one." : "  This machine\u2019s token is revoked. Other machines are unaffected."
+          )
+        );
+      }
+    });
+  });
+}
+
 // src/commands/onboard.ts
-import { Command as Command9 } from "commander";
+import { Command as Command11 } from "commander";
 init_vault();
 init_ui();
 function onboardCommand() {
-  return new Command9("onboard").description("what to ask so the brain knows who it belongs to").option("--vault <path>", "which brain").action(async (opts) => {
+  return new Command11("onboard").description("what to ask so the brain knows who it belongs to").option("--vault <path>", "which brain").action(async (opts) => {
     const { brain } = await resolveBrain(opts.vault);
     const adapter = await openBrainOrExplain(brain.root);
     const untouched = await untouchedBase(
@@ -6963,48 +8436,402 @@ function onboardCommand() {
   });
 }
 
+// src/commands/pull.ts
+init_errors();
+init_api_client();
+import { mkdir as mkdir11, readFile as readFile16, writeFile as writeFile9 } from "fs/promises";
+import { dirname as dirname3, isAbsolute as isAbsolute2, join as join16, resolve as resolve7, sep as sep2 } from "path";
+import { Command as Command12 } from "commander";
+init_ui();
+function pullCommand() {
+  return new Command12("pull").description("download your hosted brain to a folder on this machine").argument("[destination]", "folder to write into (created if missing)").option("--brain <name>", "which hosted brain to download").option("--dry-run", "say what would be written and write nothing").action(async (destination, opts) => {
+    const source = await resolveSource(opts.brain);
+    const target = resolve7(destination ?? `./${source.name}`);
+    const first = await cloudListNotes(source, { limit: 1 });
+    if (first.total === 0) {
+      throw memgError(
+        "invalid_input",
+        `\u201C${source.name}\u201D has no notes to download`,
+        "Nothing was written. `memgineering push` carries a brain on this disk up to the hosted one, and `remember` writes a first note into it."
+      );
+    }
+    if (opts.dryRun) {
+      const preview = await collectPaths(source);
+      printDual({
+        json: {
+          dry_run: true,
+          brain: { id: source.brainId, name: source.name },
+          into: target,
+          notes: first.total,
+          excluded: preview.filter((n) => n.excluded === true).length,
+          paths: preview.slice(0, 100).map((n) => n.path),
+          ...preview.length > 100 ? { paths_truncated: preview.length - 100 } : {}
+        },
+        human: () => {
+          printHuman(`## pull (dry run)
+`);
+          printHuman(`${first.total} note(s) from \u201C${source.name}\u201D into \`${target}\`
+`);
+          for (const note of preview.slice(0, 20)) {
+            printHuman(c.gray(`  ${note.path}${note.excluded === true ? "   (excluded)" : ""}`));
+          }
+          if (preview.length > 20) printHuman(c.gray(`  \u2026 and ${preview.length - 20} more`));
+          printHuman(
+            c.gray(
+              "\nNothing was written. A real run never replaces a file that is already\nthere \u2014 it skips it and says so."
+            )
+          );
+        }
+      });
+      return;
+    }
+    progress(`downloading ${first.total} note(s) from \u201C${source.name}\u201D\u2026`);
+    const written = [];
+    const already = [];
+    const excluded = [];
+    let cursor;
+    do {
+      const page = await cloudListNotes(source, {
+        ...cursor === void 0 ? {} : { cursor },
+        content: true
+      });
+      for (const note of page.notes) {
+        const file = safeJoin(target, note.path);
+        if (await exists(file)) {
+          already.push(note.path);
+          continue;
+        }
+        await mkdir11(dirname3(file), { recursive: true });
+        await writeFile9(file, note.content ?? "", "utf8");
+        written.push(note.path);
+        if (note.excluded === true) excluded.push(note.path);
+      }
+      cursor = page.next_cursor;
+    } while (cursor);
+    printDual({
+      json: {
+        brain: { id: source.brainId, name: source.name },
+        into: target,
+        written: written.length,
+        already_there: already.length,
+        excluded: excluded.length,
+        next: `\`memgineering link ${target}\` reads this folder as a brain on this machine. Until then it is markdown and nothing else.`
+      },
+      human: () => {
+        printHuman(c.green(`\u2713 ${written.length} note(s) written to \`${target}\``));
+        if (already.length > 0) {
+          printHuman(
+            c.gray(`  ${already.length} were already there \u2014 left untouched, not overwritten`)
+          );
+        }
+        if (excluded.length > 0) {
+          printHuman(
+            c.yellow(`  ${excluded.length} of them are notes this brain excludes from recall`) + c.gray("\n  they came down because they are yours; `.memgignore` came with them")
+          );
+        }
+        printHuman(
+          c.gray(
+            `
+This is a folder of markdown, not yet a brain on this machine.
+\`memgineering link ${target}\` makes it one \u2014 it shows what it would read first.`
+          )
+        );
+      }
+    });
+  });
+}
+async function collectPaths(source) {
+  const all = [];
+  let cursor;
+  do {
+    const page = await cloudListNotes(source, cursor === void 0 ? {} : { cursor });
+    all.push(...page.notes);
+    cursor = page.next_cursor;
+  } while (cursor);
+  return all;
+}
+async function resolveSource(named) {
+  const base = apiUrl();
+  const credentials = await requireCredentials(base);
+  const brains = await listCloudBrains(credentials.token, base);
+  if (brains.length === 0) {
+    throw memgError(
+      "invalid_input",
+      "this account has no hosted brains",
+      "Nothing to download. `memgineering push` carries the brain on this disk up to a hosted one."
+    );
+  }
+  const found = named ? brains.find((b) => b.name === named || b.id === named) : brains.length === 1 ? brains[0] : void 0;
+  if (!found) {
+    throw memgError(
+      "invalid_input",
+      named ? `no hosted brain called \u201C${named}\u201D` : "more than one hosted brain \u2014 say which",
+      `Pass one of: ${brains.map((b) => b.name).join(", ")}  (e.g. \`memgineering pull --brain ${brains[0]?.name}\`)`
+    );
+  }
+  return { brainId: found.id, name: found.name, token: credentials.token, apiUrl: base };
+}
+function safeJoin(root, relative4) {
+  if (isAbsolute2(relative4)) {
+    throw memgError(
+      "server_refused",
+      `the server sent an absolute path: ${relative4}`,
+      "Nothing was written for it. This should not happen \u2014 please report it."
+    );
+  }
+  const full = resolve7(join16(root, relative4));
+  if (full !== root && !full.startsWith(root + sep2)) {
+    throw memgError(
+      "server_refused",
+      `the server sent a path that escapes the destination: ${relative4}`,
+      "Nothing was written for it. This should not happen \u2014 please report it."
+    );
+  }
+  return full;
+}
+async function exists(file) {
+  try {
+    await readFile16(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/push.ts
+init_errors();
+init_config();
+init_api_client();
+import { Command as Command13 } from "commander";
+init_vault();
+init_ui();
+function pushCommand() {
+  return new Command13("push").description("upload the brain on this machine to your hosted one").option("--vault <path>", "which local brain to upload").option("--brain <name>", "the hosted brain to upload into (created if it does not exist)").option("--dry-run", "list what would be uploaded and send nothing").action(async (opts) => {
+    const { brain: local } = await resolveBrain(opts.vault);
+    const adapter = await openBrainOrExplain(local.root);
+    const scan = await adapter.scan();
+    const paths = scan.files.filter((p) => /\.(md|markdown)$/i.test(p));
+    if (paths.length === 0) {
+      throw memgError(
+        "invalid_input",
+        `there is nothing to upload in ${local.root}`,
+        "This brain has no markdown notes that the rules allow. `memgineering reindex` prints what is being left out and why."
+      );
+    }
+    if (opts.dryRun) {
+      printDual({
+        json: {
+          dry_run: true,
+          from: local.root,
+          notes: paths.length,
+          paths: paths.slice(0, 100),
+          ...paths.length > 100 ? { paths_truncated: paths.length - 100 } : {}
+        },
+        human: () => {
+          printHuman(`## push (dry run)
+`);
+          printHuman(`${paths.length} note(s) from \`${local.root}\`
+`);
+          for (const path of paths.slice(0, 20)) printHuman(c.gray(`  ${path}`));
+          if (paths.length > 20) printHuman(c.gray(`  \u2026 and ${paths.length - 20} more`));
+          printHuman(
+            c.gray(
+              "\nNothing was sent. Notes carrying credential material are refused by the\nserver and would be listed in the summary; a dry run cannot know which,\nbecause it does not read the bytes."
+            )
+          );
+        }
+      });
+      return;
+    }
+    const destination = await resolveDestination(opts.brain, local.root);
+    progress(`uploading ${paths.length} note(s) to \u201C${destination.name}\u201D\u2026`);
+    const uploaded = [];
+    const already = [];
+    const refused = [];
+    for (const path of paths) {
+      let content;
+      try {
+        content = (await adapter.read(path)).content;
+      } catch (err) {
+        refused.push({
+          path,
+          code: err.code ?? "read_failed",
+          message: err.message
+        });
+        continue;
+      }
+      try {
+        await cloudPutNote(destination, { path, content });
+        uploaded.push(path);
+      } catch (err) {
+        const code = err.code;
+        if (code === "note_exists") {
+          already.push(path);
+          continue;
+        }
+        if (code === "write_refused" || code === "invalid_path" || code === "rationale_refused") {
+          refused.push({ path, code, message: err.message });
+          continue;
+        }
+        throw Object.assign(err, {
+          hint: `${uploaded.length} note(s) went up before this. Nothing was deleted locally, and running \`memgineering push\` again resumes from where it stopped. ` + (err.hint ?? "")
+        });
+      }
+    }
+    await pointConfigAt(destination);
+    printDual({
+      json: {
+        from: local.root,
+        brain: { id: destination.brainId, name: destination.name },
+        uploaded: uploaded.length,
+        already_there: already.length,
+        refused
+      },
+      human: () => {
+        printHuman(c.green(`\u2713 ${uploaded.length} note(s) uploaded to \u201C${destination.name}\u201D`));
+        if (already.length > 0) {
+          printHuman(c.gray(`  ${already.length} were already there \u2014 left as they are`));
+        }
+        if (refused.length > 0) {
+          printHuman(
+            c.yellow(`
+\u26A0 ${refused.length} note(s) were NOT uploaded:`) + c.gray("\n  they are untouched on this machine and can be fixed and pushed again")
+          );
+          for (const r of refused.slice(0, 10)) {
+            printHuman(c.gray(`  ${r.path}  (${r.code})`));
+          }
+          if (refused.length > 10) {
+            printHuman(c.gray(`  \u2026 and ${refused.length - 10} more`));
+          }
+        }
+        printHuman(
+          c.gray(
+            `
+This machine now reads \u201C${destination.name}\u201D. Nothing was deleted from
+\`${local.root}\` \u2014 \`memgineering recall --local\` still reads it.`
+          )
+        );
+      }
+    });
+  });
+}
+async function resolveDestination(named, root) {
+  const base = apiUrl();
+  const credentials = await requireCredentials(base);
+  const config = await loadConfig();
+  const brains = await listCloudBrains(credentials.token, base);
+  const pick = (summary) => ({
+    brainId: summary.id,
+    name: summary.name,
+    token: credentials.token,
+    apiUrl: base
+  });
+  if (named) {
+    const found = brains.find((b) => b.name === named || b.id === named);
+    return pick(found ?? await createCloudBrain(credentials.token, base, named));
+  }
+  const current = config.brain.cloud;
+  if (current && current.api_url === base) {
+    const found = brains.find((b) => b.id === current.id);
+    if (found) return pick(found);
+  }
+  const fallbackName = root.split("/").filter(Boolean).pop() ?? "brain";
+  const existing = brains.find((b) => b.name === fallbackName);
+  return pick(existing ?? await createCloudBrain(credentials.token, base, fallbackName));
+}
+async function pointConfigAt(destination) {
+  const config = await loadConfig();
+  await saveConfig({
+    ...config,
+    brain: {
+      ...config.brain,
+      cloud: { id: destination.brainId, name: destination.name, api_url: destination.apiUrl }
+    }
+  });
+}
+
 // src/commands/recall.ts
 init_src();
-import { Command as Command10 } from "commander";
+import { Command as Command14 } from "commander";
 init_index_build();
+init_errors();
 init_vault();
 init_ui();
 function recallCommand() {
-  return new Command10("recall").description("recall memory cards for a question").argument("<query>", "what you want to remember").option("--vault <path>", "which brain to search").option("--scope <scope>", "restrict to one scope").option("--limit <n>", "max cards", (v) => parseInt(v, 10), 8).option("--detail <level>", "title | card | summary | chunks | full (default: card)").action(
+  return new Command14("recall").description("recall memory cards for a question").argument("<query>", "what you want to remember").option("--vault <path>", "which brain to search").option("--local", "search the brain on this machine, even when signed in to a hosted one").option("--scope <scope>", "restrict to one scope").option("--limit <n>", "max cards", (v) => parseInt(v, 10), 8).option("--detail <level>", "title | card | summary | chunks | full (default: card)").action(
     async (query, opts) => {
       const detail = parseDetail(opts.detail, "card");
-      const { brain } = await resolveBrain(opts.vault);
-      const adapter = await openBrainOrExplain(brain.root);
-      const built = await openIndex(adapter, brain.root);
-      const result = recall(built.entries, query, {
-        limit: opts.limit,
-        ...opts.scope ? { scope: opts.scope } : {}
+      const target = await resolveTarget({
+        ...opts.local === void 0 ? {} : { local: opts.local },
+        ...opts.vault === void 0 ? {} : { vault: opts.vault }
       });
-      await recordEvent(brain.root, {
-        verb: "recall",
-        query,
-        detail,
-        limit: opts.limit,
-        returnedIds: result.memory_cards.map((card) => card.id)
-      });
-      const allIds = built.entries.map((e) => e.memory.id);
-      const byId = new Map(built.entries.map((e) => [e.memory.id, e]));
-      const rows = await Promise.all(
-        result.memory_cards.map(async (card) => ({
-          card,
-          handle: displayHandle(card.id, allIds),
-          stage: await stageFor(adapter, byId.get(card.id), detail)
-        }))
-      );
-      const scaffolding = await scaffoldingAmong(
-        adapter,
-        rows.map(({ card }) => {
-          const entry = byId.get(card.id);
-          return { path: entry?.path ?? "", title: entry?.memory.title ?? "" };
-        })
-      );
-      const isScaffolding = (card) => scaffolding.has(byId.get(card.id)?.path ?? "");
-      const reasons = result.conflicts.length > 0 ? await conflictReasons(brain.root, result.conflicts, byId) : /* @__PURE__ */ new Map();
+      let rows;
+      let isScaffolding;
+      let reasons;
+      let pathOf;
+      let entries;
+      let result;
+      if (target.kind === "cloud") {
+        if (detail !== "title" && detail !== "card") {
+          throw memgError(
+            "invalid_input",
+            `\`--detail ${detail}\` is not available on a hosted brain`,
+            `Nothing was read. Hosted recall returns cards; \`memgineering open <handle> --detail ${detail}\` fetches one note's prose, and \`--local\` runs the whole search against the brain on this machine.`
+          );
+        }
+        const cloud = await openCloudBrain(target);
+        const answered = await cloudRecall(cloud, {
+          query,
+          limit: opts.limit,
+          ...opts.scope ? { scope: opts.scope } : {}
+        });
+        rows = answered.memory_cards.map((card) => ({ card, handle: card.handle, stage: {} }));
+        isScaffolding = () => false;
+        reasons = /* @__PURE__ */ new Map();
+        pathOf = () => null;
+        entries = null;
+        result = {
+          memory_cards: answered.memory_cards,
+          related: answered.related ?? [],
+          conflicts: answered.conflicts ?? []
+        };
+      } else {
+        const brain = target.brain;
+        const adapter = await openBrainOrExplain(brain.root);
+        const built = await openIndex(adapter, brain.root);
+        const local = recall(built.entries, query, {
+          limit: opts.limit,
+          ...opts.scope ? { scope: opts.scope } : {}
+        });
+        result = local;
+        entries = built.entries;
+        await recordEvent(brain.root, {
+          verb: "recall",
+          query,
+          detail,
+          limit: opts.limit,
+          returnedIds: result.memory_cards.map((card) => card.id)
+        });
+        const allIds = built.entries.map((e) => e.memory.id);
+        const byId = new Map(built.entries.map((e) => [e.memory.id, e]));
+        pathOf = (card) => byId.get(card.id)?.path ?? null;
+        rows = await Promise.all(
+          result.memory_cards.map(async (card) => ({
+            card,
+            handle: displayHandle(card.id, allIds),
+            stage: await stageFor(adapter, byId.get(card.id), detail)
+          }))
+        );
+        const scaffolding = await scaffoldingAmong(
+          adapter,
+          rows.map(({ card }) => {
+            const entry = byId.get(card.id);
+            return { path: entry?.path ?? "", title: entry?.memory.title ?? "" };
+          })
+        );
+        isScaffolding = (card) => scaffolding.has(byId.get(card.id)?.path ?? "");
+        reasons = result.conflicts.length > 0 ? await conflictReasons(brain.root, result.conflicts, byId) : /* @__PURE__ */ new Map();
+      }
       printDual({
         json: {
           query,
@@ -7012,7 +8839,7 @@ function recallCommand() {
           cards: rows.map(({ card, handle: handle2, stage }) => ({
             ...card,
             handle: handle2,
-            path: byId.get(card.id)?.path ?? null,
+            path: pathOf(card),
             // A fact about the file, not a judgement about the match: this
             // note is still exactly what `init` wrote, so nobody has answered
             // it yet.
@@ -7028,7 +8855,7 @@ function recallCommand() {
         },
         human: () => {
           const reachedSomethingWritten = rows.some(({ card }) => !isScaffolding(card));
-          const otherScript = reachedSomethingWritten ? null : unreachableScript(query, built.entries);
+          const otherScript = reachedSomethingWritten ? null : entries ? unreachableScript(query, entries) : null;
           const sayWhy = () => {
             printHuman(
               c.yellow(
@@ -7166,7 +8993,8 @@ function ago2(days) {
 function unreachableScript(query, entries) {
   const queryScripts = scriptsIn(query);
   if (queryScripts.size === 0) return null;
-  const written = entries.filter((e) => !e.path.startsWith("01_BASE/"));
+  const SCAFFOLD = ["01_BASE/", "00_HUB/"];
+  const written = entries.filter((e) => !SCAFFOLD.some((dir) => e.path.startsWith(dir)));
   const counts = /* @__PURE__ */ new Map();
   for (const entry of written) {
     const script = dominantScriptOf(`${entry.memory.title} ${entry.memory.summary ?? ""}`);
@@ -7175,6 +9003,12 @@ function unreachableScript(query, entries) {
   if (counts.size === 0) return null;
   const [dominant, seen] = [...counts].sort((a, b) => b[1] - a[1])[0];
   if (queryScripts.has(dominant)) return null;
+  if (queryScripts.size > 0) {
+    for (const entry of written) {
+      const script = dominantScriptOf(`${entry.memory.title} ${entry.memory.summary ?? ""}`);
+      if (script && queryScripts.has(script)) return null;
+    }
+  }
   return seen >= Math.max(2, written.length / 2) ? dominant : null;
 }
 var SCRIPT_RANGES = [
@@ -7213,73 +9047,103 @@ function scriptsIn(text) {
 }
 
 // src/commands/remember.ts
-import { Command as Command11 } from "commander";
+import { Command as Command15 } from "commander";
 init_errors();
 init_vault();
 init_ui();
 function rememberCommand() {
-  return new Command11("remember").description("write something down now, with no approval step").argument("<text>", "what to remember").option("--vault <path>", "which brain to write to").option("--scope <scope>", "what this is about \u2014 a project, an area").option(
+  return new Command15("remember").description("write something down now, with no approval step").argument("<text>", "what to remember").option("--vault <path>", "which brain to write to").option("--local", "write to the brain on this machine, even when signed in to a hosted one").option("--scope <scope>", "what this is about \u2014 a project, an area").option(
     "--reason <text>",
     "why you are recording this \u2014 goes in the ledger, not in the note (the fact itself belongs in <text>)"
-  ).action(async (text, opts) => {
-    const body = stripControl(text).trim();
-    if (body === "") {
-      throw memgError(
-        "invalid_input",
-        "nothing to remember",
-        'Pass the text: `memgineering remember "deploys are manual \u2014 launchctl by hand"`'
-      );
-    }
-    const rationale = sanitizeRationale(opts.reason);
-    const { brain } = await resolveBrain(opts.vault);
-    await openBrainOrExplain(brain.root);
-    const now = /* @__PURE__ */ new Date();
-    const id = newId();
-    const month = now.toISOString().slice(0, 7);
-    const dir = `${brain.observationsDir.replace(/\/+$/, "")}/${month}`;
-    const path = `${dir}/obs-${id}.md`;
-    const content = renderObservation({
-      id,
-      text: body,
-      now,
-      ...opts.scope ? { scope: opts.scope } : {}
-    });
-    const record = await withWriteLock(brain.root, async () => {
-      const adapter = await LocalFileCasAdapter.openVault(brain.root, {
-        // Writes are confined to the observations folder. `remember` creates;
-        // it has no business being able to author a file anywhere in someone's
-        // vault, and the adapter enforces that rather than this command
-        // promising it.
-        createPrefix: brain.observationsDir
-      });
-      const result = await adapter.create(path, content);
-      if (!result.ok) {
+  ).action(
+    async (text, opts) => {
+      const body = stripControl(text).trim();
+      if (body === "") {
         throw memgError(
           "invalid_input",
-          `a note already exists at ${path}`,
-          "This should not happen \u2014 ids are random. Run the command again."
+          "nothing to remember",
+          'Pass the text: `memgineering remember "deploys are manual \u2014 launchctl by hand"`'
         );
       }
-      return appendOp(brain.root, {
-        verb: "remember",
-        target: path,
-        memoryId: id,
-        hashBefore: null,
-        hashAfter: hashContent(content),
-        rationale,
-        now
+      const rationale = sanitizeRationale(opts.reason);
+      const target = await resolveTarget({
+        ...opts.local === void 0 ? {} : { local: opts.local },
+        ...opts.vault === void 0 ? {} : { vault: opts.vault }
       });
-    });
-    printDual({
-      json: { id, path, op_id: record.op_id, scope: opts.scope ?? null },
-      human: () => {
-        printHuman(`Remembered.
+      if (target.kind === "cloud") {
+        const cloud = await openCloudBrain(target);
+        const written = await cloudRemember(cloud, {
+          text: body,
+          ...opts.scope ? { scope: opts.scope } : {},
+          ...rationale ? { reason: rationale } : {}
+        });
+        printDual({
+          json: {
+            id: written.id,
+            path: written.path,
+            op_id: written.op_id,
+            scope: written.scope,
+            brain: { hosted: true, name: target.name }
+          },
+          human: () => {
+            printHuman(`Remembered in ${target.name}.
 `);
-        printHuman(`note:  \`${id}\`  \xB7  \`${path}\``);
-        printHuman(c.gray(`undo:  \`${undoHint(record.op_id, opts.vault)}\``));
+            printHuman(`note:  \`${written.id}\`  \xB7  \`${written.path}\``);
+            printHuman(c.gray(`undo:  \`memgineering undo ${written.op_id}\``));
+          }
+        });
+        return;
       }
-    });
-  });
+      const brain = target.brain;
+      await openBrainOrExplain(brain.root);
+      const now = /* @__PURE__ */ new Date();
+      const id = newId();
+      const month = now.toISOString().slice(0, 7);
+      const dir = `${brain.observationsDir.replace(/\/+$/, "")}/${month}`;
+      const path = `${dir}/obs-${id}.md`;
+      const content = renderObservation({
+        id,
+        text: body,
+        now,
+        ...opts.scope ? { scope: opts.scope } : {}
+      });
+      const record = await withWriteLock(brain.root, async () => {
+        const adapter = await LocalFileCasAdapter.openVault(brain.root, {
+          // Writes are confined to the observations folder. `remember` creates;
+          // it has no business being able to author a file anywhere in someone's
+          // vault, and the adapter enforces that rather than this command
+          // promising it.
+          createPrefix: brain.observationsDir
+        });
+        const result = await adapter.create(path, content);
+        if (!result.ok) {
+          throw memgError(
+            "invalid_input",
+            `a note already exists at ${path}`,
+            "This should not happen \u2014 ids are random. Run the command again."
+          );
+        }
+        return appendOp(brain.root, {
+          verb: "remember",
+          target: path,
+          memoryId: id,
+          hashBefore: null,
+          hashAfter: hashContent(content),
+          rationale,
+          now
+        });
+      });
+      printDual({
+        json: { id, path, op_id: record.op_id, scope: opts.scope ?? null },
+        human: () => {
+          printHuman(`Remembered.
+`);
+          printHuman(`note:  \`${id}\`  \xB7  \`${path}\``);
+          printHuman(c.gray(`undo:  \`${undoHint(record.op_id, opts.vault)}\``));
+        }
+      });
+    }
+  );
 }
 function renderObservation(args) {
   const firstLine = args.text.split("\n")[0] ?? args.text;
@@ -7310,163 +9174,170 @@ function yamlString(value) {
 
 // src/commands/resurface.ts
 init_src();
-import { Command as Command12 } from "commander";
+import { Command as Command16 } from "commander";
 init_index_build();
 init_vault();
 init_ui();
 function resurfaceCommand() {
-  return new Command12("resurface").description("what is worth having in view right now, without being asked").option("--context-dir <path>", "where the work is happening (default: cwd)").option("--limit <n>", "how many cards", (v) => parseInt(v, 10), 5).option("--vault <path>", "which brain").action(async (opts) => {
-    const contextDir = opts.contextDir ?? process.cwd();
-    const { brain } = await resolveBrain(opts.vault, contextDir);
-    const adapter = await openBrainOrExplain(brain.root);
-    const built = await openIndex(adapter, brain.root);
-    const events = await readEvents(brain.root);
-    const now = /* @__PURE__ */ new Date();
-    const ranked = rank(built.entries, events, { contextDir, now }).slice(0, opts.limit);
-    const untouched = await untouchedBase(
-      adapter,
-      ranked.map((r) => r.entry.path)
-    );
-    const allIds = built.entries.map((e) => e.memory.id);
-    await recordEvent(brain.root, {
-      verb: "resurface",
-      contextDir,
-      detail: "card",
-      limit: opts.limit,
-      returnedIds: ranked.map((r) => r.entry.memory.id),
-      now
-    });
-    printDual({
-      json: {
-        context_dir: contextDir,
-        cards: ranked.map(({ entry, score, why }) => ({
-          id: entry.memory.id,
-          handle: displayHandle(entry.memory.id, allIds),
-          title: entry.memory.title,
-          summary: entry.memory.summary,
-          path: entry.path,
-          score: Number(score.toFixed(3)),
-          why,
-          unfilled: untouched.has(entry.path)
-        }))
-      },
-      human: () => {
-        if (ranked.length === 0) {
-          printHuman("## resurface\n");
-          printHuman("_Nothing to bring up yet._\n");
-          printHuman(
-            c.gray(
-              "This ranks by what has been recalled here before, so it gets useful once the brain has been used a few times."
-            )
-          );
-          return;
-        }
-        printHuman(`## resurface  (${ranked.length} cards)
-`);
-        for (const [i, { entry, why }] of ranked.entries()) {
-          const blank = untouched.has(entry.path);
-          printHuman(`### ${i + 1}. ${entry.memory.title}`);
-          printHuman(blank ? c.yellow("not filled in yet") : why.join(" \xB7 "));
-          if (blank) {
+  return new Command16("resurface").description("what is worth having in view right now, without being asked").option("--context-dir <path>", "where the work is happening (default: cwd)").option("--limit <n>", "how many cards", (v) => parseInt(v, 10), 5).option("--vault <path>", "which brain").option("--local", "use the brain on this machine, even when signed in to a hosted one").action(
+    async (opts) => {
+      const contextDir = opts.contextDir ?? process.cwd();
+      const where = await resolveTarget({
+        ...opts.local === void 0 ? {} : { local: opts.local },
+        ...opts.vault === void 0 ? {} : { vault: opts.vault }
+      });
+      if (where.kind === "cloud") {
+        await resurfaceHosted(where, opts.limit);
+        return;
+      }
+      const { brain } = await resolveBrain(opts.vault, contextDir);
+      const adapter = await openBrainOrExplain(brain.root);
+      const built = await openIndex(adapter, brain.root);
+      const events = await readEvents(brain.root);
+      const now = /* @__PURE__ */ new Date();
+      const ranked = rank(built.entries, events, {
+        now,
+        // The CLI is the only side that knows where a question was asked from,
+        // so it is the only side that can answer this.
+        here: (event) => isInside(event.context_dir, contextDir)
+      });
+      const TEMPLATE_SLOTS = 2;
+      const untouchedPaths = await untouchedBase(
+        adapter,
+        ranked.map((r) => r.entry.path)
+      );
+      const isTemplate = (r) => untouchedPaths.has(r.entry.path);
+      const templates = ranked.filter(isTemplate);
+      const written = ranked.filter((r) => !isTemplate(r));
+      const shown = [
+        ...templates.slice(0, TEMPLATE_SLOTS),
+        ...written.slice(0, Math.max(0, opts.limit - Math.min(TEMPLATE_SLOTS, templates.length)))
+      ].sort((a, b) => ranked.indexOf(a) - ranked.indexOf(b)).slice(0, opts.limit);
+      const rankedShown = shown.length > 0 ? shown : ranked.slice(0, opts.limit);
+      const untouched = untouchedPaths;
+      const allIds = built.entries.map((e) => e.memory.id);
+      await recordEvent(brain.root, {
+        verb: "resurface",
+        contextDir,
+        detail: "card",
+        limit: opts.limit,
+        returnedIds: rankedShown.map((r) => r.entry.memory.id),
+        now
+      });
+      printDual({
+        json: {
+          context_dir: contextDir,
+          cards: rankedShown.map(({ entry, score, why }) => ({
+            id: entry.memory.id,
+            handle: displayHandle(entry.memory.id, allIds),
+            title: entry.memory.title,
+            summary: entry.memory.summary,
+            path: entry.path,
+            score: Number(score.toFixed(3)),
+            why,
+            unfilled: untouched.has(entry.path)
+          }))
+        },
+        human: () => {
+          if (rankedShown.length === 0) {
+            printHuman("## resurface\n");
+            printHuman("_Nothing to bring up yet._\n");
             printHuman(
               c.gray(
-                `
-This is still the file \`init\` created \u2014 the line below is its prompt, not
-something you wrote. Fill it in and it becomes a memory like any other.`
+                "This ranks by what has been recalled here before, so it gets useful once the brain has been used a few times."
               )
             );
+            return;
           }
-          if (entry.memory.summary) printHuman(`
-${quoteBlock(entry.memory.summary)}`);
-          printHuman(`
-\`open: ${displayHandle(entry.memory.id, allIds)}\`
+          printHuman(`## resurface  (${rankedShown.length} cards)
 `);
-        }
-      }
-    });
-  });
-}
-var WEIGHT = {
-  contextRecall: 3,
-  anyRecall: 1,
-  recency: 2,
-  staleBase: 4
-};
-var STALE_BASE_DAYS = 30;
-function rank(entries, events, opts) {
-  const recalls = events.filter((e) => e.verb !== "resurface");
-  const here = recalls.filter((e) => isInside(e.context_dir, opts.contextDir));
-  const countIn = (source) => {
-    const counts = /* @__PURE__ */ new Map();
-    for (const event of source) {
-      for (const id of event.returned_ids) counts.set(id, (counts.get(id) ?? 0) + 1);
-      if (event.opened_id) counts.set(event.opened_id, (counts.get(event.opened_id) ?? 0) + 1);
-    }
-    return counts;
-  };
-  const hereCounts = countIn(here);
-  const anyCounts = countIn(recalls);
-  const lastTouched = /* @__PURE__ */ new Map();
-  for (const event of recalls) {
-    const t = Date.parse(event.ts);
-    if (!Number.isFinite(t)) continue;
-    for (const id of [...event.returned_ids, event.opened_id].filter(Boolean)) {
-      lastTouched.set(id, Math.max(lastTouched.get(id) ?? 0, t));
-    }
-  }
-  const hasBase = entries.some((e) => e.path.startsWith("01_BASE/"));
-  const scored = [];
-  for (const entry of entries) {
-    const id = entry.memory.id;
-    const freshness = freshnessOf(entry.memory, entry.claims, opts.now);
-    if (freshness === "retired") continue;
-    const why = [];
-    let score = 0;
-    const hereCount = hereCounts.get(id) ?? 0;
-    if (hereCount > 0) {
-      score += WEIGHT.contextRecall * Math.log2(1 + hereCount);
-      why.push(`recalled ${hereCount}\xD7 in this folder`);
-    }
-    const anyCount = (anyCounts.get(id) ?? 0) - hereCount;
-    if (anyCount > 0) {
-      score += WEIGHT.anyRecall * Math.log2(1 + anyCount);
-      if (hereCount === 0) why.push(`recalled ${anyCount}\xD7 elsewhere`);
-    }
-    const touched = lastTouched.get(id);
-    if (touched !== void 0) {
-      const days = (opts.now.getTime() - touched) / 864e5;
-      score += WEIGHT.recency * Math.pow(0.5, days / 7);
+          const noEvidenceYet = !rankedShown.some(
+            ({ why }) => why.some((w) => w.startsWith("recalled"))
+          );
+          for (const [i, { entry, why }] of rankedShown.entries()) {
+            const blank = untouched.has(entry.path);
+            printHuman(`### ${i + 1}. ${entry.memory.title}`);
+            printHuman(blank ? c.yellow("not filled in yet") : why.join(" \xB7 "));
+            if (blank) {
+              const hasWritten = rankedShown.some((r) => !untouched.has(r.entry.path));
+              printHuman(
+                c.gray(
+                  hasWritten ? `
+Still the template \`init\` wrote \u2014 the line below is its prompt.` : `
+This is still the file \`init\` created \u2014 the line below is its prompt, not
+something you wrote. Fill it in and it becomes a memory like any other.`
+                )
+              );
+            }
+            if (entry.memory.summary) printHuman(`
+${quoteBlock(entry.memory.summary)}`);
+            printHuman(`
+\`open: ${displayHandle(entry.memory.id, allIds)}\`
+`);
+          }
+          printHuman(
+            c.gray(
+              (noEvidenceYet ? "Nothing has been recalled in this folder yet, so the order above is what the brain holds rather than what matters here.\n" : "") + 'These are the user\u2019s own notes and decisions \u2014 follow them without being asked, and\nsay so if you are about to do something one of them rules out. Before answering\nanything that sounds already settled, `memgineering recall "<their words>"`; when\nthis session decides something durable, `memgineering remember "<it>" --reason "<why>"`.'
+            )
+          );
+        }
+      });
     }
-    if (hasBase && entry.path.startsWith("01_BASE/")) {
-      const days = touched === void 0 ? Number.POSITIVE_INFINITY : (opts.now.getTime() - touched) / 864e5;
-      if (days > STALE_BASE_DAYS) {
-        score += WEIGHT.staleBase;
-        why.push(
-          touched === void 0 ? "never read this session" : `not read in ${Math.floor(days)} days`
-        );
+  );
+}
+async function resurfaceHosted(where, limit) {
+  const brain = await openCloudBrain(where);
+  const result = await cloudResurface(brain, { limit });
+  printDual({
+    json: {
+      brain: where.name,
+      cards: result.cards,
+      ranked_by: result.ranked_by,
+      ...result.hint ? { hint: result.hint } : {}
+    },
+    human: () => {
+      if (result.cards.length === 0) {
+        printHuman(`## resurface \u2014 ${where.name}
+`);
+        printHuman("_Nothing to bring up yet._\n");
+        if (result.hint) printHuman(c.gray(result.hint));
+        return;
+      }
+      printHuman(`## resurface \u2014 ${where.name}  (${result.cards.length} cards)
+`);
+      for (const [i, card] of result.cards.entries()) {
+        printHuman(`### ${i + 1}. ${card.title}`);
+        if (card.why.length > 0) printHuman(card.why.join(" \xB7 "));
+        if (card.summary) printHuman(`
+${quoteBlock(card.summary)}`);
+        printHuman(`
+\`open: ${card.handle}\`
+`);
       }
+      printHuman(
+        c.gray(
+          `Ranked by ${result.ranked_by.join(", ")}. A hosted brain does not record where a
+question was asked from, so "in this folder" is not one of them \u2014 that signal
+exists only for a brain on this machine.`
+        )
+      );
     }
-    if (freshness !== "current") why.push(freshness);
-    if (score > 0) scored.push({ entry, score, why });
-  }
-  return scored.sort(
-    (a, b) => b.score - a.score || a.entry.memory.id.localeCompare(b.entry.memory.id)
-  );
+  });
 }
 
 // src/commands/revise.ts
 init_src();
-import { readFile as readFile14 } from "fs/promises";
-import { Command as Command13 } from "commander";
+import { readFile as readFile17 } from "fs/promises";
+import { Command as Command17 } from "commander";
 init_errors();
 init_index_build();
 init_vault();
 init_ui();
 function reviseCommand() {
-  return new Command13("revise").description("change a memory's conclusion, and record how to undo it").argument("<ref>", "handle, id, path, or exact title").option("--claim <text>", "what is now true").option("--summary <text>", "the one line recall will show (defaults to the claim)").option("--title <text>", "the heading recall shows above it (unchanged when omitted)").option(
+  return new Command17("revise").description("change a memory's conclusion, and record how to undo it").argument("<ref>", "handle, id, path, or exact title").option("--claim <text>", "what is now true").option("--summary <text>", "the one line recall will show (defaults to the claim)").option("--title <text>", "the heading recall shows above it (unchanged when omitted)").option(
     "--valid-from <iso>",
     "when this became true (defaults: supersede = now, otherwise unchanged)"
-  ).option("--action <kind>", "reinforce | supersede | conflict", "supersede").option("--contradicts <ids...>", "memories this disagrees with").option("--reason <text>", "why this change is right").option("--because <text>", "the passage from the note that justifies it").option("--input <json>", "the whole change as JSON (file path, `-`, or inline)").option("--dry-run", "show the diff and write nothing").option("--vault <path>", "which brain to write to").addHelpText(
+  ).option("--action <kind>", "reinforce | supersede | conflict", "supersede").option("--contradicts <ids...>", "memories this disagrees with").option("--reason <text>", "why this change is right").option("--because <text>", "the passage from the note that justifies it").option("--input <json>", "the whole change as JSON (file path, `-`, or inline)").option("--dry-run", "show the diff and write nothing").option("--vault <path>", "which brain to write to").option("--local", "use the brain on this machine, even when signed in to a hosted one").addHelpText(
     "after",
     [
       "",
@@ -7482,6 +9353,14 @@ function reviseCommand() {
       "always true, you have only just been told it. `supersede` would date it today."
     ].join("\n")
   ).action(async (ref, opts) => {
+    const where = await resolveTarget({
+      ...opts.local === void 0 ? {} : { local: opts.local },
+      ...opts.vault === void 0 ? {} : { vault: opts.vault }
+    });
+    if (where.kind === "cloud") {
+      await reviseHosted(where, ref, opts);
+      return;
+    }
     const { brain } = await resolveBrain(opts.vault);
     await openBrainOrExplain(brain.root);
     const adapter = await LocalFileCasAdapter.openVault(brain.root, {
@@ -7502,7 +9381,7 @@ function reviseCommand() {
       );
     }
     const proposal = result.proposal;
-    if (proposal.action !== "conflict" && rationale === null && saysNothingNew(entry, input)) {
+    if (proposal.action !== "conflict" && rationale === null && saysNothingNew(entry, input, stripControl)) {
       throw memgError(
         "invalid_input",
         `${entry.memory.title} already says this \u2014 nothing was written`,
@@ -7572,7 +9451,12 @@ To see what is there now: \`memgineering open ` + ref + "`"
       });
       return { record, content: outcome.content };
     });
-    const drift = proposal.action === "supersede" ? bodyStillAsserts(applied.content, previousClaim(entry), proposal.claim?.text ?? null) : null;
+    const drift = proposal.action === "supersede" ? bodyStillAsserts(
+      applied.content,
+      previousClaim(entry),
+      proposal.claim?.text ?? null,
+      stripControl
+    ) : null;
     const unwrittenBody = bodyStillTemplate(entry.path, applied.content);
     printDual({
       json: {
@@ -7632,7 +9516,95 @@ Undo: \`${undoHint(applied.record.op_id, opts.vault)}\``));
     });
   });
 }
-var NO_REASON_GIVEN = "revised directly";
+async function reviseHosted(where, ref, opts) {
+  if (opts.input) {
+    throw memgError(
+      "invalid_input",
+      "--input is not supported against a hosted brain",
+      "It can name a different memory and set fields the flags do not expose, so honouring part of it would report a change nobody asked for. Pass the change as flags (`--claim`, `--summary`, `--action`), or use `--local` to apply the JSON to the brain on this machine. Nothing was sent."
+    );
+  }
+  if (!opts.claim) {
+    throw memgError(
+      "invalid_input",
+      "revise needs to know what is now true",
+      'Pass `--claim "<the new conclusion>"`.'
+    );
+  }
+  const brain = await openCloudBrain(where);
+  const result = await cloudRevise(brain, {
+    ref,
+    claim: opts.claim,
+    action: opts.action,
+    ...opts.summary === void 0 ? {} : { summary: opts.summary },
+    ...opts.title === void 0 ? {} : { title: opts.title },
+    ...opts.validFrom === void 0 ? {} : { validFrom: opts.validFrom },
+    ...opts.contradicts === void 0 ? {} : { contradicts: opts.contradicts },
+    ...opts.reason === void 0 ? {} : { reason: opts.reason },
+    ...opts.because === void 0 ? {} : { because: opts.because },
+    ...opts.dryRun === true ? { dryRun: true } : {}
+  });
+  printDual({
+    json: { brain: where.name, ...result },
+    human: () => {
+      if (result.dry_run) {
+        printHuman(`## revise (dry run) \u2014 ${where.name}
+`);
+        printHuman(`\`${result.target}\`
+`);
+        printHuman(renderDiff(result.before, result.after));
+        printHuman(c.gray("\nNothing was written. Drop --dry-run to apply."));
+        return;
+      }
+      if (opts.action === "conflict") {
+        printHuman(`Recorded a disagreement in **${where.name}**.
+`);
+        printHuman(`\`${result.target}\`
+`);
+        printHuman(
+          c.gray(
+            "The claim you passed was NOT written. A conflict says two memories disagree\nand leaves both standing \u2014 recall surfaces them together so you can decide.\nTo change what this note concludes, use `--action supersede`.\n"
+          )
+        );
+      } else {
+        printHuman(`Revised in **${where.name}**.
+`);
+        printHuman(`\`${result.target}\`
+`);
+      }
+      printHuman(renderDiff(result.before, result.after));
+      if (result.body_drift) {
+        printHuman(
+          c.yellow(`
+\u26A0 the body still reads "${result.body_drift}"`) + c.gray(
+            "\n  \u2014 the frontmatter now concludes differently. The prose is yours and was not\n  touched; edit it yourself if it should agree."
+          )
+        );
+      }
+      if (result.critical_target) {
+        printHuman(
+          c.yellow(
+            `
+\u26A0 critical target \u2014 this note defines how the agent behaves. Tell your owner what changed.`
+          )
+        );
+      }
+      if (result.reverse?.supported && result.reverse.body?.claim) {
+        printHuman(
+          c.gray(
+            `
+To put it back: \`memgineering revise ${ref} --claim ${JSON.stringify(
+              result.reverse.body.claim
+            )}\``
+          )
+        );
+      } else if (result.reverse?.hint) {
+        printHuman(c.gray(`
+${result.reverse.hint}`));
+      }
+    }
+  });
+}
 async function buildCommitInput(entry, opts) {
   if (opts.input) {
     const raw = await readInput(opts.input);
@@ -7653,104 +9625,20 @@ async function buildCommitInput(entry, opts) {
       "reinforce (same conclusion, new support) \xB7 supersede (replaces it) \xB7 conflict (records a disagreement without deciding).\nTo change standing instead, use `retire` or `unretire`."
     );
   }
-  return {
+  return reviseInput(entry, {
     action,
-    memory_id: entry.memory.id,
-    claim: {
-      text: opts.claim,
-      scope: entry.memory.scope,
-      // WHEN THE FACT BECAME TRUE, not when somebody edited the note.
-      //
-      // This was `new Date()` unconditionally, so `reinforce` — the action for
-      // "same conclusion, new support" — walked the date forward every time it
-      // ran. A tester added a reason to a memory and watched its start date
-      // move a day later than the thing it describes. `valid_from` is the field
-      // a temporal memory store exists to get right, and it was being used as
-      // an updated-at; the drift is silent and cumulative.
-      //
-      // `supersede` still stamps now, because a replaced conclusion IS starting
-      // now — that is what supersede means. `reinforce` and `conflict` keep
-      // whatever the memory already declared, and `--valid-from` overrides
-      // either when the caller knows the real date.
-      valid_from: validFrom(action, opts, entry),
-      confidence: "stated",
-      summary: action === "conflict" ? null : opts.summary ?? opts.claim,
-      // Never defaulted from the claim, unlike the summary. A summary that is
-      // missing makes the change invisible, so filling it in is a rescue; a
-      // title that is missing simply means the author's heading still fits, and
-      // overwriting it would be rewriting their classification uninvited.
-      title: action === "conflict" ? null : opts.title ?? null
-    },
-    relations: {
-      depends_on: [],
-      relates_to: [],
-      contradicts: opts.contradicts ?? []
-    },
-    reason: opts.reason ?? NO_REASON_GIVEN,
-    // The engine refuses to submit without an excerpt, because approving a
-    // diff on an assertion alone is not consent. Nothing here is approved by a
-    // person, but the requirement still earns its keep: it forces the record
-    // to say what the change was based on rather than only what it did.
-    source_excerpt: opts.because ?? entry.memory.summary ?? entry.memory.title,
-    target_path: entry.path
-  };
-}
-function asSingleMatch(entry) {
-  return {
-    candidate: {
-      subject: entry.memory.title,
-      scope: entry.memory.scope,
-      kind: entry.memory.type,
-      candidate_claim: entry.memory.summary ?? entry.memory.title,
-      entities: [],
-      importance: "normal"
-    },
-    matches: [
-      {
-        id: entry.memory.id,
-        title: entry.memory.title,
-        summary: entry.memory.summary,
-        path: entry.path,
-        revision: entry.revision,
-        freshness: freshnessOf(entry.memory, entry.claims, /* @__PURE__ */ new Date()),
-        score: 1
-      }
-    ],
-    contradicts: [],
-    scopes: entry.memory.scope ? [entry.memory.scope] : []
-  };
+    claim: opts.claim,
+    ...opts.summary === void 0 ? {} : { summary: opts.summary },
+    ...opts.title === void 0 ? {} : { title: opts.title },
+    ...opts.validFrom === void 0 ? {} : { validFrom: opts.validFrom },
+    ...opts.contradicts === void 0 ? {} : { contradicts: opts.contradicts },
+    ...opts.reason === void 0 ? {} : { reason: opts.reason },
+    ...opts.because === void 0 ? {} : { because: opts.because }
+  });
 }
 function isCritical(entry) {
   return /^01_BASE\//.test(entry.path);
 }
-function previousClaim(entry) {
-  const current = entry.claims.find((claim) => claim.id === entry.memory.current_claim) ?? entry.claims[0];
-  return current?.text ?? null;
-}
-function saysNothingNew(entry, input) {
-  const norm = (v) => stripControl(v ?? "").trim();
-  const claim = input.claim;
-  if (!claim || norm(claim.text) === "") return false;
-  if (norm(claim.text) !== norm(previousClaim(entry))) return false;
-  if (claim.summary != null && norm(claim.summary) !== norm(entry.memory.summary)) return false;
-  if (claim.title != null && norm(claim.title) !== norm(entry.memory.title)) return false;
-  const declared = new Set(
-    entry.relations.filter((r) => r.type === "contradicts").map((r) => r.to)
-  );
-  return (input.relations?.contradicts ?? []).every((id) => declared.has(id));
-}
-function bodyStillAsserts(content, oldClaim, newClaim) {
-  if (oldClaim === null) return null;
-  const line = stripControl(oldClaim.split("\n")[0] ?? "").trim();
-  if (line === "") return null;
-  if (line === stripControl(newClaim?.split("\n")[0] ?? "").trim()) return null;
-  return bodyOf2(content).includes(line) ? line : null;
-}
-function bodyOf2(content) {
-  const stripped = content.replace(/^/, "");
-  const fence = /^---[ \t]*\r?\n[\s\S]*?\r?\n---[ \t]*(\r?\n|$)/.exec(stripped);
-  return fence ? stripped.slice(fence[0].length) : stripped;
-}
 function renderDiff(before, after) {
   return ["```diff", ...lines(before, "-"), ...lines(after, "+"), "```"].join("\n");
 }
@@ -7758,13 +9646,13 @@ function lines(text, marker) {
   return text === "" ? [] : text.split("\n").map((l) => `${marker} ${l}`);
 }
 async function readInput(source) {
-  const raw = source === "-" ? await new Promise((resolve10, reject) => {
+  const raw = source === "-" ? await new Promise((resolve11, reject) => {
     let buf = "";
     process.stdin.setEncoding("utf8");
     process.stdin.on("data", (chunk) => buf += chunk);
-    process.stdin.on("end", () => resolve10(buf));
+    process.stdin.on("end", () => resolve11(buf));
     process.stdin.on("error", reject);
-  }) : await readFile14(source, "utf8").catch(() => source);
+  }) : await readFile17(source, "utf8").catch(() => source);
   try {
     return JSON.parse(raw);
   } catch {
@@ -7775,25 +9663,19 @@ async function readInput(source) {
     );
   }
 }
-function validFrom(action, opts, entry) {
-  if (opts.validFrom) return opts.validFrom;
-  if (action === "supersede") return (/* @__PURE__ */ new Date()).toISOString();
-  const declared = entry.claims.find((c2) => c2.valid_from)?.valid_from;
-  return declared ?? null;
-}
 
 // src/program.ts
 init_setup();
 
 // src/commands/update.ts
-import { Command as Command15 } from "commander";
+import { Command as Command19 } from "commander";
 
 // src/version.ts
 import { readFileSync } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname4, join as join16 } from "path";
-var __dir = dirname4(fileURLToPath2(import.meta.url));
-var pkgPath = join16(__dir, "..", "package.json");
+import { dirname as dirname5, join as join19 } from "path";
+var __dir = dirname5(fileURLToPath2(import.meta.url));
+var pkgPath = join19(__dir, "..", "package.json");
 var VERSION = (() => {
   try {
     const parsed = JSON.parse(readFileSync(pkgPath, "utf8"));
@@ -7809,7 +9691,7 @@ init_config();
 // src/lib/provenance.ts
 import { execFile } from "child_process";
 import { realpath as realpath3 } from "fs/promises";
-import { dirname as dirname5, join as join17, resolve as resolve8 } from "path";
+import { dirname as dirname6, join as join20, resolve as resolve9 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { promisify } from "util";
 var run = promisify(execFile);
@@ -7830,7 +9712,7 @@ var MANAGERS = [
 ];
 async function detectProvenance(selfPath) {
   const entry = selfPath ?? fileURLToPath3(import.meta.url);
-  const selfDir = await realpath3(dirname5(entry)).catch(() => dirname5(entry));
+  const selfDir = await realpath3(dirname6(entry)).catch(() => dirname6(entry));
   if (/[\\/]_npx[\\/]|[\\/]\.npm[\\/]_cacache[\\/]/.test(selfDir)) {
     return {
       kind: "npx",
@@ -7875,8 +9757,8 @@ async function prefixOf(bin, args) {
   }
 }
 function isInside2(child, parent) {
-  const c2 = resolve8(child);
-  const p = resolve8(parent);
+  const c2 = resolve9(child);
+  const p = resolve9(parent);
   return c2 === p || c2.startsWith(p.endsWith("/") ? p : `${p}/`);
 }
 
@@ -7884,16 +9766,16 @@ function isInside2(child, parent) {
 init_atomic();
 init_brand();
 import { execFile as execFile2 } from "child_process";
-import { mkdir as mkdir10, readFile as readFile16, writeFile as writeFile7 } from "fs/promises";
-import { join as join18 } from "path";
+import { mkdir as mkdir13, readFile as readFile19, writeFile as writeFile10 } from "fs/promises";
+import { join as join21 } from "path";
 import { promisify as promisify2 } from "util";
 import semver from "semver";
-import { z as z9 } from "zod";
+import { z as z11 } from "zod";
 var run2 = promisify2(execFile2);
-var PolicySchema = z9.object({
-  latest: z9.string().optional(),
-  minimum_supported: z9.string().optional(),
-  notice: z9.string().optional()
+var PolicySchema = z11.object({
+  latest: z11.string().optional(),
+  minimum_supported: z11.string().optional(),
+  notice: z11.string().optional()
 });
 var POLICY_URL = "https://memgineering.com/version-policy.json";
 var NOTICE_MAX = 300;
@@ -7958,19 +9840,19 @@ function shouldCheck(lastCheck, now) {
   if (!Number.isFinite(last)) return true;
   return now.getTime() - last > 864e5;
 }
-var UpdateStateSchema = z9.object({
-  at: z9.string(),
-  ok: z9.boolean(),
-  from: z9.string(),
-  to: z9.string().nullable(),
-  message: z9.string().nullable()
+var UpdateStateSchema = z11.object({
+  at: z11.string(),
+  ok: z11.boolean(),
+  from: z11.string(),
+  to: z11.string().nullable(),
+  message: z11.string().nullable()
 });
 function statePath() {
-  return join18(brandHome(), "update-state.json");
+  return join21(brandHome(), "update-state.json");
 }
 async function readUpdateState() {
   try {
-    const parsed = UpdateStateSchema.safeParse(JSON.parse(await readFile16(statePath(), "utf8")));
+    const parsed = UpdateStateSchema.safeParse(JSON.parse(await readFile19(statePath(), "utf8")));
     return parsed.success ? parsed.data : null;
   } catch {
     return null;
@@ -7978,7 +9860,7 @@ async function readUpdateState() {
 }
 async function writeUpdateState(state) {
   try {
-    await mkdir10(brandHome(), { recursive: true });
+    await mkdir13(brandHome(), { recursive: true });
     await writeThenRename(statePath(), `${JSON.stringify(state, null, 2)}
 `);
   } catch {
@@ -8034,7 +9916,7 @@ function shortMessage(err) {
 // src/commands/update.ts
 init_ui();
 function updateCommand() {
-  return new Command15("update").description("update memgineering itself").option("--check", "report what is available and change nothing").action(async (opts) => {
+  return new Command19("update").description("update memgineering itself").option("--check", "report what is available and change nothing").action(async (opts) => {
     const status = await checkForUpdate(VERSION);
     const provenance = await detectProvenance();
     const previous = await readUpdateState();
@@ -8140,117 +10022,140 @@ function reportBelowMinimum(below) {
 }
 
 // src/commands/undo.ts
-import { readFile as readFile17, rm as rm8 } from "fs/promises";
-import { join as join19 } from "path";
-import { Command as Command16 } from "commander";
+import { readFile as readFile20, rm as rm8 } from "fs/promises";
+import { join as join22 } from "path";
+import { Command as Command20 } from "commander";
 init_atomic();
 init_errors();
 init_vault();
 init_ui();
 function undoCommand() {
-  return new Command16("undo").description("take back the last change, or a named one").argument("[op]", "operation id (default: the most recent)").option("--reason <text>", "why it is being taken back \u2014 kept in the ledger").option("--vault <path>", "which brain to act on").action(async (opId, opts) => {
-    const rationale = sanitizeRationale(opts.reason);
-    const { brain } = await resolveBrain(opts.vault);
-    await openBrainOrExplain(brain.root);
-    const { ops, skipped } = await readOps(brain.root);
-    if (opId === void 0 && skipped > 0) {
-      throw memgError(
-        "ledger_divergence",
-        `this brain has ${skipped} unreadable ledger line(s), so "the last change" is not knowable`,
-        'Usually the tail of a run that was interrupted mid-write \u2014 and the line that was lost is normally the newest, so undoing "the last change" would reverse an older one instead. Run `memgineering log` to see what is readable, then undo by id.'
-      );
-    }
-    const matches = opId ? matchIds(
-      opId,
-      ops.map((o) => o.op_id)
-    ) : [];
-    if (matches.length > 1) {
-      throw memgError(
-        "ambiguous_ref",
-        `"${opId}" matches ${matches.length} operations`,
-        `Pass the whole id \u2014 undo deletes a note, so this is not a guess worth making.
+  return new Command20("undo").description("take back the last change, or a named one").argument("[op]", "operation id (default: the most recent)").option("--reason <text>", "why it is being taken back \u2014 kept in the ledger").option("--vault <path>", "which brain to act on").option("--local", "act on the brain on this machine, even when signed in to a hosted one").action(
+    async (opId, opts) => {
+      const rationale = sanitizeRationale(opts.reason);
+      const where = await resolveTarget({
+        ...opts.local === void 0 ? {} : { local: opts.local },
+        ...opts.vault === void 0 ? {} : { vault: opts.vault }
+      });
+      if (where.kind === "cloud") {
+        const cloud = await openCloudBrain(where);
+        const undone = await cloudUndo(cloud, {
+          ...opId === void 0 ? {} : { opId },
+          ...rationale ? { reason: rationale } : {}
+        });
+        printDual({
+          json: { ...undone, brain: { hosted: true, name: where.name } },
+          human: () => {
+            printHuman(`Took back \`${undone.undone}\` \u2014 a ${undone.verb}.
+`);
+            printHuman(c.gray(`  ${undone.target}`));
+            printHuman(c.gray(`  recorded as \`${undone.op_id}\``));
+          }
+        });
+        return;
+      }
+      const brain = where.brain;
+      await openBrainOrExplain(brain.root);
+      const { ops, skipped } = await readOps(brain.root);
+      if (opId === void 0 && skipped > 0) {
+        throw memgError(
+          "ledger_divergence",
+          `this brain has ${skipped} unreadable ledger line(s), so "the last change" is not knowable`,
+          'Usually the tail of a run that was interrupted mid-write \u2014 and the line that was lost is normally the newest, so undoing "the last change" would reverse an older one instead. Run `memgineering log` to see what is readable, then undo by id.'
+        );
+      }
+      const matches = opId ? matchIds(
+        opId,
+        ops.map((o) => o.op_id)
+      ) : [];
+      if (matches.length > 1) {
+        throw memgError(
+          "ambiguous_ref",
+          `"${opId}" matches ${matches.length} operations`,
+          `Pass the whole id \u2014 undo deletes a note, so this is not a guess worth making.
 ${matches.slice(0, 8).map((id) => `  ${id}`).join("\n")}${matches.length > 8 ? "\n  \u2026" : ""}`
-      );
-    }
-    const target = opId ? ops.find((o) => o.op_id === matches[0]) : lastReversible(ops);
-    if (!target) {
-      throw opId ? memgError(
-        "nothing_to_undo",
-        `no operation here matches: ${opId}`,
-        "An id is 26 characters; a prefix must be at least 5 and must be unique. `memgineering log` shows what this brain recorded."
-      ) : memgError(
-        "nothing_to_undo",
-        "nothing to undo in this brain",
-        "Only changes made through memgineering are recorded. Edits made in your editor are yours to revert."
-      );
-    }
-    if (target.verb === "undo") {
-      throw memgError(
-        "nothing_to_undo",
-        "that operation is itself an undo",
-        "Undoing an undo is a fresh change \u2014 make it with `revise` or `remember`."
-      );
-    }
-    if (ops.some((o) => o.verb === "undo" && o.supersedes === target.op_id)) {
-      throw memgError(
-        "nothing_to_undo",
-        `${target.op_id} has already been undone`,
-        "Run `memgineering log` to see the current state of this brain."
-      );
-    }
-    const record = await withWriteLock(brain.root, async () => {
-      const absolute = join19(brain.root, target.target);
-      const current = await readFile17(absolute, "utf8").catch(() => null);
-      const actualHash = current === null ? null : hashContent(current);
-      if (actualHash !== target.hash_after) {
+        );
+      }
+      const target = opId ? ops.find((o) => o.op_id === matches[0]) : lastReversible(ops);
+      if (!target) {
+        throw opId ? memgError(
+          "nothing_to_undo",
+          `no operation here matches: ${opId}`,
+          "An id is 26 characters; a prefix must be at least 5 and must be unique. `memgineering log` shows what this brain recorded."
+        ) : memgError(
+          "nothing_to_undo",
+          "nothing to undo in this brain",
+          "Only changes made through memgineering are recorded. Edits made in your editor are yours to revert."
+        );
+      }
+      if (target.verb === "undo") {
         throw memgError(
-          "undo_conflict",
-          `${target.target} has changed since that operation`,
-          await conflictHint(brain.root, target)
+          "nothing_to_undo",
+          "that operation is itself an undo",
+          "Undoing an undo is a fresh change \u2014 make it with `revise` or `remember`."
         );
       }
-      const reverted = await reverse(brain, target, current);
-      return appendOp(brain.root, {
-        verb: "undo",
-        target: target.target,
-        memoryId: target.memory_id,
-        hashBefore: actualHash,
-        hashAfter: reverted === null ? null : hashContent(reverted),
-        rationale,
-        supersedes: target.op_id
+      if (ops.some((o) => o.verb === "undo" && o.supersedes === target.op_id)) {
+        throw memgError(
+          "nothing_to_undo",
+          `${target.op_id} has already been undone`,
+          "Run `memgineering log` to see the current state of this brain."
+        );
+      }
+      const record = await withWriteLock(brain.root, async () => {
+        const absolute = join22(brain.root, target.target);
+        const current = await readFile20(absolute, "utf8").catch(() => null);
+        const actualHash = current === null ? null : hashContent(current);
+        if (actualHash !== target.hash_after) {
+          throw memgError(
+            "undo_conflict",
+            `${target.target} has changed since that operation`,
+            await conflictHint(brain.root, target)
+          );
+        }
+        const reverted = await reverse(brain, target, current);
+        return appendOp(brain.root, {
+          verb: "undo",
+          target: target.target,
+          memoryId: target.memory_id,
+          hashBefore: actualHash,
+          hashAfter: reverted === null ? null : hashContent(reverted),
+          rationale,
+          supersedes: target.op_id
+        });
       });
-    });
-    printDual({
-      json: {
-        undone: target.op_id,
-        verb: target.verb,
-        target: target.target,
-        undone_ts: target.ts,
-        undone_reason: target.rationale,
-        op_id: record.op_id
-      },
-      human: () => {
-        printHuman(`Undone: ${target.verb} on \`${target.target}\`
+      printDual({
+        json: {
+          undone: target.op_id,
+          verb: target.verb,
+          target: target.target,
+          undone_ts: target.ts,
+          undone_reason: target.rationale,
+          op_id: record.op_id
+        },
+        human: () => {
+          printHuman(`Undone: ${target.verb} on \`${target.target}\`
 `);
-        if (opId === void 0) {
-          printHuman(c.gray(`It was recorded ${target.ts}.`));
-          if (target.rationale === null) printHuman(c.gray("No reason was recorded for it."));
-          else printHuman(quoteBlock(target.rationale));
-          const minutes = minutesSince(target.ts);
-          if (minutes !== null && minutes >= STALE_UNDO_MINUTES) {
-            printHuman(
-              c.gray(
-                `
+          if (opId === void 0) {
+            printHuman(c.gray(`It was recorded ${target.ts}.`));
+            if (target.rationale === null) printHuman(c.gray("No reason was recorded for it."));
+            else printHuman(quoteBlock(target.rationale));
+            const minutes = minutesSince(target.ts);
+            if (minutes !== null && minutes >= STALE_UNDO_MINUTES) {
+              printHuman(
+                c.gray(
+                  `
 that operation was ${minutes} minutes old \u2014 pass the op id to be sure it was the one you meant.`
-              )
-            );
+                )
+              );
+            }
           }
-        }
-        printHuman(c.gray(`
+          printHuman(c.gray(`
 Recorded as ${record.op_id} \u2014 the history keeps both.`));
-      }
-    });
-  });
+        }
+      });
+    }
+  );
 }
 var STALE_UNDO_MINUTES = 10;
 function minutesSince(iso) {
@@ -8259,7 +10164,7 @@ function minutesSince(iso) {
   return Math.max(0, Math.floor((Date.now() - at) / 6e4));
 }
 async function reverse(brain, op, current) {
-  const absolute = join19(brain.root, op.target);
+  const absolute = join22(brain.root, op.target);
   if (op.verb === "remember") {
     if (current === null) {
       throw memgError(
@@ -8324,7 +10229,7 @@ async function conflictHint(vaultRoot, op) {
 Read what it says now, then decide what should stay.`;
   const snapshot = await readSnapshot(vaultRoot, op.op_id);
   return snapshot === null ? base : `${base}
-The text from before that change is still on this machine: ${join19(snapshotDir(vaultRoot), `${op.op_id}.txt`)}`;
+The text from before that change is still on this machine: ${join22(snapshotDir(vaultRoot), `${op.op_id}.txt`)}`;
 }
 
 // src/commands/use.ts
@@ -8334,8 +10239,8 @@ init_errors();
 init_config();
 init_vault();
 init_ui();
-import { isAbsolute as isAbsolute3, relative as relative3, resolve as resolve9 } from "path";
-import { Command as Command17 } from "commander";
+import { isAbsolute as isAbsolute4, relative as relative3, resolve as resolve10 } from "path";
+import { Command as Command21 } from "commander";
 var VIA_MEANS = {
   flag: "because --vault named it",
   pointer: `because a \`${BRAND.pointerFileName}\` file here points at it`,
@@ -8344,11 +10249,11 @@ var VIA_MEANS = {
   default: "because it is your default brain (`memgineering use --default <path>` changes it)"
 };
 function useCommand() {
-  return new Command17("use").description("bind this folder (and everything under it) to one brain").argument("[brain]", "path to the brain \u2014 omit to show what this folder resolves to").option("--here <dir>", "write the pointer in this directory instead of the cwd").option(
+  return new Command21("use").description("bind this folder (and everything under it) to one brain").argument("[brain]", "path to the brain \u2014 omit to show what this folder resolves to").option("--here <dir>", "write the pointer in this directory instead of the cwd").option(
     "--default",
     "make this the brain used anywhere no pointer applies, instead of binding one folder"
   ).action(async (brainPath, opts) => {
-    const where = await canonicalize(resolve9(opts.here ?? process.cwd()));
+    const where = await canonicalize(resolve10(opts.here ?? process.cwd()));
     if (!brainPath) {
       const pointer = await readPointer(where);
       const resolved = await resolveBrain(void 0, where).catch((err) => err);
@@ -8385,7 +10290,7 @@ ${hint}`));
       });
       return;
     }
-    const root = await canonicalize(resolve9(brainPath));
+    const root = await canonicalize(resolve10(brainPath));
     const cfg = await loadConfig();
     if (!findBrain(cfg, root)) {
       throw memgError(
@@ -8412,16 +10317,16 @@ A pointer to an unlinked folder would fail on every command instead of at this o
       return;
     }
     const value = isInside(root, where) ? relative3(where, root) || "." : root;
-    const file = resolve9(where, BRAND.pointerFileName);
+    const file = resolve10(where, BRAND.pointerFileName);
     await writeThenRename(file, `${value}
 `);
     printDual({
-      json: { pointer: file, brain: root, relative: !isAbsolute3(value) },
+      json: { pointer: file, brain: root, relative: !isAbsolute4(value) },
       human: () => {
         printHuman(`This folder now uses \`${root}\`.
 `);
         printHuman(c.gray(`  ${file}`));
-        if (!isAbsolute3(value)) {
+        if (!isAbsolute4(value)) {
           printHuman(
             c.gray(
               "  Written as a relative path \u2014 safe to commit, and it will resolve on a teammate\u2019s machine once they link the same brain."
@@ -8433,11 +10338,56 @@ A pointer to an unlinked folder would fail on every command instead of at this o
   });
 }
 
+// src/commands/whoami.ts
+init_api_client();
+init_ui();
+import { Command as Command22 } from "commander";
+function whoamiCommand() {
+  return new Command22("whoami").description("show which account this machine is signed in as").action(async () => {
+    const base = apiUrl();
+    const credentials = await requireCredentials(base);
+    const res = await apiRequest({
+      method: "GET",
+      path: "/v1/me",
+      token: credentials.token,
+      baseUrl: base
+    });
+    const account = res.body?.account ?? {};
+    const live = res.body?.tokens?.live ?? null;
+    printDual({
+      json: {
+        account: {
+          id: account.id ?? credentials.account_id,
+          provider: account.provider ?? null,
+          display_name: account.display_name ?? null,
+          email: account.email ?? null,
+          created_at: account.created_at ?? null
+        },
+        tokens: { live },
+        api_url: base,
+        signed_in_at: credentials.signed_in_at
+      },
+      human: () => {
+        printHuman(c.bold(account.display_name ?? account.id ?? credentials.account_id));
+        if (account.email) printHuman(c.gray(`  ${account.email}`));
+        printHuman(c.gray(`  on ${base}`));
+        if (live !== null) {
+          printHuman(
+            c.gray(
+              `  ${live} ${live === 1 ? "token" : "tokens"} signed in \u2014 \`memgineering logout --all\` ends them all.`
+            )
+          );
+        }
+      }
+    });
+  });
+}
+
 // src/program.ts
 init_ui();
 init_brand();
 function buildProgram() {
-  const program = new Command18("memgineering").version(VERSION).description("memgineering \u2014 one memory for the AI you connect").option("--json", "emit JSON to stdout instead of markdown", false).hook("preAction", (thisCommand) => {
+  const program = new Command23("memgineering").version(VERSION).description("memgineering \u2014 one memory for the AI you connect").option("--json", "emit JSON to stdout instead of markdown", false).hook("preAction", (thisCommand) => {
     const opts = thisCommand.optsWithGlobals();
     if (opts.json || process.env[BRAND.jsonEnvVar] === "1") setJsonMode(true);
   });
@@ -8449,6 +10399,8 @@ function buildProgram() {
   program.addCommand(reviseCommand());
   program.addCommand(undoCommand());
   program.addCommand(resurfaceCommand());
+  program.addCommand(pushCommand());
+  program.addCommand(pullCommand());
   program.addCommand(onboardCommand());
   program.addCommand(initCommand());
   program.addCommand(linkCommand());
@@ -8462,6 +10414,9 @@ function buildProgram() {
   program.addCommand(excludeCommand());
   program.addCommand(unexcludeCommand());
   program.addCommand(setupCommand());
+  program.addCommand(loginCommand());
+  program.addCommand(logoutCommand());
+  program.addCommand(whoamiCommand());
   program.addCommand(updateCommand());
   return program;
 }