@brainbase-labs/cli 0.49.0 → 0.51.0

package/README.md

@@ -116,18 +116,23 @@ this confirms admission or delivery, not task success.
 
 ## Renaming and labelling tasks
 
-Change a task's title, its metadata labels or its model, including while it runs:
+Label a task when you create it, find tasks by label, and change a task's
+title, its labels or its model, including while it runs:
 
 ```sh
-brainbase task update <task-id> --title "Nightly smoke run" --metadata env=staging
+brainbase task create --message "Nightly smoke run" --metadata env=staging
+brainbase task list --metadata env=staging
+brainbase task update <task-id> --title "Nightly smoke run" --metadata env=prod
 brainbase task update <task-id> --unset-metadata env --json
 brainbase task update <task-id> --model claude-sonnet-5-5
+brainbase task update <task-id> --clear-model
 ```
 
-`--metadata` and `--unset-metadata` keep every label you do not name.
-`--clear-metadata` removes them all, and `--clear-title` removes the title.
-`--model` switches the model the task's next turn runs on; a turn already
-running keeps its model. See
+`--metadata` and `--unset-metadata` keep every label you do not name, and
+edits from several clients at once all survive. `--clear-metadata` removes them
+all, and `--clear-title` removes the title. `--model` switches the model the
+task's next turn runs on; a turn already running keeps its model.
+`--clear-model` returns the task to its agent's default model. See
 [the command reference](docs/reference/commands.mdx) for every flag.
 
 ## Benchmark management

package/dist/index.js

