chofex-cli 0.1.173 → 0.1.178

package/README.md

@@ -24,17 +24,32 @@ chofex challenge notebook
 chofex challenge test --source ./shipping.js
 chofex challenge evaluate --source ./shipping.js
 chofex challenge ranking
+chofex challenge init --challenge broken-agent
+cd broken-agent && npm test
+chofex challenge test --challenge broken-agent --source ./scheduler.js
+chofex challenge evaluate --challenge broken-agent --source ./scheduler.js
+chofex challenge ranking --challenge broken-agent
 chofex confirm
+chofex badge
+chofex badge regenerate
 ```
 
 `chofex update` and `chofex upgrade` are interchangeable; both update the CLI
 to the latest published version.
 
+Las copias instaladas también consultan npm cada vez que se inicia `chofex` e
+instalan una versión publicada más reciente antes de ejecutar el comando. Si
+npm o la red no están disponibles temporalmente, se continúa con la versión
+actual. Usa `CHOFEX_AUTO_UPDATE=0` para desactivar esta comprobación.
+
 `chofex register` collects and submits an application with full name, role,
 optional phone number, bio, portfolio URL, shipped project, LinkedIn and GitHub
 URLs, and Terms and Conditions. Use `--input` to submit a completed JSON
 application.
-The Black Box does not block submission, but every challenge winner must submit
+After attendance confirmation, `chofex badge regenerate` updates the public
+badge name, one-line description, picture, and QR destination without changing
+the submitted application.
+The technical challenges do not block submission, but every challenge winner must submit
 an application before being accepted. Top results receive a direct pass; other
 scores give organizers another review metric.
 

package/dist/index.js

@@ -27645,6 +27645,7 @@ var require_throttleit = __commonJS((exports, module) => {
 
 // src/index.ts
 import { readFileSync } from "node:fs";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 // ../../node_modules/@effect/platform-node/dist/NodeRuntime.js
 var exports_NodeRuntime = {};
 __export(exports_NodeRuntime, {
@@ -58552,6 +58553,7 @@ var runWith2 = (command, config) => {
 };
 // ../../packages/challenges-contract/src/index.ts
 var blackBoxChallengeSlug = "black-box";
+var brokenAgentChallengeSlug = "broken-agent";
 var challengeCatalog = [
   {
     slug: blackBoxChallengeSlug,
@@ -58573,21 +58575,21 @@ var challengeCatalog = [
     solutionKind: "javascript_source"
   },
   {
-    slug: "last-mile",
+    slug: brokenAgentChallengeSlug,
     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",
+    theme: "Broken Agent",
+    title: "The Scheduler",
+    summary: "Take a plausible AI-generated job scheduler whose public tests already pass and harden it against production reality.",
+    coreSkill: "Production correctness & reliability",
+    format: "accuracy",
+    formatLabel: "Production readiness score",
     opensAt: "2026-09-25T05:00:00.000Z",
     queryLimit: 0,
-    evaluationLimit: 3,
-    hiddenSampleSize: 1,
-    playable: false,
-    solutionKind: "json_plan"
+    evaluationLimit: 5,
+    hiddenSampleSize: 100,
+    playable: true,
+    solutionKind: "javascript_source"
   },
   {
     slug: "make-it-fast",
@@ -58690,7 +58692,7 @@ var formatChallengeOpeningInPeru = (opensAt) => {
 var challengeOpeningNotice = (title, opensAt) => `${title} opens ${formatChallengeOpeningInPeru(opensAt)}. Queries and evaluations are disabled until then; no attempts will be consumed.`;
 var ChallengeSlugSchema = exports_Schema.Literals([
   "black-box",
-  "last-mile",
+  "broken-agent",
   "make-it-fast",
   "power-grid",
   "agent-arena"
@@ -58718,7 +58720,38 @@ var ChallengeScoreSchema = exports_Schema.Struct({
   sampleSize: exports_Schema.Number,
   meanError: exports_Schema.Number,
   queriesUsed: exports_Schema.Number,
-  runtimeMs: exports_Schema.Number
+  runtimeMs: exports_Schema.Number,
+  evaluationsUsed: exports_Schema.optional(exports_Schema.Number),
+  breakdown: exports_Schema.optional(exports_Schema.Struct({
+    coreBehavior: exports_Schema.Struct({
+      earned: exports_Schema.Number,
+      available: exports_Schema.Number
+    }),
+    persistence: exports_Schema.Struct({
+      earned: exports_Schema.Number,
+      available: exports_Schema.Number
+    }),
+    concurrency: exports_Schema.Struct({
+      earned: exports_Schema.Number,
+      available: exports_Schema.Number
+    }),
+    failureRecovery: exports_Schema.Struct({
+      earned: exports_Schema.Number,
+      available: exports_Schema.Number
+    }),
+    idempotency: exports_Schema.Struct({
+      earned: exports_Schema.Number,
+      available: exports_Schema.Number
+    }),
+    regressionSafety: exports_Schema.Struct({
+      earned: exports_Schema.Number,
+      available: exports_Schema.Number
+    }),
+    performance: exports_Schema.Struct({
+      earned: exports_Schema.Number,
+      available: exports_Schema.Number
+    })
+  }))
 });
 var ChallengeProgressStatus = exports_Schema.Literals([
   "not_started",
@@ -58785,7 +58818,8 @@ var ChallengeEvaluationSummarySchema = exports_Schema.Struct({
   shareCode: exports_Schema.String,
   rank: exports_Schema.optional(exports_Schema.Number),
   percentile: exports_Schema.optional(exports_Schema.Number),
-  createdAt: exports_Schema.String
+  createdAt: exports_Schema.String,
+  breakdown: exports_Schema.optional(ChallengeScoreSchema.fields.breakdown)
 });
 var ChallengeAttemptViewSchema = exports_Schema.Struct({
   challenge: ChallengeCatalogItemSchema,
@@ -58802,6 +58836,7 @@ var ChallengeQueryResultSchema = exports_Schema.Struct({
   queriesLimit: exports_Schema.Number
 });
 var ChallengeLocalTestResultSchema = exports_Schema.Struct({
+  kind: exports_Schema.optional(exports_Schema.Literals(["black_box", "broken_agent"])),
   matchedObservations: exports_Schema.Number,
   observationCount: exports_Schema.Number,
   accuracy: exports_Schema.Number,
@@ -58827,7 +58862,8 @@ var ChallengeEvaluationResultSchema = exports_Schema.Struct({
   evaluationsRemaining: exports_Schema.Number,
   evaluationsLimit: exports_Schema.Number,
   rankingPath: exports_Schema.String,
-  shareText: exports_Schema.String
+  shareText: exports_Schema.String,
+  breakdown: exports_Schema.optional(ChallengeScoreSchema.fields.breakdown)
 });
 var ChallengeRankingEntrySchema = exports_Schema.Struct({
   rank: exports_Schema.Number,
@@ -59156,10 +59192,25 @@ var BadgeStatus = exports_Schema.Literals([
   "completed",
   "failed"
 ]);
+var BadgeProfileSchema = exports_Schema.Struct({
+  fullName: nonBlank(200),
+  oneLiner: nonBlank(30),
+  linkUrl: url,
+  placement: exports_Schema.String
+});
 var BadgeResultSchema = exports_Schema.Struct({
   status: BadgeStatus,
-  url: exports_Schema.optional(exports_Schema.String)
+  url: exports_Schema.optional(exports_Schema.String),
+  profile: exports_Schema.optional(BadgeProfileSchema)
 });
+var badgeRegenerationInputFields = {
+  fullName: nonBlank(200),
+  oneLiner: nonBlank(30),
+  linkUrl: url,
+  pictureSource: exports_Schema.optional(PictureSource)
+};
+var BadgeRegenerationInput = exports_Schema.Struct(badgeRegenerationInputFields);
+var badgeRegenerationInputFieldNames = Object.keys(badgeRegenerationInputFields);
 var PictureUploadSchema = exports_Schema.Struct({
   url: exports_Schema.String,
   contentType: PictureContentType,
@@ -59697,6 +59748,7 @@ var register = (options, input) => request3(options, "/api/v1/registrations", {
 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 regenerateBadge = (options, input) => request3(options, "/api/v1/badge", { method: "PATCH", body: JSON.stringify(input) }, 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);
@@ -59709,6 +59761,7 @@ var getChallengeRanking = (options, slug) => publicRequest(options, `/api/v1/cha
 
 // src/challenge-input.ts
 import { readFile as readFile3 } from "node:fs/promises";
