tickmarkr 1.30.0

package/dist/cli/commands/plan.js

@@ -0,0 +1,101 @@
+import { allAdapters, discoverChannels, doctorAgeMs, modelAuthExclusions, modelAuthLine, probeAll, readDoctor, servableExclusions, servabilityLine } from "../../adapters/registry.js";
+import { modelLints } from "../../adapters/model-lints.js";
+import { collateralLints } from "../../compile/collateral.js";
+import { loadConfig } from "../../config/config.js";
+import { loadGraph } from "../../graph/graph.js";
+import { excludedChannels, exclusionLine } from "../../route/preference.js";
+import { route, RoutingError } from "../../route/router.js";
+import { loadRoutingProfile } from "../../run/journal.js";
+export async function plan(_argv, cwd = process.cwd(), adapters = allAdapters()) {
+    // ponytail: hardcoded 24h TTL — promote to config when an operator asks. mtime is the signal because
+    // doctor.json has no probe timestamp and a schema field would break the existing-files compat invariant.
+    const DOCTOR_STALE_MS = 24 * 60 * 60 * 1000;
+    const cfg = loadConfig(cwd);
+    const g = loadGraph(cwd);
+    // readDoctor cache path: staleness line only fires here (probeAll fallback is fresh by construction).
+    const cached = readDoctor(cwd);
+    const health = cached ?? (await probeAll(adapters));
+    const channels = discoverChannels(cfg, adapters, health);
+    // VIS-04 trust ramp (VALIDATION 13-01-11): preview:true bypasses the routing.learned:off short-circuit so
+    // the static-vs-learned column renders even when the daemon's learned routing is off. Cold ⇒ undefined ⇒
+    // output byte-identical to today.
+    const profile = loadRoutingProfile(cwd, cfg, { preview: true });
+    let deviations = 0;
+    const lines = [`drovr plan — dry run (${channels.length} channels available)`, ""];
+    const excluded = excludedChannels(cfg, adapters, health);
+    if (excluded.length)
+        lines.push(exclusionLine(excluded), "");
+    const servable = servableExclusions(cfg, adapters, health);
+    if (servable.length)
+        lines.push(servabilityLine(servable), "");
+    // T2 (2026-07-13): per-model unauthed verdicts from doctor — one lint per exclusion (reason + date).
+    const modelUnauthed = modelAuthExclusions(cfg, adapters, health);
+    if (modelUnauthed.length)
+        lines.push(modelAuthLine(modelUnauthed), "");
+    const unauthed = adapters.filter((a) => health[a.id]?.installed && !health[a.id]?.authed).map((a) => a.id);
+    if (unauthed.length)
+        lines.push(`installed but unauthed: ${unauthed.join(", ")} — channels excluded from routing`, "");
+    if (cached) {
+        const age = doctorAgeMs(cwd);
+        if (age !== null && age > DOCTOR_STALE_MS) {
+            lines.push(`doctor.json is ${Math.floor(age / 3_600_000)}h old — run 'drovr doctor' to refresh (servability/auth may have changed)`, "");
+        }
+    }
+    // HYG-07(a)/T2 pin honesty: append the drop reason when a pin/miss message names a filtered channel —
+    // servable (not served) or model-auth (unauthed). Floor-failure errors name only surviving channels, so
+    // these never fire there; the standalone exclusion lines above carry that attribution.
+    const exclusionReason = (msg) => {
+        const s = servable.find((x) => msg.includes(x.key));
+        if (s)
+            return ` — ${s.key} is unservable (not in ${s.adapter}'s served model list)`;
+        const m = modelUnauthed.find((x) => msg.includes(x.key));
+        if (m)
+            return ` — ${m.key} is unauthed (${m.reason}, probed ${m.probedAt.split("T")[0]})`;
+        return "";
+    };
+    const lints = [];
+    for (const [role, sel] of [["judge", cfg.judge], ["consult", cfg.consult]]) {
+        if (!health[sel.adapter]?.installed)
+            lints.push(`${role}: ${sel.adapter}:${sel.model} not installed — that gate/consult will fail closed`);
+    }
+    lints.push(...modelLints(cfg, health, adapters)); // health may be pre-v1.5/probeAll-fallback — no-detection branch covers both
+    let cost = 0;
+    for (const t of g.tasks) {
+        try {
+            const r = route(t, cfg, channels, profile);
+            for (const l of r.lints) {
+                const suf = exclusionReason(l);
+                lints.push(suf ? `${l}${suf}` : l);
+            }
+            const est = r.assignment.channel === "sub" ? 0 : cfg.pricing[r.assignment.tier];
+            cost += est;
+            lines.push(`  ${t.id.padEnd(6)} ${t.shape.padEnd(10)} c${String(t.complexity).padEnd(3)}→ ${r.assignment.adapter}:${r.assignment.model} [${r.assignment.channel}/${r.assignment.tier}]${t.humanGate ? " (human gate)" : ""}${est ? ` ~$${est.toFixed(2)}` : ""} — ${r.provenance}`);
+            if (r.deviation) {
+                deviations++;
+                const d = r.deviation;
+                lines.push(`    ⇄ static would pick ${d.static} — learned picked ${d.chosen} (score ${d.score.toFixed(3)} n=${d.n} vs ${d.staticScore.toFixed(3)})`);
+            }
+        }
+        catch (e) {
+            if (!(e instanceof RoutingError))
+                throw e;
+            const msg = `${e.message}${exclusionReason(e.message)}`;
+            lines.push(`  ${t.id.padEnd(6)} ${t.shape.padEnd(10)} !! ${msg}`);
+            lints.push(`${t.id}: unroutable — ${msg}`);
+        }
+    }
+    lines.push("", `est. cost (API channels only, rough): ~$${cost.toFixed(2)} + judge/review/consult calls`);
+    // VIS-04: summary only when a profile is active AND something deviates. Labeled by the switch — off = preview.
+    if (profile && deviations) {
+        lines.push(cfg.routing.learned === "off"
+            ? `learned routing (preview — currently OFF): ${deviations}/${g.tasks.length} tasks would deviate from static (set routing.learned: on to adopt)`
+            : `learned routing: ${deviations}/${g.tasks.length} tasks deviate from static (routing.learned: off to disable)`);
+    }
+    if (lints.length)
+        lines.push("", "routing lints:", ...lints.map((l) => `  ! ${l}`));
+    // OBS-12/13/14/21: advisory only — never blocks --route-strict (run refuses on routing lints only)
+    const scopeLints = collateralLints(g.tasks, cwd);
+    if (scopeLints.length)
+        lines.push("", "scope lints:", ...scopeLints.map((l) => `  ! ${l}`));
+    return lines.join("\n");
+}

