@amdahl/cli 0.3.3 → 0.3.5

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";
+import { createInterface as createInterface2 } from "readline";
 
 // src/select.ts
-import { emitKeypressEvents } from "readline";
+import { createInterface, 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 ? note.split("\n").flatMap((line) => wrapWords(line, 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,24 @@ 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) => {
+  const start = Math.min(Math.max(options.initial ?? 0, 0), choices.length - 1);
+  let current = ticked.includes(true) ? ticked.indexOf(true) : start;
+  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" };
@@ -7514,6 +7569,56 @@ function listenForEnter(input, onEnter, onCancel) {
   }
   return stop;
 }
+var PASTE_ON = "\x1B[?2004h";
+var PASTE_OFF = "\x1B[?2004l";
+var PASTE_SETTLE_MS = 150;
+function readPaste(input, output, question) {
+  output.write(`${question}
+`);
+  const rl = createInterface({ input, output, terminal: true, prompt: "" });
+  output.write(PASTE_ON);
+  return new Promise((resolve2, reject) => {
+    const lines = [];
+    let pasting = false;
+    let settle;
+    let settled = false;
+    const finish = (outcome) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(settle);
+      input.removeListener("keypress", onKeypress);
+      output.write(PASTE_OFF);
+      rl.close();
+      if ("text" in outcome) resolve2(outcome.text);
+      else reject(outcome.error);
+    };
+    const done = () => finish({ text: lines.join("\n").trim() });
+    const onKeypress = (_text, key) => {
+      if (key?.name === "paste-start") pasting = true;
+      else if (key?.name === "paste-end") pasting = false;
+      else if (settle && key?.name !== "return" && key?.name !== "enter") {
+        clearTimeout(settle);
+        settle = void 0;
+      }
+    };
+    input.on("keypress", onKeypress);
+    rl.on("line", (line) => {
+      if (line.trim() || pasting) {
+        lines.push(line);
+        return;
+      }
+      if (lines.length === 0) return;
+      lines.push(line);
+      clearTimeout(settle);
+      settle = setTimeout(done, PASTE_SETTLE_MS);
+    });
+    rl.on("SIGINT", () => {
+      output.write("\n");
+      finish({ error: new PromptCancelled() });
+    });
+    rl.on("close", done);
+  });
+}
 
 // src/io.ts
 var PromptCancelled = class extends Error {
@@ -7522,20 +7627,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);
@@ -7547,8 +7652,8 @@ async function readAllStdin() {
   return Buffer.concat(chunks).toString("utf8");
 }
 function promptLine(question) {
-  const rl = createInterface({ input: process.stdin, output: process.stderr });
-  return new Promise((resolve, reject) => {
+  const rl = createInterface2({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve2, reject) => {
     let settled = false;
     const cancel = () => {
       if (settled) return;
@@ -7562,10 +7667,26 @@ function promptLine(question) {
     rl.question(question, (answer) => {
       settled = true;
       rl.close();
-      resolve(answer);
+      resolve2(answer);
     });
   });
 }
+function runOnTerminal(command, args) {
+  const hold = () => {
+  };
+  process.on("SIGINT", hold);
+  return new Promise((resolve2) => {
+    let child;
+    try {
+      child = spawn(command, args, { stdio: "inherit" });
+    } catch {
+      resolve2(-1);
+      return;
+    }
+    child.on("error", () => resolve2(-1));
+    child.on("close", (code) => resolve2(code ?? -1));
+  }).finally(() => process.off("SIGINT", hold));
+}
 function uninterruptible(fn) {
   const hold = () => {
   };
@@ -7576,6 +7697,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]];
@@ -7590,23 +7720,30 @@ function realIo() {
     stdoutIsTTY: Boolean(process.stdout.isTTY),
     stderrIsTTY: Boolean(process.stderr.isTTY),
     readStdin: readAllStdin,
+    readPaste: (question) => readPaste(process.stdin, process.stderr, question),
     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,
+    runInteractive: runOnTerminal,
     openUrl: async (url) => {
       const [cmd, args] = openerFor(process.platform, url);
       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(),
@@ -7620,6 +7757,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 -y amdahl" : "amdahl";
+}
+function amdahlCommand(rest = "") {
+  return rest ? `${prefix} ${rest}` : prefix;
+}
+
 // src/errors.ts
 var EXIT = {
   ok: 0,
@@ -7656,7 +7805,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,
@@ -7694,7 +7846,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" },
@@ -7747,12 +7902,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;
@@ -7762,7 +7917,7 @@ function parseCommandLine(argv) {
       const ref = second && second.includes("/") ? second : "<publisher>/<skill>";
       throw usageError(
         second === void 0 ? "`amdahl skills` needs a subcommand." : `Unknown command \`amdahl skills ${second}\`.`,
-        `To add a skill: npx amdahl skills add ${ref}`
+        `To add a skill: npx -y amdahl skills add ${ref}`
       );
     }
     if (second === void 0) throw usageError(`\`amdahl ${first}\` needs a subcommand.`);
@@ -7771,7 +7926,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 };
 }
@@ -7783,39 +7938,64 @@ 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, or try
+                                 Amdahl in this terminal. In a terminal it
+                                 asks which. 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
+                                 (with no file, at a terminal, paste it)
+  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
@@ -7825,14 +8005,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
 `;
@@ -8031,7 +8216,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) {
@@ -8142,7 +8327,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":
@@ -8178,8 +8363,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(() => {
@@ -8195,7 +8380,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;
     }
@@ -8225,7 +8410,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(
@@ -8237,12 +8422,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?.();
@@ -8269,7 +8454,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) {
@@ -8362,7 +8547,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 {
@@ -8371,7 +8556,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.
 `
     );
   };
@@ -8503,7 +8688,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);
@@ -8511,20 +8696,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 };
@@ -8536,7 +8721,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);
@@ -8557,16 +8742,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 {
@@ -8668,13 +8853,15 @@ async function browserSignIn(ctx) {
 `);
     };
     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.";
-        out.info(`Browser didn't open? ${fallback}`);
+        fallbackLine = `Browser didn't open? ${fallback}`;
+        out.info(fallbackLine);
         cancelled = new Promise((_, reject) => {
           stopKeys = io.listenForEnter(
             () => showLink("Open this link to sign in:"),
@@ -8688,6 +8875,7 @@ async function browserSignIn(ctx) {
     }
     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);
@@ -8719,6 +8907,8 @@ async function browserSignIn(ctx) {
     };
     ctx.config.default_profile = name;
     ctx.saveConfig();
+    ctx.profileName = name;
+    ctx.profile = ctx.config.profiles[name] ?? null;
     return { profile: name, me, workspace: ws };
   } finally {
     stopKeys();
@@ -8728,6 +8918,10 @@ async function browserSignIn(ctx) {
 function signedInLine(ctx, { profile, me, workspace }) {
   return `Signed in as ${printable(me.email ?? me.user_id)} to ${ctx.out.bold(printable(workspace.name))} (${printable(workspace.slug)}). Profile: ${profile}.`;
 }
+function loginNextLine() {
+  return `Next: run \`${amdahlCommand("optimize")}\` and paste an email,
+or \`${amdahlCommand()}\` to add Amdahl to Claude Code, Cursor or Codex.`;
+}
 async function login(ctx) {
   const signedIn = await browserSignIn(ctx);
   const { profile, me, workspace } = signedIn;
@@ -8740,7 +8934,8 @@ async function login(ctx) {
       scopes: me.scopes,
       api_url: ctx.apiUrl
     },
-    signedInLine(ctx, signedIn)
+    `${signedInLine(ctx, signedIn)}
+${loginNextLine()}`
   );
   return EXIT.ok;
 }
@@ -8827,8 +9022,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";
@@ -8882,22 +9077,140 @@ 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"]);
-  return res.code === 0 && res.stdout.split("\n").some((line) => line.trim() === `URL: ${mcpUrl}`);
+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) {
+  let answer = claudeAnswers.get(ctx);
+  if (!answer) {
+    answer = ctx.io.run(command, ["mcp", "get", "amdahl"]).then((res) => res.code === 0 && res.stdout.split("\n").some((line) => line.trim() === `URL: ${mcpUrl}`));
+    claudeAnswers.set(ctx, answer);
+  }
+  return answer;
+}
+var claudeAnswers = /* @__PURE__ */ new WeakMap();
+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 {
@@ -8908,12 +9221,13 @@ function updateConfig(path, fn) {
     throw new CliError("write_failed", `Could not update ${path} (${reason}).`, EXIT.general);
   }
 }
-async function isInstalled(ctx, client) {
-  const skill = skillPath(client, ctx.io.homedir);
-  const current = existsSync3(skill) ? readFileSync3(skill, "utf8") : null;
-  if (current === null || current !== SKILL_TEXT && isShippedSkill(current)) return false;
+async function hasAmdahl(ctx, client) {
   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"));
@@ -8925,6 +9239,12 @@ async function isInstalled(ctx, client) {
     return false;
   }
 }
+async function isInstalled(ctx, client) {
+  const skill = skillPath(client, ctx.io.homedir);
+  const current = existsSync3(skill) ? readFileSync3(skill, "utf8") : null;
+  if (current === null || current !== SKILL_TEXT && isShippedSkill(current)) return false;
+  return hasAmdahl(ctx, client);
+}
 async function installClient(ctx, client, print) {
   const mcp = await installMcp(ctx, client, print);
   return { mcp, skill: installSkill(ctx, client, print) };
@@ -8971,14 +9291,14 @@ 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);
+    claudeAnswers.delete(ctx);
+    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);
     }
@@ -8996,9 +9316,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: [] };
     });
   }
