@brainbase-labs/cli 0.34.0 → 0.36.0

package/README.md

@@ -27,6 +27,58 @@ brainbase benchmark list        # list benchmarks for the linked agent
 
 Run `brainbase help` to see every command.
 
+## Task follow-ups
+
+Send an instruction to an existing task, including while its agent is running:
+
+```sh
+brainbase task send <task-id> "Also update the Linear ticket"
+brainbase task send <task-id> "Use the revised approach instead" --json
+brainbase task stop <task-id>
+```
+
+`send` prints the input ID and generation to stderr before submitting and reports delivery
+status in stdout. Initial acceptance can say **delivery pending** while the
+server determines whether native steering is available. Native steering follows
+the harness's own timing. A confirmed fallback says **queued for the next turn**.
+`submitted` means the harness has received the input; it does not mean the agent
+has acted on it. Multiple follow-ups can join one execution and receive one
+combined answer.
+
+By default, both commands read the current input generation before sending their request.
+The credential must have receipt-read access as well as permission to send or stop.
+Resource-scoped keys can lack that read access when task-read enforcement is enabled.
+If the read fails, no mutation is sent. Use `--generation <n>` to bypass the read only
+with a trusted current cutoff for a new operation, or the original cutoff for a retry.
+A concurrent Stop prevents a send from joining newer work with an older generation.
+If the HTTP response is lost or you press Ctrl-C, keep the input ID and generation,
+and repeat the exact message with `--input-id <uuid> --generation <n>` to recover that request safely. Reusing an ID
+does not replay an existing input. A **delivery unconfirmed** receipt means
+the agent may already have received the instruction; deliberately resend
+without `--input-id` only if you want to retry it as a new input.
+
+Known pre-admission HTTP 503 refusals include `task_inputs_disabled`,
+`task_input_recovery_unavailable`, and recognized sandbox provisioning or access
+codes. These mean no input was admitted by that request. Retry the same ID, message
+and generation after the service recovers. Unrecognized server or network failures
+can leave delivery unconfirmed. A recovered receipt reports `idempotency_replayed: true`
+in JSON when the server supplies its replay header.
+
+`stop` stops execution and cancels pending follow-ups while retaining their
+text. A new instruction will not replay them. Before submitting, it prints a retry
+command with `--generation <n>`. Keep that command even if the response is lost:
+retrying the original generation cannot interrupt newer work. An error can mean
+queued inputs were already cancelled while the original execution is still running.
+Follow the error's retry or operator-recovery guidance. Omit `--generation` only
+when deliberately issuing a new Stop. JSON includes the original `expected_generation`
+separately from the server's resulting `generation`.
+
+Ctrl-C in `task create --wait`
+or `task logs --follow` still only detaches; it does not stop remote work.
+Both commands support `--json`. `send` exits 1 for unconfirmed, cancelled or
+failed inputs, and for request errors. Other acknowledged states exit 0;
+this confirms admission or delivery, not task success.
+
 ## Benchmark management
 
 `benchmark init`, `benchmark validate`, and command help are local and need no
@@ -237,7 +289,7 @@ Playbook files carry a small YAML frontmatter (`title`, `description`) — the C
 
 | Variable | Purpose |
 |-|-|
-| `BRAINBASE_CONTROL_PLANE_URL` | Override the MAS host. Agent/orchestration requests use `/v2/cli`; `task create` uses `/v2/tasks`. The default is `https://api.brainbaselabs.com`. |
+| `BRAINBASE_CONTROL_PLANE_URL` | Override the MAS host. Agent/orchestration requests use `/v2/cli`; task commands use `/v2/tasks`. The default is `https://api.brainbaselabs.com`. |
 | `BRAINBASE_API_URL` | Legacy KLS host override. Control requests use `/api/cli`; it is also the fallback for model-proxy and registry traffic. |
 | `BRAINBASE_PROXY_URL` | Override the model-proxy host used when enabling harness tracking. |
 | `BRAINBASE_REGISTRY_URL` | Override the registry API host. |
