getclaros 0.1.0 → 0.1.1

package/README.md

@@ -12,8 +12,45 @@ The package name (`getclaros`) is a placeholder and lives only in `package.json`
 npx getclaros init
 ```
 
-Not published yet (`"private": true`); until then run `node dist/cli.js init` with
-`GETCLAROS_LAUNCHER="node /abs/path/to/dist/cli.js"` so the configs launch your build instead of `npx -y getclaros`.
+To try a local build, run `node dist/cli.js init` with `GETCLAROS_LAUNCHER="node /abs/path/to/dist/cli.js"` so the
+configs launch your build instead of `npx -y getclaros`.
+
+```
+  claros”  getclaros 0.1.1
+
+  Sign in  opening your browser
+  › https://claros-eta.vercel.app/device?code=ZQRC-ZCTP
+    Code ZQRC-ZCTP  approve only if the page shows this code
+
+  ✓ Signed in to workspace "Acme"  key clr_7f3a91c2_…
+    <claros server> · key saved in ~/.config/getclaros/config.json, readable only by you
+
+  MCP servers
+
+  Claude Code  ~/.claude.json
+     1 ● erpnext                     npx -y frappe-mcp-server  Work Map "Process a supplier invoice"
+     2 ○ github                      docker run -i …
+     3 ○ playwright (project ~/proj) npx @playwright/mcp@latest
+
+  Cursor  ~/.cursor/mcp.json
+     4 ● erpnext                     npx frappe-mcp-server  Work Map "Process a supplier invoice"
+
+  · 3 remote servers need OAuth — guard them later: linear, notion, figma
+
+  ● matches a Work Map: recommended
+  Guard which? Enter = 1,4 (recommended) · numbers like 1,3 · all · none ›
+
+  ✓ Guarded erpnext  in Claude Code, Cursor
+  ✓ Added the Claros MCP server  in Claude Code, Cursor
+    every file backed up first: ~/.config/getclaros/backups/2026-10-24T01-34-53-159Z
+
+  Next  restart Claude Code, Cursor, then run  npx getclaros test
+        undo anytime: npx getclaros undo
+```
+
+On a terminal the output is coloured in Claros's inks (stop magenta, ask green, nudge vermilion) with a spinner while
+it waits for the browser. Piped, it is plain text with no escape codes and no header; `NO_COLOR` turns colour off,
+`FORCE_COLOR` turns it on. Old Windows consoles get ASCII marks.
 
 `init` signs you in through the browser (RFC 8628 device flow): it prints a URL and a code (XXXX-XXXX), opens the
 URL (`--no-browser` to skip), and once you approve on Claros's `/device` page and pick a workspace it receives an
@@ -62,7 +99,20 @@ rules page. Exit codes: 0 sent, 1 no such check / not valid, 2 bad usage, 3 unre
 
 `test` asks Claros for a record that breaks a precise rule of a Work Map for one of your guarded servers
 (`GET /v1/check/example?app=…`), checks it with `POST /v1/check` and prints the stop. Nothing is sent to the app.
-With no guarded server matching a map it uses the newest map and says `DEMO`. Exit codes: 0 stopped, 1 not stopped
+With no guarded server matching a map it uses the workspace's newest map and ends with a `Demo:` note.
+
+```
+  ◉ Stopped in 1.3 s  Work Map "Process a supplier invoice" · check chk_0b14cb5eef
+
+    ◉ stop  Equipment over 5,000 is capex: book it to the capital equipment account, never to expense.
+            “Equipment above five thousand is an asset, it goes to capex.” — AP lead
+            Who to ask: Controller
+
+  Test action for erpnext, made up, only checked: items.0.item_group = Machinery, items.0.amount = 7200
+  Your agent gets the rule as the tool's error. Nothing reached erpnext.
+```
+
+Exit codes: 0 stopped, 1 not stopped
 or no map to test, 2 not signed in / bad usage, 3 Claros unreachable or key rejected (`status` uses 0 / 2 / 3 too).
 
 `undo` restores a file from its backup when it is byte-for-byte what `init` wrote; if anything changed it since, it

package/dist/setup.js

@@ -9,8 +9,8 @@ import { createInterface } from "node:readline/promises";
 import { parseArgs } from "node:util";
 import { addClaros, argvOf, CLAROS, detect, launcher, load, removeEntry, sha, unwrapServer, wrapServer, writeAtomic, } from "./clients.js";
 import { cfgDir, loadConfig, relocate, resolve, saveConfig } from "./config.js";
+import { c, dur, header, mark, say, spinner, VERSION, wrap } from "./ui.js";
 const NAME = launcher().at(-1) === "getclaros" ? "npx getclaros" : "getclaros";
-const say = (s = "") => process.stdout.write(s + "\n");
 const warn = (s) => process.stderr.write(s + "\n");
 const tilde = (p) => p.startsWith(homedir()) ? "~" + p.slice(homedir().length) : p;
 const keyId = (k) => k.split("_").slice(0, 2).join("_") + "_…"; // clr_<prefix>_… (the prefix is the lookup id, not the secret)
@@ -89,7 +89,6 @@ async function locate(v) {
     return r;
 }
 // ---- browser sign-in (RFC 8628 device flow) ----
-const VERSION = "0.1.0";
 const sleep = (s) => new Promise((ok) => setTimeout(ok, s * Number(process.env.GETCLAROS_INTERVAL_MS ?? 1000)));
 function openBrowser(url) {
     if (process.env.GETCLAROS_NO_BROWSER)
@@ -115,13 +114,22 @@ async function deviceSignIn(url, browser) {
     catch {
         return "unsupported";
     }
-    say(`Sign in to Claros in your browser:
-
-  ${d.verification_uri_complete ?? d.verification_uri}
-
-and check it shows the code ${d.user_code}. Waiting…`);
+    const link = d.verification_uri_complete ?? d.verification_uri;
+    say(`  ${c.bold("Sign in")}  ${c.dim(browser ? "opening your browser" : "open this in your browser")}`);
+    say(`  ${c.violet(mark.arrow)} ${c.ul(link)}`);
+    say(`    Code ${c.bold(c.violet(d.user_code))}  ${c.dim("approve only if the page shows this code")}`);
+    say();
     if (browser)
-        openBrowser(d.verification_uri_complete ?? d.verification_uri);
+        openBrowser(link);
+    const spin = spinner("Waiting for you to approve in the browser…");
+    try {
+        return await poll(url, d);
+    }
+    finally {
+        spin.stop();
+    }
+}
+async function poll(url, d) {
     let interval = Number(d.interval) || 5;
     const until = Date.now() + (Number(d.expires_in) || 600) * 1000;
     while (Date.now() < until) {
@@ -242,6 +250,7 @@ catch {
 const where = (s) => s.scope[0] === "projects" ? ` (project ${tilde(s.scope[1])})` : "";
 // ---- init ----
 async function init(v, project) {
+    header();
     const at = await locate(v);
     if (!at)
         return 3;
@@ -274,42 +283,52 @@ async function init(v, project) {
     workspace ??= await whoami(url, key);
     const cfg = saved.url === url && saved.web === web && saved.key === key && saved.workspace?.name === workspace?.name
         ? join(cfgDir(), "config.json") : saveConfig({ url, web, key, ...(workspace ? { workspace } : {}) });
-    say(`Signed in to ${url}${workspace?.name ? ` (workspace "${workspace.name}")` : ""} with key ${keyId(key)} (saved in ${tilde(cfg)}, readable only by you).`);
+    say(`  ${c.ask(mark.ok)} Signed in${workspace?.name ? ` to workspace ${c.bold(`"${workspace.name}"`)}` : ""}  ${c.dim(`key ${keyId(key)}`)}`);
+    say(c.dim(`    ${url} ${mark.dot} key saved in ${tilde(cfg)}, readable only by you`));
     const files = detect(project);
     if (!files.length) {
-        say(`\nSee a stop now: ${NAME} test`);
-        say("To guard an agent's tools: add an MCP server to Claude Code, Claude Desktop, Cursor, VS Code or Codex (none has one yet), then run init again.");
+        say(`\n  See a stop now: ${c.bold(`${NAME} test`)}`);
+        say(c.dim(wrap("  To guard an agent's tools: add an MCP server to Claude Code, Claude Desktop, Cursor, VS Code or Codex (none has one yet), then run init again.", 2)));
         return 1;
     }
     const maps = await api(url, key, "/api/workflows").then((r) => (Array.isArray(r.json) ? r.json : []), () => []);
     const mapOf = (name) => maps.find((m) => (m.apps ?? []).some((a) => norm(a) && norm(name) && (norm(a).includes(norm(name)) || norm(name).includes(norm(a)))));
-    const cands = [];
-    say();
+    // per client: the servers it can guard (numbered, ● = matches a Work Map), the ones already guarded; the remote
+    // servers it can't guard yet are gathered into one line per reason under the list
+    const cands = [], gaps = new Map();
+    const all = files.flatMap((f) => f.servers);
+    const w = Math.min(28, Math.max(8, ...all.map((s) => (s.name + where(s)).length)));
+    say(`\n  ${c.bold("MCP servers")}`);
     for (const f of files) {
-        say(`${f.client}  ${tilde(f.path)}`);
+        say(`\n  ${c.bold(f.client)}  ${c.dim(tilde(f.path))}`);
         if (f.error)
-            say(`      couldn't read it (${f.error}); left alone`);
+            say(c.dim(`    couldn't read it (${f.error}); left alone`));
         for (const s of f.servers) {
+            const label = (s.name + where(s)).padEnd(w);
             if (s.ours)
-                say(`      ${s.name}${where(s)}  Claros MCP server (agents read the Work Map with get_workflow)`);
+                continue;
+            if (s.gap)
+                gaps.set(s.gap, [...(gaps.get(s.gap) ?? []), s.name]);
             else if (s.guarded)
-                say(`  [=] ${s.name}${where(s)}  already guarded`);
-            else if (s.gap)
-                say(`  [ ] ${s.name}${where(s)}  remote ${site(s.entry.url)}: ${s.gap}`);
+                say(`    ${c.ask(" =")}   ${label} ${c.dim("already guarded")}`);
             else {
                 const m = mapOf(s.name);
                 cands.push(s);
-                say(`  ${String(cands.length).padStart(2)}. ${s.name}${where(s)}  ${s.remote ? `remote ${site(s.entry.url)}` : show(argvOf(s.entry))}` +
-                    (m ? `  ← Work Map "${m.name}"` : ""));
+                say(`    ${String(cands.length).padStart(2)} ${m ? c.ask(mark.on) : c.dim(mark.off)} ${m ? c.bold(label) : label} ` +
+                    c.dim(s.remote ? `remote ${site(s.entry.url)}` : show(argvOf(s.entry))) + (m ? `  ${c.ask(`Work Map "${m.name}"`)}` : ""));
             }
         }
     }