package/dist/cli/commands/profile.d.ts

@@ -0,0 +1 @@
+export declare function profile(argv: string[], cwd?: string): Promise<string>;

package/dist/cli/commands/profile.js

@@ -0,0 +1,56 @@
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { loadConfig } from "../../config/config.js";
+import { drovrDir } from "../../graph/graph.js";
+import { learnedScore, MIN_SAMPLES, cellsOf } from "../../route/profile.js";
+import { Journal, loadRoutingProfile, readProfileCursor, RUNS_WINDOW } from "../../run/journal.js";
+// drovr profile — inspect (show) and forget (reset) the derived learned-routing profile (VIS-03).
+// Read-only class like plan/status/report: no run lock. `reset` writes ONE cursor scalar, nothing else.
+export async function profile(argv, cwd = process.cwd()) {
+    return argv[0] === "reset" ? reset(cwd) : show(cwd);
+}
+// Non-destructive reset (T-13-06): a one-line runId cutoff at .drovr/profile-since. NEVER deletes,
+// truncates, or rotates any telemetry — the profile is derived (PROF-01), so there is nothing to delete;
+// the cursor only bounds loadRoutingProfile's telemetry window. drovrDir guarantees .drovr exists and
+// blanket-gitignores it, so the cursor is never git-addable. Opaque string: used only in a runId > compare.
+function reset(cwd) {
+    const cursor = Journal.latestRunId(cwd) ?? ""; // empty repo ⇒ empty cursor ⇒ readProfileCursor === undefined
+    const path = join(drovrDir(cwd), "profile-since");
+    writeFileSync(path, cursor + "\n");
+    return [
+        cursor
+            ? `profile reset — learned routing now forgets runs at or before ${cursor}.`
+            : `profile reset — no runs yet; wrote an empty cursor.`,
+        `  wrote .drovr/profile-since (telemetry is UNTOUCHED — report/resume still see every run).`,
+        `  to un-reset: delete .drovr/profile-since.`,
+    ].join("\n");
+}
+// Inspection surface: preview:true bypasses the routing.learned:off short-circuit so `show` renders the
+// profile even under the default off — same trust ramp as `drovr plan`. The routing path stays inert.
+function show(cwd) {
+    const cfg = loadConfig(cwd);
+    const cursor = readProfileCursor(cwd);
+    const p = loadRoutingProfile(cwd, cfg, { preview: true });
+    const header = [
+        `drovr profile`,
+        `  routing.learned: ${cfg.routing.learned}${cfg.routing.learned === "off" ? " (preview — routing is inert)" : ""}`,
+        `  runs window: ${RUNS_WINDOW}`,
+        ...(cursor ? [`  reset cursor: ${cursor}`] : []),
+    ];
+    if (!p || p.cells.size === 0) {
+        // preview bypasses the switch ⇒ undefined here means data, not policy: no telemetry, or all behind the cursor.
+        header.push("", cursor
+            ? `  empty profile — no telemetry after the reset cursor (delete .drovr/profile-since to see earlier runs).`
+            : `  empty profile — no telemetry yet.`);
+        return header.join("\n");
+    }
+    const rows = [...cellsOf(p)].map(({ shape, chKey, channel, cell }) => {
+        const quality = cell.n > 0 ? (cell.qSum / cell.n).toFixed(2) : "-";
+        const median = cell.doneMedianMs === undefined ? "-" : `${Math.round(cell.doneMedianMs)}ms`;
+        // VIS-04/ROUTE-15 — preview must match routing's tuning, never the bare module default.
+        const score = learnedScore(p, shape, chKey, channel, { availWeight: cfg.routing.learnedTuning?.availWeight }).toFixed(3);
+        const cold = cell.n < MIN_SAMPLES ? `  cold (n<${MIN_SAMPLES})` : "";
+        return `  ${shape.padEnd(10)} ${chKey.padEnd(28)} ${channel.padEnd(4)} n=${String(cell.n).padEnd(3)} q=${quality.padEnd(5)} ${median.padEnd(9)} disp=${String(cell.dispatches).padEnd(3)} score=${score}${cold}`;
+    });
+    return [...header, "", "  shape      channel                      class obs   quality  median    dispatch  score", ...rows].join("\n");
+}

