tickmarkr 1.68.0 → 1.70.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/report.js

@@ -1,8 +1,11 @@
+import { writeFileSync } from "node:fs";
 import { parseArgs } from "node:util";
 import { ttyVisual } from "../../adapters/model-lints.js";
 import { addUsage } from "../../adapters/types.js";
 import { dim, rule, title } from "../../brand.js";
 import { loadConfig } from "../../config/config.js";
+import { buildProofBundle } from "../../report/bundle.js";
+import { compareRuns } from "../../report/compare.js";
 import { estimateCosts } from "../../report/cost.js";
 import { cellsOf, cellSummary } from "../../route/profile.js";
 import { Journal, loadRoutingProfile } from "../../run/journal.js";
@@ -316,17 +319,49 @@ const stylizeReport = (out) => {
 export async function report(argv, cwd = process.cwd()) {
     const { values, positionals } = parseArgs({
         args: argv,
-        options: { md: { type: "boolean" } },
+        options: {
+            md: { type: "boolean" },
+            // v1.70 T3: baseline run id for cost/gate/duration delta + environment comparability guard
+            compare: { type: "string" },
+            // v1.70 T4: write a portable, schema-versioned proof packet (local file only — no network)
+            bundle: { type: "string" },
+        },
         allowPositionals: true,
     });
     const runId = positionals[0] ?? Journal.latestRunId(cwd, { withJournal: true });
     if (!runId)
-        throw new Error("no runs found — usage: tickmarkr report <run-id> [--md]");
+        throw new Error("no runs found — usage: tickmarkr report <run-id> [--md] [--compare <baseline-run-id>] [--bundle <path>]");
     const j = Journal.open(cwd, runId);
     const events = j.read();
+    const rows = j.readTelemetry();
+    const cfg = loadConfig(cwd);
+    let bundleNote = "";
+    if (values.bundle) {
+        // Local-only write of the pure proof packet — no network path exists in buildProofBundle.
+        const packet = buildProofBundle(runId, events);
+        writeFileSync(values.bundle, JSON.stringify(packet, null, 2) + "\n");
+        bundleNote = `wrote proof bundle → ${values.bundle}\n`;
+    }
+    let comparison = "";
+    if (values.compare) {
+        const baselineRunId = values.compare;
+        const baseline = Journal.open(cwd, baselineRunId);
+        const outcome = compareRuns({
+            runId,
+            baselineRunId,
+            events,
+            baselineEvents: baseline.read(),
+            rows,
+            baselineRows: baseline.readTelemetry(),
+            cost: cfg.cost,
+        });
+        // Fail closed: missing run-start yields a clear reason, never a partial table.
+        if (!outcome.ok)
+            throw new Error(outcome.reason);
+        comparison = "\n" + outcome.text;
+    }
     if (values.md) {
-        const rows = j.readTelemetry();
-        return renderMarkdownRecord(runId, events, estimateCosts(rows, loadConfig(cwd).cost), rows);
+        return bundleNote + renderMarkdownRecord(runId, events, estimateCosts(rows, cfg.cost), rows) + comparison;
     }
-    return stylizeReport(textReport(runId, events, j.readTelemetry(), cwd));
+    return bundleNote + stylizeReport(textReport(runId, events, rows, cwd)) + comparison;
 }

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[]>;