chofex-cli 0.1.173 → 0.1.177

package/README.md

@@ -24,6 +24,11 @@ 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
 ```
 
@@ -34,7 +39,7 @@ to the latest published version.
 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
+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

@@ -58552,6 +58552,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 +58574,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 +58691,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 +58719,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 +58817,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 +58835,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 +58861,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,
@@ -59709,6 +59744,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 +59760,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 +59817,6 @@ var shipmentInput = (path4, flags) => {
   }
   return interactiveShipment();
 };
-var defaultChallengeSlug = "black-box";
 
 // src/brand.ts
 var eventName = "Hack the Andes";
@@ -59834,6 +59872,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 +60060,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 +60106,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 +60162,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 +60210,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 +60440,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,7 +60485,7 @@ 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
@@ -60364,7 +60726,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 +60743,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 +60798,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 +60902,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 +60916,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"

package/package.json

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