@webappwiz/cli 0.0.1

package/index-jbrs6gqt.js

@@ -0,0 +1,418 @@
+// judge.ts
+import {
+  agentCommand,
+  Files,
+  Harness,
+  prompt as reviewPrompt
+} from "@webappwiz/rules";
+import { ConsoleLogger, color as color3 } from "webappwiz/log";
+import {
+  NodeFs as NodeFs2,
+  NodeGlob,
+  NodePs as NodePs2
+} from "webappwiz/system";
+import { SystemClock } from "webappwiz/time";
+
+// changed.ts
+import { NodePs } from "webappwiz/system";
+async function changed(dir, ref, opts = {}) {
+  const ps = opts.ps ?? new NodePs;
+  const files = new Set;
+  for (const argv of [
+    ["diff", "--name-only", "--diff-filter=d", "--relative", ref],
+    ["ls-files", "--others", "--exclude-standard"]
+  ]) {
+    for (const line of (await git(ps, dir, argv)).split(`
+`)) {
+      if (line !== "") {
+        files.add(line);
+      }
+    }
+  }
+  return files;
+}
+async function diff(dir, ref, opts = {}) {
+  const ps = opts.ps ?? new NodePs;
+  const patch = await git(ps, dir, ["diff", "--relative", ref]);
+  const added = (await git(ps, dir, ["ls-files", "--others", "--exclude-standard"])).split(`
+`).filter((line) => line !== "");
+  return { patch: patch.trim(), added };
+}
+async function git(ps, dir, argv) {
+  const { exitCode, stdout, stderr } = await ps.spawnCapture([
+    "git",
+    "-C",
+    dir,
+    ...argv
+  ]);
+  if (exitCode !== 0) {
+    throw new Error(`git ${argv[0]} failed in ${dir}: ${stderr.trim() || `exit ${exitCode}`}`);
+  }
+  return stdout;
+}
+
+// cost.ts
+import { join } from "node:path";
+import { NodeFs } from "webappwiz/system";
+var PRICES = { haiku: 1, sonnet: 3, opus: 5 };
+var priced = () => Object.keys(PRICES);
+function floor(agent, tokens) {
+  const price = PRICES[agent];
+  return price === undefined ? undefined : tokens / 1e6 * price;
+}
+var FILE = join(".wiz", "judge-cost.json");
+async function overheads(dir, opts = {}) {
+  const fs = opts.fs ?? new NodeFs;
+  try {
+    const parsed = JSON.parse(await fs.read(join(dir, FILE)));
+    if (typeof parsed !== "object" || parsed === null) {
+      return {};
+    }
+    return Object.fromEntries(Object.entries(parsed).filter(([, call]) => typeof call === "number" && call > 0));
+  } catch {
+    return {};
+  }
+}
+async function calibrate(dir, agent, call, opts = {}) {
+  const fs = opts.fs ?? new NodeFs;
+  const recorded = { ...await overheads(dir, { fs }), [agent]: call };
+  await fs.mkdir(join(dir, ".wiz"));
+  await fs.write(join(dir, FILE), `${JSON.stringify(recorded, null, "\t")}
+`);
+}
+function predict(agent, tokens, calls, measured) {
+  const listed = floor(agent, tokens);
+  const call = measured[agent];
+  return listed === undefined || call === undefined ? listed : listed + call * calls;
+}
+
+// mode.ts
+function mode({ print, estimate, agent, exec }) {
+  const named = [
+    print === true ? "--print" : undefined,
+    estimate === true ? "--estimate" : undefined,
+    agent === undefined ? undefined : "--agent",
+    exec === undefined ? undefined : "--exec"
+  ].filter((flag) => flag !== undefined);
+  if (named.length > 1) {
+    throw new Error(`${named.join(" and ")} are different things to do with one run, so pass one`);
+  }
+  if (print === true) {
+    return "print";
+  }
+  return estimate === true ? "estimate" : "run";
+}
+
+// report.ts
+import { color as color2 } from "webappwiz/log";
+
+// table.ts
+import { color } from "webappwiz/log";
+var table = (rows) => {
+  const width = (cell) => color.strip(cell).length;
+  const widths = rows[0]?.map((_, i) => Math.max(...rows.map((row) => width(row[i] ?? ""))));
+  return rows.map((row) => row.map((cell, i) => cell.padEnd((widths?.[i] ?? 0) + cell.length - width(cell))).join("   ").trimEnd());
+};
+
+// report.ts
+var count = (total, word) => `${total} ${word}${total === 1 ? "" : "s"}`;
+var divider = (name) => {
+  if (name === undefined) {
+    return color2.dim("-".repeat(72));
+  }
+  const opening = `--- ${name} `;
+  return color2.dim(opening.padEnd(Math.max(72, opening.length + 3), "-"));
+};
+var compact = new Intl.NumberFormat("en", { notation: "compact" });
+var money = new Intl.NumberFormat("en", {
+  style: "currency",
+  currency: "USD",
+  minimumFractionDigits: 2,
+  maximumFractionDigits: 4
+});
+var usd = (amount) => money.format(amount);
+var tokens = (bytes) => Math.ceil(bytes / 4);
+function overBudget(estimate, budget, cost) {
+  const money2 = cost === undefined ? "" : ` That is ${color2.bold(usd(cost))} or more.`;
+  return `${color2.yellow("!")} this run reads at least ` + `${color2.bold(compact.format(estimate))} tokens, over the ` + `${color2.bold(compact.format(budget))} budget, and the real cost will be higher.${money2} ` + `Raise it with ${color2.bold("--budget")}.`;
+}
+function estimate(files, rules, calls, tokens2, overheads2) {
+  const agents = priced();
+  const measured = agents.some((agent) => overheads2[agent] !== undefined);
+  const rows = [
+    ["agent", "floor", ...measured ? ["measured"] : []].map(color2.dim)
+  ];
+  for (const agent of agents) {
+    const least = floor(agent, tokens2) ?? 0;
+    const whole = overheads2[agent] === undefined ? undefined : predict(agent, tokens2, calls, overheads2);
+    rows.push([
+      agent,
+      color2.green(`${usd(least)}+`),
+      ...measured ? [whole === undefined ? "" : color2.green(usd(whole))] : []
+    ]);
+  }
+  return [
+    ...planned({ files, rules, calls, estimate: tokens2 }),
+    ...table(rows).map((line) => `  ${line}`),
+    "",
+    color2.gray("floor: the listed input price for the files above, and nothing else. " + `Every call
+also pays for the agent's own system prompt and for whatever it re-reads.`),
+    ...measured ? [
+      color2.gray("measured: that floor plus what a call on the agent cost over it last time.")
+    ] : [
+      color2.gray("Run one of these and the estimate is measured against it next time.")
+    ]
+  ];
+}
+function planned({
+  files,
+  rules,
+  calls,
+  estimate: estimate2,
+  concurrency,
+  cost,
+  agent
+}) {
+  const rows = [
+    [color2.dim("files"), String(files)],
+    [color2.dim("rules"), String(rules)],
+    [
+      color2.dim("calls"),
+      String(calls) + (concurrency === undefined ? "" : color2.dim(`, ${concurrency} at a time`))
+    ],
+    [color2.dim("reading"), `${compact.format(estimate2)}+ tokens`]
+  ];
+  if (cost !== undefined) {
+    rows.push([color2.dim("cost"), color2.green(`${usd(cost)}+`)]);
+  }
+  if (agent !== undefined) {
+    rows.push([color2.dim("agent"), agent]);
+  }
+  return ["", ...table(rows).map((line) => `  ${line}`), ""];
+}
+function finished({
+  rules,
+  files,
+  violations,
+  took,
+  cost,
+  done,
+  total
+}) {
+  const heading = `${color2.gray(`[${done}/${total}]`)} ` + color2.gray(`(${count(rules.length, "rule")}, ${count(files, "file")})`);
+  const spent = cost === undefined ? "" : `  ${usd(cost)}`;
+  const tail = `${color2.gray(`in ${took.human()}${spent}`)}`;
+  if (violations.length === 0) {
+    return [`${color2.green("✓")} ${heading}: clean ${tail}`];
+  }
+  return [
+    `${color2.red("✗")} ${heading}: ${count(violations.length, "problem")} ${tail}`,
+    ...violations.flatMap(finding)
+  ];
+}
+function finding(violation) {
+  const level = violation.level === "error" ? color2.red("error") : color2.yellow(violation.level);
+  const lines = [
+    `  ${color2.bold(`${violation.file}:${violation.line}`)}  ${level}  ${violation.message} ${color2.gray(`(${violation.id})`)}`
+  ];
+  if (violation.code !== "") {
+    lines.push(color2.gray(`  │ ${violation.code}`));
+  }
+  return lines;
+}
+function summary(violations, took, cost) {
+  const spent = cost === undefined ? "" : `  ${usd(cost)} total`;
+  const elapsed = color2.gray(`in ${took.human()}${spent}`);
+  if (violations.length === 0) {
+    return `${color2.green("✓ no violations")} ${elapsed}`;
+  }
+  const errors = violations.filter((violation) => violation.level === "error").length;
+  const line = `✖ ${count(violations.length, "problem")} (${count(errors, "error")}, ${count(violations.length - errors, "warning")})`;
+  return `${errors > 0 ? color2.red(line) : color2.yellow(line)} ${elapsed}`;
+}
+
+// judge.ts
+var estimated = (reviews) => tokens(reviews.reduce((bytes, review) => bytes + review.bytes, 0));
+var isFileRule = (rule) => ("files" in rule);
+var title = (rule) => /^#\s+(.+)$/m.exec(rule.document)?.[1]?.trim() ?? rule.id;
+var ask = {
+  confirm: (question) => process.stdin.isTTY === true && /^y(es)?$/i.test((prompt(`${question} [y/N]`) ?? "").trim())
+};
+
+class JudgeCommands {
+  rules;
+  signoffRules;
+  confirmer;
+  log;
+  fs;
+  ps;
+  clock;
+  glob;
+  constructor(rules, opts = {}) {
+    this.rules = rules;
+    this.signoffRules = opts.signoffRules ?? [];
+    this.confirmer = opts.confirmer ?? ask;
+    this.log = opts.log ?? new ConsoleLogger;
+    this.fs = opts.fs ?? new NodeFs2;
+    this.ps = opts.ps ?? new NodePs2;
+    this.clock = opts.clock ?? new SystemClock;
+    this.glob = opts.glob ?? new NodeGlob;
+  }
+  ls() {
+    const rows = [["id", "rule", "set", "level", "files"].map(color3.dim)];
+    for (const rule of this.rules.rules) {
+      rows.push([rule.id, title(rule), "judge", rule.level, rule.files]);
+    }
+    for (const rule of this.signoffRules) {
+      rows.push([rule.id, title(rule), "signoff", "", ""]);
+    }
+    this.log.info(table(rows).join(`
+`));
+  }
+  show(opts) {
+    const all = [...this.rules.rules, ...this.signoffRules];
+    const rule = all.find((candidate) => candidate.id === opts.id);
+    if (!rule) {
+      throw new Error(`no rule "${opts.id}". Known ids: ${all.map((candidate) => candidate.id).join(", ")}`);
+    }
+    const rows = [
+      [color3.dim("id"), rule.id],
+      [color3.dim("rule"), title(rule)]
+    ];
+    if (isFileRule(rule)) {
+      rows.push([color3.dim("level"), rule.level], [color3.dim("files"), rule.files]);
+    }
+    this.log.info(table(rows).join(`
+`));
+    this.log.info("");
+    this.log.info(rule.document.trim());
+  }
+  async judge(opts) {
+    const how = mode(opts);
+    const config = this.rules;
+    const rules = config.rules;
+    const dir = opts.dir.replace(/\/+$/, "") || "/";
+    const only = opts.since === undefined ? undefined : await changed(dir, opts.since, { ps: this.ps });
+    if (only?.size === 0) {
+      this.log.info(`nothing has changed since ${opts.since}`);
+      return;
+    }
+    const files = new Files({ log: this.log, fs: this.fs, glob: this.glob });
+    const reviews = await files.plan(rules, dir, {
+      chunk: opts.chunk,
+      only
+    });
+    if (how === "print") {
+      for (const review of reviews) {
+        this.log.info(`
+${divider(`${review.label} (${count(review.files.length, "file")})`)}
+`);
+        this.log.info(reviewPrompt(review));
+      }
+      this.log.info(`
+${divider()}`);
+      return;
+    }
+    const read = new Set(reviews.flatMap((review) => review.files)).size;
+    const predicted = estimated(reviews);
+    const calls = reviews.length;
+    if (how === "estimate") {
+      for (const line of estimate(read, rules.length, calls, predicted, await overheads(this.ps.cwd(), { fs: this.fs }))) {
+        this.log.info(line);
+      }
+      return;
+    }
+    const agent = this.agent(config, opts);
+    const model = this.model(config, opts);
+    const root = this.ps.cwd();
+    const measured = await overheads(root, { fs: this.fs });
+    const started = this.clock.now();
+    const cost = model === undefined ? undefined : predict(model, predicted, calls, measured);
+    this.log.info(planned({
+      files: read,
+      rules: rules.length,
+      calls,
+      estimate: predicted,
+      concurrency: config.concurrency,
+      cost,
+      agent: agent.label
+    }).join(`
+`));
+    if (predicted > opts.budget) {
+      this.log.info(overBudget(predicted, opts.budget, cost));
+      if (!await this.confirmer.confirm("Run anyway?")) {
+        throw new Error("over budget");
+      }
+    }
+    let spent = 0;
+    let billed = false;
+    const found = [];
+    const harness = new Harness({
+      log: this.log,
+      ps: this.ps,
+      clock: this.clock
+    });
+    harness.events.on("finished", (review) => {
+      if (review.cost !== undefined) {
+        spent += review.cost;
+        billed = true;
+      }
+      const at = reviews[review.at];
+      if (!at) {
+        return;
+      }
+      const violations2 = files.violations(at, review.findings, dir);
+      found[review.at] = violations2;
+      for (const line of finished({
+        rules: review.rules,
+        files: at.files.length,
+        violations: violations2,
+        took: review.took,
+        cost: review.cost,
+        done: review.done,
+        total: review.total
+      })) {
+        this.log.info(line);
+      }
+    });
+    await harness.run(reviews, agent, {
+      cwd: dir,
+      concurrency: config.concurrency
+    });
+    const violations = found.flat();
+    this.log.info("");
+    this.log.info(summary(violations, this.clock.now().subtract(started), billed ? spent : undefined));
+    await this.record(model, root, predicted, calls, billed ? spent : undefined);
+    const errors = violations.filter((violation) => violation.level === "error").length;
+    if (errors > 0) {
+      throw new Error(count(errors, "error"));
+    }
+  }
+  async record(agent, root, predicted, calls, spent) {
+    if (agent === undefined || spent === undefined || calls <= 0) {
+      return;
+    }
+    const listed = floor(agent, predicted);
+    if (listed === undefined) {
+      return;
+    }
+    const call = (spent - listed) / calls;
+    if (call <= 0) {
+      return;
+    }
+    try {
+      await calibrate(root, agent, call, { fs: this.fs });
+    } catch (error) {
+      this.log.error(`could not record what this run cost: ${error}`);
+    }
+  }
+  agent(config, opts) {
+    const model = this.model(config, opts);
+    return agentCommand(model === undefined ? opts : { agent: model });
+  }
+  model(config, opts) {
+    return opts.exec === undefined ? opts.agent ?? config.agent : undefined;
+  }
+}
+
+export { diff, mode, table, count, divider, usd, tokens, overBudget, ask, JudgeCommands };

