@hasna/infinity 0.1.0

package/dist/cli.js

@@ -0,0 +1,2965 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/core/strict-json.ts
+import { createHash } from "crypto";
+
+// src/core/errors.ts
+class InfinityError extends Error {
+  code;
+  status;
+  retryable;
+  details;
+  constructor(code, message, options = {}) {
+    super(message, { cause: options.cause });
+    this.name = "InfinityError";
+    this.code = code;
+    this.status = options.status ?? 400;
+    this.retryable = options.retryable ?? false;
+    this.details = Object.freeze({ ...options.details ?? {} });
+  }
+}
+
+// src/core/validation.ts
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function closedObject(value, label, required, optional = []) {
+  if (!isPlainObject(value))
+    throw invalid(`${label} must be an object`);
+  const allowed = new Set([...required, ...optional]);
+  for (const key of Object.keys(value)) {
+    if (!allowed.has(key))
+      throw invalid(`${label} contains an unknown field`);
+  }
+  for (const key of required) {
+    if (!Object.hasOwn(value, key))
+      throw invalid(`${label}.${key} is required`);
+  }
+  return value;
+}
+function stringValue(value, label, options = {}) {
+  if (typeof value !== "string")
+    throw invalid(`${label} must be a string`);
+  if (value.normalize("NFC") !== value)
+    throw invalid(`${label} must use NFC normalization`);
+  if (value.length < (options.min ?? 1))
+    throw invalid(`${label} is too short`);
+  if (value.length > (options.max ?? 256))
+    throw invalid(`${label} is too long`);
+  if (options.pattern && !options.pattern.test(value))
+    throw invalid(`${label} has an invalid format`);
+  return value;
+}
+var IDENTIFIER_PATTERN = /^[A-Za-z0-9][A-Za-z0-9:_-]*$/;
+var DIGEST_PATTERN = /^sha256:[a-f0-9]{64}$/;
+var CREDENTIAL_CARRIER_PATTERN_SOURCE = "^(?:[sS][kK]-[A-Za-z0-9]|[gG][hH][pPoOuUsSrR]_|[gG][iI][tT][hH][uU][bB]_[pP][aA][tT]_|[xX][oO][xX][bBaApPrRsS]-|[aA][kKsS][iI][aA][0-9A-Za-z]|[aA][iI][zZ][aA]|[nN][pP][mM]_|[xX][aA][iI]-|[cC][tT][xX]7[sS][kK]-)";
+var CREDENTIAL_CARRIER_PATTERN = new RegExp(CREDENTIAL_CARRIER_PATTERN_SOURCE);
+function identifier(value, label) {
+  const parsed = stringValue(value, label, { max: 96, pattern: IDENTIFIER_PATTERN });
+  if (CREDENTIAL_CARRIER_PATTERN.test(parsed)) {
+    throw invalid(`${label} resembles credential material and is not a valid public identifier`);
+  }
+  if (parsed.length > 48 && /^[A-Za-z0-9]+$/.test(parsed)) {
+    throw invalid(`${label} is an unstructured high-entropy secret-carrier candidate`);
+  }
+  return parsed;
+}
+function digest(value, label) {
+  return stringValue(value, label, { min: 71, max: 71, pattern: DIGEST_PATTERN });
+}
+function positiveInteger(value, label, maximum = Number.MAX_SAFE_INTEGER) {
+  if (!Number.isSafeInteger(value) || value <= 0 || value > maximum) {
+    throw invalid(`${label} must be a positive safe integer`);
+  }
+  return value;
+}
+function nonnegativeInteger(value, label, maximum = Number.MAX_SAFE_INTEGER) {
+  if (!Number.isSafeInteger(value) || value < 0 || value > maximum) {
+    throw invalid(`${label} must be a nonnegative safe integer`);
+  }
+  return value;
+}
+function enumValue(value, label, values) {
+  if (typeof value !== "string" || !values.includes(value)) {
+    throw invalid(`${label} must be one of ${values.join(", ")}`);
+  }
+  return value;
+}
+function stringArray(value, label, options = {}) {
+  if (!Array.isArray(value))
+    throw invalid(`${label} must be an array`);
+  if (!options.allowEmpty && value.length === 0)
+    throw invalid(`${label} must not be empty`);
+  if (value.length > (options.maxItems ?? 64))
+    throw invalid(`${label} has too many items`);
+  const parser = options.item ?? ((entry, itemLabel) => identifier(entry, itemLabel));
+  const parsed = value.map((entry, index) => parser(entry, `${label}[${index}]`));
+  if (new Set(parsed).size !== parsed.length)
+    throw invalid(`${label} must not contain duplicates`);
+  return parsed;
+}
+var RFC3339_MILLIS = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+function timestamp(value, label) {
+  const parsed = stringValue(value, label, { min: 24, max: 24, pattern: RFC3339_MILLIS });
+  const millis = Date.parse(parsed);
+  if (!Number.isFinite(millis) || new Date(millis).toISOString() !== parsed) {
+    throw invalid(`${label} must be a canonical UTC timestamp`);
+  }
+  return parsed;
+}
+function invalid(message) {
+  return new InfinityError("invalid_input", message, { status: 2 });
+}
+function deepFreeze(value) {
+  if (value && typeof value === "object" && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const nested of Object.values(value))
+      deepFreeze(nested);
+  }
+  return value;
+}
+
+// src/core/strict-json.ts
+var strictDocuments = new WeakSet;
+var strictDocumentDigests = new WeakMap;
+
+class StrictJsonParser {
+  source;
+  index = 0;
+  constructor(source) {
+    this.source = source;
+  }
+  parse() {
+    this.skipWhitespace();
+    const value = this.parseValue();
+    this.skipWhitespace();
+    if (this.index !== this.source.length)
+      throw invalid(`JSON has trailing data at byte ${this.index}`);
+    if (value !== null && typeof value === "object")
+      strictDocumentDigests.set(value, digestCanonical(value));
+    return value;
+  }
+  parseValue() {
+    this.skipWhitespace();
+    const char = this.source[this.index];
+    if (char === "{")
+      return this.parseObject();
+    if (char === "[")
+      return this.parseArray();
+    if (char === '"')
+      return this.parseString();
+    if (char === "t")
+      return this.parseLiteral("true", true);
+    if (char === "f")
+      return this.parseLiteral("false", false);
+    if (char === "n")
+      return this.parseLiteral("null", null);
+    if (char === "-" || char !== undefined && char >= "0" && char <= "9")
+      return this.parseNumber();
+    throw invalid(`invalid JSON value at byte ${this.index}`);
+  }
+  parseObject() {
+    this.index += 1;
+    const result = Object.create(null);
+    const seen = new Set;
+    this.skipWhitespace();
+    if (this.source[this.index] === "}") {
+      this.index += 1;
+      strictDocuments.add(result);
+      strictDocumentDigests.set(result, digestCanonical(result));
+      return result;
+    }
+    while (true) {
+      this.skipWhitespace();
+      if (this.source[this.index] !== '"')
+        throw invalid(`object key expected at byte ${this.index}`);
+      const key = this.parseString();
+      if (seen.has(key))
+        throw invalid("duplicate JSON key");
+      seen.add(key);
+      this.skipWhitespace();
+      if (this.source[this.index] !== ":")
+        throw invalid(`':' expected after object key at byte ${this.index}`);
+      this.index += 1;
+      result[key] = this.parseValue();
+      this.skipWhitespace();
+      const delimiter = this.source[this.index];
+      if (delimiter === "}") {
+        this.index += 1;
+        strictDocuments.add(result);
+        strictDocumentDigests.set(result, digestCanonical(result));
+        return result;
+      }
+      if (delimiter !== ",")
+        throw invalid(`',' or '}' expected at byte ${this.index}`);
+      this.index += 1;
+    }
+  }
+  parseArray() {
+    this.index += 1;
+    const result = [];
+    this.skipWhitespace();
+    if (this.source[this.index] === "]") {
+      this.index += 1;
+      strictDocuments.add(result);
+      strictDocumentDigests.set(result, digestCanonical(result));
+      return result;
+    }
+    while (true) {
+      result.push(this.parseValue());
+      this.skipWhitespace();
+      const delimiter = this.source[this.index];
+      if (delimiter === "]") {
+        this.index += 1;
+        strictDocuments.add(result);
+        strictDocumentDigests.set(result, digestCanonical(result));
+        return result;
+      }
+      if (delimiter !== ",")
+        throw invalid(`',' or ']' expected at byte ${this.index}`);
+      this.index += 1;
+    }
+  }
+  parseString() {
+    const start = this.index;
+    this.index += 1;
+    let escaped = false;
+    while (this.index < this.source.length) {
+      const char = this.source[this.index];
+      if (escaped) {
+        escaped = false;
+        this.index += 1;
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        this.index += 1;
+        continue;
+      }
+      if (char === '"') {
+        this.index += 1;
+        let value;
+        try {
+          value = JSON.parse(this.source.slice(start, this.index));
+        } catch (error) {
+          throw invalid(`invalid JSON string at byte ${start}`);
+        }
+        if (value.normalize("NFC") !== value)
+          throw invalid(`JSON strings must use NFC normalization at byte ${start}`);
+        if (hasUnpairedSurrogate(value))
+          throw invalid(`JSON strings must not contain unpaired surrogates at byte ${start}`);
+        return value;
+      }
+      if (char !== undefined && char.charCodeAt(0) < 32)
+        throw invalid(`control character in JSON string at byte ${this.index}`);
+      this.index += 1;
+    }
+    throw invalid(`unterminated JSON string at byte ${start}`);
+  }
+  parseNumber() {
+    const rest = this.source.slice(this.index);
+    const match = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/.exec(rest);
+    if (!match)
+      throw invalid(`invalid JSON number at byte ${this.index}`);
+    const token = match[0];
+    this.index += token.length;
+    if (!/[.eE]/.test(token)) {
+      if (token === "-0")
+        throw invalid("negative zero is not canonical JSON");
+      const integer = BigInt(token);
+      if (integer >= BigInt(Number.MIN_SAFE_INTEGER) && integer <= BigInt(Number.MAX_SAFE_INTEGER))
+        return Number(integer);
+      return integer;
+    }
+    const value = Number(token);
+    if (!Number.isFinite(value))
+      throw invalid(`JSON number must be finite at byte ${this.index - token.length}`);
+    if (Object.is(value, -0))
+      throw invalid("negative zero is not canonical JSON");
+    const significand = token.split(/[eE]/, 1)[0] ?? token;
+    if (value === 0 && /[1-9]/.test(significand))
+      throw invalid("JSON number underflow would lose information");
+    if (JSON.stringify(value) !== token)
+      throw invalid("JSON number is non-canonical or loses information");
+    return value;
+  }
+  parseLiteral(token, value) {
+    if (!this.source.startsWith(token, this.index))
+      throw invalid(`invalid JSON literal at byte ${this.index}`);
+    this.index += token.length;
+    return value;
+  }
+  skipWhitespace() {
+    while (this.index < this.source.length && /[\t\n\r ]/.test(this.source[this.index] ?? ""))
+      this.index += 1;
+  }
+}
+function parseStrictJson(source) {
+  return new StrictJsonParser(source).parse();
+}
+function canonicalJson(value) {
+  if (value === null)
+    return "null";
+  if (typeof value === "boolean")
+    return value ? "true" : "false";
+  if (typeof value === "string") {
+    if (value.normalize("NFC") !== value)
+      throw invalid("canonical JSON strings must use NFC normalization");
+    if (hasUnpairedSurrogate(value))
+      throw invalid("canonical JSON strings must not contain unpaired surrogates");
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || Object.is(value, -0))
+      throw invalid("canonical JSON numbers must be finite and not negative zero");
+    if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
+      throw invalid("canonical JSON integer Numbers must be safe integers; use bigint for exact wider values");
+    }
+    return JSON.stringify(value);
+  }
+  if (typeof value === "bigint")
+    return value.toString(10);
+  if (Array.isArray(value)) {
+    for (let index = 0;index < value.length; index += 1) {
+      if (!Object.hasOwn(value, index))
+        throw invalid("canonical JSON arrays must not be sparse");
+    }
+    return `[${value.map((entry) => canonicalJson(entry)).join(",")}]`;
+  }
+  if (!isPlainObject(value))
+    throw invalid("canonical JSON accepts only JSON-compatible values");
+  const entries = Object.keys(value).sort().map((key) => {
+    if (key.normalize("NFC") !== key)
+      throw invalid("canonical JSON keys must use NFC normalization");
+    if (hasUnpairedSurrogate(key))
+      throw invalid("canonical JSON keys must not contain unpaired surrogates");
+    const nested = value[key];
+    if (nested === undefined)
+      throw invalid("canonical JSON object contains an undefined field");
+    return `${JSON.stringify(key)}:${canonicalJson(nested)}`;
+  });
+  return `{${entries.join(",")}}`;
+}
+function hasUnpairedSurrogate(value) {
+  for (let index = 0;index < value.length; index += 1) {
+    const unit = value.charCodeAt(index);
+    if (unit >= 55296 && unit <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (!(next >= 56320 && next <= 57343))
+        return true;
+      index += 1;
+    } else if (unit >= 56320 && unit <= 57343) {
+      return true;
+    }
+  }
+  return false;
+}
+function digestCanonical(value) {
+  return `sha256:${createHash("sha256").update(canonicalJson(value), "utf8").digest("hex")}`;
+}
+
+// src/core/int64.ts
+var INT64_MAX = 9223372036854775807n;
+function positiveInt64(value, label) {
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value) || value <= 0)
+      throw invalid(`${label} must be a positive signed 64-bit integer`);
+    return value;
+  }
+  if (typeof value === "bigint" && value > 0n && value <= INT64_MAX) {
+    return value <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(value) : value;
+  }
+  throw invalid(`${label} must be a positive signed 64-bit integer`);
+}
+function incrementInt64(value, label) {
+  const incremented = BigInt(value) + 1n;
+  if (incremented > INT64_MAX)
+    throw invalid(`${label} reached signed 64-bit exhaustion`);
+  return incremented <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(incremented) : incremented;
+}
+function int64Equal(left, right) {
+  return BigInt(left) === BigInt(right);
+}
+
+// src/contracts/operations.ts
+var MAX_POSTGRES_INTEGER = 2147483647;
+var MAX_REVISION = MAX_POSTGRES_INTEGER;
+var MAX_MUTABLE_IF_REVISION = MAX_REVISION - 1;
+var CANCEL_RECOVERY_LEASE_DURATION_MS = 300000;
+var RUN_STATES = [
+  "admitted",
+  "active",
+  "cancel_requested",
+  "finalizing",
+  "succeeded",
+  "failed",
+  "canceled",
+  "lost_uncheckpointed",
+  "discarded_uncheckpointed"
+];
+var ATTEMPT_PHASES = [
+  "queued",
+  "lane_leased",
+  "sandbox_allocating",
+  "running",
+  "checkpointed",
+  "verifying",
+  "finalizing",
+  "terminal"
+];
+var ATTEMPT_OUTCOMES = [
+  "succeeded",
+  "failed_retryable",
+  "failed_permanent",
+  "canceled",
+  "lost_uncheckpointed",
+  "discarded_uncheckpointed",
+  "policy_denied",
+  "budget_exhausted"
+];
+function isPublicMutationCommand(value) {
+  return value === "run.submit" || value === "run.cancel" || value === "run.retry";
+}
+function parsePublicMutationResultExpectation(value) {
+  try {
+    const expectation = integrityObject(value, "public mutation result expectation");
+    const command = enumValue(expectation.command, "public mutation result expectation.command", ["run.submit", "run.cancel", "run.retry"]);
+    if (command === "run.submit") {
+      integrityClosed(expectation, ["command", "run_spec_digest", "authority_epoch", "route_epoch"], [], "run.submit result expectation");
+      return deepFreeze({
+        command,
+        run_spec_digest: digest(expectation.run_spec_digest, "result expectation.run_spec_digest"),
+        authority_epoch: positiveInt64(expectation.authority_epoch, "result expectation.authority_epoch"),
+        route_epoch: positiveInt64(expectation.route_epoch, "result expectation.route_epoch")
+      });
+    }
+    integrityClosed(expectation, command === "run.cancel" ? [
+      "command",
+      "run_id",
+      "attempt_id",
+      "attempt_number",
+      "expected_run_revision",
+      "expected_attempt_revision",
+      "recovery_lease_duration_ms",
+      "prior_lease"
+    ] : ["command", "run_id", "predecessor_attempt_id", "expected_attempt_number", "expected_run_revision"], [], `${command} result expectation`);
+    const expectedRunRevision = positiveInteger(expectation.expected_run_revision, "result expectation.expected_run_revision", MAX_REVISION);
+    if (command === "run.cancel") {
+      const priorLease = integrityObject(expectation.prior_lease, "run.cancel result expectation.prior_lease");
+      const leaseState = enumValue(priorLease.state, "run.cancel result expectation.prior_lease.state", ["none", "selected"]);
+      integrityClosed(priorLease, leaseState === "none" ? ["state"] : ["state", "attempt_lease_id", "lease_epoch"], [], "run.cancel result expectation.prior_lease");
+      return deepFreeze({
+        command,
+        run_id: identifier(expectation.run_id, "result expectation.run_id"),
+        attempt_id: identifier(expectation.attempt_id, "result expectation.attempt_id"),
+        attempt_number: positiveInteger(expectation.attempt_number, "result expectation.attempt_number", MAX_POSTGRES_INTEGER),
+        expected_run_revision: expectedRunRevision,
+        expected_attempt_revision: positiveInteger(expectation.expected_attempt_revision, "result expectation.expected_attempt_revision", MAX_REVISION),
+        recovery_lease_duration_ms: exactCancelRecoveryLeaseDuration(expectation.recovery_lease_duration_ms, "result expectation.recovery_lease_duration_ms"),
+        prior_lease: leaseState === "none" ? { state: leaseState } : {
+          state: leaseState,
+          attempt_lease_id: identifier(priorLease.attempt_lease_id, "result expectation.prior_lease.attempt_lease_id"),
+          lease_epoch: positiveInt64(priorLease.lease_epoch, "result expectation.prior_lease.lease_epoch")
+        }
+      });
+    }
+    return deepFreeze({
+      command,
+      run_id: identifier(expectation.run_id, "result expectation.run_id"),
+      predecessor_attempt_id: identifier(expectation.predecessor_attempt_id, "result expectation.predecessor_attempt_id"),
+      expected_attempt_number: positiveInteger(expectation.expected_attempt_number, "result expectation.expected_attempt_number", MAX_POSTGRES_INTEGER),
+      expected_run_revision: expectedRunRevision
+    });
+  } catch (error) {
+    throw asIntegrityFailure(error, "public mutation result expectation failed integrity validation");
+  }
+}
+function parsePublicMutationResult(command, value, expectedOperationId, expectation) {
+  try {
+    const result = integrityObject(value, `${command} result`);
+    const operationId = identifier(result.operation_id, `${command} result.operation_id`);
+    if (operationId !== expectedOperationId) {
+      throw integrity("Infinity mutation success inner operation ID differs from its protected operation");
+    }
+    if (command === "run.submit") {
+      integrityClosed(result, [
+        "operation_id",
+        "run_spec_id",
+        "run_spec_digest",
+        "run_id",
+        "attempt_id",
+        "attempt_number",
+        "attempt_phase",
+        "state",
+        "run_revision",
+        "attempt_revision",
+        "authority_epoch",
+        "route_epoch",
+        "idempotency"
+      ], [], "run.submit result");
+      identifier(result.run_spec_id, "run.submit result.run_spec_id");
+      digest(result.run_spec_digest, "run.submit result.run_spec_digest");
+      identifier(result.run_id, "run.submit result.run_id");
+      identifier(result.attempt_id, "run.submit result.attempt_id");
+      positiveInteger(result.attempt_number, "run.submit result.attempt_number", MAX_POSTGRES_INTEGER);
+      enumValue(result.attempt_phase, "run.submit result.attempt_phase", ATTEMPT_PHASES);
+      enumValue(result.state, "run.submit result.state", RUN_STATES);
+      positiveInteger(result.run_revision, "run.submit result.run_revision", MAX_REVISION);
+      positiveInteger(result.attempt_revision, "run.submit result.attempt_revision", MAX_REVISION);
+      positiveInt64(result.authority_epoch, "run.submit result.authority_epoch");
+      positiveInt64(result.route_epoch, "run.submit result.route_epoch");
+    } else {
+      const leaseFields = [
+        "attempt_lease_id",
+        "lease_epoch",
+        "lease_holder_principal",
+        "lease_issued_at",
+        "lease_expires_at",
+        "lease_duration_ms"
+      ];
+      integrityClosed(result, [
+        "operation_id",
+        "run_id",
+        "attempt_id",
+        "attempt_number",
+        "state",
+        "outcome",
+        "run_revision",
+        "attempt_revision",
+        "idempotency"
+      ], leaseFields, `${command} result`);
+      identifier(result.run_id, `${command} result.run_id`);
+      identifier(result.attempt_id, `${command} result.attempt_id`);
+      positiveInteger(result.attempt_number, `${command} result.attempt_number`, MAX_POSTGRES_INTEGER);
+      enumValue(result.state, `${command} result.state`, RUN_STATES);
+      if (result.outcome !== null)
+        enumValue(result.outcome, `${command} result.outcome`, ATTEMPT_OUTCOMES);
+      positiveInteger(result.run_revision, `${command} result.run_revision`, MAX_REVISION);
+      positiveInteger(result.attempt_revision, `${command} result.attempt_revision`, MAX_REVISION);
+      const present = leaseFields.filter((field) => Object.hasOwn(result, field)).length;
+      if (present !== 0 && present !== leaseFields.length) {
+        throw integrity(`Infinity ${command} result has a partial lease tuple`);
+      }
+      if (present !== 0) {
+        identifier(result.attempt_lease_id, `${command} result.attempt_lease_id`);
+        positiveInt64(result.lease_epoch, `${command} result.lease_epoch`);
+        identifier(result.lease_holder_principal, `${command} result.lease_holder_principal`);
+        timestamp(result.lease_issued_at, `${command} result.lease_issued_at`);
+        timestamp(result.lease_expires_at, `${command} result.lease_expires_at`);
+        positiveInteger(result.lease_duration_ms, `${command} result.lease_duration_ms`, MAX_POSTGRES_INTEGER);
+      }
+    }
+    const idempotency = integrityObject(result.idempotency, `${command} result.idempotency`);
+    integrityClosed(idempotency, ["replayed"], [], `${command} result.idempotency`);
+    if (typeof idempotency.replayed !== "boolean") {
+      throw integrity(`Infinity ${command} result has an invalid idempotency receipt`);
+    }
+    assertIntrinsicResultPostconditions(command, result);
+    if (expectation !== undefined)
+      assertExpectedResultBindings(command, result, expectation);
+    return deepFreeze({ ...result });
+  } catch (error) {
+    throw asIntegrityFailure(error, `Infinity ${command} result failed integrity validation`);
+  }
+}
+function assertExpectedResultBindings(command, result, expectation) {
+  if (expectation.command !== command)
+    throw integrity("Infinity mutation result expectation command differs from the response command");
+  if (expectation.command === "run.submit") {
+    if (result.run_spec_digest !== expectation.run_spec_digest || !int64Equal(result.authority_epoch, expectation.authority_epoch) || !int64Equal(result.route_epoch, expectation.route_epoch) || result.state !== "admitted" || result.attempt_phase !== "queued" || result.attempt_number !== 1 || result.run_revision !== 1 || result.attempt_revision !== 1) {
+      throw integrity("Infinity run.submit result differs from the exact admitted request binding");
+    }
+    return;
+  }
+  if (result.run_id !== expectation.run_id) {
+    throw integrity(`Infinity ${command} result run ID differs from the protected request`);
+  }
+  const leaseFields = [
+    "attempt_lease_id",
+    "lease_epoch",
+    "lease_holder_principal",
+    "lease_issued_at",
+    "lease_expires_at",
+    "lease_duration_ms"
+  ];
+  const present = leaseFields.filter((field) => Object.hasOwn(result, field)).length;
+  if (expectation.command === "run.cancel") {
+    const expectedLeaseEpoch = expectation.prior_lease.state === "none" ? 1 : incrementInt64(expectation.prior_lease.lease_epoch, "run.cancel result expected lease_epoch");
+    if (result.attempt_id !== expectation.attempt_id || result.attempt_number !== expectation.attempt_number || result.state !== "cancel_requested" || result.lease_holder_principal !== "service:cancel-recovery" || result.run_revision !== expectation.expected_run_revision || result.attempt_revision !== expectation.expected_attempt_revision || result.lease_duration_ms !== expectation.recovery_lease_duration_ms || !int64Equal(result.lease_epoch, expectedLeaseEpoch) || expectation.prior_lease.state === "selected" && result.attempt_lease_id === expectation.prior_lease.attempt_lease_id || present !== leaseFields.length) {
+      throw integrity("Infinity run.cancel result differs from the exact cancellation request binding");
+    }
+    return;
+  }
+  if (result.attempt_id === expectation.predecessor_attempt_id || result.attempt_number !== expectation.expected_attempt_number || result.state !== "active" || result.outcome !== null || result.run_revision !== expectation.expected_run_revision || result.attempt_number < 2 || result.attempt_revision !== 1 || present !== 0) {
+    throw integrity("Infinity run.retry result is not a fresh unleased active attempt");
+  }
+}
+function assertIntrinsicResultPostconditions(command, result) {
+  if (command === "run.submit") {
+    if (result.state !== "admitted" || result.attempt_phase !== "queued" || result.attempt_number !== 1 || result.run_revision !== 1 || result.attempt_revision !== 1) {
+      throw integrity("Infinity run.submit result violates intrinsic admission postconditions");
+    }
+    return;
+  }
+  const leaseFields = [
+    "attempt_lease_id",
+    "lease_epoch",
+    "lease_holder_principal",
+    "lease_issued_at",
+    "lease_expires_at",
+    "lease_duration_ms"
+  ];
+  const present = leaseFields.filter((field) => Object.hasOwn(result, field)).length;
+  if (command === "run.cancel") {
+    const issuedAt = Date.parse(result.lease_issued_at);
+    const expiresAt = Date.parse(result.lease_expires_at);
+    if (result.state !== "cancel_requested" || result.run_revision < 2 || result.attempt_revision === 1 || present !== leaseFields.length || result.lease_holder_principal !== "service:cancel-recovery" || result.lease_duration_ms !== CANCEL_RECOVERY_LEASE_DURATION_MS || expiresAt - issuedAt !== CANCEL_RECOVERY_LEASE_DURATION_MS) {
+      throw integrity("Infinity run.cancel result violates intrinsic cancellation recovery postconditions");
+    }
+    return;
+  }
+  if (result.state !== "active" || result.outcome !== null || result.run_revision < 2 || result.attempt_number < 2 || result.attempt_revision !== 1 || present !== 0) {
+    throw integrity("Infinity run.retry result violates intrinsic fresh-attempt postconditions");
+  }
+}
+function exactCancelRecoveryLeaseDuration(value, label) {
+  const parsed = positiveInteger(value, label, MAX_POSTGRES_INTEGER);
+  if (parsed !== CANCEL_RECOVERY_LEASE_DURATION_MS) {
+    throw integrity(`${label} must equal the fixed cancellation recovery lease duration`);
+  }
+  return CANCEL_RECOVERY_LEASE_DURATION_MS;
+}
+function parsePublicOperationResolution(value, expectedOperationId, expectation) {
+  try {
+    const resolution = integrityObject(value, "operation resolution");
+    const operationId = identifier(resolution.operation_id, "operation resolution.operation_id");
+    if (operationId !== expectedOperationId) {
+      throw integrity("Infinity resolution response operation ID does not match the protected request");
+    }
+    const status = enumValue(resolution.status, "operation resolution.status", ["committed", "in_flight", "aborted", "unknown"]);
+    if (status === "unknown") {
+      integrityClosed(resolution, ["operation_id", "status"], [], "unknown operation resolution");
+      return deepFreeze({ operation_id: operationId, status });
+    }
+    const required = status === "committed" ? ["operation_id", "status", "operation_binding", "result"] : ["operation_id", "status", "operation_binding"];
+    integrityClosed(resolution, required, [], `${status} operation resolution`);
+    const binding = integrityObject(resolution.operation_binding, "operation resolution.operation_binding");
+    integrityClosed(binding, ["command", "idempotency_key", "scope_digest", "request_hash"], [], "operation binding");
+    const command = enumValue(binding.command, "operation binding.command", ["run.submit", "run.cancel", "run.retry"]);
+    const parsedBinding = {
+      command,
+      idempotency_key: identifier(binding.idempotency_key, "operation binding.idempotency_key"),
+      scope_digest: digest(binding.scope_digest, "operation binding.scope_digest"),
+      request_hash: digest(binding.request_hash, "operation binding.request_hash")
+    };
+    if (status === "committed") {
+      const result = parsePublicMutationResult(command, resolution.result, operationId, expectation);
+      return deepFreeze({ operation_id: operationId, status, operation_binding: parsedBinding, result });
+    }
+    return deepFreeze({ operation_id: operationId, status, operation_binding: parsedBinding });
+  } catch (error) {
+    throw asIntegrityFailure(error, "Infinity operation resolution failed integrity validation");
+  }
+}
+function integrityObject(value, label) {
+  if (!isPlainObject(value))
+    throw integrity(`Infinity ${label} must be an object`);
+  return value;
+}
+function integrityClosed(value, required, optional, label) {
+  const allowed = new Set([...required, ...optional]);
+  if (Object.keys(value).some((field) => !allowed.has(field)) || required.some((field) => !Object.hasOwn(value, field))) {
+    throw integrity(`Infinity ${label} is not a closed complete object`);
+  }
+}
+function integrity(message, cause) {
+  return new InfinityError("integrity_failure", message, { status: 502, cause });
+}
+function asIntegrityFailure(error, fallback) {
+  if (error instanceof InfinityError && error.code === "integrity_failure")
+    return error;
+  return integrity(error instanceof Error ? error.message : fallback, error);
+}
+
+// src/contracts/runspec.ts
+var DATA_CLASSES = ["public", "internal_non_sensitive", "confidential"];
+var OUTPUT_CLASSES = ["patch", "test_receipt", "checkpoint", "evidence", "none"];
+var EVIDENCE_CLASSES = ["checkpoint_seal", "test_receipt", "verification_receipt", "secret_scan_receipt", "cleanup_receipt"];
+var OBJECT_FORMATS = ["sha1", "sha256"];
+var identifierSchema = {
+  type: "string",
+  minLength: 1,
+  maxLength: 96,
+  pattern: "^[A-Za-z0-9][A-Za-z0-9:_-]*$",
+  not: {
+    anyOf: [
+      { pattern: CREDENTIAL_CARRIER_PATTERN_SOURCE },
+      { minLength: 49, pattern: "^[A-Za-z0-9]+$" }
+    ]
+  }
+};
+var digestSchema = {
+  type: "string",
+  minLength: 71,
+  maxLength: 71,
+  pattern: "^sha256:[a-f0-9]{64}$"
+};
+var RUN_SPEC_INPUT_SCHEMA = deepFreeze({
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "api_version",
+    "kind",
+    "canonicalization_version",
+    "metadata",
+    "source",
+    "environment",
+    "policy",
+    "task"
+  ],
+  properties: {
+    api_version: { const: "infinity.runspec/v1alpha1" },
+    kind: { const: "RunSpec" },
+    canonicalization_version: { const: "infinity.canonical-json/v1" },
+    metadata: {
+      type: "object",
+      additionalProperties: false,
+      required: ["project_id", "logical_work_key"],
+      properties: {
+        project_id: identifierSchema,
+        logical_work_key: identifierSchema
+      }
+    },
+    source: {
+      type: "object",
+      additionalProperties: false,
+      required: ["repository_id", "object_format", "commit_sha", "expected_base_sha"],
+      properties: {
+        repository_id: identifierSchema,
+        object_format: { enum: OBJECT_FORMATS },
+        commit_sha: { type: "string", pattern: "^(?:[a-f0-9]{40}|[a-f0-9]{64})$" },
+        expected_base_sha: { type: "string", pattern: "^(?:[a-f0-9]{40}|[a-f0-9]{64})$" }
+      },
+      allOf: [
+        {
+          if: { properties: { object_format: { const: "sha1" } } },
+          then: {
+            properties: {
+              commit_sha: { type: "string", pattern: "^[a-f0-9]{40}$" },
+              expected_base_sha: { type: "string", pattern: "^[a-f0-9]{40}$" }
+            }
+          }
+        },
+        {
+          if: { properties: { object_format: { const: "sha256" } } },
+          then: {
+            properties: {
+              commit_sha: { type: "string", pattern: "^[a-f0-9]{64}$" },
+              expected_base_sha: { type: "string", pattern: "^[a-f0-9]{64}$" }
+            }
+          }
+        }
+      ]
+    },
+    environment: {
+      type: "object",
+      additionalProperties: false,
+      required: ["image_digest"],
+      properties: { image_digest: digestSchema }
+    },
+    policy: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "data_class",
+        "network_policy_digest",
+        "lane_policy_class",
+        "budget",
+        "approval_policy_id",
+        "cancellation_policy_id",
+        "checkpoint_policy_id",
+        "verification_policy_id",
+        "cleanup_policy_id",
+        "steering",
+        "policy_decision_digest",
+        "repository_automation_policy_digest"
+      ],
+      properties: {
+        data_class: { enum: DATA_CLASSES },
+        capabilities: {
+          type: "array",
+          maxItems: 64,
+          uniqueItems: true,
+          items: identifierSchema
+        },
+        network_policy_digest: digestSchema,
+        lane_policy_class: identifierSchema,
+        budget: {
+          type: "object",
+          additionalProperties: false,
+          required: ["wall_time_ms", "resource_units", "cost_minor_units"],
+          properties: {
+            wall_time_ms: { type: "integer", minimum: 1, maximum: 86400000 },
+            resource_units: { type: "integer", minimum: 1, maximum: 1e6 },
+            cost_minor_units: { type: "integer", minimum: 0, maximum: 1e9 }
+          }
+        },
+        approval_policy_id: identifierSchema,
+        retry_policy: {
+          type: "object",
+          additionalProperties: false,
+          required: ["max_attempts", "retryable_reasons"],
+          properties: {
+            max_attempts: { type: "integer", minimum: 1, maximum: 10 },
+            retryable_reasons: {
+              type: "array",
+              maxItems: 16,
+              uniqueItems: true,
+              items: identifierSchema
+            }
+          }
+        },
+        cancellation_policy_id: identifierSchema,
+        checkpoint_policy_id: identifierSchema,
+        verification_policy_id: identifierSchema,
+        cleanup_policy_id: identifierSchema,
+        steering: {
+          type: "object",
+          additionalProperties: false,
+          required: ["allowed_media_types", "max_bytes"],
+          properties: {
+            allowed_media_types: {
+              type: "array",
+              maxItems: 16,
+              uniqueItems: true,
+              items: {
+                type: "string",
+                minLength: 1,
+                maxLength: 80,
+                pattern: "^[a-z0-9.+-]+/[a-z0-9.+-]+$"
+              }
+            },
+            max_bytes: { type: "integer", minimum: 1, maximum: 1048576 }
+          }
+        },
+        policy_decision_digest: digestSchema,
+        repository_automation_policy_digest: digestSchema
+      }
+    },
+    task: {
+      type: "object",
+      additionalProperties: false,
+      required: ["expected_outputs", "expected_evidence"],
+      properties: {
+        input_artifacts: {
+          type: "array",
+          maxItems: 128,
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["artifact_id", "digest"],
+            properties: {
+              artifact_id: identifierSchema,
+              digest: digestSchema
+            }
+          }
+        },
+        expected_outputs: {
+          type: "array",
+          minItems: 1,
+          maxItems: 16,
+          uniqueItems: true,
+          items: { enum: OUTPUT_CLASSES }
+        },
+        expected_evidence: {
+          type: "array",
+          minItems: 1,
+          maxItems: 16,
+          uniqueItems: true,
+          items: { enum: EVIDENCE_CLASSES }
+        }
+      }
+    }
+  }
+});
+function parseRunSpec(value) {
+  const root = closedObject(value, "RunSpec", [
+    "api_version",
+    "kind",
+    "canonicalization_version",
+    "metadata",
+    "source",
+    "environment",
+    "policy",
+    "task"
+  ]);
+  if (root.api_version !== "infinity.runspec/v1alpha1")
+    throw invalid("RunSpec.api_version is unsupported");
+  if (root.kind !== "RunSpec")
+    throw invalid("RunSpec.kind must be RunSpec");
+  if (root.canonicalization_version !== "infinity.canonical-json/v1")
+    throw invalid("RunSpec.canonicalization_version is unsupported");
+  const metadata = closedObject(root.metadata, "RunSpec.metadata", [
+    "project_id",
+    "logical_work_key"
+  ]);
+  const logicalWorkKey = identifier(metadata.logical_work_key, "RunSpec.metadata.logical_work_key");
+  const source = closedObject(root.source, "RunSpec.source", [
+    "repository_id",
+    "object_format",
+    "commit_sha",
+    "expected_base_sha"
+  ]);
+  const objectFormat = enumValue(source.object_format, "RunSpec.source.object_format", OBJECT_FORMATS);
+  const oidLength = objectFormat === "sha1" ? 40 : 64;
+  const oidPattern = new RegExp(`^[a-f0-9]{${oidLength}}$`);
+  const commitSha = stringValue(source.commit_sha, "RunSpec.source.commit_sha", { min: oidLength, max: oidLength, pattern: oidPattern });
+  const expectedBaseSha = stringValue(source.expected_base_sha, "RunSpec.source.expected_base_sha", { min: oidLength, max: oidLength, pattern: oidPattern });
+  const environment = closedObject(root.environment, "RunSpec.environment", ["image_digest"]);
+  const policy = closedObject(root.policy, "RunSpec.policy", [
+    "data_class",
+    "network_policy_digest",
+    "lane_policy_class",
+    "budget",
+    "approval_policy_id",
+    "cancellation_policy_id",
+    "checkpoint_policy_id",
+    "verification_policy_id",
+    "cleanup_policy_id",
+    "steering",
+    "policy_decision_digest",
+    "repository_automation_policy_digest"
+  ], ["capabilities", "retry_policy"]);
+  const budget = closedObject(policy.budget, "RunSpec.policy.budget", [
+    "wall_time_ms",
+    "resource_units",
+    "cost_minor_units"
+  ]);
+  const steering = closedObject(policy.steering, "RunSpec.policy.steering", ["allowed_media_types", "max_bytes"]);
+  const retry = policy.retry_policy === undefined ? { max_attempts: 1, retryable_reasons: [] } : parseRetryPolicy(policy.retry_policy);
+  const task = closedObject(root.task, "RunSpec.task", ["expected_outputs", "expected_evidence"], ["input_artifacts"]);
+  const artifactInputs = task.input_artifacts ?? [];
+  if (!Array.isArray(artifactInputs) || artifactInputs.length > 128)
+    throw invalid("RunSpec.task.input_artifacts must be a bounded array");
+  const inputArtifacts = artifactInputs.map((entry, index) => {
+    const artifact = closedObject(entry, `RunSpec.task.input_artifacts[${index}]`, ["artifact_id", "digest"]);
+    return {
+      artifact_id: identifier(artifact.artifact_id, `RunSpec.task.input_artifacts[${index}].artifact_id`),
+      digest: digest(artifact.digest, `RunSpec.task.input_artifacts[${index}].digest`)
+    };
+  });
+  if (new Set(inputArtifacts.map((entry) => entry.artifact_id)).size !== inputArtifacts.length) {
+    throw invalid("RunSpec.task.input_artifacts contains duplicate artifact IDs");
+  }
+  const parsed = {
+    api_version: "infinity.runspec/v1alpha1",
+    kind: "RunSpec",
+    canonicalization_version: "infinity.canonical-json/v1",
+    metadata: {
+      project_id: identifier(metadata.project_id, "RunSpec.metadata.project_id"),
+      logical_work_key: logicalWorkKey
+    },
+    source: {
+      repository_id: identifier(source.repository_id, "RunSpec.source.repository_id"),
+      object_format: objectFormat,
+      commit_sha: commitSha,
+      expected_base_sha: expectedBaseSha
+    },
+    environment: { image_digest: digest(environment.image_digest, "RunSpec.environment.image_digest") },
+    policy: {
+      data_class: enumValue(policy.data_class, "RunSpec.policy.data_class", DATA_CLASSES),
+      capabilities: stringArray(policy.capabilities ?? [], "RunSpec.policy.capabilities", { allowEmpty: true, maxItems: 64 }),
+      network_policy_digest: digest(policy.network_policy_digest, "RunSpec.policy.network_policy_digest"),
+      lane_policy_class: identifier(policy.lane_policy_class, "RunSpec.policy.lane_policy_class"),
+      budget: {
+        wall_time_ms: positiveInteger(budget.wall_time_ms, "RunSpec.policy.budget.wall_time_ms", 86400000),
+        resource_units: positiveInteger(budget.resource_units, "RunSpec.policy.budget.resource_units", 1e6),
+        cost_minor_units: nonnegativeInteger(budget.cost_minor_units, "RunSpec.policy.budget.cost_minor_units", 1e9)
+      },
+      approval_policy_id: identifier(policy.approval_policy_id, "RunSpec.policy.approval_policy_id"),
+      retry_policy: retry,
+      cancellation_policy_id: identifier(policy.cancellation_policy_id, "RunSpec.policy.cancellation_policy_id"),
+      checkpoint_policy_id: identifier(policy.checkpoint_policy_id, "RunSpec.policy.checkpoint_policy_id"),
+      verification_policy_id: identifier(policy.verification_policy_id, "RunSpec.policy.verification_policy_id"),
+      cleanup_policy_id: identifier(policy.cleanup_policy_id, "RunSpec.policy.cleanup_policy_id"),
+      steering: {
+        allowed_media_types: stringArray(steering.allowed_media_types, "RunSpec.policy.steering.allowed_media_types", {
+          allowEmpty: true,
+          maxItems: 16,
+          item: (entry, label) => stringValue(entry, label, { max: 80, pattern: /^[a-z0-9.+-]+\/[a-z0-9.+-]+$/ })
+        }),
+        max_bytes: positiveInteger(steering.max_bytes, "RunSpec.policy.steering.max_bytes", 1048576)
+      },
+      policy_decision_digest: digest(policy.policy_decision_digest, "RunSpec.policy.policy_decision_digest"),
+      repository_automation_policy_digest: digest(policy.repository_automation_policy_digest, "RunSpec.policy.repository_automation_policy_digest")
+    },
+    task: {
+      input_artifacts: inputArtifacts,
+      expected_outputs: stringArray(task.expected_outputs, "RunSpec.task.expected_outputs", {
+        maxItems: 16,
+        item: (entry, label) => enumValue(entry, label, OUTPUT_CLASSES)
+      }),
+      expected_evidence: stringArray(task.expected_evidence, "RunSpec.task.expected_evidence", {
+        maxItems: 16,
+        item: (entry, label) => enumValue(entry, label, EVIDENCE_CLASSES)
+      })
+    }
+  };
+  return deepFreeze(parsed);
+}
+function parseRetryPolicy(value) {
+  const retry = closedObject(value, "RunSpec.policy.retry_policy", ["max_attempts", "retryable_reasons"]);
+  return {
+    max_attempts: positiveInteger(retry.max_attempts, "RunSpec.policy.retry_policy.max_attempts", 10),
+    retryable_reasons: stringArray(retry.retryable_reasons, "RunSpec.policy.retry_policy.retryable_reasons", {
+      allowEmpty: true,
+      maxItems: 16
+    })
+  };
+}
+function runSpecDigest(spec) {
+  return digestCanonical(spec);
+}
+
+// src/client/operator-client.ts
+var operatorHttpStatuses = new WeakMap;
+function operatorEnvelopeHttpStatus(envelope) {
+  return operatorHttpStatuses.get(envelope);
+}
+function inheritOperatorEnvelopeHttpStatus(source, target) {
+  const status = operatorHttpStatuses.get(source);
+  if (status !== undefined)
+    operatorHttpStatuses.set(target, status);
+  return target;
+}
+
+class OperatorHttpClient {
+  fetchImpl;
+  endpoint;
+  constructor(endpoint, fetchImpl = fetch) {
+    this.fetchImpl = fetchImpl;
+    const parsed = new URL(endpoint);
+    const loopbackHttp = parsed.protocol === "http:" && ["127.0.0.1", "::1", "localhost"].includes(parsed.hostname);
+    if (parsed.protocol !== "https:" && !loopbackHttp)
+      throw new Error("Infinity endpoint must use HTTPS or explicit loopback HTTP");
+    if (parsed.username || parsed.password || parsed.pathname !== "/" || parsed.search || parsed.hash) {
+      throw new Error("Infinity endpoint must be a credential-free origin");
+    }
+    this.endpoint = parsed;
+  }
+  version() {
+    return this.request("GET", "/v1/version", "version");
+  }
+  doctor() {
+    return this.request("GET", "/v1/doctor", "doctor");
+  }
+  listCapabilities() {
+    return this.request("GET", "/v1/capabilities", "capability.list");
+  }
+  validateRun(spec) {
+    return this.request("POST", "/v1/run-specs:validate", "run.validate", spec);
+  }
+  planRun(spec) {
+    return this.request("POST", "/v1/run-specs:plan", "run.plan", spec);
+  }
+  submitRun(request) {
+    return this.request("POST", "/v1/runs", "run.submit", {
+      authority_epoch: request.authorityEpoch,
+      route_lineage_id: request.routeLineageId,
+      route_id: request.routeId,
+      route_epoch: request.routeEpoch,
+      spec: request.spec
+    }, request, undefined, {
+      command: "run.submit",
+      run_spec_digest: runSpecDigest(parseRunSpec(request.spec)),
+      authority_epoch: request.authorityEpoch,
+      route_epoch: request.routeEpoch
+    });
+  }
+  getRun(runId) {
+    return this.request("GET", `/v1/runs/${encodeURIComponent(runId)}`, "run.get");
+  }
+  listRuns(options) {
+    const query = new URLSearchParams;
+    if (options.limit !== undefined)
+      query.set("limit", String(options.limit));
+    if (options.cursor !== undefined)
+      query.set("cursor", options.cursor);
+    const suffix = query.size === 0 ? "" : `?${query.toString()}`;
+    return this.request("GET", `/v1/runs${suffix}`, "run.list");
+  }
+  waitRun(runId, timeoutMs) {
+    const query = new URLSearchParams({ timeout_ms: String(timeoutMs) });
+    return this.request("GET", `/v1/runs/${encodeURIComponent(runId)}:wait?${query.toString()}`, "run.wait");
+  }
+  readRunEvents(runId, options) {
+    const query = new URLSearchParams({
+      cursor: options.cursor,
+      limit: String(options.limit),
+      wait_ms: String(options.waitMs)
+    });
+    return this.request("GET", `/v1/runs/${encodeURIComponent(runId)}/events?${query.toString()}`, "run.events.read");
+  }
+  cancelRun(request) {
+    const leaseSelector = serializeLeaseSelector(request);
+    return this.request("POST", `/v1/runs/${encodeURIComponent(request.runId)}:cancel`, "run.cancel", {
+      authority_epoch: request.authorityEpoch,
+      if_revision: request.ifRevision,
+      attempt_id: request.attemptId,
+      if_attempt_number: request.expectedAttemptNumber,
+      if_attempt_revision: request.expectedAttemptRevision,
+      ...leaseSelector,
+      reason_code: request.reasonCode
+    }, request, undefined, {
+      command: "run.cancel",
+      run_id: request.runId,
+      attempt_id: request.attemptId,
+      attempt_number: request.expectedAttemptNumber,
+      expected_run_revision: nextExpectedRunRevision(request.ifRevision),
+      expected_attempt_revision: nextExpectedAttemptRevision(request.expectedAttemptRevision),
+      recovery_lease_duration_ms: CANCEL_RECOVERY_LEASE_DURATION_MS,
+      prior_lease: request.attemptLeaseId === undefined ? { state: "none" } : {
+        state: "selected",
+        attempt_lease_id: request.attemptLeaseId,
+        lease_epoch: request.leaseEpoch
+      }
+    });
+  }
+  retryRun(request) {
+    const leaseSelector = serializeLeaseSelector(request);
+    return this.request("POST", `/v1/runs/${encodeURIComponent(request.runId)}:retry`, "run.retry", {
+      authority_epoch: request.authorityEpoch,
+      if_revision: request.ifRevision,
+      attempt_id: request.attemptId,
+      if_attempt_number: request.expectedAttemptNumber,
+      if_attempt_revision: request.expectedAttemptRevision,
+      ...leaseSelector
+    }, request, undefined, {
+      command: "run.retry",
+      run_id: request.runId,
+      predecessor_attempt_id: request.attemptId,
+      expected_attempt_number: nextExpectedAttemptNumber(request.expectedAttemptNumber),
+      expected_run_revision: nextExpectedRunRevision(request.ifRevision)
+    });
+  }
+  authorizeSandboxDispatch(request) {
+    return this.request("POST", "/v1/sandbox-dispatch-authorizations", "sandbox-dispatch.authorize", request);
+  }
+  dispatchProductionSandbox(request) {
+    return this.request("POST", "/v1/production-sandbox-dispatches", "sandbox-dispatch.production-dispatch", request);
+  }
+  resolveOperation(operationId) {
+    return this.request("GET", `/v1/operations/${encodeURIComponent(operationId)}`, "operation.resolve", undefined, undefined, operationId);
+  }
+  async request(method, path, expectedCommand, body, mutation, expectedResolutionOperationId, resultExpectation) {
+    const url = new URL(path, this.endpoint);
+    const requestId = `request-${crypto.randomUUID()}`;
+    const headers = new Headers({ "x-request-id": requestId });
+    if (body !== undefined)
+      headers.set("content-type", "application/json");
+    if (mutation) {
+      headers.set("x-infinity-operation-id", mutation.operationId);
+      headers.set("idempotency-key", mutation.idempotencyKey);
+    }
+    const response = await this.fetchImpl(url, {
+      method,
+      headers,
+      ...body === undefined ? {} : { body: canonicalJson(body) },
+      redirect: "error"
+    });
+    const parsed = parseOperatorEnvelope(await readBoundedResponse(response), response.status);
+    if (parsed.request_id !== requestId || parsed.command !== expectedCommand) {
+      throw new InfinityError("protocol_incompatible", "Infinity response correlation does not match the protected request", { status: 502 });
+    }
+    if (mutation) {
+      const missingBeforeReservation = !parsed.ok && parsed.operation_id === undefined && isOperatorPreReservationFailure(parsed);
+      if (!missingBeforeReservation && parsed.operation_id !== mutation.operationId) {
+        throw new InfinityError("integrity_failure", "Infinity mutation response operation ID does not match the protected request", { status: 502 });
+      }
+      if (parsed.ok) {
+        if (!isPublicMutationCommand(expectedCommand)) {
+          throw new InfinityError("protocol_incompatible", "Infinity returned success for an unsupported mutation command", { status: 502 });
+        }
+        parsePublicMutationResult(expectedCommand, parsed.data, mutation.operationId, resultExpectation);
+      }
+    }
+    if (expectedResolutionOperationId && parsed.ok) {
+      const data = parsed.data;
+      if (!isPlainObject(data) || data.operation_id !== expectedResolutionOperationId) {
+        throw new InfinityError("integrity_failure", "Infinity resolution response operation ID does not match the protected request", { status: 502 });
+      }
+      parsePublicOperationResolution(data, expectedResolutionOperationId);
+    }
+    return parsed;
+  }
+}
+function serializeLeaseSelector(request) {
+  const hasAttemptLeaseId = request.attemptLeaseId !== undefined;
+  const hasLeaseEpoch = request.leaseEpoch !== undefined;
+  if (hasAttemptLeaseId !== hasLeaseEpoch) {
+    throw new InfinityError("invalid_input", "attempt_lease_id and lease_epoch must be supplied together");
+  }
+  if (!hasAttemptLeaseId)
+    return {};
+  return {
+    attempt_lease_id: identifier(request.attemptLeaseId, "attempt_lease_id"),
+    lease_epoch: request.leaseEpoch
+  };
+}
+function nextExpectedRunRevision(value) {
+  const current = positiveInteger(value, "if_revision", MAX_MUTABLE_IF_REVISION);
+  return current + 1;
+}
+function nextExpectedAttemptRevision(value) {
+  const current = positiveInteger(value, "if_attempt_revision", MAX_MUTABLE_IF_REVISION);
+  return current + 1;
+}
+function nextExpectedAttemptNumber(value) {
+  const current = positiveInteger(value, "if_attempt_number", MAX_MUTABLE_IF_REVISION);
+  return current + 1;
+}
+var MAXIMUM_RESPONSE_BYTES = 1048576;
+async function readBoundedResponse(response) {
+  const contentType = response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase();
+  if (contentType !== "application/json")
+    throw incompatible("Infinity API response content type is incompatible");
+  const declaredLength = response.headers.get("content-length");
+  if (declaredLength !== null && (!/^\d+$/.test(declaredLength) || Number(declaredLength) > MAXIMUM_RESPONSE_BYTES)) {
+    throw incompatible("Infinity API response exceeds the byte limit");
+  }
+  if (!response.body)
+    throw incompatible("Infinity API response body is missing");
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  while (true) {
+    const item = await reader.read();
+    if (item.done)
+      break;
+    total += item.value.byteLength;
+    if (total > MAXIMUM_RESPONSE_BYTES) {
+      await reader.cancel();
+      throw incompatible("Infinity API response exceeds the byte limit");
+    }
+    chunks.push(item.value);
+  }
+  if (total === 0)
+    throw incompatible("Infinity API response body is empty");
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch (error) {
+    throw incompatible("Infinity API response is not valid UTF-8", error);
+  }
+}
+function parseOperatorEnvelope(source, status) {
+  try {
+    const value = parseStrictJson(source);
+    const root = closedObject(value, "operator envelope", [
+      "schema_version",
+      "ok",
+      "request_id",
+      "command",
+      "server_time",
+      "warnings",
+      "next_actions"
+    ], ["operation_id", "data", "error"]);
+    if (root.schema_version !== "infinity.operator/v1")
+      throw incompatible("Infinity API schema version is incompatible");
+    if (typeof root.ok !== "boolean")
+      throw incompatible("Infinity API envelope ok must be boolean");
+    const requestId = identifier(root.request_id, "operator envelope request_id");
+    const command = stringValue(root.command, "operator envelope command", { max: 80, pattern: /^[a-z][a-z0-9.:-]*$/ });
+    const serverTime = timestamp(root.server_time, "operator envelope server_time");
+    const operationId = root.operation_id === undefined ? undefined : identifier(root.operation_id, "operator envelope operation_id");
+    const warnings = boundedArray(root.warnings, "operator envelope warnings");
+    const nextActions = boundedArray(root.next_actions, "operator envelope next_actions");
+    const statusIsSuccess = status >= 200 && status < 300;
+    if (statusIsSuccess !== root.ok)
+      throw incompatible("Infinity API HTTP status and envelope outcome disagree");
+    if (root.ok) {
+      if (root.error !== undefined || !Object.hasOwn(root, "data"))
+        throw incompatible("Infinity API success envelope is incomplete");
+      return rememberHttpStatus(deepFreeze({
+        schema_version: "infinity.operator/v1",
+        ok: true,
+        request_id: requestId,
+        command,
+        server_time: serverTime,
+        ...operationId === undefined ? {} : { operation_id: operationId },
+        data: root.data,
+        warnings,
+        next_actions: nextActions
+      }), status);
+    }
+    if (root.data !== undefined)
+      throw incompatible("Infinity API error envelope contains success-only fields");
+    const error = closedObject(root.error, "operator envelope error", [
+      "code",
+      "message",
+      "retryable",
+      "retry_after_ms",
+      "details",
+      "remediation"
+    ]);
+    if (typeof error.retryable !== "boolean")
+      throw incompatible("Infinity API error retryable must be boolean");
+    if (error.retry_after_ms !== null)
+      nonnegativeInteger(error.retry_after_ms, "operator envelope retry_after_ms");
+    if (!isPlainObject(error.details))
+      throw incompatible("Infinity API error details must be an object");
+    const code = stringValue(error.code, "operator envelope error code", { max: 80, pattern: /^[a-z][a-z0-9_]*$/ });
+    if (!allowedErrorStatuses(code).includes(status)) {
+      throw incompatible("Infinity API error code and HTTP status are incompatible");
+    }
+    return rememberHttpStatus(deepFreeze({
+      schema_version: "infinity.operator/v1",
+      ok: false,
+      request_id: requestId,
+      command,
+      server_time: serverTime,
+      ...operationId === undefined ? {} : { operation_id: operationId },
+      error: {
+        code,
+        message: stringValue(error.message, "operator envelope error message", { max: 500 }),
+        retryable: error.retryable,
+        retry_after_ms: error.retry_after_ms,
+        details: deepFreeze({ ...error.details }),
+        remediation: stringValue(error.remediation, "operator envelope remediation", { max: 500 })
+      },
+      warnings,
+      next_actions: nextActions
+    }), status);
+  } catch (error) {
+    if (error instanceof InfinityError && ["protocol_incompatible", "integrity_failure"].includes(error.code))
+      throw error;
+    throw incompatible("Infinity API returned an incompatible envelope", error);
+  }
+}
+function rememberHttpStatus(envelope, status) {
+  operatorHttpStatuses.set(envelope, status);
+  return envelope;
+}
+function isOperatorPreReservationFailure(envelope) {
+  if (envelope.ok || !envelope.error || !isPlainObject(envelope.error.details))
+    return false;
+  return envelope.error.details.operation_reservation === "not_started";
+}
+function allowedErrorStatuses(code) {
+  const byCode = {
+    invalid_input: [400],
+    not_found: [404],
+    idempotency_key_reused: [409],
+    operation_id_conflict: [409],
+    logical_work_conflict: [409],
+    authority_epoch_mismatch: [409],
+    stale_revision: [409],
+    stale_lease_epoch: [409],
+    state_conflict: [409, 412, 503],
+    policy_denied: [403, 412],
+    approval_required: [412],
+    approval_digest_mismatch: [412],
+    capability_denied: [403, 503],
+    integrity_failure: [412],
+    capacity_unavailable: [409, 429, 503],
+    protocol_incompatible: [400, 502],
+    internal_error: [500, 503]
+  };
+  return byCode[code] ?? [];
+}
+function boundedArray(value, label) {
+  if (!Array.isArray(value) || value.length > 64)
+    throw incompatible(`${label} must be a bounded array`);
+  return structuredClone(value);
+}
+function incompatible(message, cause) {
+  return new InfinityError("protocol_incompatible", message, { status: 502, cause });
+}
+
+// src/core/ids.ts
+import { randomBytes } from "crypto";
+
+class RandomIdFactory {
+  next(prefix) {
+    return `${prefix}-${randomBytes(16).toString("hex")}`;
+  }
+}
+
+// src/core/clock.ts
+class SystemClock {
+  now() {
+    return new Date;
+  }
+}
+
+// src/authority/mutation-tuple.ts
+function submitRunMutationTuple(input) {
+  return {
+    scope: {
+      route_lineage_id: input.routeLineageId,
+      logical_work_key: input.spec.metadata.logical_work_key
+    },
+    request: {
+      run_spec_digest: runSpecDigest(input.spec),
+      route_id: input.routeId,
+      route_epoch: input.routeEpoch
+    }
+  };
+}
+function mutationRequestHash(input) {
+  return digestCanonical({
+    command: input.command,
+    scope: input.scope,
+    input: input.request,
+    authority_epoch: input.authorityEpoch,
+    idempotency_key: input.idempotencyKey
+  });
+}
+
+// src/cli/operation-journal.ts
+import { Database } from "bun:sqlite";
+import { chmodSync, closeSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync } from "fs";
+import { dirname, join } from "path";
+import { userInfo } from "os";
+var CLI_MUTATION_CONSEQUENCE_SCHEMA_VERSION = "infinity.cli-mutation-consequence/v1";
+function defaultCliOperationJournalPath() {
+  return join(userInfo().homedir, ".local", "state", "infinity", "operator-journal.sqlite");
+}
+
+class DurableCliOperationJournal {
+  path;
+  ids;
+  clock;
+  database;
+  constructor(path, ids, clock) {
+    this.path = path;
+    this.ids = ids;
+    this.clock = clock;
+  }
+  async prepare(value) {
+    closedObject(value, "CLI operation intent", [
+      "command",
+      "idempotencyKey",
+      "scope",
+      "request",
+      "authorityRequestHash",
+      "resultExpectation"
+    ]);
+    const command = stringValue(value.command, "CLI operation command", { max: 64, pattern: /^[a-z][a-z0-9.]+$/ });
+    const idempotencyKey = identifier(value.idempotencyKey, "idempotency_key");
+    if (!isPlainObject(value.scope) || !isPlainObject(value.request)) {
+      throw new InfinityError("invalid_input", "CLI operation scope and request must be closed objects");
+    }
+    const scopeDigest = digestCanonical(value.scope);
+    const requestDigest = digestCanonical(value.request);
+    const authorityRequestHash = digest(value.authorityRequestHash, "CLI authority request hash");
+    const resultExpectation = parsePublicMutationResultExpectation(value.resultExpectation);
+    if (resultExpectation.command !== command) {
+      throw new InfinityError("integrity_failure", "CLI result expectation command differs from its mutation command");
+    }
+    const resultExpectationText = canonicalJson(resultExpectation);
+    const resultExpectationDigest = digestCanonical(resultExpectation);
+    const database = this.open();
+    const prepare = database.transaction(() => {
+      const prior = database.query(`
+        SELECT operation_id, request_digest, authority_request_hash, result_expectation, result_expectation_digest
+        FROM prepared_operations
+        WHERE command = ? AND idempotency_key = ? AND scope_digest = ?
+      `).get(command, idempotencyKey, scopeDigest);
+      if (prior) {
+        if (prior.request_digest !== requestDigest) {
+          throw new InfinityError("idempotency_key_reused", "CLI idempotency tuple was reused with another request", { status: 409 });
+        }
+        if (prior.authority_request_hash !== null && prior.authority_request_hash !== authorityRequestHash) {
+          throw new InfinityError("idempotency_key_reused", "CLI idempotency tuple was reused with another authority request", { status: 409 });
+        }
+        if (prior.result_expectation !== null && prior.result_expectation !== resultExpectationText) {
+          throw new InfinityError("idempotency_key_reused", "CLI idempotency tuple was reused with another result expectation", { status: 409 });
+        }
+        if (prior.result_expectation_digest !== null && prior.result_expectation_digest !== resultExpectationDigest) {
+          throw new InfinityError("integrity_failure", "CLI result expectation digest conflicts with its canonical bytes");
+        }
+        if (prior.authority_request_hash === null || prior.result_expectation === null || prior.result_expectation_digest === null) {
+          const recovered = database.query(`
+            UPDATE prepared_operations SET
+              authority_request_hash = COALESCE(authority_request_hash, ?),
+              result_expectation = COALESCE(result_expectation, ?),
+              result_expectation_digest = COALESCE(result_expectation_digest, ?),
+              updated_at = ?
+            WHERE operation_id = ?
+              AND (authority_request_hash IS NULL OR authority_request_hash = ?)
+              AND (result_expectation IS NULL OR result_expectation = ?)
+              AND (result_expectation_digest IS NULL OR result_expectation_digest = ?)
+          `).run(authorityRequestHash, resultExpectationText, resultExpectationDigest, this.clock.now().toISOString(), prior.operation_id, authorityRequestHash, resultExpectationText, resultExpectationDigest);
+          if (recovered.changes !== 1) {
+            throw new InfinityError("integrity_failure", "legacy CLI operation recovery lost its compare-and-swap");
+          }
+        }
+        return {
+          operationId: prior.operation_id,
+          command,
+          idempotencyKey,
+          scopeDigest,
+          requestDigest,
+          authorityRequestHash,
+          resultExpectation,
+          replayed: true
+        };
+      }
+      const operationId = identifier(this.ids.next("operation"), "operation_id");
+      database.query(`
+        INSERT INTO prepared_operations
+          (operation_id, command, idempotency_key, scope_digest, request_digest, authority_request_hash,
+           result_expectation, result_expectation_digest, state, response_digest, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'prepared', NULL, ?, ?)
+      `).run(operationId, command, idempotencyKey, scopeDigest, requestDigest, authorityRequestHash, resultExpectationText, resultExpectationDigest, this.clock.now().toISOString(), this.clock.now().toISOString());
+      return {
+        operationId,
+        command,
+        idempotencyKey,
+        scopeDigest,
+        requestDigest,
+        authorityRequestHash,
+        resultExpectation,
+        replayed: false
+      };
+    });
+    return prepare.immediate();
+  }
+  async recordResponse(operationIdInput, envelope) {
+    const operationId = identifier(operationIdInput, "operation_id");
+    const database = this.open();
+    const record = database.transaction(() => {
+      const row = database.query(`
+        SELECT command, result_expectation, result_expectation_digest,
+          state, response_digest, response_consequence
+        FROM prepared_operations WHERE operation_id = ?
+      `).get(operationId);
+      if (!row)
+        throw new InfinityError("integrity_failure", "CLI response has no durable pre-dispatch operation");
+      if (envelope.command !== row.command || envelope.operation_id !== operationId) {
+        throw new InfinityError("integrity_failure", "CLI response correlation differs from its durable operation");
+      }
+      if (!envelope.ok) {
+        return;
+      }
+      const resultExpectation = parseStoredResultExpectation(row.command, row.result_expectation, row.result_expectation_digest);
+      const consequence = canonicalMutationConsequence(row.command, operationId, envelope.data, resultExpectation);
+      const consequenceText = canonicalJson(consequence);
+      const responseDigest = digestCanonical(consequence);
+      if (row.state === "responded") {
+        if (row.response_consequence === null) {
+          const legacyDigest = legacySuccessfulResponseDigest(envelope);
+          if (row.response_digest !== legacyDigest) {
+            throw new InfinityError("integrity_failure", "CLI operation received conflicting legacy response bytes");
+          }
+          const recovered = database.query(`
+            UPDATE prepared_operations SET response_digest = ?, response_consequence = ?, updated_at = ?
+            WHERE operation_id = ? AND state = 'responded' AND response_digest = ?
+              AND response_consequence IS NULL
+          `).run(responseDigest, consequenceText, this.clock.now().toISOString(), operationId, legacyDigest);
+          if (recovered.changes !== 1) {
+            throw new InfinityError("integrity_failure", "CLI legacy response recovery lost its compare-and-swap");
+          }
+        } else if (row.response_digest !== responseDigest || row.response_consequence !== consequenceText) {
+          throw new InfinityError("integrity_failure", "CLI operation received conflicting canonical consequence bytes");
+        }
+        return;
+      }
+      const updated = database.query(`
+        UPDATE prepared_operations SET state = 'responded', response_digest = ?,
+          response_consequence = ?, updated_at = ?
+        WHERE operation_id = ? AND state = 'prepared'
+      `).run(responseDigest, consequenceText, this.clock.now().toISOString(), operationId);
+      if (updated.changes !== 1)
+        throw new InfinityError("integrity_failure", "CLI response state compare-and-swap failed");
+    });
+    record.immediate();
+  }
+  read(operationIdInput) {
+    const operationId = identifier(operationIdInput, "operation_id");
+    const row = this.open().query(`
+      SELECT operation_id, command, idempotency_key, scope_digest, request_digest, authority_request_hash,
+        result_expectation, result_expectation_digest, state, response_digest, response_consequence
+      FROM prepared_operations WHERE operation_id = ?
+    `).get(operationId);
+    if (!row)
+      throw new InfinityError("not_found", "CLI operation is not in the local journal", { status: 404 });
+    if (row.authority_request_hash === null || row.result_expectation === null || row.result_expectation_digest === null) {
+      throw new InfinityError("state_conflict", "legacy CLI operation requires an exact mutation-command replay before it can be resolved", { status: 409 });
+    }
+    const authorityRequestHash = digest(row.authority_request_hash, "CLI authority request hash");
+    const resultExpectation = parseStoredResultExpectation(row.command, row.result_expectation, row.result_expectation_digest);
+    if (row.state === "responded") {
+      if (row.response_digest === null || row.response_consequence === null) {
+        throw new InfinityError("state_conflict", "legacy CLI success requires an exact command replay before resolution", {
+          status: 409
+        });
+      }
+      const responseDigest = digest(row.response_digest, "CLI response consequence digest");
+      const storedConsequence = parseStoredMutationConsequence(row.response_consequence, row.command, row.operation_id, resultExpectation);
+      if (digestCanonical(storedConsequence) !== responseDigest) {
+        throw new InfinityError("integrity_failure", "CLI stored response consequence differs from its digest");
+      }
+    } else if (row.response_digest !== null || row.response_consequence !== null) {
+      throw new InfinityError("integrity_failure", "CLI prepared operation carries response-only bytes");
+    }
+    return {
+      operationId: row.operation_id,
+      command: row.command,
+      idempotencyKey: row.idempotency_key,
+      scopeDigest: row.scope_digest,
+      requestDigest: row.request_digest,
+      authorityRequestHash,
+      resultExpectation,
+      replayed: true,
+      state: row.state,
+      responseDigest: row.response_digest
+    };
+  }
+  close() {
+    this.database?.close(false);
+    this.database = undefined;
+  }
+  open() {
+    if (this.database)
+      return this.database;
+    if (this.path !== ":memory:")
+      prepareOwnerOnlyPath(this.path);
+    const created = this.path !== ":memory:" && !existsSync(this.path);
+    const database = new Database(this.path, { create: true, strict: true });
+    database.exec("PRAGMA journal_mode = DELETE; PRAGMA synchronous = FULL; PRAGMA foreign_keys = ON;");
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS prepared_operations (
+        operation_id TEXT PRIMARY KEY,
+        command TEXT NOT NULL,
+        idempotency_key TEXT NOT NULL,
+        scope_digest TEXT NOT NULL,
+        request_digest TEXT NOT NULL,
+        authority_request_hash TEXT NOT NULL,
+        result_expectation TEXT NOT NULL,
+        result_expectation_digest TEXT NOT NULL,
+        state TEXT NOT NULL CHECK (state IN ('prepared','responded')),
+        response_digest TEXT,
+        response_consequence TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        UNIQUE (command, idempotency_key, scope_digest),
+        CHECK ((state = 'prepared' AND response_digest IS NULL AND response_consequence IS NULL)
+          OR (state = 'responded' AND response_digest IS NOT NULL AND response_consequence IS NOT NULL))
+      );
+    `);
+    const columns = database.query("PRAGMA table_info(prepared_operations)").all();
+    if (!columns.some((column) => column.name === "authority_request_hash")) {
+      database.exec("ALTER TABLE prepared_operations ADD COLUMN authority_request_hash TEXT");
+    }
+    if (!columns.some((column) => column.name === "result_expectation")) {
+      database.exec("ALTER TABLE prepared_operations ADD COLUMN result_expectation TEXT");
+    }
+    if (!columns.some((column) => column.name === "result_expectation_digest")) {
+      database.exec("ALTER TABLE prepared_operations ADD COLUMN result_expectation_digest TEXT");
+    }
+    if (!columns.some((column) => column.name === "response_consequence")) {
+      database.exec("ALTER TABLE prepared_operations ADD COLUMN response_consequence TEXT");
+    }
+    if (this.path !== ":memory:") {
+      chmodSync(this.path, 384);
+      if (created)
+        fsyncDirectory(dirname(this.path));
+    }
+    this.database = database;
+    return database;
+  }
+}
+function fsyncDirectory(path) {
+  const descriptor = openSync(path, "r");
+  try {
+    fsyncSync(descriptor);
+  } finally {
+    closeSync(descriptor);
+  }
+}
+function successfulMutationConsequenceDigest(command, operationId, value, expectation) {
+  return digestCanonical(canonicalMutationConsequence(command, operationId, value, expectation));
+}
+function legacySuccessfulResponseDigest(envelope) {
+  const data = isPlainObject(envelope.data) ? Object.fromEntries(Object.entries(envelope.data).filter(([field]) => field !== "idempotency")) : envelope.data ?? null;
+  return digestCanonical({
+    schema_version: envelope.schema_version,
+    ok: envelope.ok,
+    command: envelope.command,
+    operation_id: envelope.operation_id ?? null,
+    data
+  });
+}
+function canonicalMutationConsequence(command, operationIdInput, value, expectationInput) {
+  if (!isPublicMutationCommand(command)) {
+    throw new InfinityError("integrity_failure", "CLI consequence command is not a public mutation command");
+  }
+  const operationId = identifier(operationIdInput, "operation_id");
+  const expectation = parsePublicMutationResultExpectation(expectationInput);
+  if (expectation.command !== command) {
+    throw new InfinityError("integrity_failure", "CLI consequence expectation command differs");
+  }
+  const parsed = parsePublicMutationResult(command, value, operationId, expectation);
+  return {
+    schema_version: CLI_MUTATION_CONSEQUENCE_SCHEMA_VERSION,
+    command,
+    operation_id: operationId,
+    result_expectation_digest: digestCanonical(expectation),
+    result: {
+      ...parsed,
+      idempotency: { replayed: false }
+    }
+  };
+}
+function parseStoredResultExpectation(command, expectationText, expectationDigestText) {
+  if (expectationText === null || expectationDigestText === null) {
+    throw new InfinityError("state_conflict", "legacy CLI operation requires an exact command replay", { status: 409 });
+  }
+  const expectationDigest = digest(expectationDigestText, "CLI result expectation digest");
+  let expectation;
+  try {
+    expectation = parsePublicMutationResultExpectation(parseStrictJson(expectationText));
+  } catch (error) {
+    throw new InfinityError("integrity_failure", "CLI result expectation bytes are corrupt", { cause: error });
+  }
+  if (expectation.command !== command || digestCanonical(expectation) !== expectationDigest || canonicalJson(expectation) !== expectationText) {
+    throw new InfinityError("integrity_failure", "CLI result expectation differs from its protected digest or command");
+  }
+  return expectation;
+}
+function parseStoredMutationConsequence(consequenceText, expectedCommand, expectedOperationId, expectation) {
+  let stored;
+  try {
+    stored = closedObject(parseStrictJson(consequenceText), "CLI mutation consequence", [
+      "schema_version",
+      "command",
+      "operation_id",
+      "result_expectation_digest",
+      "result"
+    ]);
+  } catch (error) {
+    throw new InfinityError("integrity_failure", "CLI stored mutation consequence bytes are corrupt", { cause: error });
+  }
+  if (stored.schema_version !== CLI_MUTATION_CONSEQUENCE_SCHEMA_VERSION || stored.command !== expectedCommand || stored.operation_id !== expectedOperationId || stored.result_expectation_digest !== digestCanonical(expectation)) {
+    throw new InfinityError("integrity_failure", "CLI stored mutation consequence binding differs");
+  }
+  const canonical = canonicalMutationConsequence(expectedCommand, expectedOperationId, stored.result, expectation);
+  if (canonicalJson(canonical) !== consequenceText) {
+    throw new InfinityError("integrity_failure", "CLI stored mutation consequence is not canonical or complete");
+  }
+  return canonical;
+}
+function prepareOwnerOnlyPath(path) {
+  const directory = dirname(path);
+  mkdirSync(directory, { recursive: true, mode: 448 });
+  const directoryStat = lstatSync(directory);
+  if (!directoryStat.isDirectory() || directoryStat.isSymbolicLink()) {
+    throw new InfinityError("integrity_failure", "CLI journal directory is not a real directory");
+  }
+  if (typeof process.getuid === "function" && directoryStat.uid !== process.getuid()) {
+    throw new InfinityError("capability_denied", "CLI journal directory is not owned by the current user", { status: 403 });
+  }
+  chmodSync(directory, 448);
+  try {
+    const fileStat = lstatSync(path);
+    if (!fileStat.isFile() || fileStat.isSymbolicLink()) {
+      throw new InfinityError("integrity_failure", "CLI journal path is not a regular file");
+    }
+    if (typeof process.getuid === "function" && fileStat.uid !== process.getuid()) {
+      throw new InfinityError("capability_denied", "CLI journal is not owned by the current user", { status: 403 });
+    }
+    chmodSync(path, 384);
+  } catch (error) {
+    if (error instanceof InfinityError)
+      throw error;
+    if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT")
+      throw error;
+  }
+}
+
+// src/authcapsules/codewith-local.ts
+import { createHash as createHash2 } from "crypto";
+import { lstat, readdir, readFile, realpath } from "fs/promises";
+import { isAbsolute, join as join2, relative, sep } from "path";
+
+// src/authcapsules/infinity-agent-policy.ts
+import { posix } from "path";
+var INFINITY_AGENT_POLICY_SCHEMA_VERSION = "infinity.codewith-agent-policy.v1";
+var CAPSULE_REMOTE_CAPABILITIES = [
+  "sandbox.checkpoint.request",
+  "sandbox.exec",
+  "sandbox.file.read",
+  "sandbox.file.write"
+];
+var POLICY_FIELDS = [
+  "schema_version",
+  "profile",
+  "enforcement",
+  "environment_inherit",
+  "history_persistence",
+  "ephemeral",
+  "host_filesystem_access",
+  "host_shell_access",
+  "direct_network_access",
+  "auth_profile_control",
+  "allowed_capabilities"
+];
+function parseInfinityAgentPolicy(value) {
+  const input = closedObject(value, "infinity-agent policy", POLICY_FIELDS);
+  const requireBoolean = (field, expected) => {
+    if (input[field] !== expected) {
+      const words = field.replaceAll("_", " ");
+      throw new InfinityError("capability_denied", `infinity-agent policy ${words} must be ${String(expected)}`, { status: 403 });
+    }
+    return expected;
+  };
+  const allowed = stringArray(input.allowed_capabilities, "policy.allowed_capabilities", {
+    maxItems: CAPSULE_REMOTE_CAPABILITIES.length,
+    item: (entry, label) => enumValue(entry, label, CAPSULE_REMOTE_CAPABILITIES)
+  });
+  const sorted = [...allowed].sort();
+  if (allowed.some((entry, index) => entry !== sorted[index])) {
+    throw new InfinityError("invalid_input", "policy allowed capabilities must use canonical sorted order");
+  }
+  return deepFreeze({
+    schema_version: enumValue(input.schema_version, "policy.schema_version", [INFINITY_AGENT_POLICY_SCHEMA_VERSION]),
+    profile: enumValue(input.profile, "policy.profile", ["infinity-agent"]),
+    enforcement: enumValue(input.enforcement, "policy.enforcement", ["codewith-native-v1"]),
+    environment_inherit: enumValue(input.environment_inherit, "policy.environment_inherit", ["none"]),
+    history_persistence: enumValue(input.history_persistence, "policy.history_persistence", ["none"]),
+    ephemeral: requireBoolean("ephemeral", true),
+    host_filesystem_access: requireBoolean("host_filesystem_access", false),
+    host_shell_access: requireBoolean("host_shell_access", false),
+    direct_network_access: requireBoolean("direct_network_access", false),
+    auth_profile_control: requireBoolean("auth_profile_control", false),
+    allowed_capabilities: allowed
+  });
+}
+function infinityAgentPolicyDigest(value) {
+  return digestCanonical(parseInfinityAgentPolicy(value));
+}
+
+class ProtectedCapsuleRemoteToolBridge {
+  #authority;
+  #backend;
+  constructor(dependencies) {
+    this.#authority = dependencies.authority;
+    this.#backend = dependencies.backend;
+  }
+  async open(input) {
+    const policy = parseInfinityAgentPolicy(input.policy);
+    if (input.descriptor.infinity_agent_policy_sha256 !== infinityAgentPolicyDigest(policy)) {
+      throw new InfinityError("capability_denied", "infinity-agent policy measurement does not match the AuthCapsule descriptor", { status: 403 });
+    }
+    if (input.descriptor.owner_ref !== input.binding.fence.actor_principal) {
+      throw new InfinityError("capability_denied", "AuthCapsule owner does not match the remote-tool actor", { status: 403 });
+    }
+    await this.#authority.assertCurrent({ ...input, policy });
+    let closed = false;
+    const invokedIds = new Set;
+    return {
+      invoke: async (call) => {
+        if (closed)
+          throw new InfinityError("state_conflict", "capsule remote-tool bridge session is closed", { status: 409 });
+        const parsed = parseRemoteToolCall(call, policy);
+        if (invokedIds.has(parsed.request_id)) {
+          throw new InfinityError("state_conflict", "capsule remote-tool request id was already used", { status: 409 });
+        }
+        invokedIds.add(parsed.request_id);
+        await this.#authority.assertCurrent({
+          descriptor: input.descriptor,
+          binding: input.binding,
+          policy,
+          capability: parsed.capability
+        });
+        return this.#backend.invoke({
+          descriptor: input.descriptor,
+          binding: input.binding,
+          capability: parsed.capability,
+          request_id: parsed.request_id,
+          input: parsed.input
+        });
+      },
+      close: async () => {
+        closed = true;
+      }
+    };
+  }
+}
+function parseRemoteToolCall(value, policy) {
+  const call = closedObject(value, "capsule remote-tool call", ["request_id", "capability", "input"]);
+  const capability = enumValue(call.capability, "call.capability", CAPSULE_REMOTE_CAPABILITIES);
+  if (!policy.allowed_capabilities.includes(capability)) {
+    throw new InfinityError("capability_denied", "capsule remote-tool capability is not present in the measured allowlist", { status: 403 });
+  }
+  const requestId = identifier(call.request_id, "call.request_id");
+  return deepFreeze({
+    request_id: requestId,
+    capability,
+    input: parseCapabilityInput(capability, call.input)
+  });
+}
+function parseCapabilityInput(capability, value) {
+  if (capability === "sandbox.file.read") {
+    const input2 = closedObject(value, capability, ["path", "max_bytes"]);
+    return deepFreeze({
+      path: relativeSandboxPath(input2.path, "read path"),
+      max_bytes: positiveInteger(input2.max_bytes, "read max_bytes", 16 * 1024 * 1024)
+    });
+  }
+  if (capability === "sandbox.file.write") {
+    const input2 = closedObject(value, capability, ["path", "content_utf8"]);
+    const content = stringValue(input2.content_utf8, "write content_utf8", { max: 16 * 1024 * 1024 });
+    if (new TextEncoder().encode(content).byteLength > 16 * 1024 * 1024) {
+      throw new InfinityError("invalid_input", "write content exceeds the bridge byte limit");
+    }
+    return deepFreeze({ path: relativeSandboxPath(input2.path, "write path"), content_utf8: content });
+  }
+  if (capability === "sandbox.exec") {
+    const input2 = closedObject(value, capability, ["argv", "cwd", "timeout_ms"]);
+    const argv = stringArray(input2.argv, "exec argv", {
+      maxItems: 128,
+      item: (entry, label) => stringValue(entry, label, { max: 4096 })
+    });
+    return deepFreeze({
+      argv,
+      cwd: relativeSandboxPath(input2.cwd, "exec cwd", true),
+      timeout_ms: positiveInteger(input2.timeout_ms, "exec timeout_ms", 300000)
+    });
+  }
+  const input = closedObject(value, capability, ["reason"]);
+  return deepFreeze({ reason: stringValue(input.reason, "checkpoint reason", { max: 512 }) });
+}
+function relativeSandboxPath(value, label, allowDot = false) {
+  const parsed = stringValue(value, label, { max: 4096 });
+  if (parsed.includes("\\") || parsed.startsWith("/") || parsed.includes("\x00")) {
+    throw new InfinityError("capability_denied", `${label} must be a portable relative sandbox path`, { status: 403 });
+  }
+  const normalized = posix.normalize(parsed);
+  if (normalized === ".." || normalized.startsWith("../") || normalized.startsWith("/")) {
+    throw new InfinityError("capability_denied", `${label} escapes the sandbox workspace`, { status: 403 });
+  }
+  if (!allowDot && normalized === "." || normalized.length === 0) {
+    throw new InfinityError("invalid_input", `${label} must identify a sandbox path`);
+  }
+  return normalized;
+}
+
+// src/contracts/fence.ts
+var BROKER_FENCE_FIELDS = [
+  "authority_epoch",
+  "route_lineage_id",
+  "route_id",
+  "route_epoch",
+  "run_id",
+  "attempt_id",
+  "attempt_lease_id",
+  "lease_epoch",
+  "lease_holder_principal",
+  "resource_lease_id",
+  "resource_id",
+  "resource_lifecycle_generation",
+  "operation_id",
+  "operation_digest",
+  "operation_execution_epoch",
+  "actor_principal",
+  "operation_executor_principal",
+  "audience",
+  "issued_at",
+  "lease_expires_at",
+  "operation_execution_expires_at"
+];
+var BROKER_FENCE_SCHEMA_VERSION = "infinity.broker-fence.v1";
+var BROKER_FENCE_WIRE_FIELDS = ["schema_version", ...BROKER_FENCE_FIELDS];
+var REJECTED_FENCE_ALIASES = [
+  "authority_generation",
+  "authority_incarnation",
+  "route_authority_epoch",
+  "producer_epoch",
+  "attempt_lease_epoch",
+  "cancellation_generation",
+  "allocation_generation",
+  "lifecycle_revision"
+];
+function parseBrokerFence(value) {
+  if (value && typeof value === "object") {
+    for (const alias of REJECTED_FENCE_ALIASES) {
+      if (Object.hasOwn(value, alias))
+        throw new InfinityError("invalid_input", `broker fence alias ${alias} is rejected`);
+    }
+  }
+  const input = closedObject(value, "broker_fence", BROKER_FENCE_WIRE_FIELDS);
+  const parsed = {
+    schema_version: enumValue(input.schema_version, "schema_version", [BROKER_FENCE_SCHEMA_VERSION]),
+    authority_epoch: positiveInt64(input.authority_epoch, "authority_epoch"),
+    route_lineage_id: identifier(input.route_lineage_id, "route_lineage_id"),
+    route_id: identifier(input.route_id, "route_id"),
+    route_epoch: positiveInt64(input.route_epoch, "route_epoch"),
+    run_id: identifier(input.run_id, "run_id"),
+    attempt_id: identifier(input.attempt_id, "attempt_id"),
+    attempt_lease_id: identifier(input.attempt_lease_id, "attempt_lease_id"),
+    lease_epoch: positiveInt64(input.lease_epoch, "lease_epoch"),
+    lease_holder_principal: identifier(input.lease_holder_principal, "lease_holder_principal"),
+    resource_lease_id: identifier(input.resource_lease_id, "resource_lease_id"),
+    resource_id: identifier(input.resource_id, "resource_id"),
+    resource_lifecycle_generation: positiveInt64(input.resource_lifecycle_generation, "resource_lifecycle_generation"),
+    operation_id: identifier(input.operation_id, "operation_id"),
+    operation_digest: digest(input.operation_digest, "operation_digest"),
+    operation_execution_epoch: positiveInt64(input.operation_execution_epoch, "operation_execution_epoch"),
+    actor_principal: identifier(input.actor_principal, "actor_principal"),
+    operation_executor_principal: identifier(input.operation_executor_principal, "operation_executor_principal"),
+    audience: identifier(input.audience, "audience"),
+    issued_at: timestamp(input.issued_at, "issued_at"),
+    lease_expires_at: timestamp(input.lease_expires_at, "lease_expires_at"),
+    operation_execution_expires_at: timestamp(input.operation_execution_expires_at, "operation_execution_expires_at")
+  };
+  const issued = Date.parse(parsed.issued_at);
+  const leaseExpiry = Date.parse(parsed.lease_expires_at);
+  const executionExpiry = Date.parse(parsed.operation_execution_expires_at);
+  if (!(issued < executionExpiry && executionExpiry <= leaseExpiry)) {
+    throw new InfinityError("invalid_input", "broker fence expiry window is invalid");
+  }
+  return Object.freeze(parsed);
+}
+
+// src/authcapsules/codewith-local.ts
+var AUTH_CAPSULE_DESCRIPTOR_SCHEMA_VERSION = "infinity.auth-capsule-descriptor.v2";
+var CAPSULE_REMOTE_TOOL_BINDING_SCHEMA_VERSION = "infinity.capsule-remote-tool-binding.v1";
+var DESCRIPTOR_FIELDS = [
+  "schema_version",
+  "auth_capsule_id",
+  "owner_ref",
+  "provider_key",
+  "provider_subject_ref",
+  "capacity_domain_ref",
+  "account_lane_id",
+  "canonical_node_id",
+  "node_key_thumbprint",
+  "node_generation",
+  "placement_generation",
+  "auth_generation",
+  "auth_state_revision",
+  "accounts_revision_set_digest",
+  "capsule_attestation_digest",
+  "local_profile_ref",
+  "codewith_binary_sha256",
+  "runtime_policy_sha256",
+  "infinity_agent_policy_sha256"
+];
+var BINDING_FIELDS = [
+  "schema_version",
+  "dispatch_id",
+  "canonical_intent_sha256",
+  "sandbox_prepare_anchor_sha256",
+  "authority_envelope_sha256",
+  "effect_claim_sha256",
+  "operation_digest",
+  "provider",
+  "source_manifest_sha256",
+  "input_manifest_sha256",
+  "checkpoint_policy_sha256",
+  "fence"
+];
+var FORBIDDEN_CREDENTIAL_FIELD = /(?:^|_)(?:access|refresh|session)?_?(?:token|secret|password|cookie|api_key|credential|auth_json)(?:$|_)/i;
+var MAX_PROMPT_BYTES = 256 * 1024;
+var MAX_PROCESS_OUTPUT_BYTES = 16 * 1024 * 1024;
+function parseAuthCapsuleDescriptor(value) {
+  rejectCredentialFields(value, "auth capsule descriptor");
+  const input = closedObject(value, "auth capsule descriptor", DESCRIPTOR_FIELDS);
+  return deepFreeze({
+    schema_version: enumValue(input.schema_version, "descriptor.schema_version", [AUTH_CAPSULE_DESCRIPTOR_SCHEMA_VERSION]),
+    auth_capsule_id: identifier(input.auth_capsule_id, "descriptor.auth_capsule_id"),
+    owner_ref: identifier(input.owner_ref, "descriptor.owner_ref"),
+    provider_key: identifier(input.provider_key, "descriptor.provider_key"),
+    provider_subject_ref: identifier(input.provider_subject_ref, "descriptor.provider_subject_ref"),
+    capacity_domain_ref: identifier(input.capacity_domain_ref, "descriptor.capacity_domain_ref"),
+    account_lane_id: identifier(input.account_lane_id, "descriptor.account_lane_id"),
+    canonical_node_id: identifier(input.canonical_node_id, "descriptor.canonical_node_id"),
+    node_key_thumbprint: digest(input.node_key_thumbprint, "descriptor.node_key_thumbprint"),
+    node_generation: positiveCounter(input.node_generation, "descriptor.node_generation"),
+    placement_generation: positiveCounter(input.placement_generation, "descriptor.placement_generation"),
+    auth_generation: positiveCounter(input.auth_generation, "descriptor.auth_generation"),
+    auth_state_revision: positiveCounter(input.auth_state_revision, "descriptor.auth_state_revision"),
+    accounts_revision_set_digest: digest(input.accounts_revision_set_digest, "descriptor.accounts_revision_set_digest"),
+    capsule_attestation_digest: digest(input.capsule_attestation_digest, "descriptor.capsule_attestation_digest"),
+    local_profile_ref: identifier(input.local_profile_ref, "descriptor.local_profile_ref"),
+    codewith_binary_sha256: digest(input.codewith_binary_sha256, "descriptor.codewith_binary_sha256"),
+    runtime_policy_sha256: digest(input.runtime_policy_sha256, "descriptor.runtime_policy_sha256"),
+    infinity_agent_policy_sha256: digest(input.infinity_agent_policy_sha256, "descriptor.infinity_agent_policy_sha256")
+  });
+}
+function parseCapsuleRemoteToolBinding(value) {
+  rejectCredentialFields(value, "capsule remote-tool binding");
+  const input = closedObject(value, "capsule remote-tool binding", BINDING_FIELDS);
+  const fence = parseBrokerFence(input.fence);
+  const parsed = deepFreeze({
+    schema_version: enumValue(input.schema_version, "binding.schema_version", [CAPSULE_REMOTE_TOOL_BINDING_SCHEMA_VERSION]),
+    dispatch_id: identifier(input.dispatch_id, "binding.dispatch_id"),
+    canonical_intent_sha256: digest(input.canonical_intent_sha256, "binding.canonical_intent_sha256"),
+    sandbox_prepare_anchor_sha256: digest(input.sandbox_prepare_anchor_sha256, "binding.sandbox_prepare_anchor_sha256"),
+    authority_envelope_sha256: digest(input.authority_envelope_sha256, "binding.authority_envelope_sha256"),
+    effect_claim_sha256: digest(input.effect_claim_sha256, "binding.effect_claim_sha256"),
+    operation_digest: digest(input.operation_digest, "binding.operation_digest"),
+    provider: enumValue(input.provider, "binding.provider", ["e2b", "daytona"]),
+    source_manifest_sha256: digest(input.source_manifest_sha256, "binding.source_manifest_sha256"),
+    input_manifest_sha256: digest(input.input_manifest_sha256, "binding.input_manifest_sha256"),
+    checkpoint_policy_sha256: digest(input.checkpoint_policy_sha256, "binding.checkpoint_policy_sha256"),
+    fence
+  });
+  if (parsed.operation_digest !== parsed.fence.operation_digest) {
+    throw new InfinityError("capability_denied", "remote-tool operation digest does not match the full broker fence", { status: 403 });
+  }
+  if (parsed.fence.audience !== "capsule-remote-tool") {
+    throw new InfinityError("capability_denied", "remote-tool fence has the wrong audience", { status: 403 });
+  }
+  return parsed;
+}
+
+class LocalCodewithAuthCapsuleLauncher {
+  #registry;
+  #authority;
+  #bridge;
+  constructor(dependencies) {
+    this.#registry = dependencies.registry;
+    this.#authority = dependencies.authority;
+    this.#bridge = dependencies.bridge;
+  }
+  async launch(request) {
+    const descriptor = parseAuthCapsuleDescriptor(request.descriptor);
+    const binding = parseCapsuleRemoteToolBinding(request.binding);
+    const prompt = parsePrompt(request.prompt);
+    if (descriptor.owner_ref !== binding.fence.actor_principal) {
+      throw new InfinityError("capability_denied", "AuthCapsule owner does not match the run actor", { status: 403 });
+    }
+    if (binding.fence.lease_holder_principal !== binding.fence.operation_executor_principal) {
+      throw new InfinityError("capability_denied", "capsule host must hold both the attempt lease and operation execution fence", { status: 403 });
+    }
+    const profile = await this.#registry.resolve(descriptor);
+    let policy;
+    try {
+      policy = await assertTrustedLocalProfile(profile, descriptor);
+    } catch (error) {
+      if (error instanceof InfinityError)
+        throw error;
+      throw untrustedProfile("local profile path or attested artifact is unavailable");
+    }
+    await probeNativeInfinityAgentPolicy(profile);
+    await this.#authority.assertCurrent({ descriptor, binding });
+    const bridgeSession = await this.#bridge.open({ descriptor, binding, policy });
+    try {
+      const argv = [
+        profile.executable_path,
+        "exec",
+        "--auth-profile",
+        profile.auth_profile_name,
+        "--profile",
+        profile.runtime_profile_name,
+        "--strict-config",
+        "-a",
+        "never",
+        "-c",
+        'tools.policy="infinity-agent"',
+        "--sandbox",
+        "read-only",
+        "--ignore-user-config",
+        "--ignore-rules",
+        "--disable",
+        "hooks",
+        "--disable",
+        "multi_agent",
+        "--disable",
+        "scheduled_tasks",
+        "--disable",
+        "apps",
+        "--disable",
+        "browser_use",
+        "--disable",
+        "browser_use_external",
+        "--disable",
+        "computer_use",
+        "--disable",
+        "image_generation",
+        "--disable",
+        "memories",
+        "--disable",
+        "mailbox_dispatcher",
+        "--disable",
+        "workflows",
+        "--disable",
+        "shell_snapshot",
+        "--ephemeral",
+        "--json",
+        "--skip-git-repo-check",
+        "-C",
+        profile.empty_workspace_path,
+        "-"
+      ];
+      const subprocess = Bun.spawn(argv, {
+        cwd: profile.empty_workspace_path,
+        env: closedCodewithEnvironment(profile.codewith_home),
+        stdin: "pipe",
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      subprocess.stdin.write(`${prompt}
+`);
+      subprocess.stdin.end();
+      const [exitCode, stdout, stderr] = await Promise.all([
+        subprocess.exited,
+        readBoundedText(subprocess.stdout, "Codewith stdout"),
+        readBoundedText(subprocess.stderr, "Codewith stderr")
+      ]);
+      return deepFreeze({
+        schema_version: "infinity.codewith-auth-capsule-result.v1",
+        exit_code: exitCode,
+        stdout,
+        stderr,
+        descriptor_sha256: digestCanonical(descriptor),
+        binding_sha256: digestCanonical(binding)
+      });
+    } finally {
+      await bridgeSession.close();
+    }
+  }
+}
+function rejectCredentialFields(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return;
+  for (const key of Object.keys(value)) {
+    if (FORBIDDEN_CREDENTIAL_FIELD.test(key)) {
+      throw new InfinityError("invalid_input", `${label} contains credential material or a credential carrier field`);
+    }
+  }
+}
+function positiveCounter(value, label) {
+  const parsed = stringValue(value, label, { max: 20, pattern: /^[1-9][0-9]*$/ });
+  if (BigInt(parsed) > 9223372036854775807n) {
+    throw new InfinityError("invalid_input", `${label} exceeds signed int64`);
+  }
+  return parsed;
+}
+function parsePrompt(value) {
+  const parsed = stringValue(value, "Codewith prompt", { max: MAX_PROMPT_BYTES });
+  if (parsed.includes("\x00"))
+    throw new InfinityError("invalid_input", "Codewith prompt must not contain NUL");
+  if (new TextEncoder().encode(parsed).byteLength > MAX_PROMPT_BYTES) {
+    throw new InfinityError("invalid_input", "Codewith prompt is too large");
+  }
+  return parsed;
+}
+async function assertTrustedLocalProfile(profile, descriptor) {
+  const paths = [profile.executable_path, profile.codewith_home, profile.empty_workspace_path, profile.infinity_agent_policy_path];
+  if (!paths.every(isAbsolute))
+    throw new InfinityError("capability_denied", "trusted local profile paths must be absolute", { status: 403 });
+  identifier(profile.auth_profile_name, "Codewith auth profile name");
+  if (profile.runtime_profile_name !== "infinity-agent") {
+    throw new InfinityError("capability_denied", "Codewith runtime profile must be infinity-agent", { status: 403 });
+  }
+  const executableStat = await lstat(profile.executable_path);
+  const homeStat = await lstat(profile.codewith_home);
+  const workspaceStat = await lstat(profile.empty_workspace_path);
+  const agentPolicyStat = await lstat(profile.infinity_agent_policy_path);
+  if (!executableStat.isFile() || executableStat.isSymbolicLink())
+    throw untrustedProfile("Codewith executable");
+  if (!homeStat.isDirectory() || homeStat.isSymbolicLink())
+    throw untrustedProfile("Codewith home");
+  if (!workspaceStat.isDirectory() || workspaceStat.isSymbolicLink())
+    throw untrustedProfile("empty workspace");
+  if (!agentPolicyStat.isFile() || agentPolicyStat.isSymbolicLink() || agentPolicyStat.size > 64 * 1024) {
+    throw untrustedProfile("infinity-agent policy");
+  }
+  if ((await readdir(profile.empty_workspace_path)).length !== 0) {
+    throw untrustedProfile("local Codewith workspace is not empty");
+  }
+  const [realHome, realWorkspace, realAgentPolicy] = await Promise.all([
+    realpath(profile.codewith_home),
+    realpath(profile.empty_workspace_path),
+    realpath(profile.infinity_agent_policy_path)
+  ]);
+  if (containsPath(realHome, realWorkspace) || containsPath(realWorkspace, realHome)) {
+    throw untrustedProfile("Codewith credential home and empty workspace overlap");
+  }
+  if (!containsPath(realHome, realAgentPolicy))
+    throw untrustedProfile("infinity-agent policy escapes Codewith home");
+  const policyPath = join2(realHome, `${profile.runtime_profile_name}.config.toml`);
+  const authProfilePath = join2(realHome, "auth_profiles", profile.auth_profile_name);
+  const [policyStat, authProfileStat] = await Promise.all([lstat(policyPath), lstat(authProfilePath)]);
+  if (!policyStat.isFile() || policyStat.isSymbolicLink())
+    throw untrustedProfile("runtime policy");
+  if (!authProfileStat.isDirectory() || authProfileStat.isSymbolicLink())
+    throw untrustedProfile("auth profile");
+  const realAuthProfile = await realpath(authProfilePath);
+  if (!containsPath(realHome, realAuthProfile))
+    throw untrustedProfile("auth profile escapes Codewith home");
+  const [binaryDigest, policyDigest] = await Promise.all([fileDigest(profile.executable_path), fileDigest(policyPath)]);
+  if (binaryDigest !== descriptor.codewith_binary_sha256 || policyDigest !== descriptor.runtime_policy_sha256) {
+    throw untrustedProfile("Codewith binary or infinity-agent policy attestation digest mismatch");
+  }
+  if (profile.codewith_binary_sha256 !== undefined && profile.codewith_binary_sha256 !== binaryDigest) {
+    throw untrustedProfile("registry Codewith binary attestation digest mismatch");
+  }
+  if (profile.runtime_policy_sha256 !== undefined && profile.runtime_policy_sha256 !== policyDigest) {
+    throw untrustedProfile("registry runtime policy attestation digest mismatch");
+  }
+  const policyText = await readFile(realAgentPolicy, "utf8");
+  const agentPolicy = parseInfinityAgentPolicy(parseStrictJson(policyText));
+  if (canonicalJson(agentPolicy) !== policyText)
+    throw untrustedProfile("infinity-agent policy is not canonical JSON");
+  const agentPolicyDigest = infinityAgentPolicyDigest(agentPolicy);
+  if (agentPolicyDigest !== descriptor.infinity_agent_policy_sha256) {
+    throw untrustedProfile("infinity-agent policy attestation digest mismatch");
+  }
+  if (profile.infinity_agent_policy_sha256 !== undefined && profile.infinity_agent_policy_sha256 !== agentPolicyDigest) {
+    throw untrustedProfile("registry infinity-agent policy attestation digest mismatch");
+  }
+  return agentPolicy;
+}
+async function probeNativeInfinityAgentPolicy(profile) {
+  const subprocess = Bun.spawn([
+    profile.executable_path,
+    "debug",
+    "auth-capsule-policy",
+    "--format",
+    "json"
+  ], {
+    cwd: profile.empty_workspace_path,
+    env: closedCodewithEnvironment(profile.codewith_home),
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [exitCode, stdout] = await Promise.all([
+    subprocess.exited,
+    readBoundedText(subprocess.stdout, "Codewith capability probe stdout"),
+    readBoundedText(subprocess.stderr, "Codewith capability probe stderr")
+  ]);
+  if (exitCode !== 0)
+    throw unsupportedNativePolicy();
+  let document;
+  try {
+    document = parseStrictJson(stdout.trim());
+    const input = closedObject(document, "Codewith AuthCapsule capability probe", [
+      "schema_version",
+      "native_policy_enforcement",
+      "host_filesystem_tools",
+      "host_shell_tools",
+      "auth_profile_control",
+      "protected_remote_tool_bridge"
+    ]);
+    if (input.schema_version !== "codewith.auth-capsule-policy-capabilities/v1" || input.native_policy_enforcement !== true || input.host_filesystem_tools !== false || input.host_shell_tools !== false || input.auth_profile_control !== false || input.protected_remote_tool_bridge !== true) {
+      throw unsupportedNativePolicy();
+    }
+  } catch (error) {
+    if (error instanceof InfinityError && error.message.includes("native infinity-agent"))
+      throw error;
+    throw unsupportedNativePolicy();
+  }
+}
+function unsupportedNativePolicy() {
+  return new InfinityError("capability_denied", "Codewith capability probe did not prove native infinity-agent enforcement; subscription launch refused", { status: 403 });
+}
+function containsPath(parent, candidate) {
+  const path = relative(parent, candidate);
+  return path === "" || !path.startsWith(`..${sep}`) && path !== ".." && !isAbsolute(path);
+}
+async function fileDigest(path) {
+  return `sha256:${createHash2("sha256").update(await readFile(path)).digest("hex")}`;
+}
+function untrustedProfile(reason) {
+  return new InfinityError("capability_denied", `trusted local profile attestation failed: ${reason}`, { status: 403 });
+}
+function closedCodewithEnvironment(codewithHome) {
+  return {
+    CODEWITH_HOME: codewithHome,
+    HOME: codewithHome,
+    LANG: "C.UTF-8",
+    LC_ALL: "C.UTF-8",
+    NO_COLOR: "1",
+    PATH: "/usr/bin:/bin"
+  };
+}
+async function readBoundedText(stream, label) {
+  const reader = stream.getReader();
+  const chunks = [];
+  let size = 0;
+  while (true) {
+    const next = await reader.read();
+    if (next.done)
+      break;
+    size += next.value.byteLength;
+    if (size > MAX_PROCESS_OUTPUT_BYTES) {
+      await reader.cancel();
+      throw new InfinityError("state_conflict", `${label} exceeded the bounded capture limit`, { status: 502 });
+    }
+    chunks.push(next.value);
+  }
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    throw new InfinityError("state_conflict", `${label} was not valid UTF-8`, { status: 502 });
+  }
+}
+
+// src/cli/run.ts
+async function runCli(argv, runtime) {
+  try {
+    const args = [...argv];
+    consumeGlobalOutput(args);
+    const group = args.shift();
+    if (!group)
+      throw new CliUsageError("a command is required");
+    let envelope;
+    if (group === "version") {
+      requireNoArguments(args, "version");
+      envelope = await runtime.client.version();
+      if (envelope.ok && isRecord(envelope.data)) {
+        envelope = inheritOperatorEnvelopeHttpStatus(envelope, {
+          ...envelope,
+          data: { ...envelope.data, client_version: "0.1.0" }
+        });
+      } else if (envelope.ok) {
+        throw new InfinityError("protocol_incompatible", "Infinity version success data must be an object", { status: 502 });
+      }
+    } else if (group === "doctor") {
+      requireNoArguments(args, "doctor");
+      envelope = await runtime.client.doctor();
+    } else if (group === "capability") {
+      const verb = args.shift();
+      if (verb !== "list")
+        throw new CliUsageError("capability supports only list");
+      requireNoArguments(args, "capability list");
+      envelope = await runtime.client.listCapabilities();
+    } else if (group === "run") {
+      envelope = await runCommand(args, runtime);
+    } else if (group === "operation") {
+      envelope = await operationCommand(args, runtime);
+    } else if (group === "auth-capsule") {
+      envelope = await authCapsuleCommand(args, runtime);
+    } else if (group === "sandbox") {
+      envelope = await sandboxCommand(args, runtime);
+    } else {
+      throw new CliUsageError("unknown command");
+    }
+    runtime.writeStdout(`${canonicalJson(envelope)}
+`);
+    return envelope.ok ? 0 : exitCodeFor(envelope.error?.code ?? "internal_error", envelope.error?.retryable ?? false, operatorEnvelopeHttpStatus(envelope));
+  } catch (error) {
+    const envelope = localFailure(error, runtime.now());
+    runtime.writeStdout(`${canonicalJson(envelope)}
+`);
+    const status = error instanceof InfinityError ? error.status : undefined;
+    return exitCodeFor(envelope.error?.code ?? "internal_error", envelope.error?.retryable ?? false, status);
+  }
+}
+async function sandboxCommand(args, runtime) {
+  if (args.shift() !== "dispatch") {
+    throw new CliUsageError("sandbox supports only dispatch authorize or dispatch production");
+  }
+  const verb = args.shift();
+  if (verb !== "authorize" && verb !== "production") {
+    throw new CliUsageError("sandbox supports only dispatch authorize or dispatch production");
+  }
+  const parsed = parseFlags(args, new Set(["--spec"]), 0);
+  const document = parseStrictJson(await runtime.readInput(requiredFlag(parsed, "--spec")));
+  if (verb === "authorize")
+    return runtime.client.authorizeSandboxDispatch(document);
+  return runtime.client.dispatchProductionSandbox(document);
+}
+async function authCapsuleCommand(args, runtime) {
+  const noun = args.shift();
+  if (noun !== "descriptor" && noun !== "binding") {
+    throw new CliUsageError("auth-capsule supports only descriptor or binding validation");
+  }
+  const parsed = parseFlags(args, new Set(["--spec"]), 0);
+  const document = parseStrictJson(await runtime.readInput(requiredFlag(parsed, "--spec")));
+  const data = noun === "descriptor" ? parseAuthCapsuleDescriptor(document) : parseCapsuleRemoteToolBinding(document);
+  return {
+    schema_version: "infinity.operator/v1",
+    ok: true,
+    request_id: "request-local",
+    command: `auth-capsule.${noun}.validate`,
+    server_time: runtime.now().toISOString(),
+    data,
+    warnings: [],
+    next_actions: []
+  };
+}
+async function runCommand(args, runtime) {
+  const verb = args.shift();
+  if (!verb)
+    throw new CliUsageError("run command requires a verb");
+  if (verb === "validate" || verb === "plan") {
+    const parsed = parseFlags(args, new Set(["--spec"]), 0);
+    const selector = requiredFlag(parsed, "--spec");
+    const spec = parseStrictJson(await runtime.readInput(selector));
+    return verb === "validate" ? runtime.client.validateRun(spec) : runtime.client.planRun(spec);
+  }
+  if (verb === "submit") {
+    const parsed = parseFlags(args, new Set([
+      "--spec",
+      "--idempotency-key",
+      "--authority-epoch",
+      "--route-lineage-id",
+      "--route-id",
+      "--route-epoch"
+    ]), 0);
+    const spec = parseRunSpec(parseStrictJson(await runtime.readInput(requiredFlag(parsed, "--spec"))));
+    const request = {
+      spec,
+      idempotencyKey: requiredFlag(parsed, "--idempotency-key"),
+      authorityEpoch: int64Flag(parsed, "--authority-epoch"),
+      routeLineageId: requiredFlag(parsed, "--route-lineage-id"),
+      routeId: requiredFlag(parsed, "--route-id"),
+      routeEpoch: int64Flag(parsed, "--route-epoch")
+    };
+    const tuple = submitRunMutationTuple({
+      spec,
+      routeLineageId: request.routeLineageId,
+      routeId: request.routeId,
+      routeEpoch: request.routeEpoch
+    });
+    const authorityRequestHash = mutationRequestHash({
+      command: "run.submit",
+      scope: tuple.scope,
+      request: tuple.request,
+      authorityEpoch: request.authorityEpoch,
+      idempotencyKey: request.idempotencyKey
+    });
+    return dispatchMutation(runtime, {
+      command: "run.submit",
+      idempotencyKey: request.idempotencyKey,
+      scope: tuple.scope,
+      request: {
+        authority_epoch: request.authorityEpoch,
+        route_lineage_id: request.routeLineageId,
+        route_id: request.routeId,
+        route_epoch: request.routeEpoch,
+        spec
+      },
+      authorityRequestHash,
+      resultExpectation: {
+        command: "run.submit",
+        run_spec_digest: runSpecDigest(spec),
+        authority_epoch: request.authorityEpoch,
+        route_epoch: request.routeEpoch
+      }
+    }, (operationId) => runtime.client.submitRun({ ...request, operationId }));
+  }
+  if (verb === "get") {
+    const parsed = parseFlags(args, new Set, 1);
+    return runtime.client.getRun(parsed.positional[0]);
+  }
+  if (verb === "list") {
+    const parsed = parseFlags(args, new Set(["--limit", "--cursor"]), 0);
+    const limit = parsed.flags.has("--limit") ? integerFlag(parsed, "--limit", false, 100) : undefined;
+    const cursor = parsed.flags.get("--cursor");
+    return runtime.client.listRuns({ ...limit === undefined ? {} : { limit }, ...cursor === undefined ? {} : { cursor } });
+  }
+  if (verb === "wait") {
+    const parsed = parseFlags(args, new Set(["--timeout-ms"]), 1);
+    return runtime.client.waitRun(parsed.positional[0], integerFlag(parsed, "--timeout-ms", true, 30000));
+  }
+  if (verb === "attach") {
+    const parsed = parseFlags(args, new Set(["--cursor", "--limit", "--wait-ms"]), 1);
+    const cursor = String(integerFlag(parsed, "--cursor", true));
+    const limit = integerFlag(parsed, "--limit", false, 100);
+    const waitMs = integerFlag(parsed, "--wait-ms", true, 30000);
+    return runtime.client.readRunEvents(parsed.positional[0], { cursor, limit, waitMs });
+  }
+  if (verb === "cancel") {
+    const parsed = parseFlags(args, new Set([
+      "--idempotency-key",
+      "--authority-epoch",
+      "--if-revision",
+      "--attempt-id",
+      "--if-attempt-number",
+      "--if-attempt-revision",
+      "--attempt-lease-id",
+      "--lease-epoch",
+      "--reason-code"
+    ]), 1);
+    const leaseSelector = optionalLeaseSelectorFlags(parsed);
+    const request = {
+      runId: parsed.positional[0],
+      idempotencyKey: requiredFlag(parsed, "--idempotency-key"),
+      authorityEpoch: int64Flag(parsed, "--authority-epoch"),
+      ifRevision: integerFlag(parsed, "--if-revision", false, MAX_MUTABLE_IF_REVISION),
+      attemptId: requiredFlag(parsed, "--attempt-id"),
+      expectedAttemptNumber: integerFlag(parsed, "--if-attempt-number", false, MAX_POSTGRES_INTEGER),
+      expectedAttemptRevision: integerFlag(parsed, "--if-attempt-revision", false, MAX_MUTABLE_IF_REVISION),
+      ...leaseSelector,
+      reasonCode: requiredFlag(parsed, "--reason-code")
+    };
+    return dispatchMutation(runtime, mutationIntent("run.cancel", request), (operationId) => runtime.client.cancelRun({ ...request, operationId }));
+  }
+  if (verb === "retry") {
+    const parsed = parseFlags(args, new Set([
+      "--idempotency-key",
+      "--authority-epoch",
+      "--if-revision",
+      "--attempt-id",
+      "--if-attempt-number",
+      "--if-attempt-revision",
+      "--attempt-lease-id",
+      "--lease-epoch"
+    ]), 1);
+    const leaseSelector = optionalLeaseSelectorFlags(parsed);
+    const request = {
+      runId: parsed.positional[0],
+      idempotencyKey: requiredFlag(parsed, "--idempotency-key"),
+      authorityEpoch: int64Flag(parsed, "--authority-epoch"),
+      ifRevision: integerFlag(parsed, "--if-revision", false, MAX_MUTABLE_IF_REVISION),
+      attemptId: requiredFlag(parsed, "--attempt-id"),
+      expectedAttemptNumber: integerFlag(parsed, "--if-attempt-number", false, MAX_MUTABLE_IF_REVISION),
+      expectedAttemptRevision: integerFlag(parsed, "--if-attempt-revision", false, MAX_POSTGRES_INTEGER),
+      ...leaseSelector
+    };
+    return dispatchMutation(runtime, mutationIntent("run.retry", request), (operationId) => runtime.client.retryRun({ ...request, operationId }));
+  }
+  throw new CliUsageError("unknown run verb");
+}
+async function dispatchMutation(runtime, intent, dispatch) {
+  const prepared = await runtime.operationJournal.prepare(intent);
+  let correlated;
+  try {
+    const envelope = await dispatch(prepared.operationId);
+    correlated = envelope;
+    if (envelope.operation_id === undefined) {
+      if (!isOperatorPreReservationFailure(envelope)) {
+        throw new InfinityError("integrity_failure", "Infinity mutation response omitted its protected operation ID", { status: 502 });
+      }
+      correlated = inheritOperatorEnvelopeHttpStatus(envelope, { ...envelope, operation_id: prepared.operationId });
+    }
+    if (correlated.command !== prepared.command || correlated.operation_id !== prepared.operationId) {
+      throw new InfinityError("integrity_failure", "Infinity mutation response correlation does not match the protected operation", { status: 502 });
+    }
+    if (correlated.ok) {
+      if (!isPublicMutationCommand(prepared.command)) {
+        throw new InfinityError("protocol_incompatible", "CLI prepared an unsupported public mutation command", { status: 502 });
+      }
+      parsePublicMutationResult(prepared.command, correlated.data, prepared.operationId, prepared.resultExpectation);
+    }
+  } catch (error) {
+    throw new AmbiguousMutationDispatchError(prepared.command, prepared.operationId, error);
+  }
+  await recordProtectedMutationResponse(runtime, prepared.command, prepared.operationId, correlated);
+  return correlated;
+}
+async function recordProtectedMutationResponse(runtime, command, operationId, envelope) {
+  try {
+    await runtime.operationJournal.recordResponse(operationId, envelope);
+  } catch (error) {
+    if (error instanceof InfinityError && error.code === "integrity_failure")
+      throw error;
+    throw new AmbiguousMutationDispatchError(command, operationId, error);
+  }
+}
+function mutationIntent(command, request) {
+  const scope = { run_id: request.runId, attempt_id: request.attemptId };
+  const authorityRequest = {
+    expected_run_revision: request.ifRevision,
+    expected_attempt_number: request.expectedAttemptNumber,
+    expected_attempt_revision: request.expectedAttemptRevision,
+    ...request.attemptLeaseId === undefined ? {} : {
+      attempt_lease_id: request.attemptLeaseId,
+      lease_epoch: request.leaseEpoch
+    },
+    ...request.reasonCode === undefined ? {} : { reason_code: request.reasonCode }
+  };
+  return {
+    command,
+    idempotencyKey: request.idempotencyKey,
+    scope,
+    request: {
+      authority_epoch: request.authorityEpoch,
+      if_revision: request.ifRevision,
+      attempt_id: request.attemptId,
+      if_attempt_number: request.expectedAttemptNumber,
+      if_attempt_revision: request.expectedAttemptRevision,
+      ...request.attemptLeaseId === undefined ? {} : {
+        attempt_lease_id: request.attemptLeaseId,
+        lease_epoch: request.leaseEpoch
+      },
+      ...request.reasonCode === undefined ? {} : { reason_code: request.reasonCode }
+    },
+    authorityRequestHash: mutationRequestHash({
+      command,
+      scope,
+      request: authorityRequest,
+      authorityEpoch: request.authorityEpoch,
+      idempotencyKey: request.idempotencyKey
+    }),
+    resultExpectation: command === "run.cancel" ? {
+      command,
+      run_id: request.runId,
+      attempt_id: request.attemptId,
+      attempt_number: request.expectedAttemptNumber,
+      expected_run_revision: nextExpectedRunRevision2(request.ifRevision),
+      expected_attempt_revision: nextExpectedAttemptRevision2(request.expectedAttemptRevision),
+      recovery_lease_duration_ms: CANCEL_RECOVERY_LEASE_DURATION_MS,
+      prior_lease: request.attemptLeaseId === undefined ? { state: "none" } : {
+        state: "selected",
+        attempt_lease_id: request.attemptLeaseId,
+        lease_epoch: request.leaseEpoch
+      }
+    } : {
+      command,
+      run_id: request.runId,
+      predecessor_attempt_id: request.attemptId,
+      expected_attempt_number: nextExpectedAttemptNumber2(request.expectedAttemptNumber),
+      expected_run_revision: nextExpectedRunRevision2(request.ifRevision)
+    }
+  };
+}
+function nextExpectedRunRevision2(value) {
+  if (!Number.isSafeInteger(value) || value <= 0 || value > MAX_MUTABLE_IF_REVISION) {
+    throw new CliUsageError("--if-revision cannot be incremented within the safe revision range");
+  }
+  return value + 1;
+}
+function nextExpectedAttemptRevision2(value) {
+  if (!Number.isSafeInteger(value) || value <= 0 || value > MAX_MUTABLE_IF_REVISION) {
+    throw new CliUsageError("--if-attempt-revision cannot be incremented within the PostgreSQL integer range");
+  }
+  return value + 1;
+}
+function nextExpectedAttemptNumber2(value) {
+  if (!Number.isSafeInteger(value) || value <= 0 || value > MAX_MUTABLE_IF_REVISION) {
+    throw new CliUsageError("--if-attempt-number cannot be incremented within the PostgreSQL integer range");
+  }
+  return value + 1;
+}
+async function operationCommand(args, runtime) {
+  const verb = args.shift();
+  if (verb !== "resolve")
+    throw new CliUsageError("operation supports only resolve");
+  const parsed = parseFlags(args, new Set, 1);
+  const prepared = runtime.operationJournal.read(parsed.positional[0]);
+  const envelope = await runtime.client.resolveOperation(prepared.operationId);
+  if (envelope.ok) {
+    const resolution = parsePublicOperationResolution(envelope.data, prepared.operationId, prepared.resultExpectation);
+    if (resolution.status !== "unknown") {
+      const binding = resolution.operation_binding;
+      if (binding.command !== prepared.command || binding.idempotency_key !== prepared.idempotencyKey || binding.scope_digest !== prepared.scopeDigest || binding.request_hash !== prepared.authorityRequestHash) {
+        throw new InfinityError("integrity_failure", "Infinity resolution tuple does not match the protected local operation", { status: 502 });
+      }
+    }
+    if (resolution.status === "committed") {
+      if (prepared.state === "responded") {
+        const resolvedDigest = successfulMutationConsequenceDigest(prepared.command, prepared.operationId, resolution.result, prepared.resultExpectation);
+        if (resolvedDigest !== prepared.responseDigest) {
+          throw new InfinityError("integrity_failure", "Infinity committed resolution conflicts with the locally observed success", { status: 502 });
+        }
+      }
+      const mutationEnvelope = inheritOperatorEnvelopeHttpStatus(envelope, {
+        ...envelope,
+        command: prepared.command,
+        operation_id: prepared.operationId,
+        data: resolution.result
+      });
+      await recordProtectedMutationResponse(runtime, prepared.command, prepared.operationId, mutationEnvelope);
+    }
+  }
+  return envelope;
+}
+function consumeGlobalOutput(args) {
+  if (args[0] !== "--output")
+    return "json";
+  args.shift();
+  const value = args.shift();
+  if (value !== "json" && value !== "jsonl")
+    throw new CliUsageError("--output must be json or jsonl");
+  return value;
+}
+function parseFlags(args, allowed, positionalCount) {
+  const positional = [];
+  const flags = new Map;
+  for (let index = 0;index < args.length; index += 1) {
+    const token = args[index];
+    if (!token.startsWith("--")) {
+      positional.push(token);
+      continue;
+    }
+    if (!allowed.has(token))
+      throw new CliUsageError("unsupported option");
+    if (flags.has(token))
+      throw new CliUsageError(`duplicate option ${token}`);
+    const value = args[index + 1];
+    if (value === undefined || value.startsWith("--"))
+      throw new CliUsageError(`${token} requires a value`);
+    flags.set(token, value);
+    index += 1;
+  }
+  if (positional.length !== positionalCount)
+    throw new CliUsageError(`expected ${positionalCount} positional argument(s)`);
+  return { positional, flags };
+}
+function requiredFlag(parsed, name) {
+  const value = parsed.flags.get(name);
+  if (value === undefined)
+    throw new CliUsageError(`${name} is required`);
+  return value;
+}
+function integerFlag(parsed, name, allowZero, maximum = Number.MAX_SAFE_INTEGER) {
+  const value = requiredFlag(parsed, name);
+  const pattern = allowZero ? /^(?:0|[1-9]\d*)$/ : /^[1-9]\d*$/;
+  if (!pattern.test(value))
+    throw new CliUsageError(`${name} must be ${allowZero ? "a nonnegative" : "a positive"} integer`);
+  const number = Number(value);
+  if (!Number.isSafeInteger(number) || number > maximum)
+    throw new CliUsageError(`${name} is outside the allowed integer range`);
+  return number;
+}
+function int64Flag(parsed, name) {
+  const value = requiredFlag(parsed, name);
+  if (!/^[1-9]\d*$/.test(value))
+    throw new CliUsageError(`${name} must be a positive integer`);
+  try {
+    const parsedValue = BigInt(value);
+    return positiveInt64(parsedValue, name);
+  } catch {
+    throw new CliUsageError(`${name} is outside the signed 64-bit range`);
+  }
+}
+function optionalLeaseSelectorFlags(parsed) {
+  const hasAttemptLeaseId = parsed.flags.has("--attempt-lease-id");
+  const hasLeaseEpoch = parsed.flags.has("--lease-epoch");
+  if (hasAttemptLeaseId !== hasLeaseEpoch) {
+    throw new CliUsageError("--attempt-lease-id and --lease-epoch must be supplied together");
+  }
+  if (!hasAttemptLeaseId)
+    return {};
+  return {
+    attemptLeaseId: requiredFlag(parsed, "--attempt-lease-id"),
+    leaseEpoch: int64Flag(parsed, "--lease-epoch")
+  };
+}
+function requireNoArguments(args, command) {
+  if (args.length !== 0)
+    throw new CliUsageError(`${command} accepts no arguments`);
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function exitCodeFor(code, retryable, httpStatus) {
+  if (code === "operation_outcome_unknown")
+    return 10;
+  if (httpStatus === 503)
+    return 9;
+  if (code === "invalid_input")
+    return 2;
+  if (code === "not_found")
+    return 5;
+  if (["capability_denied", "policy_denied"].includes(code))
+    return 4;
+  if (["idempotency_key_reused", "operation_id_conflict", "logical_work_conflict", "authority_epoch_mismatch", "stale_revision", "stale_lease_epoch"].includes(code))
+    return 6;
+  if (code === "state_conflict" && httpStatus === 409)
+    return 6;
+  if (code === "state_conflict" && retryable)
+    return 9;
+  if (["state_conflict", "approval_required", "approval_digest_mismatch"].includes(code))
+    return 7;
+  if (code === "capacity_unavailable")
+    return 8;
+  if (code === "protocol_incompatible")
+    return 12;
+  if (code === "integrity_failure")
+    return 13;
+  return 14;
+}
+
+class AmbiguousMutationDispatchError extends Error {
+  command;
+  operationId;
+  original;
+  constructor(command, operationId, original) {
+    super(original instanceof Error ? original.message : "mutation dispatch failed after the operation was prepared", { cause: original });
+    this.command = command;
+    this.operationId = operationId;
+    this.original = original;
+    this.name = "AmbiguousMutationDispatchError";
+  }
+}
+
+class CliUsageError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CliUsageError";
+  }
+}
+function localFailure(error, now) {
+  const dispatch = error instanceof AmbiguousMutationDispatchError ? error : undefined;
+  const original = dispatch?.original ?? error;
+  const usage = original instanceof CliUsageError;
+  const known = original instanceof InfinityError;
+  const unknownOutcome = dispatch !== undefined;
+  const code = unknownOutcome ? "operation_outcome_unknown" : usage ? "invalid_input" : known ? original.code : "internal_error";
+  return {
+    schema_version: "infinity.operator/v1",
+    ok: false,
+    request_id: "request-local",
+    command: dispatch?.command ?? "local",
+    server_time: now.toISOString(),
+    ...dispatch === undefined ? {} : { operation_id: dispatch.operationId },
+    error: {
+      code,
+      message: unknownOutcome ? "Mutation dispatch outcome is unknown; resolve the protected operation ID before retrying." : original instanceof Error ? original.message : "Internal client error.",
+      retryable: unknownOutcome ? false : known ? original.retryable : false,
+      retry_after_ms: null,
+      details: known ? { ...original.details } : {},
+      remediation: unknownOutcome ? "Resolve the emitted protected operation ID before retrying." : usage || code === "invalid_input" ? "Correct the explicit command arguments." : code === "protocol_incompatible" || code === "integrity_failure" ? "Stop and verify the configured Infinity endpoint and schema." : "Contact the Infinity operator."
+    },
+    warnings: [],
+    next_actions: []
+  };
+}
+
+// src/cli/main.ts
+var LOCAL_OPERATOR_ENDPOINT = "http://127.0.0.1:18787";
+try {
+  const ids = new RandomIdFactory;
+  const clock = new SystemClock;
+  const operationJournal = new DurableCliOperationJournal(defaultCliOperationJournalPath(), ids, clock);
+  try {
+    process.exitCode = await runCli(Bun.argv.slice(2), {
+      client: new OperatorHttpClient(LOCAL_OPERATOR_ENDPOINT),
+      readInput: async (selector) => {
+        if (selector !== "-")
+          throw new CliUsageError("--spec accepts stdin ('-') only");
+        return Bun.stdin.text();
+      },
+      writeStdout: (value) => process.stdout.write(value),
+      writeStderr: (value) => process.stderr.write(value),
+      operationJournal,
+      now: () => clock.now()
+    });
+  } finally {
+    operationJournal.close();
+  }
+} catch (error) {
+  const usage = new CliUsageError(error instanceof Error ? error.message : "invalid CLI startup configuration");
+  process.stdout.write(`${canonicalJson(localFailure(usage, new Date))}
+`);
+  process.exitCode = 2;
+}
+export {
+  LOCAL_OPERATOR_ENDPOINT
+};