chainlesschain 0.161.12 → 0.162.1

package/src/commands/pair.js

@@ -0,0 +1,291 @@
+/**
+ * `cc pair` — LAN pairing utilities. v0.1 ships only the `preflight`
+ * subcommand for Linux LAN-pairing diagnostics (#21 A.1 PR1).
+ *
+ * Future:
+ *   cc pair init             — headless mode pairing initiator (PR2)
+ *   cc pair accept --qr ...  — accept a scanned QR from CLI (PR2)
+ */
+
+import chalk from "chalk";
+import { Command } from "commander";
+import {
+  runPreflight,
+  firewallCommandTemplate,
+  detectFirewallTool,
+  STATUS,
+} from "../lib/lan-pairing-preflight.js";
+import {
+  addToken,
+  listTokens,
+  findToken,
+  revokeToken,
+  STATUS as TOKEN_STATUS,
+} from "../lib/lan-pairing-tokens.js";
+
+function statusBadge(s) {
+  switch (s) {
+    case STATUS.OK:
+      return chalk.green("✔ ok");
+    case STATUS.WARNING:
+      return chalk.yellow("⚠ warn");
+    case STATUS.BLOCKER:
+      return chalk.red("✖ blocker");
+    case STATUS.SKIP:
+      return chalk.gray("· skip");
+    default:
+      return s;
+  }
+}
+
+function printHumanReadable(report, showFirewall) {
+  console.log(chalk.bold("\n  cc pair preflight\n"));
+  for (const c of report.checks) {
+    console.log(
+      `  ${statusBadge(c.status).padEnd(20)} ${chalk.bold(c.name.padEnd(22))} ${c.detail}`,
+    );
+  }
+  console.log();
+  console.log(
+    chalk.bold(
+      `  summary: ${chalk.green(report.summary.ok + " ok")}, ` +
+        `${chalk.yellow(report.summary.warnings + " warning")}, ` +
+        `${chalk.red(report.summary.blockers + " blocker")}`,
+    ),
+  );
+
+  // Show firewall commands when there's a blocker on multicast_bind, or
+  // when --show-firewall is set.
+  const multicastBlocked = report.checks.some(
+    (c) => c.name === "multicast_bind" && c.status === STATUS.BLOCKER,
+  );
+  if (showFirewall || multicastBlocked) {
+    const tool = detectFirewallTool();
+    const tpl = firewallCommandTemplate(tool);
+    if (tpl) {
+      console.log();
+      console.log(chalk.bold("  Firewall fix (detected tool: " + tool + "):"));
+      console.log();
+      console.log(
+        tpl
+          .split("\n")
+          .map((l) => "    " + l)
+          .join("\n"),
+      );
+    }
+  }
+  console.log();
+}
+
+function tokenStatusBadge(s) {
+  switch (s) {
+    case TOKEN_STATUS.PENDING:
+      return chalk.cyan("pending");
+    case TOKEN_STATUS.CONSUMED:
+      return chalk.green("consumed");
+    case TOKEN_STATUS.REVOKED:
+      return chalk.gray("revoked");
+    case TOKEN_STATUS.EXPIRED:
+      return chalk.yellow("expired");
+    default:
+      return s;
+  }
+}
+
+function relTime(ms) {
+  const diff = ms - Date.now();
+  const absMin = Math.abs(diff) / 60_000;
+  if (absMin < 60) {
+    return diff > 0
+      ? `${Math.round(absMin)} min from now`
+      : `${Math.round(absMin)} min ago`;
+  }
+  const absH = absMin / 60;
+  if (absH < 24) {
+    return diff > 0
+      ? `${Math.round(absH)}h from now`
+      : `${Math.round(absH)}h ago`;
+  }
+  return diff > 0
+    ? `${Math.round(absH / 24)}d from now`
+    : `${Math.round(absH / 24)}d ago`;
+}
+
+export function registerPairCommand(program) {
+  const pair = program
+    .command("pair")
+    .description(
+      "LAN pairing utilities (preflight diagnostics + pairing token issuance)",
+    );
+
+  pair
+    .command("preflight")
+    .description(
+      "Diagnose Linux LAN pairing — checks multicast bind, port 5353 holders, firewall hints (#21 A.1)",
+    )
+    .option("--json", "Machine-readable JSON output")
+    .option(
+      "--show-firewall",
+      "Always print firewall fix commands (default: only on blocker)",
+    )
+    .option(
+      "--multicast-bind-timeout-ms <ms>",
+      "Timeout for multicast bind probe",
+      (v) => parseInt(v, 10),
+    )
+    .action(async (options) => {
+      const report = await runPreflight({
+        multicastBindTimeoutMs: options.multicastBindTimeoutMs,
+      });
+
+      if (options.json) {
+        console.log(JSON.stringify(report, null, 2));
+        process.exitCode = report.exitCode;
+        return;
+      }
+
+      printHumanReadable(report, options.showFirewall);
+      process.exitCode = report.exitCode;
+    });
+
+  // ─── pair token (PR2) ─────────────────────────────────────────
+
+  const token = pair
+    .command("token")
+    .description(
+      "Manage pairing tokens (issue/list/show/revoke). Tokens are compatible with desktop device-pairing-handler QR shape.",
+    );
+
+  token
+    .command("generate")
+    .description("Issue a new 6-digit pairing token for a given DID")
+    .requiredOption("--did <did>", "PC DID (the token will pair this DID)")
+    .option("--name <name>", "Friendly device name (default: hostname)")
+    .option(
+      "--device-id <id>",
+      "Override deviceId (default: cli-<hostname>-<ts>)",
+    )
+    .option("--json", "Machine-readable JSON output (full qrData + metadata)")
+    .action((options) => {
+      const deviceInfo = (() => {
+        const out = {};
+        if (options.name) out.name = options.name;
+        if (options.deviceId) out.deviceId = options.deviceId;
+        return Object.keys(out).length ? out : undefined;
+      })();
+      const t = addToken({ did: options.did, deviceInfo });
+      if (options.json) {
+        console.log(JSON.stringify(t, null, 2));
+        return;
+      }
+      console.log();
+      console.log(chalk.bold("  ✓ Pairing token issued\n"));
+      console.log("  code:       " + chalk.bold.cyan(t.code));
+      console.log("  did:        " + t.qrData.did);
+      console.log("  device:     " + (t.qrData.deviceInfo?.name || "(none)"));
+      console.log("  expires:    " + relTime(t.expiresAtMs));
+      console.log();
+      console.log(
+        chalk.gray("  QR data (paste into mobile scanner / Electron handler):"),
+      );
+      console.log();
+      console.log("    " + JSON.stringify(t.qrData));
+      console.log();
+    });
+
+  token
+    .command("list")
+    .description("List pairing tokens")
+    .option(
+      "--status <s>",
+      "Filter by status (pending/consumed/revoked/expired)",
+    )
+    .option("--did <did>", "Filter by DID")
+    .option("--json", "Machine-readable JSON output")
+    .action((options) => {
+      const tokens = listTokens({ status: options.status, did: options.did });
+      if (options.json) {
+        console.log(JSON.stringify({ tokens }, null, 2));
+        return;
+      }
+      if (tokens.length === 0) {
+        console.log(chalk.gray("\n  No pairing tokens.\n"));
+        return;
+      }
+      console.log();
+      console.log(chalk.bold("  Pairing tokens:\n"));
+      console.log(
+        "  " +
+          chalk.gray("code").padEnd(10) +
+          chalk.gray("status").padEnd(14) +
+          chalk.gray("did").padEnd(30) +
+          chalk.gray("expires"),
+      );
+      for (const t of tokens) {
+        console.log(
+          "  " +
+            chalk.bold(t.code).padEnd(20) +
+            tokenStatusBadge(t.status).padEnd(20) +
+            String(t.qrData?.did || "?")
+              .slice(0, 28)
+              .padEnd(30) +
+            relTime(t.expiresAtMs),
+        );
+      }
+      console.log();
+    });
+
+  token
+    .command("show <code>")
+    .description("Show a single pairing token by code")
+    .option("--json", "Machine-readable JSON output")
+    .action((code, options) => {
+      const t = findToken(code);
+      if (!t) {
+        console.error(chalk.red(`✖ token not found: ${code}`));
+        process.exitCode = 2;
+        return;
+      }
+      if (options.json) {
+        console.log(JSON.stringify(t, null, 2));
+        return;
+      }
+      console.log();
+      console.log(chalk.bold(`  Token ${chalk.cyan(t.code)}\n`));
+      console.log("  status:     " + tokenStatusBadge(t.status));
+      console.log("  did:        " + t.qrData.did);
+      console.log(
+        "  device:     " +
+          (t.qrData.deviceInfo?.name || "(none)") +
+          " (" +
+          (t.qrData.deviceInfo?.platform || "?") +
+          ")",
+      );
+      console.log("  created:    " + new Date(t.createdAtMs).toISOString());
+      console.log("  expires:    " + new Date(t.expiresAtMs).toISOString());
+      if (t.consumedAtMs)
+        console.log("  consumed:   " + new Date(t.consumedAtMs).toISOString());
+      if (t.revokedAtMs)
+        console.log("  revoked:    " + new Date(t.revokedAtMs).toISOString());
+      console.log();
+    });
+
+  token
+    .command("revoke <code>")
+    .description("Revoke a pending pairing token")
+    .option("--json", "Machine-readable JSON output")
+    .action((code, options) => {
+      const r = revokeToken(code);
+      if (options.json) {
+        console.log(JSON.stringify(r, null, 2));
+        if (!r.revoked) process.exitCode = 2;
+        return;
+      }
+      if (r.revoked) {
+        console.log(chalk.green(`\n  ✓ Token ${code} revoked.\n`));
+      } else {
+        console.error(chalk.red(`\n  ✖ Cannot revoke: ${r.reason}\n`));
+        process.exitCode = 2;
+      }
+    });
+}

