plures 1.16.0 → 1.21.0

package/README.md

@@ -45,12 +45,14 @@ if (event.type === "task.completed" && event.data.result?.agreement === 1) {
 ## API
 
 - `plures.check(id, data, overrides?)`: run a check from your app's map, one line before the action it guards: `const check = await plures.check("refunds", { order_total, reason }); if (check.answer !== "Approve") return`. The check saved on Plures supplies the question, options, which fields people see (the rest come back in `kept_private`), who decides, how often, its conditions and what happens on a timeout, so you change them on Plures, not in code. `checked` says whether a person looked; `skipped_because` says why not. Overrides: `question`, `options`, `verifiers`, `team`, `route`, `sample`, `timeout`, `always`.
+- `plures.turns.log({ question, answer, intent, rerouted_to, retrieval, sources, session, channel })`: answer reviews for assistants. Send each turn after it's answered (don't await it in the user's path); Plures picks the ones that went wrong (rerouted, refused, empty, no sources, asked again) plus a few at random, and your team grades them. `plures.turns.insights(app)` and `plures.turns.export(app, "routes" | "retrieval" | "qa" | "missed")` turn the grades into routing examples and eval sets.
+- `plures.drift.list(app)`, `.fix(app, id)`: drift cases, when a rubric or an answer intent's grades fall. `npx plures drift fix <case> --app <app>` has Claude Code read the repo with the graded examples that got worse, find the cause, fix it and add eval cases; on GitHub, Plures opens the pull request and then checks the grades come back.
 - `npx plures check add <id> --app <app>`: Claude Code puts that line before the action on a new branch. On GitHub (the dashboard's **Add it to my code**) Plures then opens a pull request.
 - `plures.tasks.create(params, { idempotencyKey? })`: send a task. Params: `question`, `options` (2 to 8, strings or `{ id, label }`), `context`, `image_url`, `audio_url` or `video_url` with `media_seconds` (a clip up to 180 seconds that people play through before answering), `sensitive`, `instructions`, `verifiers` (1, 3, 5, 7 or 9), `max_verifiers`, `presence_check` (default true), `webhook_url`, `metadata`, `expires_in`, `route` (`"team"` sends it straight to your own people, $0.05 per internal vote live), `category` (matches your routing rules) and `team` (one of your named teams), `team_votes` and `team_unanimous` (internal consensus: how many of your team vote, and whether they must all agree; a split goes to the team's lead).
 - `plures.tasks.retrieve(id)`, `plures.tasks.list({ status?, limit?, starting_after?, app? })`, `plures.tasks.cancel(id)`
 - `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, { branch? })` (a branch other than main gets its own map, compared with main and noted on its pull request), `.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).
+- `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 (Claude at cost, at most $5 a run). `plures.maps.estimate(app, "map" | "drift")` shows what the next map or drift fix costs before it starts: the Plures engine fee, 5¢ a step of the app's map (the first map of each app is free; branch maps are free), plus Claude at cost when Plures runs it. `npx plures map` and `npx plures drift fix` check it first and stop if your credit can't cover it. A drift fix is paid by outcome: each quality point it wins back, once people have graded the new outputs, costs 20¢ a step of the map ($3 to $15 a point), at most $500 a fix, with Claude included; no better or worse is free.
 - 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)`, `.run(app)` (map now), `.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`; `npx plures map github run` maps again now.

package/dist/{chunk-Z75ZTXHZ.js → chunk-Z3YGRA2U.js}

@@ -1,5 +1,5 @@
 // src/index.ts
-var VERSION = "1.16.0";
+var VERSION = "1.21.0";
 var PluresError = class extends Error {
   constructor(message, status, type) {
     super(message);
@@ -107,8 +107,12 @@ var Plures = class {
     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)}`),
+    /** What the next map or drift fix will cost before it starts. A map: the Plures engine fee, per step of the app's map
+     * (the first map of each app is free), and Claude at cost if Plures runs it. A drift fix: paid by outcome,
+     * drift_fix.per_point_cents for each quality point it wins back, at most drift_fix.max_cents, Claude included. blocked says why it can't start. */
+    estimate: (app, kind = "map", opts = {}) => this.req("GET", `/api/v1/apps/${encodeURIComponent(app)}/map_estimate?for=${kind}${opts.case ? `&case=${encodeURIComponent(opts.case)}` : ""}`),
     /** 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`, {}),
+    startRun: (app, opts = {}) => this.req("POST", `/api/v1/apps/${encodeURIComponent(app)}/map_runs`, opts),
     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),
@@ -169,6 +173,43 @@ var Plures = class {
       return (await r.text()).split("\n").filter(Boolean).map((l) => JSON.parse(l));
     }
   };
+  /**
+   * Answer reviews: send each turn your assistant answers, with where it routed and what it
+   * retrieved. Plures picks the ones worth a look (rerouted, refused, empty, no sources, asked
+   * again, plus a few at random) and your team grades them. Free, and nothing waits on it: call
+   * it after the reply and don't await it in the user's path.
+   */
+  turns = {
+    log: (t) => this.req("POST", "/api/v1/turns", t),
+    /** Grade a turn from your own tools. */
+    grade: (id, g) => this.req("POST", `/api/v1/turns/${encodeURIComponent(id)}/grade`, g),
+    /** What the grades say: per intent, misroutes, retrieval misses and missed asks. */
+    insights: (app, opts = {}) => this.req("GET", `/api/v1/apps/${encodeURIComponent(app)}/turns/insights${opts.days ? `?days=${opts.days}` : ""}`),
+    /** Graded turns as eval data: routes (routing examples), retrieval ({ query, doc, must_contain }), qa ({ question, fact } or { question, unanswerable }), missed. */
+    export: async (app, kind, opts = {}) => {
+      const q = new URLSearchParams({ kind, ...opts.since ? { since: opts.since } : {} });
+      const r = await fetch(`${this.base}/api/v1/apps/${encodeURIComponent(app)}/turns/export?${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));
+    }
+  };
+  /**
+   * Drift: when a rubric's grades or an answer intent's grades fall, Plures opens a case, the repo's
+   * runner reads the code with the examples that got worse and opens a fix, and Plures checks the
+   * fix brings quality back. npx plures drift fix does the reading in your repo.
+   */
+  drift = {
+    list: (app) => this.req("GET", `/api/v1/apps/${encodeURIComponent(app)}/drift`),
+    /** Runs the fix on GitHub through the repo's Plures workflow. */
+    fix: (app, id) => this.req("POST", `/api/v1/apps/${encodeURIComponent(app)}/drift/${encodeURIComponent(id)}/fix`, {}),
+    /** What got worse: graded examples, the change that started it, and the steps on the map. */
+    packet: (app, id) => this.req("GET", `/api/v1/apps/${encodeURIComponent(app)}/drift/${encodeURIComponent(id)}/packet`),
+    /** After reading the code: the diagnosis, and the branch with the fix if there is one. Plures opens the pull request. */
+    report: (app, id, p) => this.req("POST", `/api/v1/apps/${encodeURIComponent(app)}/drift/${encodeURIComponent(id)}/report`, p)
+  };
   /** 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");
   /**

package/dist/cli.cjs

@@ -30,7 +30,7 @@ var import_node_path = require("path");
 var import_node_fs = require("fs");
 
 // src/index.ts
-var VERSION = "1.16.0";
+var VERSION = "1.21.0";
 var PluresError = class extends Error {
   constructor(message, status, type) {
     super(message);
@@ -138,8 +138,12 @@ var Plures = class {
     createKey: (app2, opts = {}) => this.req("POST", `/api/v1/apps/${encodeURIComponent(app2)}/map_keys`, opts),
     keys: (app2) => this.req("GET", `/api/v1/apps/${encodeURIComponent(app2)}/map_keys`),
     revokeKey: (app2, id) => this.req("DELETE", `/api/v1/apps/${encodeURIComponent(app2)}/map_keys/${encodeURIComponent(id)}`),
+    /** What the next map or drift fix will cost before it starts. A map: the Plures engine fee, per step of the app's map
+     * (the first map of each app is free), and Claude at cost if Plures runs it. A drift fix: paid by outcome,
+     * drift_fix.per_point_cents for each quality point it wins back, at most drift_fix.max_cents, Claude included. blocked says why it can't start. */
+    estimate: (app2, kind = "map", opts = {}) => this.req("GET", `/api/v1/apps/${encodeURIComponent(app2)}/map_estimate?for=${kind}${opts.case ? `&case=${encodeURIComponent(opts.case)}` : ""}`),
     /** 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`, {}),
+    startRun: (app2, opts = {}) => this.req("POST", `/api/v1/apps/${encodeURIComponent(app2)}/map_runs`, opts),
     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),
@@ -200,6 +204,43 @@ var Plures = class {
       return (await r.text()).split("\n").filter(Boolean).map((l) => JSON.parse(l));
     }
   };
+  /**
+   * Answer reviews: send each turn your assistant answers, with where it routed and what it
+   * retrieved. Plures picks the ones worth a look (rerouted, refused, empty, no sources, asked
+   * again, plus a few at random) and your team grades them. Free, and nothing waits on it: call
+   * it after the reply and don't await it in the user's path.
+   */
+  turns = {
+    log: (t) => this.req("POST", "/api/v1/turns", t),
+    /** Grade a turn from your own tools. */
+    grade: (id, g) => this.req("POST", `/api/v1/turns/${encodeURIComponent(id)}/grade`, g),
+    /** What the grades say: per intent, misroutes, retrieval misses and missed asks. */
+    insights: (app2, opts = {}) => this.req("GET", `/api/v1/apps/${encodeURIComponent(app2)}/turns/insights${opts.days ? `?days=${opts.days}` : ""}`),
+    /** Graded turns as eval data: routes (routing examples), retrieval ({ query, doc, must_contain }), qa ({ question, fact } or { question, unanswerable }), missed. */
+    export: async (app2, kind, opts = {}) => {
+      const q = new URLSearchParams({ kind, ...opts.since ? { since: opts.since } : {} });
+      const r = await fetch(`${this.base}/api/v1/apps/${encodeURIComponent(app2)}/turns/export?${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));
+    }
+  };
+  /**
+   * Drift: when a rubric's grades or an answer intent's grades fall, Plures opens a case, the repo's
+   * runner reads the code with the examples that got worse and opens a fix, and Plures checks the
+   * fix brings quality back. npx plures drift fix does the reading in your repo.
+   */
+  drift = {
+    list: (app2) => this.req("GET", `/api/v1/apps/${encodeURIComponent(app2)}/drift`),
+    /** Runs the fix on GitHub through the repo's Plures workflow. */
+    fix: (app2, id) => this.req("POST", `/api/v1/apps/${encodeURIComponent(app2)}/drift/${encodeURIComponent(id)}/fix`, {}),
+    /** What got worse: graded examples, the change that started it, and the steps on the map. */
+    packet: (app2, id) => this.req("GET", `/api/v1/apps/${encodeURIComponent(app2)}/drift/${encodeURIComponent(id)}/packet`),
+    /** After reading the code: the diagnosis, and the branch with the fix if there is one. Plures opens the pull request. */
+    report: (app2, id, p) => this.req("POST", `/api/v1/apps/${encodeURIComponent(app2)}/drift/${encodeURIComponent(id)}/report`, p)
+  };
   /** 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");
   /**
@@ -475,8 +516,7 @@ async function upload(file) {
   }
   if (!fancy) console.log(dim(`Sending the map to Plures. No source code is sent.`));
   let m;
-  const gitBranch = (0, import_node_child_process.spawnSync)("git", ["rev-parse", "--abbrev-ref", "HEAD"], { encoding: "utf8" }).stdout?.trim();
-  const branchName = process.env.PLURES_BRANCH || process.env.GITHUB_HEAD_REF || process.env.GITHUB_REF_NAME || (gitBranch && gitBranch !== "HEAD" ? gitBranch : "");
+  const branchName = currentBranch();
   try {
     m = await client().maps.upload(app, map2, branchName ? { branch: branchName } : {});
   } catch (e) {
@@ -526,6 +566,14 @@ With plures-mcp connected, just ask: ${cyan("Map this app for Plures")}`);
     return;
   }
   const before = (0, import_node_fs.existsSync)(FILE) ? (0, import_node_fs.statSync)(FILE).mtimeMs : 0;
+  const est = await client().maps.estimate(app).catch(() => null);
+  if (est) {
+    const br = currentBranch();
+    const main2 = !br || br === "main" || br === "master";
+    if (est.blocked && main2) die(est.blocked);
+    if (main2 && est.engine_fee.free) console.log(dim("Plures engine: this app's first map is free."));
+    else if (main2 && est.engine_fee.cents) console.log(dim(`Plures engine: about $${(est.engine_fee.cents / 100).toFixed(2)} (${est.engine_fee.steps} steps at ${est.engine_fee.per_step_cents}\xA2), from your credit when the map uploads.`));
+  }
   const childEnv = { ...process.env };
   const ownClaude = Boolean(process.env.ANTHROPIC_API_KEY || process.env.CLAUDE_CODE_OAUTH_TOKEN || process.env.ANTHROPIC_AUTH_TOKEN);
   if (!ownClaude && (process.env.CI || argv.includes("--plures-claude"))) {
@@ -784,9 +832,158 @@ ${cyan("\u2713")} The check is on the branch ${bold(br)}. Review it with ${cyan(
     die(e instanceof PluresError ? e.message : String(e));
   }
 }
+function currentBranch() {
+  const gitBranch = (0, import_node_child_process.spawnSync)("git", ["rev-parse", "--abbrev-ref", "HEAD"], { encoding: "utf8" }).stdout?.trim();
+  return process.env.PLURES_BRANCH || process.env.GITHUB_HEAD_REF || process.env.GITHUB_REF_NAME || (gitBranch && gitBranch !== "HEAD" ? gitBranch : "");
+}
+async function driftFix(id) {
+  if (!id) die("npx plures drift fix <case id> [--app <app>]");
+  const cl = client();
+  const report2 = async (p) => cl.drift.report(app, id, p);
+  const fail = async (msg) => {
+    await report2({ error: msg }).catch(() => {
+    });
+    die(msg);
+  };
+  let packet;
+  try {
+    packet = await cl.drift.packet(app, id);
+  } catch (e) {
+    return fail(e instanceof PluresError ? e.message : String(e));
+  }
+  const est = await cl.maps.estimate(app, "drift", { case: id }).catch(() => null);
+  if (est?.blocked) return fail(est.blocked);
+  if (!hasClaude()) return fail("Claude Code isn't installed here, so nothing could read the code.");
+  const git = (...a) => (0, import_node_child_process.spawnSync)("git", a, { encoding: "utf8" });
+  if (git("status", "--porcelain").stdout.trim()) return fail("This repo has changes that aren't committed. Commit or stash them first.");
+  const childEnv = { ...process.env };
+  const ownClaude = Boolean(process.env.ANTHROPIC_API_KEY || process.env.CLAUDE_CODE_OAUTH_TOKEN || process.env.ANTHROPIC_AUTH_TOKEN);
+  if (!ownClaude && process.env.CI) {
+    try {
+      const run = await cl.maps.startRun(app, { purpose: "drift", case: id });
+      childEnv.ANTHROPIC_BASE_URL = run.base_url;
+      childEnv.ANTHROPIC_API_KEY = run.token;
+    } catch (e) {
+      return fail(e instanceof PluresError ? e.message : String(e));
+    }
+  }
+  const session = packet.session || `drift_${(0, import_node_crypto.randomBytes)(9).toString("base64url").replace(/[-_]/g, "")}`;
+  const source = process.env.GITHUB_ACTIONS ? "github" : "cli";
+  let queue = [], phase = "reading", sent = "";
+  const flush = async () => {
+    const events = queue;
+    queue = [];
+    if (!events.length && sent === phase) return;
+    sent = phase;
+    await cl.maps.progress(app, { session, phase, source, events }).catch(() => {
+    });
+  };
+  const tick = setInterval(() => {
+    void flush();
+  }, 900);
+  void flush();
+  const DIAG = ".plures-drift.json";
+  console.log(`${bold("Plures drift")}  ${packet.label}
+${dim("Claude Code reads this repo with the graded examples that got worse. Only file names and the diagnosis go to Plures.")}
+`);
+  const prompt = `Quality fell in this codebase's AI assistant, and people graded the examples. Find out why in the code and fix it.
+
+What Plures measured (JSON):
+${JSON.stringify({ ...packet, session: void 0 }, null, 2).slice(0, 6e4)}
+
+Do this:
+1. Read the code behind the steps listed (prompts, the intent router, retrieval, the answer step). Compare the examples that got worse with the ones that were fine before${packet.version_after ? `, and look for what changed in ${packet.version_after}` : ""}. Use git log or the prompt files if that helps.
+2. Fix the cause in the code with the smallest change that would make the worse examples come out right without breaking the good ones. Prefer prompt, routing and retrieval fixes over rewrites. Don't change unrelated code or formatting.
+3. If the repo has eval files (like evals/*.jsonl), add cases from the worse examples in the same format, so this can't come back unnoticed.
+4. Write ${DIAG} in the repo root, as JSON: { "summary": "the cause in one or two sentences", "confidence": "high" | "medium" | "low", "causes": [{ "title": "...", "detail": "...", "files": [{ "file": "src/...", "line": 12 }] }], "changes": [{ "file": "src/...", "why": "..." }], "evals_added": 0 }. If you change nothing, say why in summary and leave changes empty.
+Don't run the app or tests, and never include secrets or customer data in ${DIAG}.`;
+  const rel = (p) => typeof p === "string" && p ? (0, import_node_path.isAbsolute)(p) ? (0, import_node_path.relative)(process.cwd(), p) : p : null;
+  const code = await new Promise((resolve) => {
+    const p = (0, import_node_child_process.spawn)("claude", ["-p", prompt, "--output-format", "stream-json", "--verbose", "--allowedTools", "Read,Grep,Glob,Edit,Write,Bash(git log:*),Bash(git show:*),Bash(git diff:*)"], { 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;
+        }
+        for (const b of ev.type === "assistant" ? ev.message?.content ?? [] : []) {
+          if (b.type !== "tool_use") continue;
+          const f = rel(b.input?.file_path ?? b.input?.path);
+          if (!f || f.startsWith("..") || f.endsWith(DIAG)) continue;
+          if (b.name === "Read") {
+            queue.push({ path: f, tool: "Read" });
+            console.log(`  ${dim("reading")} ${f}`);
+          } else if (b.name === "Edit" || b.name === "Write") {
+            phase = "drawing";
+            queue.push({ path: f, tool: "Edit" });
+            console.log(`  ${violet("fixing")}  ${f}`);
+          }
+        }
+      }
+    });
+    p.on("close", (n) => resolve(n ?? 1));
+    p.on("error", () => resolve(1));
+  });
+  clearInterval(tick);
+  let diagnosis = null;
+  try {
+    diagnosis = JSON.parse((0, import_node_fs.readFileSync)(DIAG, "utf8"));
+  } catch {
+  }
+  try {
+    (0, import_node_child_process.spawnSync)("rm", ["-f", DIAG]);
+  } catch {
+  }
+  if (code !== 0 || !diagnosis) {
+    phase = "failed";
+    await flush();
+    return fail("Claude Code didn't write a diagnosis. Nothing was changed on Plures.");
+  }
+  const changed = git("status", "--porcelain").stdout.trim();
+  let branch2 = null;
+  if (changed) {
+    branch2 = `plures/drift-${id.replace(/[^a-z0-9_-]+/gi, "-")}-${Date.now().toString(36)}`;
+    for (const a of [["checkout", "-b", branch2], ["add", "-A"], ["commit", "-m", `Fix drift: ${String(packet.label).slice(0, 60)}`]]) {
+      const r = git(...a);
+      if (r.status !== 0) {
+        phase = "failed";
+        await flush();
+        return fail(`git ${a[0]} failed: ${(r.stderr || r.stdout).trim().slice(0, 200)}`);
+      }
+    }
+    if (process.env.GITHUB_ACTIONS) {
+      const push = git("push", "-u", "origin", branch2);
+      if (push.status !== 0) {
+        phase = "failed";
+        await flush();
+        return fail(`Pushing the branch failed: ${(push.stderr || push.stdout).trim().slice(0, 200)}`);
+      }
+    }
+  }
+  phase = "done";
+  await flush();
+  try {
+    const r = await report2({ diagnosis, branch: process.env.GITHUB_ACTIONS ? branch2 : null });
+    const d = diagnosis;
+    console.log(`
+${cyan("\u2713")} ${d.summary ?? "Diagnosed."}`);
+    if (r.pull_request) console.log(`${cyan("\u2713")} Pull request: ${r.pull_request}`);
+    else if (branch2) console.log(`${cyan("\u2713")} The fix is on the branch ${bold(branch2)}. Review it with ${cyan("git show")}, then push it and open a pull request.`);
+  } catch (e) {
+    die(e instanceof PluresError ? e.message : String(e));
+  }
+}
 async function main() {
   const [cmd, sub, arg] = argv;
   if (cmd === "check" && sub === "add") return checkAdd(arg);
+  if (cmd === "drift" && sub === "fix") return driftFix(arg);
   if (cmd !== "map") {
     console.log(`Plures
 
@@ -798,6 +995,7 @@ async function main() {
   npx plures map github on             merge it, which turns mapping on
   npx plures map github run            map now on GitHub, and watch it build
   npx plures check add <id>            put a check into your code, on a new branch
+  npx plures drift fix <case>          find why quality fell and fix it, on a new branch
 
 Docs: https://plures.si/docs`);
     return;

package/dist/cli.js

@@ -3,7 +3,7 @@ import {
   Plures,
   PluresError,
   VERSION
-} from "./chunk-Z75ZTXHZ.js";
+} from "./chunk-Z3YGRA2U.js";
 
 // src/cli.ts
 import { spawnSync, spawn } from "child_process";
@@ -228,8 +228,7 @@ async function upload(file) {
   }
   if (!fancy) console.log(dim(`Sending the map to Plures. No source code is sent.`));
   let m;
-  const gitBranch = spawnSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], { encoding: "utf8" }).stdout?.trim();
-  const branchName = process.env.PLURES_BRANCH || process.env.GITHUB_HEAD_REF || process.env.GITHUB_REF_NAME || (gitBranch && gitBranch !== "HEAD" ? gitBranch : "");
+  const branchName = currentBranch();
   try {
     m = await client().maps.upload(app, map2, branchName ? { branch: branchName } : {});
   } catch (e) {
@@ -279,6 +278,14 @@ With plures-mcp connected, just ask: ${cyan("Map this app for Plures")}`);
     return;
   }
   const before = existsSync(FILE) ? statSync(FILE).mtimeMs : 0;
+  const est = await client().maps.estimate(app).catch(() => null);
+  if (est) {
+    const br = currentBranch();
+    const main2 = !br || br === "main" || br === "master";
+    if (est.blocked && main2) die(est.blocked);
+    if (main2 && est.engine_fee.free) console.log(dim("Plures engine: this app's first map is free."));
+    else if (main2 && est.engine_fee.cents) console.log(dim(`Plures engine: about $${(est.engine_fee.cents / 100).toFixed(2)} (${est.engine_fee.steps} steps at ${est.engine_fee.per_step_cents}\xA2), from your credit when the map uploads.`));
+  }
   const childEnv = { ...process.env };
   const ownClaude = Boolean(process.env.ANTHROPIC_API_KEY || process.env.CLAUDE_CODE_OAUTH_TOKEN || process.env.ANTHROPIC_AUTH_TOKEN);
   if (!ownClaude && (process.env.CI || argv.includes("--plures-claude"))) {
@@ -537,9 +544,158 @@ ${cyan("\u2713")} The check is on the branch ${bold(br)}. Review it with ${cyan(
     die(e instanceof PluresError ? e.message : String(e));
   }
 }
+function currentBranch() {
+  const gitBranch = spawnSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], { encoding: "utf8" }).stdout?.trim();
+  return process.env.PLURES_BRANCH || process.env.GITHUB_HEAD_REF || process.env.GITHUB_REF_NAME || (gitBranch && gitBranch !== "HEAD" ? gitBranch : "");
+}
+async function driftFix(id) {
+  if (!id) die("npx plures drift fix <case id> [--app <app>]");
+  const cl = client();
+  const report2 = async (p) => cl.drift.report(app, id, p);
+  const fail = async (msg) => {
+    await report2({ error: msg }).catch(() => {
+    });
+    die(msg);
+  };
+  let packet;
+  try {
+    packet = await cl.drift.packet(app, id);
+  } catch (e) {
+    return fail(e instanceof PluresError ? e.message : String(e));
+  }
+  const est = await cl.maps.estimate(app, "drift", { case: id }).catch(() => null);
+  if (est?.blocked) return fail(est.blocked);
+  if (!hasClaude()) return fail("Claude Code isn't installed here, so nothing could read the code.");
+  const git = (...a) => spawnSync("git", a, { encoding: "utf8" });
+  if (git("status", "--porcelain").stdout.trim()) return fail("This repo has changes that aren't committed. Commit or stash them first.");
+  const childEnv = { ...process.env };
+  const ownClaude = Boolean(process.env.ANTHROPIC_API_KEY || process.env.CLAUDE_CODE_OAUTH_TOKEN || process.env.ANTHROPIC_AUTH_TOKEN);
+  if (!ownClaude && process.env.CI) {
+    try {
+      const run = await cl.maps.startRun(app, { purpose: "drift", case: id });
+      childEnv.ANTHROPIC_BASE_URL = run.base_url;
+      childEnv.ANTHROPIC_API_KEY = run.token;
+    } catch (e) {
+      return fail(e instanceof PluresError ? e.message : String(e));
+    }
+  }
+  const session = packet.session || `drift_${randomBytes(9).toString("base64url").replace(/[-_]/g, "")}`;
+  const source = process.env.GITHUB_ACTIONS ? "github" : "cli";
+  let queue = [], phase = "reading", sent = "";
+  const flush = async () => {
+    const events = queue;
+    queue = [];
+    if (!events.length && sent === phase) return;
+    sent = phase;
+    await cl.maps.progress(app, { session, phase, source, events }).catch(() => {
+    });
+  };
+  const tick = setInterval(() => {
+    void flush();
+  }, 900);
+  void flush();
+  const DIAG = ".plures-drift.json";
+  console.log(`${bold("Plures drift")}  ${packet.label}
+${dim("Claude Code reads this repo with the graded examples that got worse. Only file names and the diagnosis go to Plures.")}
+`);
+  const prompt = `Quality fell in this codebase's AI assistant, and people graded the examples. Find out why in the code and fix it.
+
+What Plures measured (JSON):
+${JSON.stringify({ ...packet, session: void 0 }, null, 2).slice(0, 6e4)}
+
+Do this:
+1. Read the code behind the steps listed (prompts, the intent router, retrieval, the answer step). Compare the examples that got worse with the ones that were fine before${packet.version_after ? `, and look for what changed in ${packet.version_after}` : ""}. Use git log or the prompt files if that helps.
+2. Fix the cause in the code with the smallest change that would make the worse examples come out right without breaking the good ones. Prefer prompt, routing and retrieval fixes over rewrites. Don't change unrelated code or formatting.
+3. If the repo has eval files (like evals/*.jsonl), add cases from the worse examples in the same format, so this can't come back unnoticed.
+4. Write ${DIAG} in the repo root, as JSON: { "summary": "the cause in one or two sentences", "confidence": "high" | "medium" | "low", "causes": [{ "title": "...", "detail": "...", "files": [{ "file": "src/...", "line": 12 }] }], "changes": [{ "file": "src/...", "why": "..." }], "evals_added": 0 }. If you change nothing, say why in summary and leave changes empty.
+Don't run the app or tests, and never include secrets or customer data in ${DIAG}.`;
+  const rel = (p) => typeof p === "string" && p ? isAbsolute(p) ? relative(process.cwd(), p) : p : null;
+  const code = await new Promise((resolve) => {
+    const p = spawn("claude", ["-p", prompt, "--output-format", "stream-json", "--verbose", "--allowedTools", "Read,Grep,Glob,Edit,Write,Bash(git log:*),Bash(git show:*),Bash(git diff:*)"], { 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;
+        }
+        for (const b of ev.type === "assistant" ? ev.message?.content ?? [] : []) {
+          if (b.type !== "tool_use") continue;
+          const f = rel(b.input?.file_path ?? b.input?.path);
+          if (!f || f.startsWith("..") || f.endsWith(DIAG)) continue;
+          if (b.name === "Read") {
+            queue.push({ path: f, tool: "Read" });
+            console.log(`  ${dim("reading")} ${f}`);
+          } else if (b.name === "Edit" || b.name === "Write") {
+            phase = "drawing";
+            queue.push({ path: f, tool: "Edit" });
+            console.log(`  ${violet("fixing")}  ${f}`);
+          }
+        }
+      }
+    });
+    p.on("close", (n) => resolve(n ?? 1));
+    p.on("error", () => resolve(1));
+  });
+  clearInterval(tick);
+  let diagnosis = null;
+  try {
+    diagnosis = JSON.parse(readFileSync(DIAG, "utf8"));
+  } catch {
+  }
+  try {
+    spawnSync("rm", ["-f", DIAG]);
+  } catch {
+  }
+  if (code !== 0 || !diagnosis) {
+    phase = "failed";
+    await flush();
+    return fail("Claude Code didn't write a diagnosis. Nothing was changed on Plures.");
+  }
+  const changed = git("status", "--porcelain").stdout.trim();
+  let branch2 = null;
+  if (changed) {
+    branch2 = `plures/drift-${id.replace(/[^a-z0-9_-]+/gi, "-")}-${Date.now().toString(36)}`;
+    for (const a of [["checkout", "-b", branch2], ["add", "-A"], ["commit", "-m", `Fix drift: ${String(packet.label).slice(0, 60)}`]]) {
+      const r = git(...a);
+      if (r.status !== 0) {
+        phase = "failed";
+        await flush();
+        return fail(`git ${a[0]} failed: ${(r.stderr || r.stdout).trim().slice(0, 200)}`);
+      }
+    }
+    if (process.env.GITHUB_ACTIONS) {
+      const push = git("push", "-u", "origin", branch2);
+      if (push.status !== 0) {
+        phase = "failed";
+        await flush();
+        return fail(`Pushing the branch failed: ${(push.stderr || push.stdout).trim().slice(0, 200)}`);
+      }
+    }
+  }
+  phase = "done";
+  await flush();
+  try {
+    const r = await report2({ diagnosis, branch: process.env.GITHUB_ACTIONS ? branch2 : null });
+    const d = diagnosis;
+    console.log(`
+${cyan("\u2713")} ${d.summary ?? "Diagnosed."}`);
+    if (r.pull_request) console.log(`${cyan("\u2713")} Pull request: ${r.pull_request}`);
+    else if (branch2) console.log(`${cyan("\u2713")} The fix is on the branch ${bold(branch2)}. Review it with ${cyan("git show")}, then push it and open a pull request.`);
+  } catch (e) {
+    die(e instanceof PluresError ? e.message : String(e));
+  }
+}
 async function main() {
   const [cmd, sub, arg] = argv;
   if (cmd === "check" && sub === "add") return checkAdd(arg);
+  if (cmd === "drift" && sub === "fix") return driftFix(arg);
   if (cmd !== "map") {
     console.log(`Plures
 
@@ -551,6 +707,7 @@ async function main() {
   npx plures map github on             merge it, which turns mapping on
   npx plures map github run            map now on GitHub, and watch it build
   npx plures check add <id>            put a check into your code, on a new branch
+  npx plures drift fix <case>          find why quality fell and fix it, on a new branch
 
 Docs: https://plures.si/docs`);
     return;

package/dist/index.cjs

@@ -26,7 +26,7 @@ __export(index_exports, {
   default: () => index_default
 });
 module.exports = __toCommonJS(index_exports);
-var VERSION = "1.16.0";
+var VERSION = "1.21.0";
 var PluresError = class extends Error {
   constructor(message, status, type) {
     super(message);
@@ -134,8 +134,12 @@ var Plures = class {
     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)}`),
+    /** What the next map or drift fix will cost before it starts. A map: the Plures engine fee, per step of the app's map
+     * (the first map of each app is free), and Claude at cost if Plures runs it. A drift fix: paid by outcome,
+     * drift_fix.per_point_cents for each quality point it wins back, at most drift_fix.max_cents, Claude included. blocked says why it can't start. */
+    estimate: (app, kind = "map", opts = {}) => this.req("GET", `/api/v1/apps/${encodeURIComponent(app)}/map_estimate?for=${kind}${opts.case ? `&case=${encodeURIComponent(opts.case)}` : ""}`),
     /** 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`, {}),
+    startRun: (app, opts = {}) => this.req("POST", `/api/v1/apps/${encodeURIComponent(app)}/map_runs`, opts),
     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),
@@ -196,6 +200,43 @@ var Plures = class {
       return (await r.text()).split("\n").filter(Boolean).map((l) => JSON.parse(l));
     }
   };
+  /**
+   * Answer reviews: send each turn your assistant answers, with where it routed and what it
+   * retrieved. Plures picks the ones worth a look (rerouted, refused, empty, no sources, asked
+   * again, plus a few at random) and your team grades them. Free, and nothing waits on it: call
+   * it after the reply and don't await it in the user's path.
+   */
+  turns = {
+    log: (t) => this.req("POST", "/api/v1/turns", t),
+    /** Grade a turn from your own tools. */
+    grade: (id, g) => this.req("POST", `/api/v1/turns/${encodeURIComponent(id)}/grade`, g),
+    /** What the grades say: per intent, misroutes, retrieval misses and missed asks. */
+    insights: (app, opts = {}) => this.req("GET", `/api/v1/apps/${encodeURIComponent(app)}/turns/insights${opts.days ? `?days=${opts.days}` : ""}`),
+    /** Graded turns as eval data: routes (routing examples), retrieval ({ query, doc, must_contain }), qa ({ question, fact } or { question, unanswerable }), missed. */
+    export: async (app, kind, opts = {}) => {
+      const q = new URLSearchParams({ kind, ...opts.since ? { since: opts.since } : {} });
+      const r = await fetch(`${this.base}/api/v1/apps/${encodeURIComponent(app)}/turns/export?${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));
+    }
+  };
+  /**
+   * Drift: when a rubric's grades or an answer intent's grades fall, Plures opens a case, the repo's
+   * runner reads the code with the examples that got worse and opens a fix, and Plures checks the
+   * fix brings quality back. npx plures drift fix does the reading in your repo.
+   */
+  drift = {
+    list: (app) => this.req("GET", `/api/v1/apps/${encodeURIComponent(app)}/drift`),
+    /** Runs the fix on GitHub through the repo's Plures workflow. */
+    fix: (app, id) => this.req("POST", `/api/v1/apps/${encodeURIComponent(app)}/drift/${encodeURIComponent(id)}/fix`, {}),
+    /** What got worse: graded examples, the change that started it, and the steps on the map. */
+    packet: (app, id) => this.req("GET", `/api/v1/apps/${encodeURIComponent(app)}/drift/${encodeURIComponent(id)}/packet`),
+    /** After reading the code: the diagnosis, and the branch with the fix if there is one. Plures opens the pull request. */
+    report: (app, id, p) => this.req("POST", `/api/v1/apps/${encodeURIComponent(app)}/drift/${encodeURIComponent(id)}/report`, p)
+  };
   /** 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");
   /**

package/dist/index.d.cts

@@ -1,9 +1,96 @@
+type MapEstimate = {
+    object: "map_estimate";
+    app: string;
+    for: "map" | "drift";
+    engine_fee: {
+        steps: number | null;
+        cents: number | null;
+        free: boolean;
+        per_step_cents: number;
+        basis: string;
+    };
+    claude_cents_if_plures_runs: number | null;
+    /** For a drift fix: paid by outcome, per_point_cents for each quality point won back, at most max_cents. Claude included. */
+    drift_fix?: {
+        steps: number | null;
+        per_point_cents: number;
+        lost_points: number | null;
+        max_cents: number;
+        min_point_cents: number;
+        max_point_cents: number;
+        cap_cents: number;
+        outcome: true;
+        free_under_guarantee: boolean;
+    };
+    blocked: string | null;
+};
 type Option = {
     id: string;
     label: string;
 };
 /** "verifiers" asks ID verified people first; "team" goes straight to your own people ($0.05 per internal vote live). */
 type Route = "verifiers" | "team";
+type DriftDiagnosis = {
+    summary: string;
+    confidence: "high" | "medium" | "low";
+    causes: {
+        title: string;
+        detail: string;
+        files: {
+            file: string;
+            line?: number | null;
+        }[];
+    }[];
+    changes: {
+        file: string;
+        why: string;
+    }[];
+    evals_added: number;
+};
+type DriftCase = {
+    object: "drift_case";
+    id: string;
+    app: string;
+    mode: "live" | "test";
+    source: "rubric" | "answers";
+    key: string;
+    label: string;
+    status: "open" | "diagnosing" | "diagnosed" | "fix_open" | "verifying" | "recovered" | "dismissed" | "failed";
+    baseline: number | null;
+    at_open: number | null;
+    current: number | null;
+    points: number;
+    version_before: string | null;
+    version_after: string | null;
+    diagnosis: DriftDiagnosis | null;
+    pr_url: string | null;
+    merged_at: string | null;
+    post_n: number;
+    recovered_at: string | null;
+    opened_at: string;
+};
+type TurnParams = {
+    /** Which version of your assistant answered, like "prompt v15", so a drop can be traced to a change. */ version?: string;
+    /** What the user said or typed. */ question: string;
+    /** What the assistant replied ("" if it said nothing). */ answer: string;
+    /** Where your router sent it. */ intent?: string;
+    /** If the model corrected the router. */ rerouted_to?: string | null;
+    /** How it retrieved, like "full", "rerank" or "agentic". */ retrieval?: string;
+    /** What it used. [] means it answered with none. */ sources?: {
+        id?: string;
+        title?: string;
+        snippet?: string;
+        score?: number;
+    }[];
+    /** It said it didn't know. Plures guesses from the answer if you leave it out. */ refused?: boolean;
+    /** A conversation or call id, so Plures can tell when the user asks again. */ session?: string;
+    channel?: "voice" | "text";
+    /** A recording people can play, for voice. */ audio_url?: string;
+    /** Every intent your router can pick, so graders can choose the right one. */ intents?: string[];
+    /** Send this one for review whatever the sample says. */ review?: boolean;
+    app?: string;
+    metadata?: Record<string, unknown>;
+};
 type CheckOverrides = {
     question?: string;
     options?: string[];
@@ -419,7 +506,7 @@ type WebhookEvent = {
     created_at: string;
     data: Task;
 };
-declare const VERSION = "1.16.0";
+declare const VERSION = "1.21.0";
 type GitHubLink = {
     object: "github_link";
     app: string;
@@ -556,12 +643,22 @@ declare class Plures {
             id: string;
             deleted: true;
         }>;
+        /** What the next map or drift fix will cost before it starts. A map: the Plures engine fee, per step of the app's map
+         * (the first map of each app is free), and Claude at cost if Plures runs it. A drift fix: paid by outcome,
+         * drift_fix.per_point_cents for each quality point it wins back, at most drift_fix.max_cents, Claude included. blocked says why it can't start. */
+        estimate: (app: string, kind?: "map" | "drift", opts?: {
+            case?: string;
+        }) => Promise<MapEstimate>;
         /** Starts a map run where Plures runs Claude (CI with no Anthropic key). npx plures map does this. */
-        startRun: (app: string) => Promise<{
+        startRun: (app: string, opts?: {
+            purpose?: "map" | "drift";
+            case?: string;
+        }) => Promise<{
             object: "map_run";
             id: string;
             app: string;
             free: boolean;
+            purpose: "map" | "drift";
             max_cents: number;
             token: string;
             base_url: string;
@@ -733,6 +830,83 @@ declare class Plures {
             metadata: Record<string, unknown>;
         }[]>;
     };
+    /**
+     * Answer reviews: send each turn your assistant answers, with where it routed and what it
+     * retrieved. Plures picks the ones worth a look (rerouted, refused, empty, no sources, asked
+     * again, plus a few at random) and your team grades them. Free, and nothing waits on it: call
+     * it after the reply and don't await it in the user's path.
+     */
+    turns: {
+        log: (t: TurnParams) => Promise<{
+            object: "turn";
+            id: string;
+            app: string;
+            picked: boolean;
+            reason: string | null;
+            signals: string[];
+            asked_again_of?: string;
+        }>;
+        /** Grade a turn from your own tools. */
+        grade: (id: string, g: {
+            intent_ok?: boolean;
+            right_intent?: string;
+            grounded?: "yes" | "partly" | "no" | "should_refuse" | "should_answer";
+            complete?: boolean;
+            missed?: string;
+            fact?: string;
+            doc?: string;
+            note?: string;
+            email?: string;
+        }) => Promise<{
+            object: "turn_grade";
+            turn: string;
+        }>;
+        /** What the grades say: per intent, misroutes, retrieval misses and missed asks. */
+        insights: (app: string, opts?: {
+            days?: number;
+        }) => Promise<Record<string, unknown>>;
+        /** Graded turns as eval data: routes (routing examples), retrieval ({ query, doc, must_contain }), qa ({ question, fact } or { question, unanswerable }), missed. */
+        export: (app: string, kind: "routes" | "retrieval" | "qa" | "missed", opts?: {
+            since?: string;
+        }) => Promise<Record<string, unknown>[]>;
+    };
+    /**
+     * Drift: when a rubric's grades or an answer intent's grades fall, Plures opens a case, the repo's
+     * runner reads the code with the examples that got worse and opens a fix, and Plures checks the
+     * fix brings quality back. npx plures drift fix does the reading in your repo.
+     */
+    drift: {
+        list: (app: string) => Promise<{
+            object: "list";
+            data: DriftCase[];
+        }>;
+        /** Runs the fix on GitHub through the repo's Plures workflow. */
+        fix: (app: string, id: string) => Promise<{
+            object: "drift_fix";
+            case: string;
+            status: string;
+            session: string;
+        }>;
+        /** What got worse: graded examples, the change that started it, and the steps on the map. */
+        packet: (app: string, id: string) => Promise<Record<string, unknown> & {
+            case: string;
+            label: string;
+            session: string | null;
+            kind: "rubric" | "answers";
+        }>;
+        /** After reading the code: the diagnosis, and the branch with the fix if there is one. Plures opens the pull request. */
+        report: (app: string, id: string, p: {
+            diagnosis: DriftDiagnosis;
+            branch?: string | null;
+        } | {
+            error: string;
+        }) => Promise<{
+            object: "drift_fix";
+            case: string;
+            status: string;
+            pull_request?: string;
+        }>;
+    };
     /** Your prepaid credit. A live task that could cost more than available_cents is refused with a 402 insufficient_credits error. */
     balance: () => Promise<Balance>;
     /**
@@ -760,4 +934,4 @@ declare class Plures {
     static verifyWebhook(rawBody: string, signatureHeader: string | null, secret: string, toleranceSec?: number): Promise<WebhookEvent>;
 }
 
-export { type AgentMap, type App, type Balance, type CheckOverrides, type CheckResult, type Consensus, type CreateTask, type Escalation, type GitHubLink, type MapChanges, type MapCheckpoint, type MapDraft, type MapKey, type MapNode, type Mix, type Option, Plures, PluresError, type Release, type Result, type Route, type Routing, type RoutingRule, type RoutingUpdate, type Rubric, type RubricParams, type Sample, type StoredAgentMap, type Task, type TaskStatus, type TeamTally, type TeamVote, type TestMix, VERSION, type WebhookEvent, Plures as default };
+export { type AgentMap, type App, type Balance, type CheckOverrides, type CheckResult, type Consensus, type CreateTask, type DriftCase, type DriftDiagnosis, type Escalation, type GitHubLink, type MapChanges, type MapCheckpoint, type MapDraft, type MapEstimate, type MapKey, type MapNode, type Mix, type Option, Plures, PluresError, type Release, type Result, type Route, type Routing, type RoutingRule, type RoutingUpdate, type Rubric, type RubricParams, type Sample, type StoredAgentMap, type Task, type TaskStatus, type TeamTally, type TeamVote, type TestMix, type TurnParams, VERSION, type WebhookEvent, Plures as default };

package/dist/index.d.ts

@@ -1,9 +1,96 @@
+type MapEstimate = {
+    object: "map_estimate";
+    app: string;
+    for: "map" | "drift";
+    engine_fee: {
+        steps: number | null;
+        cents: number | null;
+        free: boolean;
+        per_step_cents: number;
+        basis: string;
+    };
+    claude_cents_if_plures_runs: number | null;
+    /** For a drift fix: paid by outcome, per_point_cents for each quality point won back, at most max_cents. Claude included. */
+    drift_fix?: {
+        steps: number | null;
+        per_point_cents: number;
+        lost_points: number | null;
+        max_cents: number;
+        min_point_cents: number;
+        max_point_cents: number;
+        cap_cents: number;
+        outcome: true;
+        free_under_guarantee: boolean;
+    };
+    blocked: string | null;
+};
 type Option = {
     id: string;
     label: string;
 };
 /** "verifiers" asks ID verified people first; "team" goes straight to your own people ($0.05 per internal vote live). */
 type Route = "verifiers" | "team";
+type DriftDiagnosis = {
+    summary: string;
+    confidence: "high" | "medium" | "low";
+    causes: {
+        title: string;
+        detail: string;
+        files: {
+            file: string;
+            line?: number | null;
+        }[];
+    }[];
+    changes: {
+        file: string;
+        why: string;
+    }[];
+    evals_added: number;
+};
+type DriftCase = {
+    object: "drift_case";
+    id: string;
+    app: string;
+    mode: "live" | "test";
+    source: "rubric" | "answers";
+    key: string;
+    label: string;
+    status: "open" | "diagnosing" | "diagnosed" | "fix_open" | "verifying" | "recovered" | "dismissed" | "failed";
+    baseline: number | null;
+    at_open: number | null;
+    current: number | null;
+    points: number;
+    version_before: string | null;
+    version_after: string | null;
+    diagnosis: DriftDiagnosis | null;
+    pr_url: string | null;
+    merged_at: string | null;
+    post_n: number;
+    recovered_at: string | null;
+    opened_at: string;
+};
+type TurnParams = {
+    /** Which version of your assistant answered, like "prompt v15", so a drop can be traced to a change. */ version?: string;
+    /** What the user said or typed. */ question: string;
+    /** What the assistant replied ("" if it said nothing). */ answer: string;
+    /** Where your router sent it. */ intent?: string;
+    /** If the model corrected the router. */ rerouted_to?: string | null;
+    /** How it retrieved, like "full", "rerank" or "agentic". */ retrieval?: string;
+    /** What it used. [] means it answered with none. */ sources?: {
+        id?: string;
+        title?: string;
+        snippet?: string;
+        score?: number;
+    }[];
+    /** It said it didn't know. Plures guesses from the answer if you leave it out. */ refused?: boolean;
+    /** A conversation or call id, so Plures can tell when the user asks again. */ session?: string;
+    channel?: "voice" | "text";
+    /** A recording people can play, for voice. */ audio_url?: string;
+    /** Every intent your router can pick, so graders can choose the right one. */ intents?: string[];
+    /** Send this one for review whatever the sample says. */ review?: boolean;
+    app?: string;
+    metadata?: Record<string, unknown>;
+};
 type CheckOverrides = {
     question?: string;
     options?: string[];
@@ -419,7 +506,7 @@ type WebhookEvent = {
     created_at: string;
     data: Task;
 };
-declare const VERSION = "1.16.0";
+declare const VERSION = "1.21.0";
 type GitHubLink = {
     object: "github_link";
     app: string;
@@ -556,12 +643,22 @@ declare class Plures {
             id: string;
             deleted: true;
         }>;
+        /** What the next map or drift fix will cost before it starts. A map: the Plures engine fee, per step of the app's map
+         * (the first map of each app is free), and Claude at cost if Plures runs it. A drift fix: paid by outcome,
+         * drift_fix.per_point_cents for each quality point it wins back, at most drift_fix.max_cents, Claude included. blocked says why it can't start. */
+        estimate: (app: string, kind?: "map" | "drift", opts?: {
+            case?: string;
+        }) => Promise<MapEstimate>;
         /** Starts a map run where Plures runs Claude (CI with no Anthropic key). npx plures map does this. */
-        startRun: (app: string) => Promise<{
+        startRun: (app: string, opts?: {
+            purpose?: "map" | "drift";
+            case?: string;
+        }) => Promise<{
             object: "map_run";
             id: string;
             app: string;
             free: boolean;
+            purpose: "map" | "drift";
             max_cents: number;
             token: string;
             base_url: string;
@@ -733,6 +830,83 @@ declare class Plures {
             metadata: Record<string, unknown>;
         }[]>;
     };
+    /**
+     * Answer reviews: send each turn your assistant answers, with where it routed and what it
+     * retrieved. Plures picks the ones worth a look (rerouted, refused, empty, no sources, asked
+     * again, plus a few at random) and your team grades them. Free, and nothing waits on it: call
+     * it after the reply and don't await it in the user's path.
+     */
+    turns: {
+        log: (t: TurnParams) => Promise<{
+            object: "turn";
+            id: string;
+            app: string;
+            picked: boolean;
+            reason: string | null;
+            signals: string[];
+            asked_again_of?: string;
+        }>;
+        /** Grade a turn from your own tools. */
+        grade: (id: string, g: {
+            intent_ok?: boolean;
+            right_intent?: string;
+            grounded?: "yes" | "partly" | "no" | "should_refuse" | "should_answer";
+            complete?: boolean;
+            missed?: string;
+            fact?: string;
+            doc?: string;
+            note?: string;
+            email?: string;
+        }) => Promise<{
+            object: "turn_grade";
+            turn: string;
+        }>;
+        /** What the grades say: per intent, misroutes, retrieval misses and missed asks. */
+        insights: (app: string, opts?: {
+            days?: number;
+        }) => Promise<Record<string, unknown>>;
+        /** Graded turns as eval data: routes (routing examples), retrieval ({ query, doc, must_contain }), qa ({ question, fact } or { question, unanswerable }), missed. */
+        export: (app: string, kind: "routes" | "retrieval" | "qa" | "missed", opts?: {
+            since?: string;
+        }) => Promise<Record<string, unknown>[]>;
+    };
+    /**
+     * Drift: when a rubric's grades or an answer intent's grades fall, Plures opens a case, the repo's
+     * runner reads the code with the examples that got worse and opens a fix, and Plures checks the
+     * fix brings quality back. npx plures drift fix does the reading in your repo.
+     */
+    drift: {
+        list: (app: string) => Promise<{
+            object: "list";
+            data: DriftCase[];
+        }>;
+        /** Runs the fix on GitHub through the repo's Plures workflow. */
+        fix: (app: string, id: string) => Promise<{
+            object: "drift_fix";
+            case: string;
+            status: string;
+            session: string;
+        }>;
+        /** What got worse: graded examples, the change that started it, and the steps on the map. */
+        packet: (app: string, id: string) => Promise<Record<string, unknown> & {
+            case: string;
+            label: string;
+            session: string | null;
+            kind: "rubric" | "answers";
+        }>;
+        /** After reading the code: the diagnosis, and the branch with the fix if there is one. Plures opens the pull request. */
+        report: (app: string, id: string, p: {
+            diagnosis: DriftDiagnosis;
+            branch?: string | null;
+        } | {
+            error: string;
+        }) => Promise<{
+            object: "drift_fix";
+            case: string;
+            status: string;
+            pull_request?: string;
+        }>;
+    };
     /** Your prepaid credit. A live task that could cost more than available_cents is refused with a 402 insufficient_credits error. */
     balance: () => Promise<Balance>;
     /**
@@ -760,4 +934,4 @@ declare class Plures {
     static verifyWebhook(rawBody: string, signatureHeader: string | null, secret: string, toleranceSec?: number): Promise<WebhookEvent>;
 }
 
-export { type AgentMap, type App, type Balance, type CheckOverrides, type CheckResult, type Consensus, type CreateTask, type Escalation, type GitHubLink, type MapChanges, type MapCheckpoint, type MapDraft, type MapKey, type MapNode, type Mix, type Option, Plures, PluresError, type Release, type Result, type Route, type Routing, type RoutingRule, type RoutingUpdate, type Rubric, type RubricParams, type Sample, type StoredAgentMap, type Task, type TaskStatus, type TeamTally, type TeamVote, type TestMix, VERSION, type WebhookEvent, Plures as default };
+export { type AgentMap, type App, type Balance, type CheckOverrides, type CheckResult, type Consensus, type CreateTask, type DriftCase, type DriftDiagnosis, type Escalation, type GitHubLink, type MapChanges, type MapCheckpoint, type MapDraft, type MapEstimate, type MapKey, type MapNode, type Mix, type Option, Plures, PluresError, type Release, type Result, type Route, type Routing, type RoutingRule, type RoutingUpdate, type Rubric, type RubricParams, type Sample, type StoredAgentMap, type Task, type TaskStatus, type TeamTally, type TeamVote, type TestMix, type TurnParams, VERSION, type WebhookEvent, Plures as default };

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   PluresError,
   VERSION,
   index_default
-} from "./chunk-Z75ZTXHZ.js";
+} from "./chunk-Z3YGRA2U.js";
 export {
   Plures,
   PluresError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plures",
-  "version": "1.16.0",
+  "version": "1.21.0",
   "description": "Human judgment as an API for AI agents. Send a decision to ID verified people and get their consensus back.",
   "keywords": [
     "human-in-the-loop",