@@ -9009,28 +9328,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";
@@ -9098,7 +9422,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];
@@ -9168,7 +9492,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];
@@ -9204,6 +9528,7 @@ async function keysRevoke(ctx, args) {
 
 // src/commands/optimize.ts
 import { readFileSync as readFileSync4 } from "fs";
+var NEW_USER = "New to Amdahl? The sign-in sets up your free workspace.";
 var OPTIMIZE_TIMEOUT_MS = 18e4;
 var CHANNELS = ["email", "linkedin"];
 var EVIDENCE = ["off", "workspace"];
@@ -9348,10 +9673,86 @@ function whatAmdahlDid(result) {
   const kept = new Set([...lines].sort((a, b) => a.rank - b.rank).slice(0, MAX_LINES));
   return lines.filter((l) => kept.has(l)).map((l) => l.line);
 }
+var PASTE_PROMPT = "Paste an email or LinkedIn message, then press Enter on an empty line:";
+var VERSION_RULE = "\u2500\u2500 Amdahl's version \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500";
+function nextTimeLine(ctx) {
+  const file = amdahlCommand("optimize draft.txt");
+  return ctx.io.platform === "darwin" ? `Next time: ${file},
+or pbpaste | ${amdahlCommand("optimize -")}` : `Next time: ${file}`;
+}
+function requestOptions(ctx) {
+  const { flags } = ctx;
+  const base = {};
+  const channel = oneOf("channel", str(flags.channel), CHANNELS);
+  const evidence = oneOf("evidence", str(flags.evidence), EVIDENCE);
+  const onUnsupported = oneOf("on-unsupported", str(flags["on-unsupported"]), ON_UNSUPPORTED);
+  if (channel) base.channel = channel;
+  if (evidence) base.evidence = evidence;
+  if (onUnsupported) base.on_unsupported = onUnsupported;
+  if (flags.tries === true) base.include_tries = true;
+  const contextPath = str(flags.context);
+  if (contextPath) base.context = readContext(contextPath);
+  return base;
+}
+async function optimizeOne(ctx, credential, message2, base, file) {
+  try {
+    return await withTimeout(
+      apiClient(ctx, credential).request("/api/platform/v1/messages/optimize", {
+        method: "POST",
+        body: { message: message2, ...base }
+      }),
+      OPTIMIZE_TIMEOUT_MS,
+      file
+    );
+  } catch (err) {
+    throw toCliError(err);
+  }
+}
+async function credentialOrSignIn(ctx) {
+  try {
+    return await resolveCredential(ctx);
+  } catch (err) {
+    if (!(err instanceof CliError && err.exit === EXIT.unauthenticated)) throw err;
+  }
+  ctx.out.info(`Sign in first, then paste your message.
+${NEW_USER}`);
+  const signedIn = await browserSignIn(ctx);
+  ctx.out.info(`\u2713 Signed in \xB7 ${printable(signedIn.workspace.name)}`);
+  return resolveCredential(ctx);
+}
+async function optimizePasted(ctx) {
+  const { io, out } = ctx;
+  const base = requestOptions(ctx);
+  const credential = await credentialOrSignIn(ctx);
+  const message2 = await io.readPaste(PASTE_PROMPT);
+  if (!message2.trim()) {
+    out.info(`Nothing pasted, so nothing was sent.
+${nextTimeLine(ctx)}`);
+    return EXIT.ok;
+  }
+  out.info("Amdahl is rewriting it. This can take a minute.");
+  const result = await optimizeOne(ctx, credential, message2, base, "your message");
+  if (result.ok === false) {
+    if (out.json) out.result({ ok: false, file: "-", result });
+    out.info(`Not optimized (${String(result.reason ?? "unknown")}): ${String(result.detail ?? "")}`);
+    return EXIT.general;
+  }
+  if (out.json) {
+    out.result({ ok: true, file: "-", result });
+    return EXIT.ok;
+  }
+  out.info(VERSION_RULE);
+  if (result.unchanged === true) out.info("No rewrite beat your draft; it is returned unchanged.");
+  out.result({}, String(result.message ?? ""));
+  const did = whatAmdahlDid(result);
+  out.info([...did, nextTimeLine(ctx)].join("\n"));
+  return EXIT.ok;
+}
 async function optimize(ctx, args) {
-  const { io, out, flags } = ctx;
+  const { io, out } = ctx;
   let files = args;
   if (files.length === 0) {
+    if (io.stdinIsTTY && !ctx.nonInteractive) return optimizePasted(ctx);
     if (io.stdinIsTTY) {
       throw usageError(
         "Give a file to optimize, or pipe the message on stdin.",
@@ -9361,16 +9762,7 @@ async function optimize(ctx, args) {
     files = ["-"];
   }
   if (files.filter((f) => f === "-").length > 1) throw usageError("Stdin (-) can be read only once.");
-  const base = {};
-  const channel = oneOf("channel", str(flags.channel), CHANNELS);
-  const evidence = oneOf("evidence", str(flags.evidence), EVIDENCE);
-  const onUnsupported = oneOf("on-unsupported", str(flags["on-unsupported"]), ON_UNSUPPORTED);
-  if (channel) base.channel = channel;
-  if (evidence) base.evidence = evidence;
-  if (onUnsupported) base.on_unsupported = onUnsupported;
-  if (flags.tries === true) base.include_tries = true;
-  const contextPath = str(flags.context);
-  if (contextPath) base.context = readContext(contextPath);
+  const base = requestOptions(ctx);
   const inputs = [];
   for (const file of files) {
     let message2;
@@ -9383,23 +9775,10 @@ async function optimize(ctx, args) {
     inputs.push({ file, message: message2 });
   }
   const credential = await resolveCredential(ctx);
-  const client = apiClient(ctx, credential);
   const results = [];
   let exit = EXIT.ok;
   for (const { file, message: message2 } of inputs) {
-    let result;
-    try {
-      result = await withTimeout(
-        client.request("/api/platform/v1/messages/optimize", {
-          method: "POST",
-          body: { message: message2, ...base }
-        }),
-        OPTIMIZE_TIMEOUT_MS,
-        file
-      );
-    } catch (err) {
-      throw toCliError(err);
-    }
+    const result = await optimizeOne(ctx, credential, message2, base, file);
     const ok = result.ok !== false;
     results.push({ ok, file, result });
     if (!ok) {
@@ -9426,7 +9805,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 = [];
@@ -9453,7 +9832,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);
@@ -9472,7 +9851,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;
@@ -9491,7 +9870,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);
@@ -9518,7 +9897,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);
     }
@@ -9543,7 +9922,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 });
 }
@@ -9551,15 +9930,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) {
@@ -9575,9 +9954,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) {
@@ -9585,7 +9964,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 = [];
@@ -9597,9 +9976,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);
     }
