@elgora/cli 7.5.1 → 9.0.0

package/dist/cli.js

@@ -384,36 +384,107 @@ function isBountyChallengeFrontmatterKey(value) {
 }
 
 // ../../packages/core/src/bounty-publication-response.ts
-import { isHex as isHex2 } from "viem";
+import { isHex as isHex3 } from "viem";
+import { z as z3 } from "zod";
+
+// ../../packages/core/src/auth/readiness-signoff.ts
+import {
+  isAddressEqual,
+  isHex as isHex2,
+  recoverTypedDataAddress,
+  size as size2
+} from "viem";
 import { z as z2 } from "zod";
-var addressSchema = z2.string().refine(isHexAddress, "Must be a 20-byte EVM address").transform((value) => value);
-var bytes32Schema = z2.string().refine(isHexBytes32, "Must be a bytes32 hex string").transform((value) => value);
-var hexBytesSchema = z2.string().refine(isHex2, "Must be hex-encoded calldata").transform((value) => value);
-var bountyPublicationResponseSchema = z2.object({
-  content_record: z2.object({
-    content_kind: z2.literal("bounty_challenge_spec"),
-    spec_commitment: bytes32Schema,
-    byte_length: z2.number().int().positive(),
-    token_address: addressSchema,
-    created_at: z2.string().datetime({ offset: true })
-  }).strict(),
-  create_bounty_transaction: z2.object({
-    chain_id: z2.number().int().positive(),
+
+// ../../packages/core/src/auth/eip712.ts
+var API_REQUEST_APPROVAL_PRIMARY_TYPE = "ApiRequestApproval";
+var API_REQUEST_APPROVAL_TYPES = {
+  ApiRequestApproval: [
+    { name: "endpointId", type: "string" },
+    { name: "audience", type: "string" },
+    { name: "bodyHash", type: "bytes32" },
+    { name: "query", type: "string" },
+    { name: "blockNumber", type: "uint256" },
+    { name: "blockHash", type: "bytes32" }
+  ]
+};
+function buildElgoraEip712Domain(params) {
+  return {
+    name: "Elgora",
+    version: "1",
+    chainId: params.chainId,
+    verifyingContract: params.hubAddress
+  };
+}
+function buildApiRequestApprovalTypedData(params) {
+  return {
+    domain: buildElgoraEip712Domain({
+      chainId: params.chainId,
+      hubAddress: params.hubAddress
+    }),
+    types: API_REQUEST_APPROVAL_TYPES,
+    primaryType: API_REQUEST_APPROVAL_PRIMARY_TYPE,
+    message: params.message
+  };
+}
+function endpointIdFor(input) {
+  return `${input.method.toUpperCase()} ${input.path}`;
+}
+function audienceFor(host) {
+  return host.toLowerCase();
+}
+function queryFor(query) {
+  return new URLSearchParams(query).toString();
+}
+
+// ../../packages/core/src/auth/readiness-signoff.ts
+var READINESS_APPROVAL_VALIDITY_SECONDS = 7 * 24 * 60 * 60;
+var bytes32Schema = z2.string().refine(isHexBytes32).transform((value) => value);
+var timestampSchema = z2.number().int().nonnegative().max(9999999999);
+var readinessSignoffMessageSchema = z2.object({
+  audience: z2.string().min(1).max(512),
+  spec_commitment: bytes32Schema,
+  reviewer_hash: bytes32Schema,
+  model: z2.string().min(1).max(256),
+  issued_at: timestampSchema,
+  expires_at: timestampSchema
+}).strict();
+var signatureSchema = z2.string().refine((value) => isHex2(value) && size2(value) === 65).transform((value) => value);
+var readinessSignoffSchema = readinessSignoffMessageSchema.extend({ signature: signatureSchema }).refine((signoff) => signoff.expires_at > signoff.issued_at, {
+  path: ["expires_at"],
+  message: "Must expire after issuance"
+});
+
+// ../../packages/core/src/bounty-publication-response.ts
+var addressSchema = z3.string().refine(isHexAddress, "Must be a 20-byte EVM address").transform((value) => value);
+var bytes32Schema2 = z3.string().refine(isHexBytes32, "Must be a bytes32 hex string").transform((value) => value);
+var hexBytesSchema = z3.string().refine(isHex3, "Must be hex-encoded calldata").transform((value) => value);
+var bountyChallengeContentRecordSchema = z3.object({
+  content_kind: z3.literal("bounty_challenge_spec"),
+  spec_commitment: bytes32Schema2,
+  byte_length: z3.number().int().positive(),
+  token_address: addressSchema,
+  created_at: z3.string().datetime({ offset: true })
+}).strict();
+var bountyPublicationResponseSchema = z3.object({
+  content_record: bountyChallengeContentRecordSchema,
+  create_bounty_transaction: z3.object({
+    chain_id: z3.number().int().positive(),
     to: addressSchema,
-    value: z2.literal("0"),
+    value: z3.literal("0"),
     data: hexBytesSchema,
-    function_name: z2.literal("create_bounty"),
-    args: z2.object({
-      spec_commitment: bytes32Schema,
-      escrow_amount: z2.string().refine(isPositiveInteger),
-      submission_deadline: z2.number().int().positive()
+    function_name: z3.literal("create_bounty"),
+    args: z3.object({
+      spec_commitment: bytes32Schema2,
+      escrow_amount: z3.string().refine(isPositiveInteger),
+      submission_deadline: z3.number().int().positive()
     }).strict()
   }).strict(),
-  protocol_fee_policy: z2.object({
+  protocol_fee_policy: z3.object({
     treasury_recipient: addressSchema,
-    treasury_fee_bps: z2.number().int().min(0).max(1e4),
+    treasury_fee_bps: z3.number().int().min(0).max(1e4),
     guardian_fee_recipient: addressSchema,
-    guardian_fee_bps: z2.number().int().min(0).max(1e4)
+    guardian_fee_bps: z3.number().int().min(0).max(1e4)
   }).strict()
 }).strict().superRefine((response, context) => {
   if (response.content_record.spec_commitment !== response.create_bounty_transaction.args.spec_commitment) {
@@ -424,6 +495,28 @@ var bountyPublicationResponseSchema = z2.object({
     });
   }
 });
+var priorIssueSchema = z3.object({ anchor: z3.string().min(1), code: z3.string().min(1) }).strict();
+var bountyReviewResponseSchema = z3.object({
+  content_record: bountyChallengeContentRecordSchema,
+  readiness: z3.object({
+    decision: z3.literal("ready"),
+    signoff: readinessSignoffSchema,
+    prior_issues_resolved: z3.array(priorIssueSchema),
+    prior_issues_open: z3.array(priorIssueSchema)
+  }).strict()
+}).strict().superRefine((response, context) => {
+  if (response.readiness.signoff.spec_commitment.toLowerCase() !== response.content_record.spec_commitment.toLowerCase()) {
+    context.addIssue({
+      code: "custom",
+      path: ["readiness", "signoff", "spec_commitment"],
+      message: "Must match content_record.spec_commitment"
+    });
+  }
+});
+var readinessSignerResponseSchema = z3.object({
+  signer_address: addressSchema,
+  audience: z3.string().min(1)
+}).strict();
 
 // ../../packages/core/src/chain-registry.ts
 import { base, baseSepolia, foundry } from "viem/chains";
@@ -447,7 +540,7 @@ var FOUNDRY_CHAIN_ID = foundry.id;
 import { Aes256Gcm, CipherSuite, HkdfSha256 } from "@hpke/core";
 import { DhkemX25519HkdfSha256 } from "@hpke/dhkem-x25519";
 import { concatBytes, keccak256 as keccak2562, toBytes as toBytes2 } from "viem";
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // ../../packages/core/src/base64.ts
 var BASE64_ENCODE_CHUNK_BYTES = 3 * 16384;
@@ -533,42 +626,42 @@ var BASE64URL_RE = /^[A-Za-z0-9_-]+$/;
 var SOLVER_SUBMISSION_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 var MEDIA_TYPE_RE = /^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/;
 var KEY_ID_RE = /^[A-Za-z0-9][ -~]*$/;
-var base64UrlSchema = z3.string().regex(BASE64URL_RE);
-var lowerAddressSchema = z3.string().refine(isLowercaseHexAddress);
-var bytes32Schema2 = z3.string().refine(isLowercaseBytes32);
-var sha256HexSchema = z3.string().refine(isSha256Hex);
-var keyIdSchema = z3.string().min(1).max(128).regex(KEY_ID_RE);
-var artifactNameSchema = z3.string().max(
+var base64UrlSchema = z4.string().regex(BASE64URL_RE);
+var lowerAddressSchema = z4.string().refine(isLowercaseHexAddress);
+var bytes32Schema3 = z4.string().refine(isLowercaseBytes32);
+var sha256HexSchema = z4.string().refine(isSha256Hex);
+var keyIdSchema = z4.string().min(1).max(128).regex(KEY_ID_RE);
+var artifactNameSchema = z4.string().max(
   MAX_SOLVER_SUBMISSION_NAME_CHARACTERS,
   `Artifact filename exceeds ${MAX_SOLVER_SUBMISSION_NAME_CHARACTERS} ASCII characters (including extension). Solvers may shorten it only if the published challenge permits, before the deadline.`
 ).regex(SOLVER_SUBMISSION_NAME_RE);
-var mediaTypeSchema = z3.string().regex(MEDIA_TYPE_RE);
-var bountyIdSchema = z3.string().refine(isBountyId);
-var chainIdSchema = z3.number().int().positive().lte(Number.MAX_SAFE_INTEGER);
-var privateArtifactContextSchema = z3.strictObject({
-  type: z3.literal("solver_submission"),
+var mediaTypeSchema = z4.string().regex(MEDIA_TYPE_RE);
+var bountyIdSchema = z4.string().refine(isBountyId);
+var chainIdSchema = z4.number().int().positive().lte(Number.MAX_SAFE_INTEGER);
+var privateArtifactContextSchema = z4.strictObject({
+  type: z4.literal("solver_submission"),
   chain_id: chainIdSchema,
   hub_address: lowerAddressSchema,
   bounty_id: bountyIdSchema,
   actor_address: lowerAddressSchema
 });
-var guardianRecipientSchema = z3.strictObject({
+var guardianRecipientSchema = z4.strictObject({
   key_id: keyIdSchema,
-  suite: z3.literal(PRIVATE_ARTIFACT_HPKE_SUITE),
+  suite: z4.literal(PRIVATE_ARTIFACT_HPKE_SUITE),
   public_key: base64UrlSchema.length(
     43,
     "public_key must encode a 32-byte X25519 public key"
   )
 });
-var guardianRecipientPrivateKeySchema = z3.strictObject({
+var guardianRecipientPrivateKeySchema = z4.strictObject({
   key_id: keyIdSchema,
-  suite: z3.literal(PRIVATE_ARTIFACT_HPKE_SUITE),
+  suite: z4.literal(PRIVATE_ARTIFACT_HPKE_SUITE),
   private_key: base64UrlSchema.length(
     43,
     "private_key must encode a 32-byte X25519 private key"
   )
 });
-var guardianRecipientsSchema = z3.array(guardianRecipientSchema).min(1).superRefine((recipients, ctx) => {
+var guardianRecipientsSchema = z4.array(guardianRecipientSchema).min(1).superRefine((recipients, ctx) => {
   const seen = /* @__PURE__ */ new Set();
   for (const recipient of recipients) {
     if (seen.has(recipient.key_id)) {
@@ -581,24 +674,24 @@ var guardianRecipientsSchema = z3.array(guardianRecipientSchema).min(1).superRef
     seen.add(recipient.key_id);
   }
 });
-var guardianRecipientPrivateKeysSchema = z3.array(guardianRecipientPrivateKeySchema).min(1);
-var artifactManifestEntrySchema = z3.strictObject({
+var guardianRecipientPrivateKeysSchema = z4.array(guardianRecipientPrivateKeySchema).min(1);
+var artifactManifestEntrySchema = z4.strictObject({
   name: artifactNameSchema,
   media_type: mediaTypeSchema,
-  size_bytes: z3.number().int().nonnegative().lte(Number.MAX_SAFE_INTEGER),
+  size_bytes: z4.number().int().nonnegative().lte(Number.MAX_SAFE_INTEGER),
   sha256: sha256HexSchema
 });
-var privateArtifactPublicManifestSchema = z3.strictObject({
-  kind: z3.literal(PRIVATE_ARTIFACT_PUBLIC_MANIFEST_KIND),
+var privateArtifactPublicManifestSchema = z4.strictObject({
+  kind: z4.literal(PRIVATE_ARTIFACT_PUBLIC_MANIFEST_KIND),
   context: privateArtifactContextSchema
 });
 var encryptedBundleArtifactSchema = artifactManifestEntrySchema.extend({
   bytes: base64UrlSchema
 });
-var privateArtifactEncryptedBundleSchema = z3.strictObject({
-  kind: z3.literal(PRIVATE_ARTIFACT_ENCRYPTED_BUNDLE_KIND),
+var privateArtifactEncryptedBundleSchema = z4.strictObject({
+  kind: z4.literal(PRIVATE_ARTIFACT_ENCRYPTED_BUNDLE_KIND),
   context: privateArtifactContextSchema,
-  artifacts: z3.array(encryptedBundleArtifactSchema).min(1).max(
+  artifacts: z4.array(encryptedBundleArtifactSchema).min(1).max(
     MAX_SOLVER_SUBMISSION_FILES,
     `Submission exceeds the maximum of ${MAX_SOLVER_SUBMISSION_FILES} files.`
   ).refine(
@@ -606,33 +699,33 @@ var privateArtifactEncryptedBundleSchema = z3.strictObject({
     "artifact names must be unique case-insensitively"
   )
 });
-var privateArtifactRevealPolicySchema = z3.strictObject({
-  kind: z3.literal(PRIVATE_ARTIFACT_REVEAL_POLICY_KIND),
-  network: z3.string().min(1),
-  chain_hash: z3.string().min(1),
-  round: z3.string().refine(isPositiveInteger),
-  not_before: z3.number().int().nonnegative().lte(Number.MAX_SAFE_INTEGER)
+var privateArtifactRevealPolicySchema = z4.strictObject({
+  kind: z4.literal(PRIVATE_ARTIFACT_REVEAL_POLICY_KIND),
+  network: z4.string().min(1),
+  chain_hash: z4.string().min(1),
+  round: z4.string().refine(isPositiveInteger),
+  not_before: z4.number().int().nonnegative().lte(Number.MAX_SAFE_INTEGER)
 });
-var wrappedRecipientKeySchema = z3.strictObject({
+var wrappedRecipientKeySchema = z4.strictObject({
   key_id: keyIdSchema,
-  suite: z3.literal(PRIVATE_ARTIFACT_HPKE_SUITE),
+  suite: z4.literal(PRIVATE_ARTIFACT_HPKE_SUITE),
   enc: base64UrlSchema,
   ciphertext: base64UrlSchema
 });
-var wrappedKeyBagSchema = z3.strictObject({
-  kind: z3.literal(PRIVATE_ARTIFACT_WRAPPED_KEY_BAG_KIND),
-  keys: z3.array(wrappedRecipientKeySchema).min(1)
+var wrappedKeyBagSchema = z4.strictObject({
+  kind: z4.literal(PRIVATE_ARTIFACT_WRAPPED_KEY_BAG_KIND),
+  keys: z4.array(wrappedRecipientKeySchema).min(1)
 });
-var privateArtifactEnvelopeSchema = z3.strictObject({
-  kind: z3.literal(PRIVATE_ARTIFACT_ENVELOPE_KIND),
-  alg: z3.literal(SUBMISSION_ENCRYPTION_TYPE),
+var privateArtifactEnvelopeSchema = z4.strictObject({
+  kind: z4.literal(PRIVATE_ARTIFACT_ENVELOPE_KIND),
+  alg: z4.literal(SUBMISSION_ENCRYPTION_TYPE),
   context: privateArtifactContextSchema,
   public_manifest: privateArtifactPublicManifestSchema,
   public_manifest_sha256: sha256HexSchema,
   encrypted_bundle_sha256: sha256HexSchema,
   ciphertext_sha256: sha256HexSchema,
   guardian_recipients: guardianRecipientsSchema,
-  guardian_recipients_commitment: bytes32Schema2,
+  guardian_recipients_commitment: bytes32Schema3,
   reveal_policy: privateArtifactRevealPolicySchema,
   envelope_nonce: base64UrlSchema.length(
     22,
@@ -640,7 +733,7 @@ var privateArtifactEnvelopeSchema = z3.strictObject({
   ),
   iv: base64UrlSchema.length(16, "iv must encode 12 bytes"),
   wrapped_key_bag: base64UrlSchema,
-  ciphertext_locator: z3.string().min(1)
+  ciphertext_locator: z4.string().min(1)
 });
 function parsePrivateArtifactEnvelope(input) {
   return privateArtifactEnvelopeSchema.parse(input);
@@ -698,11 +791,11 @@ var x25519PrivateKeySchema = base64UrlSchema.length(
   43,
   "must encode a 32-byte X25519 private key"
 );
-var winningSolutionDeliveryContextSchema = z3.strictObject({
+var winningSolutionDeliveryContextSchema = z4.strictObject({
   chain_id: chainIdSchema,
   hub_address: lowerAddressSchema,
   bounty_id: bountyIdSchema,
-  submission_commitment: bytes32Schema2
+  submission_commitment: bytes32Schema3
 });
 async function generateX25519KeyPair(input) {
   const suite = createHpkeSuite();
@@ -779,7 +872,7 @@ function buildWinningSolutionDeliveryInfo(contextCommitment) {
 var GUARDIAN_ROSTER_KEY_PROOF_INFO = "elgora/guardian-roster-key-proof/hpke-fixture/v0";
 var GUARDIAN_ROSTER_KEY_PROOF_MESSAGE_TYPE = "elgora_guardian_roster_key_proof_v0";
 var GUARDIAN_ROSTER_KEY_PROOF_FIXTURE_BYTES = 32;
-var guardianRosterKeyProofContextSchema = z3.strictObject({
+var guardianRosterKeyProofContextSchema = z4.strictObject({
   chain_id: chainIdSchema,
   hub_address: lowerAddressSchema,
   proposed_account: lowerAddressSchema,
@@ -1107,7 +1200,7 @@ async function wrapAesKeyForRecipients(input) {
 }
 async function openAesKeyForRecipient(input) {
   const suite = createHpkeSuite();
-  const wrappedKeys = z3.array(wrappedRecipientKeySchema).parse(input.wrappedKeys);
+  const wrappedKeys = z4.array(wrappedRecipientKeySchema).parse(input.wrappedKeys);
   const privateKeys = guardianRecipientPrivateKeysSchema.parse(
     input.privateKeys
   );
@@ -1352,8 +1445,8 @@ function readFrontmatter(markdown, issues) {
     return null;
   }
 }
-function resolveProfile(declared, fallback, issues) {
-  const pinned = getProtocolProfile(declared) ?? (declared === fallback.profile ? fallback : null);
+function resolveProfile(declared, fallback2, issues) {
+  const pinned = getProtocolProfile(declared) ?? (declared === fallback2.profile ? fallback2 : null);
   if (pinned === null) {
     issues.push({
       code: "profile_unknown",
@@ -1486,19 +1579,30 @@ function parseInlineList(value) {
 }
 
 // ../../packages/core/src/deployments.ts
-import { baseSepolia as baseSepolia2 } from "viem/chains";
+import { base as base2, baseSepolia as baseSepolia2 } from "viem/chains";
 var DEPLOYMENTS = {
+  [base2.id]: {
+    ELGORA_HUB_ADDRESS: "0x8f80d1183cd983b01b0c9ac6777cc732ec9800de",
+    ELGORA_ESCROW_TOKEN_ADDRESS: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+    payoutSchemeAddress: "0x36d304993cb1575a2f9b8a0388b18aa5ec6d7a61",
+    ELGORA_SUBGRAPH_ENDPOINT: "https://api.goldsky.com/api/public/project_cmtu7wslg04s501ovc2je3beh/subgraphs/elgora-elgorahub-base/production/gn",
+    ELGORA_API_BASE_URL: "https://elgora.ai",
+    deployBlock: 51752389,
+    deployTransaction: "0xd62f407b770c8fca82a9704b30ed0605d9e3ed2b56278dcca152958063f7f469",
+    sourceCommit: "8d40270d617a63dd5a7a35045db0d9ea3ddd9093"
+  },
   [baseSepolia2.id]: {
     ELGORA_HUB_ADDRESS: "0x2f97b5f616495c2e923f39a46648eb783c053ad7",
     ELGORA_ESCROW_TOKEN_ADDRESS: "0x036cbd53842c5426634e7929541ec2318f3dcf7e",
     payoutSchemeAddress: "0x752d4305b8567b777d479dfa9847dc4f5ffb5750",
     ELGORA_SUBGRAPH_ENDPOINT: "https://api.goldsky.com/api/public/project_cmtu7wslg04s501ovc2je3beh/subgraphs/elgora-elgorahub/testnet-production/gn",
+    ELGORA_API_BASE_URL: "https://staging.elgora.ai",
     deployBlock: 46353511,
     deployTransaction: "0xed3d3c8af3c69f9f8d4ec47da7179fe4b89bd4a4cd8d8232dbbd3d3f3d38e74b",
     sourceCommit: "1377da5c38dc5c90d8608ffa3cb15ad6f8567a01"
   }
 };
-var DEFAULT_CHAIN_ID = baseSepolia2.id;
+var DEFAULT_CHAIN_ID = base2.id;
 function getDeployment(chainId) {
   return DEPLOYMENTS[chainId];
 }
@@ -3807,7 +3911,7 @@ function settlementAmounts(escrowAmount, treasuryFeeBps, guardianFeeBps) {
 import { zeroAddress } from "viem";
 
 // ../../packages/core/src/api/bounty-preparation.ts
-import { ZodError, z as z4 } from "zod";
+import { ZodError, z as z5 } from "zod";
 
 // ../../packages/core/src/submission-timelock.ts
 import {
@@ -4068,7 +4172,7 @@ import {
   getAbiItem as getAbiItem2,
   parseAbi,
   parseSignature,
-  recoverTypedDataAddress
+  recoverTypedDataAddress as recoverTypedDataAddress2
 } from "viem";
 var ELGORA_HUB_ERRORS = ELGORA_HUB_ABI.filter(
   (item) => item.type === "error"
@@ -4225,7 +4329,7 @@ async function prepareAuthorizedCreateBountyTransaction(input) {
     if (unsupported) return null;
     throw error;
   }
-  if ((await recoverTypedDataAddress({ ...authorization, signature })).toLowerCase() !== poster.toLowerCase()) {
+  if ((await recoverTypedDataAddress2({ ...authorization, signature })).toLowerCase() !== poster.toLowerCase()) {
     throw new Error("USDC authorization was not signed by the funding Poster.");
   }
   const { r, s, yParity } = parseSignature(signature);
@@ -4301,14 +4405,14 @@ var BoundaryValidationError = class extends Error {
     this.issues = issues;
   }
 };
-var artifactUploadUrlRequestSchema = z4.object({
-  ciphertext_sha256: z4.string().refine(isSha256Hex),
-  ciphertext_byte_length: z4.number().int().positive().max(MAX_SOLVER_SUBMISSION_CIPHERTEXT_BYTES)
+var artifactUploadUrlRequestSchema = z5.object({
+  ciphertext_sha256: z5.string().refine(isSha256Hex),
+  ciphertext_byte_length: z5.number().int().positive().max(MAX_SOLVER_SUBMISSION_CIPHERTEXT_BYTES)
 }).strict();
 
 // ../../packages/core/src/api/config.ts
 import { createHash } from "crypto";
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 function withDeploymentEnvDefaults(env) {
   const merged = { ...env };
   const setIfBlank = (key, value) => {
@@ -4329,11 +4433,11 @@ function withDeploymentEnvDefaults(env) {
   setIfBlank("ELGORA_SUBGRAPH_ENDPOINT", deployment?.ELGORA_SUBGRAPH_ENDPOINT);
   return merged;
 }
-var chainIdField = z5.coerce.number().int().positive().refine((chainId) => SUPPORTED_CHAINS[chainId] !== void 0, {
+var chainIdField = z6.coerce.number().int().positive().refine((chainId) => SUPPORTED_CHAINS[chainId] !== void 0, {
   message: `ELGORA_CHAIN_ID must be a supported chain: ${Object.keys(SUPPORTED_CHAINS).join(", ")}`
 });
-var hubAddressField = z5.string().refine(isHexAddress, "ELGORA_HUB_ADDRESS must be a 20-byte EVM address").transform((value) => value.toLowerCase());
-var publicDeploymentEnvSchema = z5.object({
+var hubAddressField = z6.string().refine(isHexAddress, "ELGORA_HUB_ADDRESS must be a 20-byte EVM address").transform((value) => value.toLowerCase());
+var publicDeploymentEnvSchema = z6.object({
   ELGORA_CHAIN_ID: chainIdField,
   ELGORA_HUB_ADDRESS: hubAddressField
 });
@@ -4349,40 +4453,50 @@ function loadPublicDeploymentConfig(env = process.env) {
 var envShape = {
   ELGORA_CHAIN_ID: chainIdField,
   ELGORA_HUB_ADDRESS: hubAddressField,
-  ELGORA_ESCROW_TOKEN_ADDRESS: z5.string().refine(
+  ELGORA_ESCROW_TOKEN_ADDRESS: z6.string().refine(
     isHexAddress,
     "ELGORA_ESCROW_TOKEN_ADDRESS must be a 20-byte EVM address"
   ).transform((value) => value.toLowerCase()),
-  ELGORA_TIMELOCK_REVEAL_DELAY_SECONDS: z5.coerce.number().int().nonnegative().default(DEFAULT_TIMELOCK_REVEAL_DELAY_SECONDS),
-  ELGORA_RPC_URL: z5.string().min(1, "ELGORA_RPC_URL is required"),
+  ELGORA_TIMELOCK_REVEAL_DELAY_SECONDS: z6.coerce.number().int().nonnegative().default(DEFAULT_TIMELOCK_REVEAL_DELAY_SECONDS),
+  ELGORA_RPC_URL: z6.string().min(1, "ELGORA_RPC_URL is required"),
   /**
    * Only consulted for a chain with no recorded deployment — a local anvil
    * stack, whose addresses change on every deploy. A recorded deployment's
    * scheme always wins, because settlement validation compares against it.
    */
-  ELGORA_PAYOUT_SCHEME_ADDRESS: z5.string().refine(
+  ELGORA_PAYOUT_SCHEME_ADDRESS: z6.string().refine(
     isHexAddress,
     "ELGORA_PAYOUT_SCHEME_ADDRESS must be a 20-byte EVM address"
   ).transform((value) => value.toLowerCase()).optional(),
-  ELGORA_DATABASE_URL: z5.string().min(1, "ELGORA_DATABASE_URL is required"),
-  ELGORA_SUBGRAPH_ENDPOINT: z5.string().min(1, "ELGORA_SUBGRAPH_ENDPOINT is required"),
-  ELGORA_ARTIFACT_STORAGE_ENDPOINT: z5.string().min(1, "ELGORA_ARTIFACT_STORAGE_ENDPOINT is required"),
-  ELGORA_ARTIFACT_STORAGE_REGION: z5.string().min(1, "ELGORA_ARTIFACT_STORAGE_REGION is required"),
-  ELGORA_ARTIFACT_STORAGE_BUCKET: z5.string().min(1, "ELGORA_ARTIFACT_STORAGE_BUCKET is required"),
-  ELGORA_ARTIFACT_STORAGE_ACCESS_KEY_ID: z5.string().min(1, "ELGORA_ARTIFACT_STORAGE_ACCESS_KEY_ID is required"),
-  ELGORA_ARTIFACT_STORAGE_SECRET_ACCESS_KEY: z5.string().min(1, "ELGORA_ARTIFACT_STORAGE_SECRET_ACCESS_KEY is required"),
-  ELGORA_DELIVERY_PUBLIC_KEY: z5.string().min(1, "ELGORA_DELIVERY_PUBLIC_KEY is required"),
-  ELGORA_DELIVERY_PRIVATE_KEY: z5.string().min(1, "ELGORA_DELIVERY_PRIVATE_KEY is required")
+  ELGORA_DATABASE_URL: z6.string().min(1, "ELGORA_DATABASE_URL is required"),
+  ELGORA_SUBGRAPH_ENDPOINT: z6.string().min(1, "ELGORA_SUBGRAPH_ENDPOINT is required"),
+  ELGORA_ARTIFACT_STORAGE_ENDPOINT: z6.string().min(1, "ELGORA_ARTIFACT_STORAGE_ENDPOINT is required"),
+  ELGORA_ARTIFACT_STORAGE_REGION: z6.string().min(1, "ELGORA_ARTIFACT_STORAGE_REGION is required"),
+  ELGORA_ARTIFACT_STORAGE_BUCKET: z6.string().min(1, "ELGORA_ARTIFACT_STORAGE_BUCKET is required"),
+  ELGORA_ARTIFACT_STORAGE_ACCESS_KEY_ID: z6.string().min(1, "ELGORA_ARTIFACT_STORAGE_ACCESS_KEY_ID is required"),
+  ELGORA_ARTIFACT_STORAGE_SECRET_ACCESS_KEY: z6.string().min(1, "ELGORA_ARTIFACT_STORAGE_SECRET_ACCESS_KEY is required"),
+  ELGORA_DELIVERY_PUBLIC_KEY: z6.string().min(1, "ELGORA_DELIVERY_PUBLIC_KEY is required"),
+  ELGORA_DELIVERY_PRIVATE_KEY: z6.string().min(1, "ELGORA_DELIVERY_PRIVATE_KEY is required")
 };
+var readinessAudienceSchema = z6.string().trim().toLowerCase().min(1).max(512).refine((host) => {
+  try {
+    const url = new URL(`https://${host}`);
+    return url.host === host && url.pathname === "/" && !url.username && !url.password && !url.search && !url.hash;
+  } catch {
+    return false;
+  }
+}, "Must be a canonical hostname with optional port, without a URL path");
 var publicationEnvShape = {
   ELGORA_CHAIN_ID: envShape.ELGORA_CHAIN_ID,
   ELGORA_HUB_ADDRESS: envShape.ELGORA_HUB_ADDRESS,
   ELGORA_ESCROW_TOKEN_ADDRESS: envShape.ELGORA_ESCROW_TOKEN_ADDRESS,
   ELGORA_DATABASE_URL: envShape.ELGORA_DATABASE_URL,
-  ELGORA_SUBGRAPH_ENDPOINT: envShape.ELGORA_SUBGRAPH_ENDPOINT
+  ELGORA_SUBGRAPH_ENDPOINT: envShape.ELGORA_SUBGRAPH_ENDPOINT,
+  ELGORA_PUBLICATION_REVIEW_ENABLED: z6.string().trim().toLowerCase().pipe(z6.enum(["true", "false"])).default("true").transform((value) => value === "true"),
+  ELGORA_READINESS_TIMEOUT_MS: z6.coerce.number().int().min(1).max(12e4).default(12e4)
 };
-var envSchema = z5.object(envShape);
-var bountyPublicationEnvSchema = z5.object(publicationEnvShape);
+var envSchema = z6.object(envShape);
+var bountyPublicationEnvSchema = z6.object(publicationEnvShape);
 
 // ../../packages/core/src/api/elgora-hub-error-catalog.ts
 import { decodeErrorResult } from "viem";
@@ -4396,55 +4510,12 @@ var ELGORA_HUB_FEE_POLICY_ABI = [
   getAbiItem3({ abi: ELGORA_HUB_ABI, name: "guardianFeeBps" })
 ];
 
-// ../../packages/core/src/api/orchestrator-readiness.ts
-import { z as z6 } from "zod";
-var MAX_ORCHESTRATOR_ISSUES = 20;
-var readinessIssueSchema = z6.object({
-  path: z6.string().trim().min(1).max(120),
-  message: z6.string().trim().min(1).max(1500),
-  code: z6.enum([
-    "acceptance_undecidable",
-    "winner_unresolved",
-    "source_unidentified",
-    "domain_underspecified",
-    "platform_conflict",
-    "operative_instruction",
-    "placeholder_unreplaced",
-    "unsafe_content"
-  ]),
-  anchor: z6.string().trim().min(1).max(120),
-  hazard: z6.boolean()
-}).strict();
-var readinessResponseSchema = z6.object({
-  issues: z6.array(readinessIssueSchema).max(MAX_ORCHESTRATOR_ISSUES),
-  judgeable: z6.boolean()
-}).strict();
-var READINESS_OUTPUT_JSON_SCHEMA = z6.toJSONSchema(readinessResponseSchema, {
-  override: ({ jsonSchema }) => {
-    delete jsonSchema.minLength;
-    delete jsonSchema.maxLength;
-    delete jsonSchema.maxItems;
-  }
-});
-delete READINESS_OUTPUT_JSON_SCHEMA.$schema;
-var providerMessageSchema = z6.object({
-  id: z6.string().optional(),
-  choices: z6.array(
-    z6.object({
-      message: z6.object({
-        content: z6.string().nullable().optional()
-      }).passthrough(),
-      finish_reason: z6.string().nullable().optional()
-    }).passthrough()
-  ).min(1)
-}).passthrough();
-
 // ../../packages/core/src/api/solver-submission-responses.ts
-import { isHex as isHex3 } from "viem";
+import { isHex as isHex4 } from "viem";
 import { z as z7 } from "zod";
 var hexAddressSchema = z7.string().refine(isHexAddress, "Must be a hex-encoded address");
 var hexBytes32Schema = z7.string().refine(isHexBytes32, "Must be 32-byte hex");
-var hexDataSchema = z7.string().refine((value) => isHex3(value), "Must be hex-encoded calldata");
+var hexDataSchema = z7.string().refine((value) => isHex4(value), "Must be hex-encoded calldata");
 var artifactUploadUrlResponseSchema = z7.object({
   locator: z7.string().min(1),
   upload_url: z7.string().min(1),
@@ -4598,7 +4669,7 @@ var FRONTMATTER_DELIMITER2 = "---";
 var decimalSchema = z10.string().regex(/^[1-9][0-9]*$/, "Must be a positive integer").transform(Number).refine(Number.isSafeInteger, "Must be a safe integer");
 var bountyIdSchema2 = z10.string().regex(/^(0|[1-9][0-9]*)$/, "Must be a non-negative integer");
 var addressSchema2 = z10.string().refine(isHexAddress, "Must be a hex-encoded address").refine((value) => value === value.toLowerCase(), "Must use lowercase hex").transform((value) => value);
-var bytes32Schema3 = z10.string().refine(isHexBytes32, "Must be 32-byte hex").refine((value) => value === value.toLowerCase(), "Must use lowercase hex").transform((value) => value);
+var bytes32Schema4 = z10.string().refine(isHexBytes32, "Must be 32-byte hex").refine((value) => value === value.toLowerCase(), "Must use lowercase hex").transform((value) => value);
 var commonFields = {
   format_version: z10.literal(WRITTEN_VERDICT_FORMAT_VERSION.toString()).transform(() => WRITTEN_VERDICT_FORMAT_VERSION),
   chain_id: decimalSchema,
@@ -4614,7 +4685,7 @@ var writtenVerdictSchema = z10.discriminatedUnion("outcome", [
       (value) => value !== zeroAddress2,
       "Must not be the zero address"
     ),
-    awarded_submission_commitment: bytes32Schema3.refine(
+    awarded_submission_commitment: bytes32Schema4.refine(
       (value) => value !== ZERO_BYTES32,
       "Must not be zero bytes"
     )
@@ -4716,20 +4787,52 @@ function invalidWrittenVerdict(path5, message) {
 import {
   createPublicClient,
   createWalletClient,
+  fallback,
   http
 } from "viem";
+
+// ../../packages/core/src/auth/freshness.ts
+var API_REQUEST_APPROVAL_ANCHOR_LAG_SECONDS = 6;
+var FALLBACK_BLOCK_TIME_MS = 2e3;
+function blockTimeMsFor(chainId) {
+  const chain = chainId === void 0 ? void 0 : SUPPORTED_CHAINS[chainId];
+  return chain?.blockTime ?? FALLBACK_BLOCK_TIME_MS;
+}
+function blocksForSeconds(seconds, chainId) {
+  const blocks = Math.ceil(seconds * 1e3 / blockTimeMsFor(chainId));
+  return BigInt(Math.max(1, blocks));
+}
+function apiRequestApprovalAnchorLagBlocks(chainId) {
+  return blocksForSeconds(API_REQUEST_APPROVAL_ANCHOR_LAG_SECONDS, chainId);
+}
+
+// ../../packages/core/src/chain-client.ts
 var RPC_RETRY_COUNT = 3;
+function createChainTransport(chainId, rpcUrl) {
+  const publicRpcUrl = resolveSupportedChain(chainId).rpcUrls.default.http[0];
+  const configuredRpcUrl = rpcUrl?.trim() || publicRpcUrl;
+  if (!publicRpcUrl || configuredRpcUrl === publicRpcUrl) {
+    return http(configuredRpcUrl, { retryCount: RPC_RETRY_COUNT });
+  }
+  return fallback(
+    [
+      http(configuredRpcUrl, { retryCount: 0 }),
+      http(publicRpcUrl, { retryCount: 0 })
+    ],
+    { retryCount: RPC_RETRY_COUNT }
+  );
+}
 function createChainPublicClient(chainId, rpcUrl) {
   return createPublicClient({
     chain: resolveSupportedChain(chainId),
-    transport: http(rpcUrl, { retryCount: RPC_RETRY_COUNT })
+    transport: createChainTransport(chainId, rpcUrl)
   });
 }
 function createChainWalletClient(chainId, rpcUrl, account) {
   return createWalletClient({
     account,
     chain: resolveSupportedChain(chainId),
-    transport: http(rpcUrl, { retryCount: RPC_RETRY_COUNT })
+    transport: createChainTransport(chainId, rpcUrl)
   });
 }
 function assertChainId(actual, expected) {
@@ -4737,10 +4840,10 @@ function assertChainId(actual, expected) {
     throw new Error(`RPC returned chain_id ${actual}, expected ${expected}`);
   }
 }
-var SIGNING_BLOCK_OFFSET = 3n;
 async function fetchSignableBlock(client) {
+  const offset = apiRequestApprovalAnchorLagBlocks(client.chain?.id);
   const head = await client.getBlockNumber();
-  const anchorNumber = head > SIGNING_BLOCK_OFFSET ? head - SIGNING_BLOCK_OFFSET : 0n;
+  const anchorNumber = head > offset ? head - offset : 0n;
   const anchor = await client.getBlock({ blockNumber: anchorNumber });
   return { number: anchor.number, hash: anchor.hash };
 }
@@ -5032,7 +5135,6 @@ function loadClaimConfig(env, claimantAddress) {
 }
 
 // ../../packages/core/src/api-client-config.ts
-var PRODUCTION_API_BASE_URL = "https://elgora.vercel.app";
 var LOCAL_DEV_API_BASE_URL = "http://127.0.0.1:3000";
 var API_BASE_URL_FLAG = "--api-base-url";
 function loadApiClientConfig(env, apiBaseUrlOverride) {
@@ -5060,11 +5162,20 @@ function resolveApiBaseUrl(env, override) {
   return value;
 }
 function defaultApiBaseUrl(env) {
-  return env.NODE_ENV === "development" ? LOCAL_DEV_API_BASE_URL : PRODUCTION_API_BASE_URL;
+  if (env.NODE_ENV === "development") return LOCAL_DEV_API_BASE_URL;
+  const chainId = Number(env.ELGORA_CHAIN_ID?.trim() || DEFAULT_CHAIN_ID);
+  const recorded = getDeployment(chainId)?.ELGORA_API_BASE_URL;
+  if (!recorded) {
+    throw new Error(
+      `No Elgora API is recorded for chain ${chainId}; set ELGORA_API_BASE_URL or pass --api-base-url`
+    );
+  }
+  return recorded;
 }
 
 // ../../packages/core/src/api-client.ts
 var ApiRequestError = class extends Error {
+  issues;
   status;
   code;
   retryAfterMs;
@@ -5073,15 +5184,16 @@ var ApiRequestError = class extends Error {
       `Request to ${input.url} failed with ${input.status}: ${formatApiError(input.body)}`
     );
     this.name = "ApiRequestError";
+    this.issues = readApiErrorIssues(input.body);
     this.status = input.status;
     this.code = readApiErrorCode(input.body);
     this.retryAfterMs = input.retryAfterMs;
   }
 };
-async function postText(url, body, contentType, authorization) {
+async function postText(url, body, contentType, authorization, headers = {}) {
   const response = await fetch(url, {
     method: "POST",
-    headers: { "content-type": contentType, authorization },
+    headers: { ...headers, "content-type": contentType, authorization },
     body
   });
   return parseJsonResponse(url, response);
@@ -5186,12 +5298,11 @@ function formatApiError(body) {
   if (body && typeof body === "object" && "error" in body && body.error && typeof body.error === "object" && "message" in body.error) {
     const apiError = body.error;
     const parts = [String(apiError.message)];
-    if (Array.isArray(apiError.issues) && apiError.issues.length > 0) {
-      for (const issue of apiError.issues) {
-        if (!issue || typeof issue !== "object" || typeof issue.message !== "string")
-          continue;
-        parts.push(`${issue.path || "request"}: ${issue.message}`);
-      }
+    for (const issue of readApiErrorIssues(body)) {
+      let line = `${issue.anchor || issue.path || "request"}: ${issue.message}`;
+      if (issue.code) line += ` [${issue.code}]`;
+      if (issue.hazard !== void 0) line += ` (hazard: ${issue.hazard})`;
+      parts.push(line);
     }
     if (apiError.next_action !== void 0 && apiError.next_action !== null) {
       parts.push(`next action: ${String(apiError.next_action)}`);
@@ -5214,6 +5325,13 @@ async function assertResponseOk(url, response) {
     retryAfterMs: readRetryAfterMs(response)
   });
 }
+function readApiErrorIssues(body) {
+  if (!body || typeof body !== "object" || !("error" in body) || !body.error || typeof body.error !== "object" || !("issues" in body.error) || !Array.isArray(body.error.issues))
+    return [];
+  return body.error.issues.filter(
+    (issue) => issue && typeof issue === "object" && typeof issue.path === "string" && typeof issue.message === "string" && (issue.code === void 0 || typeof issue.code === "string") && (issue.anchor === void 0 || typeof issue.anchor === "string") && (issue.hazard === void 0 || typeof issue.hazard === "boolean")
+  );
+}
 function readApiErrorCode(body) {
   if (!body || typeof body !== "object" || !("error" in body) || !body.error || typeof body.error !== "object" || !("code" in body.error) || typeof body.error.code !== "string") {
     return void 0;
@@ -5235,7 +5353,7 @@ function toArrayBuffer(bytes) {
 import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
 
 // ../../packages/core/src/auth/authorization-header.ts
-import { isAddress as isAddress3, isHex as isHex4 } from "viem";
+import { isAddress as isAddress3, isHex as isHex5 } from "viem";
 var ELGORA_APPROVAL_AUTH_SCHEME = "Elgora-Approval";
 var FIELD_SEPARATOR = "~";
 function encodeApiRequestApprovalHeader(fields) {
@@ -5248,59 +5366,27 @@ function encodeApiRequestApprovalHeader(fields) {
   return `${ELGORA_APPROVAL_AUTH_SCHEME} ${btoa(payload)}`;
 }
 
-// ../../packages/core/src/auth/eip712.ts
-var API_REQUEST_APPROVAL_PRIMARY_TYPE = "ApiRequestApproval";
-var API_REQUEST_APPROVAL_TYPES = {
-  ApiRequestApproval: [
-    { name: "endpointId", type: "string" },
-    { name: "audience", type: "string" },
-    { name: "bodyHash", type: "bytes32" },
-    { name: "query", type: "string" },
-    { name: "blockNumber", type: "uint256" },
-    { name: "blockHash", type: "bytes32" }
-  ]
-};
-function buildElgoraEip712Domain(params) {
-  return {
-    name: "Elgora",
-    version: "1",
-    chainId: params.chainId,
-    verifyingContract: params.hubAddress
-  };
-}
-function buildApiRequestApprovalTypedData(params) {
-  return {
-    domain: buildElgoraEip712Domain({
-      chainId: params.chainId,
-      hubAddress: params.hubAddress
-    }),
-    types: API_REQUEST_APPROVAL_TYPES,
-    primaryType: API_REQUEST_APPROVAL_PRIMARY_TYPE,
-    message: params.message
-  };
-}
-function endpointIdFor(input) {
-  return `${input.method.toUpperCase()} ${input.path}`;
-}
-function audienceFor(host) {
-  return host.toLowerCase();
-}
-function queryFor(query) {
-  return new URLSearchParams(query).toString();
+// ../../packages/core/src/auth/readiness-signoff-header.ts
+var ELGORA_READINESS_SIGNOFF_HEADER = "Elgora-Readiness-Signoff";
+function encodeReadinessSignoffHeader(signoff) {
+  const bytes = new TextEncoder().encode(
+    JSON.stringify(readinessSignoffSchema.parse(signoff))
+  );
+  return btoa(String.fromCharCode(...bytes));
 }
 
 // ../../packages/core/src/auth/request-approval.ts
 import {
   hashTypedData,
-  isAddressEqual as isAddressEqual2,
+  isAddressEqual as isAddressEqual3,
   keccak256 as keccak2565,
   toBytes as toBytes4
 } from "viem";
 
 // ../../packages/core/src/auth/signature.ts
 import {
-  isAddressEqual,
-  recoverTypedDataAddress as recoverTypedDataAddress2
+  isAddressEqual as isAddressEqual2,
+  recoverTypedDataAddress as recoverTypedDataAddress3
 } from "viem";
 
 // ../../packages/core/src/auth/request-approval-header.ts
@@ -5581,6 +5667,7 @@ function readGuardianPrivateKeys(env) {
 }
 
 // src/guardian-deliver-key.ts
+var PENDING_FINALITY_EXIT_CODE = 75;
 var USAGE = "Usage: elgora-cli guardian:deliver-key <bounty_id> <solver> <submission_commitment>";
 async function main4(env = process.env, argv = process.argv.slice(2)) {
   const { apiBaseUrl, argv: positionalArgs } = extractApiBaseUrlFlag(argv);
@@ -5595,6 +5682,33 @@ async function main4(env = process.env, argv = process.argv.slice(2)) {
       "ELGORA_GUARDIAN_ACCOUNT_PRIVATE_KEY must be a 32-byte hex private key"
     );
   }
+  const guardianPrivateKeys = readGuardianPrivateKeys(env);
+  const publicClient = createChainPublicClient(config.chainId, rpcUrl);
+  const finality = await readSettlementFinality(
+    publicClient,
+    config.hubAddress,
+    bountyId
+  );
+  if (finality.latestStatus === "no_valid_submission" || finality.latestStatus === "timed_out") {
+    throw new Error(
+      `Bounty ${bountyId.toString()} settled ${finality.latestStatus}; there is no winning key to deliver`
+    );
+  }
+  if (finality.pending) {
+    console.log(
+      JSON.stringify({
+        event: "guardian_deliver_key.pending_finality",
+        bounty_id: bountyId.toString(),
+        solver,
+        submission_commitment: submissionCommitment,
+        latest_status: finality.latestStatus,
+        finalized_status: finality.finalizedStatus,
+        message: "Settlement is not behind the chain's finalized tag yet; nothing was delivered. Retry in 10-20 minutes."
+      })
+    );
+    process.exitCode = PENDING_FINALITY_EXIT_CODE;
+    return;
+  }
   const account = privateKeyToAccount4(guardianAccountPrivateKey);
   const wrapped = await wrapWinningSolutionKey({
     config,
@@ -5605,8 +5719,8 @@ async function main4(env = process.env, argv = process.argv.slice(2)) {
       privateKey: guardianAccountPrivateKey,
       address: account.address
     },
-    publicClient: createChainPublicClient(config.chainId, rpcUrl),
-    guardianPrivateKeys: readGuardianPrivateKeys(env)
+    publicClient,
+    guardianPrivateKeys
   });
   console.log(
     JSON.stringify({
@@ -5618,6 +5732,30 @@ async function main4(env = process.env, argv = process.argv.slice(2)) {
     })
   );
 }
+async function readSettlementFinality(publicClient, hubAddress, bountyId) {
+  const finalizedBlock = await publicClient.getBlock({
+    blockTag: "finalized"
+  });
+  const readStatus = async (blockNumber) => {
+    const [, state] = await publicClient.readContract({
+      address: hubAddress,
+      abi: ELGORA_HUB_BOUNTY_READ_ABI,
+      functionName: "getBounty",
+      args: [bountyId],
+      ...blockNumber === void 0 ? {} : { blockNumber }
+    });
+    return decodeBountyStatus(state.status);
+  };
+  const [latestStatus, finalizedStatus] = await Promise.all([
+    readStatus(),
+    readStatus(finalizedBlock.number)
+  ]);
+  return {
+    pending: latestStatus === "awarded" && finalizedStatus === "open",
+    latestStatus,
+    finalizedStatus
+  };
+}
 function readArgs(argv) {
   const [bountyId, solver, submissionCommitment] = argv;
   if (!bountyId || !isNumeric(bountyId) || !solver || !isHexAddress(solver) || !submissionCommitment || !isHexBytes32(submissionCommitment)) {
@@ -5754,6 +5892,13 @@ var BOUNTY_DETAIL_QUERY = `
       reportCommitments
       awardedPayoutData
       timedOutRefundAmount
+      settledLogIndex
+      claimsQueued(first: 1, orderBy: queuedLogIndex, orderDirection: desc) {
+        recipient
+        amount
+        queuedTxHash
+        queuedLogIndex
+      }
       guardianRoster {
         ${GUARDIAN_ROSTER_SNAPSHOT_FIELDS}
       }
@@ -5902,9 +6047,10 @@ function createElgoraSubgraphClient(options) {
       );
       raw = await response.text();
     } catch (cause) {
+      const code = transportErrorCode(cause);
       throw new SubgraphReadError(
         "transport_failed",
-        "Subgraph request did not complete",
+        `Subgraph request did not complete${code ? ` (${code})` : ""}`,
         { cause }
       );
     }
@@ -6057,6 +6203,17 @@ function createElgoraSubgraphClient(options) {
     }
   };
 }
+function transportErrorCode(error, depth = 0) {
+  if (depth > 4 || typeof error !== "object" || error === null)
+    return void 0;
+  const { code, cause, errors } = error;
+  if (typeof code === "string" && /^[A-Z][A-Z0-9_]*$/.test(code)) return code;
+  for (const inner of [cause, ...Array.isArray(errors) ? errors : []]) {
+    const found = transportErrorCode(inner, depth + 1);
+    if (found) return found;
+  }
+  return void 0;
+}
 var defaultFetch = (endpoint, body) => fetch(endpoint, {
   method: "POST",
   headers: { "content-type": "application/json" },
@@ -6131,8 +6288,17 @@ function mapAnalyticsGuardianRoster(row) {
 }
 function mapBountyDetail(row) {
   const record = readRecord(row);
+  const allocation = record.claimsQueued == null ? null : asArray(record.claimsQueued, "claimsQueued")[0];
+  let guardianFeeAmount = null;
+  if ((record.status === "Awarded" || record.status === "NoValidSubmission") && allocation && record.settledTxHash && record.settledLogIndex != null) {
+    const claim = readRecord(allocation);
+    if (asHex(claim.recipient, "recipient") === asHex(record.guardianFeeRecipient, "guardianFeeRecipient") && asHex(claim.queuedTxHash, "queuedTxHash") === asHex(record.settledTxHash, "settledTxHash") && asNumber(claim.queuedLogIndex, "queuedLogIndex") + 1 === asNumber(record.settledLogIndex, "settledLogIndex")) {
+      guardianFeeAmount = asString(claim.amount, "amount");
+    }
+  }
   return {
     ...mapBounty(record),
+    guardianFeeAmount,
     guardianRosterAdmin: asHex(
       record.guardianRosterAdmin,
       "guardianRosterAdmin"
@@ -6586,7 +6752,10 @@ function parseChallenge(text) {
 
 // src/guardian-verdict.ts
 import { readFile as readFile3 } from "fs/promises";
-import { zeroAddress as zeroAddress4 } from "viem";
+import {
+  BaseError as BaseError2,
+  zeroAddress as zeroAddress4
+} from "viem";
 import { privateKeyToAccount as privateKeyToAccount6 } from "viem/accounts";
 var OUTCOME = {
   no_valid_submission: 0,
@@ -6797,20 +6966,66 @@ async function main7(env = process.env, argv = process.argv.slice(2)) {
     functionName: "commitVerdict",
     args: contractArgs
   });
+  const replacements = [];
   const receipt = await publicClient.waitForTransactionReceipt({
-    hash: transactionHash
+    hash: transactionHash,
+    onReplaced: (replacement) => replacements.push(replacement)
   });
+  if (receipt.transactionHash !== transactionHash && replacements.at(-1)?.reason !== "repriced") {
+    throw new Error(
+      `commitVerdict transaction ${transactionHash} was ${replacements.at(-1)?.reason ?? "replaced"} by ${receipt.transactionHash}; this Verdict was not recorded`
+    );
+  }
   if (receipt.status !== "success") {
-    throw new Error(`commitVerdict transaction reverted: ${transactionHash}`);
+    throw new Error(
+      `commitVerdict transaction reverted: ${receipt.transactionHash}`
+    );
   }
-  const recorded = await publicClient.readContract({
-    address: config.hubAddress,
-    abi: ELGORA_HUB_VERDICT_WRITE_ABI,
-    functionName: "verdicts",
-    args: [args.bountyId, account.address]
-  });
-  if (!recorded[0] || recorded[1] !== contractArgs[1] || recorded[2].toLowerCase() !== contractArgs[2].toLowerCase() || recorded[3].toLowerCase() !== contractArgs[3].toLowerCase() || recorded[4].toLowerCase() !== reportCommitment || recorded[5].toLowerCase() !== "0x") {
-    throw new Error("ElgoraHub did not record the expected on-chain Verdict");
+  let readbackIssue;
+  try {
+    const recorded = await publicClient.readContract({
+      address: config.hubAddress,
+      abi: ELGORA_HUB_VERDICT_WRITE_ABI,
+      functionName: "verdicts",
+      args: [args.bountyId, account.address],
+      blockNumber: receipt.blockNumber
+    });
+    if (!recorded[0] || recorded[1] !== contractArgs[1] || recorded[2].toLowerCase() !== contractArgs[2].toLowerCase() || recorded[3].toLowerCase() !== contractArgs[3].toLowerCase() || recorded[4].toLowerCase() !== reportCommitment || recorded[5].toLowerCase() !== "0x") {
+      readbackIssue = {
+        observed: {
+          committed: recorded[0],
+          outcome: recorded[1],
+          winner: recorded[2],
+          awarded_submission_commitment: recorded[3],
+          report_commitment: recorded[4],
+          payout_data: recorded[5]
+        }
+      };
+    }
+  } catch (error) {
+    readbackIssue = {
+      error: error instanceof BaseError2 ? error.walk().name : error instanceof Error ? error.name : "UnknownError"
+    };
+  }
+  if (readbackIssue) {
+    console.warn(
+      JSON.stringify({
+        event: "guardian_verdict.readback_unconfirmed",
+        bounty_id: args.bountyId.toString(),
+        guardian: account.address.toLowerCase(),
+        tx_hash: receipt.transactionHash,
+        block_number: receipt.blockNumber.toString(),
+        expected: {
+          committed: true,
+          outcome: contractArgs[1],
+          winner: contractArgs[2],
+          awarded_submission_commitment: contractArgs[3],
+          report_commitment: reportCommitment,
+          payout_data: "0x"
+        },
+        ...readbackIssue
+      })
+    );
   }
   console.log(
     JSON.stringify({
@@ -6823,7 +7038,7 @@ async function main7(env = process.env, argv = process.argv.slice(2)) {
         awarded_submission_commitment: args.awardedSubmissionCommitment
       } : {},
       report_commitment: reportCommitment,
-      tx_hash: transactionHash,
+      tx_hash: receipt.transactionHash,
       block_number: receipt.blockNumber.toString()
     })
   );
@@ -6874,14 +7089,40 @@ function usageError() {
 }
 
 // src/network-flag.ts
-import { base as base2, baseSepolia as baseSepolia3, foundry as foundry3 } from "viem/chains";
+import { base as base3, baseSepolia as baseSepolia3, foundry as foundry3 } from "viem/chains";
 var NETWORK_FLAG = "--network";
-var NETWORK_CHAIN_IDS = {
-  base: base2.id,
-  "base-sepolia": baseSepolia3.id,
-  local: foundry3.id
-};
-var NETWORK_NAMES_HINT = Object.entries(NETWORK_CHAIN_IDS).map(([name, chainId]) => `${name} (${chainId})`).join(", ");
+var NETWORKS = [
+  { name: "base", chainId: base3.id, label: "Base mainnet" },
+  {
+    name: "base-sepolia",
+    chainId: baseSepolia3.id,
+    label: "Base Sepolia testnet, Elgora's staging deployment"
+  },
+  { name: "local", chainId: foundry3.id, label: "a local Anvil stack" }
+];
+var NETWORK_CHAIN_IDS = Object.fromEntries(
+  NETWORKS.map(({ name, chainId }) => [name, chainId])
+);
+var STAGING_NETWORK = NETWORKS.find(
+  ({ chainId }) => chainId === baseSepolia3.id
+);
+var NETWORK_NAMES_HINT = NETWORKS.map(
+  ({ name, chainId }) => `${name} (${chainId})`
+).join(", ");
+function describeChain(chainId) {
+  const network = NETWORKS.find((candidate) => candidate.chainId === chainId);
+  return network ? `${network.name} (${network.label})` : `chain ${chainId}`;
+}
+var STAGING_HINT = `add ${NETWORK_FLAG} ${STAGING_NETWORK.name} or set ELGORA_CHAIN_ID=${STAGING_NETWORK.chainId}`;
+var DEFAULT_NETWORK_HELP_LINES = [
+  `Default: ${describeChain(DEFAULT_CHAIN_ID)}.`,
+  `Staging: ${describeChain(STAGING_NETWORK.chainId)};`,
+  `  ${STAGING_HINT}.`
+];
+function defaultNetworkNotice(env) {
+  if (env.ELGORA_CHAIN_ID?.trim()) return void 0;
+  return `elgora-cli: using the default network, ${describeChain(DEFAULT_CHAIN_ID)}. For staging, ${STAGING_HINT}.`;
+}
 function applyNetworkFlag(env, argv) {
   const present = argv.some(
     (arg) => arg === NETWORK_FLAG || arg.startsWith(`${NETWORK_FLAG}=`)
@@ -6907,7 +7148,7 @@ function resolveChainId(selector) {
 }
 
 // src/version.ts
-var CLI_VERSION = true ? "7.5.1" : "0.0.0-dev";
+var CLI_VERSION = true ? "9.0.0" : "0.0.0-dev";
 var CLI_NODE_ENGINES = true ? ">=24 <25" : ">=24 <25";
 
 // src/node-engines.ts
@@ -7114,26 +7355,99 @@ function required3(env, name) {
 }
 
 // src/publish-fund.ts
-import { readFile as readFile4 } from "fs/promises";
-import { text as readStdinText3 } from "stream/consumers";
+import { readFile as readFile5 } from "fs/promises";
 import {
   decodeFunctionData,
   parseAbi as parseAbi2,
   parseEventLogs
 } from "viem";
 import { privateKeyToAccount as privateKeyToAccount8 } from "viem/accounts";
-var PUBLISH_FUND_USAGE = "Usage: elgora-cli poster:publish-fund <bounty_challenge_md_path>\n   or: elgora-cli poster:publish-fund -";
+
+// src/poster-request.ts
+import { readFile as readFile4 } from "fs/promises";
+import { text as readStdinText3 } from "stream/consumers";
+function loadPosterConfig(env, apiBaseUrlOverride) {
+  const defaults = withDeploymentDefaults(env);
+  const clientConfig = loadClientDeploymentConfig(defaults, apiBaseUrlOverride);
+  const rpcUrl = defaults.ELGORA_RPC_URL?.trim();
+  if (!rpcUrl) throw new Error("ELGORA_RPC_URL is required");
+  const privateKey = env.ELGORA_POSTER_PRIVATE_KEY?.trim();
+  if (!privateKey || !isHexBytes32(privateKey)) {
+    throw new Error(
+      "ELGORA_POSTER_PRIVATE_KEY must be a 32-byte hex private key"
+    );
+  }
+  return {
+    ...clientConfig,
+    rpcUrl,
+    posterPrivateKey: privateKey
+  };
+}
+function takeFlag(argv, flag, usage) {
+  const uses = argv.filter(
+    (arg) => arg === flag || arg.startsWith(`${flag}=`)
+  ).length;
+  const extracted = extractFlagValue(argv, flag);
+  if (uses > 1 || uses === 1 && (!extracted.value || extracted.value.startsWith("--")))
+    throw new Error(usage);
+  return extracted;
+}
+async function readBountyChallengeMarkdown2(path5) {
+  return path5 === "-" ? readStdinText3(process.stdin) : readFile4(path5, "utf8");
+}
+async function signPosterRequest(input) {
+  return buildAuthorizationHeader({
+    requestUrl: input.requestUrl.toString(),
+    method: "POST",
+    body: input.markdown,
+    chainId: input.config.chainId,
+    hubAddress: input.config.hubAddress,
+    address: input.account.address,
+    block: await fetchSignableBlock(input.publicClient),
+    sign: (typedData) => input.account.signTypedData(typedData)
+  });
+}
+
+// src/publish-fund.ts
+var PUBLISH_FUND_USAGE = "Usage: elgora-cli poster:publish-fund <bounty_challenge_md_path|-> --signoff <file>";
 var usdcAbi = parseAbi2([
   "function approve(address spender,uint256 value) returns (bool)",
   "function balanceOf(address account) view returns (uint256)"
 ]);
 async function main9(env = process.env, argv = process.argv.slice(2)) {
-  const { apiBaseUrl: apiBaseUrlOverride, argv: remainingArgv } = extractApiBaseUrlFlag(argv);
-  const config = loadPublishFundConfig(
-    withDeploymentDefaults(env),
-    apiBaseUrlOverride
+  const { apiBaseUrl: apiBaseUrlOverride, argv: afterApiBaseUrl } = extractApiBaseUrlFlag(argv);
+  const { value: signoffPath, argv: remainingArgv } = takeFlag(
+    afterApiBaseUrl,
+    "--signoff",
+    PUBLISH_FUND_USAGE
   );
-  const bountyChallengeMarkdown = await readBountyChallengeMarkdown2(remainingArgv);
+  if (!signoffPath || remainingArgv.length !== 1 || !remainingArgv[0])
+    throw new Error(PUBLISH_FUND_USAGE);
+  const config = loadPosterConfig(env, apiBaseUrlOverride);
+  const escrowTokenAddress = withDeploymentDefaults(env).ELGORA_ESCROW_TOKEN_ADDRESS?.trim();
+  if (!escrowTokenAddress || !isHexAddress(escrowTokenAddress)) {
+    throw new Error(
+      "ELGORA_ESCROW_TOKEN_ADDRESS must be a 20-byte EVM address"
+    );
+  }
+  const tokenAddress = escrowTokenAddress.toLowerCase();
+  const bountyChallengeMarkdown = await readBountyChallengeMarkdown2(
+    remainingArgv[0]
+  );
+  const localSpecCommitment = deriveBountyChallengeContentCommitment(
+    bountyChallengeMarkdown
+  );
+  const signoff = readinessSignoffSchema.parse(
+    JSON.parse(await readFile5(signoffPath, "utf8"))
+  );
+  if (signoff.spec_commitment.toLowerCase() !== localSpecCommitment) {
+    throw new Error(
+      "Readiness sign-off does not match the exact bounty_challenge.md bytes. Run poster:review again."
+    );
+  }
+  if (signoff.expires_at <= Math.floor(Date.now() / 1e3)) {
+    throw new Error("Readiness sign-off has expired. Run poster:review again.");
+  }
   const account = privateKeyToAccount8(config.posterPrivateKey);
   const publicClient = createChainPublicClient(config.chainId, config.rpcUrl);
   const walletClient = createChainWalletClient(
@@ -7147,31 +7461,25 @@ async function main9(env = process.env, argv = process.argv.slice(2)) {
     config.apiBaseUrl
   );
   requestUrl.searchParams.set("poster_address", account.address);
-  const block = await fetchSignableBlock(publicClient);
-  const authorization = await buildAuthorizationHeader({
-    requestUrl: requestUrl.toString(),
-    method: "POST",
-    body: bountyChallengeMarkdown,
-    chainId: config.chainId,
-    hubAddress: config.hubAddress,
-    address: account.address,
-    block,
-    sign: (typedData) => account.signTypedData(typedData)
+  const authorization = await signPosterRequest({
+    requestUrl,
+    markdown: bountyChallengeMarkdown,
+    config,
+    account,
+    publicClient
   });
   const prepared = await requestPreparePublication({
     requestUrl: requestUrl.toString(),
     markdown: bountyChallengeMarkdown,
-    authorization
+    authorization,
+    signoff: encodeReadinessSignoffHeader(signoff)
   });
-  const localSpecCommitment = deriveBountyChallengeContentCommitment(
-    bountyChallengeMarkdown
-  );
   if (prepared.content_record.spec_commitment !== localSpecCommitment) {
     throw new Error(
       "Elgora API returned a spec_commitment that does not match the locally submitted bounty_challenge.md"
     );
   }
-  if (prepared.create_bounty_transaction.chain_id !== config.chainId || prepared.create_bounty_transaction.to !== config.hubAddress || prepared.content_record.token_address !== config.escrowTokenAddress) {
+  if (prepared.create_bounty_transaction.chain_id !== config.chainId || prepared.create_bounty_transaction.to !== config.hubAddress || prepared.content_record.token_address !== tokenAddress) {
     throw new Error(
       "Elgora API returned a create_bounty_transaction that does not match the locally configured deployment (chain id, hub address, or escrow token)"
     );
@@ -7193,7 +7501,7 @@ async function main9(env = process.env, argv = process.argv.slice(2)) {
   const [ethBalance, usdcBalance] = await Promise.all([
     publicClient.getBalance({ address: account.address }),
     publicClient.readContract({
-      address: config.escrowTokenAddress,
+      address: tokenAddress,
       abi: usdcAbi,
       functionName: "balanceOf",
       args: [account.address]
@@ -7209,7 +7517,7 @@ async function main9(env = process.env, argv = process.argv.slice(2)) {
   }
   const authorized = await prepareAuthorizedCreateBountyTransaction({
     transaction: prepared.create_bounty_transaction,
-    tokenAddress: config.escrowTokenAddress,
+    tokenAddress,
     poster: account.address,
     publicClient,
     sign: (typedData) => account.signTypedData(typedData)
@@ -7230,7 +7538,7 @@ async function main9(env = process.env, argv = process.argv.slice(2)) {
     });
   } else {
     const approveHash = await walletClient.writeContract({
-      address: config.escrowTokenAddress,
+      address: tokenAddress,
       abi: usdcAbi,
       functionName: "approve",
       args: [config.hubAddress, escrowAmount]
@@ -7304,60 +7612,106 @@ async function requestPreparePublication(input) {
     new URL(input.requestUrl),
     input.markdown,
     "text/markdown",
-    input.authorization
+    input.authorization,
+    { [ELGORA_READINESS_SIGNOFF_HEADER]: input.signoff }
   );
   return bountyPublicationResponseSchema.parse(body);
 }
-async function readBountyChallengeMarkdown2(argv) {
-  const path5 = argv[0];
-  if (!path5) {
-    throw new Error(PUBLISH_FUND_USAGE);
-  }
-  if (path5 === "-") {
-    return readStdinText3(process.stdin);
-  }
-  return readFile4(path5, "utf8");
+
+// src/required-env.ts
+function missingRequiredEnv(required4, env) {
+  return required4.filter((envName) => !env[envName]?.trim());
 }
-function loadPublishFundConfig(env, apiBaseUrlOverride) {
-  const clientConfig = loadClientDeploymentConfig(env, apiBaseUrlOverride);
-  const rpcUrl = env.ELGORA_RPC_URL?.trim();
-  if (!rpcUrl) {
-    throw new Error("ELGORA_RPC_URL is required");
-  }
-  const posterPrivateKey = env.ELGORA_POSTER_PRIVATE_KEY?.trim();
-  if (!posterPrivateKey || !isHexBytes32(posterPrivateKey)) {
-    throw new Error(
-      "ELGORA_POSTER_PRIVATE_KEY must be a 32-byte hex private key"
+
+// src/review.ts
+import { writeFile as writeFile3 } from "fs/promises";
+import { resolve } from "path";
+import { privateKeyToAccount as privateKeyToAccount9 } from "viem/accounts";
+var USAGE2 = "Usage: elgora-cli poster:review <path|-> [--previous <commitment>] [--signoff-out <file>]";
+async function main10(env = process.env, argv = process.argv.slice(2)) {
+  const { apiBaseUrl, argv: args } = extractApiBaseUrlFlag(argv);
+  const { value: previous, argv: afterPrevious } = takeFlag(
+    args,
+    "--previous",
+    "--previous must be one bytes32 page commitment"
+  );
+  if (previous && !isHexBytes32(previous))
+    throw new Error("--previous must be one bytes32 page commitment");
+  const { value: signoffOut, argv: paths } = takeFlag(
+    afterPrevious,
+    "--signoff-out",
+    USAGE2
+  );
+  if (paths.length !== 1 || !paths[0] || paths[0].startsWith("--"))
+    throw new Error(USAGE2);
+  if (signoffOut && paths[0] !== "-" && resolve(signoffOut) === resolve(paths[0]))
+    throw new Error("--signoff-out must not overwrite the bounty draft");
+  const config = loadPosterConfig(env, apiBaseUrl);
+  const markdown = await readBountyChallengeMarkdown2(paths[0]);
+  const commitment = deriveBountyChallengeContentCommitment(markdown);
+  const account = privateKeyToAccount9(config.posterPrivateKey);
+  const publicClient = createChainPublicClient(config.chainId, config.rpcUrl);
+  await assertHubDeployment(publicClient, config.chainId, config.hubAddress);
+  const requestUrl = new URL(
+    "/api/bounty-challenge-specs/review",
+    config.apiBaseUrl
+  );
+  requestUrl.searchParams.set("poster_address", account.address);
+  if (previous)
+    requestUrl.searchParams.set("previous_spec_commitment", previous);
+  const authorization = await signPosterRequest({
+    requestUrl,
+    markdown,
+    config,
+    account,
+    publicClient
+  });
+  let response;
+  try {
+    response = bountyReviewResponseSchema.parse(
+      await postText(requestUrl, markdown, "text/markdown", authorization)
     );
+  } catch (error) {
+    if (error instanceof ApiRequestError && error.code === "bounty_challenge_not_ready") {
+      console.log(
+        JSON.stringify({ event: "review.not_ready", issues: error.issues })
+      );
+      process.exitCode = 2;
+      return;
+    }
+    throw error;
   }
-  const escrowTokenAddress = env.ELGORA_ESCROW_TOKEN_ADDRESS?.trim();
-  if (!escrowTokenAddress || !isHexAddress(escrowTokenAddress)) {
+  if (response.content_record.spec_commitment !== commitment) {
     throw new Error(
-      "ELGORA_ESCROW_TOKEN_ADDRESS must be a 20-byte EVM address"
+      "Elgora API returned a review for different bounty_challenge.md bytes"
     );
   }
-  return {
-    ...clientConfig,
-    rpcUrl,
-    posterPrivateKey: posterPrivateKey.toLowerCase(),
-    escrowTokenAddress: escrowTokenAddress.toLowerCase()
-  };
-}
-
-// src/required-env.ts
-function missingRequiredEnv(required4, env) {
-  return required4.filter((envName) => !env[envName]?.trim());
+  if (signoffOut)
+    await writeFile3(
+      signoffOut,
+      `${JSON.stringify(response.readiness.signoff, null, 2)}
+`
+    );
+  console.log(
+    JSON.stringify({
+      event: "review.ready",
+      spec_commitment: commitment,
+      signoff: response.readiness.signoff,
+      prior_issues_resolved: response.readiness.prior_issues_resolved,
+      prior_issues_open: response.readiness.prior_issues_open
+    })
+  );
 }
 
 // src/roster-add-guardian.ts
 import { isAddress as isAddress4 } from "viem";
-import { privateKeyToAccount as privateKeyToAccount9 } from "viem/accounts";
+import { privateKeyToAccount as privateKeyToAccount10 } from "viem/accounts";
 var ROSTER_ADMIN_ADDRESS_FLAG = "--roster-admin-address";
 var ENCRYPTION_PUBLIC_KEY_RE = /^[A-Za-z0-9_-]{43}$/;
-async function main10(env = process.env, argv = process.argv.slice(2)) {
+async function main11(env = process.env, argv = process.argv.slice(2)) {
   const args = parseRosterAddGuardianArgs(argv);
   const config = loadRosterAddGuardianConfig(env, args.rosterAdminAddress);
-  const account = config.rosterAdminPrivateKey ? privateKeyToAccount9(config.rosterAdminPrivateKey) : null;
+  const account = config.rosterAdminPrivateKey ? privateKeyToAccount10(config.rosterAdminPrivateKey) : null;
   const rosterAdmin = account?.address ?? args.rosterAdminAddress;
   if (!rosterAdmin) throw new Error("Roster admin address is required");
   const normalizedRosterAdmin = rosterAdmin.toLowerCase();
@@ -7525,7 +7879,7 @@ function usageError2() {
 // src/roster-prepare-guardian-proof.ts
 import { isAddress as isAddress5 } from "viem";
 var ENCRYPTION_PUBLIC_KEY_RE2 = /^[A-Za-z0-9_-]{43}$/;
-async function main11(env = process.env, argv = process.argv.slice(2)) {
+async function main12(env = process.env, argv = process.argv.slice(2)) {
   const args = parseArgs(argv);
   const envWithDefaults = withDeploymentDefaults(env);
   const { chainId, hubAddress } = loadPublicDeploymentConfig(envWithDefaults);
@@ -7572,17 +7926,17 @@ function usageError3() {
 }
 
 // src/roster-verify-guardian-proof.ts
-import { readFile as readFile5 } from "fs/promises";
-import { isAddress as isAddress6, isHex as isHex5, recoverMessageAddress } from "viem";
-async function main12(_env = process.env, argv = process.argv.slice(2)) {
+import { readFile as readFile6 } from "fs/promises";
+import { isAddress as isAddress6, isHex as isHex6, recoverMessageAddress } from "viem";
+async function main13(_env = process.env, argv = process.argv.slice(2)) {
   const [preparedPath, responsePath] = argv;
   if (!preparedPath || !responsePath) {
     throw new Error(
       "Usage: elgora-cli roster:verify-guardian-proof <prepared_json_path> <response_json_path>"
     );
   }
-  const prepared = parsePrepared(await readFile5(preparedPath, "utf8"));
-  const response = parseResponse(await readFile5(responsePath, "utf8"));
+  const prepared = parsePrepared(await readFile6(preparedPath, "utf8"));
+  const response = parseResponse(await readFile6(responsePath, "utf8"));
   const fixture = base64UrlToBytes(prepared.fixture);
   const signedPayload = buildGuardianRosterKeyProofSignedPayload(
     prepared.message,
@@ -7646,7 +8000,7 @@ function parseResponse(text) {
   }
   const guardianAccount = get(parsed, "guardian_account");
   const signature = get(parsed, "signature");
-  if (typeof guardianAccount !== "string" || !isAddress6(guardianAccount) || typeof signature !== "string" || !isHex5(signature) || signature.length !== 132) {
+  if (typeof guardianAccount !== "string" || !isAddress6(guardianAccount) || typeof signature !== "string" || !isHex6(signature) || signature.length !== 132) {
     throw new Error(
       "Guardian response JSON must be the unmodified stdout of guardian:prove-roster-key"
     );
@@ -7664,10 +8018,10 @@ function get(value, key) {
 }
 
 // src/spec-commitment.ts
-import { readFile as readFile6 } from "fs/promises";
+import { readFile as readFile7 } from "fs/promises";
 import { text as readStdinText4 } from "stream/consumers";
 var SPEC_COMMITMENT_USAGE = "Usage: elgora-cli spec-commitment <bounty_challenge_md_path>\n   or: elgora-cli spec-commitment -";
-async function main13(_env = process.env, argv = process.argv.slice(2)) {
+async function main14(_env = process.env, argv = process.argv.slice(2)) {
   const markdown = await readBountyChallengeMarkdown3(argv);
   const specCommitment = deriveBountyChallengeContentCommitment(markdown);
   console.log(
@@ -7686,23 +8040,23 @@ async function readBountyChallengeMarkdown3(argv) {
   if (path5 === "-") {
     return readStdinText4(process.stdin);
   }
-  return readFile6(path5, "utf8");
+  return readFile7(path5, "utf8");
 }
 
 // src/submit.ts
-import { readdir, readFile as readFile7, stat } from "fs/promises";
+import { readdir, readFile as readFile8, stat } from "fs/promises";
 import path3 from "path";
 import { createInterface } from "readline";
 import { isAddress as isAddress7 } from "viem";
-import { privateKeyToAccount as privateKeyToAccount10 } from "viem/accounts";
+import { privateKeyToAccount as privateKeyToAccount11 } from "viem/accounts";
 
 // src/external-api-approval-signer.ts
-import { isHex as isHex6 } from "viem";
+import { isHex as isHex7 } from "viem";
 function createExternalApiApprovalSigner(input) {
   return async (typedData) => {
     input.writePrompt(input.renderPrompt(typedData));
     const signature = (await input.readSignature())?.trim();
-    if (!signature || signature === "0x" || !isHex6(signature)) {
+    if (!signature || signature === "0x" || !isHex7(signature)) {
       throw new Error(
         "External signer must return one non-empty 0x-prefixed hex signature line on stdin"
       );
@@ -7744,13 +8098,13 @@ var MEDIA_TYPE_BY_EXTENSION = {
   diff: "text/x-diff"
 };
 var DEFAULT_MEDIA_TYPE = "application/octet-stream";
-async function main14(env = process.env, argv = process.argv.slice(2)) {
+async function main15(env = process.env, argv = process.argv.slice(2)) {
   const { solverAddress, argv: argvWithoutSolverAddress } = extractSolverAddressFlag(argv);
   const { apiBaseUrl: apiBaseUrlOverride, argv: remainingArgv } = extractApiBaseUrlFlag(argvWithoutSolverAddress);
   const config = loadSubmitConfig(env, apiBaseUrlOverride, solverAddress);
   const args = readSubmitArgs(remainingArgv);
   const bountyIdText = args.bountyId.toString();
-  const account = config.solverPrivateKey ? privateKeyToAccount10(config.solverPrivateKey) : null;
+  const account = config.solverPrivateKey ? privateKeyToAccount11(config.solverPrivateKey) : null;
   const solverAddressFromConfig = account?.address ?? config.solverAddress;
   if (!solverAddressFromConfig) throw new Error("Solver address is required");
   const solver = solverAddressFromConfig.toLowerCase();
@@ -8142,7 +8496,7 @@ async function readArtifactDirectory(artifactDir) {
   }
   return Promise.all(
     entries.map(async (entry) => {
-      const bytes = await readFile7(path3.join(artifactDir, entry.name));
+      const bytes = await readFile8(path3.join(artifactDir, entry.name));
       return {
         name: entry.name,
         media_type: guessMediaType(entry.name),
@@ -8211,7 +8565,7 @@ async function requestPrepareSubmission(input) {
           })
         );
       }
-      await new Promise((resolve) => setTimeout(resolve, retryDelay));
+      await new Promise((resolve2) => setTimeout(resolve2, retryDelay));
     }
   }
 }
@@ -8255,7 +8609,7 @@ function readTimelockRevealDelaySeconds(env) {
 
 // src/verification-record.ts
 var VERIFICATION_RECORD_USAGE = "Usage: elgora-cli verification-record <bounty_id>";
-async function main15(env = process.env, argv = process.argv.slice(2)) {
+async function main16(env = process.env, argv = process.argv.slice(2)) {
   const { apiBaseUrl: apiBaseUrlOverride, argv: remainingArgv } = extractApiBaseUrlFlag(argv);
   const args = readVerificationRecordArgs(remainingArgv);
   const envWithDefaults = withDeploymentDefaults(env);
@@ -8340,15 +8694,16 @@ var COMMANDS = {
   "guardian:verdict": main7,
   "guardian:deliver-key": main4,
   "poster:open-winning-submission": main8,
+  "poster:review": main10,
   "poster:publish-fund": main9,
-  "roster:add-guardian": main10,
-  "roster:prepare-guardian-proof": main11,
-  "roster:verify-guardian-proof": main12,
-  "solver:submit": main14,
+  "roster:add-guardian": main11,
+  "roster:prepare-guardian-proof": main12,
+  "roster:verify-guardian-proof": main13,
+  "solver:submit": main15,
   claim: main2,
   "check-page": main,
-  "spec-commitment": main13,
-  "verification-record": main15
+  "spec-commitment": main14,
+  "verification-record": main16
 };
 var COMMAND_HELP = {
   "guardian:judgeable": {
@@ -8404,7 +8759,7 @@ var COMMAND_HELP = {
   "guardian:deliver-key": {
     usage: "elgora-cli guardian:deliver-key <bounty_id> <solver> <submission_commitment>",
     title: "Deliver the finalized winner's content key for Poster retrieval.",
-    description: "Required after a bounty finalizes `awarded`: wrap the winning\n  Submission's key so the funding Poster can retrieve the work. Read the\n  winning Solver and Submission from ElgoraHub's finalized state (the\n  subgraph), not from a local Verdict, and pass exactly that pair. The\n  API rechecks against ElgoraHub and accepts only the current active or\n  finalized winner; written Verdicts and local state authorize nothing.\n  Idempotent \u2014 safe to re-run and safe if another Guardian already did it.",
+    description: "Required after a bounty finalizes `awarded`: wrap the winning\n  Submission's key so the funding Poster can retrieve the work. Read the\n  winning Solver and Submission from ElgoraHub's finalized state (the\n  subgraph), not from a local Verdict, and pass exactly that pair. The\n  API rechecks against ElgoraHub and accepts only the current active or\n  finalized winner; written Verdicts and local state authorize nothing.\n  Idempotent \u2014 safe to re-run and safe if another Guardian already did it.\n  Until the settlement block is behind the chain's finalized tag (about\n  10-20 minutes after settlement) it delivers nothing, prints\n  guardian_deliver_key.pending_finality, and exits 75; retry later.",
     required: [
       "ELGORA_GUARDIAN_ACCOUNT_PRIVATE_KEY",
       "ELGORA_GUARDIAN_PRIVATE_KEYS_JSON"
@@ -8417,10 +8772,23 @@ var COMMAND_HELP = {
     ],
     apiBaseUrlFlag: true
   },
+  "poster:review": {
+    usage: "elgora-cli poster:review <path|-> [--previous <commitment>] [--signoff-out <file>]",
+    title: "Review a bounty page and save its readiness certificate.",
+    description: "Send the exact Markdown for a signed readiness review. Ready prints\n  review.ready; --signoff-out saves the certificate for publication.\n  Not-ready prints all issues and exits 2; other failures exit 1.\n  --previous sends the previous page commitment with the signed request.",
+    required: ["ELGORA_POSTER_PRIVATE_KEY"],
+    defaulted: [
+      "ELGORA_CHAIN_ID",
+      "ELGORA_HUB_ADDRESS",
+      "ELGORA_RPC_URL",
+      "ELGORA_API_BASE_URL"
+    ],
+    apiBaseUrlFlag: true
+  },
   "poster:publish-fund": {
-    usage: "elgora-cli poster:publish-fund <bounty_challenge_md_path|->",
+    usage: "elgora-cli poster:publish-fund <bounty_challenge_md_path|-> --signoff <file>",
     title: "Publish an approved challenge and fund its bounty.",
-    description: "Read the exact approved bounty_challenge.md bytes and publish them through\n  Elgora's API. Eligible wallets sign a USDC authorization, then send\n  one funding transaction and pay gas. No new allowance is required;\n  this authorization path does not revoke existing allowances.\n  Unsupported accounts use approval then creation. Pass '-' to read stdin.",
+    description: "Read the exact approved bounty_challenge.md bytes and its saved certificate.\n  Publishing checks the certificate and never runs another AI review.\n  Eligible wallets sign a USDC authorization, then send\n  one funding transaction and pay gas. No new allowance is required;\n  this authorization path does not revoke existing allowances.\n  Unsupported accounts use approval then creation. Pass '-' to read stdin.",
     required: ["ELGORA_POSTER_PRIVATE_KEY"],
     defaulted: [
       "ELGORA_CHAIN_ID",
@@ -8546,6 +8914,11 @@ async function run(rawArgv) {
     process.exitCode = 1;
     return;
   }
+  const networkNotice = COMMAND_HELP[subcommand]?.defaulted?.includes(
+    "ELGORA_CHAIN_ID"
+  ) ? defaultNetworkNotice(env) : void 0;
+  if (networkNotice) process.stderr.write(`${networkNotice}
+`);
   const missing = missingRequiredEnv(
     COMMAND_HELP[subcommand]?.required ?? [],
     env
@@ -8580,6 +8953,7 @@ function printUsage() {
       "",
       `Every command accepts ${NETWORK_FLAG} <name|chain id> to select the`,
       `deployment for that invocation. Supported: ${NETWORK_NAMES_HINT}.`,
+      ...DEFAULT_NETWORK_HELP_LINES,
       "",
       "Run `elgora-cli help <command>` for exact arguments and configuration.",
       "Run `elgora-cli --version` to print this release's version."
@@ -8615,7 +8989,8 @@ function printCommandHelpOrUsage(name) {
       "",
       `Accepts ${NETWORK_FLAG} <name|chain id>; it sets ELGORA_CHAIN_ID for`,
       "this invocation, winning over the environment.",
-      `Supported: ${NETWORK_NAMES_HINT}.`
+      `Supported: ${NETWORK_NAMES_HINT}.`,
+      ...DEFAULT_NETWORK_HELP_LINES
     );
   }
   if (help.apiBaseUrlFlag) {