package/dist/cli/commands/report.d.ts

@@ -0,0 +1,4 @@
+import { type ChannelCost } from "../../report/cost.js";
+import { type JournalEvent, type TelemetryRow } from "../../run/journal.js";
+export declare function renderMarkdownRecord(runId: string, events: JournalEvent[], prices?: ChannelCost[], rows?: TelemetryRow[]): string;
+export declare function report(argv: string[], cwd?: string): Promise<string>;

package/dist/cli/commands/report.js

@@ -0,0 +1,306 @@
+import { parseArgs } from "node:util";
+import { addUsage } from "../../adapters/types.js";
+import { loadConfig } from "../../config/config.js";
+import { estimateCosts } from "../../report/cost.js";
+import { cellsOf, cellSummary } from "../../route/profile.js";
+import { Journal, loadRoutingProfile } from "../../run/journal.js";
+const n = (x) => x.toLocaleString("en-US"); // explicit locale — CI/darwin flake guard
+const EM = "—";
+// TokenUsage fields that are actually present — filtered, never coalesced to zero (absent ⇒ unmetered).
+const fields = (u) => {
+    const parts = [`in ${n(u.input)}`, `out ${n(u.output)}`];
+    if (u.cacheRead !== undefined && u.cacheWrite !== undefined)
+        parts.push(`cache r/w ${n(u.cacheRead)}/${n(u.cacheWrite)}`);
+    if (u.reasoning !== undefined)
+        parts.push(`reasoning ${n(u.reasoning)}`);
+    return parts.join("  ");
+};
+const total = (u) => [u.input, u.output, u.cacheRead, u.cacheWrite, u.reasoning].filter((x) => x !== undefined).reduce((a, b) => a + b, 0);
+const firstLine = (s) => {
+    if (typeof s !== "string" || !s)
+        return EM;
+    const i = s.indexOf("\n");
+    return (i < 0 ? s : s.slice(0, i)) || EM;
+};
+const channelLabel = (data) => {
+    const a = data.assignment;
+    if (!a || typeof a !== "object")
+        return EM;
+    const { adapter, model } = a;
+    return typeof adapter === "string" && typeof model === "string" ? `${adapter}:${model}` : EM;
+};
+const rateBasis = (row) => {
+    if (!row.rate)
+        return EM;
+    const cache = row.rate.cacheReadPerMtok === undefined ? "" : `; cache-read $${row.rate.cacheReadPerMtok}/Mtok`;
+    const date = row.rate.rateDate === undefined ? "" : `; rate date ${row.rate.rateDate}`;
+    return `in/out $${row.rate.inPerMtok}/$${row.rate.outPerMtok}/Mtok${cache}${date}`;
+};
+const priceLine = (row) => {
+    const windows = row.channel === "sub" && row.subPlan ? `windows: ${n(row.attempts)}` : `attempts/windows: ${n(row.attempts)}`;
+    const tokenText = row.tokens
+        ? `tokens: ${row.partialMetering ? "≥ " : ""}${fields(row.tokens)} (${n(total(row.tokens))} tokens)`
+        : "tokens: unmetered";
+    const prices = [];
+    const bases = [];
+    if (row.apiUsd !== undefined)
+        prices.push(`price: $${row.apiUsd.toFixed(6)}`);
+    if (row.amortizedUsd !== undefined && row.subPlan !== undefined) {
+        const [low, high] = row.amortizedUsd;
+        prices.push(`price: $${low.toFixed(6)}–$${high.toFixed(6)} amortized`);
+        bases.push(`${n(row.attempts)} windows × $${row.subPlan.planMonthly}/month ÷ ${row.subPlan.windowsPerMonthHigh}–${row.subPlan.windowsPerMonthLow} windows/month`);
+    }
+    if (row.counterfactualUsd !== undefined)
+        prices.push(`API-equivalent: $${row.counterfactualUsd.toFixed(6)}`);
+    if (row.rate)
+        bases.push(rateBasis(row));
+    if (!prices.length)
+        prices.push("price: not measurable");
+    if (!bases.length)
+        bases.push(row.reason || "not recorded");
+    return `- **${row.adapter}:${row.model}** — ${windows}; ${tokenText}; ${prices.join("; ")}; basis: ${bases.join("; ")}`;
+};
+const journalUsage = (events, known) => {
+    const groups = new Map();
+    for (const e of events) {
+        if (e.event !== "task-dispatch")
+            continue;
+        const channel = typeof e.data.assignment?.channel === "string"
+            ? e.data.assignment.channel
+            : EM;
+        const label = channelLabel(e.data);
+        if (channel === EM || label === EM)
+            continue;
+        const key = `${channel}:${label}`;
+        if (known.has(key))
+            continue;
+        const group = groups.get(key);
+        if (group)
+            group.attempts++;
+        else
+            groups.set(key, { channel, label, attempts: 1 });
+    }
+    return [...groups.values()].map((group) => `- **${group.label}** — attempts/windows: ${n(group.attempts)}; tokens: not measurable; price: not measurable; basis: no telemetry row`);
+};
+const wallClock = (start, end) => {
+    const from = Date.parse(start?.ts || "");
+    const to = Date.parse(end?.ts || "");
+    if (!Number.isFinite(from) || !Number.isFinite(to) || to < from)
+        return "not measurable";
+    const seconds = Math.round((to - from) / 1_000);
+    const minutes = Math.floor(seconds / 60);
+    return minutes ? `${minutes}m ${seconds % 60}s` : `${seconds}s`;
+};
+const detail = (value) => typeof value === "string" || typeof value === "number" ? String(value) : EM;
+const taskIds = (events) => {
+    const seen = new Set();
+    const out = [];
+    for (const e of events) {
+        if (!e.taskId || seen.has(e.taskId))
+            continue;
+        seen.add(e.taskId);
+        out.push(e.taskId);
+    }
+    return out;
+};
+const outcomeFor = (events, taskId, runEnd) => {
+    for (let i = events.length - 1; i >= 0; i--) {
+        const e = events[i];
+        if (e.taskId !== taskId)
+            continue;
+        if (e.event === "task-done")
+            return "unqualified opinion";
+        if (e.event === "task-failed")
+            return "qualified opinion";
+        if (e.event === "task-human")
+            return "human";
+    }
+    if (runEnd) {
+        const d = runEnd.data;
+        if (Array.isArray(d.done) && d.done.includes(taskId))
+            return "unqualified opinion";
+        if (Array.isArray(d.failed) && d.failed.includes(taskId))
+            return "qualified opinion";
+        if (Array.isArray(d.human) && d.human.includes(taskId))
+            return "human";
+    }
+    return "not recorded";
+};
+// VIS-07 / REC-01: derived only from the run journal, telemetry, and local configuration.
+export function renderMarkdownRecord(runId, events, prices = [], rows = []) {
+    const runStart = events.find((e) => e.event === "run-start");
+    const runEnd = [...events].reverse().find((e) => e.event === "run-end");
+    const baseRef = typeof runStart?.data.baseRef === "string" ? runStart.data.baseRef : EM;
+    const branch = typeof runEnd?.data.branch === "string" ? runEnd.data.branch : EM;
+    const count = (key) => {
+        const v = runEnd?.data[key];
+        return Array.isArray(v) ? String(v.length) : EM;
+    };
+    const gateFailures = new Map();
+    for (const event of events) {
+        if (event.event !== "gate-result" || event.data.pass !== false || typeof event.data.gate !== "string")
+            continue;
+        gateFailures.set(event.data.gate, (gateFailures.get(event.data.gate) || 0) + 1);
+    }
+    const firstAttemptRows = rows.filter((row) => row.firstAttemptOk !== undefined);
+    const firstAttemptRate = firstAttemptRows.length
+        ? `${firstAttemptRows.filter((row) => row.firstAttemptOk).length}/${firstAttemptRows.length} (${Math.round((100 * firstAttemptRows.filter((row) => row.firstAttemptOk).length) / firstAttemptRows.length)}%)`
+        : "not measurable";
+    const usageLines = prices.map(priceLine);
+    usageLines.push(...journalUsage(events, new Set(prices.map((row) => `${row.channel}:${row.adapter}:${row.model}`))));
+    if (!usageLines.length)
+        usageLines.push("- **not recorded:** attempts/windows: not measurable; tokens: not measurable; price: not measurable");
+    const lines = [
+        `# tickmarkr engagement`,
+        "",
+        `- **runId:** ${runId}`,
+        `- **base ref:** ${baseRef}`,
+        `- **branch:** ${branch}`,
+        `- **done:** ${count("done")}`,
+        `- **failed:** ${count("failed")}`,
+        `- **human:** ${count("human")}`,
+        "",
+        "## Usage & efficiency",
+        "",
+        ...usageLines,
+        `- **wall-clock:** ${wallClock(runStart, runEnd)}`,
+        `- **first-attempt rate:** ${firstAttemptRate}`,
+        `- **gate failures:** ${[...gateFailures.entries()].map(([gate, failures]) => `${gate}: ${failures}`).join(", ") || "none recorded"}`,
+        `- **consults:** ${events.filter((e) => e.event === "consult-verdict").length}`,
+        `- **escalations:** ${events.filter((e) => e.event === "escalation").length}`,
+        "",
+    ];
+    lines.push("## Audit trail", "");
+    for (const taskId of taskIds(events)) {
+        const dispatches = events.filter((e) => e.taskId === taskId && e.event === "task-dispatch");
+        const channels = dispatches.map((e) => channelLabel(e.data));
+        const gates = events.filter((e) => e.taskId === taskId && e.event === "gate-result");
+        const consults = events.filter((e) => e.taskId === taskId && e.event === "consult-verdict");
+        const deviations = events.filter((e) => e.taskId === taskId && e.event === "route-deviation");
+        const merge = [...events].reverse().find((e) => e.taskId === taskId && e.event === "merge");
+        const provenance = dispatches
+            .map((e) => typeof e.data.provenance === "string" ? e.data.provenance : "")
+            .filter(Boolean);
+        lines.push(`## ${taskId}`, "");
+        lines.push(`- **opinion:** ${outcomeFor(events, taskId, runEnd)}`);
+        lines.push(`- **attempts:** ${dispatches.length || EM}`);
+        lines.push(`- **channels tried:** ${channels.length ? channels.join(", ") : EM}`);
+        lines.push(`- **routing:** ${provenance.length ? provenance.join(" | ") : EM}`);
+        if (deviations.length) {
+            for (const deviation of deviations) {
+                lines.push(`- **route deviation:** ${detail(deviation.data.chosen)} learned score ${detail(deviation.data.score)} (n=${detail(deviation.data.n)}) vs static ${detail(deviation.data.static)} ${detail(deviation.data.staticScore)}`);
+            }
+        }
+        else
+            lines.push(`- **route deviation:** ${EM}`);
+        lines.push("- **tickmarks:**");
+        if (gates.length) {
+            for (const g of gates) {
+                const pass = g.data.pass === true ? "pass" : g.data.pass === false ? "fail" : EM;
+                const gate = typeof g.data.gate === "string" ? g.data.gate : EM;
+                lines.push(`  - ${gate}: ${pass} — ${firstLine(g.data.details)}`);
+            }
+        }
+        else
+            lines.push(`  - ${EM}`);
+        lines.push("- **National Office:**");
+        if (consults.length) {
+            for (const c of consults) {
+                const action = typeof c.data.action === "string" ? c.data.action : EM;
+                lines.push(`  - ${action} — ${firstLine(c.data.notes)}`);
+            }
+        }
+        else
+            lines.push(`  - ${EM}`);
+        const mergedBranch = typeof merge?.data.branch === "string" ? merge.data.branch : EM;
+        const mergedCommit = typeof merge?.data.commit === "string" ? merge.data.commit : EM;
+        lines.push(`- **consolidation branch:** ${mergedBranch}`);
+        lines.push(`- **consolidation commit:** ${mergedCommit}`);
+        lines.push("");
+    }
+    return lines.join("\n").trimEnd() + "\n";
+}
+function textReport(runId, events, rows, cwd) {
+    // one group per adapter:model, carrying channel + the folded usage across its rows
+    const groups = new Map();
+    for (const r of rows) {
+        const k = `${r.adapter}:${r.model}`;
+        const g = groups.get(k) ?? { channel: r.channel, rows: [] };
+        g.rows.push(r);
+        groups.set(k, g);
+    }
+    // TOKENS axis (channel-agnostic): tokens present ⇒ measured, absent ⇒ unmetered (never 0).
+    const tokenLines = [...groups.entries()].map(([k, g]) => {
+        const usage = g.rows.filter((r) => r.tokens).reduce((a, r) => addUsage(a, r.tokens), undefined);
+        if (!usage)
+            return `  ${k.padEnd(24)} unmetered (adapter reports no usage)`;
+        // exact iff EVERY row is metered to completion; a degraded (tokens but meteredAttempts undefined) row ⇒ floor
+        const exact = g.rows.every((r) => r.tokens && r.meteredAttempts === r.attempts);
+        if (exact) {
+            const tasks = g.rows.length;
+            return `  ${k.padEnd(24)} ${fields(usage)}   (${n(total(usage))} tokens, ${tasks} task${tasks === 1 ? "" : "s"})`;
+        }
+        const metered = g.rows.reduce((s, r) => (r.meteredAttempts === undefined ? s : s + r.meteredAttempts), 0);
+        const attempts = g.rows.reduce((s, r) => s + r.attempts, 0);
+        return `  ${k.padEnd(24)} ≥ ${fields(usage)}   (floor: ${metered}/${attempts} attempts metered)`;
+    });
+    // MONEY axis (orthogonal — branches on channel, NOT tokens): sub ⇒ subscription (no price ever),
+    // api ⇒ operator price × tokens; no prices configured ⇒ `price unset`, never a dollar figure.
+    const subs = [...groups].filter(([, g]) => g.channel === "sub").map(([k]) => k);
+    const apis = [...groups].filter(([, g]) => g.channel === "api").map(([k]) => k);
+    const apiLine = apis.length ? apis.map((k) => `${k} — price unset`).join(" · ") : "none configured";
+    // VIS-05 learning axis: render the PREVIEW-mode profile (preview bypasses routing.learned:off) so the
+    // operator audits per-cell confidence before ever flipping learning on. profile.ts owns every number
+    // (cellSummary); this section only formats. probes = this run's exploratory route-deviation events.
+    const cfg = loadConfig(cwd);
+    const off = cfg.routing.learned === "off";
+    const p = loadRoutingProfile(cwd, cfg, { preview: true });
+    const probes = events.filter((e) => e.event === "route-deviation" && e.data.explore === true).length;
+    const learningLines = !p || p.cells.size === 0
+        ? ["  no telemetry yet"]
+        : [...cellsOf(p)].map(({ shape, chKey, channel, cell }) => {
+            const s = cellSummary(cell);
+            return `  ${shape.padEnd(10)} ${chKey.padEnd(28)} ${channel.padEnd(4)} raw=${s.nRaw} n_eff=${s.nEff} disp=${s.dispatches} q=${s.quality === undefined ? "-" : s.quality.toFixed(2)} quota=${s.quotaHits} explore-left=${s.exploreRemaining}${s.cold ? "  cold (neutral)" : ""}`;
+        });
+    const gateResults = events.filter((e) => e.event === "gate-result");
+    const gatePass = gateResults.filter((e) => e.data.pass).length;
+    const escalations = events.filter((e) => e.event === "escalation").length;
+    const consults = events.filter((e) => e.event === "consult-verdict").length;
+    const failovers = events.filter((e) => e.event === "quota-failover").length;
+    return [
+        `tickmarkr engagement — ${runId}`,
+        "",
+        "engagement summary — audit trail:",
+        ...[...groups.entries()].map(([k, g]) => `  ${k.padEnd(30)} tasks ${g.rows.length}, attempts ${g.rows.reduce((s, r) => s + r.attempts, 0)}, done ${g.rows.filter((r) => r.outcome === "done").length}`),
+        "",
+        `tickmark rate: ${gateResults.length ? Math.round((100 * gatePass) / gateResults.length) : 0}% (${gatePass}/${gateResults.length})`,
+        `escalations: ${escalations} · National Office consults: ${consults} · quota failovers: ${failovers}`,
+        "",
+        "spend — tokens (measured where observed):",
+        ...tokenLines,
+        "spend — money:",
+        `  subscription channels (no marginal spend): ${subs.length ? subs.join(", ") : "none"}`,
+        `  api channels: ${apiLine}`,
+        "",
+        `learning (routing.learned: ${cfg.routing.learned}${off ? " — preview" : ""}):`,
+        ...learningLines,
+        `  probes this run (route-deviation explore): ${probes}`,
+    ].join("\n");
+}
+export async function report(argv, cwd = process.cwd()) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        options: { md: { type: "boolean" } },
+        allowPositionals: true,
+    });
+    const runId = positionals[0] ?? Journal.latestRunId(cwd);
+    if (!runId)
+        throw new Error("no runs found — usage: drovr report <run-id> [--md]");
+    const j = Journal.open(cwd, runId);
+    const events = j.read();
+    if (values.md) {
+        const rows = j.readTelemetry();
+        return renderMarkdownRecord(runId, events, estimateCosts(rows, loadConfig(cwd).cost), rows);
+    }
+    return textReport(runId, events, j.readTelemetry(), cwd);
+}

