baesian 0.0.0-stage → 1.0.1

package/dist/practice-answers.js

@@ -0,0 +1,42 @@
+import { PRACTICE_FIELDS } from "./api.js";
+import { PracticeEntry, describeError, newestFormat } from "./schema.js";
+// Where practice answers are kept (B-rehdw, "On the service, for every device"; docs/vault/Design/Practice Cards.md
+// section 5): an address of their own, apart from the state, on `baesian serve` (`GET` and `POST /api/practice`, a folder
+// of the live layer, `PRACTICE_DIR`) and on the relay (`GET` and `POST .../practice`, a table of the project's object,
+// `PracticeTable`, for a signed-in browser only). Both take an entry through `practiceEntry()`. Nothing an agent runs
+// reads them: not `inbox`, `wait`, the MCP tools, the plugin's hooks, `sync`, the vault adapter or the gate.
+/** The live layer's folder of practice entries, in a clone that isn't linked. Not one of the kinds the record copies. */
+export const PRACTICE_DIR = "practice";
+/** Why a practice entry wasn't taken, with the status the address answers. */
+export class PracticeRefused extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+/**
+ * A practice entry from what the client sent and who sent it, checked against those already kept: only the fields a
+ * practice entry may be sent with (`PRACTICE_FIELDS`), in its format; the blind test starts once; and an entry in the
+ * test needs it started. Throws `PracticeRefused`.
+ */
+export function practiceEntry(input, who, earlier, at = new Date().toISOString()) {
+    if (typeof input !== "object" || input === null || Array.isArray(input))
+        throw new PracticeRefused(400, "send a practice answer as a JSON object");
+    const unknown = Object.keys(input).filter((k) => !PRACTICE_FIELDS.has(k));
+    if (unknown.length)
+        throw new PracticeRefused(400, `unexpected fields: ${unknown.join(", ")}`);
+    const parsed = PracticeEntry.safeParse({ ...input, type: "practice", format: newestFormat("practice"), reviewer: who.reviewer, ...(who.account ? { account: who.account } : {}), client: who.client, at });
+    if (!parsed.success)
+        throw new PracticeRefused(400, `that practice answer isn't valid:\n${describeError(parsed.error)}`);
+    const e = parsed.data;
+    const started = earlier.some((x) => x.kind === "test-start");
+    if (e.kind === "test-start" && started)
+        throw new PracticeRefused(409, "the blind test has started already: it runs once");
+    if ((e.kind === "mark" || (e.kind === "answer" && e.test)) && !started)
+        throw new PracticeRefused(409, "the blind test hasn't started");
+    return e;
+}
+/** Practice entries in the order they were written. */
+export const inOrder = (entries) => [...entries].sort((a, b) => a.at.localeCompare(b.at));
+//# sourceMappingURL=practice-answers.js.map

package/dist/proposals.js

