kestrel.markets/dist/certify-tsqxtg86.js

A typed, token-efficient language + runtime for agentic trading: agents author bounded plans, the runtime fires them at the tick. CLI + typed library + MCP server.

import {
  toProtocolBlotter
} from "./bin-cv13fq8c.js";
import {
  parseProofRef
} from "./bin-e4mpazjy.js";
import {
  HostedFunnel,
  resolveCopyToken,
  resolveSimBase
} from "./bin-69rn2kv7.js";
import"./bin-awvz75fn.js";
import"./bin-m9a64j9t.js";
import"./bin-qewrvqtv.js";
import"./bin-x2cbtyjz.js";
import {
  parseArgs
} from "./bin-1gc4zavq.js";
import {
  CliError,
  EXIT
} from "./bin-t9ggwnv5.js";
import {
  project,
  serialize
} from "./bin-t58k60v9.js";
import"./bin-29be75ss.js";
import"./bin-mn7wcxhv.js";
import {
  sha256
} from "./bin-8pchjxn2.js";
import"./bin-73jr945c.js";
import {
  grade,
  readBusText
} from "./bin-3ft0k1jq.js";
import {
  ROOT_HASH_PREFIX,
  certifiedRoot
} from "./bin-2ywrx58g.js";
import"./bin-wckvcay0.js";