+    for (const [gap, names] of gaps) {
+        const u = [...new Set(names)], n = u.length, why = gap.replace(/ – not guarded yet$/, "");
+        const what = why.startsWith("needs ") ? `${n > 1 ? "need" : "needs"} ${why.slice(6)}` : `(${why})`;
+        say(c.dim(wrap(`\n  ${mark.dot} ${n} remote server${n > 1 ? "s" : ""} ${what} ${mark.dash} guard ${n > 1 ? "them" : "it"} later: ${u.join(", ")}`, 4)));
+    }
     say();
     const byName = (names) => cands.filter((s) => names.includes(s.name));
     let picks = cands.filter((s) => mapOf(s.name));
     if (v.servers !== undefined) {
         const names = v.servers.split(",").map((s) => s.trim()).filter(Boolean);
-        const all = files.flatMap((f) => f.servers);
         for (const n of names) {
             const hit = all.filter((s) => s.name === n);
             if (!hit.length) {
@@ -317,9 +336,9 @@ async function init(v, project) {
                 return 2;
             }
             if (hit.every((s) => s.gap))
-                say(`${n}: remote server, ${hit[0].gap}.`);
+                say(c.dim(`  ${mark.dot} ${n}: remote server, ${hit[0].gap}.`));
             else if (hit.every((s) => s.guarded || s.gap))
-                say(`${n}: already guarded.`);
+                say(c.dim(`  ${mark.dot} ${n}: already guarded.`));
         }
         picks = byName(names);
     }
@@ -329,8 +348,11 @@ async function init(v, project) {
             return 2;
         }
         const def = picks.map((s) => cands.indexOf(s) + 1).join(",");
+        if (def)
+            say(c.dim(`  ${mark.on} matches a Work Map: recommended`));
         for (;;) {
-            const a = (await ask(`Guard which? Numbers (1,3), "all", "none"${def ? `, Enter = ${def}` : ""}: `)).trim().toLowerCase();
+            const a = (await ask(`  ${c.bold("Guard which?")} ${c.dim(`Enter = ${def ? `${def} (recommended)` : "none"} ${mark.dot} numbers like 1,3 ${mark.dot} all ${mark.dot} none`)} ${c.violet(mark.arrow)} `))
+                .trim().toLowerCase();
             if (!a)
                 break;
             if (a === "none") {
@@ -346,22 +368,24 @@ async function init(v, project) {
                 picks = ns.map((n) => cands[n - 1]);
                 break;
             }
-            warn(`Pick numbers between 1 and ${cands.length}.`);
+            warn(`  Pick numbers between 1 and ${cands.length}.`);
         }
+        say();
     }
     else if (!picks.length && cands.length) {
-        say("None of these servers matches a Work Map yet, so none is guarded. Pick them with --servers a,b.");
+        say(c.dim(wrap("  None of these servers matches a Work Map yet, so none is guarded. Pick them with --servers a,b.", 2)));
     }
     const run = newRun();
-    const changed = [];
+    const changed = [], guardedIn = new Map(), added = [];
     const userClients = new Set(files.filter((f) => f.user && !f.error).map((f) => f.client));
     for (const f of files.filter((x) => !x.error)) {
-        const before = f.text, mine = picks.filter((s) => s.file === f);
+        const before = f.text, mine = picks.filter((s) => s.file === f), got = [];
+        let mcp = false;
         try {
             for (const s of mine) {
                 f.text = wrapServer(f, s);
                 load(f);
-                say(`guarded ${s.name}${where(s)} in ${f.client} (${tilde(f.path)})`);
+                got.push(s.name + where(s));
             }
             // the Claros MCP server: in each client's user config, or its project file when the client has none
             const top = f.servers.find((s) => s.name === CLAROS && s.scope.length === 1);
@@ -369,32 +393,43 @@ async function init(v, project) {
                 if (!top) {
                     f.text = addClaros(f);
                     load(f);
-                    say(`added the Claros MCP server to ${f.client} (${tilde(f.path)})`);
+                    mcp = true;
                 }
                 else if (!top.ours)
-                    say(`kept the existing "${CLAROS}" entry in ${tilde(f.path)} (not ours)`);
+                    say(c.dim(`  ${mark.dot} kept the existing "${CLAROS}" entry in ${tilde(f.path)} (not ours)`));
             }
         }
         catch (e) {
-            warn(`${tilde(f.path)}: ${e.message}; left unchanged`);
+            warn(`  ${tilde(f.path)}: ${e.message}; left unchanged`);
             f.text = before;
             continue;
         }
         if (f.text !== before) {
             commit(run, f.path, before, f.text);
             changed.push(f.client);
+            for (const n of got)
+                guardedIn.set(n, [...(guardedIn.get(n) ?? []), f.client]);
+            if (mcp)
+                added.push(f.client);
         }
     }
     if (!changed.length) {
-        say("Nothing to change.");
+        say("  Nothing to change.");
         return 0;
     }
-    say(`\nBacked up every file before changing it (${tilde(run.dir)}).`);
-    say(`Restart ${[...new Set(changed)].join(", ")} to load the change. Then: ${NAME} test   Undo: ${NAME} undo`);
+    const list = (xs) => [...new Set(xs)].join(", ");
+    for (const [n, cl] of guardedIn)
+        say(`  ${c.ask(mark.ok)} Guarded ${c.bold(n)}  ${c.dim(`in ${list(cl)}`)}`);
+    if (added.length)
+        say(`  ${c.ask(mark.ok)} Added the Claros MCP server  ${c.dim(`in ${list(added)}`)}`);
+    say(c.dim(`    every file backed up first: ${tilde(run.dir)}`));
+    say(`\n  ${c.bold("Next")}  restart ${list(changed)}, then run  ${c.violet(`${NAME} test`)}`);
+    say(c.dim(`        undo anytime: ${NAME} undo`));
     return 0;
 }
 // ---- test ----
 async function test(v, project) {
+    header();
     const at = await locate(v);
     if (!at)
         return 3;
@@ -412,7 +447,7 @@ async function test(v, project) {
             return 3;
         }
         if (ex.status === 404) {
-            say(`No approved Work Map with an exact rule to test yet. Paste a policy at ${at.web}/policy, approve the map, then run this again.`);
+            say(`  No approved Work Map with an exact rule to test yet. Paste a policy at ${at.web}/policy, approve the map, then run this again.`);
             return 1;
         }
         if (ex.status !== 200)
@@ -423,21 +458,27 @@ async function test(v, project) {
         if (r.status !== 200)
             throw new Error(`HTTP ${r.status}`);
         const ms = Date.now() - t0;
-        if (e.demo)
-            say(`DEMO: ${guarded.length ? `none of your guarded servers (${guarded.join(", ")}) matches` : "no server is guarded yet, so nothing matches"} a Work Map, so this checks a made-up record against "${e.name}".`);
-        say(`Made-up test action for ${e.app ?? "a demo app"} (only checked, never run): ${Object.entries(e.state).map(([k, x]) => `${k} = ${x}`).join(", ")}`);
         if (r.json.allowed) {
-            say(`\nClaros let it through (check ${r.json.check_id}). It should have been stopped by rule ${e.guardrail_id}; tell the Claros team.`);
+            say(`  ${c.stop(mark.no)} Claros let it through (check ${r.json.check_id}). It should have been stopped by rule ${e.guardrail_id}; tell the Claros team.`);
             return 1;
         }
-        say(`\nClaros stopped it in ${ms} ms (Work Map "${e.name}", check ${r.json.check_id}):`);
+        // the outcome first, then a card per broken rule, then the made-up action and what the agent sees
+        const held = r.json.result === "ask", ink = held ? c.ask : c.stop;
+        say(`  ${ink(c.bold(`${held ? mark.ask : mark.stop} ${held ? "Held to ask first" : "Stopped"} in ${dur(ms)}`))}  ` +
+            c.dim(`Work Map "${e.name}" ${mark.dot} check ${r.json.check_id}`));
         for (const x of r.json.violations.filter((x) => x.action === "stop" || x.action === "ask")) {
-            say(`\n  Rule: ${x.rule}`);
+            const ask = x.action === "ask", p = ask ? c.ask : c.stop;
+            say();
+            say(`    ${p(`${ask ? mark.ask : mark.stop} ${ask ? "ask " : "stop"}`)}  ${c.bold(wrap(x.rule, 12))}`);
             if (x.quote)
-                say(`  In the expert's words${x.expert ? ` (${x.expert})` : ""}: "${x.quote}"`);
-            say(`  Who to ask: ${x.who_to_ask || x.owner || x.expert || "the process owner"}`);
+                say(`            ${wrap(`“${x.quote}”`, 12)}${x.expert ? c.dim(` ${mark.dash} ${x.expert}`) : ""}`);
+            say(`            ${c.dim("Who to ask:")} ${x.who_to_ask || x.owner || x.expert || "the process owner"}`);
         }
-        say(`\nYour agent gets this as the tool's error instead of the call going through. Nothing was sent to ${e.app ?? "any app"}.`);
+        say();
+        say(c.dim(wrap(`  Test action for ${e.app ?? "a demo app"}, made up, only checked: ${Object.entries(e.state).map(([k, x]) => `${k} = ${x}`).join(", ")}`, 4)));
+        say(wrap(`  Your agent gets the rule as the tool's error. Nothing reached ${e.app ?? "any app"}.`, 2));
+        if (e.demo)
+            say(c.dim(wrap(`  Demo: ${guarded.length ? `none of your guarded servers (${guarded.join(", ")}) matches a Work Map` : "no server is guarded yet"}, so this used your newest Work Map.`, 2)));
         return 0;
     }
     catch (err) {
@@ -503,6 +544,7 @@ async function override(v, checkId) {
 }
 // ---- status ----
 async function status(v, project) {
+    header();
     const at = await locate(v);
     if (!at)
         return 3;
@@ -510,12 +552,16 @@ async function status(v, project) {
     const up = await fetch(url + "/healthz", { signal: AbortSignal.timeout(10_000) }).then((r) => r.ok, () => false);
     const ks = key ? await keyStatus(url, key) : "not set (run init)";
     const ws = ks === "valid" ? (await whoami(url, key))?.name ?? (loadConfig().key === key ? loadConfig().workspace?.name : null) : null;
-    say(`Claros  ${url}  ${up ? "reachable" : "unreachable"}  key ${key ? keyId(key) + " " : ""}${ks}${ws ? `  workspace "${ws}"` : ""}`);
+    const ok = (good, s) => (good ? c.ask(s) : c.stop(s));
+    const fine = up && ks === "valid";
+    say(`  ${ok(fine, fine ? mark.ok : mark.no)} ${c.bold("Claros")}  ${url}  ${ok(up, up ? "reachable" : "unreachable")}` +
+        `  key ${key ? keyId(key) + " " : ""}${ok(ks === "valid", ks)}${ws ? `  workspace "${ws}"` : ""}`);
     for (const f of detect(project)) {
-        say(`\n${f.client}  ${tilde(f.path)}${f.error ? `  couldn't read it (${f.error})` : ""}`);
+        say(`\n  ${c.bold(f.client)}  ${c.dim(tilde(f.path))}${f.error ? `  couldn't read it (${f.error})` : ""}`);
         for (const s of f.servers) {
-            say(`  ${(s.name + where(s)).padEnd(24)} ${s.ours ? "Claros MCP server" : s.guarded ? "guarded"
-                : s.gap ? `remote, ${s.gap}` : s.remote ? "remote, not guarded" : "not guarded"}`);
+            const [m, state] = s.ours ? [c.violet(mark.dot), c.dim("Claros MCP server")] : s.guarded ? [c.ask(mark.ok), c.ask("guarded")]
+                : s.gap ? [c.dim(mark.dot), c.dim(`remote, ${s.gap}`)] : [c.dim(mark.off), s.remote ? "remote, not guarded" : "not guarded"];
+            say(`    ${m} ${(s.name + where(s)).padEnd(24)} ${state}`);
         }
     }
     return !key ? 2 : up && ks === "valid" ? 0 : 3;
@@ -536,9 +582,10 @@ function unwrapAll(f) {
     return n;
 }
 async function undo(v, project) {
+    header();
     const scope = v.all ? runs() : runs().slice(-1);
     if (!scope.length && !v.all) {
-        say(`Nothing to undo: no backups from ${NAME} init.`);
+        say(`  Nothing to undo: no backups from ${NAME} init.`);
         return 0;
     }
     const chains = new Map();
@@ -549,14 +596,14 @@ async function undo(v, project) {
     const byPath = new Map(detect(project).map((f) => [f.path, f]));
     for (const [path, chain] of chains) {
         if (!existsSync(path)) {
-            say(`${tilde(path)}: gone; nothing to undo`);
+            say(`  ${mark.dot} ${tilde(path)}: gone; nothing to undo`);
             continue;
         }
         const cur = readFileSync(path, "utf8");
         const same = sha(cur) === chain.at(-1).after && chain.every((b, i) => !i || b.before === chain[i - 1].after);
         if (same) {
             commit(safety, path, cur, readFileSync(chain[0].backup, "utf8"));
-            say(`${tilde(path)}: restored from the backup taken before init (unchanged since)`);
+            say(`  ${c.ask(mark.ok)} ${tilde(path)}: restored from the backup taken before init (unchanged since)`);
         }
         else {
             const f = byPath.get(path) ?? detect(project).find((x) => x.path === path);
@@ -567,7 +614,7 @@ async function undo(v, project) {
             const n = unwrapAll(f);
             if (f.text !== cur)
                 commit(safety, path, cur, f.text);
-            say(`${tilde(path)}: changed since init, so unwrapped ${n} server(s) in place and kept the other edits`);
+            say(`  ${c.ask(mark.ok)} ${tilde(path)}: changed since init, so unwrapped ${n} server(s) in place and kept the other edits`);
         }
         byPath.delete(path);
     }
@@ -578,12 +625,12 @@ async function undo(v, project) {
             const cur = f.text, n = unwrapAll(f);
             if (f.text !== cur) {
                 commit(safety, f.path, cur, f.text);
-                say(`${tilde(f.path)}: unwrapped ${n} server(s) in place`);
+                say(`  ${c.ask(mark.ok)} ${tilde(f.path)}: unwrapped ${n} server(s) in place`);
             }
         }
     }
     for (const r of scope)
         renameSync(r.dir, r.dir + ".undone");
-    say(`Done. Restart your agent clients to load the change.${safety.files.length ? ` What undo replaced is in ${tilde(safety.dir)}.` : ""}`);
+    say(`\n  ${c.bold("Done.")} Restart your agent clients to load the change.${safety.files.length ? ` What undo replaced is in ${tilde(safety.dir)}.` : ""}`);
     return 0;
 }

package/dist/ui.js

@@ -0,0 +1,67 @@
+// Terminal styling for init / test / status / undo: hand-rolled ANSI, no dependency.
+// fancy (the header, the spinner, wrapped cards) when stdout is a terminal or FORCE_COLOR is set; colour when the
+// terminal has it, by Node's own rules (NO_COLOR, FORCE_COLOR, TERM=dumb, COLORTERM, Windows versions). Piped:
+// plain text, no escape codes, so the output stays greppable. Marks fall back to ASCII on old Windows consoles.
+import { readFileSync } from "node:fs";
+import { WriteStream } from "node:tty";
+export const VERSION = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+export function styleFor(s, env = process.env, platform = process.platform) {
+    const forced = env.FORCE_COLOR !== undefined && !["0", "false"].includes(env.FORCE_COLOR);
+    const fancy = !!s.isTTY || forced;
+    const depth = fancy ? WriteStream.prototype.getColorDepth.call(null, env) : 1;
+    const uni = platform !== "win32" || !!(env.WT_SESSION || env.TERM_PROGRAM || env.TERM?.startsWith("xterm"));
+    return { fancy, depth, uni };
+}
+export const S = styleFor(process.stdout);
+// the brand's three answers (stop magenta, ask green, nudge vermilion) and the quote's violet, a shade brighter than
+// the web's inks so they read on dark terminals as well as light ones: [truecolor, 256-colour, 16-colour]
+const INK = { stop: ["#c8359a", 162, 35], ask: ["#22995f", 29, 32], nudge: ["#e0531f", 166, 31], violet: ["#8b5cf6", 98, 34] };
+const fg = ([hex, n, basic]) => S.depth >= 24
+    ? `38;2;${[1, 3, 5].map((i) => parseInt(hex.slice(i, i + 2), 16)).join(";")}` : S.depth >= 8 ? `38;5;${n}` : String(basic);
+const sgr = (on, off) => (s) => (S.depth > 1 && s ? `\x1b[${on}m${s}\x1b[${off}m` : s);
+export const c = {
+    bold: sgr("1", "22"), dim: sgr("2", "22"), ul: sgr("4", "24"),
+    stop: sgr(fg(INK.stop), "39"), ask: sgr(fg(INK.ask), "39"), nudge: sgr(fg(INK.nudge), "39"), violet: sgr(fg(INK.violet), "39"),
+};
+const U = S.uni;
+/** stop = the seal, ask = the thread hooked to a person, nudge = the proofreader's pencil */
+export const mark = {
+    stop: U ? "◉" : "x", ask: U ? "↳" : "?", nudge: U ? "✎" : "~", ok: U ? "✓" : "+", no: U ? "✗" : "x",
+    on: U ? "●" : "*", off: U ? "○" : "o", dot: U ? "·" : "-", arrow: U ? "›" : ">", dash: U ? "—" : "-",
+};
+export const say = (s = "") => process.stdout.write(s + "\n");
+/** claros” and the version: only on a terminal (piped output starts with what it says) */
+export function header() {
+    if (S.fancy)
+        say(`\n  ${c.bold("claros")}${c.violet(U ? "”" : '"')}  ${c.dim(`getclaros ${VERSION}`)}\n`);
+}
+/** wraps to the terminal's width with a hanging indent (plain output isn't wrapped) */
+export function wrap(text, indent) {
+    const width = (process.stdout.columns || 0) - indent;
+    if (!S.fancy || width < 30)
+        return text;
+    const lead = /^\s*/.exec(text)[0], out = [];
+    let line = lead;
+    for (const w of text.slice(lead.length).split(" ")) {
+        if (line.trim() && (line + " " + w).length > width) {
+            out.push(line);
+            line = w;
+        }
+        else
+            line = line.trim() ? line + " " + w : line + w;
+    }
+    out.push(line);
+    return out.join("\n" + " ".repeat(indent));
+}
+/** a braille spinner on a real terminal (never when piped or forced); stop() clears its line */
+export function spinner(text) {
+    if (!process.stdout.isTTY)
+        return { stop() { } };
+    const F = U ? "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏" : "|/-\\";
+    let i = 0;
+    const draw = () => process.stdout.write(`\r\x1b[2K  ${c.violet(F[i++ % F.length])} ${c.dim(text)}`);
+    draw();
+    const t = setInterval(draw, 80);
+    return { stop() { clearInterval(t); process.stdout.write("\r\x1b[2K"); } };
+}
+export const dur = (ms) => (ms < 1000 ? `${ms} ms` : `${(ms / 1000).toFixed(1)} s`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "getclaros",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Claros guard: checks an agent's MCP tool calls against your experts' rules before they run",
   "license": "MIT",
   "type": "module",