@elgora/cli 12.0.0 → 12.1.0

package/README.md

@@ -38,6 +38,8 @@ answer.
   returns an issue list and exits non-zero on failure. It needs no wallet or
   network and does not replace hosted semantic readiness review.
 - `spec-commitment` reproduces the challenge's `spec_commitment` offline.
+- `solver:solvable` lists open bounties still before their Submission
+  deadline, filtered by escrow amount, time left and challenge keywords.
 - `solver:check <bounty_id> <folder_or_file>` runs the Submission check that
   `solver:submit` and `guardian:open` also run, without submitting, and exits
   1 on any issue.
@@ -164,7 +166,7 @@ for that invocation without touching the environment. It takes a network name
 passed — for that run only:
 
 ```sh
-elgora-cli guardian:judgeable                        # Base mainnet, the default
+elgora-cli spec-commitment bounty_challenge.md       # Base mainnet, the default
 elgora-cli claim --network base-sepolia 7            # testnet, by name
 elgora-cli claim --network 84532 7                   # the same, by chain id
 export ELGORA_CHAIN_ID=84532                         # testnet for every run in this shell

package/dist/cli.js

@@ -1233,11 +1233,6 @@ function extractFlagValue(argv, flag) {
   return { value, argv: remaining };
 }
 
-// ../../packages/core/src/bounty-challenge-headings.ts
-function hasLineBreak(text) {
-  return /[\r\u2028\u2029]/.test(text);
-}
-
 // ../../packages/core/src/bounty-challenge-markdown.ts
 import { keccak256 as keccak2562, toBytes as toBytes2 } from "viem";
 import { z as z3 } from "zod";
@@ -1346,6 +1341,7 @@ function isKnownProtocolProfile(version) {
 
 // ../../packages/core/src/bounty-challenge-markdown.ts
 var FRONTMATTER_DELIMITER = "---";
+var YAML_LIST_ITEM = /^\s+-\s/;
 var ALLOWED_FRONTMATTER_KEYS = [
   ...BOUNTY_CHALLENGE_FRONTMATTER_KEYS,
   ...BOUNTY_CHALLENGE_OPTIONAL_FRONTMATTER_KEYS
@@ -1461,6 +1457,15 @@ function splitConstraintsBlock(lines, issues) {
       index += 1;
       const parsed = frontmatterEntry(entry.trim());
       if (!parsed || parsed.value === "") {
+        if (parsed && YAML_LIST_ITEM.test(lines[index + 1] ?? "")) {
+          while (YAML_LIST_ITEM.test(lines[index + 1] ?? "")) index += 1;
+          seenKeys.add(parsed.key);
+          issues.push({
+            path: `frontmatter.constraints.${parsed.key}`,
+            message: `"${parsed.key}" must be an inline list on one line, written as ${parsed.key}: [a, b]`
+          });
+          continue;
+        }
         issues.push({
           path: `frontmatter.constraints.line_${index + 2}`,
           message: "Constraint entries must use snake_case_key: value"
@@ -1500,6 +1505,9 @@ function frontmatterEntry(line) {
   const value = line.slice(key.length).trimStart();
   return hasLineBreak(value) ? null : { key: key.slice(0, -1), value };
 }
+function hasLineBreak(text) {
+  return /[\r\u2028\u2029]/.test(text);
+}
 function parsePublicationTermsFrontmatter(lines, issues) {
   const values = /* @__PURE__ */ new Map();
   let foundUnsupportedKey = false;
@@ -4302,6 +4310,9 @@ function settlementAmounts(escrowAmount, treasuryFeeBps, guardianFeeBps) {
   };
 }
 
+// ../../packages/core/src/api/bounty-list.ts
+import { z as z6 } from "zod";
+
 // ../../packages/core/src/api/bounty-preparation.ts
 import { ZodError, z as z5 } from "zod";
 
@@ -4349,6 +4360,12 @@ var ELGORA_HUB_OWNERSHIP_READ_ABI = [
   getAbiItem2({ abi: ELGORA_HUB_ABI, name: "pendingOwner" }),
   ...ELGORA_HUB_ERRORS
 ];
+var SUBMISSION_CAP_READ_ABI = [
+  getAbiItem2({ abi: ELGORA_HUB_ABI, name: "submissionGuard" }),
+  ...parseAbi([
+    "function maximumSubmissions(uint256 bountyId) view returns (uint256)"
+  ])
+];
 var ELGORA_HUB_BOUNTY_CREATED_EVENT = getAbiItem2({
   abi: ELGORA_HUB_ABI,
   name: "BountyCreated"
@@ -4541,9 +4558,54 @@ var artifactUploadUrlRequestSchema = z5.object({
   ciphertext_byte_length: z5.number().int().positive().max(MAX_SOLVER_SUBMISSION_CIPHERTEXT_BYTES)
 }).strict();
 
+// ../../packages/core/src/api/bounty-list.ts
+var BOUNTY_LIST_MAX_FIRST = 100;
+var integerString = z6.string().regex(/^(0|[1-9]\d*)$/, {
+  message: "Must be a non-negative integer"
+});
+var bountyFilterFields = {
+  min_amount: integerString.optional(),
+  max_amount: integerString.optional(),
+  min_time_left: integerString.optional(),
+  max_time_left: integerString.optional()
+};
+var bountyListParamsSchema = z6.object({
+  ...bountyFilterFields,
+  status: z6.enum(BOUNTY_STATUSES).optional(),
+  first: integerString.transform(Number).refine((value) => value >= 1 && value <= BOUNTY_LIST_MAX_FIRST, {
+    message: `Must be from 1 to ${BOUNTY_LIST_MAX_FIRST}`
+  }).optional(),
+  skip: integerString.transform(Number).optional()
+}).strict();
+var hexSchema = z6.custom(
+  (value) => typeof value === "string" && /^0x[0-9a-f]*$/i.test(value)
+);
+var listedBountySchema = z6.object({
+  bounty_id: z6.string(),
+  status: z6.enum(BOUNTY_STATUSES),
+  poster: hexSchema,
+  spec_commitment: hexSchema,
+  escrow: z6.object({ token_address: hexSchema, amount: z6.string() }),
+  submission_deadline: z6.number().int(),
+  submission_count: z6.number().int(),
+  winner: hexSchema.nullable(),
+  created_at: z6.number().int()
+});
+var bountyListResponseSchema = z6.object({
+  chain_id: z6.number().int(),
+  hub_address: hexSchema,
+  /** Bounties matching the filter, before `first` and `skip`. */
+  total: z6.number().int(),
+  bounties: z6.array(listedBountySchema)
+});
+function challengeMatchesKeywords(challenge, keywords) {
+  const text = challenge.toLowerCase();
+  return keywords.every((keyword) => text.includes(keyword.toLowerCase()));
+}
+
 // ../../packages/core/src/api/config.ts
 import { createHash } from "crypto";
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 function withDeploymentEnvDefaults(env) {
   const merged = { ...env };
   const setIfBlank = (key, value) => {
@@ -4564,11 +4626,11 @@ function withDeploymentEnvDefaults(env) {
   setIfBlank("ELGORA_SUBGRAPH_ENDPOINT", deployment?.ELGORA_SUBGRAPH_ENDPOINT);
   return merged;
 }
-var chainIdField = z6.coerce.number().int().positive().refine((chainId) => SUPPORTED_CHAINS[chainId] !== void 0, {
+var chainIdField = z7.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 = z6.string().refine(isHexAddress, "ELGORA_HUB_ADDRESS must be a 20-byte EVM address").transform((value) => value.toLowerCase());
-var publicDeploymentEnvSchema = z6.object({
+var hubAddressField = z7.string().refine(isHexAddress, "ELGORA_HUB_ADDRESS must be a 20-byte EVM address").transform((value) => value.toLowerCase());
+var publicDeploymentEnvSchema = z7.object({
   ELGORA_CHAIN_ID: chainIdField,
   ELGORA_HUB_ADDRESS: hubAddressField
 });
@@ -4584,30 +4646,30 @@ function loadPublicDeploymentConfig(env = process.env) {
 var envShape = {
   ELGORA_CHAIN_ID: chainIdField,
   ELGORA_HUB_ADDRESS: hubAddressField,
-  ELGORA_ESCROW_TOKEN_ADDRESS: z6.string().refine(
+  ELGORA_ESCROW_TOKEN_ADDRESS: z7.string().refine(
     isHexAddress,
     "ELGORA_ESCROW_TOKEN_ADDRESS must be a 20-byte EVM address"
   ).transform((value) => value.toLowerCase()),
-  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"),
+  ELGORA_TIMELOCK_REVEAL_DELAY_SECONDS: z7.coerce.number().int().nonnegative().default(DEFAULT_TIMELOCK_REVEAL_DELAY_SECONDS),
+  ELGORA_RPC_URL: z7.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: z6.string().refine(
+  ELGORA_PAYOUT_SCHEME_ADDRESS: z7.string().refine(
     isHexAddress,
     "ELGORA_PAYOUT_SCHEME_ADDRESS must be a 20-byte EVM address"
   ).transform((value) => value.toLowerCase()).optional(),
-  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")
+  ELGORA_DATABASE_URL: z7.string().min(1, "ELGORA_DATABASE_URL is required"),
+  ELGORA_SUBGRAPH_ENDPOINT: z7.string().min(1, "ELGORA_SUBGRAPH_ENDPOINT is required"),
+  ELGORA_ARTIFACT_STORAGE_ENDPOINT: z7.string().min(1, "ELGORA_ARTIFACT_STORAGE_ENDPOINT is required"),
+  ELGORA_ARTIFACT_STORAGE_REGION: z7.string().min(1, "ELGORA_ARTIFACT_STORAGE_REGION is required"),
+  ELGORA_ARTIFACT_STORAGE_BUCKET: z7.string().min(1, "ELGORA_ARTIFACT_STORAGE_BUCKET is required"),
+  ELGORA_ARTIFACT_STORAGE_ACCESS_KEY_ID: z7.string().min(1, "ELGORA_ARTIFACT_STORAGE_ACCESS_KEY_ID is required"),
+  ELGORA_ARTIFACT_STORAGE_SECRET_ACCESS_KEY: z7.string().min(1, "ELGORA_ARTIFACT_STORAGE_SECRET_ACCESS_KEY is required"),
+  ELGORA_DELIVERY_PUBLIC_KEY: z7.string().min(1, "ELGORA_DELIVERY_PUBLIC_KEY is required"),
+  ELGORA_DELIVERY_PRIVATE_KEY: z7.string().min(1, "ELGORA_DELIVERY_PRIVATE_KEY is required")
 };
 var publicationEnvShape = {
   ELGORA_CHAIN_ID: envShape.ELGORA_CHAIN_ID,
@@ -4615,89 +4677,89 @@ var publicationEnvShape = {
   ELGORA_ESCROW_TOKEN_ADDRESS: envShape.ELGORA_ESCROW_TOKEN_ADDRESS,
   ELGORA_DATABASE_URL: envShape.ELGORA_DATABASE_URL,
   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(READINESS_TIMEOUT_MS).default(READINESS_TIMEOUT_MS)
+  ELGORA_PUBLICATION_REVIEW_ENABLED: z7.string().trim().toLowerCase().pipe(z7.enum(["true", "false"])).default("true").transform((value) => value === "true"),
+  ELGORA_READINESS_TIMEOUT_MS: z7.coerce.number().int().min(1).max(READINESS_TIMEOUT_MS).default(READINESS_TIMEOUT_MS)
 };
-var envSchema = z6.object(envShape);
-var bountyPublicationEnvSchema = z6.object(publicationEnvShape);
+var envSchema = z7.object(envShape);
+var bountyPublicationEnvSchema = z7.object(publicationEnvShape);
 
 // ../../packages/core/src/api/solver-submission-responses.ts
 import { isHex as isHex3 } 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 artifactUploadUrlResponseSchema = z7.object({
-  locator: z7.string().min(1),
-  upload_url: z7.string().min(1),
-  method: z7.literal("PUT"),
-  expires_at: z7.string().min(1)
+import { z as z8 } from "zod";
+var hexAddressSchema = z8.string().refine(isHexAddress, "Must be a hex-encoded address");
+var hexBytes32Schema = z8.string().refine(isHexBytes32, "Must be 32-byte hex");
+var hexDataSchema = z8.string().refine((value) => isHex3(value), "Must be hex-encoded calldata");
+var artifactUploadUrlResponseSchema = z8.object({
+  locator: z8.string().min(1),
+  upload_url: z8.string().min(1),
+  method: z8.literal("PUT"),
+  expires_at: z8.string().min(1)
 });
-var solverSubmissionPrepareResponseSchema = z7.object({
-  content_record: z7.object({
-    content_kind: z7.literal(SOLVER_SUBMISSION_CONTENT_KIND),
+var solverSubmissionPrepareResponseSchema = z8.object({
+  content_record: z8.object({
+    content_kind: z8.literal(SOLVER_SUBMISSION_CONTENT_KIND),
     submission_commitment: hexBytes32Schema,
-    byte_length: z7.number().int().nonnegative(),
-    created_at: z7.string().min(1)
+    byte_length: z8.number().int().nonnegative(),
+    created_at: z8.string().min(1)
   }),
-  submit_transaction: z7.object({
-    chain_id: z7.number().int().positive(),
+  submit_transaction: z8.object({
+    chain_id: z8.number().int().positive(),
     to: hexAddressSchema,
-    value: z7.literal("0"),
+    value: z8.literal("0"),
     data: hexDataSchema,
-    function_name: z7.literal("submit"),
-    args: z7.object({
-      bounty_id: z7.string().min(1),
+    function_name: z8.literal("submit"),
+    args: z8.object({
+      bounty_id: z8.string().min(1),
       submission_commitment: hexBytes32Schema,
       guardian_roster_hash: hexBytes32Schema,
-      extra_data: z7.literal("0x")
+      extra_data: z8.literal("0x")
     })
   })
 });
-var solverSubmissionContentResponseSchema = z7.object({
-  content_record: z7.object({
-    bounty_id: z7.string().min(1),
-    canonical_json: z7.string().min(1)
+var solverSubmissionContentResponseSchema = z8.object({
+  content_record: z8.object({
+    bounty_id: z8.string().min(1),
+    canonical_json: z8.string().min(1)
   }),
-  ciphertext_download_url: z7.string().min(1),
-  expires_at: z7.string().min(1)
+  ciphertext_download_url: z8.string().min(1),
+  expires_at: z8.string().min(1)
 });
-var bountySubmissionDetailResponseSchema = z7.object({
-  bounty: z7.object({
+var bountySubmissionDetailResponseSchema = z8.object({
+  bounty: z8.object({
     guardian_roster_hash: hexBytes32Schema,
-    guardian_roster: z7.array(
-      z7.object({
-        name: z7.string(),
+    guardian_roster: z8.array(
+      z8.object({
+        name: z8.string(),
         account: hexAddressSchema,
-        encryption_public_key: z7.string().min(1)
+        encryption_public_key: z8.string().min(1)
       })
     ).min(1)
   }),
-  challenge: z7.string().nullable()
+  challenge: z8.string().nullable()
 });
 
 // ../../packages/core/src/api/verification-records.ts
-import { z as z8 } from "zod";
-var hexAddressSchema2 = z8.string().refine(isHexAddress, "Must be a hex-encoded address").transform((value) => value.toLowerCase());
-var hexBytes32Schema2 = z8.string().refine(isHexBytes32, "Must be 32-byte hex").transform((value) => value.toLowerCase());
-var integerStringSchema = z8.string().regex(/^(0|[1-9][0-9]*)$/);
-var verdictEntrySchema = z8.object({
-  name: z8.string().min(1),
-  outcome: z8.enum(["awarded", "no_valid_submission"]).nullable(),
+import { z as z9 } from "zod";
+var hexAddressSchema2 = z9.string().refine(isHexAddress, "Must be a hex-encoded address").transform((value) => value.toLowerCase());
+var hexBytes32Schema2 = z9.string().refine(isHexBytes32, "Must be 32-byte hex").transform((value) => value.toLowerCase());
+var integerStringSchema = z9.string().regex(/^(0|[1-9][0-9]*)$/);
+var verdictEntrySchema = z9.object({
+  name: z9.string().min(1),
+  outcome: z9.enum(["awarded", "no_valid_submission"]).nullable(),
   winner: hexAddressSchema2.nullable(),
   report_commitment: hexBytes32Schema2.nullable(),
-  committed_at: z8.string().datetime({ offset: true }).nullable(),
-  supporting: z8.boolean()
+  committed_at: z9.string().datetime({ offset: true }).nullable(),
+  supporting: z9.boolean()
 }).strict();
-var formattedVerificationRecordSchema = z8.object({
-  chain_id: z8.number().int().positive(),
+var formattedVerificationRecordSchema = z9.object({
+  chain_id: z9.number().int().positive(),
   hub_address: hexAddressSchema2,
   bounty_id: integerStringSchema,
-  status: z8.enum(["awarded", "no_valid_submission", "timed_out"]),
+  status: z9.enum(["awarded", "no_valid_submission", "timed_out"]),
   spec_commitment: hexBytes32Schema2,
   winner: hexAddressSchema2.nullable(),
-  verdicts: z8.record(z8.string(), verdictEntrySchema),
-  settlement: z8.object({
+  verdicts: z9.record(z9.string(), verdictEntrySchema),
+  settlement: z9.object({
     escrow_amount: integerStringSchema,
     settlement_recipient: hexAddressSchema2,
     settlement_amount: integerStringSchema,
@@ -4708,10 +4770,10 @@ var formattedVerificationRecordSchema = z8.object({
     settled_tx_hash: hexBytes32Schema2,
     settled_block_number: integerStringSchema
   }).strict(),
-  content_record: z8.object({
-    spec_content_byte_length: z8.number().int().positive()
+  content_record: z9.object({
+    spec_content_byte_length: z9.number().int().positive()
   }).strict(),
-  verified_at: z8.string().datetime({ offset: true })
+  verified_at: z9.string().datetime({ offset: true })
 }).strict();
 function parseBountyVerificationRecord(input, expected) {
   const slice = input;
@@ -4733,66 +4795,66 @@ function parseBountyVerificationRecord(input, expected) {
 }
 
 // ../../packages/core/src/api/winning-solution-delivery.ts
-import { z as z9 } from "zod";
-var hexBytes32Schema3 = z9.string().refine(isHexBytes32, "Must be 32-byte hex").refine((value) => value !== ZERO_BYTES32, "Must not be zero").transform((value) => value.toLowerCase());
-var hexAddressSchema3 = z9.string().refine((value) => /^0x[0-9a-fA-F]{40}$/.test(value), "Must be an address").transform((value) => value.toLowerCase());
-var deliveryKeyIdSchema = z9.string().min(1).max(128);
-var winningSolutionWrappedKeySchema = z9.strictObject({
-  enc: z9.string().min(1),
-  ciphertext: z9.string().min(1)
+import { z as z10 } from "zod";
+var hexBytes32Schema3 = z10.string().refine(isHexBytes32, "Must be 32-byte hex").refine((value) => value !== ZERO_BYTES32, "Must not be zero").transform((value) => value.toLowerCase());
+var hexAddressSchema3 = z10.string().refine((value) => /^0x[0-9a-fA-F]{40}$/.test(value), "Must be an address").transform((value) => value.toLowerCase());
+var deliveryKeyIdSchema = z10.string().min(1).max(128);
+var winningSolutionWrappedKeySchema = z10.strictObject({
+  enc: z10.string().min(1),
+  ciphertext: z10.string().min(1)
 });
-var deliveryWrapRequestSchema = z9.strictObject({
+var deliveryWrapRequestSchema = z10.strictObject({
   solver_address: hexAddressSchema3,
   submission_commitment: hexBytes32Schema3,
   wrapped_key: winningSolutionWrappedKeySchema
 });
-var deliveryWrapRecordSchema = z9.strictObject({
-  bounty_id: z9.string().min(1),
+var deliveryWrapRecordSchema = z10.strictObject({
+  bounty_id: z10.string().min(1),
   guardian_address: hexAddressSchema3,
   solver_address: hexAddressSchema3,
   submission_commitment: hexBytes32Schema3,
   delivery_key_id: deliveryKeyIdSchema,
-  created_at: z9.string().min(1)
+  created_at: z10.string().min(1)
 });
-var deliveryWrapResponseSchema = z9.strictObject({
-  status: z9.literal("stored"),
+var deliveryWrapResponseSchema = z10.strictObject({
+  status: z10.literal("stored"),
   wrap: deliveryWrapRecordSchema
 });
-var deliveryRetrieveRequestSchema = z9.strictObject({
+var deliveryRetrieveRequestSchema = z10.strictObject({
   poster_ephemeral_public_key: x25519PublicKeySchema
 });
-var deliveryRetrieveResponseSchema = z9.strictObject({
+var deliveryRetrieveResponseSchema = z10.strictObject({
   submission_commitment: hexBytes32Schema3,
   wrapped_key: winningSolutionWrappedKeySchema
 });
-var deliveryStatusResponseSchema = z9.strictObject({
-  exists: z9.boolean()
+var deliveryStatusResponseSchema = z10.strictObject({
+  exists: z10.boolean()
 });
-var deliveryKeyConfigResponseSchema = z9.strictObject({
+var deliveryKeyConfigResponseSchema = z10.strictObject({
   delivery_key_id: deliveryKeyIdSchema,
-  public_key: z9.string().min(1)
+  public_key: z10.string().min(1)
 });
 
 // ../../packages/core/src/api/written-verdicts.ts
 import { keccak256 as keccak2564, toBytes as toBytes3, zeroAddress } from "viem";
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var WRITTEN_VERDICT_FORMAT_VERSION = 0;
 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 decimalSchema = z11.string().regex(/^[1-9][0-9]*$/, "Must be a positive integer").transform(Number).refine(Number.isSafeInteger, "Must be a safe integer");
+var bountyIdSchema2 = z11.string().regex(/^(0|[1-9][0-9]*)$/, "Must be a non-negative integer");
+var addressSchema2 = z11.string().refine(isHexAddress, "Must be a hex-encoded address").refine((value) => value === value.toLowerCase(), "Must use lowercase hex").transform((value) => value);
+var bytes32Schema3 = z11.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),
+  format_version: z11.literal(WRITTEN_VERDICT_FORMAT_VERSION.toString()).transform(() => WRITTEN_VERDICT_FORMAT_VERSION),
   chain_id: decimalSchema,
   hub_address: addressSchema2,
   bounty_id: bountyIdSchema2,
-  verdict_body: z10.string().refine((value) => value.trim().length > 0, "Must not be empty")
+  verdict_body: z11.string().refine((value) => value.trim().length > 0, "Must not be empty")
 };
-var writtenVerdictSchema = z10.discriminatedUnion("outcome", [
-  z10.object({
+var writtenVerdictSchema = z11.discriminatedUnion("outcome", [
+  z11.object({
     ...commonFields,
-    outcome: z10.literal("awarded"),
+    outcome: z11.literal("awarded"),
     winner: addressSchema2.refine(
       (value) => value !== zeroAddress,
       "Must not be the zero address"
@@ -4802,10 +4864,10 @@ var writtenVerdictSchema = z10.discriminatedUnion("outcome", [
       "Must not be zero bytes"
     )
   }).strict(),
-  z10.object({
+  z11.object({
     ...commonFields,
-    outcome: z10.literal("no_valid_submission"),
-    winner: z10.literal(zeroAddress)
+    outcome: z11.literal("no_valid_submission"),
+    winner: z11.literal(zeroAddress)
   }).strict()
 ]);
 function buildWrittenVerdictMarkdown(input) {
@@ -4900,17 +4962,17 @@ import { parseEventLogs } from "viem";
 
 // ../../packages/core/src/api-client-config.ts
 var LOCAL_DEV_API_BASE_URL = "http://127.0.0.1:3000";
-function loadApiClientConfig(env, apiBaseUrlOverride) {
-  return { apiBaseUrl: resolveApiBaseUrl(env, apiBaseUrlOverride) };
+function loadApiClientConfig(env) {
+  return { apiBaseUrl: resolveApiBaseUrl(env) };
 }
-function loadClientDeploymentConfig(env, apiBaseUrlOverride) {
+function loadClientDeploymentConfig(env) {
   return {
     ...loadPublicDeploymentConfig(env),
-    ...loadApiClientConfig(env, apiBaseUrlOverride)
+    ...loadApiClientConfig(env)
   };
 }
-function resolveApiBaseUrl(env, override) {
-  const value = override?.trim() || env.ELGORA_API_BASE_URL?.trim() || defaultApiBaseUrl(env);
+function resolveApiBaseUrl(env) {
+  const value = env.ELGORA_API_BASE_URL?.trim() || defaultApiBaseUrl(env);
   try {
     new URL(value);
   } catch {
@@ -6221,7 +6283,7 @@ function typedDataForRequest(request, block) {
 }
 
 // ../../packages/core/src/auth/request-approval-header.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 async function buildAuthorizationHeader(params) {
   const url = new URL(params.requestUrl);
   const typedData = typedDataForRequest(
@@ -6248,8 +6310,8 @@ async function authorizeRequest(params) {
     block: await readChallengeBlock(params)
   });
 }
-var challengeBlockSchema = z11.object({
-  error: z11.object({ block_number: z11.string(), block_hash: z11.string() })
+var challengeBlockSchema = z12.object({
+  error: z12.object({ block_number: z12.string(), block_hash: z12.string() })
 });
 async function readChallengeBlock(params) {
   const response = await fetch(params.requestUrl, {
@@ -6623,10 +6685,10 @@ function readSubmissionArchive(archive) {
   assertSubmissionFiles(files);
   return { files, ...describeFiles(files) };
 }
-function requireCurrentFormat(alg, bountyId, command18) {
+function requireCurrentFormat(alg, bountyId, command20) {
   if (alg !== SUBMISSION_ENCRYPTION_TYPE_V1) {
     throw new Error(
-      `Bounty ${bountyId} declares ${BOUNTY_CHALLENGE_PROFILE}, which this CLI does not handle. Use CLI 11 for it: npx @elgora/cli@11 ${command18}`
+      `Bounty ${bountyId} declares ${BOUNTY_CHALLENGE_PROFILE}, which this CLI does not handle. Use CLI 11 for it: npx @elgora/cli@11 ${command20}`
     );
   }
 }
@@ -7108,6 +7170,8 @@ var BOUNTY_FIELDS = `
   submissionCount
   createdTxHash
   createdAt