package/dist/cli/commands/resume.d.ts

@@ -0,0 +1 @@
+export declare function resume(argv: string[], cwd?: string): Promise<string>;

package/dist/cli/commands/resume.js

@@ -0,0 +1,11 @@
+import { loadConfig } from "../../config/config.js";
+import { pickDriver } from "../../drivers/index.js";
+import { formatSummary, runDaemon } from "../../run/daemon.js";
+import { formatJournalNarration } from "../../run/journal.js";
+export async function resume(argv, cwd = process.cwd()) {
+    const runId = argv[0];
+    if (!runId)
+        throw new Error("usage: drovr resume <run-id>");
+    const s = await runDaemon(cwd, { runId, resume: true, driver: pickDriver(loadConfig(cwd)), narrate: (event) => console.log(formatJournalNarration(event)) });
+    return `resumed ${s.runId} — ${formatSummary(s)}`;
+}

package/dist/cli/commands/run.d.ts

@@ -0,0 +1 @@
+export declare function run(argv: string[], cwd?: string): Promise<string>;

package/dist/cli/commands/run.js

@@ -0,0 +1,35 @@
+import { parseArgs } from "node:util";
+import { allAdapters, discoverChannels, probeAll, readDoctor } from "../../adapters/registry.js";
+import { loadConfig } from "../../config/config.js";
+import { pickDriver } from "../../drivers/index.js";
+import { loadGraph } from "../../graph/graph.js";
+import { formatSummary, runDaemon } from "../../run/daemon.js";
+import { route } from "../../route/router.js";
+import { formatJournalNarration, loadRoutingProfile } from "../../run/journal.js";
+export async function run(argv, cwd = process.cwd()) {
+    const { values } = parseArgs({
+        args: argv,
+        options: {
+            concurrency: { type: "string" },
+            driver: { type: "string" },
+            "route-strict": { type: "boolean" },
+        },
+    });
+    const cfg = loadConfig(cwd);
+    if (values["route-strict"]) {
+        const adapters = allAdapters();
+        const health = readDoctor(cwd) ?? (await probeAll(adapters));
+        const channels = discoverChannels(cfg, adapters, health);
+        // no preview: the strict pre-flight routes through exactly what the daemon will use (honors the switch)
+        const profile = loadRoutingProfile(cwd, cfg);
+        const lints = loadGraph(cwd).tasks.flatMap((t) => route(t, cfg, channels, profile).lints);
+        if (lints.length)
+            throw new Error(`--route-strict: routing lints present, refusing to dispatch:\n${lints.join("\n")}`);
+    }
+    const s = await runDaemon(cwd, {
+        concurrency: values.concurrency ? Number(values.concurrency) : undefined,
+        driver: pickDriver(cfg, values.driver),
+        narrate: (event) => console.log(formatJournalNarration(event)),
+    });
+    return `run ${s.runId} finished — ${formatSummary(s)} (merge to main is a human decision)`;
+}