package/src/index.js

@@ -8,6 +8,7 @@ import { registerServicesCommand } from "./commands/services.js";
 import { registerConfigCommand } from "./commands/config.js";
 import { registerUpdateCommand } from "./commands/update.js";
 import { registerDoctorCommand } from "./commands/doctor.js";
+import { registerPairCommand } from "./commands/pair.js";
 import { registerDbCommand } from "./commands/db.js";
 import { registerNoteCommand } from "./commands/note.js";
 import { registerChatCommand } from "./commands/chat.js";
@@ -393,6 +394,7 @@ export function createProgram(opts = {}) {
   registerConfigCommand(program);
   registerUpdateCommand(program);
   registerDoctorCommand(program);
+  registerPairCommand(program);
 
   // Headless commands
   registerDbCommand(program);

package/src/lib/cross-chain-mtc.js

@@ -421,6 +421,12 @@ function stagedFileName(op) {
  * Stage one bridge op for inclusion in the next batch close.
  * Idempotent: same op written twice -> single staging file.
  *
+ * #21 B.5 Layer 2 PR4 — when `op.multisig_provenance` is present, validate
+ * its structure via `verifyMultisigProvenance` before writing. Invalid
+ * provenance is rejected (`INVALID_MULTISIG_PROVENANCE`) instead of being
+ * silently persisted so downstream `closeBatch` / wrapper attachment
+ * cannot pick up malformed data.
+ *
  * @param {string} dir
  * @param {object} op
  * @param {{ requireEnabled?: boolean }} [opts]
@@ -434,6 +440,18 @@ export function stageBridgeOp(dir, op, opts = {}) {
     return { staged: false, path: null, reason: "DISABLED" };
   }
   validateBridgeOp(op);
+  if (op.multisig_provenance) {
+    const pv = verifyMultisigProvenance({
+      multisig_provenance: op.multisig_provenance,
+    });
+    if (!pv.ok) {
+      return {
+        staged: false,
+        path: null,
+        reason: `INVALID_MULTISIG_PROVENANCE:${pv.code}${pv.detail ? `:${pv.detail}` : ""}`,
+      };
+    }
+  }
   const file = path.join(stagingDir(dir), stagedFileName(op));
   if (fs.existsSync(file)) {
     return { staged: false, path: file, reason: "ALREADY_STAGED" };
@@ -564,10 +582,203 @@ export function closeBatch(dir, opts = {}) {
 
 // ─────────────────────────────────────────────────────────────────────
 // v0.2 — Multi-hop envelope (envelope-of-envelope)
+// v0.3 — #21 B.5 Layer 2 PR2: m-of-n multisig provenance on the wrapper
 // ─────────────────────────────────────────────────────────────────────
 
 const SCHEMA_MULTI_HOP_BRIDGE = "mtc-bridge-multihop/v1";
 
+const MULTISIG_PROVENANCE_REQUIRED_FIELDS = Object.freeze([
+  "proposal_id",
+  "threshold_m",
+  "member_count_n",
+  "signers",
+  "partial_sigs",
+]);
+
+const MULTISIG_SUPPORTED_ALGS = Object.freeze(["Ed25519", "SLH-DSA-128F"]);
+
+/**
+ * Attach m-of-n multisig provenance to a bridge envelope (single-hop or
+ * multi-hop wrapper). Returns a new envelope object — does not mutate.
+ *
+ * Provenance carries the proposal id, the m/n policy at consume time, the
+ * sorted-ASC signer DID list, and per-signer {did, alg, sig:hex} entries.
+ * Mirrors the cc_bridges columns introduced in #21 B.5 Layer 2 PR1.
+ *
+ * Layer 3 onchain broadcasters read this field to construct the m-of-n
+ * proof bundle expected by destination-chain verifier contracts.
+ *
+ * @param {object} envelope    - mtc-envelope/v1 or mtc-bridge-multihop/v1
+ * @param {{
+ *   proposalId: string,
+ *   thresholdM: number,
+ *   memberCountN: number,
+ *   signers: string[],
+ *   partialSigs: Array<{did: string, alg: string, sig: string}>,
+ * }} provenance
+ * @returns {object} new envelope with `multisig_provenance` field
+ */
+export function attachMultisigProvenance(envelope, provenance) {
+  if (!envelope || typeof envelope !== "object") {
+    throw new TypeError("attachMultisigProvenance: envelope required");
+  }
+  if (!provenance || typeof provenance !== "object") {
+    throw new TypeError("attachMultisigProvenance: provenance required");
+  }
+  return {
+    ...envelope,
+    multisig_provenance: {
+      proposal_id: provenance.proposalId,
+      threshold_m: provenance.thresholdM,
+      member_count_n: provenance.memberCountN,
+      signers: Array.isArray(provenance.signers) ? [...provenance.signers] : [],
+      partial_sigs: Array.isArray(provenance.partialSigs)
+        ? provenance.partialSigs.map((s) => ({
+            did: s.did,
+            alg: s.alg,
+            sig: s.sig,
+          }))
+        : [],
+    },
+  };
+}
+
+/**
+ * Strip-all-sigs canonical form for a bridge envelope carrying
+ * `multisig_provenance`. Returns a clone with every `partial_sigs[*].sig`
+ * replaced by `""` so producer and verifier can feed an identical byte
+ * sequence into JCS for m-of-n threshold tolerance.
+ *
+ * Mirrors `@chainlesschain/core-mtc/lib/publisher-signing.js
+ * _stripSigsForPublisher` (memory `mtc_publisher_sig_threshold.md`) — both
+ * the publisher_signature on a landmark and a wrapper-level m-of-n proof
+ * need the same canonical-skeleton-without-sigs invariant.
+ *
+ * Reused by PR3 verifier when checking each partial sig against the
+ * canonical wrapper bytes.
+ *
+ * @param {object} envelope - envelope with `multisig_provenance`
+ * @returns {object} clone with sigs zeroed; same envelope returned when no
+ *                   provenance is attached
+ */
+export function stripMultisigSigsForCanonical(envelope) {
+  if (!envelope || !envelope.multisig_provenance) return envelope;
+  return {
+    ...envelope,
+    multisig_provenance: {
+      ...envelope.multisig_provenance,
+      partial_sigs: (envelope.multisig_provenance.partial_sigs || []).map(
+        (s) => ({ ...s, sig: "" }),
+      ),
+    },
+  };
+}
+
+/**
+ * Structural validation of multisig_provenance on a bridge envelope.
+ * Does NOT verify cryptographic signatures (deferred to PR3 — would need
+ * the proposal's payload JCS + member pubkey lookup). Confirms:
+ *   - provenance is present and well-formed
+ *   - partial_sigs.length >= threshold_m
+ *   - every signer DID is in the policy.members allow-list (when supplied)
+ *   - every partial_sig has a supported alg + non-empty hex sig
+ *   - signer list is sorted ASC (canonical form invariant)
+ *
+ * @param {object} envelope - envelope with `multisig_provenance` to check
+ * @param {{ m: number, members?: Array<{did:string}> }} [policy] - optional
+ *   policy spec; when present, signer-membership and threshold are checked
+ *   against it instead of provenance's own `threshold_m` field
+ * @returns {{ ok: boolean, code?: string, detail?: string }}
+ */
+export function verifyMultisigProvenance(envelope, policy) {
+  if (!envelope || typeof envelope !== "object") {
+    return { ok: false, code: "BAD_ENVELOPE" };
+  }
+  const prov = envelope.multisig_provenance;
+  if (!prov || typeof prov !== "object") {
+    return { ok: false, code: "MISSING_PROVENANCE" };
+  }
+  for (const f of MULTISIG_PROVENANCE_REQUIRED_FIELDS) {
+    if (prov[f] === undefined || prov[f] === null) {
+      return { ok: false, code: "INCOMPLETE_PROVENANCE", detail: f };
+    }
+  }
+  if (typeof prov.proposal_id !== "string" || !prov.proposal_id) {
+    return { ok: false, code: "BAD_PROPOSAL_ID" };
+  }
+  if (
+    !Number.isInteger(prov.threshold_m) ||
+    prov.threshold_m < 1 ||
+    !Number.isInteger(prov.member_count_n) ||
+    prov.member_count_n < prov.threshold_m
+  ) {
+    return { ok: false, code: "BAD_THRESHOLD" };
+  }
+  if (!Array.isArray(prov.signers) || !Array.isArray(prov.partial_sigs)) {
+    return { ok: false, code: "BAD_PROVENANCE_SHAPE" };
+  }
+  if (prov.signers.length !== prov.partial_sigs.length) {
+    return { ok: false, code: "SIGNERS_SIGS_LENGTH_MISMATCH" };
+  }
+  const requiredM =
+    policy && Number.isInteger(policy.m) ? policy.m : prov.threshold_m;
+  if (prov.partial_sigs.length < requiredM) {
+    return {
+      ok: false,
+      code: "BELOW_THRESHOLD",
+      detail: `${prov.partial_sigs.length} < ${requiredM}`,
+    };
+  }
+  const sorted = [...prov.signers].sort();
+  for (let i = 0; i < prov.signers.length; i++) {
+    if (prov.signers[i] !== sorted[i]) {
+      return { ok: false, code: "SIGNERS_NOT_SORTED" };
+    }
+  }
+  const allowed =
+    policy && Array.isArray(policy.members)
+      ? new Set(policy.members.map((m) => m.did))
+      : null;
+  for (let i = 0; i < prov.partial_sigs.length; i++) {
+    const s = prov.partial_sigs[i];
+    if (!s || typeof s !== "object") {
+      return { ok: false, code: "BAD_PARTIAL_SIG", detail: `index ${i}` };
+    }
+    if (typeof s.did !== "string" || !s.did) {
+      return { ok: false, code: "BAD_PARTIAL_SIG_DID", detail: `index ${i}` };
+    }
+    if (s.did !== prov.signers[i]) {
+      return {
+        ok: false,
+        code: "SIGNER_DID_MISMATCH",
+        detail: `signers[${i}]=${prov.signers[i]} vs partial_sigs[${i}].did=${s.did}`,
+      };
+    }
+    if (!MULTISIG_SUPPORTED_ALGS.includes(s.alg)) {
+      return {
+        ok: false,
+        code: "UNSUPPORTED_ALG",
+        detail: `index ${i} alg=${s.alg}`,
+      };
+    }
+    if (typeof s.sig !== "string" || !/^[0-9a-fA-F]+$/.test(s.sig) || !s.sig) {
+      return {
+        ok: false,
+        code: "BAD_PARTIAL_SIG_HEX",
+        detail: `index ${i}`,
+      };
+    }
+    if (allowed && !allowed.has(s.did)) {
+      return {
+        ok: false,
+        code: "SIGNER_NOT_IN_POLICY",
+        detail: s.did,
+      };
+    }
+  }
+  return { ok: true };
+}
+
 /**
  * Build a multi-hop bridge envelope by chaining single-hop envelopes.
  * For a route A → B → C, the caller supplies the leg envelopes
@@ -579,9 +790,23 @@ const SCHEMA_MULTI_HOP_BRIDGE = "mtc-bridge-multihop/v1";
  *
  * @param {Array<object>} legEnvelopes - ≥ 2 single-hop bridge envelopes
  * @param {{ route_id?: string, total_amount?: string, asset?: string }} [meta]
+ * @param {{
+ *   proposalId: string,
+ *   thresholdM: number,
+ *   memberCountN: number,
+ *   signers: string[],
+ *   partialSigs: Array<{did:string,alg:string,sig:string}>,
+ * }} [multisigProvenance] - #21 B.5 Layer 2 PR2: optional m-of-n provenance
+ *   carried over from a multisig-gated bridge consume. Attached via
+ *   `attachMultisigProvenance` so canonical form (strip-all-sigs JCS) and
+ *   verifier path (`verifyMultisigProvenance`) work uniformly.
  * @returns {object} multi-hop wrapper envelope
  */
-export function buildMultiHopBridgeEnvelope(legEnvelopes, meta = {}) {
+export function buildMultiHopBridgeEnvelope(
+  legEnvelopes,
+  meta = {},
+  multisigProvenance = null,
+) {
   if (!Array.isArray(legEnvelopes) || legEnvelopes.length < 2) {
     throw new RangeError(
       "buildMultiHopBridgeEnvelope: need at least 2 leg envelopes",
@@ -616,7 +841,7 @@ export function buildMultiHopBridgeEnvelope(legEnvelopes, meta = {}) {
     legEnvelopes[0].leaf.src_chain,
     ...legEnvelopes.map((e) => e.leaf.dst_chain),
   ];
-  return {
+  const wrapper = {
     schema: SCHEMA_MULTI_HOP_BRIDGE,
     route_id:
       meta.route_id ||
@@ -629,6 +854,10 @@ export function buildMultiHopBridgeEnvelope(legEnvelopes, meta = {}) {
     asset: meta.asset || null,
     issued_at: new Date().toISOString(),
   };
+  if (multisigProvenance) {
+    return attachMultisigProvenance(wrapper, multisigProvenance);
+  }
+  return wrapper;
 }
 
 /**
@@ -636,11 +865,30 @@ export function buildMultiHopBridgeEnvelope(legEnvelopes, meta = {}) {
  * own landmark + the chain path must be continuous + at least one leg
  * must be the "lock" op (the trigger).
  *
+ * #21 B.5 Layer 2 PR3 — when `wrapper.multisig_provenance` is present OR
+ * `options.requireMultisig === true`, also runs `verifyMultisigProvenance`
+ * (structural). Result includes nested `multisig_result`. Cryptographic
+ * verification of each partial sig against canonical wrapper bytes is
+ * deferred (would require per-signer pubkey lookup; see Layer 3).
+ *
  * @param {object} wrapper - multi-hop envelope from buildMultiHopBridgeEnvelope
  * @param {Array<{landmark: object}>} legCacheEntries - one per leg, in order
- * @returns {{ ok: boolean, code?: string, leg_results?: Array<{ok, code?}> }}
+ * @param {{
+ *   expectedMultisigPolicy?: { m: number, members?: Array<{did:string}> },
+ *   requireMultisig?: boolean,
+ * }} [options]
+ * @returns {{
+ *   ok: boolean,
+ *   code?: string,
+ *   leg_results?: Array<{ok, code?}>,
+ *   multisig_result?: { ok: boolean, code?: string, detail?: string },
+ * }}
  */
-export function verifyMultiHopBridgeEnvelope(wrapper, legCacheEntries) {
+export function verifyMultiHopBridgeEnvelope(
+  wrapper,
+  legCacheEntries,
+  options = {},
+) {
   if (!wrapper || wrapper.schema !== SCHEMA_MULTI_HOP_BRIDGE) {
     return { ok: false, code: "BAD_MULTIHOP_SCHEMA" };
   }
@@ -679,8 +927,29 @@ export function verifyMultiHopBridgeEnvelope(wrapper, legCacheEntries) {
       }
     }
   }
-  const allOk = results.every((r) => r.ok);
-  return { ok: allOk, leg_results: results };
+  const legsOk = results.every((r) => r.ok);
+  const hasProvenance = !!wrapper.multisig_provenance;
+  const requireMultisig = !!options.requireMultisig;
+  if (hasProvenance || requireMultisig) {
+    const multisigResult = verifyMultisigProvenance(
+      wrapper,
+      options.expectedMultisigPolicy,
+    );
+    if (!multisigResult.ok) {
+      return {
+        ok: false,
+        code: "MULTISIG_PROVENANCE_INVALID",
+        leg_results: results,
+        multisig_result: multisigResult,
+      };
+    }
+    return {
+      ok: legsOk,
+      leg_results: results,
+      multisig_result: multisigResult,
+    };
+  }
+  return { ok: legsOk, leg_results: results };
 }
 
 // ─────────────────────────────────────────────────────────────────────