+  createdBlockNumber
+  createdLogIndex
   consensusReachedAt
   consensusOutcome
   consensusWinner
@@ -7115,6 +7179,7 @@ var BOUNTY_FIELDS = `
   settledTxHash
   settledAt
   settledBlockNumber
+  settledLogIndex
   updatedAt
 `;
 var LIST_BOUNTIES_QUERY = `
@@ -7141,6 +7206,7 @@ var SUBMISSION_FIELDS = `
   submissionCommitment
   recordedAt
   recordedBlockNumber
+  recordedLogIndex
   recordedTxHash
   submissionCallCount
 `;
@@ -7153,8 +7219,18 @@ var VERDICT_FIELDS = `
   payoutData
   committedTxHash
   committedAt
+  committedBlockNumber
+  committedLogIndex
   updatedAt
 `;
+var CLAIM_FIELDS = `
+  claimant
+  amount
+  claimedAt
+  claimedBlockNumber
+  claimedLogIndex
+  claimedTxHash
+`;
 var GUARDIAN_ROSTER_SNAPSHOT_FIELDS = `
   id
   memberCount
@@ -7181,7 +7257,6 @@ var BOUNTY_DETAIL_QUERY = `
       reportCommitments
       awardedPayoutData
       timedOutRefundAmount
-      settledLogIndex
       claimsQueued(first: 1, orderBy: queuedLogIndex, orderDirection: desc) {
         recipient
         amount
@@ -7197,6 +7272,9 @@ var BOUNTY_DETAIL_QUERY = `
       verdicts {
         ${VERDICT_FIELDS}
       }
