chofex-cli 0.1.76 → 0.1.78

package/dist/index.js

@@ -340,7 +340,7 @@ var require_errors = __commonJS((exports, module) => {
     toVercelCliError: () => toVercelCliError
   });
   module.exports = __toCommonJS(errors_exports);
-  var import_promises2 = __require("node:fs/promises");
+  var import_promises3 = __require("node:fs/promises");
 
   class VercelCliError2 extends Error {
     constructor(options) {
@@ -378,7 +378,7 @@ var require_errors = __commonJS((exports, module) => {
   }
   async function assertValidCwd(cwd) {
     try {
-      if (!(await (0, import_promises2.stat)(cwd)).isDirectory()) {
+      if (!(await (0, import_promises3.stat)(cwd)).isDirectory()) {
         throw new Error("not a directory");
       }
     } catch {
@@ -2435,12 +2435,12 @@ var require_fsutils = __commonJS((exports, module) => {
     statIfExists: () => statIfExists
   });
   module.exports = __toCommonJS(fsutils_exports);
-  var import_promises2 = __require("node:fs/promises");
+  var import_promises3 = __require("node:fs/promises");
   var import_node_path = __toESM2(__require("node:path"));
   var import_errutils = require_errutils();
   async function getCanonicalPath(filePath) {
     try {
-      return await (0, import_promises2.realpath)(filePath);
+      return await (0, import_promises3.realpath)(filePath);
     } catch {
       return filePath;
     }
@@ -2463,7 +2463,7 @@ var require_fsutils = __commonJS((exports, module) => {
   }
   async function statIfExists(filePath) {
     try {
-      return { stats: await (0, import_promises2.stat)(filePath) };
+      return { stats: await (0, import_promises3.stat)(filePath) };
     } catch (error2) {
       if ((0, import_errutils.isMissingPathError)(error2)) {
         return { missing: true };
@@ -2519,7 +2519,7 @@ var require_safety = __commonJS((exports, module) => {
     getUnsafeStatsReason: () => getUnsafeStatsReason
   });
   module.exports = __toCommonJS(safety_exports);
-  var import_promises2 = __require("node:fs/promises");
+  var import_promises3 = __require("node:fs/promises");
   var import_node_path = __toESM2(__require("node:path"));
   var import_errutils = require_errutils();
   var import_fsutils = require_fsutils();
@@ -2602,14 +2602,14 @@ var require_safety = __commonJS((exports, module) => {
     return reason ? `${filePath} is ${reason}` : null;
   }
   async function getUnsafeDirectoryReason(directory3) {
-    const stats = await (0, import_promises2.stat)(directory3);
+    const stats = await (0, import_promises3.stat)(directory3);
     if (!stats.isDirectory()) {
       return "not a directory";
     }
     return getUnsafeStatsReason(stats);
   }
   async function getUnsafeFileReason(filePath) {
-    const stats = await (0, import_promises2.stat)(filePath);
+    const stats = await (0, import_promises3.stat)(filePath);
     if (!stats.isFile()) {
       return "not a file";
     }
@@ -2666,7 +2666,7 @@ var require_lookup = __commonJS((exports, module) => {
     toVercelCliInvocation: () => toVercelCliInvocation
   });
   module.exports = __toCommonJS(lookup_exports);
-  var import_promises2 = __require("node:fs/promises");
+  var import_promises3 = __require("node:fs/promises");
   var import_node_path = __toESM2(__require("node:path"));
   var import_envpath = require_envpath();
   var import_errutils = require_errutils();
@@ -2756,7 +2756,7 @@ var require_lookup = __commonJS((exports, module) => {
   }
   async function canAccessCommandCandidate(candidate, localBinSearch, diagnostics) {
     try {
-      await (0, import_promises2.access)(candidate, process.platform === "win32" ? import_promises2.constants.F_OK : import_promises2.constants.F_OK | import_promises2.constants.X_OK);
+      await (0, import_promises3.access)(candidate, process.platform === "win32" ? import_promises3.constants.F_OK : import_promises3.constants.F_OK | import_promises3.constants.X_OK);
       return true;
     } catch (error2) {
       if (!(0, import_errutils.isMissingPathError)(error2)) {
@@ -2773,10 +2773,10 @@ var require_lookup = __commonJS((exports, module) => {
     recordSkippedLocalBin(diagnostics, candidate, "reason" in localBinCandidate ? localBinCandidate.reason : `local bin is not accessible: ${(0, import_errutils.getErrorMessage)(error2)}`);
   }
   async function resolveCommandCandidate(command, candidate, localBinSearch, diagnostics) {
-    if (!(await (0, import_promises2.stat)(candidate)).isFile()) {
+    if (!(await (0, import_promises3.stat)(candidate)).isFile()) {
       return null;
     }
-    const realPath2 = await (0, import_promises2.realpath)(candidate);
+    const realPath2 = await (0, import_promises3.realpath)(candidate);
     const localBinCandidate = await classifyPathLocalBinCandidate(candidate, localBinSearch.directories);
     if (!localBinCandidate) {
       return { realPath: realPath2, source: "path" };
@@ -2860,7 +2860,7 @@ var require_lookup = __commonJS((exports, module) => {
   async function getProjectRootMarker(directory3) {
     const gitPath = import_node_path.default.join(directory3, ".git");
     try {
-      await (0, import_promises2.stat)(gitPath);
+      await (0, import_promises3.stat)(gitPath);
       return { path: gitPath };
     } catch {}
     return null;
@@ -2869,11 +2869,11 @@ var require_lookup = __commonJS((exports, module) => {
     const resolvedFilePath = import_node_path.default.resolve(filePath);
     let canonicalFilePath = resolvedFilePath;
     try {
-      canonicalFilePath = import_node_path.default.join(await (0, import_promises2.realpath)(import_node_path.default.dirname(resolvedFilePath)), import_node_path.default.basename(resolvedFilePath));
+      canonicalFilePath = import_node_path.default.join(await (0, import_promises3.realpath)(import_node_path.default.dirname(resolvedFilePath)), import_node_path.default.basename(resolvedFilePath));
     } catch {}
     for (let localBinDirectory of localBinDirectories) {
       try {
-        localBinDirectory = await (0, import_promises2.realpath)(localBinDirectory);
+        localBinDirectory = await (0, import_promises3.realpath)(localBinDirectory);
       } catch {}
       if (canonicalFilePath.startsWith(`${localBinDirectory}${import_node_path.default.sep}`)) {
         return localBinDirectory;
@@ -2885,7 +2885,7 @@ var require_lookup = __commonJS((exports, module) => {
     const candidateDirectory = import_node_path.default.resolve(import_node_path.default.dirname(filePath));
     const directories = [candidateDirectory];
     try {
-      const canonicalDirectory = await (0, import_promises2.realpath)(candidateDirectory);
+      const canonicalDirectory = await (0, import_promises3.realpath)(candidateDirectory);
       if (!directories.includes(canonicalDirectory)) {
         directories.push(canonicalDirectory);
       }
@@ -2938,8 +2938,8 @@ var require_lookup = __commonJS((exports, module) => {
   }
   async function getLocalVercelPackage(nodeModulesDirectory) {
     const packageDirectory = import_node_path.default.join(nodeModulesDirectory, "vercel");
-    const realNodeModulesDirectory = await (0, import_promises2.realpath)(nodeModulesDirectory);
-    const realPackageDirectory = await (0, import_promises2.realpath)(packageDirectory);
+    const realNodeModulesDirectory = await (0, import_promises3.realpath)(nodeModulesDirectory);
+    const realPackageDirectory = await (0, import_promises3.realpath)(packageDirectory);
     if (!(0, import_fsutils.isSubpath)(realNodeModulesDirectory, realPackageDirectory)) {
       return {
         reason: "local vercel package resolves outside local node_modules"
@@ -2959,7 +2959,7 @@ var require_lookup = __commonJS((exports, module) => {
   }
   async function readLocalVercelPackageJson(realPackageDirectory) {
     const packageJsonPath = import_node_path.default.join(realPackageDirectory, "package.json");
-    const realPackageJsonPath = await (0, import_promises2.realpath)(packageJsonPath);
+    const realPackageJsonPath = await (0, import_promises3.realpath)(packageJsonPath);
     if (!(0, import_fsutils.isSubpath)(realPackageDirectory, realPackageJsonPath)) {
       return { reason: "local vercel package.json resolves outside package" };
     }
@@ -2969,7 +2969,7 @@ var require_lookup = __commonJS((exports, module) => {
         reason: `local vercel package.json is unsafe: ${unsafePackageJsonReason}`
       };
     }
-    const packageJson = JSON.parse(await (0, import_promises2.readFile)(realPackageJsonPath, "utf8"));
+    const packageJson = JSON.parse(await (0, import_promises3.readFile)(realPackageJsonPath, "utf8"));
     if (packageJson.name !== "vercel") {
       return {
         reason: 'local vercel package.json does not have name "vercel"'
@@ -2984,7 +2984,7 @@ var require_lookup = __commonJS((exports, module) => {
       return { reason: "local vercel package does not declare bin.vercel" };
     }
     const declaredBinPath = import_node_path.default.resolve(realPackageDirectory, binTarget);
-    const realDeclaredBinPath = await (0, import_promises2.realpath)(declaredBinPath);
+    const realDeclaredBinPath = await (0, import_promises3.realpath)(declaredBinPath);
     if (!(0, import_fsutils.isSubpath)(realPackageDirectory, realDeclaredBinPath)) {
       return { reason: "local vercel package bin resolves outside package" };
     }
@@ -2996,7 +2996,7 @@ var require_lookup = __commonJS((exports, module) => {
     }
     if (process.platform !== "win32" && !(0, import_fsutils.isNodeScript)(realDeclaredBinPath)) {
       try {
-        await (0, import_promises2.access)(realDeclaredBinPath, import_promises2.constants.F_OK | import_promises2.constants.X_OK);
+        await (0, import_promises3.access)(realDeclaredBinPath, import_promises3.constants.F_OK | import_promises3.constants.X_OK);
       } catch (error2) {
         return {
           reason: `local vercel package bin is not executable: ${(0, import_errutils.getErrorMessage)(error2)}`
@@ -3053,17 +3053,17 @@ var require_exec = __commonJS((exports, module) => {
   var import_node_path = __toESM2(__require("node:path"));
   var import_execa = __toESM2(require_execa());
   var import_envpath = require_envpath();
-  var import_errors6 = require_errors();
+  var import_errors7 = require_errors();
   var import_lookup = require_lookup();
   async function execVercelCli2(args2, options = {}) {
     const cwd = import_node_path.default.resolve(options.cwd ?? process.cwd());
-    await (0, import_errors6.assertValidCwd)(cwd);
+    await (0, import_errors7.assertValidCwd)(cwd);
     const env = mergeExecEnv(options.env);
     const pathValue = (0, import_envpath.getEnvPath)(env);
     try {
       return await execResolvedVercelCli(args2, options, cwd, env, pathValue);
     } catch (error2) {
-      if (error2 instanceof import_errors6.VercelCliError && error2.code === "VERCEL_CLI_NOT_FOUND") {
+      if (error2 instanceof import_errors7.VercelCliError && error2.code === "VERCEL_CLI_NOT_FOUND") {
         (0, import_lookup.clearCachedCliInvocation)(cwd, pathValue);
         return await execResolvedVercelCli(args2, options, cwd, env, pathValue);
       }
@@ -3090,15 +3090,15 @@ var require_exec = __commonJS((exports, module) => {
       const { stdout, stderr } = await (0, import_execa.default)(invocation.command, [...invocation.commandArgs, ...args2], execaOptions);
       return { stdout, stderr, invocation };
     } catch (error2) {
-      throw (0, import_errors6.toVercelCliError)(invocation, error2);
+      throw (0, import_errors7.toVercelCliError)(invocation, error2);
     }
   }
   async function resolveInvocationOrThrow(cwd, pathValue) {
     const resolution = await (0, import_lookup.resolveCachedCliInvocation)(cwd, pathValue);
     if (!resolution.found) {
-      throw new import_errors6.VercelCliError({
+      throw new import_errors7.VercelCliError({
         code: "VERCEL_CLI_NOT_FOUND",
-        message: (0, import_errors6.getCliNotFoundMessage)(resolution.diagnostics)
+        message: (0, import_errors7.getCliNotFoundMessage)(resolution.diagnostics)
       });
     }
     return (0, import_lookup.toVercelCliInvocation)(resolution);
@@ -3139,13 +3139,13 @@ var require_dist = __commonJS((exports, module) => {
   var __toCommonJS = (mod) => __copyProps(__defProp2({}, "__esModule", { value: true }), mod);
   var src_exports = {};
   __export2(src_exports, {
-    VercelCliError: () => import_errors6.VercelCliError,
+    VercelCliError: () => import_errors7.VercelCliError,
     clearVercelCliLookupCache: () => import_lookup.clearVercelCliLookupCache,
     execVercelCli: () => import_exec.execVercelCli,
     findVercelCli: () => import_lookup.findVercelCli
   });
   module.exports = __toCommonJS(src_exports);
-  var import_errors6 = require_errors();
+  var import_errors7 = require_errors();
   var import_exec = require_exec();
   var import_lookup = require_lookup();
 });
@@ -27642,6 +27642,9 @@ var require_throttleit = __commonJS((exports, module) => {
   }
   module.exports = throttle;
 });
+
+// src/index.ts
+import { readFileSync } from "node:fs";
 // ../../node_modules/@effect/platform-node/dist/NodeRuntime.js
 var exports_NodeRuntime = {};
 __export(exports_NodeRuntime, {
@@ -58403,12 +58406,250 @@ var runWith2 = (command, config) => {
     yield* provideContext2(program, services);
   }, catchFilter2((error2) => isCliError(error2) && error2._tag === "ShowHelp" ? succeed2(error2) : fail2(error2), (error2) => andThen4(showHelp(command, error2, config.renderErrors !== false), fail6(error2))), catchFilter2((error2) => config.renderErrors !== false && isCliError(error2) && error2._tag === "UserError" ? succeed2(error2) : fail2(error2), (error2) => andThen4(showUserError(error2), fail6(error2))), catchFilter2((e) => isQuitError(e) ? succeed2(e) : fail2(e), (_) => interrupt2));
 };
-// src/index.ts
-import { readFileSync } from "node:fs";
+// ../../packages/challenges-contract/src/index.ts
+var blackBoxChallengeSlug = "black-box";
+var challengeCatalog = [
+  {
+    slug: blackBoxChallengeSlug,
+    number: 1,
+    code: "01",
+    theme: "Black Box",
+    title: "The Shipping Machine",
+    summary: "Reverse-engineer an undocumented delivery-price service with a limited number of queries, then implement a compatible replacement.",
+    coreSkill: "Reverse engineering & experimentation",
+    format: "accuracy",
+    formatLabel: "Accuracy score",
+    opensAt: "2026-09-18T05:00:00.000Z",
+    queryLimit: 25,
+    evaluationLimit: 3,
+    hiddenSampleSize: 1000,
+    playable: true,
+    solutionKind: "javascript_source"
+  },
+  {
+    slug: "last-mile",
+    number: 2,
+    code: "02",
+    theme: "Last Mile",
+    title: "The Delivery Plan",
+    summary: "Build a delivery plan under capacity, traffic, and deadline constraints. Better heuristics score higher.",
+    coreSkill: "Optimization & heuristics",
+    format: "optimization",
+    formatLabel: "Optimization score",
+    opensAt: "2026-09-25T05:00:00.000Z",
+    queryLimit: 0,
+    evaluationLimit: 3,
+    hiddenSampleSize: 1,
+    playable: false,
+    solutionKind: "json_plan"
+  },
+  {
+    slug: "make-it-fast",
+    number: 3,
+    code: "03",
+    theme: "Make It Fast",
+    title: "The Slow Service",
+    summary: "Produce exactly the same result as a correct but inefficient implementation, ranked by runtime.",
+    coreSkill: "Performance engineering",
+    format: "runtime",
+    formatLabel: "Runtime score",
+    opensAt: "2026-10-02T05:00:00.000Z",
+    queryLimit: 0,
+    evaluationLimit: 3,
+    hiddenSampleSize: 1,
+    playable: false,
+    solutionKind: "javascript_source"
+  },
+  {
+    slug: "power-grid",
+    number: 4,
+    code: "04",
+    theme: "Power Grid",
+    title: "The Dispatch Desk",
+    summary: "Keep a simplified energy grid stable while minimizing cost and blackouts under uncertainty.",
+    coreSkill: "Simulation & decision making",
+    format: "multi_objective",
+    formatLabel: "Multi-objective score",
+    opensAt: "2026-10-09T05:00:00.000Z",
+    queryLimit: 0,
+    evaluationLimit: 3,
+    hiddenSampleSize: 1,
+    playable: false,
+    solutionKind: "javascript_source"
+  },
+  {
+    slug: "agent-arena",
+    number: 5,
+    code: "05",
+    theme: "Agent Arena",
+    title: "The Tool-Using Agent",
+    summary: "Configure an agent that balances accuracy, tool calls, model cost, and latency.",
+    coreSkill: "AI engineering & system design",
+    format: "multi_objective",
+    formatLabel: "Accuracy + cost + latency",
+    opensAt: "2026-10-13T05:00:00.000Z",
+    queryLimit: 0,
+    evaluationLimit: 3,
+    hiddenSampleSize: 1,
+    playable: false,
+    solutionKind: "agent_config"
+  }
+];
+var playableChallenges = challengeCatalog.filter((challenge) => challenge.playable);
+var ChallengeSlugSchema = exports_Schema.Literals([
+  "black-box",
+  "last-mile",
+  "make-it-fast",
+  "power-grid",
+  "agent-arena"
+]);
+var ShipmentSchema = exports_Schema.Struct({
+  distanceKm: exports_Schema.Number.pipe(exports_Schema.check(exports_Schema.isBetween({ minimum: 0.1, maximum: 2000 }))),
+  weightKg: exports_Schema.Number.pipe(exports_Schema.check(exports_Schema.isBetween({ minimum: 0.1, maximum: 500 }))),
+  hour: exports_Schema.Int.pipe(exports_Schema.check(exports_Schema.isBetween({ minimum: 0, maximum: 23 }))),
+  fragile: exports_Schema.Boolean,
+  express: exports_Schema.Boolean
+});
+var JavascriptSourceSolutionSchema = exports_Schema.Struct({
+  kind: exports_Schema.Literal("javascript_source"),
+  source: exports_Schema.String.pipe(exports_Schema.check(exports_Schema.isMinLength(1), exports_Schema.isMaxLength(32768)))
+});
+var ChallengeObservationSchema = exports_Schema.Struct({
+  sequence: exports_Schema.Number,
+  input: exports_Schema.Unknown,
+  output: exports_Schema.Unknown,
+  createdAt: exports_Schema.String
+});
+var ChallengeScoreSchema = exports_Schema.Struct({
+  accuracy: exports_Schema.Number,
+  exactCount: exports_Schema.Number,
+  sampleSize: exports_Schema.Number,
+  meanError: exports_Schema.Number,
+  queriesUsed: exports_Schema.Number,
+  runtimeMs: exports_Schema.Number
+});
+var ChallengeProgressStatus = exports_Schema.Literals([
+  "not_started",
+  "in_progress",
+  "evaluated"
+]);
+var ParticipantChallengeProgressSchema = exports_Schema.Struct({
+  slug: ChallengeSlugSchema,
+  title: exports_Schema.String,
+  theme: exports_Schema.String,
+  status: ChallengeProgressStatus,
+  open: exports_Schema.Boolean,
+  playable: exports_Schema.Boolean,
+  queriesUsed: exports_Schema.Number,
+  queriesLimit: exports_Schema.Number,
+  evaluationsUsed: exports_Schema.Number,
+  evaluationsLimit: exports_Schema.Number,
+  bestAccuracy: exports_Schema.optional(exports_Schema.Number),
+  bestExactCount: exports_Schema.optional(exports_Schema.Number),
+  shareCode: exports_Schema.optional(exports_Schema.String),
+  rank: exports_Schema.optional(exports_Schema.Number)
+});
+var ChallengeCatalogItemSchema = exports_Schema.Struct({
+  slug: ChallengeSlugSchema,
+  number: exports_Schema.Number,
+  code: exports_Schema.String,
+  theme: exports_Schema.String,
+  title: exports_Schema.String,
+  summary: exports_Schema.String,
+  coreSkill: exports_Schema.String,
+  format: exports_Schema.Literals([
+    "accuracy",
+    "optimization",
+    "runtime",
+    "multi_objective"
+  ]),
+  formatLabel: exports_Schema.String,
+  opensAt: exports_Schema.String,
+  queryLimit: exports_Schema.Number,
+  evaluationLimit: exports_Schema.Number,
+  playable: exports_Schema.Boolean,
+  open: exports_Schema.Boolean,
+  rankingPath: exports_Schema.String
+});
+var ChallengeEvaluationSummarySchema = exports_Schema.Struct({
+  accuracy: exports_Schema.Number,
+  exactCount: exports_Schema.Number,
+  sampleSize: exports_Schema.Number,
+  meanError: exports_Schema.Number,
+  queriesUsed: exports_Schema.Number,
+  runtimeMs: exports_Schema.Number,
+  shareCode: exports_Schema.String,
+  rank: exports_Schema.optional(exports_Schema.Number),
+  percentile: exports_Schema.optional(exports_Schema.Number),
+  createdAt: exports_Schema.String
+});
+var ChallengeAttemptViewSchema = exports_Schema.Struct({
+  challenge: ChallengeCatalogItemSchema,
+  progress: ParticipantChallengeProgressSchema,
+  observations: exports_Schema.Array(ChallengeObservationSchema),
+  latestEvaluation: exports_Schema.optional(ChallengeEvaluationSummarySchema),
+  aiAllowed: exports_Schema.Literal(true),
+  localTestHint: exports_Schema.String
+});
+var ChallengeQueryResultSchema = exports_Schema.Struct({
+  observation: ChallengeObservationSchema,
+  queriesUsed: exports_Schema.Number,
+  queriesRemaining: exports_Schema.Number,
+  queriesLimit: exports_Schema.Number
+});
+var ChallengeLocalTestResultSchema = exports_Schema.Struct({
+  matchedObservations: exports_Schema.Number,
+  observationCount: exports_Schema.Number,
+  accuracy: exports_Schema.Number,
+  meanError: exports_Schema.Number,
+  mismatches: exports_Schema.Array(exports_Schema.Struct({
+    sequence: exports_Schema.Number,
+    expected: exports_Schema.Unknown,
+    actual: exports_Schema.Unknown
+  }))
+});
+var ChallengeEvaluationResultSchema = exports_Schema.Struct({
+  accuracy: exports_Schema.Number,
+  exactCount: exports_Schema.Number,
+  sampleSize: exports_Schema.Number,
+  meanError: exports_Schema.Number,
+  queriesUsed: exports_Schema.Number,
+  runtimeMs: exports_Schema.Number,
+  shareCode: exports_Schema.String,
+  rank: exports_Schema.optional(exports_Schema.Number),
+  competitorCount: exports_Schema.optional(exports_Schema.Number),
+  percentile: exports_Schema.optional(exports_Schema.Number),
+  evaluationsUsed: exports_Schema.Number,
+  evaluationsRemaining: exports_Schema.Number,
+  evaluationsLimit: exports_Schema.Number,
+  rankingPath: exports_Schema.String,
+  shareText: exports_Schema.String
+});
+var ChallengeRankingEntrySchema = exports_Schema.Struct({
+  rank: exports_Schema.Number,
+  displayName: exports_Schema.String,
+  shareCode: exports_Schema.String,
+  accuracy: exports_Schema.Number,
+  exactCount: exports_Schema.Number,
+  sampleSize: exports_Schema.Number,
+  meanError: exports_Schema.Number,
+  queriesUsed: exports_Schema.Number,
+  runtimeMs: exports_Schema.Number,
+  evaluatedAt: exports_Schema.String
+});
+var ChallengeRankingSchema = exports_Schema.Struct({
+  challenge: ChallengeCatalogItemSchema,
+  entries: exports_Schema.Array(ChallengeRankingEntrySchema),
+  competitorCount: exports_Schema.Number
+});
+var ChallengeCatalogSchema = exports_Schema.Struct({
+  challenges: exports_Schema.Array(ChallengeCatalogItemSchema)
+});
 
 // ../../packages/registration-contract/src/index.ts
 var nonBlank = (maximum) => exports_Schema.Trim.pipe(exports_Schema.check(exports_Schema.isMinLength(1), exports_Schema.isMaxLength(maximum)));
 var optionalText = (maximum) => exports_Schema.optional(nonBlank(maximum));
+var nullableOptionalText = (maximum) => exports_Schema.optional(exports_Schema.NullOr(nonBlank(maximum)));
 var normalizedString = (normalize2) => exports_Schema.String.pipe(exports_Schema.decode({
   decode: exports_SchemaGetter.transform(normalize2),
   encode: exports_SchemaGetter.transform((value3) => value3)
@@ -58421,6 +58662,7 @@ var url = normalizedString((value3) => {
 }).pipe(exports_Schema.check(exports_Schema.isPattern(/^https?:\/\/[^\s]+$/i, {
   message: "Must be an http or https URL"
 }), exports_Schema.isMaxLength(2048)));
+var graduationYear = exports_Schema.Int.pipe(exports_Schema.check(exports_Schema.isBetween({ minimum: 1950, maximum: 2100 })));
 var RegistrationStatus = exports_Schema.Literals([
   "draft",
   "submitted",
@@ -58472,7 +58714,7 @@ var applicationInputFields = {
   organization: optionalText(200),
   role: optionalText(120),
   fieldOfStudy: optionalText(160),
-  graduationYear: exports_Schema.optional(exports_Schema.Int.pipe(exports_Schema.check(exports_Schema.isBetween({ minimum: 1950, maximum: 2100 })))),
+  graduationYear: exports_Schema.optional(graduationYear),
   shippedProject: nonBlank(2000),
   hackathonProject: nonBlank(2000),
   bio: nonBlank(2000),
@@ -58487,6 +58729,35 @@ var applicationInputFields = {
 };
 var applicationInputFieldNames = Object.keys(applicationInputFields);
 var ApplicationInput = exports_Schema.Struct(applicationInputFields);
+var applicationDraftInputFields = {
+  firstName: exports_Schema.optional(applicationInputFields.firstName),
+  lastName: exports_Schema.optional(applicationInputFields.lastName),
+  pronouns: nullableOptionalText(50),
+  city: exports_Schema.optional(applicationInputFields.city),
+  organization: nullableOptionalText(200),
+  role: nullableOptionalText(120),
+  fieldOfStudy: nullableOptionalText(160),
+  graduationYear: exports_Schema.optional(exports_Schema.NullOr(graduationYear)),
+  shippedProject: exports_Schema.optional(applicationInputFields.shippedProject),
+  hackathonProject: exports_Schema.optional(applicationInputFields.hackathonProject),
+  bio: exports_Schema.optional(applicationInputFields.bio),
+  githubUrl: exports_Schema.optional(exports_Schema.NullOr(url)),
+  linkedInUrl: exports_Schema.optional(exports_Schema.NullOr(url)),
+  portfolioUrl: exports_Schema.optional(exports_Schema.NullOr(url)),
+  teamPreference: exports_Schema.optional(applicationInputFields.teamPreference),
+  teamName: nullableOptionalText(120),
+  codeOfConductAccepted: exports_Schema.optional(exports_Schema.Boolean),
+  privacyPolicyAccepted: exports_Schema.optional(exports_Schema.Boolean),
+  mediaConsent: exports_Schema.optional(exports_Schema.Boolean)
+};
+var applicationDraftInputFieldNames = Object.keys(applicationDraftInputFields);
+var ApplicationDraftInput = exports_Schema.Struct(applicationDraftInputFields);
+var ApplicationPartId = exports_Schema.Literals([
+  "identity",
+  "experience",
+  "team",
+  "agreements"
+]);
 var acceptedDetailsInputFields = {
   fullName: nonBlank(200),
   phone: nonBlank(32),
@@ -58577,15 +58848,33 @@ var RegistrationViewSchema = exports_Schema.Struct({
   pictureSource: exports_Schema.optional(PictureSource),
   pictureUrl: exports_Schema.optional(exports_Schema.String),
   rejectionReason: exports_Schema.optional(exports_Schema.String),
-  submittedAt: exports_Schema.String,
+  codeOfConductAccepted: exports_Schema.Boolean,
+  privacyPolicyAccepted: exports_Schema.Boolean,
+  submittedAt: exports_Schema.optional(exports_Schema.String),
   acceptanceDetailsCompletedAt: exports_Schema.optional(exports_Schema.String),
   createdAt: exports_Schema.String,
-  updatedAt: exports_Schema.String
+  updatedAt: exports_Schema.String,
+  challenges: exports_Schema.Array(ParticipantChallengeProgressSchema)
+});
+var ApplicationPartSchema = exports_Schema.Struct({
+  id: ApplicationPartId,
+  title: exports_Schema.String,
+  complete: exports_Schema.Boolean,
+  missing: exports_Schema.Array(RequirementSchema)
 });
 var RegistrationRequirementsSchema = exports_Schema.Struct({
-  stage: exports_Schema.Literals(["review", "rejected", "accepted", "complete"]),
+  stage: exports_Schema.Literals([
+    "draft",
+    "review",
+    "rejected",
+    "accepted",
+    "complete"
+  ]),
   canSubmitNewApplication: exports_Schema.Boolean,
   canSubmitAcceptedDetails: exports_Schema.Boolean,
+  canSaveDraft: exports_Schema.Boolean,
+  canSubmitApplication: exports_Schema.Boolean,
+  parts: exports_Schema.Array(ApplicationPartSchema),
   missing: exports_Schema.Array(RequirementSchema),
   rejectionReason: exports_Schema.optional(exports_Schema.String)
 });
@@ -59061,7 +59350,8 @@ var sendRequest = (options, path4, init, token) => exports_Effect.tryPromise({
   try: () => {
     const headers = new Headers(init.headers);
     headers.set("accept", "application/json");
-    headers.set("authorization", `Bearer ${token}`);
+    if (token)
+      headers.set("authorization", `Bearer ${token}`);
     headers.set("x-request-id", crypto.randomUUID());
     if (init.body !== undefined) {
       headers.set("content-type", "application/json");
@@ -59074,14 +59364,7 @@ var sendRequest = (options, path4, init, token) => exports_Effect.tryPromise({
   },
   catch: (error2) => cliError("NETWORK_ERROR", `Could not reach the registration API: ${String(error2)}`, true)
 });
-var request3 = exports_Effect.fn("apiRequest")(function* (options, path4, init, decodeResponse) {
-  const suppliedToken = options.token ?? process.env.CHOFEX_TOKEN;
-  let token = yield* resolveAccessToken(suppliedToken);
-  let response = yield* sendRequest(options, path4, init, token);
-  if (response.status === 401 && !suppliedToken) {
-    token = yield* resolveAccessToken(undefined, true);
-    response = yield* sendRequest(options, path4, init, token);
-  }
+var decodeHttpBody = exports_Effect.fn("decodeHttpBody")(function* (response, decodeResponse) {
   const body = yield* exports_Effect.tryPromise({
     try: () => response.json(),
     catch: () => cliError("INVALID_API_RESPONSE", `The API returned a non-JSON response (${response.status})`, response.status >= 500)
@@ -59095,25 +59378,564 @@ var request3 = exports_Effect.fn("apiRequest")(function* (options, path4, init,
   }
   return yield* decodeResponse(body).pipe(exports_Effect.mapError((error2) => cliError("INVALID_API_RESPONSE", "The API response did not match protocol version 1", false, { issues: String(error2) })));
 });
+var request3 = exports_Effect.fn("apiRequest")(function* (options, path4, init, decodeResponse) {
+  const suppliedToken = options.token ?? process.env.CHOFEX_TOKEN;
+  let token = yield* resolveAccessToken(suppliedToken);
+  let response = yield* sendRequest(options, path4, init, token);
+  if (response.status === 401 && !suppliedToken) {
+    token = yield* resolveAccessToken(undefined, true);
+    response = yield* sendRequest(options, path4, init, token);
+  }
+  return yield* decodeHttpBody(response, decodeResponse);
+});
+var publicRequest = exports_Effect.fn("publicApiRequest")(function* (options, path4, init, decodeResponse) {
+  const response = yield* sendRequest(options, path4, init);
+  return yield* decodeHttpBody(response, decodeResponse);
+});
 var decodeCreatedRegistration = exports_Schema.decodeUnknownEffect(ApiSuccessSchema(CreatedRegistrationSchema));
 var decodeBadgeResult = exports_Schema.decodeUnknownEffect(ApiSuccessSchema(BadgeResultSchema));
 var decodeCurrentUser = exports_Schema.decodeUnknownEffect(ApiSuccessSchema(CurrentUserSchema));
 var decodeRegistrationResult = exports_Schema.decodeUnknownEffect(ApiSuccessSchema(RegistrationResultSchema));
 var decodePictureUploadGrant = exports_Schema.decodeUnknownEffect(ApiSuccessSchema(PictureUploadGrantSchema));
 var decodePictureUpload = exports_Schema.decodeUnknownEffect(ApiSuccessSchema(PictureUploadSchema));
-var register = (options, input) => request3(options, "/api/v1/registrations", {
-  method: "POST",
-  body: JSON.stringify(input)
-}, decodeCreatedRegistration);
+var decodeChallengeCatalog = exports_Schema.decodeUnknownEffect(ApiSuccessSchema(ChallengeCatalogSchema));
+var decodeChallengeAttempt = exports_Schema.decodeUnknownEffect(ApiSuccessSchema(ChallengeAttemptViewSchema));
+var decodeChallengeQuery = exports_Schema.decodeUnknownEffect(ApiSuccessSchema(ChallengeQueryResultSchema));
+var decodeChallengeTest = exports_Schema.decodeUnknownEffect(ApiSuccessSchema(ChallengeLocalTestResultSchema));
+var decodeChallengeEvaluation = exports_Schema.decodeUnknownEffect(ApiSuccessSchema(ChallengeEvaluationResultSchema));
+var decodeChallengeRanking = exports_Schema.decodeUnknownEffect(ApiSuccessSchema(ChallengeRankingSchema));
 var getCurrentUser = (options) => request3(options, "/api/v1/me", { method: "GET" }, decodeCurrentUser);
 var getRegistration = (options) => request3(options, "/api/v1/registration", { method: "GET" }, decodeRegistrationResult);
 var getBadge = (options) => request3(options, "/api/v1/badge", { method: "GET" }, decodeBadgeResult);
 var confirmAttendance = (options, input) => request3(options, "/api/v1/registration/attendance", { method: "PUT", body: JSON.stringify(input) }, decodeRegistrationResult);
 var beginPictureUpload = (options, input) => request3(options, "/api/v1/profile-picture", { method: "POST", body: JSON.stringify(input) }, decodePictureUploadGrant);
 var completePictureUpload = (options, input) => request3(options, "/api/v1/profile-picture", { method: "PUT", body: JSON.stringify(input) }, decodePictureUpload);
+var saveRegistrationDraft = (options, input) => request3(options, "/api/v1/registration", {
+  method: "PUT",
+  body: JSON.stringify(input)
+}, decodeRegistrationResult);
+var submitRegistration = (options) => request3(options, "/api/v1/registration/submit", { method: "POST" }, decodeCreatedRegistration);
+var listChallenges = (options) => publicRequest(options, "/api/v1/challenges", { method: "GET" }, decodeChallengeCatalog);
+var getChallengeAttempt = (options, slug) => request3(options, `/api/v1/challenges/${slug}`, { method: "GET" }, decodeChallengeAttempt);
+var queryChallenge = (options, slug, input) => request3(options, `/api/v1/challenges/${slug}/query`, { method: "POST", body: JSON.stringify(input) }, decodeChallengeQuery);
+var testChallenge = (options, slug, input) => request3(options, `/api/v1/challenges/${slug}/test`, { method: "POST", body: JSON.stringify(input) }, decodeChallengeTest);
+var evaluateChallenge = (options, slug, input) => request3(options, `/api/v1/challenges/${slug}/evaluate`, { method: "POST", body: JSON.stringify(input) }, decodeChallengeEvaluation);
+var getChallengeRanking = (options, slug) => publicRequest(options, `/api/v1/challenges/${slug}/ranking`, { method: "GET" }, decodeChallengeRanking);
+
+// src/challenge-input.ts
+import { readFile as readFile3 } from "node:fs/promises";
+var readStdin = async () => {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+};
+var readTextFile = (path4) => exports_Effect.tryPromise({
+  try: async () => {
+    if (path4 === "-")
+      return readStdin();
+    return readFile3(path4, "utf8");
+  },
+  catch: (error2) => cliError("INVALID_INPUT_FILE", `Could not read ${path4}: ${String(error2)}`)
+});
+var javascriptSourceFromPath = (path4) => {
+  if (!path4) {
+    return exports_Effect.fail(cliError("SOURCE_REQUIRED", "Pass --source <file.js> with function calculateShipping(input)"));
+  }
+  return readTextFile(path4).pipe(exports_Effect.map((source) => ({ kind: "javascript_source", source })));
+};
+var requiredNumber = (message) => exports_Prompt.text({
+  message,
+  validate: (value3) => {
+    if (value3.trim() === "" || Number.isNaN(Number(value3))) {
+      return exports_Effect.fail("Must be a number");
+    }
+    return exports_Effect.succeed(value3);
+  }
+});
+var interactiveShipment = () => exports_Prompt.run(exports_Prompt.all({
+  distanceKm: requiredNumber("Distance (km)"),
+  weightKg: requiredNumber("Weight (kg)"),
+  hour: requiredNumber("Hour (0-23)"),
+  fragile: exports_Prompt.confirm({ message: "Fragile?" }),
+  express: exports_Prompt.confirm({ message: "Express?" })
+})).pipe(exports_Effect.map((input) => ({
+  distanceKm: Number(input.distanceKm),
+  weightKg: Number(input.weightKg),
+  hour: Number(input.hour),
+  fragile: input.fragile,
+  express: input.express
+})), exports_Effect.flatMap((input) => exports_Schema.decodeUnknownEffect(ShipmentSchema)(input).pipe(exports_Effect.mapError((error2) => cliError("VALIDATION_ERROR", error2.message)))), exports_Effect.mapError((error2) => {
+  if (error2 instanceof CliError2)
+    return error2;
+  return cliError("PROMPT_CANCELLED", "Interactive input was cancelled");
+}));
+var shipmentInput = (path4, flags) => {
+  if (path4) {
+    return readTextFile(path4).pipe(exports_Effect.flatMap((contents) => exports_Effect.try({
+      try: () => JSON.parse(contents),
+      catch: (error2) => cliError("INVALID_INPUT_FILE", `Could not parse JSON shipment: ${String(error2)}`)
+    })), exports_Effect.flatMap((input) => exports_Schema.decodeUnknownEffect(ShipmentSchema)(input).pipe(exports_Effect.mapError((error2) => cliError("VALIDATION_ERROR", error2.message)))));
+  }
+  const hasFlags = flags.distanceKm !== undefined && flags.weightKg !== undefined && flags.hour !== undefined && flags.fragile !== undefined && flags.express !== undefined;
+  if (hasFlags) {
+    return exports_Schema.decodeUnknownEffect(ShipmentSchema)({
+      distanceKm: flags.distanceKm,
+      weightKg: flags.weightKg,
+      hour: flags.hour,
+      fragile: flags.fragile,
+      express: flags.express
+    }).pipe(exports_Effect.mapError((error2) => cliError("VALIDATION_ERROR", error2.message)));
+  }
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    return exports_Effect.fail(cliError("INPUT_REQUIRED", "Provide --input shipment.json or --distance, --weight, --hour, --fragile, and --express"));
+  }
+  return interactiveShipment();
+};
+var defaultChallengeSlug = "black-box";
+
+// src/challenge-output.ts
+var remainingBar = (used, limit) => {
+  if (limit <= 0)
+    return "";
+  const width = 20;
+  const remaining = Math.max(0, limit - used);
+  const filled = Math.round(remaining / limit * width);
+  return `${"█".repeat(filled)}${"░".repeat(width - filled)}`;
+};
+var percent = (value3) => `${(value3 * 100).toFixed(2)}%`;
+var challengeListText = (catalog) => {
+  const lines2 = ["Hack the Andes challenges", ""];
+  for (const challenge of catalog.challenges) {
+    let state = "open";
+    if (!challenge.open)
+      state = `opens ${challenge.opensAt.slice(0, 10)}`;
+    const playable = challenge.playable ? "" : " (coming later)";
+    lines2.push(`${challenge.code}  ${challenge.theme} — ${challenge.title}${playable}`);
+    lines2.push(`    ${challenge.coreSkill} · ${challenge.formatLabel} · ${state}`);
+    lines2.push(`    Ranking: ${challenge.rankingPath}`);
+    lines2.push("");
+  }
+  lines2.push("Play the open challenge: chofex challenge query");
+  return lines2.join(`
+`);
+};
+var challengeShowText = (attempt) => {
+  const { challenge, progress } = attempt;
+  const queryBar = remainingBar(progress.queriesUsed, progress.queriesLimit);
+  const evalBar = remainingBar(progress.evaluationsUsed, progress.evaluationsLimit);
+  const lines2 = [
+    `${challenge.theme} #${challenge.code}`,
+    challenge.title,
+    challenge.summary,
+    "",
+    "AI is allowed. Use ChatGPT, Claude, Codex, Cursor, or any tool you want.",
+    "The hidden rules are personalized to you, so leaked solutions will not match.",
+    "",
+    "Queries remaining",
+    queryBar,
+    `${progress.queriesLimit - progress.queriesUsed} / ${progress.queriesLimit}`,
+    "",
+    "Official evaluations remaining",
+    evalBar,
+    `${progress.evaluationsLimit - progress.evaluationsUsed} / ${progress.evaluationsLimit}`
+  ];
+  if (progress.bestAccuracy !== undefined) {
+    lines2.push("", `Best accuracy  ${percent(progress.bestAccuracy)}`);
+    if (progress.rank !== undefined)
+      lines2.push(`Rank           #${progress.rank}`);
+    if (progress.shareCode)
+      lines2.push(`Share code     #${progress.shareCode}`);
+  }
+  lines2.push("", "Next:", "  chofex challenge query", "  chofex challenge notebook", "  chofex challenge test --source ./shipping.js", "  chofex challenge evaluate --source ./shipping.js");
+  return lines2.join(`
+`);
+};
+var challengeQueryText = (result3) => {
+  const remaining = remainingBar(result3.queriesUsed, result3.queriesLimit);
+  return [
+    `Output  ${JSON.stringify(result3.observation.output)}`,
+    "",
+    "Queries remaining",
+    remaining,
+    `${result3.queriesRemaining} / ${result3.queriesLimit}`
+  ].join(`
+`);
+};
+var shipmentCells = (observation) => {
+  const input = observation.input;
+  if (typeof input !== "object" || input === null) {
+    return {
+      distance: "",
+      weight: "",
+      hour: "",
+      fragile: "",
+      express: ""
+    };
+  }
+  const record2 = input;
+  return {
+    distance: String(record2.distanceKm ?? ""),
+    weight: String(record2.weightKg ?? ""),
+    hour: String(record2.hour ?? ""),
+    fragile: String(record2.fragile ?? ""),
+    express: String(record2.express ?? "")
+  };
+};
+var notebookTableText = (observations) => {
+  if (observations.length === 0) {
+    return "No observations yet. Run `chofex challenge query`.";
+  }
+  const header = "#\tDistance\tWeight\tHour\tFragile\tExpress\tOutput";
+  const rows = observations.map((observation) => {
+    const cells = shipmentCells(observation);
+    return [
+      observation.sequence,
+      cells.distance,
+      cells.weight,
+      cells.hour,
+      cells.fragile,
+      cells.express,
+      JSON.stringify(observation.output)
+    ].join("\t");
+  });
+  return [header, ...rows].join(`
+`);
+};
+var notebookCsvText = (observations) => {
+  const header = "sequence,distanceKm,weightKg,hour,fragile,express,output";
+  const rows = observations.map((observation) => {
+    const cells = shipmentCells(observation);
+    return [
+      observation.sequence,
+      cells.distance,
+      cells.weight,
+      cells.hour,
+      cells.fragile,
+      cells.express,
+      JSON.stringify(observation.output)
+    ].join(",");
+  });
+  return [header, ...rows].join(`
+`);
+};
+var challengeTestText = (result3) => {
+  const lines2 = [
+    "LOCAL TESTS (your notebook only)",
+    `Accuracy           ${percent(result3.accuracy)}`,
+    `Exact predictions  ${result3.matchedObservations} / ${result3.observationCount}`,
+    `Mean error         ${result3.meanError.toFixed(2)}`
+  ];
+  if (result3.mismatches.length > 0) {
+    lines2.push("", "Mismatches:");
+    for (const mismatch of result3.mismatches) {
+      lines2.push(`  #${mismatch.sequence} expected ${JSON.stringify(mismatch.expected)} got ${JSON.stringify(mismatch.actual)}`);
+    }
+  }
+  return lines2.join(`
+`);
+};
+var challengeEvaluateText = (result3) => {
+  const lines2 = [
+    "BLACK BOX REPLICATION",
+    `Accuracy            ${percent(result3.accuracy)}`,
+    `Exact predictions   ${result3.exactCount} / ${result3.sampleSize}`,
+    `Mean error          ${result3.meanError.toFixed(2)}`,
+    `Oracle queries used ${result3.queriesUsed}`
+  ];
+  if (result3.rank !== undefined)
+    lines2.push(`Rank                #${result3.rank}`);
+  lines2.push(`Official evaluations remaining ${result3.evaluationsRemaining} / ${result3.evaluationsLimit}`, "", result3.shareText);
+  return lines2.join(`
+`);
+};
+var challengeRankingText = (ranking) => {
+  const lines2 = [
+    `${ranking.challenge.theme} — ${ranking.challenge.title}`,
+    `${ranking.competitorCount} official evaluations`,
+    ""
+  ];
+  if (ranking.entries.length === 0) {
+    lines2.push("No official evaluations yet.");
+    return lines2.join(`
+`);
+  }
+  lines2.push("Rank  Accuracy  Exact        Queries  Name");
+  for (const entry of ranking.entries.slice(0, 20)) {
+    const rank = String(entry.rank).padStart(4, " ");
+    const accuracy = percent(entry.accuracy).padStart(8, " ");
+    const exact = `${entry.exactCount}/${entry.sampleSize}`.padStart(11, " ");
+    const queries = String(entry.queriesUsed).padStart(7, " ");
+    lines2.push(`${rank}  ${accuracy}  ${exact}  ${queries}  ${entry.displayName} #${entry.shareCode}`);
+  }
+  return lines2.join(`
+`);
+};
+var draftSavedText = (result3) => ["Application draft saved.", registrationPartsText(result3)].join(`
+`);
+var registrationPartsText = (result3) => {
+  const parts = result3.requirements.parts ?? [];
+  if (parts.length === 0)
+    return "";
+  const lines2 = ["", "Application parts:"];
+  for (const part of parts) {
+    const mark = part.complete ? "✓" : "○";
+    let detail = "";
+    if (!part.complete && part.missing[0]) {
+      detail = ` — ${part.missing[0].reason}`;
+    }
+    lines2.push(`  ${mark} ${part.title}${detail}`);
+  }
+  if (result3.requirements.canSubmitApplication) {
+    lines2.push("", "Ready to submit: chofex register --submit");
+  } else if (result3.requirements.stage === "draft") {
+    lines2.push("", "Continue later with `chofex register`. Progress is saved.");
+  }
+  return lines2.join(`
+`);
+};
+
+// src/cli-root.ts
+var root = exports_Command.make("chofex").pipe(exports_Command.withSharedFlags({
+  apiUrl: exports_Flag.string("api-url").pipe(exports_Flag.withDefault(config.apiUrl), exports_Flag.withDescription("Registration API base URL")),
+  output: exports_Flag.choice("output", ["human", "json"]).pipe(exports_Flag.withDefault("human"), exports_Flag.withDescription("Output format")),
+  token: exports_Flag.string("token").pipe(exports_Flag.optional, exports_Flag.withDescription("Clerk OAuth token (prefer CHOFEX_TOKEN to avoid shell history)"))
+}), exports_Command.withDescription("Register for and manage your Chofex hackathon application"));
+
+// src/output.ts
+var printJson = (value3) => exports_Effect.sync(() => {
+  process.stdout.write(`${JSON.stringify(value3)}
+`);
+});
+var humanErrorDetails = (details) => {
+  if (details === undefined)
+    return "";
+  if (typeof details === "object" && details !== null && "issues" in details) {
+    const issues = details.issues;
+    if (Array.isArray(issues)) {
+      const decoded = exports_Schema.decodeUnknownResult(exports_Schema.Array(RequirementSchema))(issues);
+      if (exports_Result.isSuccess(decoded) && decoded.success.length > 0) {
+        const lines2 = decoded.success.map((issue) => `  - ${issue.field}: ${issue.reason}`);
+        return `
+Details:
+${lines2.join(`
+`)}`;
+      }
+    }
+    if (typeof issues === "string")
+      return `
+Details:
+${issues}`;
+  }
+  if (typeof details === "string")
+    return `
+Details:
+${details}`;
+  return `
+Details:
+${JSON.stringify(details, null, 2)}`;
+};
+var execute = (mode, operation, human, humanError) => operation.pipe(exports_Effect.flatMap((response) => {
+  if (mode === "json")
+    return printJson(response);
+  return exports_Console.log(human(response.data));
+}), exports_Effect.catch((error2) => {
+  process.exitCode = exitCodeFor(error2);
+  if (mode === "json") {
+    return printJson({
+      version: 1,
+      ok: false,
+      requestId: error2.requestId,
+      error: {
+        code: error2.code,
+        message: error2.message,
+        retryable: error2.retryable,
+        details: error2.details
+      }
+    });
+  }
+  const customMessage = humanError?.(error2);
+  if (customMessage !== undefined) {
+    return exports_Console.error(`${customMessage}
+Request ID: ${error2.requestId}`);
+  }
+  const details = humanErrorDetails(error2.details);
+  return exports_Console.error(`Error [${error2.code}]: ${error2.message}${details}
+Request ID: ${error2.requestId}`);
+}));
+var registrationLookupErrorText = (error2) => {
+  if (error2.code !== "REGISTRATION_NOT_FOUND")
+    return;
+  return `No registration found.
+Next command: chofex register`;
+};
+var requirementsText = (result3) => {
+  const { registration, requirements } = result3;
+  if (registration.status === "withdrawn") {
+    return "Application withdrawn. You may submit a new application.";
+  }
+  if (requirements.stage === "complete")
+    return "Attendance details: complete";
+  if (requirements.stage === "draft") {
+    return `Application draft in progress.${registrationPartsText(result3)}`;
+  }
+  if (requirements.stage === "review")
+    return "No action needed while your application is reviewed.";
+  let feedback = "";
+  const rejectionReason = requirements.rejectionReason ?? registration.rejectionReason;
+  if (rejectionReason) {
+    feedback = `
+Review feedback: ${rejectionReason}`;
+  }
+  let nextCommand = "";
+  if (requirements.stage === "accepted") {
+    nextCommand = `
+Next command: chofex confirm`;
+  }
+  let missing2 = "";
+  if (requirements.missing.length > 0) {
+    const items = requirements.missing.map((item) => `  - ${item.field}: ${item.reason}`).join(`
+`);
+    missing2 = `
+Still required:
+${items}`;
+  }
+  return `Next stage: ${requirements.stage}${feedback}${missing2}${nextCommand}`;
+};
+var registrationText = (result3) => [
+  `Registration: ${result3.registration.id}`,
+  `Participant: ${result3.registration.firstName} ${result3.registration.lastName}`,
+  `Status: ${result3.registration.status}`,
+  requirementsText(result3)
+].join(`
+`);
+var createdText = (result3) => {
+  if (result3.registration.status !== "submitted") {
+    return ["Application draft saved.", registrationText(result3)].join(`
+`);
+  }
+  return ["Application submitted successfully.", registrationText(result3)].join(`
+`);
+};
+var requirementsOnlyText = (result3) => requirementsText(result3);
+var badgeText = (result3) => {
+  if (result3.url)
+    return result3.url;
+  return "You don't have a badge yet.";
+};
+
+// src/challenge-commands.ts
+var optionalString = (name, description) => exports_Flag.string(name).pipe(exports_Flag.optional, exports_Flag.withDescription(description));
+var challengeFlag = exports_Flag.string("challenge").pipe(exports_Flag.withDefault(defaultChallengeSlug), exports_Flag.withDescription("Challenge slug (default: black-box)"));
+var sourceFlag = optionalString("source", "JavaScript file exporting function calculateShipping(input)");
+var inputFlag = optionalString("input", "JSON file, or - for stdin");
+var formatFlag = exports_Flag.choice("format", ["table", "json", "csv"]).pipe(exports_Flag.withDefault("table"), exports_Flag.withDescription("Notebook format"));
+var numberFromOption = (value3) => {
+  if (exports_Option.isNone(value3))
+    return;
+  return Number(value3.value);
+};
+var booleanFromOption = (value3) => {
+  if (exports_Option.isNone(value3))
+    return;
+  if (value3.value === "true")
+    return true;
+  if (value3.value === "false")
+    return false;
+};
+var listCommand = exports_Command.make("list", {}, exports_Effect.fn("challengeListCommand")(function* () {
+  const options = yield* root;
+  yield* execute(options.output, listChallenges({ apiUrl: options.apiUrl }), challengeListText);
+})).pipe(exports_Command.withDescription("List mini technical challenges"));
+var showCommand = exports_Command.make("show", { challenge: challengeFlag }, exports_Effect.fn("challengeShowCommand")(function* ({ challenge }) {
+  const options = yield* root;
+  const token = exports_Option.getOrUndefined(options.token);
+  yield* execute(options.output, getChallengeAttempt({ apiUrl: options.apiUrl, token }, challenge), challengeShowText);
+})).pipe(exports_Command.withDescription("Show your Black Box status and remaining budget"));
+var queryCommand = exports_Command.make("query", {
+  challenge: challengeFlag,
+  input: inputFlag,
+  distance: optionalString("distance", "Shipment distance in km"),
+  weight: optionalString("weight", "Shipment weight in kg"),
+  hour: optionalString("hour", "Hour of day, 0-23"),
+  fragile: exports_Flag.choice("fragile", ["true", "false"]).pipe(exports_Flag.optional, exports_Flag.withDescription("Fragile surcharge flag")),
+  express: exports_Flag.choice("express", ["true", "false"]).pipe(exports_Flag.optional, exports_Flag.withDescription("Express surcharge flag"))
+}, exports_Effect.fn("challengeQueryCommand")(function* ({
+  challenge,
+  input,
+  distance: distance3,
+  weight,
+  hour,
+  fragile,
+  express
+}) {
+  const options = yield* root;
+  const token = exports_Option.getOrUndefined(options.token);
+  const operation = exports_Effect.gen(function* () {
+    const shipment = yield* shipmentInput(exports_Option.getOrUndefined(input), {
+      distanceKm: numberFromOption(distance3),
+      weightKg: numberFromOption(weight),
+      hour: numberFromOption(hour),
+      fragile: booleanFromOption(fragile),
+      express: booleanFromOption(express)
+    });
+    return yield* queryChallenge({ apiUrl: options.apiUrl, token }, challenge, shipment);
+  });
+  yield* execute(options.output, operation, challengeQueryText);
+})).pipe(exports_Command.withDescription("Query the undocumented Black Box (uses one request)"), exports_Command.withExamples([
+  {
+    command: "chofex challenge query --distance 10 --weight 3 --hour 14 --fragile false --express false",
+    description: "Spend one oracle query"
+  }
+]));
+var notebookCommand = exports_Command.make("notebook", { challenge: challengeFlag, format: formatFlag }, exports_Effect.fn("challengeNotebookCommand")(function* ({ challenge, format: format6 }) {
+  const options = yield* root;
+  const token = exports_Option.getOrUndefined(options.token);
+  const operation = getChallengeAttempt({ apiUrl: options.apiUrl, token }, challenge);
+  yield* execute(options.output, operation, (attempt) => {
+    if (format6 === "csv")
+      return notebookCsvText(attempt.observations);
+    if (format6 === "json") {
+      return JSON.stringify(attempt.observations, null, 2);
+    }
+    return notebookTableText(attempt.observations);
+  });
+})).pipe(exports_Command.withDescription("Export Black Box observations as a table, JSON, or CSV"));
+var testCommand = exports_Command.make("test", { challenge: challengeFlag, source: sourceFlag }, exports_Effect.fn("challengeTestCommand")(function* ({ challenge, source }) {
+  const options = yield* root;
+  const token = exports_Option.getOrUndefined(options.token);
+  const operation = exports_Effect.gen(function* () {
+    const solution = yield* javascriptSourceFromPath(exports_Option.getOrUndefined(source));
+    return yield* testChallenge({ apiUrl: options.apiUrl, token }, challenge, solution);
+  });
+  yield* execute(options.output, operation, challengeTestText);
+})).pipe(exports_Command.withDescription("Test a replacement against your notebook without consuming an official evaluation"));
+var evaluateCommand = exports_Command.make("evaluate", { challenge: challengeFlag, source: sourceFlag }, exports_Effect.fn("challengeEvaluateCommand")(function* ({ challenge, source }) {
+  const options = yield* root;
+  const token = exports_Option.getOrUndefined(options.token);
+  const operation = exports_Effect.gen(function* () {
+    const solution = yield* javascriptSourceFromPath(exports_Option.getOrUndefined(source));
+    return yield* evaluateChallenge({ apiUrl: options.apiUrl, token }, challenge, solution);
+  });
+  yield* execute(options.output, operation, challengeEvaluateText);
+})).pipe(exports_Command.withDescription("Run an official hidden-set evaluation (limited attempts)"));
+var rankingCommand = exports_Command.make("ranking", { challenge: challengeFlag }, exports_Effect.fn("challengeRankingCommand")(function* ({ challenge }) {
+  const options = yield* root;
+  yield* execute(options.output, getChallengeRanking({ apiUrl: options.apiUrl }, challenge), challengeRankingText);
+})).pipe(exports_Command.withDescription("Show the public read-only challenge ranking"));
+var challengeCommand = exports_Command.make("challenge").pipe(exports_Command.withDescription("Play mini technical challenges and inspect public rankings"), exports_Command.withSubcommands([
+  listCommand,
+  showCommand,
+  queryCommand,
+  notebookCommand,
+  testCommand,
+  evaluateCommand,
+  rankingCommand
+]));
 
 // src/input.ts
-import { readFile as readFile3 } from "node:fs/promises";
+import { readFile as readFile4 } from "node:fs/promises";
 
 // src/profile-username-prompt.ts
 var ansi = {
@@ -59321,11 +60143,11 @@ var applicationDefaultsFromRegistration = (registration) => ({
   portfolioUrl: registration.portfolioUrl,
   teamPreference: registration.teamPreference,
   teamName: registration.teamName,
-  codeOfConductAccepted: true,
-  privacyPolicyAccepted: true,
+  codeOfConductAccepted: registration.codeOfConductAccepted ? true : undefined,
+  privacyPolicyAccepted: registration.privacyPolicyAccepted ? true : undefined,
   mediaConsent: registration.mediaConsent
 });
-var readStdin = async () => {
+var readStdin2 = async () => {
   const chunks = [];
   for await (const chunk of process.stdin) {
     chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
@@ -59336,9 +60158,9 @@ var readJsonInput = (path4) => exports_Effect.tryPromise({
   try: async () => {
     let contents;
     if (path4 === "-") {
-      contents = await readStdin();
+      contents = await readStdin2();
     } else {
-      contents = await readFile3(path4, "utf8");
+      contents = await readFile4(path4, "utf8");
     }
     return JSON.parse(contents);
   },
@@ -59355,7 +60177,7 @@ var validateSemantics = (input, requirements) => {
     issues: requirements
   }));
 };
-var applicationDetailsPrompts = (defaults2) => exports_Prompt.all({
+var identityPrompts = (defaults2) => exports_Prompt.all({
   firstName: requiredText("First name", applicationInputFields.firstName, defaults2.firstName),
   lastName: requiredText("Last name", applicationInputFields.lastName, defaults2.lastName),
   pronouns: optionalText2("Pronouns (optional)", applicationInputFields.pronouns, defaults2.pronouns),
@@ -59371,7 +60193,9 @@ var applicationDetailsPrompts = (defaults2) => exports_Prompt.all({
         return exports_Effect.succeed(value3);
       return validatePromptValue(applicationInputFields.graduationYear, Number(value3)).pipe(exports_Effect.as(value3));
     }
-  }),
+  })
+});
+var experiencePrompts = (defaults2) => exports_Prompt.all({
   shippedProject: requiredText("What have you shipped?", applicationInputFields.shippedProject, defaults2.shippedProject),
   hackathonProject: requiredText("What do you want to ship at the hackathon?", applicationInputFields.hackathonProject, defaults2.hackathonProject),
   bio: requiredText("Short bio", applicationInputFields.bio, defaults2.bio),
@@ -59421,8 +60245,47 @@ var requiredAgreement = exports_Effect.fn("requiredAgreement")(function* (name,
     return true;
   return yield* cliError("REGISTRATION_CANCELLED", "Registration cancelled. Your answers were not submitted.");
 });
+var normalizeDraftFields = (input) => {
+  const normalized = Object.fromEntries(Object.entries(input).filter(([, value3]) => value3 !== undefined).map(([key, value3]) => [key, value3 === "" ? null : value3]));
+  if (typeof input.graduationYear === "string" && input.graduationYear !== "") {
+    normalized.graduationYear = Number(input.graduationYear);
+  }
+  return normalized;
+};
+var collectIdentityPart = (defaults2) => exports_Prompt.run(identityPrompts(defaults2)).pipe(exports_Effect.map(normalizeDraftFields), exports_Effect.mapError(() => cliError("PROMPT_CANCELLED", "Interactive input was cancelled")));
+var collectExperiencePart = (defaults2) => exports_Prompt.run(experiencePrompts(defaults2)).pipe(exports_Effect.map(normalizeDraftFields), exports_Effect.mapError(() => cliError("PROMPT_CANCELLED", "Interactive input was cancelled")));
+var collectTeamPart = (defaults2) => exports_Effect.gen(function* () {
+  const teamPreference = yield* exports_Prompt.run(teamPreferencePrompt(defaults2.teamPreference));
+  let teamName = null;
+  if (teamPreference === "have_team") {
+    teamName = yield* exports_Prompt.run(requiredText("Team name", applicationInputFields.teamName, defaults2.teamName));
+  }
+  return { teamPreference, teamName };
+}).pipe(exports_Effect.mapError((error2) => {
+  if (error2 instanceof CliError2)
+    return error2;
+  return cliError("PROMPT_CANCELLED", "Interactive input was cancelled");
+}));
+var collectAgreementsPart = (publicBaseUrl, defaults2) => exports_Effect.gen(function* () {
+  const codeOfConductAccepted = yield* requiredAgreement("Terms and Code of Conduct", publicDocumentUrl(publicBaseUrl, "/terms"), defaults2.codeOfConductAccepted);
+  const privacyPolicyAccepted = yield* requiredAgreement("Privacy Policy", publicDocumentUrl(publicBaseUrl, "/privacy"), defaults2.privacyPolicyAccepted);
+  const mediaConsent = yield* exports_Prompt.run(exports_Prompt.confirm({
+    message: "Do you consent to appearing in event media? (optional)",
+    initial: defaults2.mediaConsent ?? false
+  }));
+  return {
+    codeOfConductAccepted,
+    privacyPolicyAccepted,
+    mediaConsent
+  };
+}).pipe(exports_Effect.mapError((error2) => {
+  if (error2 instanceof CliError2)
+    return error2;
+  return cliError("PROMPT_CANCELLED", "Interactive input was cancelled");
+}));
 var interactiveApplication = (publicBaseUrl, defaults2) => exports_Effect.gen(function* () {
-  const details = yield* exports_Prompt.run(applicationDetailsPrompts(defaults2));
+  const identity3 = yield* exports_Prompt.run(identityPrompts(defaults2));
+  const experience = yield* exports_Prompt.run(experiencePrompts(defaults2));
   const teamPreference = yield* exports_Prompt.run(teamPreferencePrompt(defaults2.teamPreference));
   let teamName;
   if (teamPreference === "have_team") {
@@ -59435,7 +60298,8 @@ var interactiveApplication = (publicBaseUrl, defaults2) => exports_Effect.gen(fu
     initial: defaults2.mediaConsent ?? false
   }));
   return {
-    ...details,
+    ...identity3,
+    ...experience,
     teamPreference,
     teamName,
     codeOfConductAccepted,
@@ -59522,6 +60386,12 @@ var inputOrInteractive = (path4, interactive) => {
   }));
 };
 var applicationInput = (path4, publicBaseUrl, defaults2 = {}) => inputOrInteractive(path4, interactiveApplication(publicBaseUrl, defaults2)).pipe(exports_Effect.flatMap((input) => decode2(ApplicationInput, input, applicationInputFieldNames)), exports_Effect.flatMap((input) => validateSemantics(input, applicationSemanticRequirements(input))));
+var applicationDraftInput = (path4) => {
+  if (!path4) {
+    return exports_Effect.fail(cliError("INPUT_REQUIRED", "Non-interactive use requires --input <file>, or --input - for stdin"));
+  }
+  return readJsonInput(path4).pipe(exports_Effect.flatMap((input) => decode2(ApplicationDraftInput, input, applicationDraftInputFieldNames)));
+};
 var acceptedDetailsInput = (path4, participationMode, pictures = {}) => inputOrInteractive(path4, interactiveAcceptedDetails(participationMode, pictures)).pipe(exports_Effect.flatMap((input) => decode2(AcceptedDetailsInput, input, acceptedDetailsInputFieldNames)), exports_Effect.flatMap((input) => validateSemantics(input, acceptedDetailsSemanticRequirements(input, participationMode))));
 var picturePathInput = (suppliedPath) => {
   if (suppliedPath)
@@ -59532,121 +60402,8 @@ var picturePathInput = (suppliedPath) => {
   return exports_Prompt.run(requiredText("Path to a JPEG, PNG, or WebP picture (5 MB maximum)", exports_Schema.String.pipe(exports_Schema.check(exports_Schema.isMinLength(1))))).pipe(exports_Effect.mapError(() => cliError("PROMPT_CANCELLED", "Interactive input was cancelled")));
 };
 
-// src/output.ts
-var printJson = (value3) => exports_Effect.sync(() => {
-  process.stdout.write(`${JSON.stringify(value3)}
-`);
-});
-var humanErrorDetails = (details) => {
-  if (details === undefined)
-    return "";
-  if (typeof details === "object" && details !== null && "issues" in details) {
-    const issues = details.issues;
-    if (Array.isArray(issues)) {
-      const decoded = exports_Schema.decodeUnknownResult(exports_Schema.Array(RequirementSchema))(issues);
-      if (exports_Result.isSuccess(decoded) && decoded.success.length > 0) {
-        const lines2 = decoded.success.map((issue) => `  - ${issue.field}: ${issue.reason}`);
-        return `
-Details:
-${lines2.join(`
-`)}`;
-      }
-    }
-    if (typeof issues === "string")
-      return `
-Details:
-${issues}`;
-  }
-  if (typeof details === "string")
-    return `
-Details:
-${details}`;
-  return `
-Details:
-${JSON.stringify(details, null, 2)}`;
-};
-var execute = (mode, operation, human, humanError) => operation.pipe(exports_Effect.flatMap((response) => {
-  if (mode === "json")
-    return printJson(response);
-  return exports_Console.log(human(response.data));
-}), exports_Effect.catch((error2) => {
-  process.exitCode = exitCodeFor(error2);
-  if (mode === "json") {
-    return printJson({
-      version: 1,
-      ok: false,
-      requestId: error2.requestId,
-      error: {
-        code: error2.code,
-        message: error2.message,
-        retryable: error2.retryable,
-        details: error2.details
-      }
-    });
-  }
-  const customMessage = humanError?.(error2);
-  if (customMessage !== undefined) {
-    return exports_Console.error(`${customMessage}
-Request ID: ${error2.requestId}`);
-  }
-  const details = humanErrorDetails(error2.details);
-  return exports_Console.error(`Error [${error2.code}]: ${error2.message}${details}
-Request ID: ${error2.requestId}`);
-}));
-var registrationLookupErrorText = (error2) => {
-  if (error2.code !== "REGISTRATION_NOT_FOUND")
-    return;
-  return `No registration found.
-Next command: chofex register`;
-};
-var requirementsText = (result3) => {
-  const { registration, requirements } = result3;
-  if (registration.status === "withdrawn") {
-    return "Application withdrawn. You may submit a new application.";
-  }
-  if (requirements.stage === "complete")
-    return "Attendance details: complete";
-  if (requirements.stage === "review")
-    return "No action needed while your application is reviewed.";
-  let feedback = "";
-  const rejectionReason = requirements.rejectionReason ?? registration.rejectionReason;
-  if (rejectionReason) {
-    feedback = `
-Review feedback: ${rejectionReason}`;
-  }
-  let nextCommand = "";
-  if (requirements.stage === "accepted") {
-    nextCommand = `
-Next command: chofex confirm`;
-  }
-  let missing2 = "";
-  if (requirements.missing.length > 0) {
-    const items = requirements.missing.map((item) => `  - ${item.field}: ${item.reason}`).join(`
-`);
-    missing2 = `
-Still required:
-${items}`;
-  }
-  return `Next stage: ${requirements.stage}${feedback}${missing2}${nextCommand}`;
-};
-var registrationText = (result3) => [
-  `Registration: ${result3.registration.id}`,
-  `Participant: ${result3.registration.firstName} ${result3.registration.lastName}`,
-  `Status: ${result3.registration.status}`,
-  requirementsText(result3)
-].join(`
-`);
-var createdText = (result3) => ["Application submitted successfully.", registrationText(result3)].join(`
-`);
-var requirementsOnlyText = (result3) => requirementsText(result3);
-var badgeText = (result3) => {
-  if (result3.url)
-    return result3.url;
-  return "You don't have a badge yet.";
-};
-
 // src/picture-upload.ts
-import { readFile as readFile4, stat as stat3 } from "node:fs/promises";
+import { readFile as readFile5, stat as stat3 } from "node:fs/promises";
 import { homedir } from "node:os";
 
 // ../../node_modules/is-node-process/lib/index.mjs
@@ -61270,7 +62027,7 @@ var readPicture = (inputPath) => exports_Effect.tryPromise({
     if (metadata.size < 1 || metadata.size > maximumPictureBytes) {
       throw new Error("Picture must be between 1 byte and 5 MB");
     }
-    const contents = await readFile4(path4);
+    const contents = await readFile5(path4);
     const contentType = detectPictureContentType(contents);
     if (!contentType)
       throw new Error("Picture must be JPEG, PNG, or WebP");
@@ -61309,59 +62066,137 @@ var uploadPicture = exports_Effect.fn("uploadPicture")(function* (options, path4
 });
 
 // src/commands.ts
-var inputFlag = exports_Flag.string("input").pipe(exports_Flag.optional, exports_Flag.withDescription("Read JSON from a file, or use - for stdin"));
+var inputFlag2 = exports_Flag.string("input").pipe(exports_Flag.optional, exports_Flag.withDescription("Read JSON from a file, or use - for stdin"));
 var stageFlag = exports_Flag.choice("stage", ["application", "acceptance"]).pipe(exports_Flag.withDefault("application"));
-var root = exports_Command.make("chofex").pipe(exports_Command.withSharedFlags({
-  apiUrl: exports_Flag.string("api-url").pipe(exports_Flag.withDefault(config.apiUrl), exports_Flag.withDescription("Registration API base URL")),
-  output: exports_Flag.choice("output", ["human", "json"]).pipe(exports_Flag.withDefault("human"), exports_Flag.withDescription("Output format")),
-  token: exports_Flag.string("token").pipe(exports_Flag.optional, exports_Flag.withDescription("Clerk OAuth token (prefer CHOFEX_TOKEN to avoid shell history)"))
-}), exports_Command.withDescription("Register for and manage your Chofex hackathon application"));
-var registerCommand = exports_Command.make("register", { input: inputFlag }, exports_Effect.fn("registerCommand")(function* ({ input }) {
+var submitFlag = exports_Flag.boolean("submit").pipe(exports_Flag.withDefault(false), exports_Flag.withDescription("Submit the saved application draft"));
+var currentRegistration = (client) => getRegistration(client).pipe(exports_Effect.map(exports_Option.some), exports_Effect.catch((error2) => {
+  if (error2.code === "REGISTRATION_NOT_FOUND") {
+    return exports_Effect.succeed(exports_Option.none());
+  }
+  return exports_Effect.fail(error2);
+}));
+var rejectIfApplicationLocked = exports_Effect.fn("rejectIfApplicationLocked")(function* (current) {
+  if (exports_Option.isNone(current))
+    return;
+  const { registration, requirements } = current.value.data;
+  const { status } = registration;
+  const registrationAlreadyExists = status === "submitted" || status === "under_review" || status === "waitlisted" || status === "accepted";
+  if (!registrationAlreadyExists)
+    return;
+  let message = "Already registered. Wait for approval.";
+  if (status === "accepted") {
+    message = "Already accepted. Your registration is complete.";
+    if (requirements.stage === "accepted") {
+      message = "Already accepted. Run `chofex confirm` to complete your registration.";
+    }
+  }
+  return yield* cliError("ACTIVE_APPLICATION_EXISTS", message, false, {
+    currentStatus: status
+  });
+});
+var registerCommand = exports_Command.make("register", { input: inputFlag2, submit: submitFlag }, exports_Effect.fn("registerCommand")(function* ({ input, submit }) {
   const options = yield* root;
   const operation = exports_Effect.gen(function* () {
     const token = exports_Option.getOrUndefined(options.token);
     const client = { apiUrl: options.apiUrl, token };
-    const current = yield* getRegistration(client).pipe(exports_Effect.map(exports_Option.some), exports_Effect.catch((error2) => {
-      if (error2.code === "REGISTRATION_NOT_FOUND") {
-        return exports_Effect.succeed(exports_Option.none());
-      }
-      return exports_Effect.fail(error2);
-    }));
-    if (exports_Option.isSome(current)) {
-      const { registration, requirements } = current.value.data;
-      const { status } = registration;
-      const registrationAlreadyExists = status === "submitted" || status === "under_review" || status === "waitlisted" || status === "accepted";
-      if (registrationAlreadyExists) {
-        let message = "Already registered. Wait for approval.";
-        if (status === "accepted") {
-          message = "Already accepted. Your registration is complete.";
-          if (requirements.stage === "accepted") {
-            message = "Already accepted. Run `chofex confirm` to complete your registration.";
-          }
-        }
-        return yield* cliError("ACTIVE_APPLICATION_EXISTS", message, false, {
-          currentStatus: status
-        });
+    const current = yield* currentRegistration(client);
+    yield* rejectIfApplicationLocked(current);
+    if (exports_Option.isSome(input) || submit) {
+      if (exports_Option.isSome(input)) {
+        const body = yield* applicationDraftInput(input.value);
+        const saved = yield* saveRegistrationDraft(client, body);
+        if (submit)
+          return yield* submitRegistration(client);
+        return saved;
       }
+      return yield* submitRegistration(client);
     }
-    let applicationDefaults;
-    if (exports_Option.isSome(current) && current.value.data.registration.status === "rejected") {
-      applicationDefaults = applicationDefaultsFromRegistration(current.value.data.registration);
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+      return yield* cliError("INPUT_REQUIRED", "Non-interactive use requires --input <file>, or --input - for stdin");
     }
-    const body = yield* applicationInput(exports_Option.getOrUndefined(input), config.publicSiteUrl, applicationDefaults);
-    return yield* register(client, body);
+    return yield* interactiveRegister(client, current);
+  });
+  yield* execute(options.output, operation, (result3) => {
+    if (result3.registration.status === "submitted")
+      return createdText(result3);
+    return draftSavedText(result3);
   });
-  yield* execute(options.output, operation, createdText);
-})).pipe(exports_Command.withDescription("Submit an application, or apply again after a rejection"), exports_Command.withExamples([
+})).pipe(exports_Command.withDescription("Save an application draft in parts, then submit it for review"), exports_Command.withExamples([
   {
     command: "chofex register",
-    description: "Complete the application interactively"
+    description: "Fill or resume application parts interactively"
   },
   {
     command: "chofex --output json register --input application.json",
-    description: "Submit an application from an agent or script"
+    description: "Save a draft from JSON without submitting it"
+  },
+  {
+    command: "chofex register --submit",
+    description: "Submit a completed draft"
   }
 ]));
+var interactiveRegister = (client, initial) => exports_Effect.gen(function* () {
+  let latest = exports_Option.isSome(initial) ? initial.value.data : undefined;
+  while (true) {
+    if (latest) {
+      yield* exports_Console.log(registrationPartsText(latest));
+    } else {
+      yield* exports_Console.log("No draft yet. Choose a part to start. Progress is saved on the server.");
+    }
+    let defaults2 = {};
+    if (latest) {
+      defaults2 = applicationDefaultsFromRegistration(latest.registration);
+    }
+    const choice4 = yield* exports_Prompt.run(exports_Prompt.select({
+      message: "What would you like to do?",
+      choices: [
+        { title: "Edit identity", value: "identity" },
+        { title: "Edit experience", value: "experience" },
+        { title: "Edit team", value: "team" },
+        {
+          title: "Black Box challenge status",
+          value: "challenges"
+        },
+        { title: "Review agreements", value: "agreements" },
+        { title: "Submit application", value: "submit" },
+        { title: "Save and exit", value: "exit" }
+      ]
+    })).pipe(exports_Effect.mapError(() => cliError("PROMPT_CANCELLED", "Interactive input was cancelled")));
+    if (choice4 === "exit") {
+      if (!latest) {
+        latest = (yield* saveRegistrationDraft(client, {})).data;
+      }
+      return {
+        version: 1,
+        ok: true,
+        requestId: crypto.randomUUID(),
+        data: latest
+      };
+    }
+    if (choice4 === "submit") {
+      return yield* submitRegistration(client);
+    }
+    if (choice4 === "challenges") {
+      const attempt = yield* getChallengeAttempt(client, "black-box");
+      yield* exports_Console.log(`
+${challengeShowText(attempt.data)}
+`);
+      latest = (yield* getRegistration(client)).data;
+      continue;
+    }
+    let partBody = {};
+    if (choice4 === "identity") {
+      partBody = yield* collectIdentityPart(defaults2);
+    } else if (choice4 === "experience") {
+      partBody = yield* collectExperiencePart(defaults2);
+    } else if (choice4 === "team") {
+      partBody = yield* collectTeamPart(defaults2);
+    } else {
+      partBody = yield* collectAgreementsPart(config.publicSiteUrl, defaults2);
+    }
+    latest = (yield* saveRegistrationDraft(client, partBody)).data;
+  }
+});
 var statusCommand = exports_Command.make("status", {}, exports_Effect.fn("statusCommand")(function* () {
   const options = yield* root;
   const operation = exports_Effect.gen(function* () {
@@ -61385,7 +62220,7 @@ var badgeCommand = exports_Command.make("badge", {}, exports_Effect.fn("badgeCom
   yield* execute(options.output, operation, badgeText);
 })).pipe(exports_Command.withDescription("Show your generated participant badge"));
 var confirmCommand = exports_Command.make("confirm", {
-  input: inputFlag,
+  input: inputFlag2,
   picture: exports_Flag.string("picture").pipe(exports_Flag.optional, exports_Flag.withDescription("Path to a JPEG, PNG, or WebP picture (5 MB max)"))
 }, exports_Effect.fn("confirmCommand")(function* ({ input, picture }) {
   const options = yield* root;
@@ -61475,7 +62310,7 @@ var inputValidation = (stage, path4) => {
   }
   return acceptedDetailsInput(path4, "in_person").pipe(exports_Effect.asVoid);
 };
-var validateCommand = exports_Command.make("validate", { input: inputFlag, stage: stageFlag }, exports_Effect.fn("validateCommand")(function* ({ input, stage }) {
+var validateCommand = exports_Command.make("validate", { input: inputFlag2, stage: stageFlag }, exports_Effect.fn("validateCommand")(function* ({ input, stage }) {
   const options = yield* root;
   const operation = inputValidation(stage, exports_Option.getOrUndefined(input)).pipe(exports_Effect.map(() => ({
     version: 1,
@@ -61547,7 +62382,8 @@ var command = root.pipe(exports_Command.withSubcommands([
   requirementsCommand,
   badgeCommand,
   confirmCommand,
-  schemaCommand
+  schemaCommand,
+  challengeCommand
 ]));
 
 // src/index.ts