plures 1.10.0 → 1.12.0

package/README.md

@@ -49,6 +49,8 @@ if (event.type === "task.completed" && event.data.result?.agreement === 1) {
 - `new Plures(key, { app: "support-agent" })` or `PLURES_APP`: send everything to one of your apps. `plures.apps.list()`, `.create({ name, id? })`, `.retrieve(id)`, `.update(id, { name?, id?, default? })`, `.del(id)`. Each app keeps its own tasks, ledger view, map and quality.
 - `plures.maps.guide()`, `.retrieve(app)`, `.upload(app, map)`, `.setCheckpoint(app, id, status)`: the agent map, where your agent needs a person. Or run `npx plures map` in your repo: your own coding agent reads the code and only the map is sent.
 - `plures.maps.createKey(app, { label? })`, `.keys(app)`, `.revokeKey(app, id)`: map keys for CI, which can only read and upload that app's map. `.workflow(app, branch?)` returns the GitHub Action that maps on every push; `npx plures map workflow` writes it to `.github/workflows/plures-map.yml`. Or use **Map with GitHub** on the app's map page and Plures opens the pull request for you, then **Turn on mapping** merges it. `plures.maps.startRun(app)` and `.runs(app)`: in CI with no Claude key, `npx plures map` starts a run where Plures runs Claude (first map free, then Claude's cost plus 30%, at most $5).
+- In your terminal, `npx plures map` opens your map page so you can watch it build (`--no-open` to skip), keeps one live line of what it's reading, and ends by drawing the map's flows with the checks Plures suggests. On GitHub and other CI it prints a plain log.
+- `npx plures map` shows each file as Claude Code reads it and sends the file names (never their contents) to Plures, so the map page shows the reading live and the map builds itself when it lands. `plures.maps.progress(app, { session, phase, events })` is the call behind it.
 - `plures.github.repos()`, `.connect(app, "owner/repo")`, `.turnOn(app)`, `.status(app)`, `.disconnect(app)`: Map with GitHub from code. Plures sets the repo's map key secret and opens a pull request adding the workflow; `turnOn` merges it. Installing the Plures GitHub App needs a browser once (`install_url`). From a terminal: `npx plures map github connect`, then `npx plures map github on`.
 - `plures.quality.sample({ rubric, output, input? })`: send every output; a share is graded by people against the rubric, with personal details taken out first. `plures.quality.rubrics.create({ name, question, options, sample_rate })`, `.retrieve(name)` (score by day, this week against the four before, drift), `.list()`, `.update()`, `.del()`. `plures.quality.compare({ release, input, a, b })` and `plures.quality.release(name)` for blind release checks. `plures.quality.export(rubric)` returns graded samples for evals or fine tuning.
 - `plures.testMix.set({ unanimous: 70, split: 20, tie: 5, expired: 5 })`, `.get()`, `.clear()`: with a test key, makes a share of test tasks split, tie or expire at random so you can test routing to your team without changing your agent. A task can override it with `metadata.test_mix`, and `metadata.test_outcome` beats both.

package/dist/chunk-GDI4KDAH.js

@@ -0,0 +1,205 @@
+// src/index.ts
+var VERSION = "1.12.0";
+var PluresError = class extends Error {
+  constructor(message, status, type) {
+    super(message);
+    this.status = status;
+    this.type = type;
+  }
+  status;
+  type;
+};
+var Plures = class {
+  base;
+  apiKey;
+  /** The app tasks go to when they don't name one. From opts.app or PLURES_APP. */
+  app;
+  ua;
+  constructor(apiKey, opts = {}) {
+    const key = apiKey ?? (typeof process !== "undefined" ? process.env?.PLURES_API_KEY : void 0);
+    if (!key) throw new Error("Pass your Plures API key, or set PLURES_API_KEY. Get a free test key at https://plures.si/?for=developers#join");
+    this.apiKey = key;
+    this.ua = opts.userAgent ?? `plures-js/${VERSION}`;
+    this.app = opts.app ?? (typeof process !== "undefined" ? process.env?.PLURES_APP : void 0) ?? null;
+    this.base = (opts.baseUrl ?? (typeof process !== "undefined" ? process.env?.PLURES_BASE_URL : void 0) ?? "https://plures.si").replace(/\/$/, "");
+  }
+  async req(method, path, body, headers = {}) {
+    for (let attempt = 0; ; attempt++) {
+      const r = await fetch(this.base + path, {
+        method,
+        headers: { authorization: `Bearer ${this.apiKey}`, "user-agent": this.ua, ...body ? { "content-type": "application/json" } : {}, ...this.app ? { "plures-app": this.app } : {}, ...headers },
+        body: body ? JSON.stringify(body) : void 0
+      });
+      if (r.status >= 500 && attempt < 2) {
+        await sleep(500 * 2 ** attempt);
+        continue;
+      }
+      const data = await r.json().catch(() => ({}));
+      if (!r.ok) throw new PluresError(data?.error?.message ?? `HTTP ${r.status}`, r.status, data?.error?.type ?? "api_error");
+      return data;
+    }
+  }
+  tasks = {
+    /** Sends a question to verified people. Pass an idempotency key to make retries safe. */
+    create: (params, opts = {}) => this.req("POST", "/api/v1/tasks", params, opts.idempotencyKey ? { "idempotency-key": opts.idempotencyKey } : {}),
+    retrieve: (id) => this.req("GET", `/api/v1/tasks/${encodeURIComponent(id)}`),
+    list: (params = {}) => {
+      const q = new URLSearchParams(Object.entries(params).filter(([, v]) => v != null).map(([k, v]) => [k, String(v)]));
+      return this.req("GET", `/api/v1/tasks${q.size ? `?${q}` : ""}`);
+    },
+    cancel: (id) => this.req("POST", `/api/v1/tasks/${encodeURIComponent(id)}/cancel`),
+    /** Polls until the task is settled. Prefer webhooks in production. */
+    waitFor: async (id, opts = {}) => {
+      const end = Date.now() + (opts.timeoutMs ?? 10 * 6e4);
+      for (; ; ) {
+        const t = await this.tasks.retrieve(id);
+        if (t.status !== "pending") return t;
+        if (Date.now() > end) return t;
+        await sleep(opts.intervalMs ?? 3e3);
+      }
+    }
+  };
+  /**
+   * Test keys only. How test tasks behave when they don't set metadata.test_outcome,
+   * so an agent running unchanged sends a share of decisions to your team.
+   * A single task can override it with metadata.test_mix.
+   */
+  testMix = {
+    get: () => this.req("GET", "/api/v1/test_mix"),
+    /** For example { unanimous: 70, split: 20, tie: 5, expired: 5 }. Pass null to turn it off. */
+    set: (mix) => this.req("PUT", "/api/v1/test_mix", { mix }),
+    clear: () => this.req("DELETE", "/api/v1/test_mix")
+  };
+  /**
+   * Where tasks go. set() replaces what you send (team, groups or rules) and keeps the rest.
+   * For example { groups: [{ name: "Finance", emails: ["ap@acme.com"] }], rules: [{ category: "refunds", route: "team", group: "Finance" }] }.
+   */
+  routing = {
+    get: () => this.req("GET", "/api/v1/routing"),
+    set: (update) => this.req("PUT", "/api/v1/routing", update)
+  };
+  /** Your apps. Each agent you run can be its own app, with its own tasks, ledger view and map. */
+  apps = {
+    list: () => this.req("GET", "/api/v1/apps"),
+    /** { name: "Support agent" }, with an optional id like "support-agent". */
+    create: (params) => this.req("POST", "/api/v1/apps", params),
+    retrieve: (id) => this.req("GET", `/api/v1/apps/${encodeURIComponent(id)}`),
+    /** Rename it, change its id (its tasks move with it), or make it the default. */
+    update: (id, params) => this.req("PATCH", `/api/v1/apps/${encodeURIComponent(id)}`, params),
+    /** Only an app with no tasks can be deleted. */
+    del: (id) => this.req("DELETE", `/api/v1/apps/${encodeURIComponent(id)}`)
+  };
+  /**
+   * Agent maps: where each app's agent needs a person. Your coding agent reads your code and
+   * writes the map; Plures gets only the map. guide() returns the steps it follows.
+   */
+  maps = {
+    guide: async () => {
+      const r = await fetch(`${this.base}/api/v1/map_guide`);
+      return r.text();
+    },
+    retrieve: (app) => this.req("GET", `/api/v1/apps/${encodeURIComponent(app)}/map`),
+    /** Uploads a new version. Checks you already added or dismissed keep that. */
+    upload: (app, map) => this.req("PUT", `/api/v1/apps/${encodeURIComponent(app)}/map`, map),
+    setCheckpoint: (app, id, status) => this.req("PATCH", `/api/v1/apps/${encodeURIComponent(app)}/map/checkpoints/${encodeURIComponent(id)}`, { status }),
+    /** A key that can only read and upload this app's map, for CI. The key is in the response once. */
+    createKey: (app, opts = {}) => this.req("POST", `/api/v1/apps/${encodeURIComponent(app)}/map_keys`, opts),
+    keys: (app) => this.req("GET", `/api/v1/apps/${encodeURIComponent(app)}/map_keys`),
+    revokeKey: (app, id) => this.req("DELETE", `/api/v1/apps/${encodeURIComponent(app)}/map_keys/${encodeURIComponent(id)}`),
+    /** Starts a map run where Plures runs Claude (CI with no Anthropic key). npx plures map does this. */
+    startRun: (app) => this.req("POST", `/api/v1/apps/${encodeURIComponent(app)}/map_runs`, {}),
+    runs: (app) => this.req("GET", `/api/v1/apps/${encodeURIComponent(app)}/map_runs`),
+    /** While mapping, which files the coding agent is reading, shown live on the map page. File names only. npx plures map does this. */
+    progress: (app, p) => this.req("POST", `/api/v1/apps/${encodeURIComponent(app)}/map/progress`, p),
+    /** The GitHub Actions workflow that maps a repo on every push to its main branch. */
+    workflow: async (app, branch = "main") => {
+      const r = await fetch(`${this.base}/api/v1/map_workflow?app=${encodeURIComponent(app)}&branch=${encodeURIComponent(branch)}`);
+      return r.text();
+    }
+  };
+  /**
+   * Map with GitHub: Plures adds a workflow to your repo by pull request and keeps the app's map
+   * current on every push. Installing the Plures GitHub App needs a browser once (installUrl);
+   * everything after that works here.
+   */
+  github = {
+    /** Repos the Plures GitHub App can reach. installed is false until you install it at install_url. */
+    repos: () => this.req("GET", "/api/v1/github/repos"),
+    /** Where an app's GitHub link stands: repo, pull request, mapping on, latest run, last map. */
+    status: (app) => this.req("GET", `/api/v1/apps/${encodeURIComponent(app)}/github`),
+    /** Connects a repo ("owner/name"): sets its map key secret and opens the pull request. */
+    connect: (app, repo) => this.req("POST", `/api/v1/apps/${encodeURIComponent(app)}/github`, { repo }),
+    /** Turns mapping on by merging the pull request. The repo's own rules (reviews, checks) still apply. */
+    turnOn: (app) => this.req("POST", `/api/v1/apps/${encodeURIComponent(app)}/github/merge`, {}),
+    /** Revokes the repo's map key. Delete the workflow file in the repo to stop runs. */
+    disconnect: (app) => this.req("DELETE", `/api/v1/apps/${encodeURIComponent(app)}/github`)
+  };
+  /**
+   * Quality: people grade a sample of your agent's outputs against a rubric, so you see drift
+   * early, and compare two versions blind before you ship. Personal details are taken out first.
+   */
+  quality = {
+    /** Send every output; the rubric's sample rate decides which ones people grade. */
+    sample: (p) => this.req("POST", "/api/v1/samples", p),
+    /** A blind release check: a is the current version's output, b the new one's, for the same input. */
+    compare: (p) => this.req("POST", "/api/v1/comparisons", p),
+    /** How often people preferred the new version, with a 95% range and a verdict. */
+    release: (name, opts = {}) => this.req("GET", `/api/v1/releases/${encodeURIComponent(name)}${opts.app ? `?app=${encodeURIComponent(opts.app)}` : ""}`),
+    rubrics: {
+      list: (opts = {}) => this.req("GET", `/api/v1/rubrics${opts.app ? `?app=${encodeURIComponent(opts.app)}` : ""}`),
+      /** { name: "reply_quality", question: "Is this reply correct and kind?", options: ["Good", "Okay", "Bad"], sample_rate: 0.05 } */
+      create: (p) => this.req("POST", "/api/v1/rubrics", p),
+      retrieve: (name, opts = {}) => this.req("GET", `/api/v1/rubrics/${encodeURIComponent(name)}${opts.app ? `?app=${encodeURIComponent(opts.app)}` : ""}`),
+      update: (name, p) => this.req("PATCH", `/api/v1/rubrics/${encodeURIComponent(name)}${p.app ? `?app=${encodeURIComponent(p.app)}` : ""}`, p),
+      del: (name, opts = {}) => this.req("DELETE", `/api/v1/rubrics/${encodeURIComponent(name)}${opts.app ? `?app=${encodeURIComponent(opts.app)}` : ""}`)
+    },
+    /** Graded samples as JSON lines (input, output, grade, score, agreement), for fine tuning or an eval set. */
+    export: async (rubric, opts = {}) => {
+      const q = new URLSearchParams(Object.entries({ app: opts.app ?? this.app ?? void 0, since: opts.since }).filter(([, v]) => v));
+      const r = await fetch(`${this.base}/api/v1/rubrics/${encodeURIComponent(rubric)}/export${q.size ? `?${q}` : ""}`, { headers: { authorization: `Bearer ${this.apiKey}`, "user-agent": this.ua } });
+      if (!r.ok) {
+        const d = await r.json().catch(() => ({}));
+        throw new PluresError(d?.error?.message ?? `HTTP ${r.status}`, r.status, d?.error?.type ?? "api_error");
+      }
+      return (await r.text()).split("\n").filter(Boolean).map((l) => JSON.parse(l));
+    }
+  };
+  /** Your prepaid credit. A live task that could cost more than available_cents is refused with a 402 insufficient_credits error. */
+  balance = () => this.req("GET", "/api/v1/balance");
+  /** Creates a task and waits for people to answer it. */
+  async verify(params, opts = {}) {
+    const t = await this.tasks.create(params, { idempotencyKey: opts.idempotencyKey });
+    return t.status === "pending" ? this.tasks.waitFor(t.id, { timeoutMs: opts.timeoutMs }) : t;
+  }
+  /**
+   * Checks the Plures-Signature header on a webhook and returns the parsed event.
+   * Pass the raw request body exactly as received. Throws if the signature is wrong
+   * or older than toleranceSec.
+   */
+  static async verifyWebhook(rawBody, signatureHeader, secret, toleranceSec = 300) {
+    const parts = Object.fromEntries((signatureHeader ?? "").split(",").map((p) => p.split("=", 2)));
+    const t = Number(parts.t);
+    if (!t || !parts.v1) throw new Error("Missing Plures-Signature header");
+    if (Math.abs(Date.now() / 1e3 - t) > toleranceSec) throw new Error("Webhook timestamp is too old");
+    const key = await crypto.subtle.importKey("raw", new TextEncoder().encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+    const mac = new Uint8Array(await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(`${t}.${rawBody}`)));
+    const expected = Array.from(mac, (b) => b.toString(16).padStart(2, "0")).join("");
+    if (!timingSafeEqual(expected, parts.v1)) throw new Error("Webhook signature does not match");
+    return JSON.parse(rawBody);
+  }
+};
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return diff === 0;
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var index_default = Plures;
+
+export {
+  VERSION,
+  PluresError,
+  Plures,
+  index_default
+};

package/dist/cli.cjs

@@ -1,20 +1,44 @@
 #!/usr/bin/env node
 "use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key2 of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key2) && key2 !== except)
+        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
 // src/cli.ts
 var import_node_child_process = require("child_process");
+var import_node_crypto = require("crypto");
+var import_node_path = require("path");
 var import_node_fs = require("fs");
 
-// src/index.js
-var VERSION = "1.9.1";
+// src/index.ts
+var VERSION = "1.12.0";
 var PluresError = class extends Error {
-  status;
-  type;
   constructor(message, status, type) {
     super(message);
     this.status = status;
     this.type = type;
   }
+  status;
+  type;
 };
 var Plures = class {
   base;
@@ -24,8 +48,7 @@ var Plures = class {
   ua;
   constructor(apiKey, opts = {}) {
     const key2 = apiKey ?? (typeof process !== "undefined" ? process.env?.PLURES_API_KEY : void 0);
-    if (!key2)
-      throw new Error("Pass your Plures API key, or set PLURES_API_KEY. Get a free test key at https://plures.si/?for=developers#join");
+    if (!key2) throw new Error("Pass your Plures API key, or set PLURES_API_KEY. Get a free test key at https://plures.si/?for=developers#join");
     this.apiKey = key2;
     this.ua = opts.userAgent ?? `plures-js/${VERSION}`;
     this.app = opts.app ?? (typeof process !== "undefined" ? process.env?.PLURES_APP : void 0) ?? null;
@@ -43,8 +66,7 @@ var Plures = class {
         continue;
       }
       const data = await r.json().catch(() => ({}));
-      if (!r.ok)
-        throw new PluresError(data?.error?.message ?? `HTTP ${r.status}`, r.status, data?.error?.type ?? "api_error");
+      if (!r.ok) throw new PluresError(data?.error?.message ?? `HTTP ${r.status}`, r.status, data?.error?.type ?? "api_error");
       return data;
     }
   }
@@ -62,10 +84,8 @@ var Plures = class {
       const end = Date.now() + (opts.timeoutMs ?? 10 * 6e4);
       for (; ; ) {
         const t = await this.tasks.retrieve(id);
-        if (t.status !== "pending")
-          return t;
-        if (Date.now() > end)
-          return t;
+        if (t.status !== "pending") return t;
+        if (Date.now() > end) return t;
         await sleep(opts.intervalMs ?? 3e3);
       }
     }
@@ -120,6 +140,8 @@ var Plures = class {
     /** Starts a map run where Plures runs Claude (CI with no Anthropic key). npx plures map does this. */
     startRun: (app2) => this.req("POST", `/api/v1/apps/${encodeURIComponent(app2)}/map_runs`, {}),
     runs: (app2) => this.req("GET", `/api/v1/apps/${encodeURIComponent(app2)}/map_runs`),
+    /** While mapping, which files the coding agent is reading, shown live on the map page. File names only. npx plures map does this. */
+    progress: (app2, p) => this.req("POST", `/api/v1/apps/${encodeURIComponent(app2)}/map/progress`, p),
     /** The GitHub Actions workflow that maps a repo on every push to its main branch. */
     workflow: async (app2, branch2 = "main") => {
       const r = await fetch(`${this.base}/api/v1/map_workflow?app=${encodeURIComponent(app2)}&branch=${encodeURIComponent(branch2)}`);
@@ -188,28 +210,195 @@ var Plures = class {
   static async verifyWebhook(rawBody, signatureHeader, secret, toleranceSec = 300) {
     const parts = Object.fromEntries((signatureHeader ?? "").split(",").map((p) => p.split("=", 2)));
     const t = Number(parts.t);
-    if (!t || !parts.v1)
-      throw new Error("Missing Plures-Signature header");
-    if (Math.abs(Date.now() / 1e3 - t) > toleranceSec)
-      throw new Error("Webhook timestamp is too old");
+    if (!t || !parts.v1) throw new Error("Missing Plures-Signature header");
+    if (Math.abs(Date.now() / 1e3 - t) > toleranceSec) throw new Error("Webhook timestamp is too old");
     const key2 = await crypto.subtle.importKey("raw", new TextEncoder().encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
     const mac = new Uint8Array(await crypto.subtle.sign("HMAC", key2, new TextEncoder().encode(`${t}.${rawBody}`)));
     const expected = Array.from(mac, (b) => b.toString(16).padStart(2, "0")).join("");
-    if (!timingSafeEqual(expected, parts.v1))
-      throw new Error("Webhook signature does not match");
+    if (!timingSafeEqual(expected, parts.v1)) throw new Error("Webhook signature does not match");
     return JSON.parse(rawBody);
   }
 };
 function timingSafeEqual(a, b) {
-  if (a.length !== b.length)
-    return false;
+  if (a.length !== b.length) return false;
   let diff = 0;
-  for (let i = 0; i < a.length; i++)
-    diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
   return diff === 0;
 }
 var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
+// src/term.ts
+var out = process.stdout;
+var fancy = Boolean(out.isTTY && !process.env.NO_COLOR && !process.env.CI && process.env.TERM !== "dumb");
+var rgb = (r, g, b) => (s) => `\x1B[38;2;${r};${g};${b}m${s}\x1B[0m`;
+var LANES = [rgb(91, 75, 255), rgb(74, 107, 250), rgb(50, 144, 238), rgb(25, 198, 230)];
+var C = {
+  text: rgb(243, 244, 247),
+  dim: rgb(110, 116, 136),
+  mute: rgb(160, 166, 186),
+  coral: rgb(255, 142, 122),
+  violet: rgb(185, 180, 255),
+  cyan: rgb(127, 227, 244),
+  amber: rgb(245, 184, 74),
+  bold: (s) => `\x1B[1m${s}\x1B[22m`
+};
+var width = () => Math.max(40, Math.min(out.columns || 80, 110));
+var visible = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
+var cut = (s, n) => s.length > n ? `${s.slice(0, Math.max(1, n - 1))}\u2026` : s;
+function banner(app2, where) {
+  const bar = LANES.map((c2, i) => c2("\u2501".repeat(8 - i))).join(" ");
+  out.write(`
+  ${bar}
+
+  ${C.bold(C.text("Plures"))} ${C.dim("map")}  ${C.mute(app2)}
+  ${C.dim(where)}
+
+`);
+}
+function liveLine() {
+  const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  let i = 0, count = 0, file = "", phase = "reading", timer = null;
+  const draw = () => {
+    const spin = LANES[Math.floor(i / 2) % 4](frames[i % frames.length]);
+    i++;
+    const left = phase === "drawing" ? `  ${spin} ${C.violet("Drawing the map")}  ${C.dim(`from ${count} ${count === 1 ? "file" : "files"}`)}` : `  ${spin} ${C.bold(C.text(String(count).padStart(3)))} ${C.dim(count === 1 ? "file read " : "files read")}  `;
+    const room = width() - visible(left).length - 2;
+    const f = phase === "reading" && file ? (() => {
+      const slash = file.lastIndexOf("/");
+      const s = cut(file, room);
+      return slash >= 0 && s === file ? `${C.dim(file.slice(0, slash + 1))}${C.text(file.slice(slash + 1))}` : C.text(s);
+    })() : "";
+    out.write(`\r\x1B[K${left}${f}`);
+  };
+  return {
+    start() {
+      out.write("\x1B[?25l");
+      draw();
+      timer = setInterval(draw, 80);
+    },
+    read(path) {
+      count++;
+      file = path;
+    },
+    drawing() {
+      phase = "drawing";
+    },
+    stop() {
+      if (timer) clearInterval(timer);
+      timer = null;
+      out.write("\r\x1B[K\x1B[?25h");
+    },
+    get count() {
+      return count;
+    }
+  };
+}
+if (fancy) for (const sig of ["SIGINT", "SIGTERM"]) process.once(sig, () => {
+  out.write("\x1B[?25h\n");
+  process.exit(130);
+});
+var ICON = { input: "\u25B8", model: "\u25CE", tool: "\u2315", decision: "\u25C7", action: "\u2197", data: "\u25A4", output: "\u21A6", human: "\u263A" };
+function drawMap(m, url) {
+  const nodes = new Map(m.nodes.map((n) => [n.id, n]));
+  const cps = new Map(m.checkpoints.filter((c2) => c2.status !== "dismissed").map((c2) => [c2.at, c2]));
+  const W = width();
+  const nb = new Map(m.nodes.map((n) => [n.id, []]));
+  for (const e of m.edges) {
+    nb.get(e.from)?.push(e.to);
+    nb.get(e.to)?.push(e.from);
+  }
+  const seen = /* @__PURE__ */ new Set(), flows = [];
+  for (const n of m.nodes) {
+    if (seen.has(n.id)) continue;
+    const part = [], st = [n.id];
+    seen.add(n.id);
+    while (st.length) {
+      const v = st.pop();
+      part.push(v);
+      for (const w of nb.get(v) ?? []) if (!seen.has(w)) {
+        seen.add(w);
+        st.push(w);
+      }
+    }
+    flows.push(m.nodes.map((x) => x.id).filter((id) => part.includes(id)));
+  }
+  const chip = (id) => {
+    const n = nodes.get(id), c2 = cps.get(id);
+    const label = cut(n.label, 34);
+    const tag = !c2 ? "" : c2.status === "added" ? `  ${C.cyan("\u2713 checked")}` : `  ${C.violet("\u25CC check suggested")}`;
+    if (n.kind === "action") {
+      if (c2?.status === "added") return `${C.cyan(ICON.action)} ${C.text(label)}${tag}`;
+      const risky = n.risk === "high" || n.risk === "medium";
+      return `${risky ? C.coral(ICON.action) : C.mute(ICON.action)} ${risky ? C.coral(label) : C.mute(label)}${tag}`;
+    }
+    return `${C.dim(ICON[n.kind] ?? "\xB7")} ${C.mute(label)}${tag}`;
+  };
+  out.write("\n");
+  for (const ids of flows.filter((f) => f.length > 1)) {
+    const set = new Set(ids);
+    const es = m.edges.filter((e) => set.has(e.from) && set.has(e.to));
+    const layer = new Map(ids.map((id) => [id, 0]));
+    const order = [], state = /* @__PURE__ */ new Map(), back = /* @__PURE__ */ new Set();
+    const visit = (v) => {
+      state.set(v, 1);
+      for (const e of es.filter((x) => x.from === v)) {
+        if (state.get(e.to) === 1) back.add(`${v}>${e.to}`);
+        else if (!state.get(e.to)) visit(e.to);
+      }
+      state.set(v, 2);
+      order.push(v);
+    };
+    for (const id of ids) if (!state.get(id)) visit(id);
+    for (const v of order.reverse()) for (const e of es) if (e.from === v && !back.has(`${v}>${e.to}`)) layer.set(e.to, Math.max(layer.get(e.to), layer.get(v) + 1));
+    const rows = [];
+    for (const id of ids) (rows[layer.get(id)] ??= []).push(id);
+    const root = rows[0]?.length === 1 ? rows[0][0] : null;
+    out.write(`  ${LANES[flows.indexOf(ids) % 4]("\u25CF")} ${C.bold(C.text(cut(root ? nodes.get(root).label : "Flow", W - 6)))}
+`);
+    rows.forEach((row, ri) => {
+      if (!row || ri === 0 && root) return;
+      const lines = [[]];
+      let used = 6;
+      for (const id of row) {
+        const w = visible(chip(id)).length + 4;
+        if (used + w > W && lines[lines.length - 1].length) {
+          lines.push([]);
+          used = 6;
+        }
+        lines[lines.length - 1].push(id);
+        used += w;
+      }
+      for (const ln of lines) out.write(`  ${C.dim("\u2502")}  ${ln.map((id) => chip(id)).join(C.dim("   \xB7   "))}
+`);
+    });
+    out.write("\n");
+  }
+  const actions = m.nodes.filter((n) => n.kind === "action");
+  const on = actions.filter((a) => cps.get(a.id)?.status === "added").length;
+  const sugg = m.checkpoints.filter((c2) => c2.status === "suggested").length;
+  out.write(`  ${LANES.map((c2) => c2("\u2501")).join("")} ${C.bold(C.text(sugg ? `Plures found ${sugg} ${sugg === 1 ? "place" : "places"} a person should check.` : "Your map is ready."))}
+`);
+  out.write(`       ${C.mute(`${on} of ${actions.length} ${actions.length === 1 ? "action" : "actions"} with consequences ${on === 1 ? "has" : "have"} a human check.`)}
+
+`);
+  out.write(`  ${C.text("See it build:")} ${C.cyan(url)}
+
+`);
+}
+async function openBrowser(url) {
+  const { spawn: spawn2 } = await import("child_process");
+  const [cmd, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
+  try {
+    const p = spawn2(cmd, args, { stdio: "ignore", detached: true });
+    p.on("error", () => {
+    });
+    p.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // src/cli.ts
 var argv = process.argv.slice(2);
 var flag = (name) => {
@@ -220,6 +409,7 @@ var flag = (name) => {
   return v;
 };
 var branch = flag("branch");
+var noOpen = argv.includes("--no-open") ? (argv.splice(argv.indexOf("--no-open"), 1), true) : false;
 var app = flag("app") ?? process.env.PLURES_APP ?? "default";
 var key = flag("key") ?? process.env.PLURES_API_KEY;
 var base = flag("base-url") ?? process.env.PLURES_BASE_URL ?? "https://plures.si";
@@ -247,14 +437,15 @@ async function upload(file) {
   } catch {
     die(`${file} isn't valid JSON.`);
   }
-  console.log(dim(`Sending the map to Plures. No source code is sent.`));
+  if (!fancy) console.log(dim(`Sending the map to Plures. No source code is sent.`));
   let m;
   try {
     m = await client().maps.upload(app, map2);
   } catch (e) {
     die(e instanceof PluresError ? `Plures said: ${e.message}` : String(e));
   }
-  report(m);
+  if (fancy) drawMap(m, m.url ?? `${base}/dashboard/apps/${m.app}/map`);
+  else report(m);
 }
 function report(m) {
   const nodes = new Map(m.nodes.map((n) => [n.id, n]));
@@ -304,16 +495,89 @@ With plures-mcp connected, just ask: ${cyan("Map this app for Plures")}`);
     childEnv.ANTHROPIC_API_KEY = run.token;
     console.log(dim(run.free ? "Plures is mapping this repo. Your first map is free." : `Plures is mapping this repo, at most $${(run.max_cents / 100).toFixed(2)} from your credit.`));
   }
-  console.log(`Reading this repo ${process.env.CI ? "on this runner" : "on your machine"} with Claude Code. ${dim("Only the map is sent to Plures.")}
+  const pageUrl = `${base}/dashboard/apps/${encodeURIComponent(app)}/map`;
+  if (fancy) {
+    banner(app, "Reading this repo on your machine with Claude Code. Only file names and the map go to Plures.");
+    if (key && !noOpen && await openBrowser(pageUrl)) console.log(`  ${dim("Watch it live in your browser:")} ${cyan(pageUrl)}
+`);
+  } else console.log(`Reading this repo ${process.env.CI ? "on this runner" : "on your machine"} with Claude Code. ${dim("Only the map is sent to Plures.")}
 `);
   const prompt = `${guide}
 
 Write the map to ${FILE} in the current directory now. Read the code; don't run it or change anything else.`;
+  const live = key ? client() : null;
+  const session = (0, import_node_crypto.randomBytes)(12).toString("base64url");
+  const source = process.env.GITHUB_ACTIONS ? "github" : "cli";
+  let queue = [], phase = "reading", sent = "", reads = 0;
+  const flush = async () => {
+    if (!live) return;
+    const events = queue;
+    queue = [];
+    if (!events.length && sent === phase) return;
+    sent = phase;
+    await live.maps.progress(app, { session, phase, source, events }).catch(() => {
+    });
+  };
+  const tick = setInterval(() => {
+    void flush();
+  }, 900);
+  void flush();
+  const rel = (p) => {
+    if (typeof p !== "string" || !p) return null;
+    const r = (0, import_node_path.isAbsolute)(p) ? (0, import_node_path.relative)(process.cwd(), p) : p;
+    return r.startsWith("..") ? null : r.replace(/\\/g, "/");
+  };
+  let result = "";
+  const ticker = fancy ? liveLine() : null;
+  ticker?.start();
   const code = await new Promise((resolve) => {
-    const p = (0, import_node_child_process.spawn)("claude", ["-p", prompt, "--allowedTools", "Read,Grep,Glob,Write,Bash(git rev-parse:*),Bash(git remote:*)"], { stdio: ["ignore", "inherit", "inherit"], env: childEnv });
+    const p = (0, import_node_child_process.spawn)("claude", ["-p", prompt, "--output-format", "stream-json", "--verbose", "--allowedTools", "Read,Grep,Glob,Write,Bash(git rev-parse:*),Bash(git remote:*)"], { stdio: ["ignore", "pipe", "inherit"], env: childEnv });
+    let buf = "";
+    p.stdout.on("data", (chunk) => {
+      buf += chunk.toString();
+      let i;
+      while ((i = buf.indexOf("\n")) >= 0) {
+        const line = buf.slice(0, i);
+        buf = buf.slice(i + 1);
+        let ev;
+        try {
+          ev = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (ev.type === "result" && typeof ev.result === "string") result = ev.result;
+        for (const b of ev.type === "assistant" ? ev.message?.content ?? [] : []) {
+          if (b.type !== "tool_use") continue;
+          if (b.name === "Read") {
+            const f = rel(b.input?.file_path);
+            if (!f) continue;
+            reads++;
+            queue.push({ path: f, tool: "Read" });
+            if (ticker) ticker.read(f);
+            else console.log(`  ${dim(String(reads).padStart(3))}  ${dim("reading")} ${f}`);
+          } else if (b.name === "Write" && String(b.input?.file_path ?? "").endsWith(FILE)) {
+            phase = "drawing";
+            if (ticker) ticker.drawing();
+            else console.log(`
+  ${violet("drawing")}  the map`);
+          }
+        }
+      }
+    });
     p.on("close", (n) => resolve(n ?? 1));
     p.on("error", () => resolve(1));
   });
+  clearInterval(tick);
+  ticker?.stop();
+  if (result && !fancy) console.log(`
+${result.trim()}
+`);
+  if (fancy) console.log(`  ${cyan("\u2713")} ${reads} ${reads === 1 ? "file" : "files"} read. ${dim("Sending the map to Plures. No source code is sent.")}`);
+  const ok = code === 0 && (0, import_node_fs.existsSync)(FILE) && (0, import_node_fs.statSync)(FILE).mtimeMs !== before;
+  if (!ok) {
+    phase = "failed";
+    await flush();
+  } else await flush();
   if (code !== 0 || !(0, import_node_fs.existsSync)(FILE) || (0, import_node_fs.statSync)(FILE).mtimeMs === before) die(`Claude Code didn't write ${FILE}. Ask it directly, then run npx plures map upload.`);
   await upload(FILE);
 }