@@ -0,0 +1,197 @@
+import { countedCards, replayCards, rowWindows } from "./report.js";
+import { LEVEL_AT, POSITION_NAMES, ROW_NAMES, chanceUnder, isOwnCard, loosenAfter, oneMissWithin, replay, rowTest, stop, tightenAt } from "./routing.js";
+import { SIMILAR_TITLE, jaccard, tokens } from "./similarity.js";
+// The cards Baesian files itself from the record, with no model, as it files conflict cards (D65): convention cards,
+// "Make these one rule?" (D161, P16 section 6), and slider proposals, "move this slider?" (B-y6jn6, B-jtsfh). The local server
+// runs `afterVerdict` when the client records an answer; a relay sync will run it when the CLI pulls one (M9).
+/** Where each kind goes: a deck of its own, created when it's first used. */
+export const CONVENTIONS_DECK = {
+    id: "conventions",
+    title: "Patterns in your answers",
+    brief: "Baesian files these itself when your answers show a pattern: decisions in one area decided alike, or a comment that states a rule. Saying yes asks an agent to draft the rule, which comes back to you as a card.\n",
+};
+export const PREFERENCES_DECK = {
+    id: "preferences",
+    title: "Your preferences",
+    brief: "Baesian files these itself from each row's record: one stop down once it's 95% sure the row's misses are under 1 in 10, one stop up once it's as sure they're over. Accepting one writes a new preference file; Baesian never moves a row on its own.\n",
+};
+/** A comment that states a rule (P16 section 6). The word list is a guess, to tune while dogfooding. */
+export const RULE_WORDS = /\b(always|never|from now on|in general)\b/i;
+/** After the client records a verdict: the convention cards and slider proposals the record now calls for, filed. */
+export function afterVerdict(store, verdict) {
+    return [...proposeConvention(store, verdict.card), ...proposeSliderMoves(store)];
+}
+// ---------------------------------------------------------------- convention cards (D161)
+/** A decision that can be evidence for a convention: an agent's, resolved, and not already a rule or on its way to one. */
+function eligible(store, card, used, ruled) {
+    const id = card.meta.id;
+    return !isOwnCard(card.meta) && !used.has(id) && !ruled.has(id) && store.status(id) === "resolved" && !store.ruleAsked(id);
+}
+const areaOf = (store, card) => store.canonicalTopic(card.meta.topic).split("/")[0];
+/**
+ * A convention card from a decision just resolved, if its answer shows a pattern (P16 section 6): a comment in rule
+ * words, or at least one other resolved decision in the same area whose chosen answer is alike, by the filing check's
+ * similarity. A decision is evidence for one convention card at most, so a pattern you've declined comes back only
+ * from new decisions.
+ */
+export function proposeConvention(store, id) {
+    const plan = store.view(() => {
+        const card = store.card(id);
+        if (!card)
+            return undefined;
+        const conventions = store.cards().filter((c) => c.meta.convention !== undefined && store.status(c.meta.id) !== "withdrawn");
+        const used = new Set(conventions.flatMap((c) => c.meta.depends_on));
+        const ruled = new Set(store.rules().flatMap((r) => (r.meta.from_card ? [r.meta.from_card] : [])));
+        if (!eligible(store, card, used, ruled))
+            return undefined;
+        const verdict = store.verdicts(id).filter((v) => v.revision === card.meta.revision).at(-1);
+        if (verdict?.make_rule)
+            return undefined;
+        const area = areaOf(store, card);
+        const decided = (c) => store.decision(c.meta.id) ?? "";
+        if (verdict?.comment && RULE_WORDS.test(verdict.comment)) {
+            return { signal: "rule-words", area, cards: [card], fact: `On ${id}, “${card.meta.title}”, you chose “${decided(card)}”, and wrote: “${verdict.comment}”` };
+        }
+        const mine = tokens(decided(card));
+        const alike = store
+            .cards()
+            .filter((o) => o.meta.id !== id && areaOf(store, o) === area && eligible(store, o, used, ruled) && jaccard(mine, tokens(decided(o))) >= SIMILAR_TITLE)
+            .sort((a, b) => a.meta.created.localeCompare(b.meta.created));
+        if (!alike.length)
+            return undefined;
+        const cards = [...alike, card];
+        return { signal: "same-choice", area, cards, fact: cards.map((c) => `${c.meta.id}, “${c.meta.title}”: you chose “${decided(c)}”`).join("; ") };
+    });
+    if (!plan)
+        return [];
+    const one = plan.cards.length === 1;
+    const draft = {
+        title: `A pattern in your answers on ${plan.area}`,
+        question: one ? "Should this decision become a rule?" : `Should these ${plan.cards.length} decisions become one rule?`,
+        doing: "reading your answers for patterns",
+        topic: `conventions/${plan.area}/${plan.cards[0].meta.id.toLowerCase()}`,
+        level: "provisional",
+        touches: [],
+        reverse: "cheap",
+        proposal: one ? "Draft a rule from it" : "Draft a rule from these",
+        proposal_then: "an agent drafts the rule and its gate patterns, and it comes back to you to confirm",
+        alternative: one ? "Keep it to this decision" : "Keep them separate",
+        alternative_then: one ? "nothing is saved, and this decision isn't proposed again" : "nothing is saved, and these decisions aren't proposed again",
+        crux: "Would you decide the next one like these the same way, unasked?",
+        crux_proposal: "If so",
+        crux_alternative: "If it depends",
+        crux_fact: plan.fact,
+        depends_on: plan.cards.map((c) => c.meta.id),
+        convention: plan.signal,
+    };
+    const body = `Baesian found this pattern itself, with no model (D161): ${plan.signal === "rule-words" ? "a comment that states a rule" : "decisions in one area whose chosen answers are alike"}.\n`;
+    return [store.fileOwn(draft, body, CONVENTIONS_DECK)];
+}
+// ---------------------------------------------------------------- slider proposals (B-y6jn6, B-jtsfh)
+/** What a position does to a row's cards, in a line. */
+function effect(to, settings) {
+    const rate = (p) => `about 1 in ${Math.round(1 / p)}`;
+    switch (to) {
+        case "agent-decides":
+            return `agents go ahead without you on these, and ${rate(settings.rate_agent_decides)} comes back to you as an audit`;
+        case "sample":
+            return `agents go ahead without you on these, and ${rate(settings.rate_sample)} comes back to you as an audit`;
+        case "tell-me":
+            return "these reach you, and agents carry on with their pick until you answer";
+        case "stop-and-ask":
+            return "agents wait for your answer on these while you're there";
+        case "never-without-me":
+            return "agents never go ahead on these without your answer";
+    }
+}
+const named = (p) => `“${POSITION_NAMES[p]}”`;
+/**
+ * Propose moving each row one stop (B-y6jn6), by one test both ways (B-jtsfh): down once Baesian is 95% sure the row's
+ * miss rate is under 1 in 10, up once it's as sure it's over (`rowTest()`, a uniform prior over the rate), from every
+ * final answer at the row's position since it last moved, on cards filed since the agents' model last changed
+ * (`rowWindows()`). A miss adds to what loosening needs and never wipes out the answers before it. Misses are as cards
+ * B-87tkc and B-ab06a count them, final answers on shown rows and audits on held ones. After you keep a row where it was,
+ * that move is proposed again only from the answers since, passing the test on their own. Not past a row's floor, and not
+ * while a proposal on the row is still waiting; where both ways pass, it proposes tightening. Loosening is hard, since it
+ * lets more decisions past you; tightening is provisional.
+ */
+export function proposeSliderMoves(store) {
+    const plans = store.view(() => {
+        const force = store.inForce();
+        const counted = countedCards(store);
+        return rowWindows(store, counted, force).flatMap((w) => {
+            if (w.waiting)
+                return [];
+            for (const dir of ["up", "down"]) {
+                const evidence = w[dir];
+                if (rowTest(evidence.answered.length, evidence.misses.length) !== dir)
+                    continue;
+                const to = stop(w.row, w.position, dir);
+                if (to)
+                    return [{ row: w.row, from: w.position, to, dir, evidence, counted, settings: force.settings }];
+            }
+            return [];
+        });
+    });
+    return plans.map((p) => store.fileOwn(sliderDraft(p.row, p.from, p.to, p.dir, p.evidence, p.counted, p.settings), sliderBody(p.dir), PREFERENCES_DECK));
+}
+/** What made a card a miss, in the words of a slider card's evidence (B-87tkc, B-ab06a). */
+const MISSED_BY = {
+    overturn: "your final answer went against the agent's pick",
+    asked: "you kept the agent's pick, and marked that you should have been asked",
+    blind: "a question of what you value, you chose against the agent's pick before seeing its case",
+};
+/** What a miss is, as a slider card says it (B-87tkc, B-ab06a). */
+export const MISS_WORDS = "A miss is a final answer that overturns the agent's pick, or one marked “you should have asked me” (B-87tkc); and on a question of what you value, a blind choice against the agent's pick, whatever you answer after its case (B-ab06a).";
+/** Since when a row's answers are counted, as a slider card says it: "since it last moved". */
+function sinceWords(since) {
+    if (!since)
+        return "so far";
+    if (since.why === "moved")
+        return "since it last moved";
+    if (since.why === "kept")
+        return "since you last kept it here";
+    return `since the agents' model changed to ${since.model}`;
+}
+const percent = (x) => `${(Math.floor(x * 1000) / 10).toFixed(1)}%`;
+function sliderDraft(row, from, to, dir, evidence, counted, settings) {
+    const name = ROW_NAMES[row];
+    const lower = name.charAt(0).toLowerCase() + name.slice(1);
+    const n = evidence.answered.length;
+    const k = evidence.misses.length;
+    const last = dir === "up" ? evidence.misses.at(-1) : evidence.answered.at(-1);
+    const moved = { ...settings, rows: { ...settings.rows, [row]: to } };
+    const after = replay(replayCards(counted), moved).rows[row];
+    const cards = (c) => `${c} ${c === 1 ? "card" : "cards"}`;
+    // What the move would have held of past cards, when it moves to a stop that holds any back.
+    const history = after && !LEVEL_AT[to] ? ` Of the ${cards(after.cards)} on this row so far, ${after.held} would have been held back at ${named(to)}.` : "";
+    const record = `Of your ${n} final ${n === 1 ? "answer" : "answers"} on it ${sinceWords(evidence.since)}, ${k === 0 ? "none was a miss" : k === 1 ? "1 was a miss" : `${k} were misses`}`;
+    const under = chanceUnder(n, k);
+    const fact = dir === "up"
+        ? `“${name}” is at ${named(from)}. On ${last.card.meta.id}, “${last.card.meta.title}”, ${MISSED_BY[last.answers.missBy ?? "overturn"]}. ${record}: Baesian is ${percent(1 - under)} sure the row's misses are over 1 in 10.${history}`
+        : `“${name}” is at ${named(from)}. ${record}: Baesian is ${percent(under)} sure the row's misses are under 1 in 10.${history}`;
+    return {
+        title: `The setting for ${lower}`,
+        question: `Where should the setting for ${lower} be now?`,
+        doing: "reading the record of your answers, row by row",
+        topic: `preferences/${row.replace(/_/g, "-")}/${last.card.meta.id.toLowerCase()}`,
+        level: dir === "up" ? "provisional" : "hard",
+        touches: [],
+        reverse: "cheap",
+        proposal: `Move it to ${named(to)}`,
+        proposal_then: `a new preference file moves it: ${effect(to, settings)}${settings.mode === "shadow" && !["tell-me", "stop-and-ask", "never-without-me"].includes(to) ? " (in shadow, nothing is held back yet)" : ""}`,
+        alternative: `Keep it at ${named(from)}`,
+        // B-jtsfh: a move you decline is proposed again only once the answers after it pass the test on their own.
+        alternative_then: "nothing changes, and Baesian proposes this move again only once your answers from now on pass the same test on their own",
+        crux: dir === "up" ? "Are these misses a sign of this kind of decision, or chance?" : "Can agents take this kind of decision with less of your attention?",
+        crux_proposal: dir === "up" ? "A sign of the kind" : "If they can",
+        crux_alternative: dir === "up" ? "Chance" : "Not yet",
+        crux_fact: fact,
+        pref_row: row,
+        pref_from: from,
+        pref_to: to,
+    };
+}
+/** The rule a slider card comes from, in its body (B-y6jn6, B-jtsfh), with the numbers the test gives. */
+export const sliderBody = (dir) => `Baesian files this itself from the record, by a fixed rule (B-y6jn6, B-jtsfh): ${dir === "up" ? "one stop up" : "one stop down"} once it's 95% sure the row's misses are ${dir === "up" ? "over" : "under"} 1 in 10, from every final answer on the row since it last moved, with no prior lean either way. ${dir === "up" ? `That's a miss in the first ${oneMissWithin()} answers, ${tightenAt(10)} in 10, or ${tightenAt(20)} in 20.` : `That's ${loosenAfter(0)} answers with no miss, ${loosenAfter(1)} with one, or ${loosenAfter(2)} with two.`} A change of the agents' model starts the count again, and after you keep a row where it is, Baesian proposes that move again only from the answers since. ${MISS_WORDS} Accepting writes a new preference file; Baesian never moves a row on its own.\n`;
+//# sourceMappingURL=proposals.js.map

