@elgora/cli 11.0.0 → 12.0.0

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import path5 from "path";
+import path6 from "path";
 import { config as loadDotenv } from "dotenv";
 import { ZodError as ZodError2 } from "zod";
 
@@ -40,8 +40,8 @@ function bytesToBase64Url(bytes) {
   return chunks.join("");
 }
 function base64UrlToBytes(value) {
-  const padded = value.replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(value.length / 4) * 4, "=");
-  return base64ToBytes(padded);
+  const padded2 = value.replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(value.length / 4) * 4, "=");
+  return base64ToBytes(padded2);
 }
 function base64ToBytes(value) {
   const binary = atob(value);
@@ -87,12 +87,24 @@ function safeDecodeUtf8(bytes) {
 import { Aes256Gcm, CipherSuite, HkdfSha256 } from "@hpke/core";
 import { DhkemX25519HkdfSha256 } from "@hpke/dhkem-x25519";
 import { bytesToHex, keccak256, toBytes } from "viem";
-import { z } from "zod";
+import { z as z2 } from "zod";
 
 // ../../packages/core/src/constants.ts
 var BOUNTY_CHALLENGE_PROFILE = "elgora_markdown_bounty_challenge_v0";
+var BOUNTY_CHALLENGE_PROFILE_V1 = "elgora_markdown_bounty_challenge_v1";
 var WINNER_TAKE_ALL_PAYOUT_POLICY = "winner_take_all";
+var MAX_BOUNTY_CHALLENGE_MARKDOWN_CHARACTERS = 1e6;
+var BOUNTY_CHALLENGE_FRONTMATTER_KEYS = [
+  "profile",
+  "escrow_amount",
+  "submission_deadline",
+  "payout_policy"
+];
+var BOUNTY_CHALLENGE_OPTIONAL_FRONTMATTER_KEYS = [
+  "constraints"
+];
 var SUBMISSION_ENCRYPTION_TYPE = "guardian_timelock_hpke_aes_256_gcm_v0";
+var SUBMISSION_ENCRYPTION_TYPE_V1 = "guardian_timelock_hpke_aes_256_gcm_v1";
 var ZERO_BYTES32 = "0x0000000000000000000000000000000000000000000000000000000000000000";
 var READINESS_APPROVAL_VALIDITY_SECONDS = 7 * 24 * 60 * 60;
 var READINESS_TIMEOUT_MS = 18e4;
@@ -128,63 +140,127 @@ function canonicalizeJson(value) {
   throw new Error("Unsupported JSON value");
 }
 
+// ../../packages/core/src/submission-path.ts
+import { z } from "zod";
+var SOLVER_SUBMISSION_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+var MAX_SOLVER_SUBMISSION_NAME_CHARACTERS = 255;
+var MAX_SOLVER_SUBMISSION_PATH_CHARACTERS = 768;
+var MAX_SOLVER_SUBMISSION_FILES_V1 = 1e4;
+var SUBMISSION_ENCRYPTED_BUNDLE_V1_KIND = "elgora_private_artifact_encrypted_bundle_v1";
+var NAME_TOO_LONG_MESSAGE = `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.`;
+var solverSubmissionNameSchema = z.string().max(MAX_SOLVER_SUBMISSION_NAME_CHARACTERS, NAME_TOO_LONG_MESSAGE).regex(SOLVER_SUBMISSION_NAME_RE);
+function describeSolverSubmissionPathIssue(value) {
+  if (value.length > MAX_SOLVER_SUBMISSION_PATH_CHARACTERS) {
+    return `"${value.slice(0, 64)}\u2026" is ${value.length} characters; a Submission path is at most ${MAX_SOLVER_SUBMISSION_PATH_CHARACTERS}.`;
+  }
+  for (const segment of value.split("/")) {
+    if (segment.length > MAX_SOLVER_SUBMISSION_NAME_CHARACTERS) {
+      return `"${value}" has a name longer than ${MAX_SOLVER_SUBMISSION_NAME_CHARACTERS} ASCII characters. Solvers may shorten it only if the published challenge permits, before the deadline.`;
+    }
+    if (!SOLVER_SUBMISSION_NAME_RE.test(segment)) {
+      return `"${value}" is not a valid Submission path: it is "/"-separated names, each starting with a letter or digit and using only letters, digits, ".", "_" and "-".`;
+    }
+  }
+  return null;
+}
+function findSolverSubmissionPathConflict(paths) {
+  const files = /* @__PURE__ */ new Map();
+  const folders = /* @__PURE__ */ new Map();
+  for (const path7 of paths) {
+    const folded = path7.toLowerCase();
+    const earlier = files.get(folded);
+    if (earlier !== void 0) {
+      return {
+        path: path7,
+        conflictsWith: earlier,
+        reason: earlier === path7 ? "duplicate" : "case"
+      };
+    }
+    files.set(folded, path7);
+    const segments = path7.split("/");
+    for (let depth = 1; depth < segments.length; depth += 1) {
+      const spelling = segments.slice(0, depth).join("/");
+      const known = folders.get(spelling.toLowerCase());
+      if (known === void 0) {
+        folders.set(spelling.toLowerCase(), { spelling, path: path7 });
+      } else if (known.spelling !== spelling) {
+        return { path: path7, conflictsWith: known.path, reason: "folder_case" };
+      }
+    }
+  }
+  for (const [folded, path7] of files) {
+    const nested = folders.get(folded);
+    if (nested !== void 0) {
+      return { path: path7, conflictsWith: nested.path, reason: "folder" };
+    }
+  }
+  return null;
+}
+function describeSolverSubmissionPathConflict(conflict) {
+  switch (conflict.reason) {
+    case "duplicate":
+      return `"${conflict.path}" appears twice`;
+    case "case":
+      return `"${conflict.path}" and "${conflict.conflictsWith}" differ only in case, so they would collide on a case-insensitive filesystem`;
+    case "folder_case":
+      return `"${conflict.path}" and "${conflict.conflictsWith}" spell the same folder in different case, so filesystems would disagree on whether they share it`;
+    case "folder":
+      return `"${conflict.path}" is a file, but "${conflict.conflictsWith}" needs it to be a folder`;
+  }
+}
+
 // ../../packages/core/src/submission-encryption.ts
-var PRIVATE_ARTIFACT_ENVELOPE_KIND = "elgora_private_artifact_envelope_v0";
-var PRIVATE_ARTIFACT_PUBLIC_MANIFEST_KIND = "elgora_private_artifact_public_manifest_v0";
-var PRIVATE_ARTIFACT_ENCRYPTED_BUNDLE_KIND = "elgora_private_artifact_encrypted_bundle_v0";
-var PRIVATE_ARTIFACT_WRAPPED_KEY_BAG_KIND = "elgora_private_artifact_wrapped_key_bag_v0";
-var PRIVATE_ARTIFACT_REVEAL_POLICY_KIND = "drand_timelock_reveal_policy_v0";
-var PRIVATE_ARTIFACT_HPKE_SUITE = "hpke-dhkem-x25519-hkdf-sha256+hkdf-sha256+aes-256-gcm@1";
+var SUBMISSION_ENVELOPE_KIND = "elgora_private_artifact_envelope_v0";
+var SUBMISSION_PUBLIC_MANIFEST_KIND = "elgora_private_artifact_public_manifest_v0";
+var SUBMISSION_ENCRYPTED_BUNDLE_KIND = "elgora_private_artifact_encrypted_bundle_v0";
+var SUBMISSION_WRAPPED_KEY_BAG_KIND = "elgora_private_artifact_wrapped_key_bag_v0";
+var SUBMISSION_REVEAL_POLICY_KIND = "drand_timelock_reveal_policy_v0";
+var SUBMISSION_HPKE_SUITE = "hpke-dhkem-x25519-hkdf-sha256+hkdf-sha256+aes-256-gcm@1";
 var MAX_SOLVER_SUBMISSION_CIPHERTEXT_BYTES = 50 * 1024 * 1024;
 var MAX_SOLVER_SUBMISSION_FILES = 500;
-var MAX_SOLVER_SUBMISSION_NAME_CHARACTERS = 255;
-var MAX_SOLVER_SUBMISSION_ARTIFACT_BYTES = 37 * 1024 * 1024;
 var MAX_SOLVER_SUBMISSION_EXTRACTED_BYTES = 250 * 1e3 * 1e3;
-var PRIVATE_ARTIFACT_HPKE_INFO_PREFIX = "elgora/private-artifact-envelope/hpke-aes-key/v0";
+var SUBMISSION_HPKE_INFO_PREFIX = "elgora/private-artifact-envelope/hpke-aes-key/v0";
 var AES_256_KEY_BYTES = 32;
 var AES_GCM_IV_BYTES = 12;
-var PRIVATE_ARTIFACT_NONCE_BYTES = 16;
-var AES_GCM_TAG_BITS = 128;
+var SUBMISSION_NONCE_BYTES = 16;
+var AES_GCM_TAG_BYTES = 16;
+var AES_GCM_TAG_BITS = AES_GCM_TAG_BYTES * 8;
 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 = z.string().regex(BASE64URL_RE);
-var lowerAddressSchema = z.string().refine(isLowercaseHexAddress);
-var bytes32Schema = z.string().refine(isLowercaseBytes32);
-var sha256HexSchema = z.string().refine(isSha256Hex);
-var keyIdSchema = z.string().min(1).max(128).regex(KEY_ID_RE);
-var artifactNameSchema = z.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 = z.string().regex(MEDIA_TYPE_RE);
-var bountyIdSchema = z.string().refine(isBountyId);
-var chainIdSchema = z.number().int().positive().lte(Number.MAX_SAFE_INTEGER);
-var privateArtifactContextSchema = z.strictObject({
-  type: z.literal("solver_submission"),
+var base64UrlSchema = z2.string().regex(BASE64URL_RE);
+var lowerAddressSchema = z2.string().refine(isLowercaseHexAddress);
+var bytes32Schema = z2.string().refine(isLowercaseBytes32);
+var sha256HexSchema = z2.string().refine(isSha256Hex);
+var keyIdSchema = z2.string().min(1).max(128).regex(KEY_ID_RE);
+var fileNameSchema = solverSubmissionNameSchema;
+var mediaTypeSchema = z2.string().regex(MEDIA_TYPE_RE);
+var bountyIdSchema = z2.string().refine(isBountyId);
+var chainIdSchema = z2.number().int().positive().lte(Number.MAX_SAFE_INTEGER);
+var submissionContextSchema = z2.strictObject({
+  type: z2.literal("solver_submission"),
   chain_id: chainIdSchema,
   hub_address: lowerAddressSchema,
   bounty_id: bountyIdSchema,
   actor_address: lowerAddressSchema
 });
-var guardianRecipientSchema = z.strictObject({
+var guardianRecipientSchema = z2.strictObject({
   key_id: keyIdSchema,
-  suite: z.literal(PRIVATE_ARTIFACT_HPKE_SUITE),
+  suite: z2.literal(SUBMISSION_HPKE_SUITE),
   public_key: base64UrlSchema.length(
     43,
     "public_key must encode a 32-byte X25519 public key"
   )
 });
-var guardianRecipientPrivateKeySchema = z.strictObject({
+var guardianRecipientPrivateKeySchema = z2.strictObject({
   key_id: keyIdSchema,
-  suite: z.literal(PRIVATE_ARTIFACT_HPKE_SUITE),
+  suite: z2.literal(SUBMISSION_HPKE_SUITE),
   private_key: base64UrlSchema.length(
     43,
     "private_key must encode a 32-byte X25519 private key"
   )
 });
-var guardianRecipientsSchema = z.array(guardianRecipientSchema).min(1).superRefine((recipients, ctx) => {
+var guardianRecipientsSchema = z2.array(guardianRecipientSchema).min(1).superRefine((recipients, ctx) => {
   const seen = /* @__PURE__ */ new Set();
   for (const recipient of recipients) {
     if (seen.has(recipient.key_id)) {
@@ -197,84 +273,84 @@ var guardianRecipientsSchema = z.array(guardianRecipientSchema).min(1).superRefi
     seen.add(recipient.key_id);
   }
 });
-var guardianRecipientPrivateKeysSchema = z.array(guardianRecipientPrivateKeySchema).min(1);
-var artifactManifestEntrySchema = z.strictObject({
-  name: artifactNameSchema,
+var guardianRecipientPrivateKeysSchema = z2.array(guardianRecipientPrivateKeySchema).min(1);
+var bundleFileEntrySchema = z2.strictObject({
+  name: fileNameSchema,
   media_type: mediaTypeSchema,
-  size_bytes: z.number().int().nonnegative().lte(Number.MAX_SAFE_INTEGER),
+  size_bytes: z2.number().int().nonnegative().lte(Number.MAX_SAFE_INTEGER),
   sha256: sha256HexSchema
 });
-var privateArtifactPublicManifestSchema = z.strictObject({
-  kind: z.literal(PRIVATE_ARTIFACT_PUBLIC_MANIFEST_KIND),
-  context: privateArtifactContextSchema
+var submissionPublicManifestSchema = z2.strictObject({
+  kind: z2.literal(SUBMISSION_PUBLIC_MANIFEST_KIND),
+  context: submissionContextSchema
 });
-var encryptedBundleArtifactSchema = artifactManifestEntrySchema.extend({
+var encryptedBundleFileSchema = bundleFileEntrySchema.extend({
   bytes: base64UrlSchema
 });
-var privateArtifactEncryptedBundleSchema = z.strictObject({
-  kind: z.literal(PRIVATE_ARTIFACT_ENCRYPTED_BUNDLE_KIND),
-  context: privateArtifactContextSchema,
-  artifacts: z.array(encryptedBundleArtifactSchema).min(1).max(
+var submissionEncryptedBundleSchema = z2.strictObject({
+  kind: z2.literal(SUBMISSION_ENCRYPTED_BUNDLE_KIND),
+  context: submissionContextSchema,
+  artifacts: z2.array(encryptedBundleFileSchema).min(1).max(
     MAX_SOLVER_SUBMISSION_FILES,
     `Submission exceeds the maximum of ${MAX_SOLVER_SUBMISSION_FILES} files.`
   ).refine(
-    (artifacts) => new Set(artifacts.map((artifact) => artifact.name.toLowerCase())).size === artifacts.length,
-    "artifact names must be unique case-insensitively"
+    (files) => new Set(files.map((file) => file.name.toLowerCase())).size === files.length,
+    "file names must be unique case-insensitively"
   )
 });
-var privateArtifactRevealPolicySchema = z.strictObject({
-  kind: z.literal(PRIVATE_ARTIFACT_REVEAL_POLICY_KIND),
-  network: z.string().min(1),
-  chain_hash: z.string().min(1),
-  round: z.string().refine(isPositiveInteger),
-  not_before: z.number().int().nonnegative().lte(Number.MAX_SAFE_INTEGER)
+var submissionRevealPolicySchema = z2.strictObject({
+  kind: z2.literal(SUBMISSION_REVEAL_POLICY_KIND),
+  network: z2.string().min(1),
+  chain_hash: z2.string().min(1),
+  round: z2.string().refine(isPositiveInteger),
+  not_before: z2.number().int().nonnegative().lte(Number.MAX_SAFE_INTEGER)
 });
-var wrappedRecipientKeySchema = z.strictObject({
+var wrappedRecipientKeySchema = z2.strictObject({
   key_id: keyIdSchema,
-  suite: z.literal(PRIVATE_ARTIFACT_HPKE_SUITE),
+  suite: z2.literal(SUBMISSION_HPKE_SUITE),
   enc: base64UrlSchema,
   ciphertext: base64UrlSchema
 });
-var wrappedKeyBagSchema = z.strictObject({
-  kind: z.literal(PRIVATE_ARTIFACT_WRAPPED_KEY_BAG_KIND),
-  keys: z.array(wrappedRecipientKeySchema).min(1)
+var wrappedKeyBagSchema = z2.strictObject({
+  kind: z2.literal(SUBMISSION_WRAPPED_KEY_BAG_KIND),
+  keys: z2.array(wrappedRecipientKeySchema).min(1)
 });
-var privateArtifactEnvelopeSchema = z.strictObject({
-  kind: z.literal(PRIVATE_ARTIFACT_ENVELOPE_KIND),
-  alg: z.literal(SUBMISSION_ENCRYPTION_TYPE),
-  context: privateArtifactContextSchema,
-  public_manifest: privateArtifactPublicManifestSchema,
+var submissionEnvelopeSchema = z2.strictObject({
+  kind: z2.literal(SUBMISSION_ENVELOPE_KIND),
+  alg: z2.enum([SUBMISSION_ENCRYPTION_TYPE, SUBMISSION_ENCRYPTION_TYPE_V1]),
+  context: submissionContextSchema,
+  public_manifest: submissionPublicManifestSchema,
   public_manifest_sha256: sha256HexSchema,
   encrypted_bundle_sha256: sha256HexSchema,
   ciphertext_sha256: sha256HexSchema,
   guardian_recipients: guardianRecipientsSchema,
   guardian_recipients_commitment: bytes32Schema,
-  reveal_policy: privateArtifactRevealPolicySchema,
+  reveal_policy: submissionRevealPolicySchema,
   envelope_nonce: base64UrlSchema.length(
     22,
     "envelope_nonce must encode 16 bytes"
   ),
   iv: base64UrlSchema.length(16, "iv must encode 12 bytes"),
   wrapped_key_bag: base64UrlSchema,
-  ciphertext_locator: z.string().min(1)
+  ciphertext_locator: z2.string().min(1)
 });
-function parsePrivateArtifactEnvelope(input) {
-  return privateArtifactEnvelopeSchema.parse(input);
+function parseSubmissionEnvelope(input) {
+  return submissionEnvelopeSchema.parse(input);
 }
-function serializePrivateArtifactEnvelope(envelope) {
+function serializeSubmissionEnvelope(envelope) {
   return canonicalizeJson(
-    privateArtifactEnvelopeSchema.parse(envelope)
+    submissionEnvelopeSchema.parse(envelope)
   );
 }
-function derivePrivateArtifactEnvelopeCommitment(envelope) {
-  return keccak256(toBytes(serializePrivateArtifactEnvelope(envelope)));
+function deriveSubmissionEnvelopeCommitment(envelope) {
+  return keccak256(toBytes(serializeSubmissionEnvelope(envelope)));
 }
 function deriveSolverSubmissionCiphertextLocator(input) {
   const { chain_id, hub_address, bounty_id, actor_address } = input.context;
   return `${chain_id}/${hub_address}/${bounty_id}/${actor_address}/${input.ciphertextSha256}.bin`;
 }
-async function verifyPrivateArtifactEnvelope(input) {
-  const envelope = parsePrivateArtifactEnvelope(input);
+async function verifySubmissionEnvelope(input) {
+  const envelope = parseSubmissionEnvelope(input);
   if (canonicalizeJson(envelope.public_manifest.context) !== canonicalizeJson(envelope.context)) {
     throw new Error("public_manifest context does not match envelope context");
   }
@@ -314,7 +390,7 @@ var x25519PrivateKeySchema = base64UrlSchema.length(
   43,
   "must encode a 32-byte X25519 private key"
 );
-var winningSolutionDeliveryContextSchema = z.strictObject({
+var winningSolutionDeliveryContextSchema = z2.strictObject({
   chain_id: chainIdSchema,
   hub_address: lowerAddressSchema,
   bounty_id: bountyIdSchema,
@@ -395,7 +471,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 = z.strictObject({
+var guardianRosterKeyProofContextSchema = z2.strictObject({
   chain_id: chainIdSchema,
   hub_address: lowerAddressSchema,
   proposed_account: lowerAddressSchema,
@@ -465,42 +541,30 @@ function buildGuardianRosterKeyProofSignedPayload(message, fixture) {
   return toBytes(`${message}
 ${bytesToHex(fixture).slice(2)}`);
 }
-async function sealPrivateArtifactEnvelope(input) {
-  const context = privateArtifactContextSchema.parse(
-    normalizeContext(input.context)
-  );
-  const revealPolicy = privateArtifactRevealPolicySchema.parse(
-    input.reveal_policy
+async function sealSubmissionEnvelope(input) {
+  const context = submissionContextSchema.parse(
+    normalizeSubmissionContext(input.context)
   );
+  const revealPolicy = submissionRevealPolicySchema.parse(input.reveal_policy);
   const recipients = canonicalizeGuardianRecipients(input.guardian_recipients);
   const guardianRecipientsCommitment = deriveGuardianRecipientsCommitment(recipients);
-  const artifacts = await buildBundleArtifacts(input.artifacts);
-  const publicManifest = privateArtifactPublicManifestSchema.parse({
-    kind: PRIVATE_ARTIFACT_PUBLIC_MANIFEST_KIND,
+  const publicManifest = submissionPublicManifestSchema.parse({
+    kind: SUBMISSION_PUBLIC_MANIFEST_KIND,
     context
   });
-  const encryptedBundle = privateArtifactEncryptedBundleSchema.parse({
-    kind: PRIVATE_ARTIFACT_ENCRYPTED_BUNDLE_KIND,
-    context,
-    artifacts: artifacts.map((artifact) => ({
-      ...artifact,
-      bytes: bytesToBase64Url(artifact.bytes)
-    }))
-  });
-  const encryptedBundleBytes = toBytes(
-    canonicalizeJson(encryptedBundle)
-  );
+  const alg = input.encryption_type;
+  const encryptedBundleBytes = input.encryption_type === SUBMISSION_ENCRYPTION_TYPE_V1 ? input.archive : input.bundle;
   const publicManifestSha256 = await computeSha256Hex(
     toBytes(canonicalizeJson(publicManifest))
   );
   const encryptedBundleSha256 = await computeSha256Hex(encryptedBundleBytes);
   const randomBytes = input.random_bytes ?? secureRandomBytes;
   const rawAesKey = randomBytes(AES_256_KEY_BYTES);
-  const envelopeNonce = randomBytes(PRIVATE_ARTIFACT_NONCE_BYTES);
+  const envelopeNonce = randomBytes(SUBMISSION_NONCE_BYTES);
   const iv = randomBytes(AES_GCM_IV_BYTES);
   const aadInput = {
-    kind: PRIVATE_ARTIFACT_ENVELOPE_KIND,
-    alg: SUBMISSION_ENCRYPTION_TYPE,
+    kind: SUBMISSION_ENVELOPE_KIND,
+    alg,
     context,
     public_manifest_sha256: publicManifestSha256,
     encrypted_bundle_sha256: encryptedBundleSha256,
@@ -512,7 +576,7 @@ async function sealPrivateArtifactEnvelope(input) {
     rawAesKey,
     iv,
     plaintext: encryptedBundleBytes,
-    aad: buildPrivateArtifactAad(aadInput)
+    aad: buildSubmissionAad(aadInput)
   });
   const wrappedKeys = await wrapAesKeyForRecipients({
     rawAesKey,
@@ -520,7 +584,7 @@ async function sealPrivateArtifactEnvelope(input) {
     guardianRecipientsCommitment
   });
   const wrappedKeyBag = wrappedKeyBagSchema.parse({
-    kind: PRIVATE_ARTIFACT_WRAPPED_KEY_BAG_KIND,
+    kind: SUBMISSION_WRAPPED_KEY_BAG_KIND,
     keys: wrappedKeys
   });
   const timelockedKeyBag = await input.timelock_encrypt({
@@ -532,9 +596,9 @@ async function sealPrivateArtifactEnvelope(input) {
     context,
     ciphertextSha256
   });
-  const envelope = privateArtifactEnvelopeSchema.parse({
-    kind: PRIVATE_ARTIFACT_ENVELOPE_KIND,
-    alg: SUBMISSION_ENCRYPTION_TYPE,
+  const envelope = submissionEnvelopeSchema.parse({
+    kind: SUBMISSION_ENVELOPE_KIND,
+    alg,
     context,
     public_manifest: publicManifest,
     public_manifest_sha256: publicManifestSha256,
@@ -550,67 +614,65 @@ async function sealPrivateArtifactEnvelope(input) {
   });
   return { envelope, ciphertext };
 }
-async function openPrivateArtifactEnvelope(input) {
-  const opened = await openPrivateArtifactEnvelopeWithRawKey(input);
-  return {
-    envelope: opened.envelope,
-    recipient_key_id: opened.recipient_key_id,
-    artifacts: opened.artifacts
-  };
+async function openSubmissionEnvelope(input) {
+  const { rawAesKey: _rawAesKey, ...opened } = await openSubmissionEnvelopeWithRawKey(input);
+  return opened;
 }
-async function openPrivateArtifactEnvelopeForDelivery(input) {
-  const opened = await openPrivateArtifactEnvelopeWithRawKey(input);
+async function openSubmissionEnvelopeForDelivery(input) {
+  const envelope = await verifySubmissionEnvelope(input.envelope);
+  const { rawAesKey, recipientKeyId } = await openEnvelopeAesKey(
+    envelope,
+    input
+  );
   const wrapped_key = await wrapWinningSolutionAesKey({
-    rawAesKey: opened.rawAesKey,
+    rawAesKey,
     recipientPublicKey: input.delivery_recipient_public_key,
     context: input.context
   });
-  return {
-    envelope: opened.envelope,
-    recipient_key_id: opened.recipient_key_id,
-    wrapped_key
-  };
+  return { envelope, recipient_key_id: recipientKeyId, wrapped_key };
 }
-async function openPrivateArtifactEnvelopeWithRawKey(input) {
-  const envelope = await verifyPrivateArtifactEnvelope(input.envelope);
-  await assertCiphertextIntegrity(input.ciphertext, envelope.ciphertext_sha256);
-  const timelockedKeyBag = base64UrlToBytes(envelope.wrapped_key_bag);
+async function openEnvelopeAesKey(envelope, input) {
   const wrappedKeyBagBytes = await input.timelock_decrypt({
-    ciphertext: timelockedKeyBag,
+    ciphertext: base64UrlToBytes(envelope.wrapped_key_bag),
     reveal_policy: envelope.reveal_policy
   });
   const wrappedKeyBag = wrappedKeyBagSchema.parse(
     JSON.parse(new TextDecoder().decode(wrappedKeyBagBytes))
   );
-  const openResult = await openAesKeyForRecipient({
+  return openAesKeyForRecipient({
     wrappedKeys: wrappedKeyBag.keys,
     privateKeys: input.guardian_private_keys,
     guardianRecipientsCommitment: envelope.guardian_recipients_commitment
   });
-  const artifacts = await decryptAndVerifyBundle(envelope, input.ciphertext, {
+}
+async function openSubmissionEnvelopeWithRawKey(input) {
+  const envelope = await verifySubmissionEnvelope(input.envelope);
+  await assertCiphertextIntegrity(input.ciphertext, envelope.ciphertext_sha256);
+  const openResult = await openEnvelopeAesKey(envelope, input);
+  const bundle = await decryptAndVerifyBundle(envelope, input.ciphertext, {
     rawAesKey: openResult.rawAesKey
   });
   return {
     envelope,
     recipient_key_id: openResult.recipientKeyId,
-    artifacts,
+    ...bundle,
     rawAesKey: openResult.rawAesKey
   };
 }
-async function openPrivateArtifactEnvelopeWithKnownAesKey(input) {
-  const envelope = await verifyPrivateArtifactEnvelope(input.envelope);
+async function openSubmissionEnvelopeWithKnownAesKey(input) {
+  const envelope = await verifySubmissionEnvelope(input.envelope);
   await assertCiphertextIntegrity(input.ciphertext, envelope.ciphertext_sha256);
-  const artifacts = await decryptAndVerifyBundle(envelope, input.ciphertext, {
+  const bundle = await decryptAndVerifyBundle(envelope, input.ciphertext, {
     rawAesKey: input.rawAesKey
   });
-  return { envelope, artifacts };
+  return { envelope, ...bundle };
 }
 async function decryptAndVerifyBundle(envelope, ciphertext, key) {
   const decryptedBytes = await decryptAes256Gcm({
     rawAesKey: key.rawAesKey,
     iv: base64UrlToBytes(envelope.iv),
     ciphertext,
-    aad: buildPrivateArtifactAad({
+    aad: buildSubmissionAad({
       kind: envelope.kind,
       alg: envelope.alg,
       context: envelope.context,
@@ -621,63 +683,20 @@ async function decryptAndVerifyBundle(envelope, ciphertext, key) {
       envelope_nonce: envelope.envelope_nonce
     })
   });
-  const encryptedBundle = privateArtifactEncryptedBundleSchema.parse(
-    JSON.parse(new TextDecoder().decode(decryptedBytes))
-  );
   if (await computeSha256Hex(decryptedBytes) !== envelope.encrypted_bundle_sha256) {
     throw new Error("encrypted_bundle_sha256 does not match decrypted bundle");
   }
-  const rebuiltManifest = privateArtifactPublicManifestSchema.parse({
-    kind: PRIVATE_ARTIFACT_PUBLIC_MANIFEST_KIND,
-    context: encryptedBundle.context
-  });
-  if (canonicalizeJson(rebuiltManifest) !== canonicalizeJson(envelope.public_manifest)) {
-    throw new Error("decrypted bundle does not match public_manifest");
-  }
-  const artifacts = encryptedBundle.artifacts.map((artifact) => ({
-    name: artifact.name,
-    media_type: artifact.media_type,
-    size_bytes: artifact.size_bytes,
-    sha256: artifact.sha256,
-    bytes: base64UrlToBytes(artifact.bytes)
-  }));
-  for (const artifact of artifacts) {
-    if (artifact.bytes.byteLength !== artifact.size_bytes) {
-      throw new Error(`artifact ${artifact.name} size_bytes mismatch`);
-    }
-    if (await computeSha256Hex(artifact.bytes) !== artifact.sha256) {
-      throw new Error(`artifact ${artifact.name} sha256 mismatch`);
-    }
-  }
-  return artifacts;
-}
-async function buildBundleArtifacts(artifacts) {
-  const seen = /* @__PURE__ */ new Set();
-  const parsed = artifacts.map((artifact) => ({
-    name: artifactNameSchema.parse(artifact.name),
-    media_type: mediaTypeSchema.parse(artifact.media_type),
-    bytes: Uint8Array.from(artifact.bytes)
-  })).sort((left, right) => compareCanonicalStrings(left.name, right.name));
-  if (parsed.length === 0) {
-    throw new Error(
-      "private artifact envelope must include at least one artifact"
-    );
+  if (envelope.alg === SUBMISSION_ENCRYPTION_TYPE_V1) {
+    return { alg: envelope.alg, archive: decryptedBytes };
   }
-  return Promise.all(
-    parsed.map(async (artifact) => {
-      if (seen.has(artifact.name)) {
-        throw new Error(`artifact name ${artifact.name} is duplicated`);
-      }
-      seen.add(artifact.name);
-      return {
-        name: artifact.name,
-        media_type: artifact.media_type,
-        size_bytes: artifact.bytes.byteLength,
-        sha256: await computeSha256Hex(artifact.bytes),
-        bytes: artifact.bytes
-      };
-    })
+  const encryptedBundle = submissionEncryptedBundleSchema.parse(
+    JSON.parse(new TextDecoder().decode(decryptedBytes))
   );
+  const files = encryptedBundle.artifacts.map((file) => ({
+    ...file,
+    bytes: base64UrlToBytes(file.bytes)
+  }));
+  return { alg: envelope.alg, files };
 }
 async function assertEnvelopeDigests(envelope) {
   const manifestSha256 = await computeSha256Hex(
@@ -687,7 +706,7 @@ async function assertEnvelopeDigests(envelope) {
     throw new Error("public_manifest_sha256 does not match public_manifest");
   }
 }
-function buildPrivateArtifactAad(input) {
+function buildSubmissionAad(input) {
   return toBytes(
     canonicalizeJson({
       kind: input.kind,
@@ -724,7 +743,7 @@ async function wrapAesKeyForRecipients(input) {
 }
 async function openAesKeyForRecipient(input) {
   const suite = createHpkeSuite();
-  const wrappedKeys = z.array(wrappedRecipientKeySchema).parse(input.wrappedKeys);
+  const wrappedKeys = z2.array(wrappedRecipientKeySchema).parse(input.wrappedKeys);
   const privateKeys = guardianRecipientPrivateKeysSchema.parse(
     input.privateKeys
   );
@@ -764,7 +783,7 @@ async function openAesKeyForRecipient(input) {
       ...new Set(privateKeys.map((key) => key.key_id))
     ].sort();
     throw new Error(
-      `no matching Guardian private key for private artifact envelope: this envelope was sealed for key_id ${JSON.stringify(wanted)}, but ELGORA_GUARDIAN_PRIVATE_KEYS_JSON configures key_id ${JSON.stringify(configured)}. key_id must be this Guardian's own registered roster name (the name passed to roster:add-guardian), not its account address.`
+      `no matching Guardian private key for the Submission envelope: this envelope was sealed for key_id ${JSON.stringify(wanted)}, but ELGORA_GUARDIAN_PRIVATE_KEYS_JSON configures key_id ${JSON.stringify(configured)}. key_id must be this Guardian's own registered roster name (the name passed to roster:add-guardian), not its account address.`
     );
   }
   throw new Error("matching Guardian private key could not open wrapped key", {
@@ -816,7 +835,7 @@ async function decryptAes256Gcm(input) {
       )
     );
   } catch (error) {
-    throw new Error("private artifact ciphertext authentication failed", {
+    throw new Error("Submission ciphertext authentication failed", {
       cause: error
     });
   }
@@ -833,7 +852,7 @@ async function computeSha256Hex(bytes) {
 }
 function buildRecipientKeyInfo(guardianRecipientsCommitment) {
   return toBytes(
-    `${PRIVATE_ARTIFACT_HPKE_INFO_PREFIX}:${guardianRecipientsCommitment}`
+    `${SUBMISSION_HPKE_INFO_PREFIX}:${guardianRecipientsCommitment}`
   );
 }
 function createHpkeSuite() {
@@ -845,7 +864,7 @@ function createHpkeSuite() {
 }
 function getWebCrypto() {
   if (!globalThis.crypto?.subtle) {
-    throw new Error("WebCrypto is required for private artifact encryption");
+    throw new Error("WebCrypto is required for Submission encryption");
   }
   return globalThis.crypto;
 }
@@ -868,7 +887,7 @@ function toArrayBufferView(bytes) {
 function normalizeBountyId(value) {
   return bountyIdSchema.parse(value.toString());
 }
-function normalizeContext(context) {
+function normalizeSubmissionContext(context) {
   return {
     ...context,
     hub_address: context.hub_address.toLowerCase(),
@@ -892,29 +911,29 @@ var AGE_ARMOR_END = "-----END AGE ENCRYPTED FILE-----";
 var AGE_VERSION = "age-encryption.org/v1";
 var TLOCK_STANZA_PREFIX = "-> tlock ";
 var AGE_HEADER_SEPARATOR_BYTES = new Uint8Array([10, 45, 45, 45, 32]);
-var PrivateArtifactTimelockOpenError = class extends Error {
+var SubmissionTimelockOpenError = class extends Error {
   code;
   constructor(code, message, options) {
     super(message, options);
-    this.name = "PrivateArtifactTimelockOpenError";
+    this.name = "SubmissionTimelockOpenError";
     this.code = code;
   }
 };
-function buildPrivateArtifactRevealPolicyForDeadline(input) {
+function buildSubmissionRevealPolicyForDeadline(input) {
   const revealDelaySeconds = input.revealDelaySeconds ?? DEFAULT_TIMELOCK_REVEAL_DELAY_SECONDS;
   const notBefore = addUnixSeconds(
     input.submissionDeadline,
     revealDelaySeconds
   );
   return {
-    kind: PRIVATE_ARTIFACT_REVEAL_POLICY_KIND,
+    kind: SUBMISSION_REVEAL_POLICY_KIND,
     network: TIMELOCK_DRAND_NETWORK,
     chain_hash: DEFAULT_TIMELOCK_DRAND_CHAIN_HASH,
     round: deriveFirstRoundAtOrAfter(notBefore).toString(),
     not_before: notBefore
   };
 }
-function getPrivateArtifactTimelockReleaseState(input) {
+function getSubmissionTimelockReleaseState(input) {
   const releaseTime = Math.max(
     input.revealPolicy.not_before,
     roundReleaseUnixSeconds(input.revealPolicy.round)
@@ -924,7 +943,7 @@ function getPrivateArtifactTimelockReleaseState(input) {
     release_time: releaseTime
   };
 }
-function createPrivateArtifactTimelockEncrypt(input) {
+function createSubmissionTimelockEncrypt(input) {
   const chainClient = input?.chainClient ?? mainnetClient();
   return async ({ plaintext, reveal_policy }) => {
     assertSupportedRevealPolicy(reveal_policy);
@@ -936,7 +955,7 @@ function createPrivateArtifactTimelockEncrypt(input) {
     return new TextEncoder().encode(ciphertext);
   };
 }
-function createPrivateArtifactTimelockDecrypt(input) {
+function createSubmissionTimelockDecrypt(input) {
   const chainClient = classifyBeaconUnavailableErrors(
     input?.chainClient ?? mainnetClient()
   );
@@ -944,18 +963,18 @@ function createPrivateArtifactTimelockDecrypt(input) {
   return async ({ ciphertext, reveal_policy }) => {
     try {
       assertSupportedRevealPolicy(reveal_policy);
-      assertPrivateArtifactTimelockCiphertextMatchesPolicy({
+      assertSubmissionTimelockCiphertextMatchesPolicy({
         ciphertext,
         revealPolicy: reveal_policy
       });
-      const releaseState = getPrivateArtifactTimelockReleaseState({
+      const releaseState = getSubmissionTimelockReleaseState({
         revealPolicy: reveal_policy,
         nowSeconds: nowSeconds()
       });
       if (releaseState.status !== "released") {
-        throw new PrivateArtifactTimelockOpenError(
+        throw new SubmissionTimelockOpenError(
           "timelock_not_released",
-          `private artifact timelock is not released until ${releaseState.release_time}`
+          `Submission timelock is not released until ${releaseState.release_time}`
         );
       }
       const plaintext = await timelockDecrypt(
@@ -964,18 +983,18 @@ function createPrivateArtifactTimelockDecrypt(input) {
       );
       return Uint8Array.from(plaintext);
     } catch (error) {
-      if (error instanceof PrivateArtifactTimelockOpenError) {
+      if (error instanceof SubmissionTimelockOpenError) {
         throw error;
       }
-      throw new PrivateArtifactTimelockOpenError(
+      throw new SubmissionTimelockOpenError(
         "timelock_open_failed",
-        "private artifact timelock ciphertext could not be opened",
+        "Submission timelock ciphertext could not be opened",
         { cause: error }
       );
     }
   };
 }
-function parsePrivateArtifactTimelockHeader(ciphertext) {
+function parseSubmissionTimelockHeader(ciphertext) {
   const ageText = decodeAgePayload(safeDecodeUtf8(ciphertext));
   const [version, ...lines] = ageText.split("\n");
   if (version !== AGE_VERSION) {
@@ -1001,12 +1020,12 @@ function parsePrivateArtifactTimelockHeader(ciphertext) {
     chain_hash: chainHash
   };
 }
-function assertPrivateArtifactTimelockCiphertextMatchesPolicy(input) {
-  const header = parsePrivateArtifactTimelockHeader(input.ciphertext);
-  if (header.round !== input.revealPolicy.round) {
+function assertSubmissionTimelockCiphertextMatchesPolicy(input) {
+  const header2 = parseSubmissionTimelockHeader(input.ciphertext);
+  if (header2.round !== input.revealPolicy.round) {
     throw new Error("timelock ciphertext round does not match reveal_policy");
   }
-  if (header.chain_hash !== input.revealPolicy.chain_hash) {
+  if (header2.chain_hash !== input.revealPolicy.chain_hash) {
     throw new Error(
       "timelock ciphertext chain_hash does not match reveal_policy"
     );
@@ -1049,14 +1068,14 @@ function assertUnixSeconds(value, label) {
   }
 }
 function assertSupportedRevealPolicy(revealPolicy) {
-  if (revealPolicy.kind !== PRIVATE_ARTIFACT_REVEAL_POLICY_KIND) {
-    throw new Error("unsupported private artifact reveal_policy kind");
+  if (revealPolicy.kind !== SUBMISSION_REVEAL_POLICY_KIND) {
+    throw new Error("unsupported Submission reveal_policy kind");
   }
   if (revealPolicy.network !== TIMELOCK_DRAND_NETWORK) {
-    throw new Error("unsupported private artifact timelock network");
+    throw new Error("unsupported Submission timelock network");
   }
   if (revealPolicy.chain_hash !== DEFAULT_TIMELOCK_DRAND_CHAIN_HASH) {
-    throw new Error("unsupported private artifact timelock chain hash");
+    throw new Error("unsupported Submission timelock chain hash");
   }
 }
 function decodeAgePayload(value) {
@@ -1077,8 +1096,8 @@ function decodeAgePayload(value) {
 }
 function decodeAgeHeader(bytes) {
   const separatorIndex = indexOfBytes(bytes, AGE_HEADER_SEPARATOR_BYTES);
-  const header = separatorIndex >= 0 ? bytes.subarray(0, separatorIndex) : bytes;
-  return safeDecodeUtf8(header);
+  const header2 = separatorIndex >= 0 ? bytes.subarray(0, separatorIndex) : bytes;
+  return safeDecodeUtf8(header2);
 }
 function indexOfBytes(haystack, needle) {
   for (let index = 0; index <= haystack.length - needle.length; index += 1) {
@@ -1113,9 +1132,9 @@ async function classifyBeaconFetch(operation) {
   try {
     return await operation();
   } catch (error) {
-    throw new PrivateArtifactTimelockOpenError(
+    throw new SubmissionTimelockOpenError(
       "timelock_beacon_unavailable",
-      "drand beacon is unavailable for private artifact timelock",
+      "drand beacon is unavailable for Submission timelock",
       { cause: error }
     );
   }
@@ -1185,8 +1204,8 @@ function readRevealDelaySeconds(args) {
   }
   return parsed;
 }
-function readInput(path6) {
-  return path6 === "-" ? readStdinText(process.stdin) : readFile(path6, "utf8");
+function readInput(path7) {
+  return path7 === "-" ? readStdinText(process.stdin) : readFile(path7, "utf8");
 }
 function usageError(usage) {
   return new Error(`Usage: ${usage}`);
@@ -1214,25 +1233,124 @@ 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 z2 } from "zod";
+import { z as z3 } from "zod";
+
+// ../../packages/core/src/protocol-profile.ts
+var PROTOCOL_PROFILE_V0 = Object.freeze({
+  profile: BOUNTY_CHALLENGE_PROFILE,
+  submission: Object.freeze({
+    maxCiphertextBytes: MAX_SOLVER_SUBMISSION_CIPHERTEXT_BYTES,
+    maxExtractedBytes: MAX_SOLVER_SUBMISSION_EXTRACTED_BYTES,
+    maxFiles: MAX_SOLVER_SUBMISSION_FILES,
+    filename: Object.freeze({
+      maxCharacters: MAX_SOLVER_SUBMISSION_NAME_CHARACTERS,
+      firstCharacter: "letter_or_digit",
+      allowedCharacters: "letters_digits_dot_underscore_hyphen",
+      caseInsensitivelyUnique: true
+    }),
+    layout: Object.freeze({
+      flat: true,
+      regularFilesOnly: true,
+      allowsSubdirectories: false,
+      allowsSymlinks: false,
+      allowsEmpty: false,
+      allowsArchivedDirectoryEntries: false,
+      allowsArchivedPathTraversal: false
+    }),
+    externalReferences: false
+  }),
+  challenge: Object.freeze({
+    maxMarkdownCharacters: MAX_BOUNTY_CHALLENGE_MARKDOWN_CHARACTERS,
+    requiredFrontmatterKeys: Object.freeze([
+      ...BOUNTY_CHALLENGE_FRONTMATTER_KEYS
+    ]),
+    optionalFrontmatterKeys: Object.freeze([
+      ...BOUNTY_CHALLENGE_OPTIONAL_FRONTMATTER_KEYS
+    ]),
+    payoutPolicies: Object.freeze([WINNER_TAKE_ALL_PAYOUT_POLICY])
+  }),
+  encryption: Object.freeze({
+    type: SUBMISSION_ENCRYPTION_TYPE
+  }),
+  tightenable: Object.freeze({
+    max_extracted_bytes: Object.freeze({
+      comparison: "at_most",
+      profileValue: MAX_SOLVER_SUBMISSION_EXTRACTED_BYTES
+    }),
+    max_files: Object.freeze({
+      comparison: "at_most",
+      profileValue: MAX_SOLVER_SUBMISSION_FILES
+    }),
+    allowed_extensions: Object.freeze({ comparison: "subset" }),
+    required_files: Object.freeze({ comparison: "filename_list" })
+  })
+});
+var PROTOCOL_PROFILE_V1 = Object.freeze({
+  profile: BOUNTY_CHALLENGE_PROFILE_V1,
+  submission: Object.freeze({
+    maxCiphertextBytes: MAX_SOLVER_SUBMISSION_CIPHERTEXT_BYTES,
+    maxExtractedBytes: MAX_SOLVER_SUBMISSION_EXTRACTED_BYTES,
+    maxFiles: MAX_SOLVER_SUBMISSION_FILES_V1,
+    filename: PROTOCOL_PROFILE_V0.submission.filename,
+    layout: Object.freeze({
+      regularFilesOnly: true,
+      allowsSubdirectories: true,
+      allowsSymlinks: false,
+      allowsEmpty: false,
+      allowsArchivedDirectoryEntries: true,
+      allowsArchivedPathTraversal: false
+    }),
+    path: Object.freeze({
+      maxCharacters: MAX_SOLVER_SUBMISSION_PATH_CHARACTERS
+    }),
+    externalReferences: false
+  }),
+  challenge: PROTOCOL_PROFILE_V0.challenge,
+  encryption: Object.freeze({
+    type: SUBMISSION_ENCRYPTION_TYPE_V1
+  }),
+  tightenable: Object.freeze({
+    max_extracted_bytes: Object.freeze({
+      comparison: "at_most",
+      profileValue: MAX_SOLVER_SUBMISSION_EXTRACTED_BYTES
+    }),
+    max_files: Object.freeze({
+      comparison: "at_most",
+      profileValue: MAX_SOLVER_SUBMISSION_FILES_V1
+    }),
+    allowed_extensions: Object.freeze({ comparison: "subset" }),
+    required_files: Object.freeze({ comparison: "path_list" })
+  })
+});
+var PROTOCOL_PROFILES = /* @__PURE__ */ new Map([
+  [PROTOCOL_PROFILE_V0.profile, PROTOCOL_PROFILE_V0],
+  [PROTOCOL_PROFILE_V1.profile, PROTOCOL_PROFILE_V1]
+]);
+var CURRENT_PROTOCOL_PROFILE = PROTOCOL_PROFILE_V1;
+var PROTOCOL_PROFILE_VERSIONS = Object.freeze([
+  ...PROTOCOL_PROFILES.keys()
+]);
+function getProtocolProfile(version) {
+  return PROTOCOL_PROFILES.get(version) ?? null;
+}
+function isKnownProtocolProfile(version) {
+  return PROTOCOL_PROFILES.has(version);
+}
+
+// ../../packages/core/src/bounty-challenge-markdown.ts
 var FRONTMATTER_DELIMITER = "---";
-var MAX_BOUNTY_CHALLENGE_MARKDOWN_CHARACTERS = 1e6;
-var BOUNTY_CHALLENGE_FRONTMATTER_KEYS = [
-  "profile",
-  "escrow_amount",
-  "submission_deadline",
-  "payout_policy"
-];
-var BOUNTY_CHALLENGE_OPTIONAL_FRONTMATTER_KEYS = [
-  "constraints"
-];
 var ALLOWED_FRONTMATTER_KEYS = [
   ...BOUNTY_CHALLENGE_FRONTMATTER_KEYS,
   ...BOUNTY_CHALLENGE_OPTIONAL_FRONTMATTER_KEYS
 ].join(", ");
-var ALLOWED_FRONTMATTER_KEYS_MESSAGE = `Use only the v0 template frontmatter keys: ${ALLOWED_FRONTMATTER_KEYS}`;
+var ALLOWED_FRONTMATTER_KEYS_MESSAGE = `Use only the template frontmatter keys: ${ALLOWED_FRONTMATTER_KEYS}`;
 var DEPLOYMENT_OWNED_FRONTMATTER_KEYS = /* @__PURE__ */ new Set([
   "chain_id",
   "token_address",
@@ -1257,7 +1375,7 @@ var BountyChallengeSpecValidationError = class extends Error {
     this.issues = issues;
   }
 };
-var markdownSchema = z2.string().min(1, "Markdown body must not be empty").max(
+var markdownSchema = z3.string().min(1, "Markdown body must not be empty").max(
   MAX_BOUNTY_CHALLENGE_MARKDOWN_CHARACTERS,
   `Markdown body must be at most ${MAX_BOUNTY_CHALLENGE_MARKDOWN_CHARACTERS} characters`
 );
@@ -1341,16 +1459,15 @@ function splitConstraintsBlock(lines, issues) {
       if (entry.trim().length === 0) break;
       if (!/^\s+\S/.test(entry)) break;
       index += 1;
-      const match = entry.trim().match(/^([a-z][a-z0-9_]*):\s*(.+)$/);
-      const key = match?.[1];
-      const rawValue = match?.[2];
-      if (key === void 0 || rawValue === void 0) {
+      const parsed = frontmatterEntry(entry.trim());
+      if (!parsed || parsed.value === "") {
         issues.push({
           path: `frontmatter.constraints.line_${index + 2}`,
           message: "Constraint entries must use snake_case_key: value"
         });
         continue;
       }
+      const { key, value: rawValue } = parsed;
       if (seenKeys.has(key)) {
         issues.push({
           path: `frontmatter.constraints.${key}`,
@@ -1377,28 +1494,26 @@ function splitConstraintsBlock(lines, issues) {
   }
   return { scalarLines, constraints };
 }
+function frontmatterEntry(line) {
+  const key = /^[a-z][a-z0-9_]*:/.exec(line)?.[0];
+  if (!key) return null;
+  const value = line.slice(key.length).trimStart();
+  return hasLineBreak(value) ? null : { key: key.slice(0, -1), value };
+}
 function parsePublicationTermsFrontmatter(lines, issues) {
   const values = /* @__PURE__ */ new Map();
   let foundUnsupportedKey = false;
   for (const { text: line, index } of lines) {
     if (line.trim().length === 0) continue;
-    const match = line.match(/^([a-z][a-z0-9_]*):\s*(.*)$/);
-    if (!match) {
-      issues.push({
-        path: `frontmatter.line_${index + 2}`,
-        message: "Frontmatter entries must use snake_case_key: value"
-      });
-      continue;
-    }
-    const rawKey = match[1];
-    const rawValue = match[2];
-    if (rawKey === void 0 || rawValue === void 0) {
+    const parsed = frontmatterEntry(line);
+    if (!parsed) {
       issues.push({
         path: `frontmatter.line_${index + 2}`,
         message: "Frontmatter entries must use snake_case_key: value"
       });
       continue;
     }
+    const { key: rawKey, value: rawValue } = parsed;
     if (!isBountyChallengeFrontmatterKey(rawKey)) {
       if (DEPLOYMENT_OWNED_FRONTMATTER_KEYS.has(rawKey)) {
         if (!foundUnsupportedKey) {
@@ -1411,7 +1526,7 @@ function parsePublicationTermsFrontmatter(lines, issues) {
       } else {
         issues.push({
           path: `frontmatter.${rawKey}`,
-          message: `Remove frontmatter key "${rawKey}"; use only the v0 template frontmatter keys: ${ALLOWED_FRONTMATTER_KEYS}`
+          message: `Remove frontmatter key "${rawKey}"; use only the template frontmatter keys: ${ALLOWED_FRONTMATTER_KEYS}`
         });
       }
       continue;
@@ -1439,10 +1554,10 @@ function parsePublicationTermsFrontmatter(lines, issues) {
     }
   }
   const profile = values.get("profile");
-  if (profile !== void 0 && profile !== BOUNTY_CHALLENGE_PROFILE) {
+  if (profile !== void 0 && !isKnownProtocolProfile(profile)) {
     issues.push({
       path: "frontmatter.profile",
-      message: `Must equal ${BOUNTY_CHALLENGE_PROFILE}`
+      message: `Must be a published protocol profile: ${PROTOCOL_PROFILE_VERSIONS.join(", ")}`
     });
   }
   const payoutPolicy = values.get("payout_policy");
@@ -1462,7 +1577,7 @@ function parsePublicationTermsFrontmatter(lines, issues) {
     "frontmatter.escrow_amount",
     issues
   );
-  if (profile !== BOUNTY_CHALLENGE_PROFILE || payoutPolicy !== WINNER_TAKE_ALL_PAYOUT_POLICY || escrowAmount === null || submissionDeadline === null) {
+  if (profile === void 0 || !isKnownProtocolProfile(profile) || payoutPolicy !== WINNER_TAKE_ALL_PAYOUT_POLICY || escrowAmount === null || submissionDeadline === null) {
     return null;
   }
   return {
@@ -1472,40 +1587,40 @@ function parsePublicationTermsFrontmatter(lines, issues) {
     payoutPolicy
   };
 }
-function normalizeFrontmatterScalar(rawValue, path6, issues) {
+function normalizeFrontmatterScalar(rawValue, path7, issues) {
   const value = rawValue.trim();
   if (value.length === 0) {
-    issues.push({ path: path6, message: "Frontmatter value must not be empty" });
+    issues.push({ path: path7, message: "Frontmatter value must not be empty" });
     return null;
   }
   const quote = value[0];
   if (quote !== '"' && quote !== "'") return value;
   if (value.length < 2 || value.at(-1) !== quote) {
     issues.push({
-      path: path6,
+      path: path7,
       message: "Quoted frontmatter values must close with the same quote"
     });
     return null;
   }
   return value.slice(1, -1);
 }
-function parsePositiveSafeIntegerFrontmatter(value, path6, issues) {
+function parsePositiveSafeIntegerFrontmatter(value, path7, issues) {
   if (value === void 0) return null;
   if (!isPositiveInteger(value)) {
-    issues.push({ path: path6, message: "Must be a positive integer" });
+    issues.push({ path: path7, message: "Must be a positive integer" });
     return null;
   }
   const parsed = Number(value);
   if (!Number.isSafeInteger(parsed) || parsed <= 0) {
-    issues.push({ path: path6, message: "Must be a positive safe integer" });
+    issues.push({ path: path7, message: "Must be a positive safe integer" });
     return null;
   }
   return parsed;
 }
-function parsePositiveIntegerStringFrontmatter(value, path6, issues) {
+function parsePositiveIntegerStringFrontmatter(value, path7, issues) {
   if (value === void 0) return null;
   if (!isPositiveInteger(value)) {
-    issues.push({ path: path6, message: "Must be positive token smallest units" });
+    issues.push({ path: path7, message: "Must be positive token smallest units" });
     return null;
   }
   return value;
@@ -1529,36 +1644,36 @@ function isBountyChallengeFrontmatterKey(value) {
 
 // ../../packages/core/src/bounty-publication-response.ts
 import { isHex as isHex2 } from "viem";
-import { z as z3 } from "zod";
-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(isHex2, "Must be hex-encoded calldata").transform((value) => value);
-var bountyChallengeContentRecordSchema = z3.object({
-  content_kind: z3.literal("bounty_challenge_spec"),
+import { z as z4 } from "zod";
+var addressSchema = z4.string().refine(isHexAddress, "Must be a 20-byte EVM address").transform((value) => value);
+var bytes32Schema2 = z4.string().refine(isHexBytes32, "Must be a bytes32 hex string").transform((value) => value);
+var hexBytesSchema = z4.string().refine(isHex2, "Must be hex-encoded calldata").transform((value) => value);
+var bountyChallengeContentRecordSchema = z4.object({
+  content_kind: z4.literal("bounty_challenge_spec"),
   spec_commitment: bytes32Schema2,
-  byte_length: z3.number().int().positive(),
+  byte_length: z4.number().int().positive(),
   token_address: addressSchema,
-  created_at: z3.string().datetime({ offset: true })
+  created_at: z4.string().datetime({ offset: true })
 }).strict();
-var bountyPublicationResponseSchema = z3.object({
+var bountyPublicationResponseSchema = z4.object({
   content_record: bountyChallengeContentRecordSchema,
-  create_bounty_transaction: z3.object({
-    chain_id: z3.number().int().positive(),
+  create_bounty_transaction: z4.object({
+    chain_id: z4.number().int().positive(),
     to: addressSchema,
-    value: z3.literal("0"),
+    value: z4.literal("0"),
     data: hexBytesSchema,
-    function_name: z3.literal("create_bounty"),
-    args: z3.object({
+    function_name: z4.literal("create_bounty"),
+    args: z4.object({
       spec_commitment: bytes32Schema2,
-      escrow_amount: z3.string().refine(isPositiveInteger),
-      submission_deadline: z3.number().int().positive()
+      escrow_amount: z4.string().refine(isPositiveInteger),
+      submission_deadline: z4.number().int().positive()
     }).strict()
   }).strict(),
-  protocol_fee_policy: z3.object({
+  protocol_fee_policy: z4.object({
     treasury_recipient: addressSchema,
-    treasury_fee_bps: z3.number().int().min(0).max(1e4),
+    treasury_fee_bps: z4.number().int().min(0).max(1e4),
     guardian_fee_recipient: addressSchema,
-    guardian_fee_bps: z3.number().int().min(0).max(1e4)
+    guardian_fee_bps: z4.number().int().min(0).max(1e4)
   }).strict()
 }).strict().superRefine((response, context) => {
   if (response.content_record.spec_commitment !== response.create_bounty_transaction.args.spec_commitment) {
@@ -1569,31 +1684,31 @@ var bountyPublicationResponseSchema = z3.object({
     });
   }
 });
-var priorIssueSchema = z3.object({
-  issue_index: z3.number().int().nonnegative(),
-  message: z3.string().trim().min(1).max(1500)
+var priorIssueSchema = z4.object({
+  issue_index: z4.number().int().nonnegative(),
+  message: z4.string().trim().min(1).max(1500)
 }).strict();
 var priorIssueStatusSchema = priorIssueSchema.extend({
-  status: z3.enum(["resolved", "open"])
+  status: z4.enum(["resolved", "open"])
 }).strict();
-var readinessFindingSchema = z3.object({
-  path: z3.string().trim().min(1).max(120),
-  message: z3.string().trim().min(1).max(1500),
-  code: z3.string().min(1).optional(),
-  anchor: z3.string().trim().min(1).max(120).optional(),
-  hazard: z3.boolean().optional()
+var readinessFindingSchema = z4.object({
+  path: z4.string().trim().min(1).max(120),
+  message: z4.string().trim().min(1).max(1500),
+  code: z4.string().min(1).optional(),
+  anchor: z4.string().trim().min(1).max(120).optional(),
+  hazard: z4.boolean().optional()
 });
 var MAX_READINESS_FINDINGS = 20;
-var bountyReviewResponseSchema = z3.object({
+var bountyReviewResponseSchema = z4.object({
   content_record: bountyChallengeContentRecordSchema.omit({ created_at: true }),
-  readiness: z3.object({
-    decision: z3.literal("ready"),
+  readiness: z4.object({
+    decision: z4.literal("ready"),
     // Publication reuses the approval of these exact bytes until then.
-    approved_until: z3.string().datetime({ offset: true }),
+    approved_until: z4.string().datetime({ offset: true }),
     // The dissenting pass's findings on a ready check; never blocking.
-    warnings: z3.array(readinessFindingSchema).max(MAX_READINESS_FINDINGS),
-    prior_issues_resolved: z3.array(priorIssueSchema),
-    prior_issues_open: z3.array(priorIssueSchema)
+    warnings: z4.array(readinessFindingSchema).max(MAX_READINESS_FINDINGS),
+    prior_issues_resolved: z4.array(priorIssueSchema),
+    prior_issues_open: z4.array(priorIssueSchema)
   })
 });
 
@@ -1615,76 +1730,15 @@ function resolveSupportedChain(chainId) {
 }
 var FOUNDRY_CHAIN_ID = foundry.id;
 
-// ../../packages/core/src/protocol-profile.ts
-var PROTOCOL_PROFILE_V0 = Object.freeze({
-  profile: BOUNTY_CHALLENGE_PROFILE,
-  submission: Object.freeze({
-    maxCiphertextBytes: MAX_SOLVER_SUBMISSION_CIPHERTEXT_BYTES,
-    maxExtractedBytes: MAX_SOLVER_SUBMISSION_EXTRACTED_BYTES,
-    maxFiles: MAX_SOLVER_SUBMISSION_FILES,
-    filename: Object.freeze({
-      maxCharacters: MAX_SOLVER_SUBMISSION_NAME_CHARACTERS,
-      firstCharacter: "letter_or_digit",
-      allowedCharacters: "letters_digits_dot_underscore_hyphen",
-      caseInsensitivelyUnique: true
-    }),
-    layout: Object.freeze({
-      flat: true,
-      regularFilesOnly: true,
-      allowsSubdirectories: false,
-      allowsSymlinks: false,
-      allowsEmpty: false,
-      allowsArchivedDirectoryEntries: false,
-      allowsArchivedPathTraversal: false
-    }),
-    externalReferences: false
-  }),
-  challenge: Object.freeze({
-    maxMarkdownCharacters: MAX_BOUNTY_CHALLENGE_MARKDOWN_CHARACTERS,
-    requiredFrontmatterKeys: Object.freeze([
-      ...BOUNTY_CHALLENGE_FRONTMATTER_KEYS
-    ]),
-    optionalFrontmatterKeys: Object.freeze([
-      ...BOUNTY_CHALLENGE_OPTIONAL_FRONTMATTER_KEYS
-    ]),
-    payoutPolicies: Object.freeze([WINNER_TAKE_ALL_PAYOUT_POLICY])
-  }),
-  encryption: Object.freeze({
-    type: SUBMISSION_ENCRYPTION_TYPE
-  }),
-  tightenable: Object.freeze({
-    max_extracted_bytes: Object.freeze({
-      comparison: "at_most",
-      profileValue: MAX_SOLVER_SUBMISSION_EXTRACTED_BYTES
-    }),
-    max_files: Object.freeze({
-      comparison: "at_most",
-      profileValue: MAX_SOLVER_SUBMISSION_FILES
-    }),
-    allowed_extensions: Object.freeze({ comparison: "subset" }),
-    required_files: Object.freeze({ comparison: "filename_list" })
-  })
-});
-var PROTOCOL_PROFILES = /* @__PURE__ */ new Map([
-  [PROTOCOL_PROFILE_V0.profile, PROTOCOL_PROFILE_V0]
-]);
-var CURRENT_PROTOCOL_PROFILE = PROTOCOL_PROFILE_V0;
-var PROTOCOL_PROFILE_VERSIONS = Object.freeze([
-  ...PROTOCOL_PROFILES.keys()
-]);
-function getProtocolProfile(version) {
-  return PROTOCOL_PROFILES.get(version) ?? null;
-}
-
 // ../../packages/core/src/challenge-conformance.ts
 function checkChallengeConformance(input, profile = CURRENT_PROTOCOL_PROFILE) {
   const issues = [];
   const parsed = typeof input === "string" ? readFrontmatter(input, issues) : input;
-  const pinned = parsed === null ? null : resolveProfile(parsed.publicationTerms.profile, profile, issues);
-  if (parsed !== null && pinned !== null) {
-    checkTightenings(parsed.constraints, pinned, issues);
+  const declaredProfile = parsed === null ? null : resolveProfile(parsed.publicationTerms.profile, profile, issues);
+  if (parsed !== null && declaredProfile !== null) {
+    checkTightenings(parsed.constraints, declaredProfile, issues);
   }
-  return { issues, profile: pinned };
+  return { issues, profile: declaredProfile };
 }
 function readFrontmatter(markdown, issues) {
   try {
@@ -1703,16 +1757,16 @@ function readFrontmatter(markdown, issues) {
   }
 }
 function resolveProfile(declared, fallback2, issues) {
-  const pinned = getProtocolProfile(declared) ?? (declared === fallback2.profile ? fallback2 : null);
-  if (pinned === null) {
+  const known = getProtocolProfile(declared) ?? (declared === fallback2.profile ? fallback2 : null);
+  if (known === null) {
     issues.push({
       code: "profile_unknown",
       anchor: "frontmatter.profile",
       path: "frontmatter.profile",
-      message: `Unknown protocol profile "${declared}". A bounty can only pin a published profile version.`
+      message: `Unknown protocol profile "${declared}". A bounty can only declare a published profile version.`
     });
   }
-  return pinned;
+  return known;
 }
 function checkTightenings(constraints, profile, issues) {
   for (const constraint of constraints) {
@@ -1733,6 +1787,30 @@ function checkTightenings(constraints, profile, issues) {
     }
     checkListTightening(constraint, rule, profile, anchor, issues);
   }
+  checkRequiredFilesAllowed(constraints, issues);
+}
+function checkRequiredFilesAllowed(constraints, issues) {
+  const required2 = constraints.find((c) => c.key === "required_files");
+  const allowed = constraints.find((c) => c.key === "allowed_extensions");
+  if (required2 === void 0 || allowed === void 0) return;
+  const anchors = [required2, allowed].map(
+    (constraint) => `frontmatter.constraints.${constraint.key}`
+  );
+  if (issues.some((issue) => anchors.includes(issue.anchor))) return;
+  const paths = parseInlineList(required2.value);
+  const extensions = parseInlineList(allowed.value);
+  if (paths === null || extensions === null) return;
+  const excluded = paths.filter(
+    (file) => !hasAllowedExtension(file, extensions)
+  );
+  if (excluded.length > 0) {
+    issues.push({
+      code: "tightening_malformed",
+      anchor: anchors[0],
+      path: anchors[0],
+      message: `"required_files" names ${excluded.join(", ")}, which "allowed_extensions" excludes, so no Solver could satisfy both.`
+    });
+  }
 }
 function checkNumericTightening(constraint, rule, anchor, issues) {
   const ceiling = rule.profileValue;
@@ -1791,6 +1869,10 @@ function checkListTightening(constraint, rule, profile, anchor, issues) {
     return;
   }
   const { filename, maxFiles } = profile.submission;
+  if (rule.comparison === "path_list") {
+    checkRequiredPaths(constraint, members, maxFiles, anchor, issues);
+    return;
+  }
   const malformed = members.filter(
     (member) => member.length > filename.maxCharacters || !SOLVER_SUBMISSION_NAME_RE.test(member)
   );
@@ -1830,6 +1912,57 @@ function checkListTightening(constraint, rule, profile, anchor, issues) {
     });
   }
 }
+function checkRequiredPaths(constraint, members, maxFiles, anchor, issues) {
+  const malformed = members.filter(
+    (member) => describeSolverSubmissionPathIssue(member) !== null
+  );
+  if (malformed.length > 0) {
+    issues.push({
+      code: "tightening_malformed",
+      anchor,
+      path: anchor,
+      message: `"${constraint.key}" names paths that do not satisfy the profile's path rule: ${malformed.join(", ")}. A path is "/"-separated names, each starting with a letter or digit and using only letters, digits, ".", "_" and "-".`
+    });
+    return;
+  }
+  const conflict = findSolverSubmissionPathConflict(members);
+  if (conflict !== null) {
+    issues.push({
+      code: "tightening_malformed",
+      anchor,
+      path: anchor,
+      message: `"${constraint.key}" cannot be satisfied: ${describeSolverSubmissionPathConflict(conflict)}.`
+    });
+    return;
+  }
+  if (members.length > maxFiles) {
+    issues.push({
+      code: "tightening_exceeds_profile",
+      anchor,
+      path: anchor,
+      message: `"${constraint.key}" requires ${members.length} files, above the profile's ceiling of ${maxFiles}.`
+    });
+  }
+}
+function hasAllowedExtension(path7, extensions) {
+  const name = path7.toLowerCase();
+  return extensions.some((extension) => name.endsWith(extension.toLowerCase()));
+}
+function readChallengeConstraints(constraints) {
+  const read = {};
+  for (const { key, value } of constraints) {
+    if (key === "max_extracted_bytes" && /^\d+$/.test(value)) {
+      read.maxExtractedBytes = Number(value);
+    } else if (key === "max_files" && /^\d+$/.test(value)) {
+      read.maxFiles = Number(value);
+    } else if (key === "required_files") {
+      read.requiredFiles = parseInlineList(value) ?? [];
+    } else if (key === "allowed_extensions") {
+      read.allowedExtensions = parseInlineList(value) ?? [];
+    }
+  }
+  return read;
+}
 function parseInlineList(value) {
   if (!value.startsWith("[") || !value.endsWith("]")) return null;
   return value.slice(1, -1).split(",").map((member) => member.trim().replace(/^["']|["']$/g, "")).filter((member) => member.length > 0);
@@ -1845,6 +1978,7 @@ var DEPLOYMENTS = {
     ELGORA_SUBGRAPH_ENDPOINT: "https://api.goldsky.com/api/public/project_cmtu7wslg04s501ovc2je3beh/subgraphs/elgora-elgorahub-base/production/gn",
     ELGORA_API_BASE_URL: "https://elgora.ai",
     agentIdentitySubgraphEndpoint: "https://gateway.thegraph.com/api/subgraphs/id/43s9hQRurMGjuYnC1r2ZwS6xSQktbFyXMPMqGKUFJojb",
+    agentIdentityRegistryAddress: "0x8004a169fb4a3325136eb29fa0ceb6d2e539a432",
     agentExplorerBaseUrl: "https://8004scan.io/agents/base",
     deployBlock: 51752389,
     deployTransaction: "0xd62f407b770c8fca82a9704b30ed0605d9e3ed2b56278dcca152958063f7f469",
@@ -1857,6 +1991,7 @@ var DEPLOYMENTS = {
     ELGORA_SUBGRAPH_ENDPOINT: "https://api.goldsky.com/api/public/project_cmtu7wslg04s501ovc2je3beh/subgraphs/elgora-elgorahub/testnet-production/gn",
     ELGORA_API_BASE_URL: "https://testnet.elgora.ai",
     agentIdentitySubgraphEndpoint: "https://gateway.thegraph.com/api/subgraphs/id/4yYAvQLFjBhBtdRCY7eUWo181VNoTSLLFd5M7FXQAi6u",
+    agentIdentityRegistryAddress: "0x8004a818bfb912233c491871b3d84c89a494bd9e",
     agentExplorerBaseUrl: "https://testnet.8004scan.io/agents/base-sepolia",
     deployBlock: 46353511,
     deployTransaction: "0xed3d3c8af3c69f9f8d4ec47da7179fe4b89bd4a4cd8d8232dbbd3d3f3d38e74b",
@@ -1894,9 +2029,9 @@ async function main(_env = process.env, argv = process.argv.slice(2)) {
   }
 }
 function readBountyChallengeMarkdown(argv) {
-  const path6 = argv[0];
-  if (!path6 || argv.length !== 1) throw usageError(USAGE);
-  return readInput(path6);
+  const path7 = argv[0];
+  if (!path7 || argv.length !== 1) throw usageError(USAGE);
+  return readInput(path7);
 }
 var command = { main, OPTIONS, USAGE };
 
@@ -4168,7 +4303,7 @@ function settlementAmounts(escrowAmount, treasuryFeeBps, guardianFeeBps) {
 }
 
 // ../../packages/core/src/api/bounty-preparation.ts
-import { ZodError, z as z4 } from "zod";
+import { ZodError, z as z5 } from "zod";
 
 // ../../packages/core/src/api/elgorahub.ts
 import {
@@ -4401,14 +4536,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) => {
@@ -4429,11 +4564,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
 });
@@ -4449,30 +4584,30 @@ 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 publicationEnvShape = {
   ELGORA_CHAIN_ID: envShape.ELGORA_CHAIN_ID,
@@ -4480,88 +4615,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: z5.string().trim().toLowerCase().pipe(z5.enum(["true", "false"])).default("true").transform((value) => value === "true"),
-  ELGORA_READINESS_TIMEOUT_MS: z5.coerce.number().int().min(1).max(READINESS_TIMEOUT_MS).default(READINESS_TIMEOUT_MS)
+  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)
 };
-var envSchema = z5.object(envShape);
-var bountyPublicationEnvSchema = z5.object(publicationEnvShape);
+var envSchema = z6.object(envShape);
+var bountyPublicationEnvSchema = z6.object(publicationEnvShape);
 
 // ../../packages/core/src/api/solver-submission-responses.ts
 import { isHex as isHex3 } from "viem";
-import { z as z6 } from "zod";
-var hexAddressSchema = z6.string().refine(isHexAddress, "Must be a hex-encoded address");
-var hexBytes32Schema = z6.string().refine(isHexBytes32, "Must be 32-byte hex");
-var hexDataSchema = z6.string().refine((value) => isHex3(value), "Must be hex-encoded calldata");
-var artifactUploadUrlResponseSchema = z6.object({
-  locator: z6.string().min(1),
-  upload_url: z6.string().min(1),
-  method: z6.literal("PUT"),
-  expires_at: z6.string().min(1)
+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)
 });
-var solverSubmissionPrepareResponseSchema = z6.object({
-  content_record: z6.object({
-    content_kind: z6.literal(SOLVER_SUBMISSION_CONTENT_KIND),
+var solverSubmissionPrepareResponseSchema = z7.object({
+  content_record: z7.object({
+    content_kind: z7.literal(SOLVER_SUBMISSION_CONTENT_KIND),
     submission_commitment: hexBytes32Schema,
-    byte_length: z6.number().int().nonnegative(),
-    created_at: z6.string().min(1)
+    byte_length: z7.number().int().nonnegative(),
+    created_at: z7.string().min(1)
   }),
-  submit_transaction: z6.object({
-    chain_id: z6.number().int().positive(),
+  submit_transaction: z7.object({
+    chain_id: z7.number().int().positive(),
     to: hexAddressSchema,
-    value: z6.literal("0"),
+    value: z7.literal("0"),
     data: hexDataSchema,
-    function_name: z6.literal("submit"),
-    args: z6.object({
-      bounty_id: z6.string().min(1),
+    function_name: z7.literal("submit"),
+    args: z7.object({
+      bounty_id: z7.string().min(1),
       submission_commitment: hexBytes32Schema,
       guardian_roster_hash: hexBytes32Schema,
-      extra_data: z6.literal("0x")
+      extra_data: z7.literal("0x")
     })
   })
 });
-var solverSubmissionContentResponseSchema = z6.object({
-  content_record: z6.object({
-    bounty_id: z6.string().min(1),
-    canonical_json: z6.string().min(1)
+var solverSubmissionContentResponseSchema = z7.object({
+  content_record: z7.object({
+    bounty_id: z7.string().min(1),
+    canonical_json: z7.string().min(1)
   }),
-  ciphertext_download_url: z6.string().min(1),
-  expires_at: z6.string().min(1)
+  ciphertext_download_url: z7.string().min(1),
+  expires_at: z7.string().min(1)
 });
-var bountyGuardianRosterResponseSchema = z6.object({
-  bounty: z6.object({
+var bountySubmissionDetailResponseSchema = z7.object({
+  bounty: z7.object({
     guardian_roster_hash: hexBytes32Schema,
-    guardian_roster: z6.array(
-      z6.object({
-        name: z6.string(),
+    guardian_roster: z7.array(
+      z7.object({
+        name: z7.string(),
         account: hexAddressSchema,
-        encryption_public_key: z6.string().min(1)
+        encryption_public_key: z7.string().min(1)
       })
     ).min(1)
-  })
+  }),
+  challenge: z7.string().nullable()
 });
 
 // ../../packages/core/src/api/verification-records.ts
-import { z as z7 } from "zod";
-var hexAddressSchema2 = z7.string().refine(isHexAddress, "Must be a hex-encoded address").transform((value) => value.toLowerCase());
-var hexBytes32Schema2 = z7.string().refine(isHexBytes32, "Must be 32-byte hex").transform((value) => value.toLowerCase());
-var integerStringSchema = z7.string().regex(/^(0|[1-9][0-9]*)$/);
-var verdictEntrySchema = z7.object({
-  name: z7.string().min(1),
-  outcome: z7.enum(["awarded", "no_valid_submission"]).nullable(),
+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(),
   winner: hexAddressSchema2.nullable(),
   report_commitment: hexBytes32Schema2.nullable(),
-  committed_at: z7.string().datetime({ offset: true }).nullable(),
-  supporting: z7.boolean()
+  committed_at: z8.string().datetime({ offset: true }).nullable(),
+  supporting: z8.boolean()
 }).strict();
-var formattedVerificationRecordSchema = z7.object({
-  chain_id: z7.number().int().positive(),
+var formattedVerificationRecordSchema = z8.object({
+  chain_id: z8.number().int().positive(),
   hub_address: hexAddressSchema2,
   bounty_id: integerStringSchema,
-  status: z7.enum(["awarded", "no_valid_submission", "timed_out"]),
+  status: z8.enum(["awarded", "no_valid_submission", "timed_out"]),
   spec_commitment: hexBytes32Schema2,
   winner: hexAddressSchema2.nullable(),
-  verdicts: z7.record(z7.string(), verdictEntrySchema),
-  settlement: z7.object({
+  verdicts: z8.record(z8.string(), verdictEntrySchema),
+  settlement: z8.object({
     escrow_amount: integerStringSchema,
     settlement_recipient: hexAddressSchema2,
     settlement_amount: integerStringSchema,
@@ -4572,10 +4708,10 @@ var formattedVerificationRecordSchema = z7.object({
     settled_tx_hash: hexBytes32Schema2,
     settled_block_number: integerStringSchema
   }).strict(),
-  content_record: z7.object({
-    spec_content_byte_length: z7.number().int().positive()
+  content_record: z8.object({
+    spec_content_byte_length: z8.number().int().positive()
   }).strict(),
-  verified_at: z7.string().datetime({ offset: true })
+  verified_at: z8.string().datetime({ offset: true })
 }).strict();
 function parseBountyVerificationRecord(input, expected) {
   const slice = input;
@@ -4597,66 +4733,66 @@ function parseBountyVerificationRecord(input, expected) {
 }
 
 // ../../packages/core/src/api/winning-solution-delivery.ts
-import { z as z8 } from "zod";
-var hexBytes32Schema3 = z8.string().refine(isHexBytes32, "Must be 32-byte hex").refine((value) => value !== ZERO_BYTES32, "Must not be zero").transform((value) => value.toLowerCase());
-var hexAddressSchema3 = z8.string().refine((value) => /^0x[0-9a-fA-F]{40}$/.test(value), "Must be an address").transform((value) => value.toLowerCase());
-var deliveryKeyIdSchema = z8.string().min(1).max(128);
-var winningSolutionWrappedKeySchema = z8.strictObject({
-  enc: z8.string().min(1),
-  ciphertext: z8.string().min(1)
+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)
 });
-var deliveryWrapRequestSchema = z8.strictObject({
+var deliveryWrapRequestSchema = z9.strictObject({
   solver_address: hexAddressSchema3,
   submission_commitment: hexBytes32Schema3,
   wrapped_key: winningSolutionWrappedKeySchema
 });
-var deliveryWrapRecordSchema = z8.strictObject({
-  bounty_id: z8.string().min(1),
+var deliveryWrapRecordSchema = z9.strictObject({
+  bounty_id: z9.string().min(1),
   guardian_address: hexAddressSchema3,
   solver_address: hexAddressSchema3,
   submission_commitment: hexBytes32Schema3,
   delivery_key_id: deliveryKeyIdSchema,
-  created_at: z8.string().min(1)
+  created_at: z9.string().min(1)
 });
-var deliveryWrapResponseSchema = z8.strictObject({
-  status: z8.literal("stored"),
+var deliveryWrapResponseSchema = z9.strictObject({
+  status: z9.literal("stored"),
   wrap: deliveryWrapRecordSchema
 });
-var deliveryRetrieveRequestSchema = z8.strictObject({
+var deliveryRetrieveRequestSchema = z9.strictObject({
   poster_ephemeral_public_key: x25519PublicKeySchema
 });
-var deliveryRetrieveResponseSchema = z8.strictObject({
+var deliveryRetrieveResponseSchema = z9.strictObject({
   submission_commitment: hexBytes32Schema3,
   wrapped_key: winningSolutionWrappedKeySchema
 });
-var deliveryStatusResponseSchema = z8.strictObject({
-  exists: z8.boolean()
+var deliveryStatusResponseSchema = z9.strictObject({
+  exists: z9.boolean()
 });
-var deliveryKeyConfigResponseSchema = z8.strictObject({
+var deliveryKeyConfigResponseSchema = z9.strictObject({
   delivery_key_id: deliveryKeyIdSchema,
-  public_key: z8.string().min(1)
+  public_key: z9.string().min(1)
 });
 
 // ../../packages/core/src/api/written-verdicts.ts
 import { keccak256 as keccak2564, toBytes as toBytes3, zeroAddress } from "viem";
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var WRITTEN_VERDICT_FORMAT_VERSION = 0;
 var FRONTMATTER_DELIMITER2 = "---";
-var decimalSchema = z9.string().regex(/^[1-9][0-9]*$/, "Must be a positive integer").transform(Number).refine(Number.isSafeInteger, "Must be a safe integer");
-var bountyIdSchema2 = z9.string().regex(/^(0|[1-9][0-9]*)$/, "Must be a non-negative integer");
-var addressSchema2 = z9.string().refine(isHexAddress, "Must be a hex-encoded address").refine((value) => value === value.toLowerCase(), "Must use lowercase hex").transform((value) => value);
-var bytes32Schema3 = z9.string().refine(isHexBytes32, "Must be 32-byte hex").refine((value) => value === value.toLowerCase(), "Must use lowercase hex").transform((value) => value);
+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 commonFields = {
-  format_version: z9.literal(WRITTEN_VERDICT_FORMAT_VERSION.toString()).transform(() => WRITTEN_VERDICT_FORMAT_VERSION),
+  format_version: z10.literal(WRITTEN_VERDICT_FORMAT_VERSION.toString()).transform(() => WRITTEN_VERDICT_FORMAT_VERSION),
   chain_id: decimalSchema,
   hub_address: addressSchema2,
   bounty_id: bountyIdSchema2,
-  verdict_body: z9.string().refine((value) => value.trim().length > 0, "Must not be empty")
+  verdict_body: z10.string().refine((value) => value.trim().length > 0, "Must not be empty")
 };
-var writtenVerdictSchema = z9.discriminatedUnion("outcome", [
-  z9.object({
+var writtenVerdictSchema = z10.discriminatedUnion("outcome", [
+  z10.object({
     ...commonFields,
-    outcome: z9.literal("awarded"),
+    outcome: z10.literal("awarded"),
     winner: addressSchema2.refine(
       (value) => value !== zeroAddress,
       "Must not be the zero address"
@@ -4666,10 +4802,10 @@ var writtenVerdictSchema = z9.discriminatedUnion("outcome", [
       "Must not be zero bytes"
     )
   }).strict(),
-  z9.object({
+  z10.object({
     ...commonFields,
-    outcome: z9.literal("no_valid_submission"),
-    winner: z9.literal(zeroAddress)
+    outcome: z10.literal("no_valid_submission"),
+    winner: z10.literal(zeroAddress)
   }).strict()
 ]);
 function buildWrittenVerdictMarkdown(input) {
@@ -4751,10 +4887,10 @@ ${FRONTMATTER_DELIMITER2}
   }
   return result.data;
 }
-function invalidWrittenVerdict(path6, message) {
+function invalidWrittenVerdict(path7, message) {
   return new BoundaryValidationError(
     "Invalid written Verdict",
-    [{ path: path6, message }],
+    [{ path: path7, message }],
     "invalid_written_verdict"
   );
 }
@@ -4839,12 +4975,12 @@ async function getAuthenticatedJson(apiBaseUrl, pathname, authorization) {
   });
   return parseJsonResponse(url, response);
 }
-async function requestBountyGuardianRoster(input) {
+async function requestBountySubmissionDetail(input) {
   const body = await getJson(
     input.apiBaseUrl,
     `/api/bounties/${input.bountyId}`
   );
-  return bountyGuardianRosterResponseSchema.parse(body).bounty;
+  return bountySubmissionDetailResponseSchema.parse(body);
 }
 async function requestDeploymentDeliveryPublicKey(input) {
   const body = await getJson(input.apiBaseUrl, "/api/deployment/delivery-key");
@@ -5351,8 +5487,8 @@ async function waitForSponsoredHash(config, transactionId, call) {
     `Privy ${call.function_name} transaction ${transactionId} had no transaction hash after ${SPONSORED_TIMEOUT_MS / 1e3} s`
   );
 }
-async function privyRequest(config, method, path6, body) {
-  const url = `${PRIVY_API_URL}${path6}`;
+async function privyRequest(config, method, path7, body) {
+  const url = `${PRIVY_API_URL}${path7}`;
   const headers = {
     authorization: `Basic ${Buffer.from(`${config.appId}:${config.appSecret}`).toString("base64")}`,
     "privy-app-id": config.appId
@@ -5384,12 +5520,12 @@ async function privyRequest(config, method, path6, body) {
   if (!response.ok) {
     const message = parsed && typeof parsed === "object" && typeof parsed.error === "string" ? parsed.error : `HTTP ${response.status}`;
     throw new PrivyRequestError(
-      `Privy ${method} ${path6} failed (${response.status}): ${message}`,
+      `Privy ${method} ${path7} failed (${response.status}): ${message}`,
       response.status
     );
   }
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error(`Privy ${method} ${path6} returned a non-object body`);
+    throw new Error(`Privy ${method} ${path7} returned a non-object body`);
   }
   return parsed;
 }
@@ -6085,7 +6221,7 @@ function typedDataForRequest(request, block) {
 }
 
 // ../../packages/core/src/auth/request-approval-header.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 async function buildAuthorizationHeader(params) {
   const url = new URL(params.requestUrl);
   const typedData = typedDataForRequest(
@@ -6112,8 +6248,8 @@ async function authorizeRequest(params) {
     block: await readChallengeBlock(params)
   });
 }
-var challengeBlockSchema = z10.object({
-  error: z10.object({ block_number: z10.string(), block_hash: z10.string() })
+var challengeBlockSchema = z11.object({
+  error: z11.object({ block_number: z11.string(), block_hash: z11.string() })
 });
 async function readChallengeBlock(params) {
   const response = await fetch(params.requestUrl, {
@@ -6126,98 +6262,553 @@ async function readChallengeBlock(params) {
       `Expected an approval challenge (401) from ${params.requestUrl}, got ${response.status}.`
     );
   }
-  const { block_number, block_hash } = challengeBlockSchema.parse(
-    await response.json()
-  ).error;
-  return { number: BigInt(block_number), hash: block_hash };
+  const { block_number, block_hash } = challengeBlockSchema.parse(
+    await response.json()
+  ).error;
+  return { number: BigInt(block_number), hash: block_hash };
+}
+
+// ../../packages/core/src/winning-solution-delivery.ts
+async function wrapWinningSolutionKey(input) {
+  const deploymentDeliveryPublicKey = await requestDeploymentDeliveryPublicKey({
+    apiBaseUrl: input.config.apiBaseUrl
+  });
+  const contentPathname = `/api/bounties/${input.bountyId}/submissions/${input.submissionCommitment}/content`;
+  const contentAuthorization = await authorizeRequest({
+    requestUrl: new URL(contentPathname, input.config.apiBaseUrl).toString(),
+    method: "GET",
+    body: "",
+    chainId: input.config.chainId,
+    hubAddress: input.config.hubAddress,
+    address: input.owner.address,
+    sign: input.owner.signTypedData
+  });
+  const { content_record } = solverSubmissionContentResponseSchema.parse(
+    await getAuthenticatedJson(
+      input.config.apiBaseUrl,
+      contentPathname,
+      contentAuthorization
+    )
+  );
+  const envelope = parseSubmissionEnvelope(
+    JSON.parse(content_record.canonical_json)
+  );
+  const opened = await openSubmissionEnvelopeForDelivery({
+    envelope,
+    guardian_private_keys: input.guardianPrivateKeys,
+    timelock_decrypt: createSubmissionTimelockDecrypt(),
+    delivery_recipient_public_key: deploymentDeliveryPublicKey,
+    context: {
+      chain_id: input.config.chainId,
+      hub_address: input.config.hubAddress,
+      bounty_id: input.bountyId.toString(),
+      submission_commitment: input.submissionCommitment
+    }
+  });
+  const requestUrl = new URL(
+    `/api/bounties/${input.bountyId}/delivery/wrap`,
+    input.config.apiBaseUrl
+  );
+  const body = JSON.stringify({
+    solver_address: input.solver,
+    submission_commitment: input.submissionCommitment,
+    wrapped_key: opened.wrapped_key
+  });
+  const authorization = await authorizeRequest({
+    requestUrl: requestUrl.toString(),
+    method: "POST",
+    contentType: "application/json",
+    body,
+    chainId: input.config.chainId,
+    hubAddress: input.config.hubAddress,
+    address: input.owner.address,
+    sign: input.owner.signTypedData
+  });
+  const responseBody = await postText(
+    requestUrl,
+    body,
+    "application/json",
+    authorization
+  );
+  return deliveryWrapResponseSchema.parse(responseBody);
+}
+
+// src/guardian-open.ts
+import path3 from "path";
+
+// src/artifact-output.ts
+import { constants } from "fs";
+import { lstat, mkdir, open, readdir } from "fs/promises";
+import path2 from "path";
+var CREATE_FILE_FLAGS = constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | constants.O_NOFOLLOW;
+var MAX_HOST_PATH_BYTES = process.platform === "darwin" ? 1023 : 4095;
+async function writeOpenedArtifacts(outputDir, files) {
+  for (const file of files) {
+    const issue = describeSolverSubmissionPathIssue(file.path);
+    if (issue !== null) {
+      throw new Error(`Refusing to write the Submission: ${issue}`);
+    }
+  }
+  const conflict = findSolverSubmissionPathConflict(
+    files.map((file) => file.path)
+  );
+  if (conflict !== null) {
+    throw new Error(
+      `Refusing to write the Submission: ${describeSolverSubmissionPathConflict(conflict)}.`
+    );
+  }
+  const root = path2.resolve(outputDir);
+  const targets = files.map((file) => {
+    const target = path2.resolve(root, ...file.path.split("/"));
+    const relative = path2.relative(root, target);
+    if (relative === "" || relative.startsWith("..") || path2.isAbsolute(relative)) {
+      throw new Error(
+        `Refusing to write the Submission: "${file.path}" resolves outside ${outputDir}.`
+      );
+    }
+    return { target, bytes: file.bytes };
+  });
+  const longest = targets.reduce(
+    (max, { target }) => Math.max(max, Buffer.byteLength(target)),
+    0
+  );
+  if (longest > MAX_HOST_PATH_BYTES) {
+    throw new Error(
+      `Refusing to write the Submission: its longest path under ${outputDir} is ${longest} bytes, and this host opens at most ${MAX_HOST_PATH_BYTES}. Choose a shorter output directory.`
+    );
+  }
+  await prepareOutputDirectory(root, outputDir);
+  for (const { target, bytes } of targets) {
+    await mkdir(path2.dirname(target), { recursive: true });
+    await assertRealDirectoriesBelow(root, path2.dirname(target));
+    const handle = await open(target, CREATE_FILE_FLAGS, 420);
+    try {
+      await handle.writeFile(bytes);
+    } finally {
+      await handle.close();
+    }
+  }
+}
+async function prepareOutputDirectory(root, outputDir) {
+  const existing = await lstat(root).catch((error) => {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  });
+  if (existing === null) {
+    await mkdir(root, { recursive: true });
+    return;
+  }
+  if (!existing.isDirectory()) {
+    throw new Error(
+      `Output directory ${outputDir} exists and is not a directory. Choose a new output directory.`
+    );
+  }
+  if ((await readdir(root)).length > 0) {
+    throw new Error(
+      `Output directory ${outputDir} is not empty. Choose a new output directory, or remove this one, before opening the Submission again.`
+    );
+  }
+}
+async function assertRealDirectoriesBelow(root, directory) {
+  let current = directory;
+  while (current !== root) {
+    if (!(await lstat(current)).isDirectory()) {
+      throw new Error(
+        `Refusing to write the Submission: ${current} is not a real directory.`
+      );
+    }
+    current = path2.dirname(current);
+  }
+}
+
+// src/submission-archive.ts
+import { createHash as createHash2 } from "crypto";
+import { gunzipSync, gzipSync } from "zlib";
+
+// ../../packages/tarts/src/tar.ts
+var BLOCK = 512;
+var NAME_FIELD = 100;
+var encoder = new TextEncoder();
+var decoder = new TextDecoder("utf-8");
+var TarFormatError = class extends Error {
+};
+function writeTar(files) {
+  const blocks = [];
+  for (const file of files) {
+    const name = encoder.encode(file.path);
+    if (name.byteLength > NAME_FIELD) {
+      const record = paxRecord("path", file.path);
+      blocks.push(header("PaxHeader", "x", record.byteLength), padded(record));
+    }
+    blocks.push(
+      header(file.path, "0", file.bytes.byteLength),
+      padded(file.bytes)
+    );
+  }
+  blocks.push(new Uint8Array(2 * BLOCK));
+  return concat(blocks);
+}
+function readTar(tar) {
+  const entries = [];
+  let path7;
+  for (let offset = 0; offset + BLOCK <= tar.byteLength; ) {
+    const block = tar.subarray(offset, offset + BLOCK);
+    if (block.every((byte) => byte === 0)) return entries;
+    if (!checksumMatches(block)) {
+      throw new TarFormatError(
+        `the header at byte ${offset} fails its checksum`
+      );
+    }
+    const size2 = readSize(block.subarray(124, 136));
+    const start = offset + BLOCK;
+    if (start + size2 > tar.byteLength) {
+      throw new TarFormatError(`the entry at byte ${offset} is truncated`);
+    }
+    const data = tar.subarray(start, start + size2);
+    offset = start + Math.ceil(size2 / BLOCK) * BLOCK;
+    const type = String.fromCharCode(block[156] ?? 0);
+    if (type === "x") {
+      path7 = readPaxPath(data) ?? path7;
+      continue;
+    }
+    if (type === "L") {
+      path7 = decoder.decode(nulTerminated(data));
+      continue;
+    }
+    if (type === "g") continue;
+    const prefix = decoder.decode(nulTerminated(block.subarray(345, 500)));
+    const headerName = decoder.decode(
+      nulTerminated(block.subarray(0, NAME_FIELD))
+    );
+    entries.push({
+      name: path7 ?? (prefix ? `${prefix}/${headerName}` : headerName),
+      type: type === "\0" ? "0" : type,
+      data
+    });
+    path7 = void 0;
+  }
+  throw new TarFormatError("it is truncated: no end-of-archive block");
+}
+function header(name, type, size2) {
+  const block = new Uint8Array(BLOCK);
+  const put = (offset, value) => block.set(encoder.encode(value), offset);
+  block.set(encoder.encode(name).subarray(0, NAME_FIELD), 0);
+  put(100, "0000644\0");
+  put(108, "0000000\0");
+  put(116, "0000000\0");
+  put(124, `${size2.toString(8).padStart(11, "0")}\0`);
+  put(136, "00000000000\0");
+  put(156, type);
+  put(257, "ustar\0");
+  put(263, "00");
+  block.fill(32, 148, 156);
+  const sum = block.reduce((total, byte) => total + byte, 0);
+  put(148, `${sum.toString(8).padStart(6, "0")}\0 `);
+  return block;
+}
+function paxRecord(key, value) {
+  const body = ` ${key}=${value}
+`;
+  const bodyLength = encoder.encode(body).byteLength;
+  let length = bodyLength + 1;
+  while (String(length).length + bodyLength !== length) length += 1;
+  return encoder.encode(`${length}${body}`);
+}
+function readPaxPath(data) {
+  let path7;
+  let offset = 0;
+  while (offset < data.byteLength) {
+    const space = data.indexOf(32, offset);
+    const length = Number.parseInt(latin1(data.subarray(offset, space)), 10);
+    if (space < 0 || !Number.isSafeInteger(length) || length <= 0) {
+      throw new TarFormatError("a pax header does not parse");
+    }
+    const record = data.subarray(space + 1, offset + length - 1);
+    const equals = record.indexOf(61);
+    if (equals >= 0 && latin1(record.subarray(0, equals)) === "path") {
+      path7 = decoder.decode(record.subarray(equals + 1));
+    }
+    offset += length;
+  }
+  return path7;
+}
+function checksumMatches(block) {
+  let sum = 0;
+  for (let index = 0; index < BLOCK; index += 1) {
+    sum += index >= 148 && index < 156 ? 32 : block[index] ?? 0;
+  }
+  return readOctal(block.subarray(148, 156)) === sum;
+}
+function readSize(field) {
+  let size2;
+  if (((field[0] ?? 0) & 128) !== 0) {
+    size2 = 0;
+    for (const [index, byte] of field.entries()) {
+      size2 = size2 * 256 + (index === 0 ? byte & 127 : byte);
+    }
+  } else {
+    size2 = readOctal(field);
+  }
+  if (!Number.isSafeInteger(size2) || size2 < 0) {
+    throw new TarFormatError("a header declares no readable size");
+  }
+  return size2;
+}
+function readOctal(field) {
+  const digits = latin1(field).replace(/^[ \0]+|[ \0]+$/g, "");
+  return /^[0-7]+$/.test(digits) ? Number.parseInt(digits, 8) : Number.NaN;
+}
+function nulTerminated(field) {
+  const end = field.indexOf(0);
+  return end < 0 ? field : field.subarray(0, end);
+}
+function latin1(bytes) {
+  return String.fromCharCode(...bytes);
+}
+function padded(bytes) {
+  const out = new Uint8Array(Math.ceil(bytes.byteLength / BLOCK) * BLOCK);
+  out.set(bytes);
+  return out;
+}
+function concat(chunks) {
+  const out = new Uint8Array(
+    chunks.reduce((total, chunk) => total + chunk.byteLength, 0)
+  );
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return out;
+}
+
+// src/submission-archive.ts
+function buildSubmissionArchive(files) {
+  const sorted = [...files].sort(
+    (left, right) => compareBytewise(left.path, right.path)
+  );
+  assertSubmissionFiles(sorted);
+  const archive = gzipSync(writeTar(sorted), { level: 9 });
+  return {
+    archive: new Uint8Array(archive.buffer, archive.byteOffset, archive.length),
+    ...describeFiles(sorted)
+  };
+}
+function readSubmissionArchive(archive) {
+  let tar;
+  try {
+    const inflated = gunzipSync(archive);
+    tar = new Uint8Array(
+      inflated.buffer,
+      inflated.byteOffset,
+      inflated.byteLength
+    );
+  } catch {
+    reject("it is not a gzip stream");
+  }
+  let entries;
+  try {
+    entries = readTar(tar);
+  } catch (error) {
+    if (error instanceof TarFormatError) reject(error.message);
+    throw error;
+  }
+  const files = entries.map((entry) => {
+    if (entry.type !== "0") {
+      reject(`"${entry.name}" is not a regular file entry`);
+    }
+    return { path: entry.name, bytes: entry.data };
+  });
+  files.sort((left, right) => compareBytewise(left.path, right.path));
+  assertSubmissionFiles(files);
+  return { files, ...describeFiles(files) };
+}
+function requireCurrentFormat(alg, bountyId, command18) {
+  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}`
+    );
+  }
+}
+function readOpenedSubmission(bundle) {
+  if (bundle.alg !== SUBMISSION_ENCRYPTION_TYPE_V1) {
+    throw new Error("A _v0 Submission is opened with CLI 11.");
+  }
+  const { files, content_sha256 } = readSubmissionArchive(bundle.archive);
+  return { files, content_sha256 };
+}
+function describeFiles(sorted) {
+  const manifest = {
+    kind: SUBMISSION_ENCRYPTED_BUNDLE_V1_KIND,
+    artifacts: sorted.map((file) => ({
+      path: file.path,
+      size_bytes: file.bytes.byteLength,
+      sha256: sha256Hex(file.bytes)
+    }))
+  };
+  const manifestBytes = new TextEncoder().encode(
+    canonicalizeJson(manifest)
+  );
+  return { manifest, content_sha256: sha256Hex(manifestBytes) };
+}
+function assertSubmissionFiles(files) {
+  if (files.length === 0) {
+    reject("a Submission must hold at least one file");
+  }
+  if (files.length > MAX_SOLVER_SUBMISSION_FILES_V1) {
+    reject(
+      `a Submission holds at most ${MAX_SOLVER_SUBMISSION_FILES_V1} files; this one holds ${files.length}`
+    );
+  }
+  for (const file of files) {
+    const issue = describeSolverSubmissionPathIssue(file.path);
+    if (issue !== null) reject(issue);
+  }
+  const conflict = findSolverSubmissionPathConflict(
+    files.map((file) => file.path)
+  );
+  if (conflict !== null) reject(describeSolverSubmissionPathConflict(conflict));
+  const total = files.reduce((sum, file) => sum + file.bytes.byteLength, 0);
+  if (total > MAX_SOLVER_SUBMISSION_EXTRACTED_BYTES) {
+    reject(
+      `a Submission extracts to at most ${MAX_SOLVER_SUBMISSION_EXTRACTED_BYTES} bytes; this one holds ${total}`
+    );
+  }
+}
+function sha256Hex(bytes) {
+  return createHash2("sha256").update(bytes).digest("hex");
+}
+function compareBytewise(left, right) {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+}
+function reject(reason) {
+  throw new Error(
+    `Submission archive is not a valid Elgora tar.gz: ${reason.replace(/\.$/, "")}.`
+  );
 }
 
-// ../../packages/core/src/winning-solution-delivery.ts
-async function wrapWinningSolutionKey(input) {
-  const deploymentDeliveryPublicKey = await requestDeploymentDeliveryPublicKey({
-    apiBaseUrl: input.config.apiBaseUrl
-  });
-  const contentPathname = `/api/bounties/${input.bountyId}/submissions/${input.submissionCommitment}/content`;
-  const contentAuthorization = await authorizeRequest({
-    requestUrl: new URL(contentPathname, input.config.apiBaseUrl).toString(),
-    method: "GET",
-    body: "",
-    chainId: input.config.chainId,
-    hubAddress: input.config.hubAddress,
-    address: input.owner.address,
-    sign: input.owner.signTypedData
-  });
-  const { content_record, ciphertext_download_url } = solverSubmissionContentResponseSchema.parse(
-    await getAuthenticatedJson(
-      input.config.apiBaseUrl,
-      contentPathname,
-      contentAuthorization
-    )
+// src/submission-check.ts
+function checkSubmissionArchive(input) {
+  const { files, content_sha256 } = readSubmissionArchive(input.archive);
+  return {
+    content_sha256,
+    ...checkOpenedSubmission({
+      files,
+      profile: input.profile,
+      challenge: input.challenge
+    })
+  };
+}
+function checkOpenedSubmission(input) {
+  const { files } = input;
+  const constraints = readChallengeConstraints(
+    parseBountyChallengeMarkdown(input.challenge).constraints
+  );
+  const budget = Math.min(
+    input.profile.submission.maxExtractedBytes,
+    constraints.maxExtractedBytes ?? Number.POSITIVE_INFINITY
+  );
+  const issues = [];
+  const maxFiles = Math.min(
+    input.profile.submission.maxFiles,
+    constraints.maxFiles ?? Number.POSITIVE_INFINITY
+  );
+  if (files.length > maxFiles) {
+    issues.push({
+      outcome: "disqualifies",
+      code: "max_files",
+      message: `The Submission holds ${files.length} files; at most ${maxFiles} are allowed. An included archive counts as one file.`
+    });
+  }
+  const paths = new Set(files.map((file) => file.path));
+  for (const required2 of constraints.requiredFiles ?? []) {
+    if (!paths.has(required2)) {
+      issues.push({
+        outcome: "fails_acceptance",
+        code: "required_files",
+        path: required2,
+        message: `The challenge requires "${required2}", and the Submission has no file at that path.`
+      });
+    }
+  }
+  if (constraints.allowedExtensions !== void 0) {
+    for (const file of files) {
+      if (!hasAllowedExtension(file.path, constraints.allowedExtensions)) {
+        issues.push({
+          outcome: "fails_acceptance",
+          code: "allowed_extensions",
+          path: file.path,
+          message: `"${file.path}" has an extension outside the challenge's allowed_extensions (${constraints.allowedExtensions.join(", ")}).`
+        });
+      }
+    }
+  }
+  const extracted = files.reduce(
+    (total, file) => total + file.bytes.byteLength,
+    0
   );
-  if (content_record.bounty_id !== input.bountyId.toString()) {
+  if (extracted > budget) {
+    issues.push({
+      outcome: "disqualifies",
+      code: "max_extracted_bytes",
+      message: `The Submission's files total more than ${budget} bytes.`
+    });
+  }
+  return {
+    file_count: files.length,
+    extracted_bytes: extracted,
+    extracted_budget_bytes: budget,
+    issues
+  };
+}
+
+// src/verified-challenge.ts
+async function readVerifiedChallenge(input) {
+  const [{ challenge }, [parameters]] = await Promise.all([
+    requestBountySubmissionDetail({
+      apiBaseUrl: input.apiBaseUrl,
+      bountyId: input.bountyId
+    }),
+    input.publicClient.readContract({
+      address: input.hubAddress,
+      abi: ELGORA_HUB_BOUNTY_READ_ABI,
+      functionName: "getBounty",
+      args: [BigInt(input.bountyId)],
+      ...input.blockNumber !== void 0 && {
+        blockNumber: input.blockNumber
+      }
+    })
+  ]);
+  const profile = verifyChallenge({
+    bountyId: input.bountyId,
+    challenge,
+    specCommitment: parameters.specCommitment.toLowerCase()
+  });
+  return { challenge, profile };
+}
+function verifyChallenge(input) {
+  if (input.challenge === null) {
     throw new Error(
-      `Submission ${input.submissionCommitment} belongs to bounty_id ${content_record.bounty_id}, not ${input.bountyId}`
+      `Elgora API served no verified challenge for bounty ${input.bountyId}, so the Submission format it declares cannot be determined. Try again later.`
     );
   }
-  const envelope = parsePrivateArtifactEnvelope(
-    JSON.parse(content_record.canonical_json)
-  );
-  const envelopeCommitment = derivePrivateArtifactEnvelopeCommitment(envelope);
-  if (envelopeCommitment !== input.submissionCommitment) {
+  if (deriveBountyChallengeContentCommitment(input.challenge).toLowerCase() !== input.specCommitment.toLowerCase()) {
     throw new Error(
-      `Elgora API returned an envelope whose commitment ${envelopeCommitment} does not match the requested submission_commitment ${input.submissionCommitment}`
+      `Elgora API returned a challenge that does not match bounty ${input.bountyId}'s spec commitment in ElgoraHub`
     );
   }
-  if (envelope.context.chain_id !== input.config.chainId || envelope.context.hub_address.toLowerCase() !== input.config.hubAddress.toLowerCase() || envelope.context.bounty_id !== input.bountyId.toString() || envelope.context.actor_address.toLowerCase() !== input.solver.toLowerCase()) {
+  const { profile } = checkChallengeConformance(input.challenge);
+  if (profile === null) {
     throw new Error(
-      `Submission ${input.submissionCommitment} does not belong to the requested ElgoraHub bounty and Solver`
+      `Bounty ${input.bountyId} declares a protocol profile this CLI does not know. Upgrade @elgora/cli and submit again.`
     );
   }
-  const ciphertext = await getBytes(ciphertext_download_url);
-  const opened = await openPrivateArtifactEnvelopeForDelivery({
-    envelope,
-    ciphertext,
-    guardian_private_keys: input.guardianPrivateKeys,
-    timelock_decrypt: createPrivateArtifactTimelockDecrypt(),
-    delivery_recipient_public_key: deploymentDeliveryPublicKey,
-    context: {
-      chain_id: input.config.chainId,
-      hub_address: input.config.hubAddress,
-      bounty_id: input.bountyId.toString(),
-      submission_commitment: input.submissionCommitment
-    }
-  });
-  const requestUrl = new URL(
-    `/api/bounties/${input.bountyId}/delivery/wrap`,
-    input.config.apiBaseUrl
-  );
-  const body = JSON.stringify({
-    solver_address: input.solver,
-    submission_commitment: input.submissionCommitment,
-    wrapped_key: opened.wrapped_key
-  });
-  const authorization = await authorizeRequest({
-    requestUrl: requestUrl.toString(),
-    method: "POST",
-    contentType: "application/json",
-    body,
-    chainId: input.config.chainId,
-    hubAddress: input.config.hubAddress,
-    address: input.owner.address,
-    sign: input.owner.signTypedData
-  });
-  const responseBody = await postText(
-    requestUrl,
-    body,
-    "application/json",
-    authorization
-  );
-  return deliveryWrapResponseSchema.parse(responseBody);
+  return profile;
 }
 
 // src/guardian-open.ts
-import { mkdir, writeFile as writeFile2 } from "fs/promises";
-import path2 from "path";
 var OPTIONS3 = {
   ...API_OPTIONS,
   ...ACCOUNT_OPTIONS
@@ -6255,7 +6846,7 @@ async function main3(env = process.env, argv = process.argv.slice(2)) {
       `Submission ${args.submissionCommitment} belongs to bounty_id ${content_record.bounty_id}, not ${args.bountyId}`
     );
   }
-  const envelope = await verifyPrivateArtifactEnvelope(
+  const envelope = await verifySubmissionEnvelope(
     JSON.parse(content_record.canonical_json)
   );
   if (envelope.context.chain_id !== config.chainId || envelope.context.hub_address !== config.hubAddress || envelope.context.bounty_id !== args.bountyId || envelope.context.actor_address !== args.solver) {
@@ -6263,7 +6854,8 @@ async function main3(env = process.env, argv = process.argv.slice(2)) {
       `Submission envelope context does not match chain ${config.chainId}, ElgoraHub ${config.hubAddress}, bounty_id ${args.bountyId}, and Solver ${args.solver}`
     );
   }
-  const envelopeCommitment = derivePrivateArtifactEnvelopeCommitment(envelope);
+  requireCurrentFormat(envelope.alg, args.bountyId, "guardian:open");
+  const envelopeCommitment = deriveSubmissionEnvelopeCommitment(envelope);
   if (envelopeCommitment !== args.submissionCommitment) {
     throw new Error(
       `Elgora API returned an envelope whose commitment ${envelopeCommitment} does not match the requested submission_commitment ${args.submissionCommitment}`
@@ -6284,29 +6876,35 @@ async function main3(env = process.env, argv = process.argv.slice(2)) {
       `ElgoraHub does not record Solver ${args.solver} with submission_commitment ${args.submissionCommitment} for bounty_id ${args.bountyId}`
     );
   }
+  const { challenge, profile } = await readVerifiedChallenge({
+    publicClient,
+    apiBaseUrl: config.apiBaseUrl,
+    hubAddress: config.hubAddress,
+    bountyId: args.bountyId,
+    blockNumber: finalizedBlock.number
+  });
   const ciphertext = await getBytes(ciphertext_download_url);
-  const opened = await openPrivateArtifactEnvelope({
+  const opened = await openSubmissionEnvelope({
     envelope,
     ciphertext,
     guardian_private_keys: guardianPrivateKeys,
-    timelock_decrypt: createPrivateArtifactTimelockDecrypt()
+    timelock_decrypt: createSubmissionTimelockDecrypt()
+  });
+  const { files, content_sha256 } = readOpenedSubmission(opened);
+  await writeOpenedArtifacts(args.outputDir, files);
+  const check = checkOpenedSubmission({
+    files,
+    profile,
+    challenge
   });
-  await mkdir(args.outputDir, { recursive: true });
-  for (const artifact of opened.artifacts) {
-    const filePath = path2.join(args.outputDir, artifact.name);
-    await writeFile2(filePath, artifact.bytes);
-  }
   console.log(
     JSON.stringify({
       event: "guardian_open.completed",
       bounty_id: args.bountyId,
       solver: args.solver,
       submission_commitment: args.submissionCommitment,
-      artifact_count: opened.artifacts.length,
-      // The budget the Guardian has to vet these artifacts against before
-      // extracting any archive among them. Reported here so it comes from the
-      // running client rather than a possibly older copy of the skill.
-      max_extracted_bytes: MAX_SOLVER_SUBMISSION_EXTRACTED_BYTES
+      content_sha256,
+      ...check
     })
   );
 }
@@ -6338,7 +6936,7 @@ function readGuardianOpenArgs(argv) {
     bountyId,
     solver: normalizedSolver,
     submissionCommitment: normalizedCommitment,
-    outputDir: outputDirOverride ?? path2.join(DEFAULT_OUTPUT_ROOT, bountyId, normalizedCommitment)
+    outputDir: outputDirOverride ?? path3.join(DEFAULT_OUTPUT_ROOT, bountyId, normalizedCommitment)
   };
 }
 function readGuardianPrivateKeys(env) {
@@ -7367,11 +7965,11 @@ var OPTIONS6 = { ...HUB_OPTIONS, ...SIGNER_OPTIONS };
 var USAGE6 = "elgora-cli guardian:prove-roster-key <challenge_json_path|->";
 async function main6(env = process.env, argv = process.argv.slice(2)) {
   const parsed = parseArgs(argv, OPTIONS6);
-  const [path6] = parsed.positionals;
-  if (!path6 || parsed.positionals.length !== 1) {
+  const [path7] = parsed.positionals;
+  if (!path7 || parsed.positionals.length !== 1) {
     throw usageError(USAGE6);
   }
-  const challenge = parseChallenge(await readInput(path6));
+  const challenge = parseChallenge(await readInput(path7));
   const envWithDefaults = deploymentEnv(env, parsed);
   const { chainId, hubAddress } = loadPublicDeploymentConfig(envWithDefaults);
   if (challenge.context.chain_id !== chainId || challenge.context.hub_address.toLowerCase() !== hubAddress.toLowerCase()) {
@@ -7697,7 +8295,7 @@ async function assertCheckedSubmission(input) {
   });
   let envelope;
   try {
-    envelope = await verifyPrivateArtifactEnvelope(
+    envelope = await verifySubmissionEnvelope(
       JSON.parse(response.content_record.canonical_json)
     );
   } catch (error) {
@@ -7705,7 +8303,7 @@ async function assertCheckedSubmission(input) {
       cause: error
     });
   }
-  const matchesCheckedPair = response.content_record.bounty_id === bountyId && derivePrivateArtifactEnvelopeCommitment(envelope) === input.submissionCommitment && envelope.context.chain_id === input.chainId && envelope.context.hub_address === input.hubAddress.toLowerCase() && envelope.context.bounty_id === bountyId && envelope.context.actor_address === input.winner.toLowerCase();
+  const matchesCheckedPair = response.content_record.bounty_id === bountyId && deriveSubmissionEnvelopeCommitment(envelope) === input.submissionCommitment && envelope.context.chain_id === input.chainId && envelope.context.hub_address === input.hubAddress.toLowerCase() && envelope.context.bounty_id === bountyId && envelope.context.actor_address === input.winner.toLowerCase();
   if (!matchesCheckedPair) {
     throw new Error(
       "Submission envelope does not match the checked Solver and Submission"
@@ -7788,7 +8386,7 @@ function resolveChainId(selector) {
 }
 
 // src/version.ts
-var CLI_VERSION = true ? "11.0.0" : "0.0.0-dev";
+var CLI_VERSION = true ? "12.0.0" : "0.0.0-dev";
 var CLI_NODE_ENGINES = true ? "24.x || 26.x" : "24.x || 26.x";
 
 // src/node-engines.ts
@@ -7852,8 +8450,8 @@ function compareVersions(left, right) {
 }
 
 // src/poster-open-winning-submission.ts
-import { mkdir as mkdir2, writeFile as writeFile3 } from "fs/promises";
-import path3 from "path";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import path4 from "path";
 var OPTIONS8 = { ...API_OPTIONS, ...ACCOUNT_OPTIONS };
 var USAGE8 = "elgora-cli poster:open-winning-submission <bounty_id> [output_dir]";
 var DEFAULT_OUTPUT_ROOT2 = "./winning-submission";
@@ -7917,47 +8515,34 @@ async function main8(env = process.env, argv = process.argv.slice(2)) {
         contentAuthorization
       )
     );
-    if (content_record.bounty_id !== args.bountyId) {
-      throw new Error(
-        `Submission ${retrieved.submission_commitment} belongs to bounty_id ${content_record.bounty_id}, not ${args.bountyId}`
-      );
-    }
-    const envelope = await verifyPrivateArtifactEnvelope(
+    const envelope = parseSubmissionEnvelope(
       JSON.parse(content_record.canonical_json)
     );
-    if (envelope.context.chain_id !== config.chainId || envelope.context.hub_address !== config.hubAddress.toLowerCase() || envelope.context.bounty_id !== args.bountyId) {
-      throw new Error(
-        `Winning Submission envelope does not belong to chain ${config.chainId}, ElgoraHub ${config.hubAddress}, and bounty_id ${args.bountyId}`
-      );
-    }
-    const envelopeCommitment = derivePrivateArtifactEnvelopeCommitment(envelope);
-    if (envelopeCommitment !== retrieved.submission_commitment) {
-      throw new Error(
-        `Winning Submission envelope commitment ${envelopeCommitment} does not match the retrieved submission_commitment ${retrieved.submission_commitment}`
-      );
-    }
-    const ciphertext = await getBytes(ciphertext_download_url);
-    const opened = await openPrivateArtifactEnvelopeWithKnownAesKey({
+    requireCurrentFormat(
+      envelope.alg,
+      args.bountyId,
+      "poster:open-winning-submission"
+    );
+    const opened = await openSubmissionEnvelopeWithKnownAesKey({
       envelope,
-      ciphertext,
+      ciphertext: await getBytes(ciphertext_download_url),
       rawAesKey
     });
-    const outputDir = args.outputDir ?? path3.join(
-      DEFAULT_OUTPUT_ROOT2,
-      args.bountyId,
-      retrieved.submission_commitment
+    if (opened.alg !== SUBMISSION_ENCRYPTION_TYPE_V1) return;
+    const outputDir = args.outputDir ?? DEFAULT_OUTPUT_ROOT2;
+    const file = path4.join(
+      outputDir,
+      `elgora-${args.bountyId}-${retrieved.submission_commitment.slice(2, 12)}.tar.gz`
     );
     await mkdir2(outputDir, { recursive: true });
-    for (const artifact of opened.artifacts) {
-      await writeFile3(path3.join(outputDir, artifact.name), artifact.bytes);
-    }
+    await writeFile2(file, opened.archive);
     console.log(
       JSON.stringify({
         event: "poster_open_winning_submission.completed",
         bounty_id: args.bountyId,
         submission_commitment: retrieved.submission_commitment,
-        artifact_count: opened.artifacts.length,
-        output_dir: outputDir
+        file,
+        byte_length: opened.archive.byteLength
       })
     );
   } finally {
@@ -8006,10 +8591,10 @@ var OPTIONS9 = {
 var USAGE9 = "elgora-cli poster:publish-fund [--prepare-only] <bounty_challenge_md_path|->";
 async function main9(env = process.env, argv = process.argv.slice(2)) {
   const args = parseArgs(argv, OPTIONS9);
-  const [path6] = args.positionals;
-  if (args.positionals.length !== 1 || !path6) throw usageError(USAGE9);
+  const [path7] = args.positionals;
+  if (args.positionals.length !== 1 || !path7) throw usageError(USAGE9);
   const config = loadApiDeployment(env, args);
-  const bountyChallengeMarkdown = await readInput(path6);
+  const bountyChallengeMarkdown = await readInput(path7);
   const localSpecCommitment = deriveBountyChallengeContentCommitment(
     bountyChallengeMarkdown
   );
@@ -8387,7 +8972,7 @@ function parseRosterAddGuardianArgs(argv) {
   if (!name) throw usageError(USAGE11);
   if (!KEY_ID_RE.test(name)) {
     throw new Error(
-      // A Solver's CLI seals private artifacts against this exact string as
+      // A Solver's CLI seals Submissions against this exact string as
       // the Guardian's key_id, so it must be non-empty, start with an
       // alphanumeric, and stay within printable ASCII (no control/formatting
       // characters, no leading whitespace).
@@ -8566,72 +9151,23 @@ function get(value, key) {
 }
 var command13 = { main: main13, OPTIONS: OPTIONS13, USAGE: USAGE13 };
 
-// src/spec-commitment.ts
-var OPTIONS14 = {};
-var USAGE14 = "elgora-cli spec-commitment <bounty_challenge_md_path|->";
-async function main14(_env = process.env, argv = process.argv.slice(2)) {
-  const markdown = await readBountyChallengeMarkdown2(
-    parseArgs(argv, OPTIONS14).positionals
-  );
-  const specCommitment = deriveBountyChallengeContentCommitment(markdown);
-  console.log(
-    JSON.stringify({
-      event: "spec_commitment.derived",
-      byte_length: Buffer.byteLength(markdown, "utf8"),
-      spec_commitment: specCommitment
-    })
-  );
-}
-function readBountyChallengeMarkdown2(argv) {
-  const path6 = argv[0];
-  if (!path6 || argv.length !== 1) throw usageError(USAGE14);
-  return readInput(path6);
-}
-var command14 = { main: main14, OPTIONS: OPTIONS14, USAGE: USAGE14 };
-
 // src/submit.ts
-import { readdir, readFile as readFile5, stat } from "fs/promises";
-import path4 from "path";
-var OPTIONS15 = {
+import { lstat as lstat2, readdir as readdir2, readFile as readFile5 } from "fs/promises";
+import path5 from "path";
+var OPTIONS14 = {
   ...API_OPTIONS,
   ...ACCOUNT_OPTIONS,
   ...PREPARE_ONLY_OPTIONS,
   ...REVEAL_DELAY_OPTIONS
 };
-var USAGE15 = "elgora-cli solver:submit [--prepare-only] <bounty_id> <artifact_dir>";
+var USAGE14 = "elgora-cli solver:submit [--prepare-only] <bounty_id> <folder_or_file>";
 var PREPARE_SUBMISSION_ATTEMPTS = 5;
 var PREPARE_SUBMISSION_BASE_DELAY_MS = 1e3;
 var PREPARE_SUBMISSION_MAX_DELAY_MS = 4e3;
 var BOUNTY_PROJECTION_UNAVAILABLE_CODE = "bounty_projection_unavailable";
 var UNAUTHORIZED_CODE = "unauthorized";
-var MEDIA_TYPE_BY_EXTENSION = {
-  txt: "text/plain",
-  md: "text/markdown",
-  json: "application/json",
-  csv: "text/csv",
-  pdf: "application/pdf",
-  zip: "application/zip",
-  gz: "application/gzip",
-  tar: "application/x-tar",
-  png: "image/png",
-  jpg: "image/jpeg",
-  jpeg: "image/jpeg",
-  gif: "image/gif",
-  svg: "image/svg+xml",
-  py: "text/x-python",
-  js: "text/javascript",
-  ts: "text/plain",
-  sol: "text/plain",
-  yaml: "application/yaml",
-  yml: "application/yaml",
-  toml: "application/toml",
-  log: "text/plain",
-  patch: "text/x-diff",
-  diff: "text/x-diff"
-};
-var DEFAULT_MEDIA_TYPE = "application/octet-stream";
-async function main15(env = process.env, argv = process.argv.slice(2)) {
-  const parsed = parseArgs(argv, OPTIONS15);
+async function main14(env = process.env, argv = process.argv.slice(2)) {
+  const parsed = parseArgs(argv, OPTIONS14);
   const config = {
     ...loadApiDeployment(env, parsed),
     timelockRevealDelaySeconds: readRevealDelaySeconds(parsed)
@@ -8651,10 +9187,11 @@ async function main15(env = process.env, argv = process.argv.slice(2)) {
     address: solver,
     sign: approvals.signTypedData
   });
-  const rosterResponse = await requestBountyGuardianRoster({
+  const detail = await requestBountySubmissionDetail({
     apiBaseUrl: config.apiBaseUrl,
     bountyId: bountyIdText
   });
+  const rosterResponse = detail.bounty;
   const readBountySubmissionFacts = async () => {
     const [parameters, state] = await publicClient.readContract({
       address: config.hubAddress,
@@ -8664,6 +9201,7 @@ async function main15(env = process.env, argv = process.argv.slice(2)) {
     });
     return parseBountySubmissionFacts({
       bountyId: bountyIdText,
+      specCommitment: parameters.specCommitment,
       guardianRosterHash: parameters.guardianRosterHash,
       submissionDeadline: parameters.submissionDeadline,
       status: state.status
@@ -8675,12 +9213,29 @@ async function main15(env = process.env, argv = process.argv.slice(2)) {
     response: rosterResponse,
     hubGuardianRosterHash: bountyFacts.guardianRosterHash
   });
-  const artifacts = await readArtifactDirectory(args.artifactDir);
+  const profile = verifyChallenge({
+    bountyId: bountyIdText,
+    challenge: detail.challenge,
+    specCommitment: bountyFacts.specCommitment
+  });
+  requireCurrentFormat(profile.encryption.type, bountyIdText, "solver:submit");
+  const { plaintext, content_sha256, macos_metadata_skipped } = await readSubmissionPlaintext(args.inputPath, profile);
+  const { issues } = checkSubmissionArchive({
+    archive: plaintext.archive,
+    profile,
+    challenge: detail.challenge
+  });
+  if (issues.length > 0) {
+    throw new Error(
+      `The Submission does not meet bounty ${bountyIdText}'s rules, so nothing was submitted: ${issues.map((issue) => issue.message).join(" ")} Run solver:check for the full report.`
+    );
+  }
+  const contentDigest = { content_sha256 };
   const { envelope, ciphertext } = await buildSolverSubmissionEnvelope({
     config,
     bountyId: args.bountyId,
     solver,
-    artifacts,
+    plaintext,
     guardianRoster,
     submissionDeadline: bountyFacts.submissionDeadline
   });
@@ -8708,7 +9263,9 @@ async function main15(env = process.env, argv = process.argv.slice(2)) {
       event: "submit.ciphertext_uploaded",
       bounty_id: bountyIdText,
       solver,
-      byte_length: ciphertext.byteLength
+      byte_length: ciphertext.byteLength,
+      ...contentDigest,
+      ...macos_metadata_skipped.length > 0 && { macos_metadata_skipped }
     })
   );
   const prepared = await requestPrepareSubmission({
@@ -8718,7 +9275,7 @@ async function main15(env = process.env, argv = process.argv.slice(2)) {
     envelope,
     authorizeRequest: authorizeSubmitRequest
   });
-  const localCommitment = derivePrivateArtifactEnvelopeCommitment(envelope);
+  const localCommitment = deriveSubmissionEnvelopeCommitment(envelope);
   if (prepared.content_record.submission_commitment !== localCommitment) {
     throw new Error(
       "Elgora API returned a submission_commitment that does not match the locally sealed envelope"
@@ -8792,7 +9349,8 @@ async function main15(env = process.env, argv = process.argv.slice(2)) {
       bounty_id: bountyIdText,
       solver,
       submission_commitment: localCommitment,
-      guardian_roster_hash: signingFacts.guardianRosterHash
+      guardian_roster_hash: signingFacts.guardianRosterHash,
+      ...contentDigest
     })
   );
 }
@@ -8824,10 +9382,28 @@ function parseBountySubmissionFacts(input) {
   }
   return {
     status: decodeBountyStatus(input.status),
+    specCommitment: input.specCommitment.toLowerCase(),
     submissionDeadline: Number(input.submissionDeadline),
     guardianRosterHash: input.guardianRosterHash.toLowerCase()
   };
 }
+async function readSubmissionPlaintext(artifactPath, profile) {
+  const { files, macos_metadata_skipped } = await readSubmissionFiles(
+    artifactPath,
+    profile
+  );
+  const { archive, content_sha256 } = buildSubmissionArchive(files);
+  if (archive.byteLength + AES_GCM_TAG_BYTES > MAX_SOLVER_SUBMISSION_CIPHERTEXT_BYTES) {
+    throw new Error(
+      `This Submission packs to ${archive.byteLength + AES_GCM_TAG_BYTES} bytes encrypted and exceeds Elgora's ${formatMebibytes(MAX_SOLVER_SUBMISSION_CIPHERTEXT_BYTES)} encrypted submission limit. Reduce the files before submitting.`
+    );
+  }
+  return {
+    plaintext: { encryption_type: SUBMISSION_ENCRYPTION_TYPE_V1, archive },
+    content_sha256,
+    macos_metadata_skipped
+  };
+}
 function verifyPinnedGuardianRoster(input) {
   const roster = input.response.guardian_roster.map((guardian) => ({
     name: guardian.name,
@@ -8895,7 +9471,7 @@ async function buildSolverSubmissionEnvelope(input) {
   const guardianRecipients = input.guardianRoster.map(
     (guardian) => ({
       key_id: guardian.name,
-      suite: PRIVATE_ARTIFACT_HPKE_SUITE,
+      suite: SUBMISSION_HPKE_SUITE,
       public_key: guardian.encryptionPublicKey
     })
   );
@@ -8907,69 +9483,132 @@ async function buildSolverSubmissionEnvelope(input) {
       bounty_id: bountyId,
       actor_address: solver
     },
-    artifacts: input.artifacts,
+    ...input.plaintext,
     guardian_recipients: guardianRecipients,
-    reveal_policy: buildPrivateArtifactRevealPolicyForDeadline({
+    reveal_policy: buildSubmissionRevealPolicyForDeadline({
       submissionDeadline: input.submissionDeadline,
       revealDelaySeconds: input.config.timelockRevealDelaySeconds
     }),
-    timelock_encrypt: input.timelockEncrypt ?? createPrivateArtifactTimelockEncrypt()
+    timelock_encrypt: input.timelockEncrypt ?? createSubmissionTimelockEncrypt()
   };
   if (input.randomBytes) {
     envelopeInput.random_bytes = input.randomBytes;
   }
-  return sealPrivateArtifactEnvelope(envelopeInput);
+  return sealSubmissionEnvelope(envelopeInput);
 }
 function readSubmitArgs(argv) {
-  const [bountyIdText, artifactDir] = argv;
-  if (argv.length !== 2 || !bountyIdText || !isNumeric(bountyIdText) || !artifactDir?.trim()) {
-    throw usageError(USAGE15);
+  const [bountyIdText, inputPath] = argv;
+  if (argv.length !== 2 || !bountyIdText || !isNumeric(bountyIdText) || !inputPath?.trim()) {
+    throw usageError(USAGE14);
+  }
+  return { bountyId: BigInt(bountyIdText), inputPath };
+}
+async function readSubmissionFiles(inputPath, profile) {
+  const { maxFiles, maxExtractedBytes } = profile.submission;
+  const root = await lstat2(inputPath);
+  const found = [];
+  const skipped = [];
+  if (root.isFile()) {
+    const issue = describeSolverSubmissionPathIssue(path5.basename(inputPath));
+    if (issue !== null) throw new Error(issue);
+    found.push({
+      path: path5.basename(inputPath),
+      absolute: inputPath,
+      size: root.size
+    });
+  } else if (root.isDirectory()) {
+    await walkSubmissionDirectory(inputPath, "", found, skipped, maxFiles);
+    if (found.length === 0) {
+      throw new Error(`No files found in folder: ${inputPath}`);
+    }
+  } else {
+    throw new Error(
+      `${inputPath} is ${describeEntryType(root)}; point solver:submit at a folder or a regular file.`
+    );
   }
-  return { bountyId: BigInt(bountyIdText), artifactDir };
-}
-async function readArtifactDirectory(artifactDir) {
-  const entries = await readdir(artifactDir, { withFileTypes: true });
-  const unsupportedEntry = entries.find((entry) => !entry.isFile());
-  if (unsupportedEntry) {
+  const conflict = findSolverSubmissionPathConflict(
+    found.map((file) => file.path)
+  );
+  if (conflict !== null) {
+    throw new Error(describeSolverSubmissionPathConflict(conflict));
+  }
+  const declaredBytes = found.reduce((total, file) => total + file.size, 0);
+  if (declaredBytes > maxExtractedBytes) {
     throw new Error(
-      `Artifact directory must be flat and contain only regular files; found unsupported entry "${unsupportedEntry.name}". Remove it and submit only regular files directly inside ${artifactDir}.`
+      `The Submission holds ${declaredBytes} bytes of files and exceeds Elgora's ${maxExtractedBytes}-byte limit on what one Submission extracts to.`
     );
   }
-  if (entries.length === 0) {
-    throw new Error(`No files found in artifact directory: ${artifactDir}`);
+  const files = [];
+  for (const file of found) {
+    files.push({
+      path: file.path,
+      bytes: new Uint8Array(await readFile5(file.absolute))
+    });
   }
-  if (entries.length > MAX_SOLVER_SUBMISSION_FILES) {
+  return { files, macos_metadata_skipped: skipped };
+}
+function isMacosMetadataFile(entry) {
+  return entry.isFile() && (entry.name === ".DS_Store" || entry.name.startsWith("._"));
+}
+async function walkSubmissionDirectory(directory, relative, found, skipped, maxFiles) {
+  const entries = await readdir2(directory, { withFileTypes: true });
+  if (entries.length === 0 && relative !== "") {
     throw new Error(
-      `Artifact directory holds ${entries.length} files and exceeds Elgora's maximum of ${MAX_SOLVER_SUBMISSION_FILES} files per Submission. Combine them into fewer files, if the challenge allows it, before submitting.`
+      `Folder "${relative}" is empty. A Submission cannot carry an empty folder; remove it or add the files it should hold.`
     );
   }
-  let plaintextByteLength = 0;
+  const foundBefore = found.length;
   for (const entry of entries) {
-    plaintextByteLength += (await stat(path4.join(artifactDir, entry.name))).size;
-    if (plaintextByteLength > MAX_SOLVER_SUBMISSION_ARTIFACT_BYTES) {
+    const entryPath = relative === "" ? entry.name : `${relative}/${entry.name}`;
+    const absolute = path5.join(directory, entry.name);
+    if (isMacosMetadataFile(entry)) {
+      skipped.push(entryPath);
+      continue;
+    }
+    const issue = describeSolverSubmissionPathIssue(entryPath);
+    if (issue !== null) throw new Error(issue);
+    if (entry.isDirectory()) {
+      await walkSubmissionDirectory(
+        absolute,
+        entryPath,
+        found,
+        skipped,
+        maxFiles
+      );
+      continue;
+    }
+    if (!entry.isFile()) {
+      throw new Error(
+        `"${entryPath}" is ${describeEntryType(entry)}. A Submission carries regular files only; replace it with the file it stands for or remove it.`
+      );
+    }
+    found.push({
+      path: entryPath,
+      absolute,
+      size: (await lstat2(absolute)).size
+    });
+    if (found.length > maxFiles) {
       throw new Error(
-        `Artifact directory exceeds Elgora's ${formatMebibytes(MAX_SOLVER_SUBMISSION_ARTIFACT_BYTES)} of files per Submission, which is what fits the ${formatMebibytes(MAX_SOLVER_SUBMISSION_CIPHERTEXT_BYTES)} encrypted submission limit once packaged. Reduce the final artifact package before submitting.`
+        `The Submission holds more than ${maxFiles} files, Elgora's maximum per Submission.`
       );
     }
   }
-  return Promise.all(
-    entries.map(async (entry) => {
-      const bytes = await readFile5(path4.join(artifactDir, entry.name));
-      return {
-        name: entry.name,
-        media_type: guessMediaType(entry.name),
-        bytes: new Uint8Array(bytes)
-      };
-    })
-  );
+  if (found.length === foundBefore && relative !== "") {
+    throw new Error(
+      `Folder "${relative}" holds only macOS metadata (.DS_Store or ._ files), which is left out, so it would be empty. A Submission cannot carry an empty folder; remove it or add the files it should hold.`
+    );
+  }
+}
+function describeEntryType(entry) {
+  if (entry.isSymbolicLink()) return "a symbolic link";
+  if (entry.isFIFO()) return "a FIFO";
+  if (entry.isSocket()) return "a socket";
+  if (entry.isBlockDevice() || entry.isCharacterDevice()) return "a device";
+  return "not a regular file";
 }
 function formatMebibytes(byteLength) {
   return `${byteLength / 1024 / 1024} MiB`;
 }
-function guessMediaType(fileName) {
-  const extension = path4.extname(fileName).slice(1).toLowerCase();
-  return MEDIA_TYPE_BY_EXTENSION[extension] ?? DEFAULT_MEDIA_TYPE;
-}
 async function requestArtifactUploadUrl(input) {
   const requestUrl = new URL(
     `/api/bounties/${input.bountyId}/submissions/${input.solver}/artifact-upload-url`,
@@ -8993,7 +9632,7 @@ async function requestPrepareSubmission(input) {
     `/api/bounties/${input.bountyId}/submissions/${input.solver}/prepare`,
     input.apiBaseUrl
   );
-  const bodyText = serializePrivateArtifactEnvelope(input.envelope);
+  const bodyText = serializeSubmissionEnvelope(input.envelope);
   for (let attempt = 1; ; attempt += 1) {
     try {
       const authorization = await input.authorizeRequest(requestUrl, bodyText);
@@ -9027,13 +9666,107 @@ async function requestPrepareSubmission(input) {
     }
   }
 }
+var command14 = { main: main14, OPTIONS: OPTIONS14, USAGE: USAGE14 };
+
+// src/solver-check.ts
+var OPTIONS15 = { ...API_OPTIONS, ...RPC_OPTIONS, ...HUB_OPTIONS };
+var USAGE15 = "elgora-cli solver:check <bounty_id> <folder_or_file>";
+async function main15(env = process.env, argv = process.argv.slice(2)) {
+  const parsed = parseArgs(argv, OPTIONS15);
+  const [bountyIdText, inputPath] = parsed.positionals;
+  if (parsed.positionals.length !== 2 || !bountyIdText || !isNumeric(bountyIdText) || !inputPath?.trim()) {
+    throw usageError(USAGE15);
+  }
+  const config = loadApiDeployment(env, parsed);
+  const publicClient = createChainPublicClient(config.chainId, config.rpcUrl);
+  await assertHubDeployment(publicClient, config.chainId, config.hubAddress);
+  const { challenge, profile } = await readVerifiedChallenge({
+    publicClient,
+    apiBaseUrl: config.apiBaseUrl,
+    hubAddress: config.hubAddress,
+    bountyId: bountyIdText
+  });
+  requireCurrentFormat(profile.encryption.type, bountyIdText, "solver:submit");
+  const report = await checkSubmission({ inputPath, profile, challenge });
+  const blocking = report.issues.length > 0;
+  console.log(
+    JSON.stringify({
+      event: blocking ? "solver_check.issues" : "solver_check.passed",
+      bounty_id: bountyIdText,
+      // Named so a passing result is never read as "this Submission wins".
+      checked: "format_and_constraints",
+      ...report
+    })
+  );
+  if (blocking) process.exitCode = 1;
+}
+async function checkSubmission(input) {
+  const base4 = {
+    profile: input.profile.profile,
+    max_encrypted_bytes: MAX_SOLVER_SUBMISSION_CIPHERTEXT_BYTES
+  };
+  let archive;
+  let skipped;
+  try {
+    const { plaintext, macos_metadata_skipped } = await readSubmissionPlaintext(
+      input.inputPath,
+      input.profile
+    );
+    archive = plaintext.archive;
+    skipped = macos_metadata_skipped;
+  } catch (error) {
+    return {
+      ...base4,
+      issues: [
+        {
+          outcome: "refused",
+          code: "submission_input",
+          message: error instanceof Error ? error.message : String(error)
+        }
+      ]
+    };
+  }
+  return {
+    ...base4,
+    encrypted_bytes: archive.byteLength + AES_GCM_TAG_BYTES,
+    ...skipped.length > 0 && { macos_metadata_skipped: skipped },
+    ...checkSubmissionArchive({
+      archive,
+      profile: input.profile,
+      challenge: input.challenge
+    })
+  };
+}
 var command15 = { main: main15, OPTIONS: OPTIONS15, USAGE: USAGE15 };
 
+// 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)) {
+  const markdown = await readBountyChallengeMarkdown2(
+    parseArgs(argv, OPTIONS16).positionals
+  );
+  const specCommitment = deriveBountyChallengeContentCommitment(markdown);
+  console.log(
+    JSON.stringify({
+      event: "spec_commitment.derived",
+      byte_length: Buffer.byteLength(markdown, "utf8"),
+      spec_commitment: specCommitment
+    })
+  );
+}
+function readBountyChallengeMarkdown2(argv) {
+  const path7 = argv[0];
+  if (!path7 || argv.length !== 1) throw usageError(USAGE16);
+  return readInput(path7);
+}
+var command16 = { main: main16, OPTIONS: OPTIONS16, USAGE: USAGE16 };
+
 // src/verification-record.ts
-var OPTIONS16 = { ...API_OPTIONS, ...HUB_OPTIONS };
-var USAGE16 = "elgora-cli verification-record <bounty_id>";
-async function main16(env = process.env, argv = process.argv.slice(2)) {
-  const parsed = parseArgs(argv, OPTIONS16);
+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);
   const args = readVerificationRecordArgs(parsed.positionals);
   const config = loadClientDeploymentConfig(deploymentEnv(env, parsed));
   const record = await requestVerificationRecord({
@@ -9085,15 +9818,15 @@ function readVerificationRecordArgs(argv) {
   const [bountyIdText] = argv;
   const bountyId = bountyIdText?.trim();
   if (argv.length !== 1 || !bountyId || !isBountyId(bountyId)) {
-    throw usageError(USAGE16);
+    throw usageError(USAGE17);
   }
   return { bountyId: BigInt(bountyId) };
 }
-var command16 = { main: main16, OPTIONS: OPTIONS16, USAGE: USAGE16 };
+var command17 = { main: main17, OPTIONS: OPTIONS17, USAGE: USAGE17 };
 
 // src/cli.ts
 if (process.env.DOTENV_CONFIG_PATH) {
-  const dotenvPath = path5.resolve(process.env.DOTENV_CONFIG_PATH);
+  const dotenvPath = path6.resolve(process.env.DOTENV_CONFIG_PATH);
   const dotenvResult = loadDotenv({ path: dotenvPath, quiet: true });
   process.stderr.write(
     `Env: ${dotenvPath} (${dotenvResult.error ? `not found: ${dotenvResult.error.message}` : "loaded"})
@@ -9116,11 +9849,12 @@ var COMMANDS = {
   "roster:add-guardian": command11,
   "roster:prepare-guardian-proof": command12,
   "roster:verify-guardian-proof": command13,
-  "solver:submit": command15,
+  "solver:check": command15,
+  "solver:submit": command14,
   claim: command2,
   "check-challenge": command,
-  "spec-commitment": command14,
-  "verification-record": command16
+  "spec-commitment": command16,
+  "verification-record": command17
 };
 var OPTION_HELP = {
   "--api-base-url": "--api-base-url <url>        Elgora API (else ELGORA_API_BASE_URL)",
@@ -9146,7 +9880,7 @@ var COMMAND_HELP = {
   },
   "guardian:open": {
     title: "Verify and decrypt one Solver Submission.",
-    description: "Check the exact Solver and Submission against ElgoraHub and the\n  commitment-addressed envelope, then sign the protected content GET\n  with this Guardian's account before downloading ciphertext. Then\n  decrypt with this Guardian's retained X25519 keys and write the\n  artifacts locally. Without output_dir, files go under\n  guardian-open/<bounty_id>/<submission_commitment>/. A fetch or decrypt\n  failure never becomes a Verdict.",
+    description: "Verify, decrypt and extract one Submission into a new or empty\n  output_dir (default guardian-open/<bounty_id>/<submission_commitment>/).\n  Prints content_sha256 and the issues solver:check reports.",
     required: ["ELGORA_GUARDIAN_PRIVATE_KEYS_JSON"]
   },
   "guardian:prove-roster-key": {
@@ -9176,7 +9910,7 @@ var COMMAND_HELP = {
   },
   "poster:open-winning-submission": {
     title: "Retrieve and decrypt the finalized winning Submission.",
-    description: "Authenticate as the funding Poster, ask the existing delivery API for\n  the finalized winner's key rewrapped to a fresh local key, verify the\n  committed envelope, and decrypt the artifacts locally. Without\n  output_dir, files go under\n  winning-submission/<bounty_id>/<submission_commitment>/.",
+    description: "Save the finalized winning Submission, decrypted, as one .tar.gz in\n  output_dir (default winning-submission/).",
     required: []
   },
   "roster:add-guardian": {
@@ -9194,9 +9928,14 @@ 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: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.",
+    required: []
+  },
   "solver:submit": {
-    title: "Encrypt and submit a Solver's private artifacts.",
-    description: "Encrypt for the Guardian roster pinned to this bounty, upload the\n  ciphertext, check ElgoraHub immediately before signing, and locally\n  encode all four V2 submit values.",
+    title: "Encrypt and submit a Solver's private files.",
+    description: "Pack a folder or one file into a .tar.gz, encrypt it for the bounty's\n  Guardians, upload it and submit it on ElgoraHub. Refuses it on any issue\n  solver:check reports. Prints content_sha256, which stays on this machine.",
     required: []
   },
   claim: {
@@ -9241,8 +9980,8 @@ async function run(rawArgv) {
     printCommandHelpOrUsage(rest[0]);
     return;
   }
-  const command17 = COMMANDS[subcommand];
-  if (!command17) {
+  const command18 = COMMANDS[subcommand];
+  if (!command18) {
     process.stderr.write(`Unknown command: ${subcommand}
 `);
     printUsage();
@@ -9255,8 +9994,8 @@ async function run(rawArgv) {
   }
   let args;
   try {
-    args = parseArgs(rest, command17.OPTIONS);
-    if ("--signer" in command17.OPTIONS) readSignerOptions(args);
+    args = parseArgs(rest, command18.OPTIONS);
+    if ("--signer" in command18.OPTIONS) readSignerOptions(args);
   } catch (error) {
     process.stderr.write(
       `Error: ${error instanceof Error ? error.message : String(error)}
@@ -9273,10 +10012,10 @@ Run \`elgora-cli help ${subcommand}\` for its arguments and options.
     process.exitCode = 1;
     return;
   }
-  const networkNotice = usesDeployment(command17.OPTIONS) ? defaultNetworkNotice(env) : void 0;
+  const networkNotice = usesDeployment(command18.OPTIONS) ? defaultNetworkNotice(env) : void 0;
   if (networkNotice) process.stderr.write(`${networkNotice}
 `);
-  const needsLocalKey = "--signer" in command17.OPTIONS && (args.value("--signer") ?? "local") === "local";
+  const needsLocalKey = "--signer" in command18.OPTIONS && (args.value("--signer") ?? "local") === "local";
   const missing = missingRequiredEnv(
     [
       ...COMMAND_HELP[subcommand]?.required ?? [],
@@ -9303,7 +10042,7 @@ Run \`elgora-cli help ${subcommand}\` for its arguments and options.
     process.exitCode = 1;
     return;
   }
-  await command17.main(env, rest);
+  await command18.main(env, rest);
 }
 function usesDeployment(options) {
   return DEPLOYMENT_OPTIONS.some((option) => option in options);
@@ -9344,14 +10083,14 @@ function printUsage() {
 }
 function printCommandHelpOrUsage(name) {
   const help = name ? COMMAND_HELP[name] : void 0;
-  const command17 = name ? COMMANDS[name] : void 0;
-  if (!help || !command17) {
+  const command18 = name ? COMMANDS[name] : void 0;
+  if (!help || !command18) {
     printUsage();
     process.exitCode = name ? 1 : 0;
     return;
   }
-  const options = command17.OPTIONS;
-  const lines = [`Usage: ${command17.USAGE}`, "", help.description];
+  const options = command18.OPTIONS;
+  const lines = [`Usage: ${command18.USAGE}`, "", help.description];
   const described = Object.keys(options).filter(
     (option) => option in OPTION_HELP
   );
@@ -9440,9 +10179,9 @@ function extractIssues(error) {
   if (!Array.isArray(issues)) return [];
   return issues.map((issue) => {
     if (issue && typeof issue === "object" && "message" in issue) {
-      const path6 = "path" in issue ? issue.path : void 0;
+      const path7 = "path" in issue ? issue.path : void 0;
       return {
-        path: typeof path6 === "string" ? path6 : "",
+        path: typeof path7 === "string" ? path7 : "",
         message: String(issue.message)
       };
     }