@jeffreyjyz/reqshape 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,18 @@
+MIT License
+
+Copyright (c) 2024-2026 Jeffrey JYZ
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,3 +1,150 @@
-# Temporary Holding Version
+# reqshape
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Measure the shape of your requests from opencode's own history, then price that shape against any model.
+
+[![CI](https://img.shields.io/github/actions/workflow/status/JeffreyJYZ/cmdcode-tools/ci.yml?branch=main&style=flat-square&label=CI)](https://github.com/JeffreyJYZ/cmdcode-tools/actions/workflows/ci.yml) [![npm](https://img.shields.io/npm/v/@jeffreyjyz/reqshape?style=flat-square)](https://www.npmjs.com/package/@jeffreyjyz/reqshape) [![license](https://img.shields.io/badge/license-MIT-blue?style=flat-square)](LICENSE)
+
+## What it is
+
+A **req** is one model call — the same unit the opencode sidebar counts: a single `assistant` row in opencode's store. An agentic ask is many reqs, because the model is called again after every tool result.
+
+`reqshape` reads that history, drops the requests that ask for nothing, averages the rest, and hands you the answer as a token vector: *one of my requests is 8.2K input, 309 output, 139 reasoning, 248K cache read*. Then it prices that vector on every model OpenCode Go and CommandCode sell, and divides each plan's allowance and window caps by the result.
+
+`mpc` answers the same question with a fixed assumption (800 in / 50K cache / 200 out). This answers it with your actual traffic — and usually disagrees, because context is re-read on every call and yours is deep.
+
+## Install
+
+Install the published CLI globally:
+
+```sh
+bun add -g @jeffreyjyz/reqshape
+```
+
+Or run it from a checkout — Bun runs the TypeScript entry directly, or link the binary:
+
+```sh
+bun install
+bun run src/index.ts --help
+bun link
+```
+
+## Usage
+
+```sh
+reqshape
+```
+
+```text
+reqshape  7.3K reqs · every req weighted equally
+measured from the opencode v2 store · priced by mpc
+
+MEASURED  1,084 asks · 38 sessions · 12 projects · 2026-07-10 → 2026-09-29
+DROPPED   synthetic prompt 260 · trivial prompt 138 · system prompt 130 · empty prompt 14 · compaction prompt 9 · shell prompt 7
+
+PER REQ   input 8.2K · output 309 · reasoning 139 · cache read 248.0K · cache write 8.1
+          p10/p90  input 67/9.2K · output 46/701 · cache read 1.9K/648.7K
+          one vote per conversation instead: cache read 64.0K · input 10.4K · output 216
+
+PER SIDE  each side priced on its own traffic
+          OpenCode Go   input     7.2K  output     296  cache read    134.8K  3,684 reqs
+          CommandCode   input     3.7K  output     337  cache read    397.0K  3,360 reqs
+
+POSITION  how far into its session the req sat — every call re-reads the context
+          pos 1        cache read      579  input    8.5K  output     75  28 reqs
+          pos 2-5      cache read     9.9K  input    4.9K  output    180  107 reqs
+          pos 6-20     cache read    21.5K  input    8.2K  output    279  356 reqs
+          pos 21-100   cache read    62.2K  input   10.9K  output    388  1,043 reqs
+          pos 101+     cache read   301.5K  input    7.8K  output    301  5,737 reqs
+
+MODELS    deepseek-v4.1-flash 2.8K · minimax-m3 1.7K · glm-5.2 1.4K · best-coding 447 · hy3-free 391 · big-pickle 140 …2 more
+
+PROJECTED what the plan's allowance buys at the measured shape
+
+MODEL                       PLAN                $/req      req/mo      req/5h      req/wk
+──────────────────────────  ───────────  ────────────  ──────────  ──────────  ──────────
+Jev                         CC GOAT       $0.00034461       58.0K       11.6K       29.0K
+Muse Spark 1.3 Contributor  OC Go         $0.00140623       42.7K        8.5K       21.3K
+MiMo V2.6 Flash             OC Go         $0.00197864       30.3K        6.1K       15.2K
+DeepSeek V4.1 Flash         OC Go          $0.0022531       26.6K        5.3K       13.3K
+...
+Grok 4.6                    OC Go             $0.1431         105          21          52
+
+CC account  1,898 reqs this period · GOAT · ends 2026-10-27
+```
+
+## Why "cache read" is the whole story
+
+Every request re-sends the conversation, and providers bill the re-sent part as cached tokens. So cache read is not a property of how you prompt; it is a function of **how far into the conversation you are**:
+
+| position in its session | reqs | cache read / req |
+| --- | --- | --- |
+| 1st | 28 | 579 |
+| 2–5 | 107 | 9.9K |
+| 6–20 | 356 | 21.5K |
+| 21–100 | 1,043 | 62.2K |
+| 101+ | 5,737 | 301.5K |
+
+The first request of a conversation is essentially free to re-send; the hundredth re-sends 300K tokens. On this history **78% of all requests sit at 101+**, which is why the per-request average (248K) is four times the per-conversation average (64K) — one enormous session otherwise sets the profile.
+
+`--weight turn` (the default) treats every req as one data point, because that is the unit you are billed in. `--weight session` gives each conversation one vote and prices that instead. Both are printed either way, so you can see the gap.
+
+A model with no published cache-read rate is billed for that context at its **input** rate, and flagged with `*`. This is the single biggest swing in the table: a model with no caching support is not slightly more expensive for this traffic, it is unusable.
+
+## Noise filtering
+
+"hi", "thanks", "ok", "continue" are real requests but say nothing about the work you do. `reqshape` drops an ask — the prompt *and* every req it drove — when:
+
+- its prompt normalises to a keyword (`hi`, `hey there`, `thanks`, `great`, `lgtm`, `continue please`, …) — edit the list with `--keywords`
+- its prompt is nothing but emoji or punctuation (`--min-chars` adds a length floor)
+- it produced almost no output (`--min-output N`)
+
+Structural noise is always dropped: auto-generated `synthetic` prompts, the `compaction` summary turn, `shell` commands, and `system` rows are not requests you made. `--keep-trivial` turns off the prompt filters and keeps everything else the same, and `--explain` prints every reason with its count — nothing is silently discarded.
+
+## Options
+
+| flag | default | meaning |
+| --- | --- | --- |
+| `--weight <mode>` | `turn` | `turn` (every req equal) or `session` (one vote per conversation) |
+| `--sessions <mode>` | `all` | `all` includes subagent sessions; `user` drops them |
+| `--keywords <list>` | built-in list | comma-separated prompts to treat as noise (replaces the list) |
+| `--min-chars <n>` | `0` | also drop prompts shorter than this |
+| `--min-output <n>` | `0` | also drop asks that produced fewer output tokens |
+| `--keep-trivial` | off | keep every prompt; only structural noise is dropped |
+| `--since <date>` | all time | only asks on or after this date |
+| `--project <dir>` | all | only sessions whose directory contains this |
+| `--model <text>` | all | only model rows whose name contains this |
+| `--limit <n>` | all | cap the number of model rows |
+| `--sort <key>` | `reqmo` | `reqmo` (most requests first), `cost`, `name` |
+| `--explain` | off | list every drop reason rather than the top six |
+| `--format <mode>` | `text` | `text` or `json` |
+| `--db <path>` | opencode's store | where the history lives (`OPENCODE_DB`) |
+| `--mpc <bin>` | `mpc` | catalogue source (`MPC_BIN`) |
+| `--cmduse <bin>` | `cmduse` | account line (`CMDUSE_BIN`) |
+| `--no-account` | off | skip the `cmduse` account line |
+| `--no-color` | off | plain output (also honours `NO_COLOR`) |
+
+### A model nobody sells
+
+```sh
+reqshape --in 0.15 --out 0.6 --cache-read 0.003 --budget 60 --five-hour 12 --weekly 30
+```
+
+`--budget` is the monthly allowance; `--five-hour` and `--weekly` are the plan's caps, and without them those two columns show `—` rather than inventing a window. Omit `--cache-read` and the context is billed at the input rate, flagged `*`.
+
+## Where the numbers come from
+
+- **Your traffic** — opencode's own store, read-only (`~/.local/share/opencode/opencode.db`). v2's `session_message` is read when present, the pre-v2 `message` table otherwise, and session metadata is joined across `session` and `session_v2`.
+- **Model rates, allowances and window caps** — `mpc --json`. The 5-hour and weekly caps are read back from mpc's own figures, so the provider's window rule is not restated here where it could drift.
+- **The account line** — `cmduse -1 --json`, purely as context for how much of your usage this profile covers. If it cannot answer, the line is simply absent.
+
+### Per side, and back into `mpc`
+
+`--format json` carries `sides.oc` and `sides.cc`: the same measured profile split by whose traffic it is (requests to `opencode*` vs the `CC_PREFIXES` ids), with each side's own request count. `mpc --shape measured` reads exactly that payload and prices each plan on its side's shape, so its estimated `req/mo` is "how many of *my* requests fit" instead of a fixed 800-in / 50K-cache / 200-out assumption.
+
+Runs take about 20 seconds: both `mpc` and `cmduse` go to the network.
+
+## Links
+
+- [Source (GitHub)](https://github.com/JeffreyJYZ/cmdcode-tools/tree/main/reqshape)
+- [npm: @jeffreyjyz/reqshape](https://www.npmjs.com/package/@jeffreyjyz/reqshape)
+- [MIT license](LICENSE)

package/package.json

@@ -1,6 +1,32 @@
 {
-  "name": "@jeffreyjyz/reqshape",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@jeffreyjyz/reqshape",
+	"version": "0.1.1",
+	"description": "Measure the shape of your requests from opencode's own history, then price it against any model",
+	"license": "MIT",
+	"type": "module",
+	"bin": {
+		"reqshape": "src/index.ts"
+	},
+	"files": [
+		"src",
+		"LICENSE"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"start": "bun run src/index.ts",
+		"test": "bun test",
+		"fmt": "biome format --write .",
+		"check": "biome check --write .",
+		"typecheck": "tsc --noEmit"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "^2.5.13",
+		"@types/bun": "latest",
+		"typescript": "^7"
+	},
+	"dependencies": {
+		"cac": "^7.0.0"
+	}
+}

package/src/cli/flags.ts

@@ -0,0 +1,108 @@
+import type { CustomRates } from "~/market/rates.ts";
+
+/**
+ * cac prints --help and --version itself and only sets `run = false`, which is
+ * already false for us, so the tool would otherwise carry on and print a report
+ * after the help text. This reports that the question is already answered.
+ */
+export function answeredByCac(flags: Record<string, unknown>): boolean {
+	return flags.help === true || flags.version === true;
+}
+
+/**
+ * mri coerces a numeric-looking value to a number, `""` to `0` and a valueless
+ * flag to `true`, so a string option is read through here rather than trusted
+ * to arrive as a string.
+ */
+export function str(value: unknown): string | undefined {
+	if (value === undefined || value === null || typeof value === "boolean") {
+		return undefined;
+	}
+	return String(value);
+}
+
+export function number(value: unknown, flag: string): number {
+	if (typeof value === "boolean") {
+		throw new Error(`--${flag} expects a number, got a bare flag`);
+	}
+	if (value === undefined || value === null) return 0;
+	const parsed = Number(value);
+	if (!Number.isFinite(parsed) || parsed < 0) {
+		throw new Error(
+			`--${flag} expects a number, got ${JSON.stringify(value)}`,
+		);
+	}
+	return parsed;
+}
+
+export function optionalNumber(value: unknown, flag: string): number | null {
+	if (value === undefined || value === null || value === "") return null;
+	return number(value, flag);
+}
+
+export function oneOf<T extends string>(
+	value: unknown,
+	allowed: readonly T[],
+	flag: string,
+): T | undefined {
+	if (value === undefined || value === null) return undefined;
+	const text = String(value);
+	if (!(allowed as readonly string[]).includes(text)) {
+		throw new Error(
+			`--${flag} expects ${allowed.join(" | ")}, got "${text}"`,
+		);
+	}
+	return text as T;
+}
+
+export function sinceOf(value: unknown): number {
+	if (value === undefined || value === null || value === "") return 0;
+	const parsed = Date.parse(String(value));
+	if (Number.isNaN(parsed)) {
+		throw new Error(`--since expects a date, got ${JSON.stringify(value)}`);
+	}
+	return parsed;
+}
+
+/** `--keywords ""` and a bare `--keywords` both mean "no keyword list at all". */
+export function keywordList(value: unknown): string[] | undefined {
+	if (value === undefined || value === null) return undefined;
+	if (value === true || value === 0 || value === "") return [];
+	return String(value)
+		.split(",")
+		.map((word) => word.trim().toLowerCase())
+		.filter(Boolean);
+}
+
+/** Custom rates only make sense with something to price them against. */
+export function customOf(flags: Record<string, unknown>): CustomRates | null {
+	// Any custom-model flag counts as "this run is about a custom model". The
+	// window caps and label were previously ignored on their own (`customOf`
+	// returned null and they vanished); now they demand the rates + budget too.
+	const touched =
+		flags.in !== undefined ||
+		flags.out !== undefined ||
+		flags.cacheRead !== undefined ||
+		flags.cacheWrite !== undefined ||
+		flags.budget !== undefined ||
+		flags.fiveHour !== undefined ||
+		flags.weekly !== undefined ||
+		flags.label !== undefined;
+	if (!touched) return null;
+	const budget = number(flags.budget, "budget");
+	if (budget <= 0) {
+		throw new Error("--budget <usd> is required alongside custom rates");
+	}
+	return {
+		label: typeof flags.label === "string" ? flags.label : "custom model",
+		input: number(flags.in, "in"),
+		output: number(flags.out, "out"),
+		cacheRead: optionalNumber(flags.cacheRead, "cache-read"),
+		cacheWrite: optionalNumber(flags.cacheWrite, "cache-write"),
+		budget,
+		// cac camelCases `--five-hour` to `fiveHour`; a name whose dash is
+		// followed by a digit (`--cap-5h`) would stay hyphenated and be unreadable.
+		cap5h: optionalNumber(flags.fiveHour, "five-hour"),
+		capWeek: optionalNumber(flags.weekly, "weekly"),
+	};
+}

package/src/cli/options.ts

@@ -0,0 +1,55 @@
+import { DEFAULT_KEYWORDS } from "~/constants/keywords.ts";
+import type { CustomRates } from "~/market/rates.ts";
+import { defaultStorePath } from "~/measure/store.ts";
+
+export interface Options {
+	/** `user` keeps only prompts you typed; `all` includes subagent sessions. */
+	sessions: "user" | "all";
+	/** Which mean the projection prices: the per-req mean, or one vote per conversation. */
+	weight: "turn" | "session";
+	keepTrivial: boolean;
+	keywords: string[];
+	minChars: number;
+	minOutput: number;
+	/** Epoch ms floor; 0 keeps everything. */
+	since: number;
+	project: string;
+	model: string;
+	limit: number;
+	sort: "reqmo" | "cost" | "name";
+	format: "text" | "json";
+	explain: boolean;
+	account: boolean;
+	/** cac already printed --help or --version; there is nothing left to do. */
+	handled: boolean;
+	color: "auto" | "always" | "never";
+	db: string;
+	mpc: string;
+	cmduse: string;
+	custom: CustomRates | null;
+}
+
+export function defaultOptions(): Options {
+	return {
+		sessions: "all",
+		weight: "turn",
+		keepTrivial: false,
+		keywords: [...DEFAULT_KEYWORDS],
+		minChars: 0,
+		minOutput: 0,
+		since: 0,
+		project: "",
+		model: "",
+		limit: 0,
+		sort: "reqmo",
+		format: "text",
+		explain: false,
+		account: true,
+		handled: false,
+		color: "auto",
+		db: defaultStorePath(),
+		mpc: process.env.MPC_BIN ?? "mpc",
+		cmduse: process.env.CMDUSE_BIN ?? "cmduse",
+		custom: null,
+	};
+}

package/src/cli/parse.ts

@@ -0,0 +1,101 @@
+import { cac } from "cac";
+import pkg from "../../package.json" with { type: "json" };
+import {
+	answeredByCac,
+	customOf,
+	keywordList,
+	number,
+	oneOf,
+	sinceOf,
+	str,
+} from "./flags.ts";
+import { defaultOptions, type Options } from "./options.ts";
+
+export function parseArgs(argv: string[]): Options {
+	const cli = cac("reqshape");
+	cli.option("--sessions <mode>", "all | user — user drops subagent sessions")
+		.option(
+			"--weight <mode>",
+			"turn | session — which mean the projection prices",
+		)
+		.option("--keep-trivial", "profile every prompt, noise included")
+		.option(
+			"--keywords <list>",
+			"comma-separated prompts counted as noise (replaces the default list)",
+		)
+		.option(
+			"--min-chars <n>",
+			"also drop prompts shorter than this (0 = off)",
+		)
+		.option(
+			"--min-output <n>",
+			"also drop asks producing fewer output tokens (0 = off)",
+		)
+		.option("--since <date>", "only asks on or after this date")
+		.option("--project <dir>", "only sessions under this directory")
+		.option("--model <text>", "only model rows whose name contains this")
+		.option("--limit <n>", "cap the number of model rows")
+		.option("--sort <key>", "reqmo | cost | name")
+		.option("--in <rate>", "custom model: input $/M tokens")
+		.option("--out <rate>", "custom model: output $/M tokens")
+		.option("--cache-read <rate>", "custom model: cache-read $/M tokens")
+		.option("--cache-write <rate>", "custom model: cache-write $/M tokens")
+		.option("--budget <usd>", "custom model: monthly allowance")
+		.option("--five-hour <usd>", "custom model: five-hour cap")
+		.option("--weekly <usd>", "custom model: weekly cap")
+		.option("--label <name>", "custom model: display name")
+		.option(
+			"--db <path>",
+			"opencode store (default ~/.local/share/opencode/opencode.db)",
+		)
+		.option("--mpc <bin>", "mpc binary (else MPC_BIN)")
+		.option("--cmduse <bin>", "cmduse binary (else CMDUSE_BIN)")
+		.option("--no-account", "skip the cmduse account line")
+		.option("--color <mode>", "auto | always | never")
+		.option("--explain", "list every drop reason rather than the top few")
+		.option("--format <mode>", "text | json");
+	cli.help();
+	cli.version(pkg.version);
+	cli.example("reqshape");
+	cli.example("reqshape --weight session --sort cost");
+	cli.example("reqshape --in 0.15 --out 0.6 --cache-read 0.003 --budget 60");
+
+	const { options: flags } = cli.parse(["node", "reqshape", ...argv], {
+		run: false,
+	});
+	const raw = (flags ?? {}) as Record<string, unknown>;
+	const options = defaultOptions();
+
+	options.sessions =
+		oneOf(raw.sessions, ["all", "user"], "sessions") ?? options.sessions;
+	options.weight =
+		oneOf(raw.weight, ["turn", "session"], "weight") ?? options.weight;
+	options.sort =
+		oneOf(raw.sort, ["reqmo", "cost", "name"], "sort") ?? options.sort;
+	options.format =
+		oneOf(raw.format, ["text", "json"], "format") ?? options.format;
+	// cac negates a declared flag itself, so --no-color arrives as `false`.
+	options.color =
+		raw.color === false
+			? "never"
+			: (oneOf(raw.color, ["auto", "always", "never"], "color") ??
+				options.color);
+
+	options.keepTrivial = raw.keepTrivial === true;
+	options.keywords = keywordList(raw.keywords) ?? options.keywords;
+	options.minChars = number(raw.minChars, "min-chars");
+	options.minOutput = number(raw.minOutput, "min-output");
+	options.limit = number(raw.limit, "limit");
+	options.since = sinceOf(raw.since);
+	options.project = str(raw.project) ?? "";
+	options.model = str(raw.model) ?? "";
+	options.explain = raw.explain === true;
+	options.account = raw.account !== false;
+	options.handled = answeredByCac(raw);
+	options.db = str(raw.db) ?? options.db;
+	options.mpc = str(raw.mpc) ?? options.mpc;
+	options.cmduse = str(raw.cmduse) ?? options.cmduse;
+	options.custom = customOf(raw);
+
+	return options;
+}

package/src/cli/run.ts

@@ -0,0 +1,142 @@
+import { entriesOf } from "~/market/entries.ts";
+import { type Projection, projectAll } from "~/market/project.ts";
+import { customEntry, type RateEntry } from "~/market/rates.ts";
+import { loadAccount, loadMpc } from "~/market/sources.ts";
+import { buildAsks } from "~/measure/asks.ts";
+import { filterAsks } from "~/measure/filter.ts";
+import { buildShape } from "~/measure/profile.ts";
+import { readStore } from "~/measure/store.ts";
+import type { Profile } from "~/types.ts";
+import { setColorMode } from "~/view/format.ts";
+import { renderJson } from "~/view/json.ts";
+import { renderText } from "~/view/render.ts";
+import type { Options } from "./options.ts";
+import { parseArgs } from "./parse.ts";
+
+function colorEnabled(options: Options): boolean {
+	if (options.color === "always") return true;
+	if (options.color === "never") return false;
+	return Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+}
+
+/** Most requests per month first. Free models tie rather than compare as NaN. */
+function byRequestsPerMonth(a: Projection, b: Projection): number {
+	if (a.requestsPerMonth === b.requestsPerMonth) return 0;
+	return a.requestsPerMonth > b.requestsPerMonth ? -1 : 1;
+}
+
+function sortProjections(
+	projections: Projection[],
+	sort: Options["sort"],
+): Projection[] {
+	const sorted = [...projections];
+	if (sort === "cost") {
+		return sorted.sort((a, b) => a.costPerReq - b.costPerReq);
+	}
+	if (sort === "name") {
+		return sorted.sort((a, b) =>
+			a.entry.model.localeCompare(b.entry.model),
+		);
+	}
+	return sorted.sort(byRequestsPerMonth);
+}
+
+/**
+ * The catalogue comes from mpc, which already knows both plans' pricing,
+ * allowances and window rules. A custom model is priced alongside it, and
+ * carries the run when mpc is unavailable.
+ */
+function ratesOf(options: Options): RateEntry[] {
+	let entries: RateEntry[] = [];
+	try {
+		entries = entriesOf(loadMpc(options.mpc));
+	} catch (error) {
+		const detail = error instanceof Error ? error.message : String(error);
+		if (!options.custom) {
+			throw new Error(
+				`${detail}\nPass --in/--out/--budget to price a custom model instead.`,
+			);
+		}
+		process.stderr.write(
+			`reqshape: ${detail}\n          pricing the custom model only\n`,
+		);
+	}
+	if (options.custom) entries.push(customEntry(options.custom));
+	return entries;
+}
+
+export async function run(argv: string[]): Promise<number> {
+	const options = parseArgs(argv);
+	// cac has already written the help or version text.
+	if (options.handled) return 0;
+	setColorMode(colorEnabled(options));
+
+	const store = readStore(options.db);
+	const asks = buildAsks(store.messages, store.sessions);
+	const { kept, drops } = filterAsks(asks, {
+		sessions: options.sessions,
+		keywords: new Set(options.keywords),
+		minChars: options.minChars,
+		minOutput: options.minOutput,
+		keepTrivial: options.keepTrivial,
+		since: options.since,
+		project: options.project,
+	});
+	const shape = buildShape(kept);
+
+	if (shape.reqs === 0) {
+		const why =
+			drops.map((drop) => `${drop.reason} ${drop.asks}`).join(" · ") ||
+			"no requests found";
+		process.stderr.write(
+			`reqshape: nothing to price — no requests survived the filters (${why})\n`,
+		);
+		return 1;
+	}
+
+	const profile: Profile =
+		options.weight === "session" ? shape.perSession : shape.perReq;
+
+	let entries = ratesOf(options);
+	const needle = options.model.trim().toLowerCase();
+	if (needle) {
+		entries = entries.filter((entry) =>
+			entry.model.toLowerCase().includes(needle),
+		);
+	}
+	const total = entries.length;
+	let projections = sortProjections(
+		projectAll(entries, profile),
+		options.sort,
+	);
+	if (options.limit > 0) projections = projections.slice(0, options.limit);
+	const account = options.account ? loadAccount(options.cmduse) : null;
+
+	if (options.format === "json") {
+		process.stdout.write(
+			renderJson({
+				shape,
+				projections,
+				drops,
+				weight: options.weight,
+				layout: store.layout,
+				profile: { ...profile },
+			}),
+		);
+		return 0;
+	}
+
+	process.stdout.write(
+		renderText({
+			shape,
+			projections,
+			drops,
+			weight: options.weight,
+			account,
+			layout: store.layout,
+			total,
+			explain: options.explain,
+		}),
+	);
+	return 0;
+}

package/src/constants/ansi.ts

@@ -0,0 +1,4 @@
+// Biome forbids control characters in regex literals, and a literal escape here
+// would be one: build the pattern from a codepoint instead.
+export const ESC = String.fromCharCode(27);
+export const ANSI = new RegExp(`${ESC}\\[[0-9;]*m`, "g");

package/src/constants/asks.ts

@@ -0,0 +1,14 @@
+import type { AskKind } from "~/types.ts";
+
+/**
+ * Row kinds that *open* a new ask. Only a prompt the user typed does.
+ *
+ * `synthetic` / `system` / `compaction` / `shell` rows are interjections: a
+ * system-reminder lands after the prompt and before its answer, so treating one
+ * as a boundary filed the answer's reqs under the interjection, which the
+ * filter then discarded along with the whole response. They now continue the
+ * ask they interrupted.
+ */
+export const BOUNDARY: Record<string, AskKind> = {
+	user: "user",
+};