package/dist/quote.js

@@ -0,0 +1,28 @@
+/** A name or branch as it's printed: as it is when it's plain, else as a JSON string, since names are self-declared. */
+export function plain(name) {
+    return /^[\w][\w .@/+-]*$/.test(name) && !name.endsWith(" ") ? name : JSON.stringify(name);
+}
+/** The author, as a line names them: `Gus Ellerm (a person)`, `claude-code on main (an agent)`. */
+export function byLine(a) {
+    return "person" in a ? `${plain(a.person)} (a person)` : `${plain(a.agent)} on ${plain(a.branch)} (an agent)`;
+}
+/** An agent's name alone, as a line names it: `claude-code (an agent)`. */
+export const agentLabel = (name) => `${plain(name)} (an agent)`;
+/** A text someone else wrote, as a JSON string: one line, its quotes and newlines escaped. */
+export const q = (text) => JSON.stringify(text);
+/** `<what> by <author>: "<text>"`. */
+export const said = (what, a, text) => `${what} by ${byLine(a)}: ${q(text)}`;
+export const cardAuthor = (m) => ({ agent: m.source_agent, branch: m.source_branch });
+export const reviewerOf = (v) => ({ person: v.reviewer });
+/**
+ * One verdict on a line: what the reviewer answered, by whom, and its comment, each text quoted (D169). `accepted` is
+ * the proposal an accept chose, when the caller has the card: an accept names what it decided, as `wait` does.
+ */
+export function answerLine(v, accepted) {
+    const what = v.choice ?? (v.response === "accept" ? accepted : undefined);
+    const answer = `${v.response} by ${byLine(reviewerOf(v))}${what !== undefined ? `: ${q(what)}` : ""}`;
+    const comment = v.comment ? `; comment: ${q(v.comment)}` : "";
+    const retired = v.retire_rules?.length ? `; retires ${v.retire_rules.join(", ")}` : "";
+    return `${answer}${comment}${retired}`;
+}
+//# sourceMappingURL=quote.js.map