+var defaultChallengeSlug = "black-box";
 var readStdin = async () => {
   const chunks = [];
   for await (const chunk of process.stdin) {
@@ -59724,9 +59777,12 @@ var readTextFile = (path4) => exports_Effect.tryPromise({
   },
   catch: (error2) => cliError("INVALID_INPUT_FILE", `Could not read ${path4}: ${String(error2)}`)
 });
-var javascriptSourceFromPath = (path4) => {
+var javascriptSourceFromPath = (path4, challenge = defaultChallengeSlug) => {
   if (!path4) {
-    return exports_Effect.fail(cliError("SOURCE_REQUIRED", "Pass --source <file.js> with function calculateShipping(input)"));
+    let expectedFunction = "calculateShipping(input)";
+    if (challenge === "broken-agent")
+      expectedFunction = "createScheduler(dependencies)";
+    return exports_Effect.fail(cliError("SOURCE_REQUIRED", `Pass --source <file.js> with function ${expectedFunction}`));
   }
   return readTextFile(path4).pipe(exports_Effect.map((source) => ({ kind: "javascript_source", source })));
 };
@@ -59778,7 +59834,6 @@ var shipmentInput = (path4, flags) => {
   }
   return interactiveShipment();
 };
-var defaultChallengeSlug = "black-box";
 
 // src/brand.ts
 var eventName = "Hack the Andes";
@@ -59834,6 +59889,32 @@ var challengeShowText = (attempt) => {
   const { challenge, progress } = attempt;
   const queriesRemaining = progress.queriesLimit - progress.queriesUsed;
   const evaluationsRemaining = progress.evaluationsLimit - progress.evaluationsUsed;
+  if (challenge.slug === "broken-agent") {
+    let caseStatus2 = "READY TO AUDIT";
+    if (attempt.latestEvaluation)
+      caseStatus2 = "EVALUATED";
+    const lines3 = [
+      `${challenge.title.toUpperCase()} — CASE #${challenge.code}`,
+      challenge.summary,
+      "",
+      `CASE STATUS: ${caseStatus2}`,
+      "",
+      "The public tests are green. Your job is to make the scheduler trustworthy under production conditions.",
+      "AI tools are allowed.",
+      "",
+      `Evaluations    ${evaluationsRemaining} / ${progress.evaluationsLimit} remaining`
+    ];
+    if (progress.bestAccuracy !== undefined) {
+      lines3.push("", `Best score     ${percent(progress.bestAccuracy)}`);
+      if (progress.rank !== undefined)
+        lines3.push(`Rank           #${progress.rank}`);
+      if (progress.shareCode)
+        lines3.push(`Share code     #${progress.shareCode}`);
+    }
+    lines3.push("", "YOUR NEXT MOVE", "Read the contract, audit scheduler.js, and keep the visible suite green.", "  cd broken-agent && npm test", "  chofex challenge test --challenge broken-agent --source ./broken-agent/scheduler.js");
+    return lines3.join(`
+`);
+  }
   let evidence = `${attempt.observations.length} observations`;
   if (attempt.observations.length === 1)
     evidence = "1 observation";
@@ -59996,6 +60077,26 @@ var notebookCsvText = (observations) => {
 `);
 };
 var challengeTestText = (result3) => {
+  if (result3.kind === "broken_agent") {
+    const lines3 = [
+      "PUBLIC SUITE — BROKEN AGENT",
+      `${result3.matchedObservations} / ${result3.observationCount} visible behaviors passing`
+    ];
+    if (result3.accuracy === 1) {
+      lines3.push("", "Everything passes.", "Unfortunately, that does not mean the scheduler is production-correct.", "Reason about concurrency, restarts, failures, and idempotency before evaluating.", "", "Next: spend one official evaluation when you would ship it", "  chofex challenge evaluate --challenge broken-agent --source ./broken-agent/scheduler.js");
+      return lines3.join(`
+`);
+    }
+    if (result3.mismatches.length > 0) {
+      lines3.push("", "Visible failures:");
+      for (const mismatch of result3.mismatches) {
+        lines3.push(`  ${String(mismatch.actual)}`);
+      }
+    }
+    lines3.push("", "Fix the public regressions before using an official evaluation.");
+    return lines3.join(`
+`);
+  }
   let verdict = "KEEP WORKING";
   if (result3.accuracy === 1)
     verdict = "NOTEBOOK MATCHED";
@@ -60022,6 +60123,34 @@ var challengeTestText = (result3) => {
 `);
 };
 var challengeEvaluateText = (result3) => {
+  if (result3.breakdown) {
+    const capabilityLines = [
+      ["Core behavior", result3.breakdown.coreBehavior],
+      ["Persistence", result3.breakdown.persistence],
+      ["Concurrency", result3.breakdown.concurrency],
+      ["Failure recovery", result3.breakdown.failureRecovery],
+      ["Idempotency", result3.breakdown.idempotency],
+      ["Regression safety", result3.breakdown.regressionSafety],
+      ["Performance", result3.breakdown.performance]
+    ];
+    const lines3 = [
+      "OFFICIAL VERDICT — BROKEN AGENT — PRODUCTION READINESS",
+      `Score               ${(result3.accuracy * 100).toFixed(2)} / ${result3.sampleSize}`,
+      `Runtime             ${result3.runtimeMs} ms`,
+      "",
+      "Capability scores",
+      ...capabilityLines.map(([label, score]) => `${label.padEnd(20)}${score.earned.toFixed(2)} / ${score.available}`)
+    ];
+    if (result3.rank !== undefined) {
+      lines3.push(`Rank                 #${result3.rank}`);
+    }
+    lines3.push(`Official evaluations remaining ${result3.evaluationsRemaining} / ${result3.evaluationsLimit}`, "", result3.shareText, "", "Next: inspect the leaderboard", "  chofex challenge ranking --challenge broken-agent");
+    if (result3.evaluationsRemaining > 0) {
+      lines3.push("", "The evaluator reports capabilities, not individual hidden cases. Reason before submitting again.", "  chofex challenge test --challenge broken-agent --source ./broken-agent/scheduler.js");
+    }
+    return lines3.join(`
+`);
+  }
   const lines2 = [
     "OFFICIAL VERDICT — BLACK BOX REPLICATION",
     `Accuracy            ${percent(result3.accuracy)}`,
@@ -60050,6 +60179,18 @@ var challengeRankingText = (ranking, now3 = new Date) => {
   if (ranking.entries.length === 0) {
     lines2.push("No official evaluations yet.");
     return lines2.join(`
+`);
+  }
+  if (ranking.challenge.slug === "broken-agent") {
+    lines2.push("Rank  Score       Points       Runtime  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 points = `${entry.exactCount}/${entry.sampleSize}`.padStart(11, " ");
+      const runtime = `${entry.runtimeMs}ms`.padStart(8, " ");
+      lines2.push(`${rank}  ${accuracy}  ${points}  ${runtime}  ${entry.displayName} #${entry.shareCode}`);
+    }
+    return lines2.join(`
 `);
   }
   lines2.push("Rank  Accuracy  Exact        Queries  Name");
@@ -60086,7 +60227,216 @@ var registrationPartsText = (result3) => {
 };
 
 // src/challenge-scaffold.ts
-import { writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir2, writeFile as writeFile3 } from "node:fs/promises";
+
+// ../../packages/challenges-contract/src/broken-agent.ts
+var brokenAgentScaffoldDirectory = "broken-agent";
+var brokenAgentSolutionPath = `${brokenAgentScaffoldDirectory}/scheduler.js`;
+var brokenAgentPackageJson = `${JSON.stringify({
+  name: "broken-agent-challenge",
+  private: true,
+  type: "commonjs",
+  scripts: { test: "node --test scheduler.test.js" }
+}, null, 2)}
+`;
+var brokenAgentStarterSource = `/**
+ * Broken Agent — The Scheduler
+ *
+ * A coding agent implemented this scheduler and declared the feature complete.
+ * Every public test passes. The implementation is not production-correct.
+ * Keep the createScheduler interface intact and harden the implementation.
+ */
+function createScheduler({ store, clock, execute }) {
+  return {
+    async schedule(input) {
+      const job = { ...input, status: "pending" };
+      await store.transaction((tx) => tx.put(job));
+      return job;
+    },
+
+    async cancel(id) {
+      return store.transaction((tx) => {
+        const job = tx.get(id);
+        if (!job || job.status !== "pending") return false;
+        tx.put({ ...job, status: "cancelled" });
+        return true;
+      });
+    },
+
+    async list() {
+      return store.transaction((tx) => tx.list());
+    },
+
+    async runDue() {
+      const now = clock.now().getTime();
+      const jobs = await store.transaction((tx) => tx.list());
+      for (const job of jobs) {
+        if (job.status !== "pending" || Date.parse(job.runAt) > now) continue;
+        await execute(job);
+        await store.transaction((tx) =>
+          tx.put({ ...job, status: "completed" }),
+        );
+      }
+    },
+  };
+}
+
+module.exports = { createScheduler };
+`;
+var brokenAgentReadme = `# Broken Agent — The Scheduler
+
+> A coding agent was asked to implement a feature. It says it is done. It is
+> not. Your job is to ship it.
+
+The repository starts with all public tests passing. Repair \`scheduler.js\`
+without changing its exported \`createScheduler(dependencies)\` interface.
+
+## Commands
+
+\`\`\`sh
+npm test
+chofex challenge test --challenge broken-agent --source ./broken-agent/scheduler.js
+chofex challenge evaluate --challenge broken-agent --source ./broken-agent/scheduler.js
+\`\`\`
+
+Local and public tests are unlimited. You have **5 official evaluations**
+against hidden production scenarios. AI tools are explicitly allowed.
+
+## Public contract
+
+\`createScheduler({ store, clock, execute, workerId })\` returns:
+
+- \`schedule({ id, runAt, payload })\`
+- \`cancel(id)\`
+- \`list()\`
+- \`runDue()\`
+
+### Jobs
+
+- \`id\` matches \`^[A-Za-z0-9_-]{1,64}$\`.
+- \`runAt\` is an ISO-8601 timestamp with an explicit timezone.
+- \`payload\` is JSON-serializable.
+- Scheduling an identical job ID is idempotent. Reusing an ID for different
+  work must reject without changing the original job.
+- Past timestamps are valid and become due immediately.
+- \`list()\` returns jobs ordered by \`runAt\`, then \`id\`.
+
+### Durability and concurrency
+
+- The supplied store survives scheduler instances and process restarts.
+- Several workers may call \`runDue()\` concurrently against the same store.
+- A worker claim lasts 30 seconds. Another worker may reclaim the job when
+  \`clock.now()\` reaches that lease deadline.
+- A pending job may be cancelled. A running or terminal job may not.
+- Failed executions retry, without preventing other due jobs from running.
+- A job becomes \`failed\` after 3 unsuccessful attempts.
+- The execution adapter applies effects idempotently by job ID. A worker may
+  stop after the effect is applied but before completion is recorded; retrying
+  must eventually complete the job without duplicating the effect.
+
+The store exposes only \`transaction(action)\`. Inside an action, \`tx\`
+provides synchronous \`get(id)\`, \`put(job)\`, \`delete(id)\`, and \`list()\`
+operations. Transactions are serialized. Do not keep a transaction open while
+executing a job.
+
+\`clock.now()\` returns a \`Date\`. \`execute(job)\` returns a promise.
+
+## Evaluation
+
+The hidden evaluator checks the published contract under deterministic
+concurrency, restart, failure, idempotency, compatibility, and load scenarios.
+It reports capability-level scores, not individual hidden-test failures.
+
+- Core behavior: 10 points
+- Persistence: 15 points
+- Concurrency: 20 points
+- Failure recovery: 20 points
+- Idempotency: 15 points
+- Regression safety: 15 points
+- Performance: 5 points, available only when the load jobs complete correctly
+
+Ranking order is total score, fewer official evaluations used, runtime, then
+official submission time. Submission time is only the final tie-breaker.
+`;
+var brokenAgentPublicTestSource = `const test = require("node:test");
+const assert = require("node:assert/strict");
+const { createScheduler } = require("./scheduler.js");
+
+const clone = (value) => {
+  if (value === undefined) return undefined;
+  return JSON.parse(JSON.stringify(value));
+};
+
+class MemoryStore {
+  constructor() {
+    this.jobs = new Map();
+    this.tail = Promise.resolve();
+  }
+
+  transaction(action) {
+    const run = this.tail.then(() => action({
+      get: (id) => clone(this.jobs.get(id)),
+      put: (job) => {
+        this.jobs.set(job.id, clone(job));
+        return clone(job);
+      },
+      delete: (id) => this.jobs.delete(id),
+      list: () => [...this.jobs.values()].map(clone),
+    }));
+    this.tail = run.then(() => undefined, () => undefined);
+    return run;
+  }
+}
+
+const setup = () => {
+  const store = new MemoryStore();
+  const now = new Date("2026-10-17T15:00:00.000Z");
+  const executed = [];
+  const scheduler = createScheduler({
+    store,
+    clock: { now: () => new Date(now) },
+    execute: async (job) => executed.push(job.id),
+    workerId: "public-worker",
+  });
+  return { store, scheduler, executed };
+};
+
+const job = (id, runAt = "2026-10-17T15:00:00.000Z") => ({
+  id,
+  runAt,
+  payload: { message: id },
+});
+
+test("schedules and lists a job", async () => {
+  const { scheduler } = setup();
+  await scheduler.schedule(job("job-1"));
+  assert.equal((await scheduler.list()).length, 1);
+});
+
+test("executes a due job", async () => {
+  const { scheduler, executed } = setup();
+  await scheduler.schedule(job("job-1"));
+  await scheduler.runDue();
+  assert.deepEqual(executed, ["job-1"]);
+});
+
+test("does not execute a future job", async () => {
+  const { scheduler, executed } = setup();
+  await scheduler.schedule(job("future", "2026-10-17T16:00:00.000Z"));
+  await scheduler.runDue();
+  assert.deepEqual(executed, []);
+});
+
+test("cancels a pending job", async () => {
+  const { scheduler, executed } = setup();
+  await scheduler.schedule(job("cancel-me"));
+  assert.equal(await scheduler.cancel("cancel-me"), true);
+  await scheduler.runDue();
+  assert.deepEqual(executed, []);
+});
+`;
+
+// src/challenge-scaffold.ts
 var solutionPath = "shipping.js";
 var starterSource = `/**
  * The Shipping Machine
@@ -60107,7 +60457,36 @@ function calculateShipping(input) {
   return 0;
 }
 `;
-var createChallengeScaffold = exports_Effect.fn("createChallengeScaffold")(function* () {
+var createChallengeScaffold = exports_Effect.fn("createChallengeScaffold")(function* (challengeSlug = "black-box") {
+  const challenge = challengeBySlug(challengeSlug);
+  if (!challenge?.playable) {
+    return yield* exports_Effect.fail(cliError("CHALLENGE_NOT_AVAILABLE", `Challenge ${challengeSlug} is not available`));
+  }
+  if (challengeSlug === "broken-agent") {
+    const status2 = yield* exports_Effect.tryPromise({
+      try: async () => {
+        await mkdir2(brokenAgentScaffoldDirectory);
+        await Promise.all([
+          writeFile3(brokenAgentSolutionPath, brokenAgentStarterSource, "utf8"),
+          writeFile3(`${brokenAgentScaffoldDirectory}/scheduler.test.js`, brokenAgentPublicTestSource, "utf8"),
+          writeFile3(`${brokenAgentScaffoldDirectory}/README.md`, brokenAgentReadme, "utf8"),
+          writeFile3(`${brokenAgentScaffoldDirectory}/package.json`, brokenAgentPackageJson, "utf8")
+        ]);
+        return "created";
+      },
+      catch: (error2) => error2
+    }).pipe(exports_Effect.catch((error2) => {
+      if (exports_Predicate.hasProperty(error2, "code") && error2.code === "EEXIST") {
+        return exports_Effect.succeed("exists");
+      }
+      return exports_Effect.fail(cliError("SCAFFOLD_FAILED", `Could not create ${brokenAgentScaffoldDirectory}: ${String(error2)}`));
+    }));
+    return {
+      challenge: challengeSlug,
+      path: brokenAgentScaffoldDirectory,
+      status: status2
+    };
+  }
   const status = yield* exports_Effect.tryPromise({
     try: async () => {
       await writeFile3(solutionPath, starterSource, {
@@ -60123,14 +60502,19 @@ var createChallengeScaffold = exports_Effect.fn("createChallengeScaffold")(funct
     }
     return exports_Effect.fail(cliError("SCAFFOLD_FAILED", `Could not create ${solutionPath}: ${String(error2)}`));
   }));
-  return { path: solutionPath, status };
+  return { challenge: challengeSlug, path: solutionPath, status };
 });
 
 // src/cli-root.ts
+var rootValueFlagNames = {
+  apiUrl: "api-url",
+  output: "output",
+  token: "token"
+};
 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("Chofex 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)"))
+  apiUrl: exports_Flag.string(rootValueFlagNames.apiUrl).pipe(exports_Flag.withDefault(config.apiUrl), exports_Flag.withDescription("Chofex API base URL")),
+  output: exports_Flag.choice(rootValueFlagNames.output, ["human", "json"]).pipe(exports_Flag.withDefault("human"), exports_Flag.withDescription("Output format")),
+  token: exports_Flag.string(rootValueFlagNames.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 ${eventName} application`));
 
 // src/output.ts
@@ -60252,7 +60636,13 @@ var requirementsOnlyText = (result3) => requirementsText(result3);
 var badgeText = (result3) => {
   if (result3.url)
     return result3.url;
-  return "You don't have a badge yet.";
+  if (result3.status === "pending" || result3.status === "running") {
+    return "Tu carnet se está generando.";
+  }
+  if (result3.status === "failed") {
+    return "No se pudo generar tu carnet. Ejecuta `chofex badge regenerate` para intentarlo de nuevo.";
+  }
+  return "Todavía no tienes un carnet.";
 };
 
 // src/challenge-commands.ts
@@ -60364,7 +60754,7 @@ var challengeQuickstartText = (participationState, launchNotice) => {
 };
 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 defining function calculateShipping(input)");
+var sourceFlag = optionalString("source", "JavaScript challenge solution file");
 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) => {
@@ -60381,6 +60771,30 @@ var booleanFromOption = (value3) => {
     return false;
 };
 var challengeInitText = (result3) => {
+  if (result3.challenge === "broken-agent") {
+    if (result3.status === "exists") {
+      return [
+        `${result3.path} already exists. Left it unchanged.`,
+        "",
+        "Next: keep hardening your scheduler, then run the public tests",
+        `  cd ${result3.path} && npm test`,
+        `  chofex challenge test --challenge broken-agent --source ./${result3.path}/scheduler.js`
+      ].join(`
+`);
+    }
+    return [
+      `Created ${result3.path}`,
+      "The previous agent says the scheduler is done. Everything passes.",
+      "Unfortunately, the agent was wrong.",
+      "",
+      "Start with the public contract and tests:",
+      `  cd ${result3.path} && npm test`,
+      "",
+      "Then repair scheduler.js and test it safely:",
+      `  chofex challenge test --challenge broken-agent --source ./${result3.path}/scheduler.js`
+    ].join(`
+`);
+  }
   if (result3.status === "exists") {
     return [
       `${result3.path} already exists. Left it unchanged.`,
@@ -60412,28 +60826,32 @@ var listCommand = exports_Command.make("list", {}, exports_Effect.fn("challengeL
     description: "See which challenge is currently playable"
   }
 ]));
-var initCommand = exports_Command.make("init", {}, exports_Effect.fn("challengeInitCommand")(function* () {
+var initCommand = exports_Command.make("init", { challenge: challengeFlag }, exports_Effect.fn("challengeInitCommand")(function* ({ challenge }) {
   const options = yield* root;
-  const participationState = participationStateFor(defaultChallengeSlug);
+  const participationState = participationStateFor(challenge);
   if (participationState !== "open") {
-    const message = launchNoticeFor(defaultChallengeSlug) ?? "El challenge todavía no está disponible.";
+    const message = launchNoticeFor(challenge) ?? "El challenge todavía no está disponible.";
     let code = "CHALLENGE_NOT_OPEN";
     if (participationState === "closed")
       code = "CHALLENGE_CLOSED";
     yield* execute(options.output, exports_Effect.fail(cliError(code, message)), challengeInitText);
     return;
   }
-  const operation = createChallengeScaffold().pipe(exports_Effect.map((data) => ({
+  const operation = createChallengeScaffold(challenge).pipe(exports_Effect.map((data) => ({
     version: 1,
     ok: true,
     requestId: crypto.randomUUID(),
     data
   })));
   yield* execute(options.output, operation, challengeInitText);
-})).pipe(exports_Command.withDescription("Create a documented shipping.js starter in the current directory. Existing files are never overwritten."), exports_Command.withExamples([
+})).pipe(exports_Command.withDescription("Create a challenge starter without overwriting existing work."), exports_Command.withExamples([
   {
     command: "chofex challenge init",
     description: "Prepare a safe JavaScript solution file"
+  },
+  {
+    command: "chofex challenge init --challenge broken-agent",
+    description: "Prepare the Broken Agent starter repository"
   }
 ]));
 var showCommand = exports_Command.make("show", { challenge: challengeFlag }, exports_Effect.fn("challengeShowCommand")(function* ({ challenge }) {
@@ -60512,11 +60930,11 @@ var testCommand = exports_Command.make("test", { challenge: challengeFlag, sourc
   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));
+    const solution = yield* javascriptSourceFromPath(exports_Option.getOrUndefined(source), challenge);
     return yield* testChallenge({ apiUrl: options.apiUrl, token }, challenge, solution);
   });
   yield* execute(options.output, operation, challengeTestText);
-})).pipe(exports_Command.withDescription("Check calculateShipping against your saved observations. Safe to repeat; official evaluations are not consumed. Requires sign-in."), exports_Command.withExamples([
+})).pipe(exports_Command.withDescription("Run the challenge's public tests. Safe to repeat; official evaluations are not consumed. Requires sign-in."), exports_Command.withExamples([
   {
     command: "chofex challenge test --source ./shipping.js",
     description: "Test a JavaScript replacement against your notebook"
@@ -60526,11 +60944,11 @@ var evaluateCommand = exports_Command.make("evaluate", { challenge: challengeFla
   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));
+    const solution = yield* javascriptSourceFromPath(exports_Option.getOrUndefined(source), challenge);
     return yield* evaluateChallenge({ apiUrl: options.apiUrl, token }, challenge, solution);
   });
   yield* execute(options.output, operation, challengeEvaluateText);
-})).pipe(exports_Command.withDescription("Score calculateShipping on hidden cases. This consumes one limited official evaluation. Requires sign-in."), exports_Command.withExamples([
+})).pipe(exports_Command.withDescription("Score a solution on hidden cases. This consumes one limited official evaluation. Requires sign-in."), exports_Command.withExamples([
   {
     command: "chofex challenge evaluate --source ./shipping.js",
     description: "Spend one official evaluation when your solution is ready"
@@ -60975,6 +61393,34 @@ 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")));
 };
+var badgeProfileInput = (path4, defaults2, pictures) => {
+  const interactive = exports_Effect.gen(function* () {
+    const publicFields = yield* exports_Prompt.run(exports_Prompt.all({
+      fullName: requiredText("Nombre impreso en el carnet", exports_Schema.Trim.pipe(exports_Schema.check(exports_Schema.isMinLength(1), exports_Schema.isMaxLength(200))), defaults2.fullName),
+      oneLiner: requiredText("Presentación de una línea", exports_Schema.Trim.pipe(exports_Schema.check(exports_Schema.isMinLength(1), exports_Schema.isMaxLength(30))), defaults2.oneLiner),
+      linkUrl: requiredText("Destino del QR", exports_Schema.Trim.pipe(exports_Schema.check(exports_Schema.isMinLength(1), exports_Schema.isMaxLength(2048))), defaults2.linkUrl)
+    }));
+    const pictureChoices = [{ title: "Mantener mi foto actual", value: "keep" }];
+    if (pictures.clerkPictureUrl) {
+      pictureChoices.push({ title: "Usar mi foto de Clerk", value: "clerk" });
+    }
+    if (pictures.githubUrl) {
+      pictureChoices.push({ title: "Usar mi foto de GitHub", value: "github" });
+    }
+    pictureChoices.push({
+      title: "Subir otra foto",
+      value: "upload"
+    });
+    const pictureChoice = yield* exports_Prompt.run(exports_Prompt.select({
+      message: "Foto impresa en el carnet",
+      choices: pictureChoices
+    }));
+    if (pictureChoice === "keep")
+      return publicFields;
+    return { ...publicFields, pictureSource: pictureChoice };
+  });
+  return inputOrInteractive(path4, interactive).pipe(exports_Effect.flatMap((input) => decode2(BadgeRegenerationInput, input, badgeRegenerationInputFieldNames)));
+};
 
 // src/picture-upload.ts
 import { readFile as readFile5, stat as stat3 } from "node:fs/promises";
@@ -62643,13 +63089,14 @@ var uploadPicture = exports_Effect.fn("uploadPicture")(function* (options, path4
 import { spawn as spawn3 } from "node:child_process";
 import { mkdtemp as mkdtemp2, rm as rm2 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import { dirname as dirname2, join as join3 } from "node:path";
+import { dirname as dirname2, isAbsolute, join as join3, relative, sep } from "node:path";
 var cliPackageName = "chofex-cli";
 var upgradeVersion = "latest";
-var npmUpgradeArguments = (cacheDirectory) => [
+var npmRegistryUrl = `https://registry.npmjs.org/${cliPackageName}/latest`;
+var npmUpgradeArguments = (cacheDirectory, version) => [
   "install",
   "--global",
-  `${cliPackageName}@${upgradeVersion}`,
+  `${cliPackageName}@${version}`,
   "--force",
   "--prefer-online",
   `--cache=${cacheDirectory}`
@@ -62657,22 +63104,32 @@ var npmUpgradeArguments = (cacheDirectory) => [
 var runProcess = (executable, arguments_, input) => new Promise((resolve4, reject) => {
   const stdin = input === undefined ? "ignore" : "pipe";
   const child = spawn3(executable, arguments_, {
-    stdio: [stdin, "ignore", "pipe"]
+    stdio: [stdin, "pipe", "pipe"]
   });
+  let stdout = "";
   let stderr = "";
+  const stdoutStream = child.stdout;
   const stderrStream = child.stderr;
-  if (stderrStream === null) {
+  if (stdoutStream === null || stderrStream === null) {
     child.kill();
-    reject(new Error(`Could not capture stderr from ${executable}`));
+    reject(new Error(`Could not capture output from ${executable}`));
     return;
   }
+  stdoutStream.setEncoding("utf8");
+  stdoutStream.on("data", (chunk) => {
+    stdout += chunk;
+  });
   stderrStream.setEncoding("utf8");
   stderrStream.on("data", (chunk) => {
     stderr += chunk;
   });
   child.on("error", reject);
   child.on("close", (exitCode) => {
-    resolve4({ exitCode: exitCode ?? 1, stderr: stderr.trim() });
+    resolve4({
+      exitCode: exitCode ?? 1,
+      stdout: stdout.trim(),
+      stderr: stderr.trim()
+    });
   });
   if (input !== undefined) {
     const stdinStream = child.stdin;
@@ -62689,7 +63146,7 @@ var runNpm = (arguments_) => {
   return runProcess(executable, arguments_);
 };
 var installerUrl = "https://hacktheandes.com/install";
-var runInstaller = async (installDirectory) => {
+var runInstaller = async (installDirectory, version) => {
   const response = await fetch(installerUrl);
   if (!response.ok) {
     throw new Error(`installer download returned HTTP ${response.status}`);
@@ -62698,6 +63155,8 @@ var runInstaller = async (installDirectory) => {
   const arguments_ = [
     "-s",
     "--",
+    "--version",
+    version,
     "--install-dir",
     installDirectory,
     "--no-modify-path"
@@ -62717,22 +63176,160 @@ var assertSuccessful = (result3, program) => {
   throw new Error(`${program} exited with code ${result3.exitCode}${detail}`);
 };
 var upgradeCli = async (options = {}) => {
+  const version = options.version ?? upgradeVersion;
   const standalone = options.standalone ?? isStandaloneExecutable();
   if (standalone) {
     const runner2 = options.installerRunner ?? runInstaller;
-    const result3 = await runner2(dirname2(process.execPath));
+    const result3 = await runner2(dirname2(process.execPath), version);
     assertSuccessful(result3, "installer");
     return;
   }
   const runner = options.npmRunner ?? runNpm;
   const cacheDirectory = await mkdtemp2(join3(tmpdir2(), "chofex-npm-cache-"));
   try {
-    const result3 = await runner(npmUpgradeArguments(cacheDirectory));
+    const result3 = await runner(npmUpgradeArguments(cacheDirectory, version));
     assertSuccessful(result3, "npm");
   } finally {
     await rm2(cacheDirectory, { recursive: true, force: true });
   }
 };
+var parseVersion = (version) => {
+  const match9 = version.match(/^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/);
+  if (match9 === null)
+    throw new Error(`Invalid CLI version: ${version}`);
+  return {
+    core: [Number(match9[1]), Number(match9[2]), Number(match9[3])],
+    prerelease: match9[4]?.split(".") ?? []
+  };
+};
+var comparePrereleaseIdentifier = (left, right) => {
+  const leftNumber = /^\d+$/.test(left) ? Number(left) : undefined;
+  const rightNumber = /^\d+$/.test(right) ? Number(right) : undefined;
+  if (leftNumber !== undefined && rightNumber !== undefined) {
+    return leftNumber - rightNumber;
+  }
+  if (leftNumber !== undefined)
+    return -1;
+  if (rightNumber !== undefined)
+    return 1;
+  return left.localeCompare(right);
+};
+var compareVersions = (left, right) => {
+  const parsedLeft = parseVersion(left);
+  const parsedRight = parseVersion(right);
+  const [leftMajor, leftMinor, leftPatch] = parsedLeft.core;
+  const [rightMajor, rightMinor, rightPatch] = parsedRight.core;
+  for (const difference3 of [
+    leftMajor - rightMajor,
+    leftMinor - rightMinor,
+    leftPatch - rightPatch
+  ]) {
+    if (difference3 !== 0)
+      return difference3;
+  }
+  if (parsedLeft.prerelease.length === 0) {
+    return parsedRight.prerelease.length === 0 ? 0 : 1;
+  }
+  if (parsedRight.prerelease.length === 0)
+    return -1;
+  const identifierCount = Math.max(parsedLeft.prerelease.length, parsedRight.prerelease.length);
+  for (let index2 = 0;index2 < identifierCount; index2 += 1) {
+    const leftIdentifier = parsedLeft.prerelease[index2];
+    const rightIdentifier = parsedRight.prerelease[index2];
+    if (leftIdentifier === undefined)
+      return -1;
+    if (rightIdentifier === undefined)
+      return 1;
+    const difference3 = comparePrereleaseIdentifier(leftIdentifier, rightIdentifier);
+    if (difference3 !== 0)
+      return difference3;
+  }
+  return 0;
+};
+var fetchLatestVersion = async () => {
+  const response = await fetch(npmRegistryUrl, {
+    headers: { accept: "application/json" },
+    signal: AbortSignal.timeout(5000)
+  });
+  if (!response.ok) {
+    throw new Error(`npm registry returned HTTP ${response.status}`);
+  }
+  const metadata = await response.json();
+  if (typeof metadata !== "object" || metadata === null || !("version" in metadata) || typeof metadata.version !== "string") {
+    throw new Error("npm registry returned an invalid package version");
+  }
+  parseVersion(metadata.version);
+  return metadata.version;
+};
+var autoUpdateCli = async (currentVersion, options = {}) => {
+  const latestVersion = await (options.fetchLatestVersion ?? fetchLatestVersion)();
+  if (compareVersions(latestVersion, currentVersion) <= 0) {
+    return { status: "current", version: currentVersion };
+  }
+  const upgrade = options.upgrade ?? ((version) => upgradeCli({ version }));
+  await upgrade(latestVersion);
+  return {
+    status: "updated",
+    previousVersion: currentVersion,
+    version: latestVersion
+  };
+};
+var npmGlobalNodeModulesPath = async (runner = runNpm) => {
+  const result3 = await runner(["root", "--global"]);
+  assertSuccessful(result3, "npm");
+  if (!result3.stdout)
+    throw new Error("npm did not report its global root");
+  return result3.stdout;
+};
+var pathIsInside = (parent, child) => {
+  const pathFromParent = relative(parent, child);
+  return pathFromParent !== "" && pathFromParent !== ".." && !pathFromParent.startsWith(`..${sep}`) && !isAbsolute(pathFromParent);
+};
+var rootFlagsWithValues = new Set(Object.values(rootValueFlagNames).map((name) => `--${name}`));
+var requestedCommand = (arguments_) => {
+  for (let index2 = 0;index2 < arguments_.length; index2 += 1) {
+    const argument = arguments_[index2];
+    if (argument === undefined)
+      continue;
+    if (rootFlagsWithValues.has(argument)) {
+      index2 += 1;
+      continue;
+    }
+    if (argument.startsWith("-"))
+      continue;
+    return argument;
+  }
+  return;
+};
+var shouldAutoUpdateCli = async ({
+  arguments: arguments_,
+  entryPath,
+  environmentValue,
+  globalNodeModulesPath,
+  npmRunner,
+  standalone
+}) => {
+  if (environmentValue === "0" || environmentValue === "false")
+    return false;
+  const command = requestedCommand(arguments_);
+  if (command === "update" || command === "upgrade") {
+    return false;
+  }
+  if (standalone)
+    return true;
+  if (!entryPath.split(/[\\/]/).includes("node_modules"))
+    return false;
+  const npmRoot = globalNodeModulesPath ?? await npmGlobalNodeModulesPath(npmRunner);
+  return pathIsInside(join3(npmRoot, cliPackageName), entryPath);
+};
+var runUpdatedCli = () => new Promise((resolve4, reject) => {
+  const child = spawn3(process.execPath, process.argv.slice(1), {
+    env: { ...process.env, CHOFEX_AUTO_UPDATE: "0" },
+    stdio: "inherit"
+  });
+  child.on("error", reject);
+  child.on("close", (exitCode) => resolve4(exitCode ?? 1));
+});
 
 // src/commands.ts
 var inputFlag2 = exports_Flag.string("input").pipe(exports_Flag.optional, exports_Flag.withDescription("Read JSON from a file, or use - for stdin"));
@@ -62819,12 +63416,50 @@ var requirementsCommand = exports_Command.make("requirements", {}, exports_Effec
   });
   yield* execute(options.output, operation, requirementsOnlyText, registrationLookupErrorText);
 })).pipe(exports_Command.withDescription("Show information you still need to provide"));
+var badgeRegenerateCommand = exports_Command.make("regenerate", {
+  input: inputFlag2,
+  picture: exports_Flag.string("picture").pipe(exports_Flag.optional, exports_Flag.withDescription("Ruta a una foto JPEG, PNG o WebP (máximo 5 MB)"))
+}, exports_Effect.fn("badgeRegenerateCommand")(function* ({ input, picture }) {
+  const options = yield* root;
+  const operation = exports_Effect.gen(function* () {
+    const inputPath = exports_Option.getOrUndefined(input);
+    if (options.output === "json" && inputPath === undefined) {
+      return yield* exports_Effect.fail(cliError("INPUT_REQUIRED", "El modo JSON requiere --input <archivo> o --input -"));
+    }
+    const token = exports_Option.getOrUndefined(options.token);
+    const client = { apiUrl: options.apiUrl, token };
+    const badge = yield* getBadge(client);
+    if (!badge.data.profile) {
+      return yield* exports_Effect.fail(cliError("INVALID_APPLICATION_STATE", "Confirma tu asistencia antes de regenerar tu carnet"));
+    }
+    const [current, currentUser] = yield* exports_Effect.all([
+      getRegistration(client),
+      getCurrentUser(client)
+    ]);
+    const body = yield* badgeProfileInput(inputPath, badge.data.profile, {
+      clerkPictureUrl: currentUser.data.clerkPictureUrl,
+      githubUrl: current.data.registration.githubUrl
+    });
+    const picturePath = exports_Option.getOrUndefined(picture);
+    if (body.pictureSource === "upload") {
+      if (options.output === "json" && picturePath === undefined) {
+        return yield* exports_Effect.fail(cliError("PICTURE_PATH_REQUIRED", "Usa --picture <ruta> cuando pictureSource es upload"));
+      }
+      const path4 = yield* picturePathInput(picturePath);
+      yield* uploadPicture(client, path4);
+    } else if (picturePath) {
+      return yield* exports_Effect.fail(cliError("UNEXPECTED_PICTURE_PATH", "--picture solo se puede usar cuando pictureSource es upload"));
+    }
+    return yield* regenerateBadge(client, body);
+  });
+  yield* execute(options.output, operation, badgeText);
+})).pipe(exports_Command.withDescription("Actualiza la foto, el nombre, la presentación y el enlace QR del carnet"));
 var badgeCommand = exports_Command.make("badge", {}, exports_Effect.fn("badgeCommand")(function* () {
   const options = yield* root;
   const token = exports_Option.getOrUndefined(options.token);
   const operation = getBadge({ apiUrl: options.apiUrl, token });
   yield* execute(options.output, operation, badgeText);
-})).pipe(exports_Command.withDescription("Show your generated participant badge"));
+})).pipe(exports_Command.withDescription("Muestra o regenera tu carnet de participante"), exports_Command.withSubcommands([badgeRegenerateCommand]));
 var confirmCommand = exports_Command.make("confirm", {
   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)"))
@@ -63259,4 +63894,37 @@ var programForArguments = () => {
   }
   return commandProgram;
 };
-programForArguments().pipe(exports_Effect.provide(exports_NodeServices.layer), (program) => exports_NodeRuntime.runMain(program, { disableErrorReporting: true }));
+var runAutomaticUpdate = async () => {
+  try {
+    const standalone = isStandaloneExecutable();
+    const enabled = await shouldAutoUpdateCli({
+      arguments: arguments_,
+      entryPath: fileURLToPath2(import.meta.url),
+      environmentValue: process.env.CHOFEX_AUTO_UPDATE,
+      standalone
+    });
+    if (!enabled)
+      return "continue";
+    const result3 = await autoUpdateCli(cliVersion);
+    if (result3.status === "current")
+      return "continue";
+    process.stderr.write(`${cliPackageName} se actualizó de ${result3.previousVersion} a ${result3.version}.
+`);
+    if (standalone && process.platform === "win32") {
+      process.stderr.write(`La actualización se aplicará cuando termine este comando.
+`);
+      return "continue";
+    }
+    process.exitCode = await runUpdatedCli();
+    return "command-completed";
+  } catch {
+    process.stderr.write(`No se pudo comprobar o instalar una actualización de ${cliPackageName}; se continuará con ${cliVersion}.
+`);
+    return "continue";
+  }
+};
+exports_Effect.promise(runAutomaticUpdate).pipe(exports_Effect.flatMap((outcome) => {
+  if (outcome === "command-completed")
+    return exports_Effect.void;
+  return programForArguments();
+}), exports_Effect.provide(exports_NodeServices.layer), (program) => exports_NodeRuntime.runMain(program, { disableErrorReporting: true }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chofex-cli",
-  "version": "0.1.173",
+  "version": "0.1.178",
   "description": "Command-line client for Hack the Andes",
   "type": "module",
   "bin": {