@@ -256,7 +308,7 @@ it talks to:
 |-|-|
 | `agent`, `orchestration`, `link`, `unlink`, `sync`, `status`, `team` | `BRAINBASE_TOKEN`, then the `auth.json` session |
 | `template`, `skill`, `token` | `BRAINBASE_TOKEN`, then the session, then `token.json` |
-| `task create` | `BRAINBASE_TOKEN`, then the session, then `token.json` — the last only when no session is configured |
+| `task` commands | `BRAINBASE_TOKEN`, then the session, then `token.json` — the last only when no session is configured |
 | `benchmark` control-plane commands | `BRAINBASE_TOKEN`, then the session |
 
 `brainbase whoami` (or `--json`) reports which one is active.

package/dist/index.js

@@ -36018,7 +36018,7 @@ function padStart(s, n) {
 // package.json
 var package_default = {
   name: "@brainbase-labs/cli",
-  version: "0.34.0",
+  version: "0.36.0",
   description: "Pack, share, and install agent templates across harnesses (Claude Code, Codex, ...).",
   type: "module",
   bin: {
@@ -54605,7 +54605,7 @@ async function masReadRequest(pathname, callerSignal) {
   } catch {}
   if (!res.ok) {
     const message = masApiErrorMessage(body, res.status);
-    throw new ApiError(res.status === 401 ? withRejectedSessionHint(message, credential.source, "managed-task") : message, res.status, body);
+    throw new ApiError(res.status === 401 ? withRejectedSessionHint(message, credential.source, "managed-task") : res.status === 404 && isUnroutedPath(body) ? `This control plane does not serve ${pathname} yet. Update the server, or use the web app.` : message, res.status, body);
   }
   return body;
 }
@@ -54623,7 +54623,7 @@ function withRequestDeadline(callerSignal, timeoutMs) {
   });
   return combined.signal;
 }