package/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/index.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env bun
+// @bun
+import {
+  add,
+  ls,
+  update,
+  update1 as update2,
+  version
+} from "./index-g2q5rg7s.js";
+import {
+  JUDGE_RULES,
+  SIGNOFF_RULES
+} from "./index-8jpb8xae.js";
+import {
+  Signoff
+} from "./index-3k3rtw49.js";
+import {
+  JudgeCommands
+} from "./index-jbrs6gqt.js";
+
+// index.ts
+import { NodeFs, NodeGlob } from "webappwiz/system";
+import { SystemClock } from "webappwiz/time";
+
+// webappwiz.ts
+import { AGENTS } from "@webappwiz/rules";
+import { cli } from "webappwiz/cmd";
+import { t } from "webappwiz/t";
+var webappwiz = cli("webappwiz");
+webappwiz.command("update").description("pin every webappwiz dependency in a tree to one version").arg("dir", t.string(), {
+  default: ".",
+  description: "directory to scan recursively (default: .)"
+}).option("version", t.string(), {
+  default: version,
+  description: "version to pin to"
+}).action((opts, { log, fs }) => update2({ ...opts, log, fs }));
+var judge = ({ log, fs, ps, clock, glob }) => new JudgeCommands(JUDGE_RULES, {
+  signoffRules: SIGNOFF_RULES,
+  log,
+  fs,
+  ps,
+  clock,
+  glob
+});
+webappwiz.command("judge").description("check a directory against the config, one agent per glob").arg("dir", t.string(), {
+  default: ".",
+  description: "directory to judge (default: .)"
+}).option("agent", t.optional(t.enum(Object.keys(AGENTS))), {
+  description: "model to check with (default: the config's agent)"
+}).option("exec", t.optional(t.string()), {
+  description: "command the prompt is passed to, instead of --agent"
+}).option("print", t.boolean(), {
+  default: false,
+  description: "print the prompts and run no agent at all"
+}).option("estimate", t.boolean(), {
+  default: false,
+  description: "print what a run would read, and run nothing"
+}).option("chunk", t.number(), {
+  default: 25,
+  description: "files per review"
+}).option("since", t.optional(t.string()), {
+  description: "only check files added or changed since this git ref"
+}).option("budget", t.number(), {
+  default: 200000,
+  description: "confirm before reading more than this many tokens"
+}).action((opts, deps) => judge(deps).judge(opts));
+webappwiz.command("signoff").description("weigh a change against the rules that ask for a person").arg("dir", t.string(), {
+  default: ".",
+  description: "directory whose change is weighed (default: .)"
+}).option("agent", t.optional(t.enum(Object.keys(AGENTS))), {
+  description: "model to weigh it with (default: the config's agent)"
+}).option("exec", t.optional(t.string()), {
+  description: "command the prompt is passed to, instead of --agent"
+}).option("print", t.boolean(), {
+  default: false,
+  description: "print the rules to apply yourself, and run no agent"
+}).option("since", t.string(), {
+  default: "main",
+  description: "the ref the change is measured against"
+}).option("budget", t.number(), {
+  default: 200000,
+  description: "confirm before reading more than this many tokens"
+}).action((opts, { log, ps, clock }) => new Signoff(SIGNOFF_RULES, JUDGE_RULES.agent, {
+  log,
+  ps,
+  clock
+}).run(opts));
+var rules = webappwiz.group("rules").description("list and print the rules, to run or to read yourself");
+rules.command("ls").description("list the rules").action((_opts, deps) => judge(deps).ls());
+rules.command("show").description("print one rule in full, by the id `rules ls` gives it").arg("id", t.string(), { description: "rule id" }).action((opts, deps) => judge(deps).show(opts));
+var skillsGroup = webappwiz.group("skills").description("manage webappwiz agent skills in .agents/skills");
+skillsGroup.command("ls").description("list the skills there are, and what the project has of them").arg("dir", t.string(), {
+  default: ".",
+  description: "project to inspect (default: .)"
+}).action((opts, { log, fs }) => ls({ ...opts, log, fs }));
+skillsGroup.command("add").description("add a skill to a project").arg("skill", t.string(), { description: "skill name" }).arg("dir", t.string(), {
+  default: ".",
+  description: "project to add it to (default: .)"
+}).action((opts, { log, fs }) => add({ ...opts, log, fs }));
+skillsGroup.command("update").description("refresh the skills a project already has").arg("dir", t.string(), {
+  default: ".",
+  description: "project to refresh (default: .)"
+}).action((opts, { log, fs }) => update({ ...opts, log, fs }));
+
+// index.ts
+await webappwiz.run({
+  fs: new NodeFs,
+  clock: new SystemClock,
+  glob: new NodeGlob
+});