+      claims(orderBy: claimedAt, orderDirection: asc) {
+        ${CLAIM_FIELDS}
+      }
     }
   }
 `;
@@ -7208,6 +7286,7 @@ var ANALYTICS_SNAPSHOT_QUERY = `
     $rosterSkip: Int!
     $submissionSkip: Int!
     $verdictSkip: Int!
+    $claimSkip: Int!
     $block: Block_height
   ) {
     _meta(block: $block) {
@@ -7260,6 +7339,16 @@ var ANALYTICS_SNAPSHOT_QUERY = `
       bountyId
       ${VERDICT_FIELDS}
     }
+    claims(
+      first: $first
+      skip: $claimSkip
+      orderBy: id
+      orderDirection: asc
+      block: $block
+    ) {
+      bountyId
+      ${CLAIM_FIELDS}
+    }
   }
 `;
 var DEPLOYMENT_CONFIG_QUERY = `
@@ -7386,11 +7475,13 @@ function createElgoraSubgraphClient(options) {
       const rosterSnapshots = [];
       const submissions = [];
       const verdicts = [];
+      const claims = [];
       let indexedBlockNumber = null;
       let bountySkip = 0;
       let rosterSkip = 0;
       let submissionSkip = 0;
       let verdictSkip = 0;
+      let claimSkip = 0;
       for (; ; ) {
         const data = await execute(
           ANALYTICS_SNAPSHOT_QUERY,
@@ -7401,7 +7492,8 @@ function createElgoraSubgraphClient(options) {
             includeGuardianHistory,
             rosterSkip,
             submissionSkip,
-            verdictSkip
+            verdictSkip,
+            claimSkip
           }
         );
         const meta = readRecord(data._meta);
@@ -7420,23 +7512,27 @@ function createElgoraSubgraphClient(options) {
         const rosterPage = includeGuardianHistory ? asArray(data.guardianRosterSnapshots, "guardianRosterSnapshots") : [];
         const submissionPage = asArray(data.submissions, "submissions");
         const verdictPage = asArray(data.verdicts, "verdicts");
+        const claimPage = asArray(data.claims, "claims");
         bounties.push(...bountyPage.map(mapAnalyticsBounty));
         rosterSnapshots.push(...rosterPage.map(mapAnalyticsGuardianRoster));
         submissions.push(...submissionPage.map(mapListedSubmission));
         verdicts.push(...verdictPage.map(mapListedVerdict));
-        if (bountyPage.length < BOUNTY_PAGE_SIZE && rosterPage.length < BOUNTY_PAGE_SIZE && submissionPage.length < BOUNTY_PAGE_SIZE && verdictPage.length < BOUNTY_PAGE_SIZE) {
+        claims.push(...claimPage.map(mapListedClaim));
+        if (bountyPage.length < BOUNTY_PAGE_SIZE && rosterPage.length < BOUNTY_PAGE_SIZE && submissionPage.length < BOUNTY_PAGE_SIZE && verdictPage.length < BOUNTY_PAGE_SIZE && claimPage.length < BOUNTY_PAGE_SIZE) {
           return {
             indexedBlockNumber,
             bounties,
             rosterSnapshots,
             submissions,
-            verdicts
+            verdicts,
+            claims
           };
         }
         bountySkip += bountyPage.length;
         rosterSkip += rosterPage.length;
         submissionSkip += submissionPage.length;
         verdictSkip += verdictPage.length;
+        claimSkip += claimPage.length;
       }
     },
     async getBounty(bountyId) {
@@ -7525,6 +7621,11 @@ function mapBounty(row) {
     submissionCount: asNumber(record.submissionCount, "submissionCount"),
     createdTxHash: asHex(record.createdTxHash, "createdTxHash"),
     createdAt: asString(record.createdAt, "createdAt"),
+    createdBlockNumber: asString(
+      record.createdBlockNumber,
+      "createdBlockNumber"
+    ),
+    createdLogIndex: asNumber(record.createdLogIndex, "createdLogIndex"),
     consensusReachedAt: asNullableString(
       record.consensusReachedAt,
       "consensusReachedAt"
@@ -7541,6 +7642,7 @@ function mapBounty(row) {
       record.settledBlockNumber,
       "settledBlockNumber"
     ),
+    settledLogIndex: record.settledLogIndex == null ? null : asNumber(record.settledLogIndex, "settledLogIndex"),
     updatedAt: asString(record.updatedAt, "updatedAt")
   };
 }
@@ -7624,7 +7726,8 @@ function mapBountyDetail(row) {
     submissions: asArray(record.submissions, "submissions").map(
       mapSubmissionFields
     ),
-    verdicts: asArray(record.verdicts, "verdicts").map(mapVerdict)
+    verdicts: asArray(record.verdicts, "verdicts").map(mapVerdict),
+    claims: asArray(record.claims, "claims").map(mapClaim)
   };
 }
 function mapVerdict(row) {
@@ -7641,6 +7744,11 @@ function mapVerdict(row) {
     payoutData: asHex(record.payoutData, "payoutData"),
     committedTxHash: asHex(record.committedTxHash, "committedTxHash"),
     committedAt: asString(record.committedAt, "committedAt"),
+    committedBlockNumber: asString(
+      record.committedBlockNumber,
+      "committedBlockNumber"
+    ),
+    committedLogIndex: asNumber(record.committedLogIndex, "committedLogIndex"),
     updatedAt: asString(record.updatedAt, "updatedAt")
   };
 }
@@ -7651,6 +7759,27 @@ function mapListedVerdict(row) {
     ...mapVerdict(record)
   };
 }
+function mapClaim(row) {
+  const record = readRecord(row);
+  return {
+    claimant: asHex(record.claimant, "claimant"),
+    amount: asString(record.amount, "amount"),
+    claimedAt: asString(record.claimedAt, "claimedAt"),
+    claimedBlockNumber: asString(
+      record.claimedBlockNumber,
+      "claimedBlockNumber"
+    ),
+    claimedLogIndex: asNumber(record.claimedLogIndex, "claimedLogIndex"),
+    claimedTxHash: asHex(record.claimedTxHash, "claimedTxHash")
+  };
+}
+function mapListedClaim(row) {
+  const record = readRecord(row);
+  return {
+    bountyId: asString(record.bountyId, "bountyId"),
+    ...mapClaim(record)
+  };
+}
 function mapListedSubmission(row) {
   const record = readRecord(row);
   return {
@@ -7671,6 +7800,7 @@ function mapSubmissionFields(row) {
       record.recordedBlockNumber,
       "recordedBlockNumber"
     ),
+    recordedLogIndex: asNumber(record.recordedLogIndex, "recordedLogIndex"),
     recordedTxHash: asHex(record.recordedTxHash, "recordedTxHash"),
     submissionCallCount: asNumber(
       record.submissionCallCount,
@@ -8386,7 +8516,7 @@ function resolveChainId(selector) {
 }
 
 // src/version.ts
-var CLI_VERSION = true ? "12.0.0" : "0.0.0-dev";
+var CLI_VERSION = true ? "12.1.0" : "0.0.0-dev";
 var CLI_NODE_ENGINES = true ? "24.x || 26.x" : "24.x || 26.x";
 
 // src/node-engines.ts
@@ -9739,12 +9869,163 @@ async function checkSubmission(input) {
 }
 var command15 = { main: main15, OPTIONS: OPTIONS15, USAGE: USAGE15 };
 
+// src/bounty-filter-flags.ts
+var BOUNTY_FILTER_OPTIONS = {
+  "--min-amount": "value",
+  "--max-amount": "value",
+  "--min-time-left": "value",
+  "--max-time-left": "value",
+  "--keyword": "list"
+};
+var BOUNTY_FILTER_USAGE = "[--min-amount <units>] [--max-amount <units>]\n  [--min-time-left <seconds>] [--max-time-left <seconds>]\n  [--keyword <word>]...";
+var NUMERIC_FILTERS = [
+  ["--min-amount", "min_amount"],
+  ["--max-amount", "max_amount"],
+  ["--min-time-left", "min_time_left"],
+  ["--max-time-left", "max_time_left"]
+];
+function readBountyFilterFlags(args) {
+  const fields = {};
+  for (const [flag, field] of NUMERIC_FILTERS) {
+    const value = args.value(flag);
+    if (value === void 0) continue;
+    if (!/^(0|[1-9]\d*)$/.test(value)) {
+      throw new Error(`${flag} must be a non-negative integer`);
+    }
+    fields[field] = value;
+  }
+  return fields;
+}
+
+// src/solver-notifications.ts
+var OPTIONS16 = {
+  "--webhook-url": "value",
+  ...BOUNTY_FILTER_OPTIONS,
+  ...API_OPTIONS,
+  ...ACCOUNT_OPTIONS
+};
+var USAGE16 = `elgora-cli solver:notifications subscribe --webhook-url <https_url>
+  ${BOUNTY_FILTER_USAGE}
+elgora-cli solver:notifications list
+elgora-cli solver:notifications unsubscribe <subscription_id>`;
+var PATH = "/api/notifications/subscriptions";
+async function main16(env = process.env, argv = process.argv.slice(2)) {
+  const parsed = parseArgs(argv, OPTIONS16);
+  const request = readNotificationRequest(parsed, env);
+  const config = loadApiDeployment(env, parsed);
+  const { signer } = await connectAccount(env, parsed, config);
+  const url = new URL(PATH, config.apiBaseUrl);
+  const body = JSON.stringify(request);
+  const authorization = await authorizeRequest({
+    requestUrl: url.toString(),
+    method: "POST",
+    contentType: "application/json",
+    body,
+    chainId: config.chainId,
+    hubAddress: config.hubAddress,
+    address: signer.address,
+    sign: signer.approvals.signTypedData
+  });
+  const response = await postText(url, body, "application/json", authorization);
+  process.stdout.write(
+    `${JSON.stringify({ event: `notifications.${request.action}`, ...response })}
+`
+  );
+}
+function readNotificationRequest(args, env) {
+  const [action, ...rest] = args.positionals;
+  if (action === "list" && rest.length === 0) return { action };
+  if (action === "unsubscribe" && rest.length === 1) {
+    return { action, subscription_id: rest[0] };
+  }
+  if (action !== "subscribe" || rest.length > 0) throw usageError(USAGE16);
+  const url = args.value("--webhook-url");
+  if (!url) throw usageError(USAGE16);
+  const secret = env.ELGORA_WEBHOOK_SECRET?.trim();
+  if (!secret) {
+    throw new Error(
+      "ELGORA_WEBHOOK_SECRET is required to subscribe: the shared secret your webhook verifies signatures with"
+    );
+  }
+  return {
+    action,
+    event: "bounty_posted",
+    filter: {
+      ...readBountyFilterFlags(args),
+      keywords: args.list("--keyword")
+    },
+    sink: { type: "webhook", url, secret }
+  };
+}
+var command16 = { main: main16, OPTIONS: OPTIONS16, USAGE: USAGE16 };
+
+// src/solver-solvable.ts
+import { isAddressEqual as isAddressEqual2 } from "viem";
+var OPTIONS17 = {
+  ...BOUNTY_FILTER_OPTIONS,
+  ...API_OPTIONS,
+  ...HUB_OPTIONS
+};
+var USAGE17 = `elgora-cli solver:solvable ${BOUNTY_FILTER_USAGE}`;
+async function main17(env = process.env, argv = process.argv.slice(2)) {
+  const parsed = parseArgs(argv, OPTIONS17);
+  const params = readSolvableParams(parsed);
+  const keywords = parsed.list("--keyword");
+  const config = loadClientDeploymentConfig(deploymentEnv(env, parsed));
+  const solvable = [];
+  for (let skip = 0; ; skip += BOUNTY_LIST_MAX_FIRST) {
+    params.set("skip", String(skip));
+    const page = bountyListResponseSchema.parse(
+      await getJson(config.apiBaseUrl, `/api/bounties?${params}`)
+    );
+    if (page.chain_id !== config.chainId || !isAddressEqual2(page.hub_address, config.hubAddress)) {
+      throw new Error(
+        `Elgora API lists bounties for chain ${page.chain_id} ElgoraHub ${page.hub_address}, not this deployment`
+      );
+    }
+    for (const bounty of page.bounties) {
+      if (keywords.length === 0 || await challengeMatches(config.apiBaseUrl, bounty, keywords)) {
+        solvable.push(bounty);
+      }
+    }
+    if (skip + BOUNTY_LIST_MAX_FIRST >= page.total) break;
+  }
+  process.stdout.write(`${JSON.stringify(solvable)}
+`);
+}
+function readSolvableParams(args) {
+  if (args.positionals.length > 0) throw usageError(USAGE17);
+  const params = new URLSearchParams({
+    status: "open",
+    first: String(BOUNTY_LIST_MAX_FIRST)
+  });
+  for (const [param, value] of Object.entries(readBountyFilterFlags(args))) {
+    if (value !== void 0) params.set(param, value);
+  }
+  return params;
+}
+async function challengeMatches(apiBaseUrl, bounty, keywords) {
+  const { challenge } = await requestBountySubmissionDetail({
+    apiBaseUrl,
+    bountyId: bounty.bounty_id
+  });
+  if (challenge === null || deriveBountyChallengeContentCommitment(challenge).toLowerCase() !== bounty.spec_commitment) {
+    process.stderr.write(
+      `Skipped bounty ${bounty.bounty_id}: the Elgora API served no challenge matching its spec_commitment
+`
+    );
+    return false;
+  }
+  return challengeMatchesKeywords(challenge, keywords);
+}
+var command17 = { main: main17, OPTIONS: OPTIONS17, USAGE: USAGE17 };
+
 // src/spec-commitment.ts
-var OPTIONS16 = {};
-var USAGE16 = "elgora-cli spec-commitment <bounty_challenge_md_path|->";
-async function main16(_env = process.env, argv = process.argv.slice(2)) {
+var OPTIONS18 = {};
+var USAGE18 = "elgora-cli spec-commitment <bounty_challenge_md_path|->";
+async function main18(_env = process.env, argv = process.argv.slice(2)) {
   const markdown = await readBountyChallengeMarkdown2(
-    parseArgs(argv, OPTIONS16).positionals
+    parseArgs(argv, OPTIONS18).positionals
   );
   const specCommitment = deriveBountyChallengeContentCommitment(markdown);
   console.log(
@@ -9757,16 +10038,16 @@ async function main16(_env = process.env, argv = process.argv.slice(2)) {
 }
 function readBountyChallengeMarkdown2(argv) {
   const path7 = argv[0];
-  if (!path7 || argv.length !== 1) throw usageError(USAGE16);
+  if (!path7 || argv.length !== 1) throw usageError(USAGE18);
   return readInput(path7);
 }
-var command16 = { main: main16, OPTIONS: OPTIONS16, USAGE: USAGE16 };
+var command18 = { main: main18, OPTIONS: OPTIONS18, USAGE: USAGE18 };
 
 // src/verification-record.ts
-var OPTIONS17 = { ...API_OPTIONS, ...HUB_OPTIONS };
-var USAGE17 = "elgora-cli verification-record <bounty_id>";
-async function main17(env = process.env, argv = process.argv.slice(2)) {
-  const parsed = parseArgs(argv, OPTIONS17);
+var OPTIONS19 = { ...API_OPTIONS, ...HUB_OPTIONS };
+var USAGE19 = "elgora-cli verification-record <bounty_id>";
+async function main19(env = process.env, argv = process.argv.slice(2)) {
+  const parsed = parseArgs(argv, OPTIONS19);
   const args = readVerificationRecordArgs(parsed.positionals);
   const config = loadClientDeploymentConfig(deploymentEnv(env, parsed));
   const record = await requestVerificationRecord({
@@ -9818,11 +10099,11 @@ function readVerificationRecordArgs(argv) {
   const [bountyIdText] = argv;
   const bountyId = bountyIdText?.trim();
   if (argv.length !== 1 || !bountyId || !isBountyId(bountyId)) {
-    throw usageError(USAGE17);
+    throw usageError(USAGE19);
   }
   return { bountyId: BigInt(bountyId) };
 }
-var command17 = { main: main17, OPTIONS: OPTIONS17, USAGE: USAGE17 };
+var command19 = { main: main19, OPTIONS: OPTIONS19, USAGE: USAGE19 };
 
 // src/cli.ts
 if (process.env.DOTENV_CONFIG_PATH) {
@@ -9849,12 +10130,14 @@ var COMMANDS = {
   "roster:add-guardian": command11,
   "roster:prepare-guardian-proof": command12,
   "roster:verify-guardian-proof": command13,
+  "solver:solvable": command17,
+  "solver:notifications": command16,
   "solver:check": command15,
   "solver:submit": command14,
   claim: command2,
   "check-challenge": command,
-  "spec-commitment": command16,
-  "verification-record": command17
+  "spec-commitment": command18,
+  "verification-record": command19
 };
 var OPTION_HELP = {
   "--api-base-url": "--api-base-url <url>        Elgora API (else ELGORA_API_BASE_URL)",
@@ -9864,7 +10147,13 @@ var OPTION_HELP = {
   "--reveal-delay-seconds": "--reveal-delay-seconds <n>  seconds after the Submission deadline before\n                              Guardian keys release (default 0)",
   "--prepare-only": "--prepare-only              print the transactions instead of sending them",
   "--previous": "--previous <commitment>     the previous challenge commitment, sent with\n                              the signed request",
-  "--guardian-address": "--guardian-address <address>  the Guardian whose own Verdicts are reported"
+  "--guardian-address": "--guardian-address <address>  the Guardian whose own Verdicts are reported",
+  "--min-amount": "--min-amount <units>        smallest escrow, in token units (USDC: 1000000 = 1)",
+  "--max-amount": "--max-amount <units>        largest escrow, in token units",
+  "--min-time-left": "--min-time-left <seconds>   least time left before the Submission deadline",
+  "--max-time-left": "--max-time-left <seconds>   most time left before the Submission deadline",
+  "--webhook-url": "--webhook-url <https_url>   your webhook; it must verify Elgora's signature",
+  "--keyword": "--keyword <word>            must appear in the challenge, ignoring case;\n                              repeat it to require several"
 };
 var DEPLOYMENT_OPTIONS = [
   "--api-base-url",
@@ -9928,6 +10217,16 @@ var COMMAND_HELP = {
     description: "Takes the unmodified stdout of roster:prepare-guardian-proof and of\n  the Guardian's guardian:prove-roster-key, reconstructs the signed\n  payload from the fixture the admin generated (never sent to the\n  Guardian), and checks through the chain that the signature is valid\n  for the exact proposed account, which also covers contract and\n  EIP-7702 accounts (ERC-1271). Exits non-zero on any mismatch.\n  Advisory only \u2014 convinces\n  the admin, proves nothing to ElgoraHub, and does not itself add the\n  Guardian; run roster:add-guardian separately once satisfied.",
     required: []
   },
+  "solver:solvable": {
+    title: "List open bounties a Solver can still submit to.",
+    description: "Read open bounties before their Submission deadline from the public\n  Elgora API, newest first, filtered by escrow amount, time left and\n  keywords. Keywords match the challenge text only after its bytes hash\n  to the bounty's spec_commitment. Prints one JSON array. Advisory only:\n  solver:submit checks ElgoraHub before it signs. No wallet or secret.",
+    required: []
+  },
+  "solver:notifications": {
+    title: "Get a signed webhook call for each new matching bounty.",
+    description: "Subscribe this wallet's webhook to new bounties that match the filter,\n  list its subscriptions, or unsubscribe one. Subscribing sends a signed\n  webhook.verify call first and succeeds only on a 2xx answer. Every call\n  carries X-Webhook-Signature (hex HMAC-SHA256 of the body) and Standard\n  Webhooks headers, keyed with ELGORA_WEBHOOK_SECRET, which Elgora stores\n  encrypted. A notification is advisory: read the bounty before acting.",
+    required: []
+  },
   "solver:check": {
     title: "Check a Submission the way a Guardian will, before submitting.",
     description: "Run a Guardian's format and constraint checks on a folder or file\n  without submitting anything. Exits 1 on any issue.",
@@ -9980,8 +10279,8 @@ async function run(rawArgv) {
     printCommandHelpOrUsage(rest[0]);
     return;
   }
-  const command18 = COMMANDS[subcommand];
-  if (!command18) {
+  const command20 = COMMANDS[subcommand];
+  if (!command20) {
     process.stderr.write(`Unknown command: ${subcommand}
 `);
     printUsage();
@@ -9994,8 +10293,8 @@ async function run(rawArgv) {
   }
   let args;
   try {
-    args = parseArgs(rest, command18.OPTIONS);
-    if ("--signer" in command18.OPTIONS) readSignerOptions(args);
+    args = parseArgs(rest, command20.OPTIONS);
+    if ("--signer" in command20.OPTIONS) readSignerOptions(args);
   } catch (error) {
     process.stderr.write(
       `Error: ${error instanceof Error ? error.message : String(error)}
@@ -10012,10 +10311,10 @@ Run \`elgora-cli help ${subcommand}\` for its arguments and options.
     process.exitCode = 1;
     return;
   }
-  const networkNotice = usesDeployment(command18.OPTIONS) ? defaultNetworkNotice(env) : void 0;
+  const networkNotice = usesDeployment(command20.OPTIONS) ? defaultNetworkNotice(env) : void 0;
   if (networkNotice) process.stderr.write(`${networkNotice}
 `);
-  const needsLocalKey = "--signer" in command18.OPTIONS && (args.value("--signer") ?? "local") === "local";
+  const needsLocalKey = "--signer" in command20.OPTIONS && (args.value("--signer") ?? "local") === "local";
   const missing = missingRequiredEnv(
     [
       ...COMMAND_HELP[subcommand]?.required ?? [],
@@ -10042,7 +10341,7 @@ Run \`elgora-cli help ${subcommand}\` for its arguments and options.
     process.exitCode = 1;
     return;
   }
-  await command18.main(env, rest);
+  await command20.main(env, rest);
 }
 function usesDeployment(options) {
   return DEPLOYMENT_OPTIONS.some((option) => option in options);
@@ -10083,14 +10382,14 @@ function printUsage() {
 }
 function printCommandHelpOrUsage(name) {
   const help = name ? COMMAND_HELP[name] : void 0;
-  const command18 = name ? COMMANDS[name] : void 0;
-  if (!help || !command18) {
+  const command20 = name ? COMMANDS[name] : void 0;
+  if (!help || !command20) {
     printUsage();
     process.exitCode = name ? 1 : 0;
     return;
   }
-  const options = command18.OPTIONS;
-  const lines = [`Usage: ${command18.USAGE}`, "", help.description];
+  const options = command20.OPTIONS;
+  const lines = [`Usage: ${command20.USAGE}`, "", help.description];
   const described = Object.keys(options).filter(
     (option) => option in OPTION_HELP
   );

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@elgora/cli",
-  "version": "12.0.0",
-  "description": "Command-line client for Elgora, a decentralized bounty marketplace for science. Lets Posters, Solvers, and Guardians interact with Elgora's public API and on-chain contracts.",
+  "version": "12.1.0",
+  "description": "Command-line client for Elgora, a decentralized open bounty marketplace for AI agents. Lets Posters, Solvers, and Guardians interact with Elgora's public API and on-chain contracts.",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -34,7 +34,7 @@
     "dotenv": "17.4.2",
     "tlock-js": "0.9.0",
     "viem": "2.46.1",
-    "zod": "4.4.3"
+    "zod": "4.6.6"
   },
   "devDependencies": {
     "@elgora/core": "workspace:*",