@@ -36091,7 +36091,7 @@ function padStart(s, n) {
 // package.json
 var package_default = {
   name: "@brainbase-labs/cli",
-  version: "0.49.0",
+  version: "0.51.0",
   description: "Pack, share, and install agent templates across harnesses (Claude Code, Codex, ...).",
   type: "module",
   bin: {
@@ -68334,6 +68334,9 @@ var import_picocolors30 = __toESM(require_picocolors(), 1);
 function sanitizeLabel(s3) {
   return s3.replace(/\u001b\][\s\S]*?(?:\u0007|\u001b\\|$)/g, "").replace(/\u001b\[[\u0030-\u003f]*[\u0020-\u002f]*[\u0040-\u007e]?/g, "").replace(/\u001b[\s\S]?/g, "").replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029]/g, "");
 }
+function sanitizeLines(s3) {
+  return s3.split(/\r\n|[\n\r\u2028\u2029]/).map(sanitizeLabel);
+}
 
 // src/cli/agent-status.ts
 function capabilityDrifted(field) {
@@ -86110,8 +86113,173 @@ async function waitForAccount(agentId, slug, before2, options) {
 var import_picocolors68 = __toESM(require_picocolors(), 1);
 
 // src/cli/task-create.ts
-var import_picocolors63 = __toESM(require_picocolors(), 1);
+var import_picocolors64 = __toESM(require_picocolors(), 1);
 import { randomUUID as randomUUID4 } from "node:crypto";
+
+// src/cli/task-update.ts
+var import_picocolors63 = __toESM(require_picocolors(), 1);
+var TASK_UPDATE_USAGE = "brainbase task update <task-id> [--title <text> | --clear-title] [--metadata key=value]... [--unset-metadata <key>]... [--clear-metadata] [--model <id> | --clear-model] [--json]";
+var TITLE_MAX = 200;
+var MODEL_UNSUPPORTED = "This control plane does not support changing a task's model yet.";
+var CLEAR_MODEL_UNSUPPORTED = "This control plane does not support resetting a task's model yet.";
+async function runTaskUpdate(taskId, options) {
+  const title = validTitle(options);
+  const labels = validLabelEdit(options);
+  const model = validModel(options);
+  if (title === undefined && !labels && !options.clearMetadata && model === undefined && !options.clearModel) {
+    throw new Error(`Nothing to update: pass --title, --clear-title, --metadata, --unset-metadata, --clear-metadata, --model or --clear-model.
+` + `Usage: ${TASK_UPDATE_USAGE}`);
+  }
+  const input = {};
+  if (title !== undefined)
+    input.title = title;
+  if (options.clearMetadata) {
+    input.metadata = Object.fromEntries(labels?.set ?? []);
+  } else if (labels) {
+    input.metadata_patch = {
+      set: Object.fromEntries(labels.set),
+      unset: [...labels.unset]
+    };
+  }
+  if (model !== undefined)
+    input.model = model;
+  if (options.clearModel)
+    input.clear_model = true;
+  let task;
+  try {
+    task = await masApi.updateTask(taskId, input);
+  } catch (error2) {
+    if (!(error2 instanceof ApiError))
+      throw error2;
+    if (error2.status === 422 && rejectsBodyField(error2.body, "clear_model")) {
+      throw new ApiError(CLEAR_MODEL_UNSUPPORTED, error2.status, error2.body);
+    }
+    if (error2.status === 422 && rejectsBodyField(error2.body, "model")) {
+      throw new ApiError(MODEL_UNSUPPORTED, error2.status, error2.body);
+    }
+    if (labels && input.metadata_patch && mergeUnsupported(error2)) {
+      task = await updateByReplacingLabels(taskId, input, labels);
+    } else {
+      throw error2;
+    }
+  }
+  if (options.json) {
+    console.log(JSON.stringify(task, null, 2));
+    return;
+  }
+  banner("task update — rename or relabel a task");
+  console.log(format(task));
+}
+function mergeUnsupported(error2) {
+  return error2.status === 501 || error2.status === 422 && rejectsBodyField(error2.body, "metadata_patch");
+}
+async function updateByReplacingLabels(taskId, input, labels) {
+  const { metadata_patch: _merge, ...rest2 } = input;
+  const current = await masApi.getTask(taskId);
+  return masApi.updateTask(taskId, {
+    ...rest2,
+    metadata: applyLabelEdit(current.metadata ?? {}, labels)
+  });
+}
+function validTitle(options) {
+  if (options.clearTitle) {
+    if (options.title !== undefined) {
+      throw new Error("--title and --clear-title cannot be combined.");
+    }
+    return "";
+  }
+  if (options.title === undefined)
+    return;
+  const title = options.title.trim();
+  if (!title) {
+    throw new Error("--title must not be blank; use --clear-title to remove the title.");
+  }
+  if ([...title].length > TITLE_MAX) {
+    throw new Error(`--title must be at most ${TITLE_MAX} characters.`);
+  }
+  return title;
+}
+function validModel(options) {
+  if (options.model !== undefined && options.clearModel) {
+    throw new Error("--model and --clear-model cannot be combined.");
+  }
+  if (options.model === undefined)
+    return;
+  const model = options.model.trim();
+  if (!model)
+    throw new Error("--model must not be blank.");
+  if (!MODEL_ID_RE.test(model)) {
+    throw new Error(`--model "${sanitizeLabel(model)}" is not a valid model id: use letters, digits and . _ - : / only, at most 128 characters.`);
+  }
+  return model;
+}
+function parseLabelArgs(raw, flag = "--metadata") {
+  const labels = new Map;
+  for (const arg of raw ?? []) {
+    const equals = arg.indexOf("=");
+    if (equals < 0) {
+      throw new Error(`${flag} expects key=value, got "${arg}".`);
+    }
+    const key2 = arg.slice(0, equals).trim();
+    if (!key2) {
+      throw new Error(`${flag} needs a non-empty key, got "${arg}".`);
+    }
+    if (labels.has(key2)) {
+      throw new Error(`${flag} sets "${key2}" more than once.`);
+    }
+    labels.set(key2, arg.slice(equals + 1));
+  }
+  return labels;
+}
+function validLabelEdit(options) {
+  const set3 = parseLabelArgs(options.metadata);
+  const unset2 = new Set;
+  for (const raw of options.unsetMetadata ?? []) {
+    const key2 = raw.trim();
+    if (!key2)
+      throw new Error("--unset-metadata needs a non-empty key.");
+    if (set3.has(key2)) {
+      throw new Error(`"${key2}" is both set with --metadata and removed with --unset-metadata.`);
+    }
+    unset2.add(key2);
+  }
+  if (unset2.size > 0 && options.clearMetadata) {
+    throw new Error("--unset-metadata and --clear-metadata cannot be combined: --clear-metadata already removes every label.");
+  }
+  return set3.size > 0 || unset2.size > 0 ? { set: set3, unset: unset2 } : undefined;
+}
+function applyLabelEdit(current, edit) {
+  const next = new Map(Object.entries(current).filter(([key2]) => !edit.unset.has(key2)));
+  for (const [key2, value2] of edit.set)
+    next.set(key2, value2);
+  return Object.fromEntries(next);
+}
+function format(task) {
+  const lines = [""];
+  const title = task.title?.trim() ? sanitizeLabel(task.title) : import_picocolors63.default.dim("(untitled)");
+  lines.push(`  ${import_picocolors63.default.green("updated")}  ${import_picocolors63.default.bold(title)}`);
+  lines.push("");
+  lines.push(`  ${import_picocolors63.default.dim("task")}     ${sanitizeLabel(task.id)}`);
+  if (task.model !== undefined) {
+    const model = task.model?.trim() ? sanitizeLabel(task.model) : import_picocolors63.default.dim("agent default");
+    lines.push(`  ${import_picocolors63.default.dim("model")}    ${model}`);
+  }
+  const metadata = Object.entries(task.metadata ?? {});
+  lines.push("");
+  lines.push(`  ${import_picocolors63.default.bold(import_picocolors63.default.dim("METADATA"))}`);
+  if (metadata.length === 0) {
+    lines.push(`  ${import_picocolors63.default.dim("none")}`);
+  }
+  for (const [key2, value2] of metadata) {
+    lines.push(`  ${import_picocolors63.default.dim(sanitizeLabel(key2))}  ${sanitizeLabel(value2)}`);
+  }
+  lines.push("");
+  lines.push(`  ${import_picocolors63.default.dim("read it with")} ${import_picocolors63.default.cyan(`brainbase task get ${sanitizeLabel(task.id)}`)}`, "");
+  return lines.join(`
+`);
+}
+
+// src/cli/task-create.ts
 var DEFAULT_POLL_INTERVAL_MS2 = 2000;
 async function createTask(input, options) {
   return await masApi.createTask(input, options);
@@ -86164,6 +86332,7 @@ async function runTaskCreate(cwd2, options, dependencies = {}) {
   const title = optionalValue(options.title, "--title");
   const model = optionalValue(options.model, "--model");
   const versionRef = optionalValue(options.version, "--version");
+  const labels = parseLabelArgs(options.metadata);
   const version2 = versionRef ? (await agentVersionsApi.resolve(agentId, versionRef)).version : undefined;
   const input = {
     agent_id: agentId,
@@ -86172,7 +86341,8 @@ async function runTaskCreate(cwd2, options, dependencies = {}) {
     ...title ? { title } : {},
     ...model ? { default_model: model } : {},
     ...interfaceId ? { interface_id: interfaceId } : {},
-    ...version2 && { agent_version_id: version2.id }
+    ...version2 && { agent_version_id: version2.id },
+    ...labels.size > 0 ? { metadata: Object.fromEntries(labels) } : {}
   };
   let created;
   try {
@@ -86242,24 +86412,24 @@ async function waitForCreatedTask(created, options, dependencies, version2) {
       return;
     }
     if (outcome.kind === "timeout") {
-      console.log(import_picocolors63.default.yellow(`Timed out after ${options.timeoutSeconds}s with the task still ${status}.`));
+      console.log(import_picocolors64.default.yellow(`Timed out after ${options.timeoutSeconds}s with the task still ${status}.`));
       return;
     }
     if (outcome.kind === "interrupted") {
-      console.log(import_picocolors63.default.yellow("Interrupted. The task is still running."));
+      console.log(import_picocolors64.default.yellow("Interrupted. The task is still running."));
       return;
     }
-    console.log(code === 0 ? import_picocolors63.default.green("Task completed.") : import_picocolors63.default.red(`Task finished as ${status}.`));
+    console.log(code === 0 ? import_picocolors64.default.green("Task completed.") : import_picocolors64.default.red(`Task finished as ${status}.`));
   } finally {
     process.removeListener("SIGINT", onSigint);
   }
 }
 
 // src/cli/task-get.ts
-var import_picocolors65 = __toESM(require_picocolors(), 1);
+var import_picocolors66 = __toESM(require_picocolors(), 1);
 
 // src/cli/task-list.ts
-var import_picocolors64 = __toESM(require_picocolors(), 1);
+var import_picocolors65 = __toESM(require_picocolors(), 1);
 
 // src/core/agent-names.ts
 async function agentNames(ids) {
@@ -86283,64 +86453,87 @@ async function agentNames(ids) {
 }
 function agentLabel(id, names) {
   const name = names.get(id.toLowerCase());
-  return name ? `${name} (${id})` : id;
+  const safeId = sanitizeLabel(id);
+  return name ? `${name} (${safeId})` : safeId;
 }
 
 // src/cli/task-list.ts
 var INTERFACE_THREAD_METADATA_KEY = "brainbase_interface_id";
 async function runTaskList(options) {
+  const metadata = labelFilter(options);
   if (!options.json)
     banner("task list — recent tasks");
   const tasks = await masApi.listTasks({
     agentId: options.agentId,
     limit: options.limit,
-    ...options.interfaceId ? { metadata: { [INTERFACE_THREAD_METADATA_KEY]: options.interfaceId } } : {}
+    ...Object.keys(metadata).length > 0 ? { metadata } : {}
   });
   if (options.json) {
     console.log(JSON.stringify(tasks, null, 2));
     return;
   }
   const names = await agentNames(tasks.map((task) => task.agent_id));
-  console.log(formatTaskList(tasks, names, options.agentId, options.interfaceId));
+  const filtered = (options.metadata?.length ?? 0) > 0;
+  console.log(formatTaskList(tasks, names, options.agentId, options.interfaceId, filtered));
 }
-function formatTaskList(tasks, names, agentId, interfaceId) {
+function labelFilter(options) {
+  const labels = parseLabelArgs(options.metadata);
+  for (const key2 of labels.keys()) {
+    if (key2.includes(":")) {
+      throw new Error(`--metadata cannot filter on "${key2}": a key with ":" cannot be matched.`);
+    }
+  }
+  if (options.interfaceId) {
+    if (labels.has(INTERFACE_THREAD_METADATA_KEY)) {
+      throw new Error(`--interface already filters on ${INTERFACE_THREAD_METADATA_KEY}.`);
+    }
+    labels.set(INTERFACE_THREAD_METADATA_KEY, options.interfaceId);
+  }
+  return Object.fromEntries(labels);
+}
+function formatTaskList(tasks, names, agentId, interfaceId, labelFiltered = false) {
   const lines = [""];
+  if (tasks.length === 0 && labelFiltered) {
+    lines.push(`  ${import_picocolors65.default.dim("No tasks carry every label given with --metadata.")}`, "");
+    return lines.join(`
+`);
+  }
   if (tasks.length === 0 && interfaceId) {
     const id = sanitizeLabel(interfaceId);
-    lines.push(`  ${import_picocolors64.default.dim(`No build conversations for interface ${id}.`)}`, "", `  ${import_picocolors64.default.dim("start one with")} ${import_picocolors64.default.cyan(`brainbase interface build ${id} "..."`)}`, "");
+    lines.push(`  ${import_picocolors65.default.dim(`No build conversations for interface ${id}.`)}`, "", `  ${import_picocolors65.default.dim("start one with")} ${import_picocolors65.default.cyan(`brainbase interface build ${id} "..."`)}`, "");
     return lines.join(`
 `);
   }
   if (tasks.length === 0) {
-    lines.push(`  ${import_picocolors64.default.dim(agentId ? `No tasks for agent ${agentId}.` : "No tasks yet.")}`, "", `  ${import_picocolors64.default.dim("start one with")} ${import_picocolors64.default.cyan('brainbase task create --message "..."')}`, "");
+    lines.push(`  ${import_picocolors65.default.dim(agentId ? `No tasks for agent ${agentId}.` : "No tasks yet.")}`, "", `  ${import_picocolors65.default.dim("start one with")} ${import_picocolors65.default.cyan('brainbase task create --message "..."')}`, "");
     return lines.join(`
 `);
   }
   for (const task of tasks) {
-    const title = sanitizeLabel(task.title ?? "").trim() || import_picocolors64.default.dim("(untitled)");
-    lines.push(`  ${statusLabel(task.status)}  ${import_picocolors64.default.bold(title)}`);
-    lines.push(`    ${import_picocolors64.default.dim(task.id)}`);
-    lines.push(`    ${import_picocolors64.default.dim(`agent ${agentLabel(task.agent_id, names)} · created ${task.created_at}`)}`);
+    const title = sanitizeLabel(task.title ?? "").trim() || import_picocolors65.default.dim("(untitled)");
+    lines.push(`  ${statusLabel(task.status)}  ${import_picocolors65.default.bold(title)}`);
+    lines.push(`    ${import_picocolors65.default.dim(sanitizeLabel(task.id))}`);
+    lines.push(`    ${import_picocolors65.default.dim(`agent ${agentLabel(task.agent_id, names)} · created ${sanitizeLabel(task.created_at)}`)}`);
     lines.push("");
   }
-  lines.push(`  ${import_picocolors64.default.dim("inspect one with")} ${import_picocolors64.default.cyan("brainbase task get <id>")}`, "");
+  lines.push(`  ${import_picocolors65.default.dim("inspect one with")} ${import_picocolors65.default.cyan("brainbase task get <id>")}`, "");
   return lines.join(`
 `);
 }
 function statusLabel(status) {
-  const padded = status.padEnd(14);
+  const padded = sanitizeLabel(status).padEnd(14);
   switch (status) {
     case "success":
-      return import_picocolors64.default.green(padded);
+      return import_picocolors65.default.green(padded);
     case "fail":
-      return import_picocolors64.default.red(padded);
+      return import_picocolors65.default.red(padded);
     case "need_more_info":
-      return import_picocolors64.default.yellow(padded);
+      return import_picocolors65.default.yellow(padded);
     case "running":
     case "initializing":
-      return import_picocolors64.default.cyan(padded);
+      return import_picocolors65.default.cyan(padded);
     default:
-      return import_picocolors64.default.dim(padded);
+      return import_picocolors65.default.dim(padded);
   }
 }
 
@@ -86357,7 +86550,7 @@ async function runTaskGet(taskId, options = {}) {
     console.log(JSON.stringify(payload, null, 2));
     return;
   }
-  console.log(format(task, evals, await agentNames([task.agent_id])));
+  console.log(format2(task, evals, await agentNames([task.agent_id])));
 }
 async function readEvalRuns(task) {
   try {
@@ -86372,51 +86565,62 @@ async function readEvalRuns(task) {
     throw error2;
   }
 }
-function format(task, evals, names) {
+function format2(task, evals, names) {
   const lines = [""];
-  const title = task.title?.trim() || import_picocolors65.default.dim("(untitled)");
-  lines.push(`  ${statusLabel(task.status)}  ${import_picocolors65.default.bold(title)}`);
+  const title = sanitizeLabel(task.title ?? "").trim() || import_picocolors66.default.dim("(untitled)");
+  const id = sanitizeLabel(task.id);
+  lines.push(`  ${statusLabel(task.status)}  ${import_picocolors66.default.bold(title)}`);
   lines.push("");
-  lines.push(`  ${import_picocolors65.default.dim("task")}     ${task.id}`);
-  lines.push(`  ${import_picocolors65.default.dim("agent")}    ${agentLabel(task.agent_id, names)}`);
-  lines.push(`  ${import_picocolors65.default.dim("created")}  ${task.created_at}`);
+  lines.push(`  ${import_picocolors66.default.dim("task")}     ${id}`);
+  lines.push(`  ${import_picocolors66.default.dim("agent")}    ${agentLabel(task.agent_id, names)}`);
+  if (task.model !== undefined) {
+    const model = task.model?.trim() ? sanitizeLabel(task.model) : import_picocolors66.default.dim("agent default");
+    lines.push(`  ${import_picocolors66.default.dim("model")}    ${model}`);
+  }
+  lines.push(`  ${import_picocolors66.default.dim("created")}  ${sanitizeLabel(task.created_at)}`);
   if (task.parent_task_id) {
-    lines.push(`  ${import_picocolors65.default.dim("parent")}   ${task.parent_task_id}`);
+    lines.push(`  ${import_picocolors66.default.dim("parent")}   ${sanitizeLabel(task.parent_task_id)}`);
   }
   if (task.machine_id) {
-    lines.push(`  ${import_picocolors65.default.dim("machine")}  ${task.machine_id}${task.machine_size ? ` (size ${task.machine_size})` : ""}`);
+    const size2 = task.machine_size ? ` (size ${sanitizeLabel(task.machine_size)})` : "";
+    lines.push(`  ${import_picocolors66.default.dim("machine")}  ${sanitizeLabel(task.machine_id)}${size2}`);
   }
   if (task.sandbox_id)
-    lines.push(`  ${import_picocolors65.default.dim("sandbox")}  ${task.sandbox_id}`);
-  const failure = failureSummary(task);
+    lines.push(`  ${import_picocolors66.default.dim("sandbox")}  ${sanitizeLabel(task.sandbox_id)}`);
+  const [failure, ...failureRest] = sanitizeLines(failureSummary(task) ?? "").filter((line2) => line2.trim());
   if (failure) {
+    const label3 = "  failure  ";
     lines.push("");
-    lines.push(`  ${import_picocolors65.default.red("failure")}  ${failure}`);
+    lines.push(`  ${import_picocolors66.default.red("failure")}  ${failure}`);
+    for (const line2 of failureRest)
+      lines.push(`${" ".repeat(label3.length)}${line2}`);
   }
   const metadata = Object.entries(task.metadata ?? {});
   if (metadata.length > 0) {
     lines.push("");
-    lines.push(`  ${import_picocolors65.default.bold(import_picocolors65.default.dim("METADATA"))}`);
+    lines.push(`  ${import_picocolors66.default.bold(import_picocolors66.default.dim("METADATA"))}`);
     for (const [key2, value2] of metadata) {
-      lines.push(`  ${import_picocolors65.default.dim(key2)}  ${value2}`);
+      lines.push(`  ${import_picocolors66.default.dim(sanitizeLabel(key2))}  ${sanitizeLabel(String(value2))}`);
     }
   }
   lines.push("");
-  lines.push(`  ${import_picocolors65.default.bold(import_picocolors65.default.dim("EVAL VERDICTS"))}`);
+  lines.push(`  ${import_picocolors66.default.bold(import_picocolors66.default.dim("EVAL VERDICTS"))}`);
   if (evals.unavailable) {
-    lines.push(`  ${import_picocolors65.default.dim(evals.unavailable)}`);
+    lines.push(`  ${import_picocolors66.default.dim(sanitizeLabel(evals.unavailable))}`);
   } else if (evals.runs.length === 0) {
-    lines.push(`  ${import_picocolors65.default.dim("none")}`);
+    lines.push(`  ${import_picocolors66.default.dim("none")}`);
   } else {
     for (const run of evals.runs) {
-      const verdict = run.passed === true ? import_picocolors65.default.green("pass") : run.passed === false ? import_picocolors65.default.red("fail") : import_picocolors65.default.dim(run.status);
-      lines.push(`  ${verdict}  ${run.eval_slug ?? run.eval_id}`);
-      if (run.reasoning)
-        lines.push(`    ${import_picocolors65.default.dim(run.reasoning)}`);
+      const verdict = run.passed === true ? import_picocolors66.default.green("pass") : run.passed === false ? import_picocolors66.default.red("fail") : import_picocolors66.default.dim(sanitizeLabel(run.status));
+      lines.push(`  ${verdict}  ${sanitizeLabel(run.eval_slug ?? run.eval_id)}`);
+      for (const line2 of sanitizeLines(run.reasoning ?? "")) {
+        if (line2.trim())
+          lines.push(`    ${import_picocolors66.default.dim(line2)}`);
+      }
     }
   }
   lines.push("");
-  lines.push(`  ${import_picocolors65.default.dim("read its transcript with")} ${import_picocolors65.default.cyan(`brainbase task logs ${task.id}`)}`, "");
+  lines.push(`  ${import_picocolors66.default.dim("read its transcript with")} ${import_picocolors66.default.cyan(`brainbase task logs ${id}`)}`, "");
   return lines.join(`
 `);
 }
@@ -86433,7 +86637,7 @@ function failureSummary(task) {
 }
 
 // src/cli/task-logs.ts
-var import_picocolors66 = __toESM(require_picocolors(), 1);
+var import_picocolors67 = __toESM(require_picocolors(), 1);
 
 // src/core/task-events.ts
 var DEFAULT_RETRY_BUDGET_MS = 60000;
@@ -86716,14 +86920,14 @@ async function runTaskLogs(taskId, options = {}, dependencies = {}) {
     console.log(renderEvent(event, messages));
   }
   if (ordered.length === 0) {
-    console.log(import_picocolors66.default.dim("No events for this task yet."));
+    console.log(import_picocolors67.default.dim("No events for this task yet."));
   }
 }
 async function followTranscript(taskId, options, dependencies) {
   const backfill = options.limit === undefined ? "" : `?backfill=${options.limit}`;
   const { url: url2, resolveBearer } = await masStreamTarget(`/tasks/${encodeURIComponent(taskId)}/events/stream${backfill}`);
   if (!options.json) {
-    console.log(import_picocolors66.default.dim(`Following task ${taskId} — Ctrl-C to stop.`));
+    console.log(import_picocolors67.default.dim(`Following task ${taskId} — Ctrl-C to stop.`));
   }
   const setExitCode = dependencies.setExitCode ?? ((code) => process.exitCode = code);
   const controller = new AbortController;
@@ -86765,13 +86969,13 @@ async function followTranscript(taskId, options, dependencies) {
         } else if (options.json) {
           console.log(JSON.stringify(frame));
         } else {
-          console.log(import_picocolors66.default.dim(frame.type));
+          console.log(import_picocolors67.default.dim(frame.type));
         }
       },
       onOpen: () => settle.noteFrame(),
       onReconnect: (reason) => {
         settle.noteDisconnected();
-        console.error(import_picocolors66.default.dim(`reconnecting — ${reason}`));
+        console.error(import_picocolors67.default.dim(`reconnecting — ${reason}`));
       }
     });
     if (interruptCode !== undefined)
@@ -87104,137 +87308,6 @@ Omit --generation only for a deliberately new Stop.`;
 `));
 }
 
-// src/cli/task-update.ts
-var import_picocolors67 = __toESM(require_picocolors(), 1);
-var TASK_UPDATE_USAGE = "brainbase task update <task-id> [--title <text> | --clear-title] [--metadata key=value]... [--unset-metadata <key>]... [--clear-metadata] [--model <id>] [--json]";
-var TITLE_MAX = 200;
-var MODEL_UNSUPPORTED = "This control plane does not support changing a task's model yet.";
-async function runTaskUpdate(taskId, options) {
-  const title = validTitle(options);
-  const labels = validLabelEdit(options);
-  const model = validModel(options);
-  if (title === undefined && !labels && !options.clearMetadata && model === undefined) {
-    throw new Error(`Nothing to update: pass --title, --clear-title, --metadata, --unset-metadata, --clear-metadata or --model.
-` + `Usage: ${TASK_UPDATE_USAGE}`);
-  }
-  const input = {};
-  if (title !== undefined)
-    input.title = title;
-  if (options.clearMetadata) {
-    input.metadata = Object.fromEntries(labels?.set ?? []);
-  } else if (labels) {
-    const current = await masApi.getTask(taskId);
-    input.metadata = applyLabelEdit(current.metadata ?? {}, labels);
-  }
-  if (model !== undefined)
-    input.model = model;
-  let task;
-  try {
-    task = await masApi.updateTask(taskId, input);
-  } catch (error2) {
-    if (error2 instanceof ApiError && error2.status === 422 && rejectsBodyField(error2.body, "model")) {
-      throw new ApiError(MODEL_UNSUPPORTED, error2.status, error2.body);
-    }
-    throw error2;
-  }
-  if (options.json) {
-    console.log(JSON.stringify(task, null, 2));
-    return;
-  }
-  banner("task update — rename or relabel a task");
-  console.log(format2(task));
-}
-function validTitle(options) {
-  if (options.clearTitle) {
-    if (options.title !== undefined) {
-      throw new Error("--title and --clear-title cannot be combined.");
-    }
-    return "";
-  }
-  if (options.title === undefined)
-    return;
-  const title = options.title.trim();
-  if (!title) {
-    throw new Error("--title must not be blank; use --clear-title to remove the title.");
-  }
-  if ([...title].length > TITLE_MAX) {
-    throw new Error(`--title must be at most ${TITLE_MAX} characters.`);
-  }
-  return title;
-}
-function validModel(options) {
-  if (options.model === undefined)
-    return;
-  const model = options.model.trim();
-  if (!model)
-    throw new Error("--model must not be blank.");
-  if (!MODEL_ID_RE.test(model)) {
-    throw new Error(`--model "${sanitizeLabel(model)}" is not a valid model id: use letters, digits and . _ - : / only, at most 128 characters.`);
-  }
-  return model;
-}
-function validLabelEdit(options) {
-  const set3 = new Map;
-  for (const raw of options.metadata ?? []) {
-    const equals = raw.indexOf("=");
-    if (equals < 0) {
-      throw new Error(`--metadata expects key=value, got "${raw}".`);
-    }
-    const key2 = raw.slice(0, equals).trim();
-    if (!key2) {
-      throw new Error(`--metadata needs a non-empty key, got "${raw}".`);
-    }
-    if (set3.has(key2)) {
-      throw new Error(`--metadata sets "${key2}" more than once.`);
-    }
-    set3.set(key2, raw.slice(equals + 1));
-  }
-  const unset2 = new Set;
-  for (const raw of options.unsetMetadata ?? []) {
-    const key2 = raw.trim();
-    if (!key2)
-      throw new Error("--unset-metadata needs a non-empty key.");
-    if (set3.has(key2)) {
-      throw new Error(`"${key2}" is both set with --metadata and removed with --unset-metadata.`);
-    }
-    unset2.add(key2);
-  }
-  if (unset2.size > 0 && options.clearMetadata) {
-    throw new Error("--unset-metadata and --clear-metadata cannot be combined: --clear-metadata already removes every label.");
-  }
-  return set3.size > 0 || unset2.size > 0 ? { set: set3, unset: unset2 } : undefined;
-}
-function applyLabelEdit(current, edit) {
-  const next = new Map(Object.entries(current).filter(([key2]) => !edit.unset.has(key2)));
-  for (const [key2, value2] of edit.set)
-    next.set(key2, value2);
-  return Object.fromEntries(next);
-}
-function format2(task) {
-  const lines = [""];
-  const title = task.title?.trim() ? sanitizeLabel(task.title) : import_picocolors67.default.dim("(untitled)");
-  lines.push(`  ${import_picocolors67.default.green("updated")}  ${import_picocolors67.default.bold(title)}`);
-  lines.push("");
-  lines.push(`  ${import_picocolors67.default.dim("task")}     ${sanitizeLabel(task.id)}`);
-  if (task.model !== undefined) {
-    const model = task.model?.trim() ? sanitizeLabel(task.model) : import_picocolors67.default.dim("agent default");
-    lines.push(`  ${import_picocolors67.default.dim("model")}    ${model}`);
-  }
-  const metadata = Object.entries(task.metadata ?? {});
-  lines.push("");
-  lines.push(`  ${import_picocolors67.default.bold(import_picocolors67.default.dim("METADATA"))}`);
-  if (metadata.length === 0) {
-    lines.push(`  ${import_picocolors67.default.dim("none")}`);
-  }
-  for (const [key2, value2] of metadata) {
-    lines.push(`  ${import_picocolors67.default.dim(sanitizeLabel(key2))}  ${sanitizeLabel(value2)}`);
-  }
-  lines.push("");
-  lines.push(`  ${import_picocolors67.default.dim("read it with")} ${import_picocolors67.default.cyan(`brainbase task get ${sanitizeLabel(task.id)}`)}`, "");
-  return lines.join(`
-`);
-}
-
 // src/cli/task.ts
 var VALUE_FLAGS = [
   ["--agent", "agentId"],
@@ -87246,9 +87319,11 @@ var VALUE_FLAGS = [
   ["--timeout", "timeout"]
 ];
 var BOOLEAN_FLAGS = ["--json", "--wait"];
+var METADATA_FLAG = "--metadata";
 var TASK_OPTION_NAMES = new Set([
   ...VALUE_FLAGS.map(([flag]) => flag),
-  ...BOOLEAN_FLAGS
+  ...BOOLEAN_FLAGS,
+  METADATA_FLAG
 ]);
 var HELP_FLAGS = new Set(["--help", "-h"]);
 var LIST_LIMIT_MAX = 200;
@@ -87280,6 +87355,25 @@ function parseCreateArgs(args) {
         options.wait = true;
       continue;
     }
+    if (arg === METADATA_FLAG || arg.startsWith(`${METADATA_FLAG}=`)) {
+      let value2;
+      if (arg !== METADATA_FLAG) {
+        value2 = arg.slice(METADATA_FLAG.length + 1);
+      } else {
+        value2 = args[index + 1];
+        if (value2 === "--") {
+          value2 = args[index + 2];
+          index += 1;
+        } else if (value2 !== undefined && TASK_OPTION_NAMES.has(value2)) {
+          throw flagLikeValueError(METADATA_FLAG, value2);
+        }
+        if (value2 === undefined)
+          throw new Error("--metadata expects key=value.");
+        index += 1;
+      }
+      (options.metadata ??= []).push(value2);
+      continue;
+    }
     let matched = false;
     for (const [flag, option] of VALUE_FLAGS) {
       if (arg === flag) {
@@ -87412,16 +87506,18 @@ async function dispatchTask(cwd2, sub, args, setJson) {
       const parsed = parse6([
         { key: "agent", names: ["--agent"], kind: "value" },
         { key: "interface", names: ["--interface"], kind: "value" },
+        { key: "metadata", names: ["--metadata"], kind: "value", multiple: true },
         { key: "limit", names: ["--limit"], kind: "value" },
         { key: "json", names: ["--json"], kind: "boolean" }
       ]);
       if (parsed.positionals.length > 0) {
-        throw new Error("Usage: brainbase task list [--agent <id>] [--interface <id>] [--limit <n>] [--json]");
+        throw new Error("Usage: brainbase task list [--agent <id>] [--interface <id>] [--metadata key=value]... [--limit <n>] [--json]");
       }
       const interfaceId = optionalValue(stringOption(parsed, "interface"), "--interface");
       await runTaskList({
         agentId: stringOption(parsed, "agent"),
         interfaceId,
+        metadata: stringOptions(parsed, "metadata"),
         limit: positiveInteger(stringOption(parsed, "limit"), "--limit", LIST_LIMIT_MAX),
         json: booleanOption(parsed, "json")
       });
@@ -87473,6 +87569,7 @@ async function dispatchTask(cwd2, sub, args, setJson) {
         { key: "unsetMetadata", names: ["--unset-metadata"], kind: "value", multiple: true },
         { key: "clearMetadata", names: ["--clear-metadata"], kind: "boolean" },
         { key: "model", names: ["--model"], kind: "value" },
+        { key: "clearModel", names: ["--clear-model"], kind: "boolean" },
         { key: "json", names: ["--json"], kind: "boolean" },
         { key: "help", names: ["--help", "-h"], kind: "boolean" }
       ]);
@@ -87488,6 +87585,7 @@ async function dispatchTask(cwd2, sub, args, setJson) {
         unsetMetadata: stringOptions(parsed, "unsetMetadata"),
         clearMetadata: booleanOption(parsed, "clearMetadata"),
         model: stringOption(parsed, "model"),
+        clearModel: booleanOption(parsed, "clearModel"),
         json: booleanOption(parsed, "json")
       });
       return;
@@ -87563,7 +87661,7 @@ function printHelp5() {
   out.push(`  ${import_picocolors68.default.cyan("logs")} ${import_picocolors68.default.dim("<task-id> [--follow]")} ${import_picocolors68.default.dim("one line per event in the task's transcript, or tail it live")}`);
   out.push(`  ${import_picocolors68.default.cyan("send")} ${import_picocolors68.default.dim("<task-id> <message>")} ${import_picocolors68.default.dim("send a follow-up, including while the agent is running")}`);
   out.push(`  ${import_picocolors68.default.cyan("stop")} ${import_picocolors68.default.dim("<task-id>")}           ${import_picocolors68.default.dim("stop execution and cancel pending follow-ups, retaining their text")}`);
-  out.push(`  ${import_picocolors68.default.cyan("update")} ${import_picocolors68.default.dim("<task-id>")}         ${import_picocolors68.default.dim("rename a task, change its metadata labels or switch its model, including while it runs")}`);
+  out.push(`  ${import_picocolors68.default.cyan("update")} ${import_picocolors68.default.dim("<task-id>")}         ${import_picocolors68.default.dim("rename a task, change its metadata labels, switch its model or reset it to the agent default, including while it runs")}`);
   out.push(`  ${import_picocolors68.default.cyan("delete")} ${import_picocolors68.default.dim("<task-id>")}         ${import_picocolors68.default.dim("permanently delete a stopped task and tear down its sandbox (--yes to skip the prompt)")}`);
   out.push("");
   out.push(`  ${import_picocolors68.default.bold("create flags")}`);
@@ -87573,12 +87671,14 @@ function printHelp5() {
   out.push(`  ${import_picocolors68.default.dim("--title <text>")}     optional task title`);
   out.push(`  ${import_picocolors68.default.dim("--model <id>")}       optional model override`);
   out.push(`  ${import_picocolors68.default.dim("--version <v>")}      run a saved version of the agent: 12, v12 or a version id (\`agent versions list\`)`);
+  out.push(`  ${import_picocolors68.default.dim("--metadata key=value")} label the task (repeatable)`);
   out.push(`  ${import_picocolors68.default.dim("--wait")}             block until the task finishes; exit 1 unless it succeeded`);
   out.push(`  ${import_picocolors68.default.dim("--timeout <secs>")}   give up waiting after <secs> and exit 1 (needs --wait)`);
   out.push("");
   out.push(`  ${import_picocolors68.default.bold("list flags")}`);
   out.push(`  ${import_picocolors68.default.dim("--agent <id>")}       only this agent's tasks`);
   out.push(`  ${import_picocolors68.default.dim("--interface <id>")}   only this interface's build conversations (hidden from a plain list)`);
+  out.push(`  ${import_picocolors68.default.dim("--metadata key=value")} only tasks carrying this label (repeatable; all must match)`);
   out.push(`  ${import_picocolors68.default.dim("--limit <n>")}        cap the page (1-200, server default 50)`);
   out.push("");
   out.push(`  ${import_picocolors68.default.bold("logs flags")}`);
@@ -87590,9 +87690,10 @@ function printHelp5() {
   out.push(`  ${import_picocolors68.default.dim("--clear-title")}           remove the title; automatic titling may name the task again on a later turn`);
   out.push(`  ${import_picocolors68.default.dim("--metadata key=value")}    set one label, keeping the others (repeatable)`);
   out.push(`  ${import_picocolors68.default.dim("--unset-metadata <key>")}  remove one label (repeatable)`);
+  out.push(`  ${import_picocolors68.default.dim("                         the server applies label edits in one step, so concurrent edits from other clients are kept")}`);
   out.push(`  ${import_picocolors68.default.dim("--clear-metadata")}        remove every label; with --metadata, the labels become exactly those given`);
-  out.push(`  ${import_picocolors68.default.dim("                         label edits read the current labels first, so two writers at once can overwrite each other")}`);
   out.push(`  ${import_picocolors68.default.dim("--model <id>")}            switch the model the task's next turn runs on (the running turn keeps its model)`);
+  out.push(`  ${import_picocolors68.default.dim("--clear-model")}           go back to the agent's default model from the next turn`);
   out.push("");
   out.push(`  ${import_picocolors68.default.bold("send flags")}`);
   out.push(`  ${import_picocolors68.default.dim("--input-id <uuid>")}  recover the same request using its original ID and identical message`);
@@ -97011,7 +97112,32 @@ async function runBenchmark(sub, args, write3 = (value2) => process.stdout.write
   }
 }
 
+// src/ui/console-streams.ts
+import { format as format3 } from "node:util";
+function routeConsoleThroughStreams() {
+  if (typeof globalThis.Bun === "undefined")
+    return;
+  const writer = (stream) => (...args) => {
+    if (!stream.writable)
+      return;
+    stream.write(`${format3(...args)}
+`);
+  };
+  console.log = writer(process.stdout);
+  console.info = writer(process.stdout);
+  console.debug = writer(process.stdout);
+  console.warn = writer(process.stderr);
+  console.error = writer(process.stderr);
+  const ignoreClosedReader = (error2) => {
+    if (error2.code !== "EPIPE")
+      throw error2;
+  };
+  process.stdout.on("error", ignoreClosedReader);
+  process.stderr.on("error", ignoreClosedReader);
+}
+
 // src/index.ts
+routeConsoleThroughStreams();
 var PROTECTED = new Set([
   "template",
   "skill",
@@ -97096,12 +97222,12 @@ function help() {
   out.push(divider("TASKS"));
   out.push("");
   out.push(`  ${import_picocolors80.default.cyan("task create")} ${import_picocolors80.default.dim("--message <text>")}   ${import_picocolors80.default.dim("create a managed task and start its first run (--wait to block on it; --interface <id> for a build conversation)")}`);
-  out.push(`  ${import_picocolors80.default.cyan("task list")}                       ${import_picocolors80.default.dim("recent tasks you can reach (--interface <id> for its build conversations)")}`);
+  out.push(`  ${import_picocolors80.default.cyan("task list")}                       ${import_picocolors80.default.dim("recent tasks you can reach (--metadata k=v to filter by label; --interface <id> for its build conversations)")}`);
   out.push(`  ${import_picocolors80.default.cyan("task get")} ${import_picocolors80.default.dim("<task-id>")}              ${import_picocolors80.default.dim("one task: status, agent, machine, eval verdicts")}`);
   out.push(`  ${import_picocolors80.default.cyan("task logs")} ${import_picocolors80.default.dim("<task-id> [--follow]")}  ${import_picocolors80.default.dim("one line per event in the task's transcript, or tail it live")}`);
   out.push(`  ${import_picocolors80.default.cyan("task send")} ${import_picocolors80.default.dim("<task-id> <message>")}  ${import_picocolors80.default.dim("send a follow-up during execution, or queue it for the next turn")}`);
   out.push(`  ${import_picocolors80.default.cyan("task stop")} ${import_picocolors80.default.dim("<task-id>")}             ${import_picocolors80.default.dim("stop execution and cancel pending follow-ups, retaining their text")}`);
-  out.push(`  ${import_picocolors80.default.cyan("task update")} ${import_picocolors80.default.dim("<task-id>")}           ${import_picocolors80.default.dim("rename a task, change its metadata labels or switch its model, including while it runs")}`);
+  out.push(`  ${import_picocolors80.default.cyan("task update")} ${import_picocolors80.default.dim("<task-id>")}           ${import_picocolors80.default.dim("rename a task, change its metadata labels, switch its model or reset it to the agent default, including while it runs")}`);
   out.push(`  ${import_picocolors80.default.cyan("task delete")} ${import_picocolors80.default.dim("<task-id>")}           ${import_picocolors80.default.dim("permanently delete a stopped task and tear down its sandbox")}`);
   out.push("");
   out.push(divider("INTERFACES"));
@@ -97197,10 +97323,11 @@ function help() {
   out.push(`  ${import_picocolors80.default.dim("--message <text>")}   for task create: required first user message`);
   out.push(`  ${import_picocolors80.default.dim("--title <text>")}     for task create: optional task title; for task update: the new title`);
   out.push(`  ${import_picocolors80.default.dim("--clear-title")}      for task update: remove the title (automatic titling may name it again later)`);
-  out.push(`  ${import_picocolors80.default.dim("--metadata k=v")}     for task update: set one label, keeping the others (repeatable)`);
+  out.push(`  ${import_picocolors80.default.dim("--metadata k=v")}     for task create: label the task; for task list: only tasks with this label; for task update: set one label, keeping the others (all repeatable)`);
   out.push(`  ${import_picocolors80.default.dim("--unset-metadata <k>")} for task update: remove one label (repeatable)`);
   out.push(`  ${import_picocolors80.default.dim("--clear-metadata")}   for task update: remove every label; with --metadata, keep only those given`);
   out.push(`  ${import_picocolors80.default.dim("--model <id>")}       for task create: optional model override; for task update: switch the model the task's next turn runs on (the running turn keeps its model)`);
+  out.push(`  ${import_picocolors80.default.dim("--clear-model")}      for task update: go back to the agent's default model from the next turn`);
   out.push(`  ${import_picocolors80.default.dim("--version <v>")}      for task create: run a saved version of the agent (12, v12 or a version id)`);
   out.push(`  ${import_picocolors80.default.dim("--wait")}             for task create: block until the task finishes; exit 1 unless it succeeded`);
   out.push(`  ${import_picocolors80.default.dim("--timeout <secs>")}   for task create --wait: give up after <secs> and exit 1`);
@@ -97695,8 +97822,10 @@ ${didYouMean(cmd, COMMANDS3, "brainbase")}`);
         process14.exit(1);
     }
   } catch (err) {
+    const message2 = sanitizeLines(err.message).join(`
+`);
     console.error(import_picocolors80.default.red(`
-${err.message}`));
+${message2}`));
     if (err instanceof ApiError && err.status === 401 && !err.message.includes("brainbase login")) {
       console.error(`  Run ${import_picocolors80.default.cyan("brainbase login")} to connect this device.`);
     }

package/package.json

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