tickmarkr 1.67.0 → 1.69.0

package/dist/adapters/kimi.d.ts

@@ -1,6 +1,30 @@
-import { type WorkerAdapter, type WorkerResult } from "./types.js";
+import type { ExecutorDriver, Slot } from "../drivers/types.js";
+import { type Assignment, type WorkerAdapter, type WorkerResult } from "./types.js";
 export declare function kimiAuthed(credentialsText: string, nowMs: number): boolean;
 export declare function parseKimiModels(raw: string): string[];
 export declare function parseKimiResult(raw: string, nonce: string): WorkerResult;
 export declare function kimiSessionId(output: string): string | undefined;
+export declare function kimiBannerModel(banner: string): string | undefined;
+export declare function kimiBannerSessionId(banner: string): string | undefined;
+export type KimiBannerConfirm = {
+    ok: true;
+    sessionId?: string;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function confirmKimiSeedBanner(banner: string, assignedModel: string): KimiBannerConfirm;
+export interface KimiInteractiveSeedResult {
+    output: string;
+    seedFailed: boolean;
+    seedError?: string;
+    sessionId?: string;
+}
+export declare function runKimiInteractiveSeed(opts: {
+    driver: Pick<ExecutorDriver, "run" | "waitOutput" | "read">;
+    slot: Slot;
+    assignment: Assignment;
+    promptFile: string;
+    taskTimeoutMinutes: number;
+}): Promise<KimiInteractiveSeedResult>;
 export declare const kimi: WorkerAdapter;

package/dist/adapters/kimi.js

@@ -68,16 +68,90 @@ export function parseKimiResult(raw, nonce) {
 // line only: prompt/model prose can contain lookalike text, and the anchored charset keeps a
 // captured id shell-safe by construction (shq in resumeCommand is the second layer). Last valid
 // line wins — a run may echo stale resume lines mid-transcript.
+//
+// v1.69 T7: the native TUI cold-start banner also prints `Session: session_<uuid>` at launch.
+// Prefer a banner Session line when present so seed-mode captures the id from the launch banner
+// itself rather than waiting for a completion-time resume trailer (which the TUI may never emit).
 const RESUME_TRAILER_RE = /^\s*To resume this session: kimi -r (session_[0-9a-f-]+)\s*$/;
+const BANNER_SESSION_LINE_RE = /^\s*Session:\s*(session_[0-9a-f-]+)\s*$/;
 export function kimiSessionId(output) {
     let id;
     for (const line of output.split("\n")) {
+        const banner = BANNER_SESSION_LINE_RE.exec(line);
+        if (banner) {
+            id = banner[1];
+            continue;
+        }
         const m = RESUME_TRAILER_RE.exec(line);
         if (m)
             id = m[1];
     }
     return id;
 }
+// v1.69 T6: the native TUI takes -m <alias>, where config.toml aliases are the bare model suffix of
+// the tickmarkr channel id (live probe 2026-07-22). Keep the mapping explicit and localized.
+function kimiAlias(model) {
+    return model.replace(/^kimi-code\//, "");
+}
+// v1.69 T7: the cold-start banner prints the model alias and session id. Parse them from the
+// banner text already captured for the readiness match — no new probe, no extra dispatch.
+const BANNER_MODEL_RE = /^Model:\s*(.+)$/m;
+const BANNER_SESSION_RE = /^Session:\s*(session_[0-9a-f-]+)$/m;
+export function kimiBannerModel(banner) {
+    const m = BANNER_MODEL_RE.exec(banner);
+    if (!m)
+        return undefined;
+    const alias = m[1].trim();
+    if (!alias)
+        return undefined;
+    return `kimi-code/${alias}`;
+}
+export function kimiBannerSessionId(banner) {
+    return BANNER_SESSION_RE.exec(banner)?.[1];
+}
+// Fail closed on a named-model mismatch; a missing Model line is not a mismatch (banner partial).
+export function confirmKimiSeedBanner(banner, assignedModel) {
+    const saw = kimiBannerModel(banner);
+    if (saw !== undefined && saw !== assignedModel) {
+        return { ok: false, error: `model mismatch: expected ${assignedModel}, saw ${saw}` };
+    }
+    return { ok: true, sessionId: kimiBannerSessionId(banner) };
+}
+// Shared launch-then-seed surface (T6) + banner confirm helpers (T7). One definition so the
+// adapter property and runKimiInteractiveSeed cannot drift.
+const KIMI_SEED = {
+    launch: (model) => `kimi -y -m ${shq(kimiAlias(model))}`,
+    readinessMatch: "Send /help for help information.",
+    seedLine: (promptFile) => `Read ${promptFile} and do exactly what it says.`,
+};
+// v1.69 T7: kimi-local launch-then-seed that confirms the banner model and captures the session id
+// from the SAME pane text already present for the readiness match. No extra probe, no extra
+// dispatch — one read of the launch banner, then seed or fail closed.
+export async function runKimiInteractiveSeed(opts) {
+    await opts.driver.run(opts.slot, KIMI_SEED.launch(opts.assignment.model));
+    const ready = await opts.driver.waitOutput(opts.slot, KIMI_SEED.readinessMatch, opts.taskTimeoutMinutes * 60_000);
+    // Banner text already on the pane for the readiness match — the only text model/session use.
+    const banner = await opts.driver.read(opts.slot, 1000);
+    if (!ready) {
+        return { output: banner, seedFailed: true, seedError: `readiness pattern not seen: ${KIMI_SEED.readinessMatch}` };
+    }
+    const confirm = confirmKimiSeedBanner(banner, opts.assignment.model);
+    if (!confirm.ok) {
+        return { output: banner, seedFailed: true, seedError: confirm.error };
+    }
+    const seedText = KIMI_SEED.seedLine(opts.promptFile);
+    await opts.driver.run(opts.slot, seedText);
+    let output = "";
+    for (let attempt = 0; attempt < 5; attempt++) {
+        await new Promise((r) => setTimeout(r, 200));
+        output = await opts.driver.read(opts.slot, 1000);
+        const bottom = output.trimEnd().split("\n").pop() ?? "";
+        if (!bottom.includes(seedText)) {
+            return { output, seedFailed: false, sessionId: confirm.sessionId };
+        }
+    }
+    return { output, seedFailed: true, seedError: "seed line never left the input box", sessionId: confirm.sessionId };
+}
 export const kimi = {
     id: "kimi",
     vendor: "moonshot",
@@ -108,6 +182,12 @@ export const kimi = {
     // ("unknown command '…'", live-verified 2026-07-17, OBS-67) and -p is non-interactive-only.
     // null → the daemon's print fallback (types.ts:101) keeps kimi workers visible without a TUI.
     interactiveCommand: () => null,
+    // v1.69 T6/T7: launch the real TUI, wait for the cold-start readiness marker, then submit the
+    // prompt as one user turn. Banner model/session confirmation for seed mode lives in
+    // runKimiInteractiveSeed / confirmKimiSeedBanner (same pane text as the readiness match — no
+    // extra probe). Live-probed 2026-07-22 (kimi 0.28.1): `kimi -y` opens the TUI with yolo active
+    // and prints the model/session lines plus "Send /help for help information." before the input box.
+    interactiveSeed: KIMI_SEED,
     // v1.53 T3 resume — live-probed 2026-07-18: `-p` + `-S <id>` compose cleanly (no OBS-67-class
     // flag rejection) and the resumed session carries prior conversation state. `-S <id>` is the
     // deterministic form; `-c` rejected as primary — cwd-keyed, nondeterministic under worktree

package/dist/adapters/types.d.ts

@@ -48,6 +48,11 @@ export interface WorkerResult {
     deviations: string[];
     raw: string;
 }
+export interface InteractiveSeed {
+    launch(model: string): string;
+    readinessMatch: string;
+    seedLine(promptFile: string): string;
+}
 export interface ContextUsage {
     tokens: number;
     limit?: number;
@@ -78,6 +83,7 @@ export interface WorkerAdapter {
     channels(cfg: TickmarkrConfig): BillingChannel[];
     headlessCommand(promptFile: string, model: string): string;
     interactiveCommand(promptFile: string, model: string): string | null;
+    interactiveSeed?: InteractiveSeed;
     resumeCommand?(sessionId: string, promptFile: string, model: string): string;
     sessionIdFrom?(output: string): string | undefined;
     resumeUnknownContext?: boolean;

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

@@ -0,0 +1,4 @@
+export declare function evalCommand(argv: string[], cwd?: string): Promise<string | {
+    out: string;
+    code: number;
+}>;

package/dist/cli/commands/eval.js

@@ -0,0 +1,26 @@
+import { parseArgs } from "node:util";
+import { discoverFixtures, resolveFixturesRoot, seedFixture } from "../../eval/fixtures.js";
+export async function evalCommand(argv, cwd = process.cwd()) {
+    const { positionals } = parseArgs({ args: argv, allowPositionals: true });
+    const root = resolveFixturesRoot(positionals[0], cwd);
+    const { valid, invalid } = discoverFixtures(root);
+    const lines = [`tickmarkr eval — discovered ${valid.length} fixture${valid.length === 1 ? "" : "s"}`];
+    for (const f of valid)
+        lines.push(`  ${f.id}`);
+    if (invalid.length) {
+        lines.push("", "invalid fixtures:");
+        for (const i of invalid)
+            lines.push(`  ${i.id} — ${i.reason}`);
+    }
+    for (const f of valid) {
+        const seeded = await seedFixture(f);
+        try {
+            lines.push(`  seeded ${f.id}`);
+        }
+        finally {
+            await seeded.cleanup();
+        }
+    }
+    const out = lines.join("\n");
+    return invalid.length ? { out, code: 1 } : out;
+}

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

@@ -1,5 +1,25 @@
+import { type Task, type TaskStatus } from "../../graph/schema.js";
+import { type JournalEvent } from "../../run/journal.js";
 export type StatusOpts = {
     iterations?: number;
     sleep?: (ms: number) => Promise<void>;
 };
+export declare const GATE_KEYS: {
+    readonly build: "B";
+    readonly test: "T";
+    readonly lint: "L";
+    readonly evidence: "E";
+    readonly scope: "S";
+    readonly acceptance: "A";
+    readonly review: "R";
+};
+export declare const taskBox: (status: TaskStatus) => string;
+export declare const gateBox: (state: "open" | "pass" | "fail" | "skip", unicode: boolean) => string;
+export type GateState = "open" | "pass" | "fail" | "skip";
+export declare const defaultGateStates: (task: Task) => GateState[];
+export declare const gateStates: (task: Task, events: JournalEvent[]) => GateState[];
+export declare const gateChain: (states: GateState[], unicode: boolean) => string;
+export declare const failedGates: (states: GateState[]) => string[];
+export declare const humanGateSuffix: (t: Task, st: TaskStatus, states: GateState[]) => string;
+export declare const shortGoal: (goal: string, max: number) => string;
 export declare function status(argv: string[], cwd?: string, opts?: StatusOpts): Promise<string>;

package/dist/cli/commands/status.js

@@ -9,7 +9,7 @@ const NOT_COMPARABLE_NOTICE = "graph recompiled since this run — task states n
 // The timer must keep the process ALIVE: an unref'd timer here let the event loop drain after the
 // first frame, so a live `--watch` printed once and exited 0 (OBS-11). Never unref this.
 const defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
-const GATE_KEYS = { build: "B", test: "T", lint: "L", evidence: "E", scope: "S", acceptance: "A", review: "R" };
+export const GATE_KEYS = { build: "B", test: "T", lint: "L", evidence: "E", scope: "S", acceptance: "A", review: "R" };
 const attemptStartIdx = (events, taskId) => {
     let idx = -1;
     for (let i = 0; i < events.length; i++) {
@@ -21,22 +21,22 @@ const attemptStartIdx = (events, taskId) => {
 };
 const visual = () => process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
 // non-TTY machine surface only — the TTY frame draws task verdicts via statusRow
-const taskBox = (status) => {
+export const taskBox = (status) => {
     if (status === "done")
         return "[x]";
     if (status === "failed" || status === "human")
         return "[!]";
     return "[ ]";
 };
-const gateBox = (state, unicode) => {
+export const gateBox = (state, unicode) => {
     if (unicode) {
         // shared glyph vocabulary: pass/fail verdicts, dash for skip, dim circle for not-yet-run
         return state === "pass" ? GLYPHS.pass : state === "fail" ? GLYPHS.fail : state === "skip" ? GLYPHS.neutral : GLYPHS.toggleInactive;
     }
     return state === "pass" ? "[x]" : state === "fail" ? "[!]" : state === "skip" ? "." : "[ ]";
 };
-const defaultGateStates = (task) => GATE_NAMES.map((gate) => task.gates.includes(gate) ? "open" : "skip");
-const gateStates = (task, events) => {
+export const defaultGateStates = (task) => GATE_NAMES.map((gate) => task.gates.includes(gate) ? "open" : "skip");
+export const gateStates = (task, events) => {
     const outcomes = new Map();
     const start = attemptStartIdx(events, task.id);
     if (start >= 0) {
@@ -57,10 +57,10 @@ const gateStates = (task, events) => {
 const GATE_STATE_TOKEN = { pass: ok, fail, skip: dim, open: dim };
 // TTY cells are bare glyphs in fixed GATE_NAMES order — gate identity lives once in the frame
 // legend, and in words on a failing row; non-TTY keeps the letter+box chips (byte-pinned surface)
-const gateChain = (states, unicode) => GATE_NAMES.map((gate, i) => unicode
+export const gateChain = (states, unicode) => GATE_NAMES.map((gate, i) => unicode
     ? GATE_STATE_TOKEN[states[i]](gateBox(states[i], true))
     : `${GATE_KEYS[gate]}${gateBox(states[i], false)}`).join(" ");
-const failedGates = (states) => GATE_NAMES.filter((_, i) => states[i] === "fail");
+export const failedGates = (states) => GATE_NAMES.filter((_, i) => states[i] === "fail");
 // plain-text form of the failed-gate words for column math; rendered with a dim dot + red names
 const failedSuffix = (states) => {
     const f = failedGates(states);
@@ -70,8 +70,8 @@ const failedSuffix = (states) => {
 // awaited approval is named from task state alone — never from gate results. Failed gates win the
 // cell when present: a post-approval park is not awaiting the designed gate. Plain text for column
 // math; rendered with a dim dot + warn words. TTY-only — the non-TTY surface stays byte-pinned.
-const humanGateSuffix = (t, st, states) => st === "human" && t.humanGate && failedGates(states).length === 0 ? " · awaiting approval" : "";
-const shortGoal = (goal, max) => {
+export const humanGateSuffix = (t, st, states) => st === "human" && t.humanGate && failedGates(states).length === 0 ? " · awaiting approval" : "";
+export const shortGoal = (goal, max) => {
     const clause = goal.split(/[,;.?!]/, 1)[0].trim();
     if (clause.length <= max)
         return clause;

package/dist/cli/index.d.ts

@@ -5,7 +5,7 @@ export type CommandResult = string | {
 };
 export type CommandMap = Record<string, (argv: string[]) => Promise<CommandResult>>;
 export declare const COMMANDS: CommandMap;
-export declare const USAGE = "tickmarkr \u2014 spec-driven orchestration harness for AI coding agents\nusage: tickmarkr <command>\n  init          guided setup + doctor; init --agent [--force] [--docs] adds agent skills/docs\n  doctor        re-probe adapters, herdr, auth; print capability matrix\n  fleet         interactive fleet editor (fleet --print for CI drift checks)\n  compile <src> spec \u2192 .tickmarkr/graph.json (fails without acceptance criteria)\n  scope <intent> draft a compiled native spec beside an answered intent (--force to overwrite)\n  plan          dry-run routing table + cost estimate + floor lints\n  run           execute the graph (--concurrency N --driver herdr|subprocess --route-strict)\n  status        live run state\n  resume <id>   continue a run from its journal\n  report <id>   cost/quality report (--md for committable execution record)\n  profile       show learned routing profile (profile reset = forget history via cursor, keeps telemetry)\n  ui            open the Fleet Studio TUI (full-screen tabbed cockpit)\n  unlock        remove a stale/garbage run lock (refuses if the holder is alive)\n  approve <id> <task>  approve a parked human gate (--by <name> --reason <text>); takes effect on resume";
+export declare const USAGE = "tickmarkr \u2014 spec-driven orchestration harness for AI coding agents\nusage: tickmarkr <command>\n  init          guided setup + doctor; init --agent [--force] [--docs] adds agent skills/docs\n  doctor        re-probe adapters, herdr, auth; print capability matrix\n  fleet         interactive fleet editor (fleet --print for CI drift checks)\n  compile <src> spec \u2192 .tickmarkr/graph.json (fails without acceptance criteria)\n  scope <intent> draft a compiled native spec beside an answered intent (--force to overwrite)\n  plan          dry-run routing table + cost estimate + floor lints\n  eval          run checked-in fixtures against every channel in isolated temp repos\n  run           execute the graph (--concurrency N --driver herdr|subprocess --route-strict)\n  status        live run state\n  resume <id>   continue a run from its journal\n  report <id>   cost/quality report (--md for committable execution record)\n  profile       show learned routing profile (profile reset = forget history via cursor, keeps telemetry)\n  ui            open the Fleet Studio TUI (full-screen tabbed cockpit)\n  unlock        remove a stale/garbage run lock (refuses if the holder is alive)\n  approve <id> <task>  approve a parked human gate (--by <name> --reason <text>); takes effect on resume";
 export declare function dispatch(cmd: string | undefined, argv: string[], commands?: CommandMap): Promise<{
     out: string;
     code: number;

package/dist/cli/index.js

@@ -4,6 +4,7 @@ import { pathToFileURL } from "node:url";
 import { approve } from "./commands/approve.js";
 import { compile } from "./commands/compile.js";
 import { doctor } from "./commands/doctor.js";
+import { evalCommand } from "./commands/eval.js";
 import { fleet } from "./commands/fleet.js";
 import { init } from "./commands/init.js";
 import { plan } from "./commands/plan.js";
@@ -18,7 +19,7 @@ import { unlock } from "./commands/unlock.js";
 import { version } from "./commands/version.js";
 const normalize = (r) => typeof r === "string" ? { out: r, code: 0 } : r;
 export const COMMANDS = {
-    init, doctor, fleet, compile, scope, plan, run, status, resume, report, profile, ui, unlock, approve, version,
+    init, doctor, fleet, compile, scope, plan, run, status, resume, report, profile, ui, unlock, approve, version, eval: evalCommand,
 };
 const VERSION_FLAGS = new Set(["version", "--version", "-v"]);
 const HELP_CMDS = new Set(["help", "-h", "--help"]);
@@ -31,6 +32,7 @@ usage: tickmarkr <command>
   compile <src> spec → .tickmarkr/graph.json (fails without acceptance criteria)
   scope <intent> draft a compiled native spec beside an answered intent (--force to overwrite)
   plan          dry-run routing table + cost estimate + floor lints
+  eval          run checked-in fixtures against every channel in isolated temp repos
   run           execute the graph (--concurrency N --driver herdr|subprocess --route-strict)
   status        live run state
   resume <id>   continue a run from its journal

package/dist/eval/canary.d.ts

@@ -0,0 +1,46 @@
+import type { WorkerAdapter } from "../adapters/types.js";
+import { type Fixture } from "./fixtures.js";
+export declare const CANARY_FIXTURE_ID = "canary";
+export interface CanaryJudgeResult {
+    fixtureId: string;
+    expectedPass: boolean;
+    judgePass: boolean;
+    breach: boolean;
+    details: string;
+}
+export interface FixtureChannelResult {
+    fixtureId: string;
+    channelKey: string;
+    skipped: boolean;
+    pass?: boolean;
+}
+export interface ChannelQualificationTotal {
+    channelKey: string;
+    passed: number;
+    failed: number;
+    skipped: number;
+    total: number;
+}
+export declare function isCanaryFixture(fixture: Fixture): boolean;
+export declare function isCanaryResult(result: FixtureChannelResult): boolean;
+export declare function resolveCanaryFixture(root: string): Fixture | undefined;
+/**
+ * Return a fixture list that always includes the held-out canary fixture.
+ * If the canary is already present, the list is returned unchanged.
+ */
+export declare function ensureCanary(fixtures: Fixture[], root: string): Fixture[];
+/**
+ * Run the held-out canary fixture against a judge adapter.
+ * The fixture is seeded, a deliberately failing change is committed, and the judge oracle
+ * is evaluated against the resulting diff. A correct judge returns pass=false; any pass=true
+ * verdict is flagged as a judge-integrity breach.
+ */
+export declare function runCanaryJudge(fixture: Fixture, judgeAdapter: WorkerAdapter, model: string): Promise<CanaryJudgeResult>;
+/**
+ * Aggregate per-channel qualification totals from fixture-channel results.
+ * Results marked as canary (by the supplied predicate, defaulting to isCanaryResult) are excluded
+ * from every total so the canary never contributes to a channel's qualification score.
+ */
+export declare function aggregateChannelTotals(results: FixtureChannelResult[], options?: {
+    isCanary?: (r: FixtureChannelResult) => boolean;
+}): ChannelQualificationTotal[];

package/dist/eval/canary.js

@@ -0,0 +1,113 @@
+import { existsSync, lstatSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { compileSource } from "../compile/index.js";
+import { acceptanceGate } from "../gates/acceptance.js";
+import { shGitOk } from "../run/git.js";
+import { seedFixture } from "./fixtures.js";
+export const CANARY_FIXTURE_ID = "canary";
+export function isCanaryFixture(fixture) {
+    return fixture.id === CANARY_FIXTURE_ID;
+}
+export function isCanaryResult(result) {
+    return result.fixtureId === CANARY_FIXTURE_ID;
+}
+export function resolveCanaryFixture(root) {
+    const path = join(root, CANARY_FIXTURE_ID);
+    if (!existsSync(path) || !lstatSync(path).isDirectory())
+        return undefined;
+    const startDir = join(path, "start");
+    const solutionDir = join(path, "solution");
+    if (!existsSync(startDir) || !lstatSync(startDir).isDirectory())
+        return undefined;
+    if (!existsSync(solutionDir) || !lstatSync(solutionDir).isDirectory())
+        return undefined;
+    return { id: CANARY_FIXTURE_ID, path, startDir, solutionDir };
+}
+/**
+ * Return a fixture list that always includes the held-out canary fixture.
+ * If the canary is already present, the list is returned unchanged.
+ */
+export function ensureCanary(fixtures, root) {
+    if (fixtures.some(isCanaryFixture))
+        return fixtures;
+    const canary = resolveCanaryFixture(root);
+    return canary ? [canary, ...fixtures] : fixtures;
+}
+function compileCanaryTask(fixture) {
+    const specPath = join(fixture.path, "spec.md");
+    const graph = compileSource(specPath);
+    if (graph.tasks.length !== 1) {
+        throw new Error(`canary spec must contain exactly one task (found ${graph.tasks.length})`);
+    }
+    return graph.tasks[0];
+}
+// Apply a known-bad change so the judged diff contains quotable evidence of an unmet criterion.
+async function applyKnownBadChange(repo) {
+    writeFileSync(join(repo, "a.txt"), "canary-wrong");
+    await shGitOk("git add -A", repo);
+    await shGitOk("git commit -m 'canary bad change' --no-gpg-sign", repo);
+}
+/**
+ * Run the held-out canary fixture against a judge adapter.
+ * The fixture is seeded, a deliberately failing change is committed, and the judge oracle
+ * is evaluated against the resulting diff. A correct judge returns pass=false; any pass=true
+ * verdict is flagged as a judge-integrity breach.
+ */
+export async function runCanaryJudge(fixture, judgeAdapter, model) {
+    if (!isCanaryFixture(fixture)) {
+        throw new Error(`fixture ${fixture.id} is not the canary fixture`);
+    }
+    const task = compileCanaryTask(fixture);
+    const seeded = await seedFixture(fixture);
+    const initialCommit = (await shGitOk("git rev-parse HEAD", seeded.repo)).trim();
+    try {
+        await applyKnownBadChange(seeded.repo);
+        const gateResult = await acceptanceGate(task, seeded.repo, initialCommit, { adapter: judgeAdapter, model });
+        const expectedPass = false;
+        const judgePass = gateResult.pass;
+        const breach = judgePass === true && expectedPass === false;
+        return {
+            fixtureId: fixture.id,
+            expectedPass,
+            judgePass,
+            breach,
+            details: gateResult.details,
+        };
+    }
+    finally {
+        await seeded.cleanup();
+    }
+}
+/**
+ * Aggregate per-channel qualification totals from fixture-channel results.
+ * Results marked as canary (by the supplied predicate, defaulting to isCanaryResult) are excluded
+ * from every total so the canary never contributes to a channel's qualification score.
+ */
+export function aggregateChannelTotals(results, options = {}) {
+    const isCanary = options.isCanary ?? isCanaryResult;
+    const byChannel = new Map();
+    for (const r of results) {
+        if (isCanary(r))
+            continue;
+        let total = byChannel.get(r.channelKey);
+        if (!total) {
+            total = { channelKey: r.channelKey, passed: 0, failed: 0, skipped: 0, total: 0 };
+            byChannel.set(r.channelKey, total);
+        }
+        total.total++;
+        if (r.skipped) {
+            total.skipped++;
+        }
+        else if (r.pass === true) {
+            total.passed++;
+        }
+        else if (r.pass === false) {
+            total.failed++;
+        }
+        else {
+            // A result with no pass verdict is treated as neither passed nor failed; it still counts
+            // toward the total so the aggregate is not silently distorted.
+        }
+    }
+    return [...byChannel.values()].sort((a, b) => a.channelKey.localeCompare(b.channelKey));
+}

package/dist/eval/dispatch.d.ts

@@ -0,0 +1,31 @@
+import type { AuthHealth, BillingChannel, WorkerAdapter, WorkerResult } from "../adapters/types.js";
+import type { TickmarkrConfig } from "../config/config.js";
+import { type Fixture } from "./fixtures.js";
+export interface AcceptanceRunResult {
+    pass: boolean;
+    details: string;
+}
+export interface ChannelResult {
+    channel: BillingChannel;
+    channelKey: string;
+    skipped: boolean;
+    skipReason?: string;
+    repo?: string;
+    worker?: WorkerResult;
+    acceptance?: AcceptanceRunResult;
+}
+export interface DispatchOptions {
+    fixture: Fixture;
+    channels: BillingChannel[];
+    adapters: WorkerAdapter[];
+    health: Record<string, AuthHealth>;
+    cfg: TickmarkrConfig;
+}
+/**
+ * Render one prompt for a fixture and dispatch that identical, unmodified prompt to every channel
+ * under test. Each channel runs inside its own isolated seeded repository, and the fixture's own
+ * deterministic acceptance oracles are evaluated against each channel's resulting diff independently.
+ * Channels that fail install or model authentication are skipped with a recorded reason rather than
+ * dispatched. The dispatch path reuses the existing adapter `invoke` and `parse` contract.
+ */
+export declare function dispatchFixture(opts: DispatchOptions): Promise<ChannelResult[]>;