// src/cli/commands/certify.ts
var VERDICT_EXIT = {
  REPRODUCED: 0,
  MISMATCH: EXIT.GENERIC,
  NON_DETERMINISTIC: EXIT.GENERIC,
  NOT_FOUND: EXIT.NOT_FOUND
};
function contentHash(text) {
  return `sha256:${sha256(text)}`;
}
function reproject(bundle) {
  const events = [...readBusText(bundle.bus)];
  const localBlotter = project(events);
  const local = serialize(localBlotter);
  const localAgain = serialize(project(events));
  const determinismSelf = local === localAgain ? "pass" : "fail";
  const reproduced = local === bundle.blotter;
  const verdict = determinismSelf === "fail" ? "NON_DETERMINISTIC" : reproduced ? "REPRODUCED" : "MISMATCH";
  return {
    verdict,
    determinismSelf,
    reproduced,
    busHash: contentHash(bundle.bus),
    publishedBlotterHash: contentHash(bundle.blotter),
    localBlotterHash: contentHash(local),
    localBlotter
  };
}
function sameMetrics(a, b) {
  const ak = Object.keys(a);
  const bk = Object.keys(b);
  if (ak.length !== bk.length)
    return false;
  for (const k of ak)
    if (!Object.is(a[k], b[k]))
      return false;
  return true;
}
function numbersBindTapeOf(result, bundle) {
  if (bundle.publishedGrade === undefined)
    return "unknown";
  const local = grade([toProtocolBlotter(bundle.publishedGrade.subjectSessionId, result.localBlotter)]);
  return sameMetrics(local.metrics, bundle.publishedGrade.metrics) ? "yes" : "no";
}
async function rootBindOf(bundle) {
  if (bundle.coveredFields === undefined || bundle.root === undefined)
    return "unknown";
  try {
    const bare = bundle.root.startsWith(ROOT_HASH_PREFIX) ? bundle.root.slice(ROOT_HASH_PREFIX.length) : bundle.root;
    const recomputed = await certifiedRoot(bundle.coveredFields);
    return recomputed === bare ? "yes" : "no";
  } catch {
    return "unknown";
  }
}
function emit(ctx, report) {
  if (ctx.mode === "json") {
    process.stdout.write(JSON.stringify({ schema: "kestrel.certify/v1", ...report }) + `
`);
    return;
  }
  const parts = [report.verdict, `proof=${report.proof_id}`, `leg=${report.leg}(L1)`];
  if (report.reproduced !== undefined)
    parts.push(`reproduced=${report.reproduced}`);
  if (report.published_blotter_sha256 !== undefined)
    parts.push(`published_blotter=${report.published_blotter_sha256}`);
  if (report.local_blotter_sha256 !== undefined)
    parts.push(`local_blotter=${report.local_blotter_sha256}`);
  if (report.verdict === "MISMATCH" && report.numbers_bind_tape === "no")
    parts.push("note=published-numbers-differ-from-grade-of-the-reprojected-tape");
  else if (report.verdict === "MISMATCH" && report.root_bind === "no")
    parts.push("note=published-numbers-do-not-rebuild-the-signed-root");
  else if (report.verdict === "MISMATCH")
    parts.push("note=local-reprojection-differs-from-the-published-blotter");
  if (report.verdict === "NON_DETERMINISTIC")
    parts.push("note=the-local-projector-is-not-a-pure-function-of-the-bus");
  if (report.numbers_bind_tape !== undefined)
    parts.push(`numbers-bind-tape=${report.numbers_bind_tape}`);
  if (report.root_bind !== undefined)
    parts.push(`root-bind=${report.root_bind}`);
  process.stdout.write(parts.join("\t") + `
`);
}
async function runCertify(client, id, ctx, forward) {
  const bundle = await client.evidenceBundle(id, forward);
  if (bundle === null) {
    emit(ctx, { verdict: "NOT_FOUND", proof_id: id, leg: "determinism" });
    return VERDICT_EXIT.NOT_FOUND;
  }
  let result;
  try {
    result = reproject(bundle);
  } catch (e) {
    throw new CliError({
      code: "GENERIC",
      exit: EXIT.GENERIC,
      message: `certify could not re-project the evidence bus for proof ${id}: ${e.message}`,
      hint: "the published evidence bundle's bus is not a graded bus the OSS projector can re-project (ADR-0011)"
    });
  }
  const numbersBindTape = result.verdict === "REPRODUCED" ? numbersBindTapeOf(result, bundle) : "unknown";
  const rootBind = result.verdict === "REPRODUCED" ? await rootBindOf(bundle) : "unknown";
  const bindingFailed = numbersBindTape === "no" || rootBind === "no";
  const verdict = result.verdict === "REPRODUCED" && bindingFailed ? "MISMATCH" : result.verdict;
  emit(ctx, {
    verdict,
    proof_id: id,
    leg: "determinism",
    determinism_self: result.determinismSelf,
    reproduced: result.reproduced,
    bus_sha256: result.busHash,
    published_blotter_sha256: result.publishedBlotterHash,
    local_blotter_sha256: result.localBlotterHash,
    ...bundle.engine_version !== undefined ? { engine_version: bundle.engine_version } : {},
    ...bundle.fill_model !== undefined ? { fill_model: bundle.fill_model } : {},
    numbers_bind_tape: numbersBindTape,
    root_bind: rootBind
  });
  return VERDICT_EXIT[verdict];
}
async function certifyCommand(argv, ctx, globals, deps = {}) {
  const { positionals, flags } = parseArgs(argv, new Set, new Set(["copy-token"]));
  if (positionals.length === 0)
    throw new CliError({
      code: "USAGE",
      exit: EXIT.USAGE,
      message: "certify needs a proof URL or id",
      hint: "usage: kestrel certify <https://kestrel.markets/proof/<id> | <id>>"
    });
  const env = deps.env ?? process.env;
  const id = parseProofRef(positionals[0]);
  const copyToken = resolveCopyToken(flags, env);
  const forward = copyToken !== undefined ? { copyToken } : {};
  const base = resolveSimBase(globals, env);
  const client = new HostedFunnel({ baseUrl: base, ...deps.fetch !== undefined ? { fetch: deps.fetch } : {} });
  return runCertify(client, id, ctx, forward);
}
export {
  runCertify,
  rootBindOf,
  reproject,
  numbersBindTapeOf,
  certifyCommand
};