@@ -9704,16 +10083,124 @@ 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 TERMINAL = "This terminal";
+var FOUND_TAG = "found on your machine";
+var CONNECT_URL = "https://amdahl.ai/connect";
+var NONE_FOUND = `We didn't find Claude Code, Cursor or Codex on this computer.
+Using the Claude or ChatGPT app? Connect it at ${CONNECT_URL}`;
+var MENU_HINT = "\u2191\u2193 move \xB7 Space tick/untick \xB7 Enter continue";
+var ASK = '"Use Amdahl to make this sound less like AI"';
+var SIGN_IN = {
+  "Claude Code": "If it's open, quit and reopen it. Type /mcp, pick amdahl, sign in.",
+  // Cursor reads ~/.cursor/mcp.json at start, and lists its MCP servers under Customize > MCPs.
+  Cursor: "If it's open, quit and reopen it. In Customize > MCPs, sign in to amdahl."
+};
+var TRY_IN = {
+  "Claude Code": `Paste an email and say: ${ASK}`,
+  Cursor: `In chat, paste an email, say: ${ASK}`,
+  Codex: `In codex, paste an email, say: ${ASK}`
+};
+var CODEX_TRY = `Run codex, paste an email and say: ${ASK}`;
+var CODEX_LOGIN = "codex mcp login amdahl";
+function toolScreen(name, already) {
+  return [
+    already ? `\u2713 ${name} already has Amdahl.` : `\u2713 Added Amdahl to ${name}.`,
+    `One step left, in ${name}:`,
+    `  1. ${SIGN_IN[name] ?? ""}`,
+    `  2. ${TRY_IN[name] ?? ""}`
+  ];
+}
+function allSetLines(names) {
+  const [only] = names;
+  if (only === void 0) return [];
+  const tryHere2 = `Want to try it here instead? Run: ${amdahlCommand("optimize")}`;
+  if (names.length === 1) {
+    const done = {
+      "Claude Code": ["If you've already run /mcp, you're done.", "If not: quit and reopen Claude Code, type /mcp, pick amdahl, sign in."],
+      Cursor: ["If you've already signed in under Customize > MCPs, you're done.", "If not: quit and reopen Cursor, then sign in to amdahl there."],
+      Codex: [`If you've already run ${CODEX_LOGIN}, you're done.`, `If not, run it now in this terminal.`]
+    };
+    return [`Amdahl is in ${only}. You're all set.`, `Paste an email there and say: ${ASK}`, ...done[only] ?? [], tryHere2];
+  }
+  const step = {
+    "Claude Code": "quit and reopen it, type /mcp, pick amdahl, sign in",
+    Cursor: "quit and reopen it, then in Customize > MCPs, sign in to amdahl",
+    Codex: `run ${CODEX_LOGIN}`
+  };
+  return [
+    `Amdahl is in ${joinNames(names)}. You're all set.`,
+    `Paste an email in ${names.length === 2 ? "either" : "any of them"} and say: ${ASK}`,
+    "If you've already signed each one in, you're done. If not:",
+    ...names.map((n) => `  ${n}: ${step[n] ?? ""}`),
+    tryHere2
+  ];
+}
+function nothingPickedLines() {
+  return [
+    "Nothing picked, so nothing changed.",
+    `To try it here, run ${amdahlCommand()} again and tick "${TERMINAL}".`,
+    `Using the Claude or ChatGPT app? Connect it at ${CONNECT_URL}`
+  ];
+}
+function wrapLine(line, columns) {
+  if (!columns || [...line].length <= columns) return [line];
+  const lead = /^\s*(?:\d+\.\s+)?/.exec(line)?.[0] ?? "";
+  const indent = " ".repeat(lead.length);
+  const lines = [];
+  let current = lead;
+  let words = 0;
+  for (const word of line.slice(lead.length).split(" ")) {
+    if (words > 0 && [...`${current} ${word}`].length > columns) {
+      lines.push(current);
+      current = indent + word;
+    } else current = words > 0 ? `${current} ${word}` : current + word;
+    words++;
+  }
+  lines.push(current);
+  return lines;
+}
+var AGENT_ASK = `paste an email and say ${ASK}`;
+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_LOGIN}\` once to connect Amdahl.`
+    };
+    return [`Try it: ${AGENT_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_LOGIN}\``
+  };
+  return [`Try it: ${AGENT_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;
@@ -9731,83 +10218,178 @@ 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, tools) {
+  let exit = EXIT.ok;
+  const ready = [];
+  for (const tool of tools) {
+    let steps;
+    try {
+      steps = await installClient(ctx, tool.client, false);
+    } catch (raw) {
+      const err = raw instanceof CliError ? raw : new CliError("install_failed", `Could not set up ${tool.name}: ${raw instanceof Error ? raw.message : String(raw)}`, EXIT.general);
+      reportError(ctx.io, err);
+      if (exit === EXIT.ok) exit = err.exit;
+      continue;
+    }
+    const detail = [steps.mcp.human, ...steps.mcp.notes, steps.skill.human, ...steps.skill.notes].filter(Boolean).join("\n");
+    ready.push({ ...tool, already: steps.mcp.data.action === "unchanged", detail });
+  }
+  return { ready, exit };
+}
+function enterOrSkip(io) {
+  return new Promise((resolve2) => {
+    const stop = io.listenForEnter(
+      () => {
+        stop();
+        resolve2(true);
+      },
+      () => resolve2(false)
+    );
+  });
+}
+async function codexScreen(ctx, tool, say, detail, lead) {
+  say(tool.already ? "\u2713 Codex already has Amdahl." : "\u2713 Added Amdahl to Codex.");
+  detail(tool.detail);
+  for (const line of lead) say(line);
+  if (!await onPath(ctx, "codex")) {
+    say("One step left, in your terminal:");
+    say(`  1. Run: ${CODEX_LOGIN}`);
+    say(`  2. ${TRY_IN.Codex ?? ""}`);
+    return;
+  }
+  say("Press Enter to sign Codex in to Amdahl (opens your browser).");
+  if (!await enterOrSkip(ctx.io)) {
+    say(`Skipped. To connect it later, run: ${CODEX_LOGIN}`);
+    say(CODEX_TRY);
+    return;
+  }
+  const code = await ctx.io.runInteractive("codex", ["mcp", "login", "amdahl"]);
+  if (code === 0) say("\u2713 Codex is connected.");
+  else {
+    say("");
+    say(`Codex didn't finish signing in. To try again, run: ${CODEX_LOGIN}`);
+  }
+  say(CODEX_TRY);
+}
+async function setup(ctx, mode) {
   const { io, out } = ctx;
   const verbose = ctx.flags.verbose === true;
-  const say = (line) => io.stdout(`${line}
+  const say = (line) => {
+    for (const part of mode === "menu" ? wrapLine(line, io.columns()) : [line]) io.stdout(`${part}
 `);
+  };
   const detail = (text2) => {
-    if (verbose && text2) say(text2.replace(/^/gm, "  "));
+    if (verbose && text2) io.stdout(`${text2.replace(/^/gm, "  ")}
+`);
   };
   say(`${out.bold("Amdahl")} \xB7 predictive ML for GTM`);
   const found = await detectClients(ctx);
   const detected = SHOWN.filter((c) => found[c.client]);
-  let who;
+  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);
+    for (const tool of ready) {
+      say(tool.already ? `\u2713 ${tool.name} already has Amdahl` : `\u2713 Added to ${tool.name}`);
+      detail(tool.detail);
+    }
+    for (const line of finishLines(ready.map((t) => t.name), Boolean(io.env.CLAUDECODE))) say(line);
+    return exit2;
+  }
   if (detected.length > 0) {
-    const installed = await Promise.all(detected.map((c) => isInstalled(ctx, c.client)));
-    if (installed.every(Boolean)) {
-      let unreachable = false;
-      try {
-        who = await signIn(ctx);
-      } catch (err) {
-        if (!(err instanceof CliError && err.exit === EXIT.network)) throw err;
-        unreachable = true;
-      }
-      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 ?? ""));
-        return EXIT.ok;
-      }
+    const there = await Promise.all(detected.map((c) => hasAmdahl(ctx, c.client)));
+    if (there.every(Boolean)) {
+      for (const tool of detected) {
+        if (await isInstalled(ctx, tool.client)) continue;
+        const { ready } = await installEach(ctx, [tool]);
+        for (const r of ready) detail(r.detail);
+      }
+      for (const line of allSetLines(detected.map((c) => c.name))) say(line);
+      return EXIT.ok;
     }
   }
-  const picks = await io.multiSelect(
-    "Set up in:",
-    SHOWN.map((c) => c.name),
-    { ticked: SHOWN.map((c) => found[c.client]), color: out.color }
-  );
+  const rows = [...SHOWN.map((c) => c.name), TERMINAL];
+  const picks = await io.multiSelect(QUESTION, rows, {
+    ticked: [...SHOWN.map((c) => found[c.client]), false],
+    tags: [...SHOWN.map((c) => found[c.client] ? FOUND_TAG : void 0), void 0],
+    note: detected.length === 0 ? NONE_FOUND : void 0,
+    // With no tool here, the marker starts on "This terminal": Space, then Enter.
+    initial: detected.length === 0 ? SHOWN.length : void 0,
+    hint: MENU_HINT,
+    color: out.color
+  });
   if (picks.length === 0) {
-    say("Nothing picked, so nothing changed.");
+    for (const line of nothingPickedLines()) say(line);
     return EXIT.ok;
   }
-  who ??= await signIn(ctx);
+  const here = picks.includes(SHOWN.length);
+  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;
+  }
+  const done = await installEach(ctx, chosen);
+  if (exit === EXIT.ok) exit = done.exit;
+  let lead = [NEW_USER];
+  for (const [i, tool] of done.ready.entries()) {
+    if (i > 0) say("");
+    if (tool.client === "codex") {
+      await codexScreen(ctx, tool, say, detail, lead);
+    } else {
+      const [first, ...steps] = toolScreen(tool.name, tool.already);
+      say(first ?? "");
+      detail(tool.detail);
+      for (const line of [...steps, ...lead]) say(line);
+    }
+    lead = [];
+  }
+  if (!here) return exit;
+  if (done.ready.length > 0) say("");
+  try {
+    const code = await tryHere(ctx, say, lead);
+    return exit === EXIT.ok ? code : exit;
+  } catch (err) {
+    if (err instanceof PromptCancelled && done.ready.length > 0) {
+      throw new CliError("cancelled", `Stopped. Amdahl is still set up in ${joinNames(done.ready.map((t) => t.name))}.`, EXIT.cancelled);
+    }
+    throw err;
+  }
+}
+async function tryHere(ctx, say, lead) {
+  const { out } = ctx;
+  const verbose = ctx.flags.verbose === true;
+  const who = await signIn(ctx);
   if (who.kind === "in") {
     say(`\u2713 Signed in \xB7 ${who.workspace}`);
-    detail(`Signed in as ${who.email}.`);
+    if (verbose) say(`  Signed in as ${who.email}.`);
   } else if (who.kind === "out") {
+    for (const line of lead) say(line);
     const signedIn = await browserSignIn(ctx);
     say(`\u2713 Signed in \xB7 ${printable(signedIn.workspace.name)}`);
-    detail(signedInLine(ctx, signedIn));
+    if (verbose) say(`  ${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\`.`);
-  }
-  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"));
+    out.info(`Amdahl rejected the key in ${name}, so a message can't be tried here. Fix it, or unset it and run \`${amdahlCommand("login")}\`.`);
+    return EXIT.unauthenticated;
   }
-  if (ready) say(tryItLine(ready.name, ready.connect));
-  return exit;
+  return optimizePasted(ctx);
 }
 
 // src/commands/skills.ts
@@ -9935,8 +10517,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);
@@ -10357,9 +10939,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 = [
@@ -10371,8 +10953,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) {
@@ -10401,7 +10984,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);
@@ -10411,7 +10994,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();
@@ -10420,7 +11003,7 @@ async function workspaceUse(ctx, args) {
 }
 
 // src/version.ts
-var VERSION = "0.3.3";
+var VERSION = "0.3.5";
 
 // src/main.ts
 var COMMANDS = {
@@ -10438,8 +11021,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 {
@@ -10450,18 +11034,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);