package/dist/cli/commands/scope.d.ts

@@ -0,0 +1,3 @@
+import type { WorkerAdapter } from "../../adapters/types.js";
+import type { ExecutorDriver } from "../../drivers/types.js";
+export declare function scope(argv: string[], cwd?: string, adapters?: WorkerAdapter[], driver?: ExecutorDriver): Promise<string>;

package/dist/cli/commands/scope.js

@@ -0,0 +1,22 @@
+import { isAbsolute, join, relative } from "node:path";
+import { parseArgs } from "node:util";
+import { allAdapters } from "../../adapters/registry.js";
+import { loadConfig } from "../../config/config.js";
+import { scopeIntent } from "../../plan/scope.js";
+export async function scope(argv, cwd = process.cwd(), adapters = allAdapters(), driver) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        options: { force: { type: "boolean" } },
+        allowPositionals: true,
+    });
+    if (positionals.length !== 1)
+        throw new Error("usage: drovr scope <intent-file> [--force]");
+    const source = positionals[0];
+    const intentFile = isAbsolute(source) ? source : join(cwd, source);
+    const result = await scopeIntent(intentFile, cwd, {
+        cfg: loadConfig(cwd), adapters, driver, force: values.force,
+    });
+    const tasks = `${result.tasks} task${result.tasks === 1 ? "" : "s"}`;
+    const calls = `${result.attempts} LLM call${result.attempts === 1 ? "" : "s"}`;
+    return `scoped ${source} → ${relative(cwd, result.specFile)} (${tasks}, ${calls})`;
+}

package/dist/cli/commands/status.d.ts

@@ -0,0 +1,9 @@
+import { type Task } from "../../graph/schema.js";
+import { type JournalEvent } from "../../run/journal.js";
+export type StatusOpts = {
+    iterations?: number;
+    sleep?: (ms: number) => Promise<void>;
+};
+/** Derive the live phase column for one task. Counts only that task's events since its last dispatch/escalation. */
+export declare const derivePhase: (task: Task, events: JournalEvent[], channel?: string) => string;
+export declare function status(argv: string[], cwd?: string, opts?: StatusOpts): Promise<string>;