package/dist/report.js

@@ -0,0 +1,261 @@
+import { FINAL, FIXED_ROWS, ROWS, TODAY, answeredInChat, isOwnCard, outcomeOf, rank, rowOf, stop, toLoosen, } from "./routing.js";
+import { PENDING, settingsOf } from "./store.js";
+/**
+ * The agents' cards, on their rows, oldest first: Baesian's own and withdrawn cards are left out, and so are cards
+ * answered in chat (B-hswmx), whose choice wasn't made blind (`chatCards()` counts them). A card counts on its latest
+ * revision's record; one filed before the gate counts as "Today" showed it, in shadow.
+ */
+export function countedCards(store) {
+    return store.view(() => store
+        .cards()
+        .flatMap((card) => {
+        const id = card.meta.id;
+        const gate = store.gateRecord(id, card.meta.revision);
+        if (isOwnCard(card.meta) || gate?.source === "baesian")
+            return [];
+        const status = store.status(id);
+        if (status === "withdrawn")
+            return [];
+        const verdicts = store.verdicts(id);
+        if (answeredInChat({ meta: card.meta, verdicts }))
+            return [];
+        // A crux of preference makes a blind choice against the pick a miss (B-ab06a), as the latest revision states it.
+        const answers = outcomeOf(verdicts, { preference: card.meta.crux_preference });
+        if (gate) {
+            return [{ card, row: gate.row, position: gate.position, outcome: gate.outcome, mode: gate.mode, drawn: gate.drawn === true, at: gate.at, held: status === "held", answers, gate }];
+        }
+        const { row, position } = rowOf(card.meta.touches, TODAY);
+        return [{ card, row, position, outcome: "shown", mode: "shadow", drawn: false, at: card.meta.created, held: false, answers }];
+    })
+        .sort((a, b) => a.at.localeCompare(b.at)));
+}
+/**
+ * The agents' cards answered in chat (B-hswmx), each by the row `countedCards()` would put it on: left out of every
+ * measure, and only counted, so the report can say how many it left out. Withdrawn ones aren't counted at all.
+ */
+export function chatCards(store) {
+    return store.view(() => store.cards().flatMap((card) => {
+        const id = card.meta.id;
+        const gate = store.gateRecord(id, card.meta.revision);
+        if (isOwnCard(card.meta) || gate?.source === "baesian" || store.status(id) === "withdrawn")
+            return [];
+        if (!answeredInChat({ meta: card.meta, verdicts: store.verdicts(id) }))
+            return [];
+        return [gate ? gate.row : rowOf(card.meta.touches, TODAY).row];
+    }));
+}
+/** The counted cards as the replay reads them (`replay()` in src/routing.ts). */
+export function replayCards(counted) {
+    return counted.map((c) => ({
+        id: c.card.meta.id,
+        touches: c.card.meta.touches,
+        reverse: c.card.meta.reverse,
+        ...(c.gate?.asked ? { asked: c.gate.asked } : {}),
+        source: c.gate?.source ?? "agent",
+        outcome: c.answers,
+    }));
+}
+/** When each row last moved, from the preference history: a row never moved from "Today" has no time. */
+function lastMoves(store) {
+    const out = {};
+    let rows = TODAY.rows;
+    for (const name of store.preferenceNames()) {
+        let file;
+        try {
+            file = store.preferenceFile(name);
+        }
+        catch {
+            continue;
+        }
+        if (!file)
+            continue;
+        const next = settingsOf(file).rows;
+        for (const r of ROWS)
+            if (next[r] !== rows[r])
+                out[r] = file.at;
+        rows = next;
+    }
+    return out;
+}
+/**
+ * The agents' latest change of model (B-jtsfh, B-k0w7d): across every counted card, in filing order, the last card whose
+ * model is known and differs from the last one known before it. A card with no model changes nothing, and counts in
+ * whichever model's run it falls. Two models filing alternately keep starting the count again.
+ */
+export function modelChange(counted) {
+    let known;
+    let change;
+    for (const c of counted) {
+        const model = c.card.meta.source_model;
+        if (model === undefined)
+            continue;
+        if (known !== undefined && model !== known)
+            change = { at: c.at, model };
+        known = model;
+    }
+    return change;
+}
+/**
+ * When you last kept each row where it was, for each move Baesian proposed (B-jtsfh): the time of the final answer, other
+ * than accepting it, on a slider proposal that's no longer waiting. Baesian proposes that move again only from the final
+ * answers after it, so it never asks again on the evidence you just answered.
+ */
+function keptAt(store) {
+    const out = new Map();
+    for (const c of store.cards()) {
+        const m = c.meta;
+        if (!m.pref_row || !m.pref_from || !m.pref_to || PENDING.has(store.status(m.id)))
+            continue;
+        const last = store.verdicts(m.id).filter((v) => FINAL.has(v.response)).at(-1);
+        if (!last || last.response === "accept")
+            continue;
+        const key = `${m.pref_row} ${rank(m.pref_to) > rank(m.pref_from) ? "up" : "down"}`;
+        if ((out.get(key) ?? "") < last.at)
+            out.set(key, last.at);
+    }
+    return out;
+}
+/**
+ * Each row's record for moving it, under the settings in force (B-jtsfh): the final answers at its position since it last
+ * moved, on cards filed since the agents' model last changed; for each way, less those before you last kept it where it
+ * was when Baesian proposed moving it that way. A miss adds to what's needed, and never wipes out the answers before it.
+ */
+export function rowWindows(store, counted, force = store.inForce()) {
+    return store.view(() => {
+        const moved = lastMoves(store);
+        const model = modelChange(counted);
+        const kept = keptAt(store);
+        const waiting = new Set(store.cards().flatMap((c) => (c.meta.pref_row && PENDING.has(store.status(c.meta.id)) ? [c.meta.pref_row] : [])));
+        return ROWS.map((row) => {
+            const position = force.settings.rows[row];
+            const since = moved[row];
+            const base = counted
+                .filter((c) => c.row === row && c.position === position && c.answers.final && (!since || c.answers.final.at >= since) && (!model || c.at >= model.at))
+                .sort((a, b) => a.answers.final.at.localeCompare(b.answers.final.at));
+            const evidence = (dir) => {
+                const keptHere = kept.get(`${row} ${dir}`);
+                const answered = keptHere ? base.filter((c) => c.answers.final.at > keptHere) : base;
+                const starts = [
+                    ...(since ? [{ at: since, why: "moved" }] : []),
+                    ...(model ? [{ at: model.at, why: "model", model: model.model }] : []),
+                    ...(keptHere ? [{ at: keptHere, why: "kept" }] : []),
+                ];
+                const start = starts.sort((a, b) => a.at.localeCompare(b.at)).at(-1);
+                return { ...(start ? { since: start } : {}), answered, misses: answered.filter((c) => c.answers.miss) };
+            };
+            return { row, position, down: evidence("down"), up: evidence("up"), waiting: waiting.has(row) };
+        });
+    });
+}
+/** A row of the report with nothing counted yet. */
+export const blankRow = () => ({
+    shown: 0,
+    held: 0,
+    wouldHold: 0,
+    drawn: 0,
+    auditsAnswered: 0,
+    auditsUnanswered: 0,
+    answered: 0,
+    misses: 0,
+    switched: 0,
+    blind: 0,
+    matched: 0,
+    agreed: 0,
+    cameRound: 0,
+    unblind: 0,
+    unanswered: 0,
+    heldWaiting: 0,
+    inChat: 0,
+});
+/**
+ * Where a card falls in your calibration's bar (D180), by its answers: a miss (overturned, should have been asked, or on
+ * a crux of preference chosen against blind, B-ab06a), came round (switched, on a crux of fact), chose as the agent did
+ * (a final accept whose blind choice was its pick); or, left out of the bar, a final accept with no blind choice, or no
+ * final answer at all. Each card falls in exactly one.
+ */
+export function calibrationOf(answers) {
+    if (answers.miss)
+        return "missed";
+    if (answers.switched)
+        return "cameRound";
+    if (!answers.final)
+        return "unanswered";
+    return answers.final.response === "accept" && answers.final.first_choice === "proposal" ? "agreed" : "unblind";
+}
+/** The report (P14 section 3): per row, and pooled first, as the client shows it. */
+export function routingReport(store, force = store.inForce()) {
+    return store.view(() => {
+        const counted = countedCards(store);
+        const rows = {};
+        const pooled = blankRow();
+        for (const row of ROWS)
+            rows[row] = { position: force.settings.rows[row], ...blankRow() };
+        for (const c of counted) {
+            const r = (rows[c.row] ??= { position: FIXED_ROWS.includes(c.row) ? "never-without-me" : force.settings.rows[c.row], ...blankRow() });
+            for (const t of [r, pooled]) {
+                if (c.outcome === "shown")
+                    t.shown++;
+                else if (c.mode === "enforce")
+                    t.held++;
+                else
+                    t.wouldHold++;
+                if (c.outcome === "held" && c.mode === "enforce" && c.drawn) {
+                    t.drawn++;
+                    if (c.held)
+                        t.auditsUnanswered++;
+                    else if (c.answers.final)
+                        t.auditsAnswered++;
+                }
+                if (c.answers.final) {
+                    t.answered++;
+                    if (c.answers.miss)
+                        t.misses++;
+                    if (c.answers.switched)
+                        t.switched++;
+                    if (c.answers.final.first_choice) {
+                        t.blind++;
+                        if (c.answers.final.first_choice === "proposal")
+                            t.matched++;
+                    }
+                }
+                else if (c.answers.miss)
+                    t.misses++;
+                const where = calibrationOf(c.answers);
+                if (where === "agreed")
+                    t.agreed++;
+                else if (where === "cameRound")
+                    t.cameRound++;
+                else if (where === "unblind")
+                    t.unblind++;
+                else if (where === "unanswered") {
+                    t.unanswered++;
+                    if (c.held)
+                        t.heldWaiting++;
+                }
+            }
+        }
+        // Answered in chat (B-hswmx): left out of every count above, and said beside them.
+        for (const row of chatCards(store)) {
+            const r = (rows[row] ??= { position: FIXED_ROWS.includes(row) ? "never-without-me" : force.settings.rows[row], ...blankRow() });
+            r.inChat++;
+            pooled.inChat++;
+        }
+        // What each row now needs for a lower stop (B-jtsfh), which the calibration panel says beside its bar.
+        for (const w of rowWindows(store, counted, force)) {
+            const { since, answered, misses } = w.down;
+            const lower = stop(w.row, w.position, "down") !== undefined;
+            rows[w.row].test = {
+                ...(since ? { since: since.at, why: since.why } : {}),
+                answers: answered.length,
+                misses: misses.length,
+                ...(lower ? { toLoosen: toLoosen(answered.length, misses.length) } : {}),
+                waiting: w.waiting,
+            };
+        }
+        for (const r of [...Object.values(rows), pooled])
+            if (r.answered > 0 && r.misses === 0)
+                r.bound = 3 / r.answered;
+        return { rows, pooled, beforeGate: counted.filter((c) => !c.gate).length };
+    });
+}
+//# sourceMappingURL=report.js.map