@amdahl/cli 0.3.2 → 0.3.4

package/dist/amdahl.js

@@ -315,8 +315,8 @@ var require_directives = __commonJS({
               if (parts.length < 2)
                 return false;
             }
-            const [handle, prefix] = parts;
-            this.tags[handle] = prefix;
+            const [handle, prefix2] = parts;
+            this.tags[handle] = prefix2;
             return true;
           }
           case "%YAML": {
@@ -366,10 +366,10 @@ var require_directives = __commonJS({
         const [, handle, suffix] = source.match(/^(.*!)([^!]*)$/s);
         if (!suffix)
           onError(`The ${source} tag has no suffix`);
-        const prefix = this.tags[handle];
-        if (prefix) {
+        const prefix2 = this.tags[handle];
+        if (prefix2) {
           try {
-            return prefix + decodeURIComponent(suffix);
+            return prefix2 + decodeURIComponent(suffix);
           } catch (error) {
             onError(String(error));
             return null;
@@ -385,9 +385,9 @@ var require_directives = __commonJS({
        * taking into account current tag prefixes and defaults.
        */
       tagString(tag) {
-        for (const [handle, prefix] of Object.entries(this.tags)) {
-          if (tag.startsWith(prefix))
-            return handle + escapeTagName(tag.substring(prefix.length));
+        for (const [handle, prefix2] of Object.entries(this.tags)) {
+          if (tag.startsWith(prefix2))
+            return handle + escapeTagName(tag.substring(prefix2.length));
         }
         return tag[0] === "!" ? tag : `!<${tag}>`;
       }
@@ -404,11 +404,11 @@ var require_directives = __commonJS({
           tagNames = Object.keys(tags);
         } else
           tagNames = [];
-        for (const [handle, prefix] of tagEntries) {
-          if (handle === "!!" && prefix === "tag:yaml.org,2002:")
+        for (const [handle, prefix2] of tagEntries) {
+          if (handle === "!!" && prefix2 === "tag:yaml.org,2002:")
             continue;
-          if (!doc || tagNames.some((tn) => tn.startsWith(prefix)))
-            lines.push(`%TAG ${handle} ${prefix}`);
+          if (!doc || tagNames.some((tn) => tn.startsWith(prefix2)))
+            lines.push(`%TAG ${handle} ${prefix2}`);
         }
         return lines.join("\n");
       }
@@ -443,14 +443,14 @@ var require_anchors = __commonJS({
       });
       return anchors;
     }
-    function findNewAnchor(prefix, exclude) {
+    function findNewAnchor(prefix2, exclude) {
       for (let i = 1; true; ++i) {
-        const name = `${prefix}${i}`;
+        const name = `${prefix2}${i}`;
         if (!exclude.has(name))
           return name;
       }
     }
-    function createNodeAnchors(doc, prefix) {
+    function createNodeAnchors(doc, prefix2) {
       const aliasObjects = [];
       const sourceObjects = /* @__PURE__ */ new Map();
       let prevAnchors = null;
@@ -458,7 +458,7 @@ var require_anchors = __commonJS({
         onAnchor: (source) => {
           aliasObjects.push(source);
           prevAnchors ?? (prevAnchors = anchorNames(doc));
-          const anchor = findNewAnchor(prefix, prevAnchors);
+          const anchor = findNewAnchor(prefix2, prevAnchors);
           prevAnchors.add(anchor);
           return anchor;
         },
@@ -2451,10 +2451,10 @@ var require_int = __commonJS({
     var stringifyNumber = require_stringifyNumber();
     var intIdentify = (value) => typeof value === "bigint" || Number.isInteger(value);
     var intResolve = (str2, offset, radix, { intAsBigInt }) => intAsBigInt ? BigInt(str2) : parseInt(str2.substring(offset), radix);
-    function intStringify(node, radix, prefix) {
+    function intStringify(node, radix, prefix2) {
       const { value } = node;
       if (intIdentify(value) && value >= 0)
-        return prefix + value.toString(radix);
+        return prefix2 + value.toString(radix);
       return stringifyNumber.stringifyNumber(node);
     }
     var intOct = {
@@ -2916,11 +2916,11 @@ var require_int2 = __commonJS({
       const n = parseInt(str2, radix);
       return sign === "-" ? -1 * n : n;
     }
-    function intStringify(node, radix, prefix) {
+    function intStringify(node, radix, prefix2) {
       const { value } = node;
       if (intIdentify(value)) {
         const str2 = value.toString(radix);
-        return value < 0 ? "-" + prefix + str2.substr(1) : prefix + str2;
+        return value < 0 ? "-" + prefix2 + str2.substr(1) : prefix2 + str2;
       }
       return stringifyNumber.stringifyNumber(node);
     }
@@ -7365,26 +7365,45 @@ var require_dist = __commonJS({
 
 // src/io.ts
 import { spawn } from "child_process";
+import { accessSync, constants, statSync } from "fs";
 import { homedir, hostname } from "os";
 import { createInterface } from "readline";
 
 // src/select.ts
 import { emitKeypressEvents } from "readline";
 var HINT = "(Use the arrow keys, then Enter)";
-var MULTI_HINT = "(Use the arrow keys, Space to tick or untick, then Enter)";
+var MULTI_HINT = "\u2191\u2193 move \xB7 Space tick/untick \xB7 Enter to accept";
 var OFF = "\x1B[0m";
+var GREY = "\x1B[90m";
+var GREY_OFF = "\x1B[39m";
 var HIDE_CURSOR = "\x1B[?25l";
 var SHOW_CURSOR = "\x1B[?25h";
 var CLEAR_LINE = "\x1B[2K";
 var CLEAR_DOWN = "\x1B[0J";
-var up = (n) => `\x1B[${n}A`;
-function runMenu(input, output, question, hint, rows, onKey) {
-  const draw = () => rows().map((r) => `${CLEAR_LINE}\r${r}
-`).join("") + `${CLEAR_LINE}\r${hint}
-`;
-  const height = rows().length;
+var up = (n) => n > 0 ? `\x1B[${n}A` : "";
+var ESCAPES = /\u001b\[[0-9;?]*[A-Za-z]|\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)/g;
+function eraseUp(lines) {
+  return `\r${up(lines)}${CLEAR_DOWN}`;
+}
+function screenLines(text2, columns) {
+  const width = [...text2.replace(ESCAPES, "")].length;
+  if (!columns || columns < 1) return 1;
+  return Math.max(1, Math.ceil(width / columns));
+}
+function runMenu(input, output, head, rows, onKey) {
+  const { question, note, hint } = head;
+  const width = () => head.columns?.();
+  let headLines = 0;
+  let drawn = 0;
+  const frame = () => {
+    const cols = width();
+    const lines = [...rows(), ...fitHint(hint, cols)];
+    drawn = lines.reduce((n, line) => n + screenLines(line, cols), 0);
+    return lines.map((line) => `${CLEAR_LINE}\r${line}
+`).join("");
+  };
   const wasRaw = input.isRaw === true;
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     let done = false;
     const finish = (outcome) => {
       if (done) return;
@@ -7398,19 +7417,22 @@ function runMenu(input, output, question, hint, rows, onKey) {
       }
       input.pause();
       if ("pick" in outcome) {
-        output.write(`${up(height + 2)}\r${CLEAR_DOWN}${question} ${outcome.summary}
+        output.write(`\r${up(headLines + drawn)}${CLEAR_DOWN}${question} ${outcome.summary}
 ${SHOW_CURSOR}`);
-        resolve(outcome.pick);
+        resolve2(outcome.pick);
       } else {
-        output.write(SHOW_CURSOR);
+        output.write(`\r${up(headLines + drawn)}${CLEAR_DOWN}${question}
+${SHOW_CURSOR}`);
         reject(outcome.error);
       }
     };
     const onKeypress = (text2, key) => {
       const name = key?.name ?? text2;
-      if (key?.ctrl && (name === "c" || name === "d")) return finish({ error: new PromptCancelled() });
+      if (key?.ctrl && (name === "c" || name === "d") || name === "escape" || name === "q" && !key?.ctrl) {
+        return finish({ error: new PromptCancelled() });
+      }
       const result = onKey(text2, name);
-      if (result === "redraw") output.write(`${up(height + 1)}${draw()}`);
+      if (result === "redraw") output.write(`\r${up(drawn)}${CLEAR_DOWN}${frame()}`);
       else if (result) finish(result);
     };
     const onError = (err) => finish({ error: err });
@@ -7418,8 +7440,11 @@ ${SHOW_CURSOR}`);
     try {
       emitKeypressEvents(input);
       input.setRawMode?.(true);
-      output.write(`${HIDE_CURSOR}${question}
-${draw()}`);
+      const cols = width();
+      const top = [question, ...note ? wrapWords(note, cols) : []];
+      headLines = top.reduce((n, line) => n + screenLines(line, cols), 0);
+      output.write(`${HIDE_CURSOR}${top.map((line) => `${line}
+`).join("")}${frame()}`);
       input.on("keypress", onKeypress);
       input.on("error", onError);
       process.on("SIGINT", onSigint);
@@ -7429,6 +7454,26 @@ ${draw()}`);
     }
   });
 }
+function fitHint(hint, columns) {
+  if (!columns || [...hint].length <= columns) return [hint];
+  const lines = [];
+  for (const part of hint.split(" \xB7 ")) {
+    const last = lines[lines.length - 1];
+    if (last !== void 0 && [...`${last} \xB7 ${part}`].length <= columns) lines[lines.length - 1] = `${last} \xB7 ${part}`;
+    else lines.push(part);
+  }
+  return lines;
+}
+function wrapWords(text2, columns) {
+  if (!columns || [...text2].length <= columns) return [text2];
+  const lines = [];
+  for (const word of text2.split(" ")) {
+    const last = lines[lines.length - 1];
+    if (last !== void 0 && [...`${last} ${word}`].length <= columns) lines[lines.length - 1] = `${last} ${word}`;
+    else lines.push(word);
+  }
+  return lines;
+}
 function marker(options) {
   return options.color ? options.trueColor ? "\x1B[1;38;2;253;75;3m" : "\x1B[1;38;5;202m" : "\x1B[1m";
 }
@@ -7442,7 +7487,7 @@ function selectMenu(input, output, question, choices, options = {}) {
   let current = Math.min(Math.max(options.initial ?? 0, 0), choices.length - 1);
   const on = marker(options);
   const rows = () => choices.map((c, i) => i === current ? `${on}> ${c}${OFF}` : `  ${c}`);
-  return runMenu(input, output, question, HINT, rows, (text2, name) => {
+  return runMenu(input, output, { question, hint: HINT, columns: options.columns }, rows, (text2, name) => {
     if (name === "return" || name === "enter") return { pick: current, summary: choices[current] ?? "" };
     const next = move(current, choices.length, text2, name);
     if (next === null || next === current) return null;
@@ -7451,14 +7496,23 @@ function selectMenu(input, output, question, choices, options = {}) {
   });
 }
 function multiSelectMenu(input, output, question, choices, options = {}) {
-  let current = 0;
   const ticked = choices.map((_, i) => options.ticked?.[i] === true);
-  const on = marker(options);
-  const rows = () => choices.map((c, i) => {
-    const row = `[${ticked[i] ? "x" : " "}] ${c}`;
-    return i === current ? `${on}> ${row}${OFF}` : `  ${row}`;
-  });
-  return runMenu(input, output, question, MULTI_HINT, rows, (text2, name) => {
+  let current = Math.max(ticked.indexOf(true), 0);
+  const pointer = `${marker(options)}>${OFF}`;
+  const pad = Math.max(...choices.map((c) => c.length));
+  const label = (i) => {
+    const tag = options.tags?.[i];
+    const name = choices[i] ?? "";
+    if (!tag) return name;
+    const cols = options.columns?.() ?? Infinity;
+    const grey = options.color ? `${GREY}${tag}${GREY_OFF}` : tag;
+    if (6 + pad + 3 + tag.length <= cols) return `${name.padEnd(pad)}   ${grey}`;
+    if (6 + name.length + 1 + tag.length <= cols) return `${name} ${grey}`;
+    return name;
+  };
+  const rows = () => choices.map((_, i) => `${i === current ? pointer : " "} [${ticked[i] ? "x" : " "}] ${label(i)}`);
+  const head = { question, note: options.note, hint: options.hint ?? MULTI_HINT, columns: options.columns };
+  return runMenu(input, output, head, rows, (text2, name) => {
     if (name === "return" || name === "enter") {
       const picks = choices.flatMap((_, i) => ticked[i] ? [i] : []);
       return { pick: picks, summary: picks.map((i) => choices[i]).join(", ") || "none" };
@@ -7478,6 +7532,42 @@ function multiSelectMenu(input, output, question, choices, options = {}) {
     return "redraw";
   });
 }
+function listenForEnter(input, onEnter, onCancel) {
+  const wasRaw = input.isRaw === true;
+  let done = false;
+  const stop = () => {
+    if (done) return;
+    done = true;
+    input.removeListener("keypress", onKeypress);
+    input.removeListener("error", stop);
+    process.removeListener("SIGINT", cancel);
+    try {
+      input.setRawMode?.(wasRaw);
+    } catch {
+    }
+    input.pause();
+  };
+  const cancel = () => {
+    if (done) return;
+    stop();
+    onCancel();
+  };
+  const onKeypress = (_text, key) => {
+    if (key?.ctrl && key.name === "c") cancel();
+    else if (key?.name === "return" || key?.name === "enter") onEnter();
+  };
+  try {
+    emitKeypressEvents(input);
+    input.setRawMode?.(true);
+    input.on("keypress", onKeypress);
+    input.on("error", stop);
+    process.on("SIGINT", cancel);
+    input.resume();
+  } catch {
+    stop();
+  }
+  return stop;
+}
 
 // src/io.ts
 var PromptCancelled = class extends Error {
@@ -7486,20 +7576,20 @@ var PromptCancelled = class extends Error {
     this.name = "PromptCancelled";
   }
 };
-var runProcess = (command, args, options) => new Promise((resolve) => {
+var runProcess = (command, args, options) => new Promise((resolve2) => {
   let stdout = "";
   let stderr = "";
   let child;
   try {
     child = spawn(command, args, { stdio: ["pipe", "pipe", "pipe"] });
   } catch (err) {
-    resolve({ code: -1, stdout: "", stderr: String(err) });
+    resolve2({ code: -1, stdout: "", stderr: String(err) });
     return;
   }
   child.stdout.on("data", (d) => stdout += d.toString("utf8"));
   child.stderr.on("data", (d) => stderr += d.toString("utf8"));
-  child.on("error", (err) => resolve({ code: -1, stdout, stderr: String(err) }));
-  child.on("close", (code) => resolve({ code: code ?? -1, stdout, stderr }));
+  child.on("error", (err) => resolve2({ code: -1, stdout, stderr: String(err) }));
+  child.on("close", (code) => resolve2({ code: code ?? -1, stdout, stderr }));
   child.stdin.on("error", () => {
   });
   if (options?.input !== void 0) child.stdin.end(options.input);
@@ -7512,7 +7602,7 @@ async function readAllStdin() {
 }
 function promptLine(question) {
   const rl = createInterface({ input: process.stdin, output: process.stderr });
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     let settled = false;
     const cancel = () => {
       if (settled) return;
@@ -7526,7 +7616,7 @@ function promptLine(question) {
     rl.question(question, (answer) => {
       settled = true;
       rl.close();
-      resolve(answer);
+      resolve2(answer);
     });
   });
 }
@@ -7540,6 +7630,15 @@ function uninterruptible(fn) {
     setImmediate(() => process.off("SIGINT", hold));
   }
 }
+function isExecutable(path) {
+  try {
+    if (!statSync(path).isFile()) return false;
+    accessSync(path, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function openerFor(platform, url) {
   if (platform === "darwin") return ["open", [url]];
   if (platform === "win32") return ["cmd", ["/c", "start", '""', url]];
@@ -7557,12 +7656,15 @@ function realIo() {
     prompt: promptLine,
     select: (question, choices, options) => selectMenu(process.stdin, process.stderr, question, choices, {
       ...options,
-      trueColor: /^(truecolor|24bit)$/i.test(process.env.COLORTERM ?? "")
+      trueColor: /^(truecolor|24bit)$/i.test(process.env.COLORTERM ?? ""),
+      columns: () => process.stderr.columns
     }),
     multiSelect: (question, choices, options) => multiSelectMenu(process.stdin, process.stderr, question, choices, {
       ...options,
-      trueColor: /^(truecolor|24bit)$/i.test(process.env.COLORTERM ?? "")
+      trueColor: /^(truecolor|24bit)$/i.test(process.env.COLORTERM ?? ""),
+      columns: () => process.stderr.columns
     }),
+    listenForEnter: (onEnter, onCancel) => listenForEnter(process.stdin, onEnter, onCancel),
     uninterruptible,
     run: runProcess,
     openUrl: async (url) => {
@@ -7570,13 +7672,15 @@ function realIo() {
       return (await runProcess(cmd, args)).code === 0;
     },
     homedir: homedir(),
+    scriptPath: process.argv[1],
+    columns: () => process.stderr.columns,
+    isExecutable,
     cwd: process.cwd(),
     platform: process.platform,
     hostname: hostname(),
     now: () => Date.now(),
     sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
     loginTimeoutMs: 9e5,
-    browserGraceMs: 6e4,
     fetchTimeoutMs: 15e3
   };
 }
@@ -7584,6 +7688,18 @@ function realIo() {
 // src/args.ts
 import { parseArgs } from "util";
 
+// src/command-name.ts
+var prefix = "amdahl";
+function startedByNpx(io) {
+  return io.env.npm_command === "exec" || io.env.npm_lifecycle_event === "npx" || /[\\/]_npx[\\/]/.test(io.scriptPath ?? "");
+}
+function setCommandName(io) {
+  prefix = startedByNpx(io) ? "npx amdahl" : "amdahl";
+}
+function amdahlCommand(rest = "") {
+  return rest ? `${prefix} ${rest}` : prefix;
+}
+
 // src/errors.ts
 var EXIT = {
   ok: 0,
@@ -7620,7 +7736,10 @@ var CliError = class extends Error {
 function usageError(message2, hint) {
   return new CliError("usage", message2, EXIT.usage, hint);
 }
-var NOT_SIGNED_IN = "Not signed in. Run `amdahl login`, or set AMDAHL_KEY.";
+function notSignedIn() {
+  return `Not signed in. Run \`${amdahlCommand("login")}\`, or set AMDAHL_KEY.`;
+}
+var NETWORK_HINT = "Check your internet connection, then run the same command again.";
 var CODE_EXITS = {
   oauth_required: EXIT.forbidden,
   cli_client_required: EXIT.forbidden,
@@ -7658,7 +7777,10 @@ var GLOBAL_OPTIONS = {
   version: { type: "boolean", short: "v" },
   verbose: { type: "boolean" }
 };
+var SETUP_OPTIONS = { "no-browser": { type: "boolean" } };
 var COMMAND_OPTIONS = {
+  setup: SETUP_OPTIONS,
+  help: {},
   login: {
     workspace: { type: "string" },
     "no-browser": { type: "boolean" },
@@ -7711,12 +7833,12 @@ function parseCommandLine(argv) {
   try {
     loose = parseArgs({ args: argv, options: allOptions(), allowPositionals: true, strict: false });
   } catch (err) {
-    throw usageError(err instanceof Error ? err.message : String(err));
+    throw usageError(...parseErrorMessage(err));
   }
   const positionals = loose.positionals;
   const first = positionals[0];
   if (first === void 0) {
-    return { command: null, args: [], flags: strictParse(argv, GLOBAL_OPTIONS).values };
+    return { command: null, args: [], flags: strictParse(argv, { ...GLOBAL_OPTIONS, ...SETUP_OPTIONS }).values };
   }
   let words = 1;
   let name = first;
@@ -7735,7 +7857,7 @@ function parseCommandLine(argv) {
   }
   name = ALIASES[name] ?? name;
   const spec = COMMAND_OPTIONS[name];
-  if (!spec) throw usageError(`Unknown command \`${positionals.slice(0, words).join(" ")}\`.`);
+  if (!spec) throw usageError(`Unknown command \`${positionals.slice(0, words).join(" ")}\`.`, `Run \`${amdahlCommand("--help")}\` to see the commands.`);
   const strict = strictParse(argv, { ...GLOBAL_OPTIONS, ...spec });
   return { command: name, args: strict.positionals.slice(words), flags: strict.values };
 }
@@ -7747,39 +7869,62 @@ function strictParse(argv, options) {
       values: parsed.values
     };
   } catch (err) {
-    throw usageError(err instanceof Error ? err.message : String(err));
+    throw usageError(...parseErrorMessage(err));
   }
 }
+function parseErrorMessage(err) {
+  const message2 = err instanceof Error ? err.message : String(err);
+  const code = err?.code;
+  const help = `Run \`${amdahlCommand("--help")}\`.`;
+  if (code === "ERR_PARSE_ARGS_UNKNOWN_OPTION") {
+    const option = /'(-[^']*)'/.exec(message2)?.[1] ?? message2;
+    return [`Unknown option ${option}.`, help];
+  }
+  if (code === "ERR_PARSE_ARGS_INVALID_OPTION_VALUE") {
+    const option = /'(--?[\w-]+)/.exec(message2)?.[1];
+    if (option && /argument missing/.test(message2)) return [`${option} needs a value.`, help];
+    if (option) return [`${option} takes no value.`, help];
+  }
+  return [message2, help];
+}
 var USAGE = `Usage: amdahl <command> [options]
 
 What you can do:
-  amdahl                         Set up Claude Code, Cursor or Codex, in a terminal: it asks
-                                 which, signs you in, and runs install for each one
-                                 (--verbose shows the files and profile it used)
+  amdahl                         Set up Claude Code, Cursor or Codex. In a
+                                 terminal it asks which and signs you in.
+                                 Run by an agent or with no terminal, it
+                                 sets up that agent, or every client it
+                                 finds, and asks nothing (also: amdahl setup)
   amdahl optimize draft.md       Rewrite an outbound email or LinkedIn message
-  amdahl status                  Check that this workspace is set up to optimize
+  amdahl status                  Check that this workspace can optimize
   amdahl keys create --name ci   Make an API key for a server or CI
-  amdahl install claude-code     Connect your AI client (also codex, cursor)
+  amdahl install claude-code     Connect one AI client (also codex, cursor)
   amdahl skills add <publisher>/<skill>
-                                 Add a skill from https://amdahl.ai/skills to this project:
-                                 its SKILL.md, or its whole folder
-  For everything Amdahl can do: https://docs.amdahl.ai/skills/amdahl/SKILL.md
+                                 Add a skill from https://amdahl.ai/skills
+                                 to this project: its SKILL.md, or its folder
+  Everything Amdahl can do: https://docs.amdahl.ai/skills/amdahl/SKILL.md
 
 Commands:
-  login   [--workspace <slug>] [--no-browser] [--port <n>]   Sign in (alias: auth login)
-  logout  [--all]                                           Sign out (alias: auth logout)
-  whoami  [--show-token]                                    Show who you are (alias: auth status)
-  auth token                                                Print a fresh access token
-  status                                                    Check whether this workspace can optimize
-  optimize [<file>... | -] [--channel email|linkedin] [--evidence off|workspace]
-           [--on-unsupported flag|remove] [--tries] [--context <file.json>]
-  keys create --name <name> [--preset read-only|agent|internal|admin] [--expires 30d|90d|365d] [--no-browser]
+  setup   [--no-browser]                     The guided setup (bare amdahl)
+  login   [--workspace <slug>] [--no-browser] [--port <n>]
+                                             Sign in (alias: auth login)
+  logout  [--all]                            Sign out (alias: auth logout)
+  whoami  [--show-token]                     Who you are (alias: auth status)
+  auth token                                 Print a fresh access token
+  status                                     Can this workspace optimize?
+  optimize [<file>... | -] [--channel email|linkedin]
+           [--evidence off|workspace] [--on-unsupported flag|remove]
+           [--tries] [--context <file.json>]
+  keys create --name <name> [--preset read-only|agent|internal|admin]
+              [--expires 30d|90d|365d] [--no-browser]
   keys list
   keys revoke <id|prefix> [--yes] [--no-browser]
   workspace list | workspace use <profile>
   install claude-code|codex|cursor [--print] [--force]
-  skills add <publisher>/<skill> [-y] [-g] [--agents] [--force] [--accept-warning] [--site <origin>]
-           In a terminal it asks one question: this project (Enter) or every project.
+  skills add <publisher>/<skill> [-y] [-g] [--agents] [--force]
+             [--accept-warning] [--site <origin>]
+           In a terminal it asks one question: this project (Enter) or
+           every project.
            -y        add without asking, to this project
            -g        every project (~/.claude/skills), not just this one
            --agents  also .agents/skills, for Codex, Cursor and other agents
@@ -7789,14 +7934,19 @@ Commands:
                      after printing the warning. Without it, a terminal asks
                      (Cancel or Install anyway); -y, --json or no terminal
                      stops (exit 9)
+  help                                       Show this help
 
 Global options:
-  --profile <name>   Use a saved profile (default: AMDAHL_PROFILE, then the default profile)
-  --api-url <url>    API host (default: AMDAHL_API_URL, then the profile, then https://app.amdahl.ai)
-  --api-key <key>    Use an API key for this command (prefer AMDAHL_KEY: argv is visible to other users)
+  --profile <name>   Use a saved profile (default: AMDAHL_PROFILE, then the
+                     default profile)
+  --api-url <url>    API host (default: AMDAHL_API_URL, then the profile,
+                     then https://app.amdahl.ai)
+  --api-key <key>    Use an API key for this command (prefer AMDAHL_KEY: argv
+                     is visible to other users)
   --json             Data on stdout as JSON, messages on stderr
   --no-color         No colour (NO_COLOR is honoured too)
-  --verbose          Say more: files written, the profile, where the sign-in is stored
+  --verbose          Say more: files written, the profile, where the sign-in
+                     is stored
   -h, --help         Show this help
   -v, --version      Show the version
 `;
@@ -7995,7 +8145,7 @@ async function send(url, init) {
     return await fetch(url, init);
   } catch (err) {
     const message2 = err instanceof Error ? err.message : String(err);
-    throw new CliError("network_error", `Could not reach ${new URL(url).host}: ${message2}`, EXIT.network);
+    throw new CliError("network_error", `Could not reach ${new URL(url).host}: ${message2}`, EXIT.network, NETWORK_HINT);
   }
 }
 async function discover(apiUrl) {
@@ -8106,7 +8256,7 @@ function signInAgainLine(reason, url) {
 function noBusinessMessage(consoleUrl, mayCreate, reason) {
   switch (reason) {
     case void 0:
-      return mayCreate ? `You're signed in, but you don't have a workspace yet. Create one at ${consoleUrl}/new, then run \`amdahl login\` again.` : `You're signed in, but you don't have access yet. Amdahl is in beta: join the waitlist at ${consoleUrl}/new, then run \`amdahl login\` again once you're in.`;
+      return mayCreate ? `You're signed in, but you don't have a workspace yet. Create one at ${consoleUrl}/new, then run \`${amdahlCommand("login")}\` again.` : `You're signed in, but you don't have access yet. Amdahl is in beta: join the waitlist at ${consoleUrl}/new, then run \`${amdahlCommand("login")}\` again once you're in.`;
     case "domain_has_workspace":
       return `Your company already has an Amdahl workspace. Ask its admins to let you in at ${consoleUrl}, then try again.`;
     case "invite_only":
@@ -8142,8 +8292,8 @@ async function startLoopback(io, input) {
   let refused = null;
   let settle;
   let fail;
-  const result = new Promise((resolve, reject) => {
-    settle = resolve;
+  const result = new Promise((resolve2, reject) => {
+    settle = resolve2;
     fail = reject;
   });
   result.catch(() => {
@@ -8159,7 +8309,7 @@ async function startLoopback(io, input) {
       res.end(page(body));
     };
     if (url.searchParams.get("state") !== input.state) {
-      send2(400, "<p>This sign-in did not match the one your terminal started. Run <code>amdahl login</code> again.</p>");
+      send2(400, `<p>This sign-in did not match the one your terminal started. Run <code>${amdahlCommand("login")}</code> again.</p>`);
       fail(new CliError("state_mismatch", "The sign-in response did not match this login (state mismatch).", EXIT.general));
       return;
     }
@@ -8189,7 +8339,7 @@ async function startLoopback(io, input) {
       settle({ kind: "error", error: "invalid_request", description: "The callback carried no code." });
     }
   });
-  await new Promise((resolve, reject) => {
+  await new Promise((resolve2, reject) => {
     server.once(
       "error",
       (err) => reject(
@@ -8201,12 +8351,12 @@ async function startLoopback(io, input) {
         )
       )
     );
-    server.listen(input.port, "127.0.0.1", () => resolve());
+    server.listen(input.port, "127.0.0.1", () => resolve2());
   });
   const port = server.address().port;
   const timer = setTimeout(() => {
     fail(
-      refused ? new CliError("no_business", noBusinessMessage(input.consoleUrl, false, refused), EXIT.noWorkspace) : new CliError("login_timeout", "Timed out waiting for the browser sign-in.", EXIT.general, "Run `amdahl login` again.")
+      refused ? new CliError("no_business", noBusinessMessage(input.consoleUrl, false, refused), EXIT.noWorkspace) : new CliError("login_timeout", "Timed out waiting for the browser sign-in.", EXIT.general, `Run \`${amdahlCommand("login")}\` again.`)
     );
   }, input.timeoutMs);
   timer.unref?.();
@@ -8233,7 +8383,7 @@ function consoleUrlFor(io, apiUrl) {
 }
 
 // src/secrets.ts
-import { chmodSync as chmodSync2, existsSync as existsSync2, readFileSync as readFileSync2, rmSync, statSync } from "fs";
+import { chmodSync as chmodSync2, existsSync as existsSync2, readFileSync as readFileSync2, rmSync, statSync as statSync2 } from "fs";
 import { join as join2 } from "path";
 var KEYCHAIN_SERVICE = "amdahl-cli";
 function keychainAccount(apiUrl, profile) {
@@ -8326,7 +8476,7 @@ function fileStore(io, note) {
   const checkMode = () => {
     if (checked || io.platform === "win32" || !existsSync2(path)) return;
     checked = true;
-    if ((statSync(path).mode & 63) === 0) return;
+    if ((statSync2(path).mode & 63) === 0) return;
     try {
       chmodSync2(path, 384);
     } catch {
@@ -8335,7 +8485,7 @@ function fileStore(io, note) {
       return;
     }
     io.stderr(
-      `Warning: ${path} was readable by other users on this machine. It is private now; to be safe, run \`amdahl logout\` and sign in again.
+      `Warning: ${path} was readable by other users on this machine. It is private now; to be safe, run \`${amdahlCommand("logout")}\` and sign in again.
 `
     );
   };
@@ -8467,7 +8617,7 @@ async function requireOAuthCredential(ctx) {
       "oauth_required",
       `This command needs your own sign-in, but a credential from ${winner === "flag" ? "--api-key" : winner} takes precedence.`,
       EXIT.forbidden,
-      "Unset it and run `amdahl login`."
+      `Unset it and run \`${amdahlCommand("login")}\`.`
     );
   }
   return profileCredential(ctx);
@@ -8475,20 +8625,20 @@ async function requireOAuthCredential(ctx) {
 async function profileCredential(ctx) {
   const { profile, profileName } = ctx;
   if (!profile || !profileName) {
-    throw new CliError("not_signed_in", NOT_SIGNED_IN, EXIT.unauthenticated);
+    throw new CliError("not_signed_in", notSignedIn(), EXIT.unauthenticated);
   }
   if (normaliseApiUrl(profile.api_url) !== ctx.apiUrl) {
     throw new CliError(
       "profile_host_mismatch",
       `Profile "${profileName}" is signed in to ${profile.api_url}, not ${ctx.apiUrl}.`,
       EXIT.usage,
-      "Drop --api-url / AMDAHL_API_URL, or run `amdahl login` against that host."
+      `Drop --api-url / AMDAHL_API_URL, or run \`${amdahlCommand("login")}\` against that host.`
     );
   }
   const account = keychainAccount(profile.api_url, profileName);
   const store = ctx.secrets();
   const secrets = await store.get(account);
-  if (!secrets) throw new CliError("not_signed_in", NOT_SIGNED_IN, EXIT.unauthenticated);
+  if (!secrets) throw new CliError("not_signed_in", notSignedIn(), EXIT.unauthenticated);
   const left = Date.parse(secrets.access_expires_at) - ctx.io.now();
   if (Number.isFinite(left) && left >= 6e4) {
     return { source: "profile", token: secrets.access_token, profile: profileName };
@@ -8500,7 +8650,7 @@ async function profileCredential(ctx) {
       "invalid_grant",
       "Your sign-in has expired.",
       EXIT.unauthenticated,
-      "Run `amdahl login` again."
+      `Run \`${amdahlCommand("login")}\` again.`
     );
   }
   await store.set(account, refreshed);
@@ -8521,16 +8671,16 @@ function errorDetails(body) {
 }
 function toCliError(err) {
   if (err instanceof CliError) return err;
-  if (err instanceof PromptCancelled) return new CliError("cancelled", "Stopped.", EXIT.cancelled);
+  if (err instanceof PromptCancelled) return new CliError("cancelled", "Stopped. Nothing changed.", EXIT.cancelled);
   if (err instanceof AmdahlApiError) {
     const exit = exitForHttp(err.statusCode, err.errorCode);
     const details = errorDetails(err.responseBody);
     const retry = details.retry_after_seconds;
-    const hint = exit === EXIT.unauthenticated ? "Run `amdahl login`, or check AMDAHL_KEY." : typeof retry === "number" ? `Try again in ${retry} seconds.` : void 0;
+    const hint = exit === EXIT.unauthenticated ? `Run \`${amdahlCommand("login")}\`, or check AMDAHL_KEY.` : typeof retry === "number" ? `Try again in ${retry} seconds.` : void 0;
     return new CliError(err.errorCode ?? `http_${err.statusCode}`, err.message, exit, hint);
   }
   const message2 = err instanceof Error ? err.message : String(err);
-  return new CliError("network_error", `Could not reach the Amdahl API: ${message2}`, EXIT.network);
+  return new CliError("network_error", `Could not reach the Amdahl API: ${message2}`, EXIT.network, NETWORK_HINT);
 }
 async function call(fn) {
   try {
@@ -8545,6 +8695,18 @@ var CONTROL_RE = /[\u0000-\u001f\u007f-\u009f]/g;
 function printable(text2) {
   return text2.replace(CONTROL_RE, "");
 }
+var HYPERLINK_TERMINALS = /* @__PURE__ */ new Set(["iTerm.app", "vscode", "WarpTerminal", "Apple_Terminal", "WezTerm", "ghostty"]);
+function supportsHyperlinks(env, color) {
+  if (env.FORCE_HYPERLINK === "0") return false;
+  if (env.FORCE_HYPERLINK === "1") return true;
+  if (!color) return false;
+  if (HYPERLINK_TERMINALS.has(env.TERM_PROGRAM ?? "")) return true;
+  if (Number(env.VTE_VERSION) >= 5e3) return true;
+  return Boolean(env.WT_SESSION);
+}
+function hyperlink(text2, url) {
+  return `\x1B]8;;${printable(url)}\x1B\\${text2}\x1B]8;;\x1B\\`;
+}
 function createOutput(io, json, noColor) {
   const color = !noColor && !io.env.NO_COLOR && io.env.TERM !== "dumb" && io.stderrIsTTY && !json;
   return {
@@ -8593,7 +8755,8 @@ async function browserSignIn(ctx) {
   const endpoints = await discover(ctx.apiUrl);
   const pkce = createPkce();
   const consoleUrl = consoleUrlFor(io, ctx.apiUrl);
-  let timer;
+  let stopKeys = () => {
+  };
   let linkShown = false;
   const loopback = await startLoopback(io, {
     port,
@@ -8602,7 +8765,6 @@ async function browserSignIn(ctx) {
     timeoutMs: io.loginTimeoutMs,
     // The page carries the way on; the authorize link would only sign in as the same address again.
     onSignInAgain: (reason, retry) => {
-      clearTimeout(timer);
       linkShown = true;
       out.info(signInAgainLine(reason, retry));
     }
@@ -8619,18 +8781,30 @@ async function browserSignIn(ctx) {
   ${url}
 `);
     };
+    let cancelled;
+    let fallbackLine = null;
     if (flags["no-browser"]) {
       showLink("Open this URL in a browser to sign in:");
     } else {
       out.info("Opening your browser\u2026");
+      if (!ctx.nonInteractive && io.stderrIsTTY) {
+        const fallback = supportsHyperlinks(io.env, out.color) ? hyperlink("Open the sign-in page", url) : "Press Enter for the link.";
+        fallbackLine = `Browser didn't open? ${fallback}`;
+        out.info(fallbackLine);
+        cancelled = new Promise((_, reject) => {
+          stopKeys = io.listenForEnter(
+            () => showLink("Open this link to sign in:"),
+            () => reject(new PromptCancelled())
+          );
+        });
+      }
       void io.openUrl(url).then((opened) => {
         if (!opened) showLink("Your browser did not open. Open this link to sign in:");
       });
-      timer = setTimeout(() => showLink("Finish in your browser, or open this link:"), io.browserGraceMs);
-      timer.unref?.();
     }
-    const callback = await loopback.result;
-    clearTimeout(timer);
+    const callback = await (cancelled ? Promise.race([loopback.result, cancelled]) : loopback.result);
+    stopKeys();
+    if (fallbackLine && !linkShown && callback.kind === "code") io.stderr(eraseUp(screenLines(fallbackLine, io.columns())));
     linkShown = true;
     if (callback.kind === "no_business") {
       throw new CliError("no_business", noBusinessMessage(consoleUrl, callback.mayCreate, callback.reason), EXIT.noWorkspace);
@@ -8664,7 +8838,7 @@ async function browserSignIn(ctx) {
     ctx.saveConfig();
     return { profile: name, me, workspace: ws };
   } finally {
-    clearTimeout(timer);
+    stopKeys();
     loopback.close();
   }
 }
@@ -8770,8 +8944,8 @@ async function authToken(ctx) {
 }
 
 // src/commands/install.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { dirname, join as join4 } from "path";
+import { chmodSync as chmodSync3, copyFileSync, existsSync as existsSync3, lstatSync, mkdirSync as mkdirSync2, readFileSync as readFileSync3, readlinkSync, realpathSync, renameSync as renameSync2, rmSync as rmSync2, statSync as statSync3, writeFileSync as writeFileSync2 } from "fs";
+import { basename, dirname, join as join4, resolve } from "path";
 
 // src/skill.ts
 import { createHash as createHash2 } from "crypto";
@@ -8825,23 +8999,136 @@ async function onPath(ctx, command) {
   return res.code === 0;
 }
 var CLIENT_SIGNS = {
-  "claude-code": { command: "claude", dir: ".claude" },
-  codex: { command: "codex", dir: ".codex" },
-  cursor: { command: "cursor", dir: ".cursor" }
+  "claude-code": { command: "claude", paths: [".claude", ".claude.json"] },
+  codex: { command: "codex", paths: [".codex"] },
+  cursor: { command: "cursor", paths: [".cursor"] }
 };
 async function detectClients(ctx) {
   const found = await Promise.all(
     CLIENTS.map(async (client) => {
-      const { command, dir } = CLIENT_SIGNS[client];
-      return existsSync3(join4(ctx.io.homedir, dir)) || await onPath(ctx, command);
+      const { command, paths } = CLIENT_SIGNS[client];
+      return paths.some((p) => existsSync3(join4(ctx.io.homedir, p))) || await onPath(ctx, command);
     })
   );
   return Object.fromEntries(CLIENTS.map((client, i) => [client, found[i]]));
 }
-async function claudeHasAmdahl(ctx, mcpUrl) {
-  const res = await ctx.io.run("claude", ["mcp", "get", "amdahl"]);
+function claudeConfigPath(ctx) {
+  return join4(ctx.io.env.CLAUDE_CONFIG_DIR || ctx.io.homedir, ".claude.json");
+}
+var routes = /* @__PURE__ */ new WeakMap();
+function claudeRoute(ctx) {
+  let route = routes.get(ctx);
+  if (!route) {
+    route = findClaude(ctx).then((command) => command ? { kind: "command", command } : { kind: "file", path: claudeConfigPath(ctx) });
+    routes.set(ctx, route);
+  }
+  return route;
+}
+async function findClaude(ctx) {
+  const { io } = ctx;
+  if (await onPath(ctx, "claude")) return "claude";
+  const win = io.platform === "win32";
+  const local = [join4(io.homedir, ".local", "bin", win ? "claude.exe" : "claude"), join4(io.homedir, ".claude", "local", win ? "claude.exe" : "claude")];
+  const system = win ? [] : ["/opt/homebrew/bin/claude", "/usr/local/bin/claude"];
+  const found = [...local, ...system].find((path) => io.isExecutable(path));
+  if (found) return found;
+  if (win) return null;
+  const prefix2 = io.env.npm_config_global_prefix || await npmGlobalPrefix(ctx);
+  const npmClaude = prefix2 ? join4(prefix2, "bin", "claude") : null;
+  return npmClaude && io.isExecutable(npmClaude) ? npmClaude : null;
+}
+async function npmGlobalPrefix(ctx) {
+  const res = await ctx.io.run("npm", ["prefix", "-g"]);
+  const prefix2 = res.code === 0 ? res.stdout.trim() : "";
+  return prefix2 || null;
+}
+async function claudeHasAmdahl(ctx, command, mcpUrl) {
+  const res = await ctx.io.run(command, ["mcp", "get", "amdahl"]);
   return res.code === 0 && res.stdout.split("\n").some((line) => line.trim() === `URL: ${mcpUrl}`);
 }
+var CONFIG_HINT = "Fix the file, or move it away, then run the same command again.";
+function readJsonObject(path) {
+  if (!existsSync3(path)) return { config: {}, existed: false };
+  const raw = readFileSync3(path, "utf8");
+  if (!raw.trim()) return { config: {}, existed: true };
+  let config;
+  try {
+    config = JSON.parse(raw);
+  } catch {
+    throw new CliError("invalid_config", `${path} is not valid JSON; not changing it.`, EXIT.general, CONFIG_HINT);
+  }
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    throw new CliError("invalid_config", `${path} does not hold a JSON object; not changing it.`, EXIT.general, CONFIG_HINT);
+  }
+  return { config, existed: true };
+}
+function readMcpConfig(path) {
+  const { config, existed } = readJsonObject(path);
+  const servers = config.mcpServers;
+  if (servers === void 0) return { config, servers: {}, existed };
+  if (!servers || typeof servers !== "object" || Array.isArray(servers)) {
+    throw new CliError("invalid_config", `The "mcpServers" in ${path} is not a JSON object; not changing it.`, EXIT.general, CONFIG_HINT);
+  }
+  return { config, servers, existed };
+}
+function claudeFileHasAmdahl(path, mcpUrl) {
+  try {
+    const servers = readMcpConfig(path).servers;
+    return servers.amdahl?.url === mcpUrl;
+  } catch {
+    return false;
+  }
+}
+function writeTarget(path) {
+  let target = path;
+  for (let hops = 0; hops < 40; hops++) {
+    let link;
+    try {
+      link = lstatSync(target).isSymbolicLink();
+    } catch {
+      return target;
+    }
+    if (!link) return existsSync3(target) ? realpathSync(target) : target;
+    target = resolve(dirname(target), readlinkSync(target));
+  }
+  throw new CliError("invalid_config", `${path} is a chain of more than 40 symbolic links; not changing it.`, EXIT.general, CONFIG_HINT);
+}
+function writeFileAtomic(path, text2) {
+  const target = writeTarget(path);
+  const mode = existsSync3(target) ? statSync3(target).mode & 511 : 384;
+  mkdirSync2(dirname(target), { recursive: true });
+  const tmp = join4(dirname(target), `.${basename(target)}.amdahl-${process.pid}.tmp`);
+  try {
+    writeFileSync2(tmp, text2, { mode });
+    chmodSync3(tmp, mode);
+    renameSync2(tmp, target);
+  } catch (err) {
+    rmSync2(tmp, { force: true });
+    throw err;
+  }
+}
+function writeClaudeConfig(ctx, path, mcpUrl, command) {
+  return updateConfig(path, () => {
+    const { config, servers, existed } = readMcpConfig(path);
+    const data = { ok: true, client: "claude-code", action: "unchanged", path, command };
+    if (servers.amdahl?.url === mcpUrl) {
+      return { data, human: `${path} already points Claude Code at ${mcpUrl}; nothing changed.`, notes: [] };
+    }
+    config.mcpServers = { ...servers, amdahl: { type: "http", url: mcpUrl } };
+    const backup = `${writeTarget(path)}.amdahl-backup`;
+    ctx.io.uninterruptible(() => {
+      if (existed) copyFileSync(writeTarget(path), backup);
+      writeFileAtomic(path, `${JSON.stringify(config, null, 2)}
+`);
+    });
+    const saved = existed ? ` The file as it was is saved at ${backup}.` : "";
+    return {
+      data: { ...data, action: "wrote", ...existed ? { backup } : {} },
+      human: `Added Amdahl to Claude Code for all your projects, in ${path} (\`claude\` was not found).${saved} Run /mcp in Claude Code to sign in. If amdahl is not listed there, restart Claude Code first.`,
+      notes: []
+    };
+  });
+}
 function updateConfig(path, fn) {
   try {
     return fn();
@@ -8856,7 +9143,11 @@ async function isInstalled(ctx, client) {
   const current = existsSync3(skill) ? readFileSync3(skill, "utf8") : null;
   if (current === null || current !== SKILL_TEXT && isShippedSkill(current)) return false;
   const mcpUrl = `${ctx.apiUrl}/mcp`;
-  if (client === "claude-code") return await onPath(ctx, "claude") && await claudeHasAmdahl(ctx, mcpUrl);
+  if (client === "claude-code") {
+    if (claudeFileHasAmdahl(claudeConfigPath(ctx), mcpUrl)) return true;
+    const route = await claudeRoute(ctx);
+    return route.kind === "command" && await claudeHasAmdahl(ctx, route.command, mcpUrl);
+  }
   if (client === "codex") {
     const path = codexConfigPath(ctx.io.homedir);
     return existsSync3(path) && codexHasAmdahl(readFileSync3(path, "utf8"));
@@ -8914,14 +9205,13 @@ async function installMcp(ctx, client, print) {
   if (client === "claude-code") {
     const args = ["mcp", "add", "--scope", "user", "--transport", "http", "amdahl", mcpUrl];
     const command = `claude ${args.join(" ")}`;
-    if (print || !await onPath(ctx, "claude")) {
-      const notes = print ? [] : ["`claude` is not on your PATH. Run the command above once it is installed."];
-      return { data: { ok: true, client, action: "printed", command }, human: command, notes };
-    }
-    if (await claudeHasAmdahl(ctx, mcpUrl)) {
+    if (print) return { data: { ok: true, client, action: "printed", command }, human: command, notes: [] };
+    const route = await claudeRoute(ctx);
+    if (route.kind === "file") return writeClaudeConfig(ctx, route.path, mcpUrl, command);
+    if (claudeFileHasAmdahl(claudeConfigPath(ctx), mcpUrl) || await claudeHasAmdahl(ctx, route.command, mcpUrl)) {
       return { data: { ok: true, client, action: "unchanged", command }, human: `Claude Code already has Amdahl at ${mcpUrl}; nothing changed.`, notes: [] };
     }
-    const res = await io.run("claude", args);
+    const res = await io.run(route.command, args);
     if (res.code !== 0) {
       throw new CliError("install_failed", `\`${command}\` failed: ${res.stderr.trim() || `exit ${res.code}`}`, EXIT.general);
     }
@@ -8939,9 +9229,8 @@ ${block}`, notes: [] };
       if (codexHasAmdahl(current)) {
         return { data: { ok: true, client, action: "unchanged", path: path2 }, human: `${path2} already has [mcp_servers.amdahl]; nothing changed.`, notes: [] };
       }
-      mkdirSync2(dirname(path2), { recursive: true });
       const sep2 = current.length === 0 ? "" : current.endsWith("\n\n") ? "" : current.endsWith("\n") ? "\n" : "\n\n";
-      writeFileSync2(path2, `${current}${sep2}${block}`);
+      writeFileAtomic(path2, `${current}${sep2}${block}`);
       return { data: { ok: true, client, action: "wrote", path: path2 }, human: `Added Amdahl to ${path2}. Run \`codex mcp login amdahl\` to sign in.`, notes: [] };
     });
   }
@@ -8952,28 +9241,33 @@ ${block}`, notes: [] };
 ${JSON.stringify({ mcpServers: { amdahl: entry } }, null, 2)}`, notes: [] };
   }
   return updateConfig(path, () => {
-    let config = {};
-    if (existsSync3(path)) {
-      const raw = readFileSync3(path, "utf8");
-      if (raw.trim()) {
-        try {
-          config = JSON.parse(raw);
-        } catch {
-          throw new CliError("invalid_config", `${path} is not valid JSON; not changing it.`, EXIT.general);
-        }
-      }
-    }
-    const servers = config.mcpServers && typeof config.mcpServers === "object" ? config.mcpServers : {};
+    const { config, servers } = readMcpConfig(path);
     if (JSON.stringify(servers.amdahl) === JSON.stringify(entry)) {
       return { data: { ok: true, client, action: "unchanged", path }, human: `${path} already points at ${mcpUrl}; nothing changed.`, notes: [] };
     }
     config.mcpServers = { ...servers, amdahl: entry };
-    mkdirSync2(dirname(path), { recursive: true });
-    writeFileSync2(path, `${JSON.stringify(config, null, 2)}
+    writeFileAtomic(path, `${JSON.stringify(config, null, 2)}
 `);
     return { data: { ok: true, client, action: "wrote", path }, human: `Added Amdahl to ${path}. Cursor asks you to sign in on first use.`, notes: [] };
   });
 }
+async function preflight(ctx, client) {
+  let path = null;
+  if (client === "cursor") path = cursorConfigPath(ctx.io.homedir);
+  if (client === "claude-code") {
+    const route = await claudeRoute(ctx);
+    if (route.kind === "file") path = route.path;
+  }
+  if (!path) return null;
+  try {
+    readMcpConfig(path);
+    return null;
+  } catch (err) {
+    if (err instanceof CliError) return err;
+    const reason = err instanceof Error ? err.message : String(err);
+    return new CliError("write_failed", `Could not read ${path} (${reason}).`, EXIT.general);
+  }
+}
 
 // src/keygen.ts
 import { createHash as createHash3, randomBytes as randomBytes2 } from "crypto";
@@ -9041,7 +9335,7 @@ async function waitForDecision(ctx, client, req) {
 }
 async function keysCreate(ctx) {
   const name = str(ctx.flags.name)?.trim();
-  if (!name) throw usageError("--name is required.", 'Example: amdahl keys create --name "CI pipeline"');
+  if (!name) throw usageError("--name is required.", `Example: ${amdahlCommand('keys create --name "CI pipeline"')}`);
   if (name.length > 80) throw usageError("--name must be at most 80 characters.");
   const preset = str(ctx.flags.preset) ?? "read-only";
   const bundle = PRESET_BUNDLES[preset];
@@ -9111,7 +9405,7 @@ function findKey(keys, ref) {
   const matches = keys.filter((k) => ref.length >= 8 && k.key_prefix.startsWith(ref));
   if (matches.length === 1 && matches[0]) return matches[0];
   if (matches.length > 1) throw usageError(`"${ref}" matches ${matches.length} keys. Use the key id.`);
-  throw new CliError("key_not_found", `No active key matches "${ref}".`, EXIT.general, "Run `amdahl keys list`.");
+  throw new CliError("key_not_found", `No active key matches "${ref}".`, EXIT.general, `Run \`${amdahlCommand("keys list")}\`.`);
 }
 async function keysRevoke(ctx, args) {
   const ref = args[0];
@@ -9369,7 +9663,7 @@ import { dirname as dirname3, join as join6, relative, sep } from "path";
 
 // src/commands/skills-install.ts
 import { randomBytes as randomBytes3 } from "crypto";
-import { chmodSync as chmodSync3, lstatSync, mkdirSync as mkdirSync3, mkdtempSync, readdirSync, readFileSync as readFileSync5, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
+import { chmodSync as chmodSync4, lstatSync as lstatSync2, mkdirSync as mkdirSync3, mkdtempSync, readdirSync, readFileSync as readFileSync5, renameSync as renameSync3, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
 import { dirname as dirname2, join as join5 } from "path";
 function skillDirs(targets, name) {
   const dirs = [];
@@ -9396,7 +9690,7 @@ function writeFailure(path, err, written = []) {
 function sameFolder(dir, archive) {
   let top;
   try {
-    top = lstatSync(dir);
+    top = lstatSync2(dir);
   } catch (err) {
     if (err.code === "ENOENT") return null;
     throw writeFailure(dir, err);
@@ -9415,7 +9709,7 @@ function sameFolder(dir, archive) {
         const file = want.get(path);
         if (!file) return false;
         const full = join5(dir, path);
-        if (process.platform !== "win32" && (lstatSync(full).mode & 73 ? 493 : 420) !== file.mode) return false;
+        if (process.platform !== "win32" && (lstatSync2(full).mode & 73 ? 493 : 420) !== file.mode) return false;
         if (!readFileSync5(full).equals(file.bytes)) return false;
       } else {
         return false;
@@ -9434,7 +9728,7 @@ function refuseLinks(dir, file, written = []) {
   for (const part of [dirname2(dirname2(dir)), dirname2(dir), dir, ...file ? [file] : []]) {
     let stat;
     try {
-      stat = lstatSync(part);
+      stat = lstatSync2(part);
     } catch (err) {
       if (err.code === "ENOENT") return;
       throw writeFailure(path, err, written);
@@ -9461,7 +9755,7 @@ function planInstall(dirs, payload) {
     refuseLinks(dir, path);
     let current;
     try {
-      current = lstatSync(path, { throwIfNoEntry: false }) ? readFileSync5(path) : null;
+      current = lstatSync2(path, { throwIfNoEntry: false }) ? readFileSync5(path) : null;
     } catch (err) {
       throw writeFailure(path, err);
     }
@@ -9486,7 +9780,7 @@ function stage(target, name, archive, staged) {
   s.createdParent = mkdirSync3(dirname2(target), { recursive: true }) ?? void 0;
   refuseLinks(target);
   s.temp = mkdtempSync(join5(dirname2(target), `.${name}.amdahl-tmp-`));
-  chmodSync3(s.temp, 493);
+  chmodSync4(s.temp, 493);
   for (const dir of archive.dirs) mkdirSync3(join5(s.temp, dir));
   for (const file of archive.files) writeFileSync3(join5(s.temp, file.path), file.bytes, { flag: "wx", mode: file.mode });
 }
@@ -9494,15 +9788,15 @@ function rollBack(staged) {
   for (const s of [...staged].reverse()) {
     try {
       if (s.swapped) {
-        rmSync2(s.target, { recursive: true, force: true });
-        if (s.backup) renameSync2(s.backup, s.target);
+        rmSync3(s.target, { recursive: true, force: true });
+        if (s.backup) renameSync3(s.backup, s.target);
       } else if (s.backup) {
-        renameSync2(s.backup, s.target);
+        renameSync3(s.backup, s.target);
       }
     } catch {
     }
-    if (s.temp) rmSync2(s.temp, { recursive: true, force: true });
-    if (s.createdParent) rmSync2(s.createdParent, { recursive: true, force: true });
+    if (s.temp) rmSync3(s.temp, { recursive: true, force: true });
+    if (s.createdParent) rmSync3(s.createdParent, { recursive: true, force: true });
   }
 }
 function writeFolders(plan, name, archive) {
@@ -9518,9 +9812,9 @@ function writeFolders(plan, name, archive) {
       current = s.target;
       if (plan.find((p) => p.path === s.target)?.action === "replaced") {
         s.backup = `${s.temp}.old`;
-        renameSync2(s.target, s.backup);
+        renameSync3(s.target, s.backup);
       }
-      renameSync2(s.temp, s.target);
+      renameSync3(s.temp, s.target);
       s.swapped = true;
     }
   } catch (err) {
@@ -9528,7 +9822,7 @@ function writeFolders(plan, name, archive) {
     if (err instanceof CliError) throw err;
     throw writeFailure(current, err);
   }
-  for (const s of staged) if (s.backup) rmSync2(s.backup, { recursive: true, force: true });
+  for (const s of staged) if (s.backup) rmSync3(s.backup, { recursive: true, force: true });
 }
 function writeFiles(plan, body) {
   const written = [];
@@ -9540,9 +9834,9 @@ function writeFiles(plan, body) {
       mkdirSync3(dirname2(p.path), { recursive: true });
       refuseLinks(dirname2(p.path), p.path, written);
       writeFileSync3(temp, body, { flag: "wx", mode: 420 });
-      renameSync2(temp, p.path);
+      renameSync3(temp, p.path);
     } catch (err) {
-      rmSync2(temp, { force: true });
+      rmSync3(temp, { force: true });
       if (err instanceof CliError) throw err;
       throw writeFailure(p.path, err, written);
     }
@@ -9647,16 +9941,51 @@ var SHOWN = [
   { client: "cursor", name: "Cursor" },
   { client: "codex", name: "Codex" }
 ];
-function tryItLine(name, connect = false) {
-  const ask2 = 'say "make this email sound less like AI"';
-  if (connect && name === "Claude Code") return `Try it: in Claude Code, run /mcp once to connect, then ${ask2}`;
-  if (name === "Codex") return `Try it: run \`codex mcp login amdahl\`, then open Codex and ${ask2}`;
-  return `Try it: open ${name} and ${ask2}`;
+var QUESTION = "Where should Amdahl work?";
+var FOUND_TAG = "found on your machine";
+var NONE_FOUND = "We didn't find any of these on this computer. Tick the ones you use.";
+var MENU_HINT = "\u2191\u2193 move \xB7 Space tick/untick \xB7 Enter to install";
+var ASK = 'say "make this email sound less like AI"';
+function finishLines(names, inClaudeCode = false) {
+  const [only] = names;
+  if (only === void 0) return [];
+  if (names.length === 1) {
+    const step2 = {
+      "Claude Code": inClaudeCode ? "Before that, restart Claude Code and run /mcp once to connect Amdahl." : "Before that, run /mcp once in Claude Code to connect Amdahl.",
+      Cursor: "Before that, sign in when Cursor asks, the first time you use Amdahl.",
+      Codex: "Before that, run `codex mcp login amdahl` once to connect Amdahl."
+    };
+    return [`Try it: ${ASK} in ${only}.`, step2[only] ?? ""];
+  }
+  const step = {
+    "Claude Code": inClaudeCode ? "restart it, then run /mcp" : "run /mcp",
+    Cursor: "sign in when it asks, on first use",
+    Codex: "run `codex mcp login amdahl`"
+  };
+  return [`Try it: ${ASK} in any of them.`, "Before that, connect each one once:", ...names.map((n) => `  ${n}: ${step[n] ?? ""}`)];
+}
+var isSet = (value) => Boolean(value) && value !== "false" && value !== "0";
+function ciVariable(env) {
+  const named = ["CI", "JENKINS_URL", "TF_BUILD", "CODEBUILD_BUILD_ID", "TEAMCITY_VERSION", "GITHUB_ACTIONS", "GITLAB_CI", "BUILDKITE", "CIRCLECI"].find((name) => isSet(env[name]));
+  if (named) return named;
+  return isSet(env.BUILD_NUMBER) && isSet(env.JENKINS_HOME) ? "BUILD_NUMBER with JENKINS_HOME" : null;
 }
-function shouldSetUp(io) {
+function setupMode(io) {
   const { env } = io;
-  const ci = Boolean(env.CI) && env.CI !== "false" && env.CI !== "0";
-  return io.stdinIsTTY && io.stdoutIsTTY && io.stderrIsTTY && env.AMDAHL_NO_PROMPT !== "1" && !ci && !env.CLAUDECODE && !env.CURSOR_AGENT;
+  const ci = ciVariable(env);
+  if (ci) return { kind: "usage", reason: `${ci} is set` };
+  if (env.AMDAHL_NO_PROMPT === "1") return { kind: "usage", reason: "AMDAHL_NO_PROMPT=1 is set" };
+  if (env.CLAUDECODE || env.CURSOR_AGENT) return { kind: "agent" };
+  return io.stdinIsTTY && io.stdoutIsTTY && io.stderrIsTTY ? { kind: "menu" } : { kind: "agent" };
+}
+function installLine() {
+  return `To set up a client, run \`${amdahlCommand("install claude-code")}\` (or cursor, codex).`;
+}
+function noSetupLine(reason) {
+  return `Setup did not run: ${reason}.
+${installLine()}
+
+`;
 }
 async function signIn(ctx) {
   let credential;
@@ -9674,7 +10003,32 @@ async function signIn(ctx) {
     return credential.source === "profile" ? { kind: "out" } : { kind: "rejected", source: credential.source };
   }
 }
-async function setup(ctx) {
+function reportError(io, err) {
+  io.stderr(`Error: ${err.message}
+${err.hint ? `${err.hint}
+` : ""}`);
+}
+async function installEach(ctx, clients, detail) {
+  let exit = EXIT.ok;
+  const ready = [];
+  for (const { client, name } of clients) {
+    let steps;
+    try {
+      steps = await installClient(ctx, client, false);
+    } catch (raw) {
+      const err = raw instanceof CliError ? raw : new CliError("install_failed", `Could not set up ${name}: ${raw instanceof Error ? raw.message : String(raw)}`, EXIT.general);
+      reportError(ctx.io, err);
+      if (exit === EXIT.ok) exit = err.exit;
+      continue;
+    }
+    ctx.io.stdout(`${steps.mcp.data.action === "unchanged" ? `\u2713 ${name} already has Amdahl` : `\u2713 Added to ${name}`}
+`);
+    ready.push(name);
+    detail([steps.mcp.human, ...steps.mcp.notes, steps.skill.human, ...steps.skill.notes].filter(Boolean).join("\n"));
+  }
+  return { ready, exit };
+}
+async function setup(ctx, mode) {
   const { io, out } = ctx;
   const verbose = ctx.flags.verbose === true;
   const say = (line) => io.stdout(`${line}
@@ -9682,9 +10036,23 @@ async function setup(ctx) {
   const detail = (text2) => {
     if (verbose && text2) say(text2.replace(/^/gm, "  "));
   };
+  const inClaudeCode = Boolean(io.env.CLAUDECODE);
   say(`${out.bold("Amdahl")} \xB7 predictive ML for GTM`);
   const found = await detectClients(ctx);
   const detected = SHOWN.filter((c) => found[c.client]);
+  if (mode === "agent") {
+    const running = SHOWN.filter((c) => c.client === "claude-code" && io.env.CLAUDECODE || c.client === "cursor" && io.env.CURSOR_AGENT);
+    const targets = running.length > 0 ? running : detected;
+    if (targets.length === 0) {
+      io.stderr(`Didn't find Claude Code, Cursor or Codex on this computer, so nothing changed.
+${installLine()}
+`);
+      return EXIT.general;
+    }
+    const { ready, exit: exit2 } = await installEach(ctx, targets, detail);
+    for (const line of finishLines(ready, inClaudeCode)) say(line);
+    return exit2;
+  }
   let who;
   if (detected.length > 0) {
     const installed = await Promise.all(detected.map((c) => isInstalled(ctx, c.client)));
@@ -9698,20 +10066,38 @@ async function setup(ctx) {
       }
       if (unreachable || who?.kind === "in") {
         say(`You're set up in ${joinNames(detected.map((c) => c.name))}.${unreachable ? " (Could not reach Amdahl to check your sign-in.)" : ""}`);
-        say(tryItLine(detected[0]?.name ?? ""));
+        for (const line of finishLines(detected.map((c) => c.name), inClaudeCode)) say(line);
         return EXIT.ok;
       }
     }
   }
   const picks = await io.multiSelect(
-    "Set up in:",
+    QUESTION,
     SHOWN.map((c) => c.name),
-    { ticked: SHOWN.map((c) => found[c.client]), color: out.color }
+    {
+      ticked: SHOWN.map((c) => found[c.client]),
+      tags: SHOWN.map((c) => found[c.client] ? FOUND_TAG : void 0),
+      note: detected.length === 0 ? NONE_FOUND : void 0,
+      hint: MENU_HINT,
+      color: out.color
+    }
   );
   if (picks.length === 0) {
     say("Nothing picked, so nothing changed.");
     return EXIT.ok;
   }
+  let exit = EXIT.ok;
+  const chosen = [];
+  for (const pick of picks.flatMap((i) => SHOWN[i] ?? [])) {
+    const err = await preflight(ctx, pick.client);
+    if (!err) {
+      chosen.push(pick);
+      continue;
+    }
+    reportError(io, err);
+    if (exit === EXIT.ok) exit = err.exit;
+  }
+  if (chosen.length === 0) return exit;
   who ??= await signIn(ctx);
   if (who.kind === "in") {
     say(`\u2713 Signed in \xB7 ${who.workspace}`);
@@ -9722,35 +10108,11 @@ async function setup(ctx) {
     detail(signedInLine(ctx, signedIn));
   } else {
     const name = who.source === "flag" ? "--api-key" : who.source.slice("env:".length);
-    out.info(`Amdahl rejected the key in ${name}. Skipping the browser sign-in, because that key would still be used instead. Fix it, or unset it and run \`amdahl login\`.`);
+    out.info(`Amdahl rejected the key in ${name}. Skipping the browser sign-in, because that key would still be used instead. Fix it, or unset it and run \`${amdahlCommand("login")}\`.`);
   }
-  let exit = EXIT.ok;
-  let ready = null;
-  for (const { client, name } of picks.flatMap((i) => SHOWN[i] ?? [])) {
-    let steps;
-    try {
-      steps = await installClient(ctx, client, false);
-    } catch (raw) {
-      const err = raw instanceof CliError ? raw : new CliError("install_failed", `Could not set up ${name}: ${raw instanceof Error ? raw.message : String(raw)}`, EXIT.general);
-      io.stderr(`Error: ${err.message}
-${err.hint ? `${err.hint}
-` : ""}`);
-      if (exit === EXIT.ok) exit = err.exit;
-      continue;
-    }
-    const action = steps.mcp.data.action;
-    if (action === "printed") {
-      say(`! ${name}: \`claude\` is not on your PATH. Once it is, run:
-  ${String(steps.mcp.data.command)}`);
-    } else {
-      say(action === "unchanged" ? `\u2713 ${name} already has Amdahl` : `\u2713 Added to ${name}`);
-      ready ??= { name, connect: action !== "unchanged" };
-    }
-    const mcpDetail = action === "printed" ? [] : [steps.mcp.human, ...steps.mcp.notes];
-    detail([...mcpDetail, steps.skill.human, ...steps.skill.notes].filter(Boolean).join("\n"));
-  }
-  if (ready) say(tryItLine(ready.name, ready.connect));
-  return exit;
+  const done = await installEach(ctx, chosen, detail);
+  for (const line of finishLines(done.ready, inClaudeCode)) say(line);
+  return exit === EXIT.ok ? done.exit : exit;
 }
 
 // src/commands/skills.ts
@@ -9878,8 +10240,8 @@ function readTar(tar) {
       throw new ArchiveError("its tar is not ustar");
     }
     const name = field(header, 0, 100);
-    const prefix = field(header, 345, 155);
-    let path = prefix ? `${prefix}/${name}` : name;
+    const prefix2 = field(header, 345, 155);
+    let path = prefix2 ? `${prefix2}/${name}` : name;
     const type = String.fromCharCode(header[156]);
     const size = octal(header, 124, 12);
     const mode = octal(header, 100, 8);
@@ -10300,9 +10662,9 @@ ${done}`);
 
 // src/commands/workspace-status.ts
 var BLOCKER_FIX = {
-  missing_scope: "This credential cannot optimize. Use a Customer agent key, or run `amdahl login` again.",
-  role_too_low: "Your role cannot optimize. Ask a workspace admin to raise it.",
-  quota_exhausted: "The monthly optimize quota is used up."
+  missing_scope: () => `This credential cannot optimize. Use a Customer agent key, or run \`${amdahlCommand("login")}\` again.`,
+  role_too_low: () => "Your role cannot optimize. Ask a workspace admin to raise it.",
+  quota_exhausted: () => "The monthly optimize quota is used up."
 };
 function describe(status2) {
   const lines = [
@@ -10314,8 +10676,9 @@ function describe(status2) {
   if (opt.quota) {
     lines.push(`Quota:      ${opt.quota.used} of ${opt.quota.limit} used, resets ${opt.quota.resets_at}`);
   }
-  if (!opt.allowed && opt.blocker && BLOCKER_FIX[opt.blocker]) {
-    lines.push(`            ${BLOCKER_FIX[opt.blocker]}`);
+  const fix = opt.blocker ? BLOCKER_FIX[opt.blocker] : void 0;
+  if (!opt.allowed && fix) {
+    lines.push(`            ${fix()}`);
   }
   const conns = status2.connections;
   if ("omitted" in conns) {
@@ -10344,7 +10707,7 @@ async function workspaceList(ctx) {
     email: p.email,
     api_url: p.api_url
   }));
-  const human = profiles.length === 0 ? "No profiles. Run `amdahl login`." : profiles.map(
+  const human = profiles.length === 0 ? `No profiles. Run \`${amdahlCommand("login")}\`.` : profiles.map(
     (p) => `${p.name === config.default_profile ? "*" : " "} ${p.name}  ${p.workspace.name}  ${p.email ?? ""}  ${p.api_url}`
   ).join("\n");
   ctx.out.result({ ok: true, default: config.default_profile, profiles }, human);
@@ -10354,7 +10717,7 @@ async function workspaceUse(ctx, args) {
   const name = args[0];
   if (!name || args.length > 1) throw usageError("Usage: amdahl workspace use <profile>");
   if (!ctx.config.profiles[name]) {
-    throw usageError(`No profile named "${name}".`, "Run `amdahl workspace list` to see your profiles.");
+    throw usageError(`No profile named "${name}".`, `Run \`${amdahlCommand("workspace list")}\` to see your profiles.`);
   }
   ctx.config.default_profile = name;
   ctx.saveConfig();
@@ -10363,7 +10726,7 @@ async function workspaceUse(ctx, args) {
 }
 
 // src/version.ts
-var VERSION = "0.3.2";
+var VERSION = "0.3.4";
 
 // src/main.ts
 var COMMANDS = {
@@ -10381,8 +10744,9 @@ var COMMANDS = {
   install,
   "skills add": skillsAdd
 };
-var NO_ARGS = /* @__PURE__ */ new Set(["login", "logout", "whoami", "auth token", "status", "keys create", "keys list", "workspace list"]);
+var NO_ARGS = /* @__PURE__ */ new Set(["setup", "login", "logout", "whoami", "auth token", "status", "keys create", "keys list", "workspace list"]);
 async function runCli(argv, io) {
+  setCommandName(io);
   const json = argv.includes("--json");
   let out = createOutput(io, json, argv.includes("--no-color"));
   try {
@@ -10393,18 +10757,21 @@ async function runCli(argv, io) {
 `);
       return EXIT.ok;
     }
-    if (parsed.flags.help) {
+    if (parsed.flags.help || parsed.command === "help") {
       io.stdout(USAGE);
       return EXIT.ok;
     }
-    if (!parsed.command) {
-      if (argv.every((a) => a === "--verbose") && shouldSetUp(io)) return await setup(createCtx(io, out, parsed.flags));
-      io.stderr(USAGE);
-      return EXIT.usage;
-    }
-    if (NO_ARGS.has(parsed.command) && parsed.args.length > 0) {
+    if (NO_ARGS.has(parsed.command ?? "") && parsed.args.length > 0) {
       throw new CliError("usage", `Unexpected argument: ${parsed.args[0]}`, EXIT.usage);
     }
+    if (!parsed.command || parsed.command === "setup") {
+      const mode = parsed.flags.json ? { kind: "usage", reason: "it has no --json output" } : setupMode(io);
+      if (mode.kind === "usage") {
+        io.stderr(`${noSetupLine(mode.reason)}${USAGE}`);
+        return EXIT.usage;
+      }
+      return await setup(createCtx(io, out, parsed.flags), mode.kind);
+    }
     const handler = COMMANDS[parsed.command];
     if (!handler) throw new CliError("usage", `Unknown command ${parsed.command}`, EXIT.usage);
     const ctx = createCtx(io, out, parsed.flags);