package/judge.d.ts

@@ -0,0 +1,99 @@
+import { type Rule, type RuleSet } from "@webappwiz/rules";
+import { type Logger } from "webappwiz/log";
+import { type Fs, type Glob, type Ps } from "webappwiz/system";
+import { type Clock } from "webappwiz/time";
+/** Asked before a run spends more than it was allowed to. */
+export interface Confirm {
+    confirm(question: string): boolean | Promise<boolean>;
+}
+export interface ShowOptions {
+    /** The rule to print, as `rules ls` lists it. */
+    id: string;
+}
+export interface JudgeOptions {
+    /** The directory to check, and what paths in the report are relative to. */
+    dir: string;
+    agent?: string;
+    exec?: string;
+    /** Print the prompts to the logger and spawn nothing. */
+    print?: boolean;
+    /** Print what a run would read and stop. */
+    estimate?: boolean;
+    /** Files per review. */
+    chunk: number;
+    /** Narrows the run to what git says has changed since this ref. */
+    since?: string;
+    /** Tokens a run may read before it asks whether you meant it. */
+    budget: number;
+}
+/**
+ * Answers on the terminal, and answers no without one: a run nobody is watching
+ * should stop and say the number rather than block forever waiting to be told
+ * to go ahead.
+ */
+export declare const ask: Confirm;
+/** What a `JudgeCommands` runs through, and what else it lists. */
+export interface JudgeCommandsOptions {
+    /** Rules only a reader applies, listed beside the ones a run checks. */
+    signoffRules?: Rule[];
+    /** Who is asked before a run goes over budget; the terminal by default. */
+    confirmer?: Confirm;
+    log?: Logger;
+    fs?: Fs;
+    ps?: Ps;
+    clock?: Clock;
+    glob?: Glob;
+}
+export declare class JudgeCommands {
+    private rules;
+    private signoffRules;
+    private confirmer;
+    private log;
+    private fs;
+    private ps;
+    private clock;
+    private glob;
+    constructor(rules: RuleSet, opts?: JudgeCommandsOptions);
+    /**
+     * Lists every rule there is, one row each, ids first for citing. The rules a
+     * run checks and the ones only a reader applies are one list with a SET
+     * column, because "what rules are there" is one question.
+     */
+    ls(): void;
+    /**
+     * Prints one rule in full: what it covers, and the document an agent is
+     * given, verbatim. Take the id from `rules ls` or from a finding. This is
+     * how a reader applies a rule nothing runs for them.
+     */
+    show(opts: ShowOptions): void;
+    /**
+     * Runs the rules over a directory with the agent you name, as `agent` or
+     * `exec`, falling back to the config's. Exits 1 on any error. Under `print`
+     * it spawns nothing and prints the prompts instead, for an agent that would
+     * rather hand them to subagents of its own.
+     *
+     * `since` narrows the run to what git says has changed, and `budget` caps
+     * what it may read before asking whether you meant it. Under `estimate` it
+     * prints that size and stops, which is the answer to "what would this cost"
+     * without having to guess a budget low enough to be refused.
+     */
+    judge(opts: JudgeOptions): Promise<void>;
+    /**
+     * Measures what one call cost over the files it was handed and leaves that
+     * behind, so the next `--estimate` on this agent has something better than a
+     * floor. Per call rather than per token, because that is how the charge
+     * falls: an agent pays for its own system prompt once per spawn, whatever it
+     * was asked to read, so a figure taken from a two-call run still holds for a
+     * fifteen-call one.
+     *
+     * A run nobody priced records nothing, and a failed write is said aloud
+     * rather than thrown: the agents have already been paid for by this point,
+     * and losing the measurement costs the next estimate accuracy, not the run.
+     */
+    private record;
+    /** The agent a command runs with: what it was told, else the config's. */
+    private agent;
+    /** The model a run asks, or undefined for an `--exec` command, which is a
+     * model nothing here can name or price. */
+    private model;
+}

package/judge.js

@@ -0,0 +1,8 @@
+import {
+  JudgeCommands,
+  ask
+} from "./index-jbrs6gqt.js";
+export {
+  ask,
+  JudgeCommands
+};

package/mode.d.ts

@@ -0,0 +1,23 @@
+/** What a command does with the plan it has made. */
+export type Mode = "print" | "estimate" | "run";
+/** The flags that choose between the three, on top of the two that name an
+ * agent. */
+export interface ModeOptions {
+    /** A model to ask. */
+    agent?: string;
+    /** A command to hand the prompt to instead. */
+    exec?: string;
+    /** Print to the logger and spawn nothing. */
+    print?: boolean;
+    /** Print what a run would read, and spawn nothing. */
+    estimate?: boolean;
+}
+/**
+ * Which of the three a caller asked for, with running the default: a command
+ * given nothing but a directory is one somebody means to run.
+ *
+ * Naming two is an error rather than a quiet winner. All of these say what to
+ * do with one plan, and letting one silently beat the other would leave a
+ * caller unsure which of the two things they asked for they got.
+ */
+export declare function mode({ print, estimate, agent, exec }: ModeOptions): Mode;