-async function masResourceRequest(pathname, init = {}) {
+async function masResourceRequest(pathname, init = {}, onHeaders) {
   const credential = await resolveMasCredential();
   let currentSession = credential.session;
   const res = await sendWithAuthRetry(credential.source === "session" ? currentSession : null, async (refreshed) => {
@@ -54648,6 +54648,7 @@ async function masResourceRequest(pathname, init = {}) {
     const message = masApiErrorMessage(body, res.status);
     throw new ApiError(res.status === 401 ? withRejectedSessionHint(message, credential.source, "managed-task") : res.status === 404 && isUnroutedPath(body) ? `This control plane does not serve ${pathname} yet. Update the server, or use the web app.` : message, res.status, body);
   }
+  onHeaders?.(res.headers);
   return body;
 }
 
@@ -54687,6 +54688,12 @@ function masItems(body, what) {
   }
   throw new ApiError(`MAS returned an unreadable ${what} response.`, undefined, body);
 }
+function isTaskInputReceipt(body) {
+  if (!body || typeof body !== "object")
+    return false;
+  const receipt = body;
+  return typeof receipt.id === "string" && typeof receipt.task_id === "string" && Array.isArray(receipt.message_ids) && receipt.message_ids.every((id) => typeof id === "string") && typeof receipt.status === "string" && ["queued", "dispatching", "submitted", "unconfirmed", "cancelled", "completed", "failed"].includes(receipt.status) && (receipt.turn_id === null || typeof receipt.turn_id === "string") && Number.isInteger(receipt.generation) && Number.isInteger(receipt.sequence) && (receipt.reason === undefined || receipt.reason === null || typeof receipt.reason === "string") && typeof receipt.created_at === "string" && typeof receipt.updated_at === "string";
+}
 var masApi = {
   async createTask(input, options) {
     const body = await masRequest("/tasks", {
@@ -54696,6 +54703,30 @@ var masApi = {
     });
     return parseMasTaskCreateResponse(body);
   },
+  async getTaskInputGeneration(taskId) {
+    const body = await masReadRequest(`/tasks/${encodeURIComponent(taskId)}/inputs?limit=1&include_messages=false`);
+    if (!body || !Array.isArray(body.inputs) || typeof body.generation !== "number" || !Number.isSafeInteger(body.generation) || body.generation < 0) {
+      throw new ApiError("MAS returned an unreadable task input generation.", undefined, body);
+    }
+    return body.generation;
+  },
+  async sendTaskInput(taskId, input) {
+    let replayed = false;
+    const body = await masResourceRequest(`/tasks/${encodeURIComponent(taskId)}/inputs`, { method: "POST", body: JSON.stringify(input), keepalive: false }, (headers) => {
+      replayed = headers.get("Idempotency-Replayed") === "true";
+    });
+    if (!body || !isTaskInputReceipt(body.input) || body.input.id.toLowerCase() !== input.input_id.toLowerCase() || body.input.task_id.toLowerCase() !== taskId.toLowerCase() || !Array.isArray(body.messages) || typeof body.run_started !== "boolean" || !(body.accepted_turn_id === null || typeof body.accepted_turn_id === "string")) {
+      throw new ApiError("MAS returned an unreadable follow-up receipt.", undefined, body);
+    }
+    return replayed ? { ...body, idempotency_replayed: true } : body;
+  },
+  async stopTask(taskId, expectedGeneration) {
+    const body = await masResourceRequest(`/tasks/${encodeURIComponent(taskId)}/interrupt`, { method: "POST", body: JSON.stringify({ expected_generation: expectedGeneration }), keepalive: false });
+    if (!body || typeof body.id !== "string" || body.id.toLowerCase() !== taskId.toLowerCase() || typeof body.status !== "string" || !Number.isInteger(body.generation) || !Array.isArray(body.cancelled_inputs) || !body.cancelled_inputs.every((input) => isTaskInputReceipt(input) && input.task_id.toLowerCase() === taskId.toLowerCase() && input.status === "cancelled")) {
+      throw new ApiError("MAS did not confirm Stop and pending follow-up cancellation.", undefined, body);
+    }
+    return body;
+  },
   async listTasks(options = {}) {
     const params = new URLSearchParams;
     if (options.agentId)
@@ -81143,6 +81174,177 @@ function oneLine2(value) {
   return flattened.length > 300 ? `${flattened.slice(0, 299)}…` : flattened;
 }
 
+// src/cli/task-input.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+function errorCode(error2) {
+  if (!(error2 instanceof ApiError) || !error2.body || typeof error2.body !== "object")
+    return;
+  const detail = error2.body.detail;
+  if (!detail || typeof detail !== "object")
+    return;
+  const code = detail.code;
+  return typeof code === "string" ? code : undefined;
+}
+function stopRetryCommand(taskId, generation) {
+  const argument = /^[A-Za-z0-9_-]+$/.test(taskId) ? taskId : `'${sanitizeLabel(taskId).replaceAll("'", "'\\''")}'`;
+  return `brainbase task stop ${argument} --generation ${generation}`;
+}
+var NO_ADMISSION_CODES = new Set([
+  "task_inputs_disabled",
+  "task_input_recovery_unavailable",
+  "aws_microvm_unavailable",
+  "modal_sandboxes_unavailable",
+  "modal_sandbox_authorization_unavailable",
+  "bbsandbox_unavailable",
+  "bbsandbox_authorization_unavailable",
+  "cloudflare_unavailable",
+  "cloudflare_authorization_unavailable"
+]);
+var STOP_RECOVERY_CODES = new Set([
+  "turn_interrupt_unsupported",
+  "turn_interrupt_recovery_required",
+  "task_recovery_required"
+]);
+var INPUT_STATUS_TEXT = {
+  queued: "Accepted; delivery pending.",
+  dispatching: "Delivery in progress; the harness has not acknowledged it yet.",
+  submitted: "Received by the harness; this does not confirm the instruction has been acted on.",
+  unconfirmed: "Delivery unconfirmed. The agent may have received this message. Send it again only if you intend to retry; omit --input-id to create a new follow-up.",
+  cancelled: "Cancelled. The text is retained and will not be replayed by a new instruction.",
+  completed: "The execution containing this follow-up has completed.",
+  failed: "Follow-up failed. Its text is retained."
+};
+var NEXT_TURN_REASONS = new Set([
+  "unsupported",
+  "closing",
+  "stale",
+  "native_rejected",
+  "native_fallback"
+]);
+async function runTaskSend(taskId, message, options = {}) {
+  if (!message.trim())
+    throw new Error("The follow-up message must not be blank.");
+  const inputId = options.inputId?.trim().toLowerCase() ?? randomUUID3();
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(inputId)) {
+    throw new Error("--input-id must be a UUID.");
+  }
+  console.error(`Input ID: ${inputId}`);
+  let result2;
+  let expectedGeneration = options.generation;
+  let attempted = false;
+  try {
+    expectedGeneration ??= await masApi.getTaskInputGeneration(taskId);
+    console.error([
+      `Input generation: ${expectedGeneration}`,
+      `If interrupted, rerun with --input-id ${inputId} and the identical message, plus --generation ${expectedGeneration}, to recover this request.`
+    ].join(`
+`));
+    attempted = true;
+    result2 = await masApi.sendTaskInput(taskId, {
+      input_id: inputId,
+      messages: [{ role: "user", content: message }],
+      expected_generation: expectedGeneration
+    });
+  } catch (error2) {
+    const status = error2 instanceof ApiError ? error2.status : undefined;
+    const code = errorCode(error2);
+    const rejected = status === 503 && NO_ADMISSION_CODES.has(code ?? "");
+    const uncertain = attempted && !rejected && (status === undefined || status >= 500);
+    const detail = error2 instanceof Error ? error2.message : String(error2);
+    const retry = `rerun with --input-id ${inputId} and the identical message${expectedGeneration === undefined ? "" : `, plus --generation ${expectedGeneration}`}`;
+    const recovery = uncertain ? ` Delivery is unconfirmed. To recover the same request safely, ${retry}.` : rejected ? ` No input was admitted by this request. After service recovery, ${retry}.` : !attempted ? ` No input was sent: the task generation could not be read. After resolving the error, ${retry}. Use --generation <n> only with a trusted current cutoff, or the original cutoff for a retry.` : "";
+    if (options.json) {
+      console.log(JSON.stringify({
+        task_id: taskId,
+        input_id: inputId,
+        expected_generation: expectedGeneration,
+        error: { message: `${detail}${recovery}`, status, code },
+        ...uncertain ? { delivery: "unconfirmed" } : {}
+      }));
+      process.exitCode = 1;
+      return;
+    }
+    throw new ApiError(`Follow-up ${inputId}: ${detail}${recovery}`, status, error2 instanceof ApiError ? error2.body : undefined);
+  }
+  if (options.json) {
+    console.log(JSON.stringify({ ...result2, expected_generation: expectedGeneration }, null, 2));
+  } else {
+    const receipt = result2.input;
+    const lines = [
+      `Task ID: ${sanitizeLabel(taskId)}`,
+      `Input ID: ${sanitizeLabel(receipt.id)}`,
+      `Status: ${receipt.status}`,
+      receipt.status === "queued" && NEXT_TURN_REASONS.has(receipt.reason ?? "") ? "Queued for the next turn." : INPUT_STATUS_TEXT[receipt.status]
+    ];
+    if (result2.idempotency_replayed)
+      lines.push("Recovered an existing receipt; no new delivery was requested.");
+    if (receipt.turn_id)
+      lines.push(`Turn ID: ${sanitizeLabel(receipt.turn_id)}`);
+    if (receipt.reason)
+      lines.push(`Reason: ${sanitizeLabel(receipt.reason)}`);
+    console.log(lines.join(`
+`));
+  }
+  if (["unconfirmed", "cancelled", "failed"].includes(result2.input.status)) {
+    process.exitCode = 1;
+  }
+}
+async function runTaskStop(taskId, options = {}) {
+  let task;
+  let expectedGeneration = options.generation;
+  let attempted = false;
+  try {
+    expectedGeneration ??= await masApi.getTaskInputGeneration(taskId);
+    console.error([
+      `Stop generation: ${expectedGeneration}`,
+      "If interrupted, retry the original Stop with:",
+      stopRetryCommand(taskId, expectedGeneration)
+    ].join(`
+`));
+    attempted = true;
+    task = await masApi.stopTask(taskId, expectedGeneration);
+  } catch (error2) {
+    const status = error2 instanceof ApiError ? error2.status : undefined;
+    const code = errorCode(error2);
+    const detail = error2 instanceof Error ? error2.message : String(error2);
+    let guidance = "";
+    if (!attempted) {
+      guidance = " Stop was not sent: the task generation could not be read. Use --generation <n> only with a trusted current cutoff, or the original cutoff for a retry.";
+    } else if (status === undefined || status >= 500 || code === "turn_interrupt_pending" || STOP_RECOVERY_CODES.has(code ?? "")) {
+      guidance = " Stop is not confirmed. Pending follow-ups may already be cancelled; their text is retained. The original execution may still be running.";
+      const retry = stopRetryCommand(taskId, expectedGeneration);
+      guidance += code === "turn_interrupt_unsupported" ? " If the original execution finishes, try the original Stop again. Contact support if it still cannot be confirmed. Retry with:" : STOP_RECOVERY_CODES.has(code ?? "") ? " Wait for operator recovery. Retain this command for any later retry:" : ` ${code === "turn_interrupt_pending" || code === "turn_interrupt_unconfirmed" ? "Wait at least one second, then retry" : "Check the task, then retry"} the original Stop with:`;
+      guidance += `
+${retry}
+Omit --generation only for a deliberately new Stop.`;
+    }
+    const message = `${detail}${guidance}`;
+    if (options.json) {
+      console.log(JSON.stringify({
+        task_id: taskId,
+        expected_generation: expectedGeneration,
+        error: { message, status, code }
+      }));
+      process.exitCode = 1;
+      return;
+    }
+    throw new ApiError(message, status, error2 instanceof ApiError ? error2.body : undefined);
+  }
+  if (options.json) {
+    console.log(JSON.stringify({ ...task, expected_generation: expectedGeneration }, null, 2));
+    return;
+  }
+  console.log([
+    `Task ID: ${sanitizeLabel(task.id)}`,
+    `Status: ${sanitizeLabel(task.status)}`,
+    `Stop generation: ${expectedGeneration}`,
+    `Cancelled follow-ups: ${task.cancelled_inputs.length}`,
+    ...task.cancelled_inputs.map((input) => `Cancelled input: ${sanitizeLabel(input.id)}`),
+    "Follow-ups covered by this Stop are cancelled. Their text is retained; a new instruction will not replay them."
+  ].join(`
+`));
+}
+
 // src/core/argv.ts
 class ArgvParseError extends Error {
   code = "invalid_arguments";
@@ -81399,6 +81601,15 @@ function requiredTaskId(positionals, usage) {
   }
   return positionals[0].trim();
 }
+function inputGeneration(value) {
+  if (value === undefined)
+    return;
+  const parsed = Number(value.trim());
+  if (!/^\d+$/.test(value.trim()) || !Number.isSafeInteger(parsed)) {
+    throw new Error("--generation must be a non-negative safe whole number.");
+  }
+  return parsed;
+}
 async function runTask(cwd2, sub, args) {
   switch (sub) {
     case "create": {
@@ -81430,6 +81641,44 @@ async function runTask(cwd2, sub, args) {
       });
       return;
     }
+    case "send": {
+      const parsed = parseArgv(args, [
+        { key: "inputId", names: ["--input-id"], kind: "value" },
+        { key: "generation", names: ["--generation"], kind: "value" },
+        { key: "json", names: ["--json"], kind: "boolean" },
+        { key: "help", names: ["--help", "-h"], kind: "boolean" }
+      ]);
+      if (booleanOption(parsed, "help")) {
+        printHelp4();
+        return;
+      }
+      if (parsed.positionals.length !== 2 || !parsed.positionals[0]?.trim()) {
+        throw new Error("Usage: brainbase task send <task-id> <message> [--input-id <uuid>] [--generation <n>] [--json]");
+      }
+      await runTaskSend(parsed.positionals[0].trim(), parsed.positionals[1], {
+        inputId: stringOption(parsed, "inputId"),
+        generation: inputGeneration(stringOption(parsed, "generation")),
+        json: booleanOption(parsed, "json")
+      });
+      return;
+    }
+    case "stop": {
+      const parsed = parseArgv(args, [
+        { key: "generation", names: ["--generation"], kind: "value" },
+        { key: "json", names: ["--json"], kind: "boolean" },
+        { key: "help", names: ["--help", "-h"], kind: "boolean" }
+      ]);
+      if (booleanOption(parsed, "help")) {
+        printHelp4();
+        return;
+      }
+      const taskId = requiredTaskId(parsed.positionals, "brainbase task stop <task-id> [--generation <n>] [--json]");
+      await runTaskStop(taskId, {
+        generation: inputGeneration(stringOption(parsed, "generation")),
+        json: booleanOption(parsed, "json")
+      });
+      return;
+    }
     case "get": {
       if (args.some((arg) => HELP_FLAGS.has(arg))) {
         printHelp4();
@@ -81482,6 +81731,8 @@ function printHelp4() {
   out.push(`  ${import_picocolors56.default.cyan("list")}                     ${import_picocolors56.default.dim("recent tasks you can reach (--json for scripts)")}`);
   out.push(`  ${import_picocolors56.default.cyan("get")} ${import_picocolors56.default.dim("<task-id>")}            ${import_picocolors56.default.dim("one task: status, agent, machine, eval verdicts")}`);
   out.push(`  ${import_picocolors56.default.cyan("logs")} ${import_picocolors56.default.dim("<task-id> [--follow]")} ${import_picocolors56.default.dim("one line per event in the task's transcript, or tail it live")}`);
+  out.push(`  ${import_picocolors56.default.cyan("send")} ${import_picocolors56.default.dim("<task-id> <message>")} ${import_picocolors56.default.dim("send a follow-up, including while the agent is running")}`);
+  out.push(`  ${import_picocolors56.default.cyan("stop")} ${import_picocolors56.default.dim("<task-id>")}           ${import_picocolors56.default.dim("stop execution and cancel pending follow-ups, retaining their text")}`);
   out.push("");
   out.push(`  ${import_picocolors56.default.bold("create flags")}`);
   out.push(`  ${import_picocolors56.default.dim("--message <text>")}   required first user message`);
@@ -81499,12 +81750,24 @@ function printHelp4() {
   out.push(`  ${import_picocolors56.default.dim("--limit <n>")}        stop after <n> events instead of the whole transcript; with --follow, the first page size`);
   out.push(`  ${import_picocolors56.default.dim("--follow, -f")}       stay attached and print events as they land, until the task finishes`);
   out.push("");
+  out.push(`  ${import_picocolors56.default.bold("send flags")}`);
+  out.push(`  ${import_picocolors56.default.dim("--input-id <uuid>")}  recover the same request using its original ID and identical message`);
+  out.push(`  ${import_picocolors56.default.dim("                    omit it to send a new follow-up; an unconfirmed receipt is never automatically replayed")}`);
+  out.push(`  ${import_picocolors56.default.dim("                    admission disabled/recovery unavailable means no input was admitted; retry the same ID after recovery")}`);
+  out.push("");
+  out.push(`  ${import_picocolors56.default.bold("send and stop flags")}`);
+  out.push(`  ${import_picocolors56.default.dim("--generation <n>")}   retain the printed generation when retrying; defaults to a fresh snapshot for a new operation`);
+  out.push(`  ${import_picocolors56.default.dim("                    Stop errors may follow queued-input cancellation; retry the printed command to avoid stopping newer work")}`);
+  out.push("");
   out.push(`  ${import_picocolors56.default.bold("every subcommand")}`);
-  out.push(`  ${import_picocolors56.default.dim("--json")}             machine-readable output — create prints task_id, agent_id and status; list, get and logs print the raw records`);
+  out.push(`  ${import_picocolors56.default.dim("--json")}             machine-readable output — create prints task_id, agent_id and status; list, get, logs, send and stop print the raw records`);
+  out.push(`  ${import_picocolors56.default.dim("                    send and stop include expected_generation for safe retries; send also reports idempotency_replayed when present")}`);
   out.push(`  ${import_picocolors56.default.dim("                    logs --follow --json prints one record per line, since a live stream has no end to close on")}`);
   out.push("");
   out.push(`  ${import_picocolors56.default.dim("Exit codes with --wait:")} ${import_picocolors56.default.dim("0 succeeded · 1 failed, needs input, or timed out · 130 interrupted")}`);
   out.push(`  ${import_picocolors56.default.dim("Exit codes with --follow:")} ${import_picocolors56.default.dim("0 task reached a terminal state · 1 stream refused, or unreachable for 60s · 130 interrupted (Ctrl-C) · 143 terminated")}`);
+  out.push(`  ${import_picocolors56.default.dim("Exit codes with send:")} ${import_picocolors56.default.dim("0 queued, dispatching, submitted or completed · 1 unconfirmed, cancelled, failed or request error")}`);
+  out.push(`  ${import_picocolors56.default.dim("Ctrl-C while waiting or following logs detaches; use task stop to cancel remote work.")}`);
   out.push("");
   out.push(`  ${import_picocolors56.default.dim("Flag-like values:")} use ${import_picocolors56.default.cyan("--flag=value")} or ${import_picocolors56.default.cyan("--flag -- <value>")}`);
   out.push("");
@@ -85418,9 +85681,12 @@ class BenchmarkApiClient {
       query: { baseline_target_id: baselineTargetId }
     });
   }
-  exportRunResults(runId) {
+  exportRunResults(runId, query = {}) {
     return this.request(`/runs/${encodeURIComponent(runId)}/results/export`, {
-      mode: "binary"
+      mode: "binary",
+      query: {
+        include_billing_receipts: query.includeBillingReceipts || undefined
+      }
     });
   }
   listTrials(runId, query = {}) {
@@ -87134,6 +87400,11 @@ var DEFINITIONS = [
   { key: "yes", names: ["--yes", "-y"], kind: "boolean" },
   { key: "all", names: ["--all"], kind: "boolean" },
   { key: "force", names: ["--force"], kind: "boolean" },
+  {
+    key: "includeBillingReceipts",
+    names: ["--include-billing-receipts"],
+    kind: "boolean"
+  },
   { key: "archived", names: ["--archived"], kind: "boolean" },
   { key: "preview", names: ["--preview"], kind: "boolean" },
   { key: "watch", names: ["--watch"], kind: "boolean" },
@@ -88696,11 +88967,17 @@ async function runArtifacts(cwd2, argv, deps) {
   }, options);
 }
 async function runExportResults(cwd2, argv, deps) {
-  const options = parseControlOptions(argv, ["output", "force"]);
-  expectPositionals(options.positionals, 1, 1, "brainbase benchmark export-results <run-id> [--output <path>]");
+  const options = parseControlOptions(argv, [
+    "output",
+    "force",
+    "includeBillingReceipts"
+  ]);
+  expectPositionals(options.positionals, 1, 1, "brainbase benchmark export-results <run-id> [--output <path>] [--include-billing-receipts]");
   const runId = options.positionals[0];
   const { client, output } = context(cwd2, "benchmark export-results", options, deps);
-  const response = await client.exportRunResults(runId);
+  const response = await client.exportRunResults(runId, {
+    includeBillingReceipts: bool(options.parsed, "includeBillingReceipts")
+  });
   const fallback = safeExportFilename(response.filename, `benchmark-run-${runId}-results.zip`);
   const written = writeBinaryOutput(cwd2, optionalNonblank(options.parsed, "output"), response.bytes, fallback, bool(options.parsed, "force"));
   output.result({
@@ -88913,7 +89190,7 @@ function commandLevelHelp(sub, argv) {
     case "artifacts":
       return usage("brainbase benchmark artifacts <run-id> <attempt-id> [--limit <n>] [--cursor <cursor>] [--all]");
     case "export-results":
-      return usage("brainbase benchmark export-results <run-id> [--output <path>] [--force]");
+      return usage("brainbase benchmark export-results <run-id> [--output <path>] [--force] [--include-billing-receipts]");
     case "history":
       return usage("brainbase benchmark history <benchmark-id> [--limit <n>]");
     case "baseline":
@@ -89463,6 +89740,8 @@ function help() {
   out.push(`  ${import_picocolors61.default.cyan("task list")}                       ${import_picocolors61.default.dim("recent tasks you can reach")}`);
   out.push(`  ${import_picocolors61.default.cyan("task get")} ${import_picocolors61.default.dim("<task-id>")}              ${import_picocolors61.default.dim("one task: status, agent, machine, eval verdicts")}`);
   out.push(`  ${import_picocolors61.default.cyan("task logs")} ${import_picocolors61.default.dim("<task-id> [--follow]")}  ${import_picocolors61.default.dim("one line per event in the task's transcript, or tail it live")}`);
+  out.push(`  ${import_picocolors61.default.cyan("task send")} ${import_picocolors61.default.dim("<task-id> <message>")}  ${import_picocolors61.default.dim("send a follow-up during execution, or queue it for the next turn")}`);
+  out.push(`  ${import_picocolors61.default.cyan("task stop")} ${import_picocolors61.default.dim("<task-id>")}             ${import_picocolors61.default.dim("stop execution and cancel pending follow-ups, retaining their text")}`);
   out.push("");
   out.push(divider("SANDBOXES"));
   out.push("");
@@ -89556,7 +89835,7 @@ function help() {
   out.push(`  ${import_picocolors61.default.dim("BRAINBASE_HOME")}         override the local config dir (default ~/.brainbase)`);
   out.push(`  ${import_picocolors61.default.dim("BRAINBASE_DEBUG")}        print full stack traces on error (any value; unset to disable)`);
   out.push(`  ${import_picocolors61.default.dim("BRAINBASE_WEB_URL")}      override the web app URL used by login`);
-  out.push(`  ${import_picocolors61.default.dim("BRAINBASE_CONTROL_PLANE_URL")} override the MAS host (/v2/cli; task create uses /v2/tasks)`);
+  out.push(`  ${import_picocolors61.default.dim("BRAINBASE_CONTROL_PLANE_URL")} override the MAS host (/v2/cli; task commands use /v2/tasks)`);
   out.push(`  ${import_picocolors61.default.dim("BRAINBASE_API_URL")}      legacy KLS host override (uses /api/cli; proxy/registry fallback)`);
   out.push(`  ${import_picocolors61.default.dim("BRAINBASE_PROXY_URL")}    override the model-proxy URL used by harness traffic (default https://api.v1.brainbaselabs.com)`);
   out.push(`  ${import_picocolors61.default.dim("BRAINBASE_REGISTRY_URL")} override the registry API URL (default https://api.v1.brainbaselabs.com)`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainbase-labs/cli",
-  "version": "0.34.0",
+  "version": "0.36.0",
   "description": "Pack, share, and install agent templates across harnesses (Claude Code, Codex, ...).",
   "type": "module",
   "bin": {