atomicreps 0.0.1

package/dist/cli.js

@@ -0,0 +1,2770 @@
+#!/usr/bin/env node
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+
+// src/clock.ts
+function now() {
+  return Date.now();
+}
+function sameLocalDay(a, b) {
+  return new Date(a).toDateString() === new Date(b).toDateString();
+}
+function iso(at) {
+  return new Date(at).toISOString();
+}
+function hhmm(at) {
+  const local = new Date(at);
+  return `${String(local.getHours()).padStart(2, "0")}:${String(local.getMinutes()).padStart(2, "0")}`;
+}
+function localDate(at) {
+  return new Date(at).toLocaleDateString();
+}
+function deadline(budgetMs, start = now()) {
+  const at = start + budgetMs;
+  return {
+    at,
+    remaining: () => Math.max(0, at - now()),
+    passed: () => now() > at
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function within(ms, parent) {
+  const deadlineSignal = AbortSignal.timeout(ms);
+  return parent === void 0 ? deadlineSignal : AbortSignal.any([deadlineSignal, parent]);
+}
+var init_clock = __esm({
+  "src/clock.ts"() {
+    "use strict";
+  }
+});
+
+// src/constants.ts
+var CALL_DEADLINE_MS, ANSWER_DEADLINE_MS, LOGIN_DEADLINE_MS, HOOK_DEADLINE_MS, INFER_BUDGET_MS, TUI_INFER_BUDGET_MS, UNAUTHORIZED_BACKOFF_MS, DEGRADED_BACKOFF_MS, TOPICS_TTL_MS, GRAMMAR_TTL_MS, STATUS_TTL_MS, PENDING_TTL_MS, OFFER_TTL_MS, REPS_KEPT, MS_PER_MINUTE, MAX_MUTE_MINUTES, MAX_QUIET_MS, QUICK_MUTE_MINUTES, QUICK_MUTE_MS, MAX_FILES_READ, MAX_BYTES_PER_FILE, MAX_CHANGED, MAX_DIFF_BYTES, MAX_IMPORTS_PER_FILE, MAX_MANIFEST_DEPS, MAX_PACKAGES_SENT, MAX_EXTENSIONS_SENT, MAX_ROOT_HOPS, TOUCHED_SENT, MAX_ADDED_LINES, HEAD_LINES, MAX_RULES, MAX_PATTERN, MAX_HITS_PER_PHRASE, MIN_WEIGHT, MAX_WEIGHT, MAX_SHORT_PROMPT_CHARS, DEFAULT_SITE, DEFAULT_API, ALPHA_SITE, ALPHA_API, CONFIG_DIR_NAME, FILES, FILE_MODE, DIR_MODE, MAX_ERROR_LOG_BYTES, MAX_NOTE_CHARS, ENV, MODERN_VERSION, LEGACY_VERSIONS, META_VERSION, META_CLIENT_INFO, META_CLIENT_CAPABILITIES, MODERN_ENVELOPE_KEYS, MAX_INPUT_ROUNDS, TOOL_NAMES, SIGN_IN_MESSAGE, DOCTOR_HINT, ESC, CLEAR, HIDE_CURSOR, SHOW_CURSOR, MAX_LINE, ART_WIDTH, ART_GUTTER, STEPS, TOGGLE_KEYS, TOKEN_PREFIX_CHARS, TOUCHED_SHOWN;
+var init_constants = __esm({
+  "src/constants.ts"() {
+    "use strict";
+    CALL_DEADLINE_MS = 1200;
+    ANSWER_DEADLINE_MS = 4e3;
+    LOGIN_DEADLINE_MS = 8e3;
+    HOOK_DEADLINE_MS = 1200;
+    INFER_BUDGET_MS = 150;
+    TUI_INFER_BUDGET_MS = INFER_BUDGET_MS * 4;
+    UNAUTHORIZED_BACKOFF_MS = 60 * 6e4;
+    DEGRADED_BACKOFF_MS = 5 * 6e4;
+    TOPICS_TTL_MS = 24 * 60 * 6e4;
+    GRAMMAR_TTL_MS = 30 * 24 * 60 * 6e4;
+    STATUS_TTL_MS = 24 * 60 * 6e4;
+    PENDING_TTL_MS = 30 * 6e4;
+    OFFER_TTL_MS = 30 * 6e4;
+    REPS_KEPT = 20;
+    MS_PER_MINUTE = 6e4;
+    MAX_MUTE_MINUTES = 1440;
+    MAX_QUIET_MS = MAX_MUTE_MINUTES * MS_PER_MINUTE;
+    QUICK_MUTE_MINUTES = 120;
+    QUICK_MUTE_MS = QUICK_MUTE_MINUTES * MS_PER_MINUTE;
+    MAX_FILES_READ = 8;
+    MAX_BYTES_PER_FILE = 8 * 1024;
+    MAX_CHANGED = 40;
+    MAX_DIFF_BYTES = 96 * 1024;
+    MAX_IMPORTS_PER_FILE = 24;
+    MAX_MANIFEST_DEPS = 60;
+    MAX_PACKAGES_SENT = 64;
+    MAX_EXTENSIONS_SENT = 32;
+    MAX_ROOT_HOPS = 64;
+    TOUCHED_SENT = 12;
+    MAX_ADDED_LINES = 400;
+    HEAD_LINES = 60;
+    MAX_RULES = 8192;
+    MAX_PATTERN = 200;
+    MAX_HITS_PER_PHRASE = 3;
+    MIN_WEIGHT = 1;
+    MAX_WEIGHT = 10;
+    MAX_SHORT_PROMPT_CHARS = 60;
+    DEFAULT_SITE = "https://atomicreps.com";
+    DEFAULT_API = "https://api.atomicreps.com";
+    ALPHA_SITE = "https://staging.atomicreps.com";
+    ALPHA_API = "https://api.staging.atomicreps.com";
+    CONFIG_DIR_NAME = "atomicreps";
+    FILES = {
+      config: "config.json",
+      errorLog: "last-error.log",
+      topics: "topics.json",
+      grammar: "grammar.json",
+      reps: "reps.json",
+      status: "status.json"
+    };
+    FILE_MODE = 384;
+    DIR_MODE = 448;
+    MAX_ERROR_LOG_BYTES = 256 * 1024;
+    MAX_NOTE_CHARS = 200;
+    ENV = {
+      api: "ATOMICREPS_API",
+      site: "ATOMICREPS_SITE",
+      channel: "ATOMICREPS_CHANNEL",
+      client: "ATOMICREPS_CLIENT",
+      pluginHint: "ATOMICREPS_PLUGIN_HINT"
+    };
+    MODERN_VERSION = "2026-07-28";
+    LEGACY_VERSIONS = ["2025-11-25", "2025-06-18", "2025-03-26"];
+    META_VERSION = "io.modelcontextprotocol/protocolVersion";
+    META_CLIENT_INFO = "io.modelcontextprotocol/clientInfo";
+    META_CLIENT_CAPABILITIES = "io.modelcontextprotocol/clientCapabilities";
+    MODERN_ENVELOPE_KEYS = /* @__PURE__ */ new Set(["resultType", "ttlMs", "cacheScope", "_meta"]);
+    MAX_INPUT_ROUNDS = 3;
+    TOOL_NAMES = ["rep", "answer", "me", "settings"];
+    SIGN_IN_MESSAGE = "Atomic Reps is not signed in on this machine. Run: npx atomicreps login";
+    DOCTOR_HINT = "Run npx atomicreps doctor.";
+    ESC = "\x1B";
+    CLEAR = "\x1B[2J\x1B[H";
+    HIDE_CURSOR = "\x1B[?25l";
+    SHOW_CURSOR = "\x1B[?25h";
+    MAX_LINE = 4e3;
+    ART_WIDTH = 19;
+    ART_GUTTER = 21;
+    STEPS = 5;
+    TOGGLE_KEYS = "abcdefghijklmnopqrstuvwxyz";
+    TOKEN_PREFIX_CHARS = 12;
+    TOUCHED_SHOWN = 8;
+  }
+});
+
+// src/types.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asPick(value) {
+  if (typeof value !== "string") return null;
+  const upper = value.toUpperCase();
+  return PICKS.includes(upper) ? upper : null;
+}
+var PICKS;
+var init_types = __esm({
+  "src/types.ts"() {
+    "use strict";
+    init_constants();
+    PICKS = ["A", "B", "C", "D"];
+  }
+});
+
+// src/files.ts
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+function readJsonFile(path) {
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return isRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function ensureDir(path) {
+  if (!existsSync(path)) mkdirSync(path, { recursive: true, mode: DIR_MODE });
+}
+function scratch(path) {
+  return {
+    [Symbol.dispose]: () => {
+      if (existsSync(path)) rmSync(path, { force: true });
+    }
+  };
+}
+function writeFileAtomic(path, text, mode) {
+  var _stack = [];
+  try {
+    const temporary = `${path}.${process.pid}.tmp`;
+    const _temp = __using(_stack, scratch(temporary));
+    writeFileSync(temporary, text, mode === void 0 ? {} : { mode });
+    if (mode !== void 0) {
+      try {
+        chmodSync(temporary, mode);
+      } catch {
+      }
+    }
+    renameSync(temporary, path);
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function writeJsonAtomic(path, value, mode) {
+  writeFileAtomic(path, JSON.stringify(value, null, 2), mode);
+}
+var init_files = __esm({
+  "src/files.ts"() {
+    "use strict";
+    init_constants();
+    init_types();
+  }
+});
+
+// src/config.ts
+import { appendFileSync, existsSync as existsSync2, statSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir, hostname } from "node:os";
+import { join } from "node:path";
+function setChannel(next) {
+  channel = next;
+}
+function channelOf() {
+  return channel;
+}
+function isAlpha() {
+  return channel === "alpha";
+}
+function configDir() {
+  const base = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+  const root = join(base, CONFIG_DIR_NAME);
+  return isAlpha() ? join(root, "alpha") : root;
+}
+function configPath() {
+  return join(configDir(), FILES.config);
+}
+function errorLogPath() {
+  return join(configDir(), FILES.errorLog);
+}
+function readConfig() {
+  return readJsonFile(configPath()) ?? {};
+}
+function ensureConfigDir() {
+  const dir2 = configDir();
+  ensureDir(dir2);
+  return dir2;
+}
+function writeConfig(config) {
+  ensureConfigDir();
+  writeJsonAtomic(configPath(), config, FILE_MODE);
+}
+function updateConfig(patch) {
+  const next = { ...readConfig(), ...patch };
+  writeConfig(next);
+  return next;
+}
+function noteFailure(message, now2) {
+  ensureConfigDir();
+  const line = `${iso(now2)} ${message.slice(0, MAX_NOTE_CHARS)}
+`;
+  try {
+    const path = errorLogPath();
+    if (existsSync2(path) && statSync(path).size > MAX_ERROR_LOG_BYTES) {
+      writeFileSync2(path, "", { mode: FILE_MODE });
+    }
+    appendFileSync(path, line, { mode: FILE_MODE });
+  } catch {
+  }
+  updateConfig({ lastFailureAt: now2, lastFailure: message.slice(0, MAX_NOTE_CHARS) });
+}
+function noteQuiet(reason, detail, now2) {
+  const message = detail ? `${reason}: ${detail}` : reason;
+  updateConfig({ lastQuietAt: now2, lastQuiet: message.slice(0, MAX_NOTE_CHARS) });
+}
+function apiOrigin() {
+  const fallback = isAlpha() ? ALPHA_API : DEFAULT_API;
+  return (process.env[ENV.api] || fallback).replace(/\/+$/, "");
+}
+function siteOrigin() {
+  const fallback = isAlpha() ? ALPHA_SITE : DEFAULT_SITE;
+  return (process.env[ENV.site] || fallback).replace(/\/+$/, "");
+}
+function clientLabel() {
+  const client = process.env[ENV.client] || "npx atomicreps";
+  return `${client} on ${hostname()}`;
+}
+function hostLabel() {
+  return hostname();
+}
+var channel;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    init_clock();
+    init_constants();
+    init_files();
+    channel = "default";
+  }
+});
+
+// src/api.ts
+async function call(path, init) {
+  const started = now();
+  const signal = within(init.deadlineMs ?? CALL_DEADLINE_MS, init.signal);
+  try {
+    const headers = { accept: "application/json", ...init.headers };
+    if (init.body !== void 0) headers["content-type"] = "application/json";
+    if (init.token) headers.authorization = `Bearer ${init.token}`;
+    const response = await fetch(`${apiOrigin()}${path}`, {
+      method: init.method,
+      headers,
+      ...init.body === void 0 ? {} : { body: JSON.stringify(init.body) },
+      signal
+    });
+    const ms = now() - started;
+    if (response.status === 304 && init.allowNotModified) {
+      return { ok: true, value: null, ms, status: 304 };
+    }
+    if (response.status === 401) return { ok: false, reason: "unauthorized", ms };
+    if (response.status === 503) return { ok: false, reason: "closed", ms };
+    if (!response.ok) {
+      return { ok: false, reason: "server", ms, detail: `${response.status}` };
+    }
+    const value = await response.json();
+    return { ok: true, value, ms, status: response.status };
+  } catch (error) {
+    const ms = now() - started;
+    const expired = Error.isError(error) && error.name === "TimeoutError";
+    return {
+      ok: false,
+      reason: expired ? "timeout" : "network",
+      ms,
+      detail: Error.isError(error) ? error.message : String(error)
+    };
+  }
+}
+function token() {
+  return readConfig().token;
+}
+function startDeviceLogin(clientName, host) {
+  return call("/mcp/device/start", {
+    method: "POST",
+    body: { clientName, host },
+    deadlineMs: LOGIN_DEADLINE_MS
+  });
+}
+function pollDeviceLogin(deviceSecret) {
+  return call("/mcp/device/poll", {
+    method: "POST",
+    body: { deviceSecret },
+    deadlineMs: LOGIN_DEADLINE_MS
+  });
+}
+function rep(request, deadlineMs, signal) {
+  return call("/mcp/rep", { method: "POST", body: request, token: token(), deadlineMs, signal });
+}
+function answer(id, pick) {
+  return call("/mcp/answer", {
+    method: "POST",
+    body: id === void 0 ? { pick } : { id, pick },
+    token: token(),
+    deadlineMs: ANSWER_DEADLINE_MS
+  });
+}
+function me(show = "summary", deadlineMs) {
+  return call(`/mcp/me?show=${show}`, { method: "GET", token: token(), deadlineMs });
+}
+function topics(deadlineMs) {
+  return call("/mcp/topics", { method: "GET", token: token(), deadlineMs });
+}
+function grammar(knownVersion, deadlineMs) {
+  return call("/mcp/grammar", {
+    method: "GET",
+    token: token(),
+    deadlineMs: deadlineMs ?? LOGIN_DEADLINE_MS,
+    headers: knownVersion === void 0 ? {} : { "if-none-match": `"${knownVersion}"` },
+    allowNotModified: true
+  });
+}
+function settings(patch) {
+  return call("/mcp/settings", {
+    method: "POST",
+    body: patch,
+    token: token(),
+    deadlineMs: ANSWER_DEADLINE_MS
+  });
+}
+var init_api = __esm({
+  "src/api.ts"() {
+    "use strict";
+    init_clock();
+    init_config();
+    init_constants();
+  }
+});
+
+// src/format.ts
+function plainBlock(text) {
+  return text.split("\n").filter((line) => line !== REP_RULE && line !== REP_FOOTER && line !== REP_FOOTER_TAP).map(
+    (line) => line.replace(/^```\w+$/, "```").replace(/^⚛ \*\*(.*)\*\*$/, "$1").replace(/\*\*(.+?)\*\*/g, "$1").replace(/^_(.+)_$/, "$1")
+  );
+}
+function isRepBlock(text) {
+  if (typeof text !== "string" || text.length > MAX_BLOCK_BYTES) return false;
+  const lines = text.split("\n");
+  const [header, rule2] = lines;
+  if (header === void 0 || !header.startsWith(BLOCK_HEADER)) return false;
+  if (rule2 !== REP_RULE) return false;
+  return lines.length >= 3;
+}
+var REP_MARK, REP_RULE, REP_FOOTER, REP_FOOTER_TAP, FALLBACK_INSTRUCTIONS, MAX_BLOCK_BYTES, BLOCK_HEADER;
+var init_format = __esm({
+  "src/format.ts"() {
+    "use strict";
+    REP_MARK = "\u269B";
+    REP_RULE = "\u2500".repeat(26);
+    REP_FOOTER = "_From memory. Reply with a letter._";
+    REP_FOOTER_TAP = "_From memory. Reply with a letter; add ! if you are sure, ? if you are not._";
+    FALLBACK_INSTRUCTIONS = [
+      "Atomic Reps serves one short retrieval question about what the user just built, for the person at the keyboard, never for you.",
+      "- After you finish a task, call `rep` once with `touched` (short phrases for what changed). An empty result is quiet: say nothing.",
+      "- Reproduce a rep, a verdict or a `me` block verbatim after your own answer; never solve, hint or comment; never write one yourself.",
+      "- A single letter A-D is the user's answer: call `answer` with `pick`. A digit 1-3 after a verdict: call `rep` with `ask` set to that offer entry's handle."
+    ].join("\n");
+    MAX_BLOCK_BYTES = 8 * 1024;
+    BLOCK_HEADER = `${REP_MARK} **Atomic Reps \xB7 `;
+  }
+});
+
+// src/touch.ts
+function phraseRegExp(words) {
+  const first = words[0] ?? "";
+  const last = words[words.length - 1] ?? "";
+  const lead = WORD_CHAR.test(first) ? "(?:^|[^a-z0-9_])" : "";
+  const tail = WORD_CHAR.test(last) ? "(?:$|[^a-z0-9_])" : "";
+  return new RegExp(`${lead}${RegExp.escape(words)}${tail}`);
+}
+function compiles(pattern) {
+  try {
+    return new RegExp(pattern, "i") instanceof RegExp;
+  } catch {
+    return false;
+  }
+}
+function weightOf(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 1;
+}
+function parseGrammar(value) {
+  if (!isRecord(value) || typeof value.version !== "string") return null;
+  if (value.version.length > 128) return null;
+  if (!Array.isArray(value.paths) || !Array.isArray(value.words)) return null;
+  const paths = [];
+  for (const rule2 of value.paths.slice(0, MAX_RULES)) {
+    if (!isRecord(rule2) || typeof rule2.pattern !== "string" || typeof rule2.key !== "string")
+      continue;
+    if (rule2.pattern.length > MAX_PATTERN) continue;
+    if (!compiles(rule2.pattern)) continue;
+    paths.push({ pattern: rule2.pattern, key: rule2.key, weight: weightOf(rule2.weight) });
+  }
+  const words = [];
+  for (const rule2 of value.words.slice(0, MAX_RULES)) {
+    if (!isRecord(rule2) || typeof rule2.words !== "string" || typeof rule2.key !== "string") continue;
+    if (rule2.words.length === 0) continue;
+    words.push({ words: rule2.words, key: rule2.key, weight: weightOf(rule2.weight) });
+  }
+  return { version: value.version, paths, words };
+}
+function compiled(grammar2) {
+  const cached = compiledByVersion.get(grammar2.version);
+  if (cached) return cached;
+  const built = {
+    paths: grammar2.paths.map((rule2) => ({ rule: rule2, re: new RegExp(rule2.pattern, "i") })),
+    words: grammar2.words.map((rule2) => ({ rule: rule2, re: phraseRegExp(rule2.words) }))
+  };
+  compiledByVersion.set(grammar2.version, built);
+  return built;
+}
+function applyGrammar(grammar2, input) {
+  const { paths, words } = compiled(grammar2);
+  const score = /* @__PURE__ */ new Map();
+  const bump = (key, weight) => score.set(key, (score.get(key) ?? 0) + weight);
+  for (const path of input.paths) {
+    if (input.deadline.passed()) break;
+    for (const { rule: rule2, re } of paths) if (re.test(path)) bump(rule2.key, rule2.weight);
+  }
+  const scan = (lines, factor) => {
+    const hits = /* @__PURE__ */ new Map();
+    for (const raw of lines) {
+      if (input.deadline.passed()) return;
+      const line = raw.toLowerCase();
+      for (const { rule: rule2, re } of words) {
+        if (!line.includes(rule2.words) || !re.test(line)) continue;
+        const seen = hits.get(rule2.words) ?? 0;
+        if (seen >= MAX_HITS_PER_PHRASE) continue;
+        hits.set(rule2.words, seen + 1);
+        bump(rule2.key, rule2.weight * factor);
+      }
+    }
+  };
+  scan(input.addedLines.slice(0, MAX_ADDED_LINES), 1);
+  scan(
+    input.heads.flatMap((head) => head.split("\n").slice(0, HEAD_LINES)),
+    0.5
+  );
+  return [...score.entries()].map(([key, weight]) => ({
+    key,
+    weight: Math.max(MIN_WEIGHT, Math.min(MAX_WEIGHT, Math.round(weight)))
+  })).toSorted((a, b) => b.weight - a.weight || a.key.localeCompare(b.key)).slice(0, TOUCHED_SENT);
+}
+function topicOf(key) {
+  const at = key.indexOf(".");
+  return at < 0 ? key : key.slice(0, at);
+}
+function allMuted(touched, muteKeys) {
+  if (touched.length === 0 || muteKeys.length === 0) return false;
+  const mutes = new Set(muteKeys);
+  return touched.every((entry) => mutes.has(entry.key) || mutes.has(topicOf(entry.key)));
+}
+var WORD_CHAR, compiledByVersion;
+var init_touch = __esm({
+  "src/touch.ts"() {
+    "use strict";
+    init_constants();
+    init_types();
+    WORD_CHAR = /[a-z0-9_]/;
+    compiledByVersion = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/infer.ts
+import { spawn } from "node:child_process";
+import { closeSync, existsSync as existsSync3, openSync, readFileSync as readFileSync2, readSync, statSync as statSync2 } from "node:fs";
+import { basename, dirname, extname, join as join2 } from "node:path";
+function runGit(cwd, args, budgetMs) {
+  const { promise, resolve } = Promise.withResolvers();
+  let out2 = "";
+  let done = false;
+  const finish = (value) => {
+    if (done) return;
+    done = true;
+    resolve(value);
+  };
+  let child;
+  try {
+    child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "ignore"] });
+  } catch {
+    finish("");
+    return promise;
+  }
+  const timer = setTimeout(() => {
+    try {
+      child.kill("SIGKILL");
+    } catch {
+    }
+    finish(out2);
+  }, budgetMs);
+  child.stdout?.on("data", (chunk) => {
+    if (out2.length < MAX_DIFF_BYTES) out2 += chunk.toString("utf8");
+  });
+  child.on("error", () => {
+    clearTimeout(timer);
+    finish("");
+  });
+  child.on("close", () => {
+    clearTimeout(timer);
+    finish(out2);
+  });
+  return promise;
+}
+function openRead(path) {
+  const fd = openSync(path, "r");
+  return { fd, [Symbol.dispose]: () => closeSync(fd) };
+}
+function readHead(path) {
+  try {
+    var _stack = [];
+    try {
+      const size = Math.min(statSync2(path).size, MAX_BYTES_PER_FILE);
+      const file = __using(_stack, openRead(path));
+      const buffer = Buffer.alloc(size);
+      const read = readSync(file.fd, buffer, 0, size, 0);
+      return buffer.subarray(0, read).toString("utf8");
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  } catch {
+    return "";
+  }
+}
+function importSpecifiers(source) {
+  const found = /* @__PURE__ */ new Set();
+  for (const match of source.matchAll(IMPORT_RE)) {
+    const spec = match[1];
+    if (!spec || spec.startsWith(".") || spec.startsWith("/") || spec.startsWith("@/")) continue;
+    const pkg = spec.startsWith("@") ? spec.split("/").slice(0, 2).join("/") : spec.split("/")[0] ?? spec;
+    found.add(pkg);
+    if (found.size >= MAX_IMPORTS_PER_FILE) break;
+  }
+  return [...found];
+}
+function manifestDeps(cwd) {
+  try {
+    const raw = readFileSync2(join2(cwd, "package.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    return Object.keys({ ...parsed.dependencies, ...parsed.devDependencies }).slice(
+      0,
+      MAX_MANIFEST_DEPS
+    );
+  } catch {
+    return [];
+  }
+}
+function isSafeRepoPath(entry) {
+  if (entry.length === 0 || entry.length > 1024) return false;
+  if (entry.startsWith("/") || entry.includes("..")) return false;
+  return !/[\u0000-\u001f]/.test(entry);
+}
+function repoRoot(cwd) {
+  let dir2 = cwd;
+  for (let hops = 0; hops < MAX_ROOT_HOPS; hops++) {
+    if (existsSync3(join2(dir2, ".git"))) return dir2;
+    const parent = dirname(dir2);
+    if (parent === dir2) break;
+    dir2 = parent;
+  }
+  return cwd;
+}
+function extensionOf(path) {
+  const base = basename(path).toLowerCase();
+  if (base === "dockerfile") return "dockerfile";
+  return extname(base).replace(/^\./, "");
+}
+function addedLines(diff) {
+  const lines = [];
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("+") && !line.startsWith("+++")) lines.push(line.slice(1));
+  }
+  return lines;
+}
+async function inferHints(cwd, budgetMs = INFER_BUDGET_MS, grammar2 = null) {
+  const deadline2 = deadline(budgetMs);
+  const root = repoRoot(cwd);
+  const changedRaw = await runGit(
+    cwd,
+    ["status", "--porcelain", "-z", "--untracked-files=all", "--no-renames"],
+    Math.min(deadline2.remaining(), budgetMs * 0.4)
+  );
+  const changed = changedRaw.split("\0").map((entry) => entry.slice(3).trim()).filter(isSafeRepoPath).slice(0, MAX_CHANGED);
+  const extensions = /* @__PURE__ */ new Set();
+  const packages = /* @__PURE__ */ new Set();
+  for (const file of changed) {
+    const ext = extensionOf(file);
+    if (ext) extensions.add(ext);
+    const dir2 = file.split("/")[0];
+    if (dir2 && dir2 !== file) extensions.add(dir2.toLowerCase());
+  }
+  const diff = grammar2 && changed.length > 0 && deadline2.remaining() > 20 ? await runGit(
+    root,
+    ["diff", "--no-color", "--unified=0", "--no-ext-diff", "HEAD", "--", ...changed],
+    Math.min(deadline2.remaining(), budgetMs * 0.3)
+  ) : "";
+  const byRecency = changed.map((file) => {
+    try {
+      return { file, mtime: statSync2(join2(root, file)).mtimeMs };
+    } catch {
+      return null;
+    }
+  }).filter((entry) => entry !== null).toSorted((a, b) => b.mtime - a.mtime).slice(0, MAX_FILES_READ);
+  const heads = [];
+  for (const { file } of byRecency) {
+    if (deadline2.remaining() <= 0) break;
+    const head = readHead(join2(root, file));
+    heads.push(head);
+    for (const spec of importSpecifiers(head)) packages.add(spec);
+  }
+  for (const dep of manifestDeps(cwd)) packages.add(dep);
+  if (root !== cwd) for (const dep of manifestDeps(root)) packages.add(dep);
+  const touched = grammar2 === null ? [] : applyGrammar(grammar2, { paths: changed, addedLines: addedLines(diff), heads, deadline: deadline2 });
+  return {
+    packages: [...packages].slice(0, MAX_PACKAGES_SENT),
+    extensions: [...extensions].slice(0, MAX_EXTENSIONS_SENT),
+    touched
+  };
+}
+var IMPORT_RE;
+var init_infer = __esm({
+  "src/infer.ts"() {
+    "use strict";
+    init_clock();
+    init_constants();
+    init_touch();
+    IMPORT_RE = /(?:from\s+|require\(|import\s+)["']([^"']+)["']/g;
+  }
+});
+
+// src/store.ts
+import { join as join3 } from "node:path";
+function dir() {
+  return join3(configPath(), "..");
+}
+function readJson(name) {
+  return readJsonFile(join3(dir(), name));
+}
+function writeJson(name, value) {
+  try {
+    ensureDir(dir());
+    writeJsonAtomic(join3(dir(), name), value, FILE_MODE);
+  } catch {
+  }
+}
+async function refreshTopics(now2) {
+  const fetched2 = await topics();
+  if (!fetched2.ok) return null;
+  const file = {
+    fetchedAt: now2,
+    topics: fetched2.value.topics,
+    ...fetched2.value.domains ? { domains: fetched2.value.domains } : {}
+  };
+  writeJson(FILES.topics, file);
+  return file;
+}
+async function topicCatalog(now2 = now()) {
+  const cached = readJson(FILES.topics);
+  if (cached && now2 - cached.fetchedAt < TOPICS_TTL_MS) return cached.topics;
+  const fresh = await refreshTopics(now2);
+  return fresh?.topics ?? cached?.topics ?? [];
+}
+async function domainCatalog(now2 = now()) {
+  const cached = readJson(FILES.topics);
+  if (cached?.domains && now2 - cached.fetchedAt < TOPICS_TTL_MS) return cached.domains;
+  const fresh = await refreshTopics(now2);
+  return fresh?.domains ?? cached?.domains ?? [];
+}
+function cachedGrammar() {
+  const file = readJson(FILES.grammar);
+  return file ? parseGrammar(file.grammar) : null;
+}
+async function ensureGrammar(now2 = now(), expectedVersion, deadlineMs) {
+  const file = readJson(FILES.grammar);
+  const cached = file ? parseGrammar(file.grammar) : null;
+  const fresh = cached !== null && file !== null && now2 - file.fetchedAt < GRAMMAR_TTL_MS && (expectedVersion === void 0 || expectedVersion === cached.version);
+  if (fresh) return cached;
+  const fetched2 = await grammar(cached?.version, deadlineMs);
+  if (!fetched2.ok) return cached;
+  if (fetched2.status === 304 && cached) {
+    writeJson(FILES.grammar, { fetchedAt: now2, grammar: cached });
+    return cached;
+  }
+  const parsed = parseGrammar(fetched2.value);
+  if (!parsed) return cached;
+  writeJson(FILES.grammar, { fetchedAt: now2, grammar: parsed });
+  return parsed;
+}
+function listReps() {
+  return readJson(FILES.reps)?.reps ?? [];
+}
+function recordServed(rep2) {
+  const reps = listReps().filter((r) => r.id !== rep2.id);
+  reps.push(rep2);
+  writeJson(FILES.reps, { reps: reps.slice(-REPS_KEPT) });
+}
+function recordAnswered(id, correct, verdict, now2, offer) {
+  const reps = listReps().map(
+    (r) => r.id === id ? { ...r, answeredAt: now2, correct, verdict, offer } : r
+  );
+  writeJson(FILES.reps, { reps });
+}
+function offerOf(data) {
+  if (!Array.isArray(data.offer)) return [];
+  return data.offer.filter(
+    (o) => isRecord(o) && typeof o.handle === "string" && typeof o.name === "string"
+  );
+}
+function observeRep(data, text, now2) {
+  if (data.kind === "verdict") {
+    observeVerdict(void 0, data, text, now2);
+    return;
+  }
+  if (typeof data.nextEligibleAt === "number" && Number.isFinite(data.nextEligibleAt)) {
+    updateConfig({ nextEligibleAt: Math.min(data.nextEligibleAt, now2 + MAX_QUIET_MS) });
+  }
+  if (data.kind === "quiet" && typeof data.reason === "string")
+    noteQuiet(data.reason, void 0, now2);
+  if (data.kind === "question" && typeof data.id === "string") {
+    recordServed({
+      id: data.id,
+      topicSlug: typeof data.topicSlug === "string" ? data.topicSlug : "",
+      ...typeof data.handle === "string" ? { handle: data.handle } : {},
+      ...data.lane === "asked" || data.lane === "pushed" ? { lane: data.lane } : {},
+      text,
+      servedAt: now2
+    });
+  }
+}
+function observeVerdict(id, data, text, now2) {
+  const answered = data.status === "answered" || data.kind === "verdict";
+  if (!answered || typeof data.correct !== "boolean") return;
+  if (typeof data.currentStreak === "number")
+    mergeStatus({ currentStreak: data.currentStreak, streakAt: now2 }, now2);
+  const target = id ?? listReps().at(-1)?.id;
+  if (target !== void 0) recordAnswered(target, data.correct, text, now2, offerOf(data));
+}
+function pendingRep(now2 = now()) {
+  const last = listReps().at(-1);
+  if (!last || last.answeredAt !== void 0) return void 0;
+  return now2 - last.servedAt <= PENDING_TTL_MS ? last : void 0;
+}
+function openOffer(now2 = now()) {
+  const last = listReps().at(-1);
+  if (!last?.answeredAt || !last.offer || last.offer.length === 0) return [];
+  return now2 - last.answeredAt <= OFFER_TTL_MS ? last.offer : [];
+}
+function mergeStatus(fields, now2) {
+  const cached = readJson(FILES.status);
+  const status = cached && now2 - cached.fetchedAt <= STATUS_TTL_MS ? cached.status : {};
+  writeJson(FILES.status, { fetchedAt: now2, status: { ...status, ...fields } });
+}
+function writeStatusCache(status, now2 = now()) {
+  writeJson(FILES.status, { fetchedAt: now2, status: { ...status, streakAt: now2 } });
+}
+function readStatusCache(now2 = now(), maxAgeMs = STATUS_TTL_MS) {
+  const cached = readJson(FILES.status);
+  if (!cached || now2 - cached.fetchedAt > maxAgeMs) return null;
+  return cached.status;
+}
+function observeClient(client, now2 = now()) {
+  const fields = {};
+  if (Array.isArray(client?.muteKeys)) fields.muteKeys = client.muteKeys;
+  if (typeof client?.grammarVersion === "string") fields.grammarVersion = client.grammarVersion;
+  if (Object.keys(fields).length > 0) mergeStatus(fields, now2);
+}
+function streakForStatus(now2 = now()) {
+  const status = readStatusCache(now2);
+  const at = status?.streakAt;
+  const streak = status?.currentStreak;
+  if (typeof at !== "number" || typeof streak !== "number") return null;
+  return sameLocalDay(at, now2) ? streak : null;
+}
+function cachedMuteKeys(now2 = now()) {
+  const keys = readStatusCache(now2)?.muteKeys;
+  return Array.isArray(keys) ? keys.filter((k) => typeof k === "string") : [];
+}
+function cachedGrammarVersion(now2 = now()) {
+  const version = readStatusCache(now2)?.grammarVersion;
+  return typeof version === "string" ? version : void 0;
+}
+var init_store = __esm({
+  "src/store.ts"() {
+    "use strict";
+    init_api();
+    init_clock();
+    init_config();
+    init_constants();
+    init_files();
+    init_touch();
+    init_types();
+  }
+});
+
+// src/ansi.ts
+function colourAllowed() {
+  if (process.env.NO_COLOR !== void 0) return false;
+  if (process.env.FORCE_COLOR !== void 0) return true;
+  if (process.env.TERM === "dumb") return false;
+  return Boolean(process.stdout.isTTY);
+}
+function paint(text, ...tones) {
+  if (!COLOUR || tones.length === 0) return text;
+  const open = tones.map((t) => `\x1B[${CODES[t]}m`).join("");
+  return `${open}${text}\x1B[0m`;
+}
+function sanitize(text, max = MAX_LINE) {
+  return text.replace(NOT_COLOUR, "").replace(STRAY_ESC, "").replace(CONTROLS, "").slice(0, max);
+}
+function stripAnsi(text) {
+  return sanitize(text).replace(COLOUR_SEQUENCE, "");
+}
+function visibleWidth(text) {
+  return [...stripAnsi(text)].length;
+}
+function wrap(text, width) {
+  const out2 = [];
+  for (const paragraph2 of text.split("\n")) {
+    if (paragraph2.trim() === "") {
+      out2.push("");
+      continue;
+    }
+    let line = "";
+    for (const word of paragraph2.split(/\s+/)) {
+      if (line === "") line = word;
+      else if (visibleWidth(line) + 1 + visibleWidth(word) <= width) line += ` ${word}`;
+      else {
+        out2.push(line);
+        line = word;
+      }
+    }
+    out2.push(line);
+  }
+  return out2;
+}
+var CODES, COLOUR, NOT_COLOUR, STRAY_ESC, COLOUR_SEQUENCE, CONTROLS;
+var init_ansi = __esm({
+  "src/ansi.ts"() {
+    "use strict";
+    init_constants();
+    CODES = {
+      ink: "38;5;231",
+      soft: "38;5;250",
+      faint: "38;5;244",
+      coral: "38;5;209",
+      gold: "38;5;221",
+      green: "38;5;114",
+      red: "38;5;203",
+      body: "38;5;218",
+      gill: "38;5;211",
+      face: "38;5;53",
+      blush: "38;5;205",
+      bold: "1",
+      dim: "2"
+    };
+    COLOUR = colourAllowed();
+    NOT_COLOUR = new RegExp(
+      [
+        `${ESC}\\][^\\u0007${ESC}]*(?:\\u0007|${ESC}\\\\)?`,
+        `${ESC}[P^_X][^${ESC}]*(?:${ESC}\\\\)?`,
+        `${ESC}\\[[0-?]*[ -/]*[@-ln-~]`,
+        `${ESC}[^\\[\\]P^_X]`
+      ].join("|"),
+      "g"
+    );
+    STRAY_ESC = new RegExp(`${ESC}(?!\\[[0-9;]*m)`, "g");
+    COLOUR_SEQUENCE = new RegExp(`${ESC}\\[[0-9;]*m`, "g");
+    CONTROLS = /[\u0000-\u0008\u000b-\u001a\u001c-\u001f\u007f-\u009f\u2028\u2029]/g;
+  }
+});
+
+// src/loop.ts
+function mirror(gill) {
+  return [...gill].toReversed().join("");
+}
+function loopArt(pose) {
+  const { eyes, mouth, blush } = FACES[pose];
+  const [g1, g2, g3] = GILLS[pose];
+  const g = (s) => paint(s, "gill");
+  const b = (s) => paint(s, "body");
+  const f = (s) => paint(s, "face");
+  const bl = (s) => paint(s, "blush");
+  const arms = pose === "celebrating" ? [g(" \\"), g("/ ")] : ["  ", "  "];
+  return [
+    `${g(g1)}${b("\u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E")}${g(mirror(g1))}`,
+    `${g(g2)}${b("\u2502")}${f(`  ${eyes}  `)}${b("\u2502")}${g(mirror(g2))}`,
+    `${g(g3)}${b("\u2502")} ${bl(blush)} ${f(mouth)} ${bl(blush)} ${b("\u2502")}${g(mirror(g3))}`,
+    `    ${b("\u2570\u2500\u2500\u256E")}${b("   ")}${b("\u256D\u2500\u2500\u256F")}    `,
+    `${arms[0]}     ${b("\u2570\u2500\u2500\u2500\u256F")}${b("~")}    ${arms[1]}`
+  ];
+}
+var FACES, GILLS;
+var init_loop = __esm({
+  "src/loop.ts"() {
+    "use strict";
+    init_ansi();
+    FACES = {
+      idle: { eyes: "\u25D5   \u25D5", mouth: " \u203F ", blush: "\u2661" },
+      thinking: { eyes: "\u25D4   \u25D5", mouth: " ~ ", blush: " " },
+      impressed: { eyes: "\u2726   \u2726", mouth: " \u25BD ", blush: "\u2661" },
+      facepalm: { eyes: "-   -", mouth: " \u2312 ", blush: " " },
+      celebrating: { eyes: "^   ^", mouth: " \u25BD ", blush: "\u2661" },
+      sleeping: { eyes: "\u2013   \u2013", mouth: " z ", blush: " " }
+    };
+    GILLS = {
+      idle: ["  ~\u2248", " ~\u2248\u2248", "  ~\u2248"],
+      thinking: ["  ~\u2248", " ~\u2248\u2248", "  ~\u2248"],
+      impressed: [" ~\u2248\u2248", "~\u2248\u2248\u2248", " ~\u2248\u2248"],
+      facepalm: ["  ~\u2248", " ~\u2248\u2248", "  ~\u2248"],
+      celebrating: [" ~\u2248\u2248", "~\u2248\u2248\u2248", " ~\u2248\u2248"],
+      sleeping: ["   ~", "  ~\u2248", "   ~"]
+    };
+  }
+});
+
+// src/screen.ts
+import { spawnSync } from "node:child_process";
+function isInteractive() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY) && !process.env.CI;
+}
+function out(lines) {
+  const all = [...channelBanner(), ...lines];
+  process.stdout.write(`${CLEAR}${all.map((l) => `  ${sanitize(l)}`).join("\n")}
+`);
+}
+function plain(lines) {
+  process.stdout.write(`${lines.map(stripAnsi).join("\n")}
+`);
+}
+function rule() {
+  return paint("\u2500".repeat(TEXT_WIDTH), "faint");
+}
+function title(text) {
+  return paint(text, "bold", "ink");
+}
+function keyHint(pairs) {
+  return pairs.map(([k, label]) => `${paint(k, "coral", "bold")} ${paint(label, "soft")}`).join("   ");
+}
+function withLoop(pose, copy) {
+  const art = loopArt(pose);
+  const rows = Math.max(art.length, copy.length);
+  const lines = [];
+  for (let i = 0; i < rows; i++) {
+    const left = art[i] ?? " ".repeat(ART_WIDTH);
+    const pad = " ".repeat(Math.max(0, ART_GUTTER - visibleWidth(left)));
+    lines.push(`${left}${pad}${copy[i] ?? ""}`);
+  }
+  return lines;
+}
+function rawMode() {
+  const stdin = process.stdin;
+  stdin.setRawMode?.(true);
+  stdin.resume();
+  stdin.setEncoding("utf8");
+  return {
+    [Symbol.dispose]: () => {
+      stdin.setRawMode?.(false);
+      stdin.pause();
+    }
+  };
+}
+async function readKey() {
+  var _stack = [];
+  try {
+    const _raw = __using(_stack, rawMode());
+    const { promise, resolve } = Promise.withResolvers();
+    const onData = (data) => {
+      process.stdin.off("data", onData);
+      resolve(data);
+    };
+    process.stdin.on("data", onData);
+    return await promise;
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function isEnter(key) {
+  return key === "\r" || key === "\n";
+}
+function isBack(key) {
+  return key === ESC || key === "q";
+}
+async function pause(label = "back") {
+  process.stdout.write(`
+  ${keyHint([["any key", label]])}
+`);
+  await readKey();
+}
+function safeUrl(raw) {
+  if (typeof raw !== "string" || raw.length > 512) return null;
+  let parsed;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    return null;
+  }
+  if (parsed.protocol !== "https:") return null;
+  return parsed.host === new URL(siteOrigin()).host ? parsed.toString() : null;
+}
+function openBrowser(url) {
+  const safe = safeUrl(url);
+  if (safe === null) return;
+  const [command, args] = process.platform === "darwin" ? ["open", [safe]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", safe]] : ["xdg-open", [safe]];
+  try {
+    spawnSync(command, [...args], { stdio: "ignore" });
+  } catch {
+  }
+}
+function copyToClipboard(text) {
+  const tool = process.platform === "darwin" ? "pbcopy" : process.platform === "win32" ? "clip" : "xclip";
+  try {
+    const run = spawnSync(tool, process.platform === "linux" ? ["-selection", "clipboard"] : [], {
+      input: text,
+      stdio: ["pipe", "ignore", "ignore"]
+    });
+    return run.status === 0;
+  } catch {
+    return false;
+  }
+}
+function channelBanner() {
+  if (!isAlpha()) return [];
+  return [`${paint(" ALPHA ", "bold", "gold")} ${paint(apiOrigin(), "faint")}`, ""];
+}
+function step(index, total) {
+  return paint(`Step ${index} of ${total}`, "faint");
+}
+var WIDTH, TEXT_WIDTH;
+var init_screen = __esm({
+  "src/screen.ts"() {
+    "use strict";
+    init_ansi();
+    init_config();
+    init_constants();
+    init_loop();
+    WIDTH = Math.min(process.stdout.columns || 80, 88);
+    TEXT_WIDTH = WIDTH - 4;
+  }
+});
+
+// src/connect.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join4 } from "node:path";
+function serverName() {
+  return isAlpha() ? "atomicreps-alpha" : "atomicreps";
+}
+function bridgeArgs() {
+  return isAlpha() ? ["-y", "atomicreps", "mcp", "--alpha"] : ["-y", "atomicreps", "mcp"];
+}
+function toolAllowlist() {
+  return TOOL_NAMES.map((tool) => `mcp__${serverName()}__${tool}`);
+}
+function claudeAddCommand() {
+  return `claude mcp add --scope user ${serverName()} -- npx ${bridgeArgs().join(" ")}`;
+}
+function cursorConfig() {
+  return { mcpServers: { [serverName()]: { command: "npx", args: bridgeArgs() } } };
+}
+function claudeSettingsPath() {
+  return join4(homedir2(), ".claude", "settings.json");
+}
+function claudeAvailable() {
+  const probe = spawnSync2("claude", ["--version"], { stdio: "ignore" });
+  return probe.status === 0;
+}
+function addToClaude() {
+  const run = spawnSync2(
+    "claude",
+    ["mcp", "add", "--scope", "user", serverName(), "--", "npx", ...bridgeArgs()],
+    {
+      encoding: "utf8"
+    }
+  );
+  const output = `${run.stdout ?? ""}${run.stderr ?? ""}`.trim();
+  return { ok: run.status === 0, output };
+}
+function unusableSettings(path) {
+  try {
+    const parsed = JSON.parse(readFileSync3(path, "utf8"));
+    return Array.isArray(parsed) ? "settings.json is not an object" : null;
+  } catch {
+    return "could not parse the file; add the allowlist by hand";
+  }
+}
+function allowInClaude() {
+  const path = claudeSettingsPath();
+  let settings2 = {};
+  if (existsSync4(path)) {
+    const parsed = readJsonFile(path);
+    if (parsed === null) {
+      const skipped = unusableSettings(path);
+      if (skipped !== null) return { added: [], path, skipped };
+    } else settings2 = parsed;
+  }
+  const permissions = typeof settings2.permissions === "object" && settings2.permissions !== null ? settings2.permissions : {};
+  const allow = Array.isArray(permissions.allow) ? permissions.allow.filter((x) => typeof x === "string") : [];
+  const added = toolAllowlist().filter((tool) => !allow.includes(tool));
+  if (added.length === 0) return { added, path };
+  const next = { ...settings2, permissions: { ...permissions, allow: [...allow, ...added] } };
+  writeFileAtomic(path, `${JSON.stringify(next, null, 2)}
+`);
+  return { added, path };
+}
+function allowlistMissing() {
+  const parsed = readJsonFile(claudeSettingsPath());
+  const allow = Array.isArray(parsed?.permissions?.allow) ? parsed.permissions.allow : [];
+  return toolAllowlist().filter((tool) => !allow.includes(tool));
+}
+var init_connect = __esm({
+  "src/connect.ts"() {
+    "use strict";
+    init_config();
+    init_constants();
+    init_files();
+  }
+});
+
+// src/tui.ts
+var tui_exports = {};
+__export(tui_exports, {
+  connect: () => connect,
+  doctor: () => doctor,
+  home: () => home,
+  login: () => login
+});
+async function fetched(result, failTitle = "Could not reach the server.") {
+  if (result.ok) return result.value;
+  out(withLoop("facepalm", [title(failTitle), `(${result.reason})`]));
+  await pause();
+  return null;
+}
+async function confirmSaved(result, pose = "impressed") {
+  out(
+    withLoop(pose, [title(result.ok ? result.value.text : `Could not save (${result.reason}).`)])
+  );
+  await pause();
+}
+function humanize(key) {
+  const [topic, sub] = key.split(".");
+  const words = (s) => s.replace(/_/g, " ");
+  return sub ? `${words(topic ?? "")} \xB7 ${words(sub)}` : words(topic ?? key);
+}
+async function login(interactive = isInteractive()) {
+  const started = await startDeviceLogin(clientLabel(), hostLabel());
+  if (!started.ok) {
+    plain([`Could not reach ${siteOrigin()} (${started.reason}). Try again in a moment.`]);
+    return false;
+  }
+  const { userCode, deviceSecret, verifyUrl, expiresAt, intervalMs } = started.value;
+  const copied = interactive && copyToClipboard(userCode);
+  const copy = [
+    title("Sign in from your browser."),
+    "",
+    `Open ${paint(verifyUrl, "coral", "bold")} and type this code:`,
+    "",
+    `      ${paint(` ${userCode} `, "bold", "ink")}${copied ? paint("   (copied)", "faint") : ""}`,
+    "",
+    paint("The code never travels in a link. Only approve a code you see here.", "faint")
+  ];
+  if (interactive) out(withLoop("thinking", copy));
+  else plain(copy);
+  openBrowser(verifyUrl);
+  while (now() < expiresAt) {
+    await sleep(intervalMs);
+    const polled = await pollDeviceLogin(deviceSecret);
+    if (!polled.ok) continue;
+    if (polled.value.status === "approved") {
+      writeConfig({
+        token: polled.value.token,
+        tokenPrefix: polled.value.token.slice(0, TOKEN_PREFIX_CHARS),
+        connectedAt: now()
+      });
+      return true;
+    }
+    if (polled.value.status === "expired") break;
+  }
+  plain(["That code expired. Run npx atomicreps again for a fresh one."]);
+  return false;
+}
+async function fetchSummary() {
+  const result = await me("summary", LOGIN_DEADLINE_MS);
+  if (!result.ok || !result.value.data) return null;
+  return result.value.data;
+}
+function summaryLines(s) {
+  const plan = s.isPro ? paint("Pro", "gold", "bold") : paint("Free", "soft", "bold");
+  const muted = s.mutedUntil && s.mutedUntil > now();
+  return [
+    `${title(`Hey ${s.name}.`)}  ${plan}`,
+    "",
+    `Today: ${paint(String(s.answeredToday), "bold")} answered of ${s.cap}, ${s.askedToday} asked of ${s.askedCap}. This week ${s.weekReps}.`,
+    `Streak: ${paint(String(s.currentStreak), "bold")} day${s.currentStreak === 1 ? "" : "s"} (best ${s.longestStreak}).`,
+    `Intensity: ${paint(s.intensity, "bold")} (${s.gapMinutes} min between reps)${muted ? paint("  muted", "faint") : ""}`,
+    `Prefers: ${s.prefer.length > 0 ? s.prefer.join(", ") : "the whole catalog"}${s.muteCount > 0 ? paint(`  \xB7 ${s.muteCount} mute${s.muteCount === 1 ? "" : "s"}`, "faint") : ""}`
+  ];
+}
+async function localHints() {
+  return await inferHints(process.cwd(), TUI_INFER_BUDGET_MS, await ensureGrammar());
+}
+async function repScreen(ask) {
+  const now2 = now();
+  const served = await fetched(
+    await rep(
+      ask === void 0 ? { hints: await localHints(), lane: "asked", kind: "question" } : { ask, kind: "question" },
+      LOGIN_DEADLINE_MS
+    )
+  );
+  if (!served) return;
+  const data = served.data ?? {};
+  observeRep(served.data ?? {}, served.text, now2);
+  if (data.kind !== "question" || !data.id) {
+    const why = data.reason === "spent" ? "Today's asked reps are done." : data.reason === "off" ? "The door is off. Set an intensity to open it." : "Nothing to serve right now.";
+    out(withLoop("sleeping", [title("Quiet."), why]));
+    await pause();
+    return;
+  }
+  const body = plainBlock(served.text).flatMap((line) => wrap(line, TEXT_WIDTH));
+  out([
+    ...withLoop("thinking", [title("One rep. From memory."), "", ...body.slice(0, 3)]),
+    ...body.slice(3),
+    "",
+    keyHint([
+      ["A-D", "answer"],
+      ["esc", "skip"]
+    ])
+  ]);
+  let pick = null;
+  while (pick === null) {
+    const key = await readKey();
+    if (isBack(key)) return;
+    pick = asPick(key);
+  }
+  const answered = await fetched(await answer(data.id, pick), "Could not grade that.");
+  if (!answered) return;
+  const verdict = answered.data ?? {};
+  observeVerdict(data.id, verdict, answered.text, now2);
+  const offer = offerOf(verdict);
+  const correct = verdict.correct === true;
+  const graded = verdict.status === "answered";
+  const lines = plainBlock(answered.text).filter((line) => !line.startsWith("Also touched:")).flatMap((line) => wrap(line, TEXT_WIDTH));
+  out([
+    ...withLoop(correct ? "celebrating" : graded ? "facepalm" : "idle", [
+      title(correct ? "Yes." : graded ? "Not this time." : "Hm."),
+      "",
+      ...lines.slice(0, 3)
+    ]),
+    ...lines.slice(3),
+    "",
+    ...offer.length > 0 ? [paint("Also touched:", "faint"), keyHint(offer.map((o, i) => [String(i + 1), o.name])), ""] : [],
+    keyHint([["any other key", "back"]])
+  ]);
+  const next = offer[Number(await readKey()) - 1];
+  if (next) await repScreen(next.handle);
+}
+async function sessionScreen() {
+  out(withLoop("thinking", [title("Reading the working tree\u2026")]));
+  const { touched } = await localHints();
+  if (touched.length === 0) {
+    out(
+      withLoop("idle", [
+        title("Nothing touched yet."),
+        "Change a file, or ask for any rep from the home screen."
+      ])
+    );
+    await pause();
+    return;
+  }
+  const shown = touched.slice(0, TOUCHED_SHOWN);
+  out([
+    ...withLoop("impressed", [title("This session touched:"), ""]),
+    ...shown.map(
+      (entry2, i) => `${paint(String(i + 1), "coral", "bold")} ${humanize(entry2.key)}  ${paint(`\xB7${entry2.weight}`, "faint")}`
+    ),
+    "",
+    keyHint([
+      ["1-8", "a rep on that"],
+      ["esc", "back"]
+    ])
+  ]);
+  const key = await readKey();
+  const entry = shown[Number(key) - 1];
+  if (entry) await repScreen(entry.key);
+}
+async function skillsScreen() {
+  const skills = await fetched(await me("skills", LOGIN_DEADLINE_MS));
+  if (!skills) return;
+  const lines = plainBlock(skills.text).flatMap((line) => wrap(line, TEXT_WIDTH));
+  out([...withLoop("impressed", [title(lines[0] ?? "Skills"), ""]), ...lines.slice(1)]);
+  await pause();
+}
+async function mutesScreen() {
+  const shown = await fetched(await me("mutes", LOGIN_DEADLINE_MS));
+  if (!shown) return;
+  const mutes = (shown.data?.mutes ?? []).slice(0, 9);
+  if (mutes.length === 0) {
+    out(
+      withLoop("idle", [
+        title("No mutes."),
+        'Tell your agent "never X" or "not this topic" and it lands here.'
+      ])
+    );
+    await pause();
+    return;
+  }
+  out([
+    ...withLoop("idle", [title("Muted."), "A number lifts one.", ""]),
+    ...mutes.map(
+      (m, i) => `${paint(String(i + 1), "coral", "bold")} ${m.name}  ${paint(
+        m.until === void 0 ? "forever" : `until ${localDate(m.until)}`,
+        "faint"
+      )}`
+    ),
+    "",
+    keyHint([
+      ["1-9", "unmute"],
+      ["esc", "back"]
+    ])
+  ]);
+  const key = await readKey();
+  const target = mutes[Number(key) - 1];
+  if (target) await confirmSaved(await settings({ unmute: target.key }));
+}
+async function preferScreen(current) {
+  const domains = (await domainCatalog()).slice(0, PREFER_KEYS.length);
+  if (domains.length === 0) {
+    out(withLoop("facepalm", [title("Could not load the domains."), "Try again in a moment."]));
+    await pause();
+    return;
+  }
+  const chosen = new Set(current);
+  for (; ; ) {
+    out([
+      ...withLoop("idle", [
+        title("What the pushed rep prefers."),
+        "The rep follows what you touched; among that, these domains come first.",
+        ""
+      ]),
+      ...domains.map(
+        (d, i) => `${paint(PREFER_KEYS[i] ?? "", "coral", "bold")} ${chosen.has(d.slug) ? paint("\u25CF", "gold") : paint("\xB7", "faint")} ${d.name}`
+      ),
+      "",
+      keyHint([
+        ["a-m", "toggle"],
+        ["enter", "save"],
+        ["esc", "back"]
+      ])
+    ]);
+    const key = await readKey();
+    if (isBack(key)) return;
+    if (isEnter(key)) break;
+    const index = PREFER_KEYS.indexOf(key.toLowerCase());
+    const domain = domains[index];
+    if (!domain) continue;
+    if (chosen.has(domain.slug)) chosen.delete(domain.slug);
+    else chosen.add(domain.slug);
+  }
+  const saved = await settings({ prefer: [...chosen] });
+  out(
+    withLoop("impressed", [
+      title(saved.ok ? saved.value.text : `Could not save (${saved.reason}).`)
+    ])
+  );
+  await pause();
+}
+async function settingsScreen(status) {
+  out(
+    withLoop("idle", [
+      title("Intensity."),
+      `${paint("0", "coral", "bold")} off   ${paint("1", "coral", "bold")} light   ${paint("2", "coral", "bold")} regular${status.isPro ? "" : paint(" (Pro)", "faint")}   ${paint("3", "coral", "bold")} intense${status.isPro ? "" : paint(" (Pro)", "faint")}`,
+      `${paint("m", "coral", "bold")} mute for two hours   ${paint("esc", "coral", "bold")} back`,
+      "",
+      paint(`Now: ${status.intensity}`, "faint")
+    ])
+  );
+  const key = await readKey();
+  const picked = CADENCES.find((c) => c.key === key);
+  if (picked) await confirmSaved(await settings({ intensity: picked.value }), "idle");
+  else if (key === "m") {
+    const result = await settings({ muteMinutes: QUICK_MUTE_MINUTES });
+    if (result.ok) updateConfig({ nextEligibleAt: now() + QUICK_MUTE_MS });
+    await confirmSaved(result, "sleeping");
+  }
+}
+async function connect(interactive = isInteractive()) {
+  const lines = [title("Connect your coding agent.")];
+  if (claudeAvailable()) {
+    const added = addToClaude();
+    lines.push(
+      added.ok ? `Claude Code: added at user scope.` : `Claude Code: ${added.output || "could not add"}. Run by hand:`,
+      added.ok ? "" : `  ${claudeAddCommand()}`
+    );
+    const allow = allowInClaude();
+    if (allow.skipped) lines.push(`Allowlist: ${allow.skipped}`);
+    else if (allow.added.length > 0)
+      lines.push(
+        `Allowlist: ${allow.added.length} tools added to ${allow.path} so the first rep is not a prompt.`
+      );
+    else lines.push("Allowlist: already in place.");
+  } else {
+    lines.push("Claude Code CLI not found. When it is installed, run:", `  ${claudeAddCommand()}`);
+  }
+  lines.push(
+    "",
+    "Cursor: put this in ~/.cursor/mcp.json",
+    ...JSON.stringify(cursorConfig(), null, 2).split("\n").map((l) => `  ${l}`)
+  );
+  lines.push("", "Codex: codex mcp add atomicreps -- npx -y atomicreps mcp");
+  lines.push(
+    "",
+    `Other MCP clients: ${siteOrigin()}/mcp with a token from ${siteOrigin()}/account.`
+  );
+  if (interactive) {
+    out([...withLoop("celebrating", lines.slice(0, 5)), ...lines.slice(5)]);
+    await pause();
+  } else {
+    plain(lines);
+  }
+}
+async function doctor() {
+  const config = readConfig();
+  const lines = [`channel: ${channelOf()}`, `door: ${apiOrigin()}`];
+  let failures = 0;
+  if (!config.token) {
+    lines.push("token: none. Run npx atomicreps to sign in.");
+    failures += 1;
+  } else {
+    lines.push(
+      `token: ${config.tokenPrefix ?? config.token.slice(0, TOKEN_PREFIX_CHARS)}\u2026 connected ${config.connectedAt ? iso(config.connectedAt) : "unknown"}`
+    );
+    const ping = await me("summary", LOGIN_DEADLINE_MS);
+    if (ping.ok) {
+      lines.push(`server: ok in ${ping.ms}ms`);
+      const version = ping.value.data?.grammarVersion;
+      const grammar2 = await ensureGrammar(
+        now(),
+        typeof version === "string" ? version : void 0
+      );
+      lines.push(
+        grammar2 ? `grammar: ${grammar2.version} (${grammar2.words.length} phrases, ${grammar2.paths.length} paths)` : "grammar: none cached"
+      );
+    } else {
+      lines.push(
+        `server: ${ping.reason}${ping.detail ? ` (${ping.detail})` : ""} after ${ping.ms}ms`
+      );
+      failures += 1;
+    }
+  }
+  lines.push(
+    config.nextEligibleAt && config.nextEligibleAt > now() ? `quiet until: ${iso(config.nextEligibleAt)}` : "quiet until: now (eligible)"
+  );
+  lines.push(
+    config.lastFailure ? `last failure: ${config.lastFailure} at ${config.lastFailureAt ? iso(config.lastFailureAt) : "?"}` : "last failure: none"
+  );
+  lines.push(
+    config.lastQuiet ? `last quiet: ${config.lastQuiet} at ${config.lastQuietAt ? iso(config.lastQuietAt) : "?"}` : "last quiet: none"
+  );
+  const missing = allowlistMissing();
+  lines.push(
+    missing.length === 0 ? "claude allowlist: complete" : `claude allowlist: missing ${missing.join(", ")} (run npx atomicreps connect)`
+  );
+  lines.push(claudeAvailable() ? "claude cli: found" : "claude cli: not found");
+  plain(lines);
+  return failures === 0 ? 0 : 1;
+}
+function menuItem(key) {
+  const pressed = isEnter(key) ? "enter" : key;
+  return MENU.find((item) => item.key === pressed);
+}
+function hiddenCursor() {
+  process.stdout.write(HIDE_CURSOR);
+  const restore = () => process.stdout.write(`${SHOW_CURSOR}
+`);
+  process.on("exit", restore);
+  return {
+    [Symbol.dispose]: () => {
+      process.off("exit", restore);
+      restore();
+    }
+  };
+}
+async function home() {
+  var _stack = [];
+  try {
+    const _cursor = __using(_stack, hiddenCursor());
+    if (!readConfig().token) {
+      out(
+        withLoop("idle", [
+          title("Atomic Reps, in your terminal."),
+          "One short question about the thing you just built.",
+          "",
+          keyHint([
+            ["enter", "sign in"],
+            ["q", "quit"]
+          ])
+        ])
+      );
+      const key = await readKey();
+      if (isBack(key)) return;
+      const ok = await login();
+      if (!ok) return;
+    }
+    for (; ; ) {
+      const summary = await fetchSummary();
+      if (!summary) {
+        out(
+          withLoop("facepalm", [
+            title("Could not reach the server."),
+            "Check your connection, or run: npx atomicreps doctor",
+            "",
+            keyHint([
+              ["r", "retry"],
+              ["q", "quit"]
+            ])
+          ])
+        );
+        const key2 = await readKey();
+        if (key2 === "r") continue;
+        return;
+      }
+      out([
+        ...withLoop(summary.answeredToday > 0 ? "impressed" : "idle", summaryLines(summary)),
+        "",
+        rule(),
+        keyHint(MENU.slice(0, 6).map((item) => [item.key, item.label])),
+        keyHint([
+          ...MENU.slice(6).map((item) => [item.key, item.label]),
+          ["o", "sign out"],
+          ["q", "quit"]
+        ]),
+        ...summary.isPro || !summary.upgradeUrl ? [] : [
+          "",
+          paint(
+            `Pro asks the hard ones, on the stack you actually run. ${summary.upgradeUrl}`,
+            "faint"
+          )
+        ]
+      ]);
+      const key = await readKey();
+      if (isBack(key)) return;
+      if (key === "o") {
+        writeConfig({});
+        out(withLoop("sleeping", [title("Signed out."), "Run npx atomicreps to sign in again."]));
+        return;
+      }
+      await menuItem(key)?.run(summary);
+    }
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+var PREFER_KEYS, MENU;
+var init_tui = __esm({
+  "src/tui.ts"() {
+    "use strict";
+    init_ansi();
+    init_api();
+    init_clock();
+    init_config();
+    init_connect();
+    init_constants();
+    init_format();
+    init_infer();
+    init_install();
+    init_screen();
+    init_store();
+    init_types();
+    PREFER_KEYS = TOGGLE_KEYS.slice(0, 13);
+    MENU = [
+      { key: "enter", label: "one rep now", run: () => repScreen() },
+      { key: "t", label: "this session", run: () => sessionScreen() },
+      { key: "s", label: "skills", run: () => skillsScreen() },
+      { key: "m", label: "mutes", run: () => mutesScreen() },
+      { key: "p", label: "prefer", run: (summary) => preferScreen(summary.prefer) },
+      { key: "i", label: "intensity", run: (summary) => settingsScreen(summary) },
+      { key: "c", label: "connect an editor", run: () => connect(true) },
+      {
+        key: "d",
+        label: "doctor",
+        run: async () => {
+          process.stdout.write(CLEAR);
+          await doctor();
+          await pause();
+        }
+      }
+    ];
+  }
+});
+
+// src/install.ts
+function mark(on) {
+  return on ? DOT_ON : DOT_OFF;
+}
+function columns(rows, width = TEXT_WIDTH) {
+  if (rows.length <= 7) return rows;
+  const half = Math.ceil(rows.length / 2);
+  const left = rows.slice(0, half);
+  const right = rows.slice(half);
+  const pad = Math.floor(width / 2);
+  return left.map((row, i) => {
+    const gap = " ".repeat(Math.max(2, pad - visibleWidth(row)));
+    return `${row}${gap}${right[i] ?? ""}`;
+  });
+}
+function paragraph(text) {
+  return wrap(text, TEXT_WIDTH).map((line) => paint(line, "faint"));
+}
+async function sentScreen() {
+  out(withLoop("thinking", [title("Reading this working tree\u2026")]));
+  const grammar2 = await ensureGrammar();
+  const hints = await inferHints(process.cwd(), TUI_INFER_BUDGET_MS, grammar2);
+  const touched = hints.touched.slice(0, TOUCHED_SHOWN);
+  const rows = touched.length > 0 ? touched.map((t) => `    ${t.key.padEnd(30)} ${paint(`\xB7${t.weight}`, "gold")}`) : paragraph(
+    grammar2 === null ? "    Topic names resolve after you sign in; the rest below is read here on your machine." : "    Nothing touched yet, so a rep would follow your settings instead."
+  );
+  const line = (label, values) => {
+    if (values.length === 0) return [];
+    const wrapped = wrap(values.join(", "), TEXT_WIDTH - 16);
+    return wrapped.map(
+      (part, i) => `    ${paint((i === 0 ? label : "").padEnd(12), "faint")}${part}`
+    );
+  };
+  out([
+    ...withLoop("idle", [
+      title("What gets sent."),
+      "",
+      ...paragraph(
+        "Everything below is what this repo would put on the wire right now. Shapes are file extensions and top-level folder names."
+      ),
+      ""
+    ]),
+    ...rows,
+    "",
+    ...line("packages", hints.packages.slice(0, 8)),
+    ...line("shapes", hints.extensions.slice(0, 10)),
+    "",
+    ...paragraph(SENT_NOTE)
+  ]);
+  await pause();
+}
+async function areasScreen(draft) {
+  const domains = (await domainCatalog()).slice(0, TOGGLE_KEYS.length);
+  if (domains.length === 0) {
+    out(
+      withLoop("facepalm", [
+        title("Could not load the catalog."),
+        "Check your connection and run npx atomicreps again."
+      ])
+    );
+    await pause();
+    return null;
+  }
+  const chosen = new Set(draft.prefer);
+  for (; ; ) {
+    const rows = domains.map(
+      (d, i) => `${paint(TOGGLE_KEYS[i] ?? "", "coral", "bold")} ${mark(chosen.has(d.slug))} ${d.name}`
+    );
+    out([
+      ...withLoop("idle", [
+        `${title("What are you working on?")}   ${step(1, STEPS)}`,
+        "",
+        ...paragraph(
+          "Pick the areas a rep may come from. Pick none and the whole catalog is in play."
+        ),
+        ""
+      ]),
+      ...columns(rows),
+      "",
+      rule(),
+      keyHint([
+        ["a-n", "toggle"],
+        ["enter", "next"],
+        ["esc", "quit"]
+      ])
+    ]);
+    const key = await readKey();
+    if (isBack(key)) return null;
+    if (isEnter(key)) return { ...draft, prefer: [...chosen] };
+    const index = TOGGLE_KEYS.indexOf(key.toLowerCase());
+    const domain = domains[index];
+    if (!domain) continue;
+    if (chosen.has(domain.slug)) chosen.delete(domain.slug);
+    else chosen.add(domain.slug);
+  }
+}
+function groupTopics(domains, topics2, prefer) {
+  const wanted = prefer.length > 0 ? new Set(prefer) : null;
+  return domains.filter((d) => wanted === null || wanted.has(d.slug)).map((d) => ({
+    slug: d.slug,
+    name: d.name,
+    topics: topics2.filter((t) => t.domain === d.slug)
+  })).filter((g) => g.topics.length > 0);
+}
+async function expandArea(group, pinned) {
+  const shown = group.topics.slice(0, TOGGLE_KEYS.length);
+  for (; ; ) {
+    const rows = shown.map(
+      (t, i) => `${paint(TOGGLE_KEYS[i] ?? "", "coral", "bold")} ${mark(pinned.has(t.slug))} ${t.name}`
+    );
+    out([
+      ...withLoop("thinking", [
+        `${title(group.name)}   ${step(2, STEPS)}`,
+        "",
+        ...paragraph("Pin the ones you want. Pin none and the whole area is in play."),
+        ""
+      ]),
+      ...columns(rows),
+      "",
+      rule(),
+      keyHint([
+        ["a-z", "toggle"],
+        ["*", "all"],
+        ["-", "none"],
+        ["enter", "done"]
+      ])
+    ]);
+    const key = await readKey();
+    if (isEnter(key) || isBack(key)) return;
+    if (key === "*") {
+      for (const t of shown) pinned.add(t.slug);
+      continue;
+    }
+    if (key === "-") {
+      for (const t of shown) pinned.delete(t.slug);
+      continue;
+    }
+    const topic = shown[TOGGLE_KEYS.indexOf(key.toLowerCase())];
+    if (!topic) continue;
+    if (pinned.has(topic.slug)) pinned.delete(topic.slug);
+    else pinned.add(topic.slug);
+  }
+}
+async function topicsScreen(draft) {
+  const groups = groupTopics(await domainCatalog(), await topicCatalog(), draft.prefer);
+  if (groups.length === 0) return draft;
+  const pinned = new Set(draft.topics);
+  for (; ; ) {
+    const shown = groups.slice(0, TOGGLE_KEYS.length);
+    const rows = shown.map((g, i) => {
+      const picked = g.topics.filter((t) => pinned.has(t.slug)).length;
+      const state = picked === 0 ? paint("all of it", "faint") : paint(`${picked} pinned`, "gold");
+      return `${paint(TOGGLE_KEYS[i] ?? "", "coral", "bold")} ${g.name.padEnd(26)} ${paint(String(g.topics.length).padStart(3), "faint")} topics   ${state}`;
+    });
+    out([
+      ...withLoop("idle", [
+        `${title("Narrow it down, or skip.")}   ${step(2, STEPS)}`,
+        "",
+        ...paragraph(
+          "Open an area to pin single topics inside it. Skipping means everything in the areas you picked."
+        ),
+        ""
+      ]),
+      ...rows,
+      "",
+      rule(),
+      keyHint([
+        [`a-${TOGGLE_KEYS[shown.length - 1] ?? "a"}`, "open"],
+        ["enter", "next"],
+        ["esc", "back"]
+      ])
+    ]);
+    const key = await readKey();
+    if (isBack(key)) return null;
+    if (isEnter(key)) return { ...draft, topics: [...pinned] };
+    const group = shown[TOGGLE_KEYS.indexOf(key.toLowerCase())];
+    if (group) await expandArea(group, pinned);
+  }
+}
+async function cadenceScreen(draft) {
+  for (; ; ) {
+    out([
+      ...withLoop("idle", [
+        `${title("How often should a rep arrive?")}   ${step(3, STEPS)}`,
+        "",
+        ...paragraph(
+          "A rep waits for a finished task, never for a keystroke. The gap is the most it will ever ask."
+        ),
+        ""
+      ]),
+      ...CADENCES.map(
+        (c) => `${paint(c.key, "coral", "bold")} ${mark(c.value === draft.intensity)} ${paint(c.name.padEnd(9), "bold")} ${paint(c.says, "soft")}`
+      ),
+      "",
+      rule(),
+      keyHint([
+        ["0-3", "pick"],
+        ["enter", "next"],
+        ["esc", "back"]
+      ])
+    ]);
+    const key = await readKey();
+    if (isBack(key)) return null;
+    if (isEnter(key)) return draft;
+    const picked = CADENCES.find((c) => c.key === key);
+    if (picked) draft = { ...draft, intensity: picked.value };
+  }
+}
+function bandFrom(first, second) {
+  return first <= second ? { min: first, max: second } : { min: second, max: first };
+}
+async function levelsScreen(draft) {
+  let pending = null;
+  for (; ; ) {
+    const { min, max } = draft.levels;
+    out([
+      ...withLoop("thinking", [
+        `${title("How hard?")}   ${step(4, STEPS)}`,
+        "",
+        ...paragraph(
+          pending === null ? "Press two digits for the two ends of the range, or the same digit twice for one rung." : `From ${pending}. Press the other end.`
+        ),
+        ""
+      ]),
+      ...LEVELS.map(
+        (l) => `${paint(String(l.level), "coral", "bold")} ${mark(l.level >= min && l.level <= max)} ${paint(l.name.padEnd(12), "bold")} ${paint(l.says, "soft")}`
+      ),
+      "",
+      ...paragraph(FREE_LEVEL_NOTE),
+      "",
+      rule(),
+      keyHint([
+        ["1-5", "an end"],
+        ["enter", "next"],
+        ["esc", "back"]
+      ])
+    ]);
+    const key = await readKey();
+    if (isBack(key)) return null;
+    if (isEnter(key)) return draft;
+    const digit = Number(key);
+    if (!Number.isInteger(digit) || digit < 1 || digit > LEVELS.length) continue;
+    if (pending === null) pending = digit;
+    else {
+      draft = { ...draft, levels: bandFrom(pending, digit) };
+      pending = null;
+    }
+  }
+}
+function patchOf(draft) {
+  return {
+    prefer: draft.prefer,
+    topics: draft.topics,
+    intensity: draft.intensity,
+    levels: draft.levels
+  };
+}
+function count(n, one, many = `${one}s`) {
+  return `${n} ${n === 1 ? one : many}`;
+}
+function draftLines(draft, names = /* @__PURE__ */ new Map()) {
+  const cadence = CADENCES.find((c) => c.value === draft.intensity);
+  const areas = draft.prefer.length === 0 ? "the whole catalog" : draft.prefer.map((slug) => names.get(slug) ?? slug).join(", ");
+  const topics2 = draft.topics.length === 0 ? "all of it" : `${count(draft.topics.length, "topic")} pinned`;
+  const { min, max } = draft.levels;
+  const band = min === max ? `level ${min}` : `levels ${min} to ${max}`;
+  return [
+    `Areas: ${areas} \xB7 ${topics2}.`,
+    `Rate: ${cadence?.says ?? draft.intensity}.`,
+    `Depth: ${band}.`
+  ];
+}
+async function runInstall(deps) {
+  for (; ; ) {
+    out([
+      ...withLoop("idle", [
+        title("Atomic Reps, in your coding agent."),
+        "",
+        ...paragraph(WELCOME[0] ?? "")
+      ]),
+      "",
+      ...paragraph(WELCOME[1] ?? ""),
+      "",
+      ...paragraph(WELCOME[2] ?? ""),
+      "",
+      rule(),
+      keyHint([
+        ["enter", "set it up"],
+        ["w", "what gets sent"],
+        ["esc", "quit"]
+      ])
+    ]);
+    const key = await readKey();
+    if (isBack(key)) return false;
+    if (isEnter(key)) break;
+    if (key === "w") await sentScreen();
+  }
+  let draft = DEFAULT_DRAFT;
+  const screens = [areasScreen, topicsScreen, cadenceScreen, levelsScreen];
+  for (let i = 0; i < screens.length; ) {
+    const screen = screens[i];
+    if (screen === void 0) break;
+    const next = await screen(draft);
+    if (next === null) {
+      if (i === 0) return false;
+      i -= 1;
+      continue;
+    }
+    draft = next;
+    i += 1;
+  }
+  out(
+    withLoop("impressed", [
+      `${title("That is the setup.")}   ${step(5, STEPS)}`,
+      "",
+      ...draftLines(draft, new Map((await domainCatalog()).map((d) => [d.slug, d.name]))).map(
+        (line) => paint(line, "soft")
+      ),
+      "",
+      ...paragraph("Signing in saves it to your account, so a second machine starts here."),
+      "",
+      keyHint([["enter", "sign in"]])
+    ])
+  );
+  await readKey();
+  if (!deps.hasToken() && !await deps.login()) return false;
+  const saved = await deps.save(patchOf(draft));
+  out(
+    withLoop(saved.ok ? "celebrating" : "facepalm", [
+      title(saved.ok ? "Saved." : `Could not save (${saved.reason}).`),
+      "",
+      ...saved.ok ? paragraph(saved.value.text) : paragraph("Run npx atomicreps to set it again."),
+      "",
+      keyHint([["enter", "connect an editor"]])
+    ])
+  );
+  await readKey();
+  updateConfig({ setupAt: now() });
+  await deps.connect();
+  return true;
+}
+function needsSetup() {
+  const config = readConfig();
+  return config.setupAt === void 0 && config.token === void 0;
+}
+async function install() {
+  const { connect: connect2, login: login2 } = await Promise.resolve().then(() => (init_tui(), tui_exports));
+  return await runInstall({
+    login: () => login2(true),
+    connect: () => connect2(true),
+    save: (patch) => settings(patch),
+    hasToken: () => readConfig().token !== void 0
+  });
+}
+var DEFAULT_DRAFT, CADENCES, LEVELS, WELCOME, SENT_NOTE, FREE_LEVEL_NOTE, DOT_ON, DOT_OFF;
+var init_install = __esm({
+  "src/install.ts"() {
+    "use strict";
+    init_ansi();
+    init_api();
+    init_clock();
+    init_config();
+    init_constants();
+    init_infer();
+    init_screen();
+    init_store();
+    DEFAULT_DRAFT = {
+      prefer: [],
+      topics: [],
+      intensity: "regular",
+      levels: { min: 1, max: 5 }
+    };
+    CADENCES = [
+      { key: "0", value: "off", name: "off", says: "never; set it up now, turn it on when you want" },
+      { key: "1", value: "light", name: "light", says: "when you finish a task, at most once an hour" },
+      {
+        key: "2",
+        value: "regular",
+        name: "regular",
+        says: "when you finish a task, at most every 20 minutes"
+      },
+      { key: "3", value: "intense", name: "intense", says: "every time you finish a task" }
+    ];
+    LEVELS = [
+      { level: 1, name: "foundations", says: "the thing everyone half-remembers" },
+      { level: 2, name: "working", says: "what you use on a normal day" },
+      { level: 3, name: "deep", says: "the edges that bite in review" },
+      { level: 4, name: "hard", says: "the ones that cost an afternoon" },
+      { level: 5, name: "brutal", says: "you will want the explanation" }
+    ];
+    WELCOME = [
+      "One short question about the thing you just built, while it is still warm. Your agent never writes it. Every question is authored and reviewed long before it reaches you.",
+      "What leaves this machine is a list of topic names, the packages you depend on, and the file extensions and top-level folders you touched. Never your code, never your prompts.",
+      "AI makes the work faster. How the work feels is part of the evidence too: atomicreps.com/research/the-human-cost"
+    ];
+    SENT_NOTE = "That is the whole of it. We choose the question from those names and the settings you pick next. More at atomicreps.com/docs/data-flows";
+    FREE_LEVEL_NOTE = "Free accounts are served level 1. Level 2 and up come with Pro, a team seat or a school seat, and the band you set here is waiting the day one lands.";
+    DOT_ON = paint("\u25CF", "gold");
+    DOT_OFF = paint("\xB7", "faint");
+  }
+});
+
+// src/cli.ts
+init_config();
+init_constants();
+
+// src/hook.ts
+init_api();
+init_clock();
+init_config();
+init_constants();
+init_format();
+init_infer();
+init_store();
+init_touch();
+init_types();
+var LETTER = /^\s*([A-Da-d])(?:[.):]|\s|$)/;
+var DIGIT = /^\s*([1-3])(?:[.):]|\s|$)/;
+var REP_ETIQUETTE = "A rep for the person at the keyboard arrived from Atomic Reps. After you finish answering their message, append the block below verbatim as the last thing you write. Do not solve it, hint at it, or comment on it. If their next message is a single letter, the hook grades it. This block is the only rep this turn; never write one yourself.";
+var QUIET_CONTEXT = "Atomic Reps: no rep this turn. Write no rep block and say nothing about this. A rep exists only as text the hook or the rep tool hands you; never compose, complete or paraphrase one.";
+var VERDICT_ETIQUETTE = "The person just answered their pending rep and the verdict is below. Relay the block verbatim as your whole reply, nothing before or after.";
+var ASKED_ETIQUETTE = "The person asked for another rep by number and it is below. Relay the block verbatim as your whole reply, nothing before or after. If their next message is a single letter, the hook grades it.";
+function context(text) {
+  return {
+    hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: text }
+  };
+}
+function quiet() {
+  return context(QUIET_CONTEXT);
+}
+function parseInput(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return typeof parsed === "object" && parsed !== null ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function letterOf(prompt) {
+  if (prompt.length > MAX_SHORT_PROMPT_CHARS) return null;
+  return asPick(LETTER.exec(prompt)?.[1]);
+}
+function digitOf(prompt) {
+  if (prompt.length > MAX_SHORT_PROMPT_CHARS) return null;
+  const match = DIGIT.exec(prompt);
+  return match?.[1] === void 0 ? null : Number(match[1]);
+}
+async function gradeLetter(pick, id, now2) {
+  const result = await answer(id, pick);
+  if (!result.ok) return quiet();
+  const data = result.value.data ?? {};
+  observeClient(result.value.client, now2);
+  observeVerdict(id, data, result.value.text, now2);
+  if (data.status === "not_served" || data.status === "rate_limited") return quiet();
+  return context(`${VERDICT_ETIQUETTE}
+
+${result.value.text}`);
+}
+async function handOver(result, etiquette, now2) {
+  if (!result.ok) return quiet();
+  const data = result.value.data ?? {};
+  observeClient(result.value.client, now2);
+  observeRep(data, result.value.text, now2);
+  if (data.kind !== "question" && data.kind !== "insight") return quiet();
+  if (!isRepBlock(result.value.text)) return quiet();
+  return context(`${etiquette}
+
+${result.value.text}`);
+}
+async function fetchRep(cwd, now2) {
+  const hints = await inferHints(cwd, INFER_BUDGET_MS, cachedGrammar());
+  if (allMuted(hints.touched, cachedMuteKeys(now2))) return quiet();
+  const result = await rep({ hints, kind: "auto" }, HOOK_DEADLINE_MS);
+  if (!result.ok) updateConfig({ nextEligibleAt: now2 + DEGRADED_BACKOFF_MS });
+  return await handOver(result, REP_ETIQUETTE, now2);
+}
+function decide(input, state, now2) {
+  if (input.hook_event_name !== void 0 && input.hook_event_name !== "UserPromptSubmit") {
+    return { kind: "ignore" };
+  }
+  if (!state.hasToken) return { kind: "quiet" };
+  const prompt = input.prompt ?? "";
+  const letter = letterOf(prompt);
+  if (letter && state.pending) return { kind: "grade", id: state.pending.id, pick: letter };
+  const digit = digitOf(prompt);
+  const entry = digit === null || state.pending ? void 0 : state.offer[digit - 1];
+  if (entry) return { kind: "take", handle: entry.handle };
+  if (state.nextEligibleAt !== void 0 && state.nextEligibleAt > now2) return { kind: "quiet" };
+  if (state.pending) return { kind: "quiet" };
+  return { kind: "push", cwd: input.cwd ?? process.cwd() };
+}
+function readState(now2) {
+  const config = readConfig();
+  return {
+    hasToken: Boolean(config.token),
+    nextEligibleAt: config.nextEligibleAt,
+    pending: pendingRep(now2),
+    offer: openOffer(now2)
+  };
+}
+async function perform(action, now2) {
+  switch (action.kind) {
+    case "ignore":
+      return null;
+    case "quiet":
+      return quiet();
+    case "grade":
+      return await gradeLetter(action.pick, action.id, now2);
+    case "take":
+      return await handOver(
+        await rep({ ask: action.handle }, HOOK_DEADLINE_MS),
+        ASKED_ETIQUETTE,
+        now2
+      );
+    case "push":
+      return await fetchRep(action.cwd, now2);
+  }
+}
+async function runHook(raw, now2 = now()) {
+  return await perform(decide(parseInput(raw), readState(now2), now2), now2);
+}
+async function refreshGrammar(now2 = now()) {
+  if (!readConfig().token) return;
+  const held = cachedGrammar();
+  const wanted = cachedGrammarVersion(now2);
+  if (held !== null && (wanted === void 0 || held.version === wanted)) return;
+  await ensureGrammar(now2, wanted, HOOK_DEADLINE_MS);
+}
+
+// src/cli.ts
+init_install();
+
+// src/mcp.ts
+init_clock();
+init_config();
+init_constants();
+init_format();
+init_infer();
+init_store();
+init_types();
+import { createInterface } from "node:readline";
+
+// src/version.ts
+init_files();
+import { join as join5 } from "node:path";
+var MANIFEST = join5(import.meta.dirname, "..", "package.json");
+function readVersion() {
+  const version = readJsonFile(MANIFEST)?.version;
+  return typeof version === "string" ? version : "0.0.0";
+}
+var SERVER_VERSION = readVersion();
+
+// src/mcp.ts
+var FAILURE_KIND = {
+  unauthorized: "terminal",
+  timeout: "transient",
+  network: "transient",
+  server: "transient",
+  closed: "transient",
+  cancelled: "silent"
+};
+function isReportable(reason) {
+  return FAILURE_KIND[reason] !== "silent";
+}
+var EMPTY_LIST = {
+  "tools/list": { tools: [] },
+  "prompts/list": { prompts: [] },
+  "resources/list": { resources: [] },
+  "resources/templates/list": { resourceTemplates: [] }
+};
+function unreachableText(reason) {
+  return `Atomic Reps is unreachable (${reason}). ${DOCTOR_HINT}`;
+}
+var NAMED = {
+  "tools/call": "name",
+  "prompts/get": "name",
+  "resources/read": "uri"
+};
+function log(message) {
+  process.stderr.write(`[atomicreps] ${message}
+`);
+}
+function headerValue(value) {
+  const ascii = /^[\x21-\x7e][\x20-\x7e]*[\x21-\x7e]$|^[\x21-\x7e]$/.test(value);
+  if (ascii && !value.startsWith("=?base64?")) return value;
+  return `=?base64?${Buffer.from(value, "utf8").toString("base64")}?=`;
+}
+var Bridge = class {
+  constructor(write, cwd = process.cwd(), fetchImpl = fetch) {
+    this.write = write;
+    this.cwd = cwd;
+    this.fetchImpl = fetchImpl;
+  }
+  write;
+  cwd;
+  fetchImpl;
+  era = { kind: "opening" };
+  inflight = /* @__PURE__ */ new Map();
+  awaitingClient = /* @__PURE__ */ new Map();
+  serverRequestId = 0;
+  async callDoor(message, deadlineMs, signal) {
+    const token2 = readConfig().token;
+    if (!token2) return { ok: false, reason: "unauthorized" };
+    const within2 = within(deadlineMs, signal);
+    const headers = {
+      accept: "application/json, text/event-stream",
+      "content-type": "application/json",
+      authorization: `Bearer ${token2}`,
+      "mcp-protocol-version": MODERN_VERSION,
+      "mcp-method": message.method ?? ""
+    };
+    const field = message.method ? NAMED[message.method] : void 0;
+    const named = field ? message.params?.[field] : void 0;
+    if (typeof named === "string") headers["mcp-name"] = headerValue(named);
+    try {
+      const response = await this.fetchImpl(`${apiOrigin()}/mcp`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(message),
+        signal: within2
+      });
+      if (response.status === 401) return { ok: false, reason: "unauthorized" };
+      if (response.status === 503) return { ok: false, reason: "closed" };
+      if (response.status === 202) return { ok: true, body: {} };
+      let body = {};
+      try {
+        const parsed = JSON.parse(await response.text());
+        if (isRecord(parsed)) body = parsed;
+      } catch {
+        return { ok: false, reason: "server" };
+      }
+      if (!response.ok && body.error === void 0) return { ok: false, reason: "server" };
+      return { ok: true, body };
+    } catch (error) {
+      if (signal?.aborted) return { ok: false, reason: "cancelled" };
+      const expired = Error.isError(error) && error.name === "TimeoutError";
+      return { ok: false, reason: expired ? "timeout" : "network" };
+    }
+  }
+  async roundTrip(id, message, deadlineMs, then) {
+    var _stack = [];
+    try {
+      const controller = new AbortController();
+      const _registered = __using(_stack, this.track(id, controller));
+      const door = await this.callDoor(this.modernize(message), deadlineMs, controller.signal);
+      return then ? await then(door, controller.signal) : door;
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
+  track(id, controller) {
+    const key = String(id);
+    this.inflight.set(key, controller);
+    return {
+      [Symbol.dispose]: () => {
+        this.inflight.delete(key);
+      }
+    };
+  }
+  modernize(message) {
+    const era = this.era;
+    if (era.kind === "modern") return message;
+    const info = era.kind === "legacy" ? era.clientInfo : {};
+    const params = { ...message.params };
+    const meta = isRecord(params._meta) ? { ...params._meta } : {};
+    meta[META_VERSION] = MODERN_VERSION;
+    meta[META_CLIENT_INFO] = { ...info, name: info.name ?? "unknown" };
+    meta[META_CLIENT_CAPABILITIES] = era.kind === "legacy" ? era.clientCapabilities : {};
+    params._meta = meta;
+    return { ...message, params };
+  }
+  legacyResult(result) {
+    if (this.era.kind === "modern") return result;
+    return Object.fromEntries(
+      Object.entries(result).filter(([key]) => !MODERN_ENVELOPE_KEYS.has(key))
+    );
+  }
+  reply(id, result) {
+    this.write({ jsonrpc: "2.0", id, result: this.legacyResult(result) });
+  }
+  fail(id, code, message) {
+    this.write({ jsonrpc: "2.0", id, error: { code, message } });
+  }
+  forward(id, body) {
+    if (body.error) this.write({ jsonrpc: "2.0", id, error: body.error });
+    else if (isRecord(body.result)) this.reply(id, body.result);
+    else this.fail(id, -32e3, "Atomic Reps answered with nothing.");
+  }
+  unreachable(id, method, reason, now2) {
+    noteFailure(`${method}: ${reason}`, now2);
+    switch (FAILURE_KIND[reason]) {
+      case "terminal":
+        this.fail(id, -32001, SIGN_IN_MESSAGE);
+        return;
+      case "transient": {
+        const empty = EMPTY_LIST[method];
+        if (empty) this.reply(id, empty);
+        else this.fail(id, -32e3, unreachableText(reason));
+        return;
+      }
+    }
+  }
+  async handleLine(line) {
+    const trimmed = line.trim();
+    if (trimmed === "") return;
+    let message;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (!isRecord(parsed)) throw new Error("not an object");
+      message = parsed;
+    } catch {
+      this.fail(null, -32700, "Parse error: invalid JSON");
+      return;
+    }
+    if (message.method === void 0) {
+      const key = message.id === void 0 ? void 0 : String(message.id);
+      const waiting = key === void 0 ? void 0 : this.awaitingClient.get(key);
+      if (waiting && key !== void 0) {
+        this.awaitingClient.delete(key);
+        waiting(message);
+      }
+      return;
+    }
+    if (message.id === void 0) {
+      if (message.method === "notifications/cancelled") {
+        const requestId = message.params?.requestId;
+        if (requestId !== void 0) this.inflight.get(String(requestId))?.abort();
+      }
+      return;
+    }
+    await this.handleRequest(message);
+  }
+  async handleRequest(message) {
+    const id = message.id ?? null;
+    const method = message.method ?? "";
+    const params = message.params ?? {};
+    if (method === "initialize") return await this.handleInitialize(id, params);
+    if (method === "server/discover") {
+      const meta = isRecord(params._meta) ? params._meta : {};
+      this.era = {
+        kind: "modern",
+        clientInfo: isRecord(meta[META_CLIENT_INFO]) ? meta[META_CLIENT_INFO] : {},
+        clientCapabilities: isRecord(meta[META_CLIENT_CAPABILITIES]) ? meta[META_CLIENT_CAPABILITIES] : {}
+      };
+    }
+    if (method === "ping" && this.era.kind !== "modern") return this.reply(id, {});
+    if (method === "tools/call") return await this.handleToolCall(id, params);
+    const door = await this.roundTrip(id, message, LOGIN_DEADLINE_MS);
+    if (door.ok) return this.forward(id, door.body);
+    if (isReportable(door.reason)) this.unreachable(id, method, door.reason, now());
+  }
+  async handleInitialize(id, params) {
+    this.era = {
+      kind: "legacy",
+      clientInfo: isRecord(params.clientInfo) ? params.clientInfo : {},
+      clientCapabilities: isRecord(params.capabilities) ? params.capabilities : {}
+    };
+    const requested = params.protocolVersion;
+    const protocolVersion = LEGACY_VERSIONS.find((v) => v === requested) ?? LEGACY_VERSIONS[0];
+    const discover = await this.roundTrip(
+      id,
+      { jsonrpc: "2.0", id: "discover", method: "server/discover", params: {} },
+      LOGIN_DEADLINE_MS
+    );
+    const instructions = discover.ok && typeof discover.body.result?.instructions === "string" ? discover.body.result.instructions : FALLBACK_INSTRUCTIONS;
+    if (!discover.ok) log(`door unreachable at connect (${discover.reason}); serving fallback`);
+    this.write({
+      jsonrpc: "2.0",
+      id,
+      result: {
+        protocolVersion,
+        capabilities: {
+          tools: { listChanged: false },
+          prompts: { listChanged: false },
+          resources: { subscribe: false, listChanged: false },
+          completions: {}
+        },
+        serverInfo: { name: "atomicreps", title: "Atomic Reps", version: SERVER_VERSION },
+        instructions
+      }
+    });
+  }
+  async handleToolCall(id, params) {
+    const name = typeof params.name === "string" ? params.name : "";
+    const args = isRecord(params.arguments) ? { ...params.arguments } : {};
+    const now2 = now();
+    const asked = typeof args.ask === "string" && args.ask !== "" || args.lane === "asked";
+    if (name === "rep" && !asked) {
+      const quietUntil = readConfig().nextEligibleAt;
+      if (typeof quietUntil === "number" && quietUntil > now2) {
+        return this.reply(id, {
+          content: [{ type: "text", text: "" }],
+          structuredContent: { kind: "quiet", reason: "gap", nextEligibleAt: quietUntil }
+        });
+      }
+      if (!isRecord(args.hints))
+        args.hints = await inferHints(this.cwd, INFER_BUDGET_MS, cachedGrammar());
+    }
+    const message = {
+      jsonrpc: "2.0",
+      id,
+      method: "tools/call",
+      params: { ...params, arguments: args }
+    };
+    const deadline2 = name === "rep" && !asked ? CALL_DEADLINE_MS : ANSWER_DEADLINE_MS;
+    const door = await this.roundTrip(
+      id,
+      message,
+      deadline2,
+      (first, signal) => this.answerInputRequests(message, first, signal)
+    );
+    if (!door.ok) {
+      if (door.reason === "cancelled") return;
+      noteFailure(`${name}: ${door.reason}`, now2);
+      if (name !== "rep") {
+        return this.reply(id, {
+          content: [{ type: "text", text: unreachableText(door.reason) }],
+          isError: true
+        });
+      }
+      const nextEligibleAt = now2 + (door.reason === "unauthorized" ? UNAUTHORIZED_BACKOFF_MS : DEGRADED_BACKOFF_MS);
+      updateConfig({ nextEligibleAt });
+      noteQuiet("degraded", door.reason, now2);
+      return this.reply(id, {
+        content: [{ type: "text", text: "" }],
+        structuredContent: {
+          kind: "quiet",
+          reason: "degraded",
+          detail: door.reason,
+          nextEligibleAt
+        }
+      });
+    }
+    if (isRecord(door.body.result)) this.observe(name, args, door.body.result, now2);
+    this.forward(id, door.body);
+  }
+  async answerInputRequests(original, first, signal) {
+    let door = first;
+    for (let round = 1; round <= MAX_INPUT_ROUNDS; round += 1) {
+      if (!door.ok || this.era.kind === "modern") return door;
+      const result = door.body.result;
+      if (result?.resultType !== "input_required") return door;
+      const requests = isRecord(result.inputRequests) ? result.inputRequests : {};
+      const inputResponses = /* @__PURE__ */ Object.create(null);
+      for (const [key, value] of Object.entries(requests)) {
+        if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+        if (!isRecord(value) || typeof value.method !== "string") continue;
+        inputResponses[key] = await this.askClient(
+          value.method,
+          isRecord(value.params) ? value.params : {}
+        );
+      }
+      const requestState = result.requestState;
+      const retry = {
+        jsonrpc: "2.0",
+        id: `${String(original.id)}:retry${round}`,
+        ...original.method === void 0 ? {} : { method: original.method },
+        params: {
+          ...original.params,
+          inputResponses,
+          ...typeof requestState === "string" ? { requestState } : {}
+        }
+      };
+      door = await this.callDoor(this.modernize(retry), LOGIN_DEADLINE_MS, signal);
+    }
+    return door;
+  }
+  askClient(method, params) {
+    const id = `s${++this.serverRequestId}`;
+    const { promise, resolve } = Promise.withResolvers();
+    this.awaitingClient.set(id, (message) => {
+      resolve(isRecord(message.result) ? message.result : { action: "cancel" });
+    });
+    this.write({ jsonrpc: "2.0", id, method, params });
+    return promise;
+  }
+  observe(name, args, result, now2) {
+    const data = isRecord(result.structuredContent) ? result.structuredContent : {};
+    const textBlock = Array.isArray(result.content) ? result.content.find((c) => isRecord(c) && c.type === "text") : void 0;
+    const text = isRecord(textBlock) && typeof textBlock.text === "string" ? textBlock.text : "";
+    if (name === "rep") observeRep(data, text, now2);
+    if (name === "answer")
+      observeVerdict(typeof args.id === "string" ? args.id : void 0, data, text, now2);
+    if (name === "me" && data.show === "summary") writeStatusCache(data, now2);
+    if (name === "settings" && typeof args.muteMinutes === "number" && args.muteMinutes > 0) {
+      updateConfig({
+        nextEligibleAt: now2 + Math.min(args.muteMinutes, MAX_MUTE_MINUTES) * MS_PER_MINUTE
+      });
+    }
+  }
+};
+function serve() {
+  const bridge = new Bridge((message) => {
+    process.stdout.write(`${JSON.stringify(message)}
+`);
+  });
+  process.stdout.on("error", (error) => {
+    if (error.code === "EPIPE") process.exit(0);
+  });
+  const lines = createInterface({ input: process.stdin, crlfDelay: Infinity });
+  let chain = Promise.resolve();
+  lines.on("line", (line) => {
+    chain = chain.then(() => bridge.handleLine(line)).catch((error) => {
+      log(`bridge: ${Error.isError(error) ? error.message : String(error)}`);
+    });
+  });
+  lines.on("close", () => process.exit(0));
+  log(`bridge to ${apiOrigin()} on stdio (${SERVER_VERSION})`);
+}
+
+// src/cli.ts
+init_screen();
+
+// src/statusline.ts
+init_clock();
+init_config();
+init_store();
+var FACE_READY = "(\u2022\u203F\u2022)";
+var FACE_PENDING = "(\u2022_\u2022)?";
+var FACE_QUIET = "(-_-)";
+function statusLine(now2 = now()) {
+  const config = readConfig();
+  if (!config.token) return `${FACE_QUIET} atomicreps: not signed in`;
+  const streak = streakForStatus(now2);
+  const streakPart = streak === null ? "" : `  streak ${streak}`;
+  const pending = pendingRep(now2);
+  if (pending) return `${FACE_PENDING} rep pending, answer with a letter${streakPart}`;
+  if (config.nextEligibleAt !== void 0 && config.nextEligibleAt > now2) {
+    return `${FACE_QUIET} quiet until ${hhmm(config.nextEligibleAt)}${streakPart}`;
+  }
+  return `${FACE_READY} rep ready${streakPart}`;
+}
+
+// src/cli.ts
+init_tui();
+var HELP = `atomicreps - one short rep about the thing you just built, inside your coding agent.
+
+  npx atomicreps            the terminal surface: you, this session, topics, mutes, rate
+  npx atomicreps setup      the first-run wizard: areas, topics, how often, how hard
+  npx atomicreps login      sign in from a browser with a typed code
+  npx atomicreps connect    add the server to Claude Code (user scope) and print the Cursor config
+  npx atomicreps mcp        the stdio bridge to the door (what the editor launches)
+  npx atomicreps doctor     token, server ping, quiet clock, allowlist
+  npx atomicreps logout     forget the token on this machine
+  npx atomicreps hook       the Claude Code plugin's UserPromptSubmit hook (stdin JSON in, context out)
+  npx atomicreps statusline one line for a Claude Code status line
+
+Add --alpha to any command to use the staging door instead of the live one.
+Alpha keeps its own token and cache, so both can be signed in at once.
+
+Env: ATOMICREPS_API, ATOMICREPS_SITE, ATOMICREPS_CHANNEL=alpha, NO_COLOR.
+`;
+function pluginHint() {
+  if (!process.env.CLAUDECODE || process.env[ENV.pluginHint] !== "1") return;
+  process.stderr.write(
+    '<claude-code-hint v="1" type="plugin" value="atomicreps@claude-plugins-official" />\n'
+  );
+}
+function readStdin() {
+  return new Promise((resolve) => {
+    let raw = "";
+    if (process.stdin.isTTY) return resolve("");
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => raw += chunk);
+    process.stdin.on("end", () => resolve(raw));
+    process.stdin.on("error", () => resolve(raw));
+  });
+}
+function takeChannel(argv) {
+  const flagged = argv.includes("--alpha");
+  if (flagged || process.env[ENV.channel] === "alpha") setChannel("alpha");
+  return argv.filter((arg) => arg !== "--alpha");
+}
+async function main(raw) {
+  const argv = takeChannel(raw);
+  const [command] = argv;
+  switch (command) {
+    case "mcp":
+      serve();
+      return -1;
+    case "login": {
+      const ok = await login(isInteractive());
+      if (ok) process.stdout.write("Signed in. Run npx atomicreps connect to wire an editor.\n");
+      if (ok) pluginHint();
+      return ok ? 0 : 1;
+    }
+    case "hook": {
+      try {
+        const [output] = await Promise.all([runHook(await readStdin()), refreshGrammar()]);
+        if (output) process.stdout.write(`${JSON.stringify(output)}
+`);
+      } catch {
+      }
+      return 0;
+    }
+    case "statusline":
+      process.stdout.write(`${statusLine()}
+`);
+      return 0;
+    case "version":
+    case "--version":
+    case "-v":
+      process.stdout.write(`${SERVER_VERSION}
+`);
+      return 0;
+    case "setup":
+      if (!isInteractive()) {
+        process.stdout.write("Setup needs a terminal. Run npx atomicreps setup by hand.\n");
+        return 1;
+      }
+      return await install() ? 0 : 1;
+    case "connect":
+      if (!readConfig().token) {
+        process.stdout.write("Not signed in yet. Run npx atomicreps login first.\n");
+        return 1;
+      }
+      await connect(false);
+      return 0;
+    case "doctor":
+      return await doctor();
+    case "logout": {
+      writeConfig({});
+      process.stdout.write("Signed out on this machine.\n");
+      return 0;
+    }
+    case "help":
+    case "--help":
+    case "-h":
+      process.stdout.write(HELP);
+      pluginHint();
+      return 0;
+    case void 0:
+      if (isInteractive()) {
+        if (needsSetup()) await install();
+        else await home();
+        return 0;
+      }
+      process.stdout.write(HELP);
+      return readConfig().token ? await doctor() : 1;
+    default:
+      process.stderr.write(`Unknown command: ${command}
+
+${HELP}`);
+      return 2;
+  }
+}
+main(process.argv.slice(2)).then(
+  (code) => {
+    if (code >= 0) process.exit(code);
+  },
+  (error) => {
+    process.stderr.write(`[atomicreps] ${Error.isError(error) ? error.message : String(error)}
+`);
+    process.exit(1);
+  }
+);