@brainbase-labs/cli 0.16.5 → 0.17.0

package/README.md

@@ -18,6 +18,8 @@ brainbase template pack         # bundle the current agent into a template
 brainbase template publish      # upload to the registry
 brainbase template search       # find templates published by your team
 brainbase template onboard <creator/slug>   # install or refresh a template
+brainbase agent create          # claim a local brainbase.agent.yaml
+brainbase task create --message "Review this project and propose next steps"
 ```
 
 Run `brainbase help` to see every command.
@@ -74,7 +76,7 @@ Playbook files carry a small YAML frontmatter (`title`, `description`) — the C
 
 | Variable | Purpose |
 |-|-|
-| `BRAINBASE_CONTROL_PLANE_URL` | Override the MAS control-plane host. Requests use `/v2/cli`; the default is `https://api.brainbaselabs.com`. |
+| `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_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. |
@@ -86,12 +88,14 @@ the server captured at login, and finally `https://api.v1.brainbaselabs.com`.
 
 ## Auth
 
-Two ways to authenticate, in priority order:
+Managed task creation uses this authentication precedence:
 
-1. `brainbase login` — interactive Supabase OAuth, stored in `~/.brainbase/auth.json`. Carries full scopes.
-2. `brainbase token create --scope publish` — long-lived PAT (`bbpat_…`) for CI / unattended use.
+1. `BRAINBASE_TOKEN` — an explicit PAT from the environment.
+2. `brainbase login` — a Supabase session stored in `~/.brainbase/auth.json`.
+3. `brainbase token create --scopes read,publish` — a PAT stored in `~/.brainbase/token.json` when no login session is configured.
 
-`BRAINBASE_TOKEN` env var overrides both.
+An explicit PAT does not inherit routing from a stored login. Set
+`BRAINBASE_CONTROL_PLANE_URL` when using a PAT against a non-default MAS host.
 
 ## License
 

package/dist/index.js

@@ -35141,7 +35141,7 @@ var require_dist2 = __commonJS((exports, module) => {
 });
 
 // src/index.ts
-var import_picocolors43 = __toESM(require_picocolors(), 1);
+var import_picocolors44 = __toESM(require_picocolors(), 1);
 import process14 from "node:process";
 import fs79 from "node:fs";
 
@@ -36008,7 +36008,7 @@ function padStart(s, n) {
 // package.json
 var package_default = {
   name: "@brainbase-labs/cli",
-  version: "0.16.5",
+  version: "0.17.0",
   description: "Pack, share, and install agent templates across harnesses (Claude Code, Codex, ...).",
   type: "module",
   bin: {
@@ -53841,9 +53841,80 @@ function apiErrorMessage(body, status) {
   return `HTTP ${status}`;
 }
 
+// src/core/token.ts
+import path57 from "node:path";
+import fs47 from "node:fs";
+var TOKEN_FILE = path57.join(BRAINBASE_HOME, "token.json");
+var TOKEN_PREFIX = "bbpat_";
+var TOKEN_PREFIX_LEN = 14;
+function tokenPrefix(token) {
+  if (!token.startsWith(TOKEN_PREFIX)) {
+    throw new Error(`not a brainbase PAT: missing ${TOKEN_PREFIX} prefix`);
+  }
+  return token.slice(0, TOKEN_PREFIX_LEN);
+}
+function isValidTokenFormat(token) {
+  if (typeof token !== "string")
+    return false;
+  if (!token.startsWith(TOKEN_PREFIX))
+    return false;
+  return /^bbpat_[A-Za-z0-9]{20,}$/.test(token);
+}
+var StoredTokenSchema = exports_external.object({
+  schemaVersion: exports_external.literal(1),
+  token: exports_external.string(),
+  prefix: exports_external.string(),
+  name: exports_external.string().optional(),
+  createdAt: exports_external.string()
+});
+function readToken() {
+  if (!exists(TOKEN_FILE))
+    return null;
+  try {
+    return StoredTokenSchema.parse(readJson(TOKEN_FILE));
+  } catch {
+    return null;
+  }
+}
+function writeToken(token, name) {
+  if (!isValidTokenFormat(token)) {
+    throw new Error("refusing to store token: invalid format");
+  }
+  ensureDir(BRAINBASE_HOME);
+  const stored = {
+    schemaVersion: 1,
+    token,
+    prefix: tokenPrefix(token),
+    name,
+    createdAt: new Date().toISOString()
+  };
+  writeJson(TOKEN_FILE, stored);
+  try {
+    fs47.chmodSync(TOKEN_FILE, 384);
+  } catch {}
+  return stored;
+}
+function clearToken() {
+  if (exists(TOKEN_FILE))
+    fs47.rmSync(TOKEN_FILE);
+}
+
 // src/core/api.ts
 var DEFAULT_CONTROL_PLANE_BASE = "https://api.brainbaselabs.com";
 var DEFAULT_PROXY_BASE = "https://api.v1.brainbaselabs.com";
+var MAS_IN_PROGRESS_MAX_WAIT_MS = 15000;
+var MAS_REQUEST_TIMEOUT_MS = 30000;
+var MAS_MIN_RETRY_DELAY_MS = 100;
+var MAS_MAX_RETRY_DELAY_MS = 2000;
+var DEFINITELY_UNSENT_NETWORK_CODES = new Set([
+  "ConnectionRefused",
+  "ECONNREFUSED",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "ERR_INVALID_URL",
+  "FailedToOpenSocket",
+  "UND_ERR_CONNECT_TIMEOUT"
+]);
 
 class ApiError extends Error {
   status;
@@ -53855,6 +53926,17 @@ class ApiError extends Error {
     this.name = "ApiError";
   }
 }
+
+class NetworkApiError extends ApiError {
+  definitelyUnsent;
+  constructor(message, definitelyUnsent) {
+    super(message);
+    this.definitelyUnsent = definitelyUnsent;
+  }
+}
+
+class TaskRecoveryDeadlineError extends ApiError {
+}
 function normalizeControlPlaneUrl(url) {
   const normalized = url?.trim().replace(/\/+$/, "");
   return normalized || DEFAULT_CONTROL_PLANE_BASE;
@@ -53870,10 +53952,17 @@ function controlPlaneBaseUrl(session) {
   }
   return normalizeControlPlaneUrl(session?.control_plane_url);
 }
+function masControlPlaneBaseUrl(session) {
+  const controlPlane = process.env.BRAINBASE_CONTROL_PLANE_URL?.trim();
+  return normalizeControlPlaneUrl(controlPlane || session?.control_plane_url);
+}
 function apiBase(session) {
   const suffix = usesLegacyControlPlane() ? "/api/cli" : "/v2/cli";
   return `${controlPlaneBaseUrl(session)}${suffix}`;
 }
+function masApiBase(session) {
+  return `${masControlPlaneBaseUrl(session)}/v2`;
+}
 function usesLegacyControlPlane() {
   return !process.env.BRAINBASE_CONTROL_PLANE_URL?.trim() && !!process.env.BRAINBASE_API_URL?.trim();
 }
@@ -53903,6 +53992,53 @@ async function resolveCredential() {
   const status = authStatus();
   throw new ApiError(status.ok ? "CLI authentication changed while this command was starting; retry it" : status.reason ?? "not logged in", 401);
 }
+async function resolveMasCredential() {
+  const configuredSession = readAuth();
+  try {
+    return await resolveCredential();
+  } catch (error) {
+    if (!(error instanceof ApiError && error.status === 401)) {
+      throw error;
+    }
+    if (configuredSession || readAuth()) {
+      if (readToken()) {
+        throw new ApiError(`${error.message}. A stored PAT is available but will not be used while a login session is configured. Run \`brainbase logout\` to use the stored PAT, or \`brainbase login\` to refresh the session.`, 401);
+      }
+      throw error;
+    }
+  }
+  const storedToken = readToken();
+  if (storedToken) {
+    return {
+      bearer: storedToken.token,
+      session: null,
+      source: "stored_pat"
+    };
+  }
+  const status = authStatus();
+  throw new ApiError(status.ok ? "CLI authentication changed while this command was starting; retry it" : status.reason ?? "not logged in", 401);
+}
+function networkErrorCode(error) {
+  if (!error || typeof error !== "object")
+    return;
+  const code = error.code;
+  if (typeof code === "string")
+    return code;
+  const cause = error.cause;
+  if (!cause || typeof cause !== "object")
+    return;
+  const causeCode = cause.code;
+  return typeof causeCode === "string" ? causeCode : undefined;
+}
+function isDefinitelyUnsentNetworkError(error) {
+  const code = networkErrorCode(error);
+  if (DEFINITELY_UNSENT_NETWORK_CODES.has(code ?? ""))
+    return true;
+  if (!error || typeof error !== "object")
+    return false;
+  const cause = error.cause;
+  return !!cause && typeof cause === "object" && cause.message === "bad port";
+}
 async function sendRequest(url, init, bearer) {
   const headers = new Headers(init.headers);
   if (!headers.has("Authorization")) {
@@ -53916,7 +54052,7 @@ async function sendRequest(url, init, bearer) {
   try {
     return await fetch(url, { ...init, headers });
   } catch (err) {
-    throw new ApiError(`Network error: ${err.message}`);
+    throw new NetworkApiError(`Network error: ${err.message}`, isDefinitelyUnsentNetworkError(err));
   }
 }
 async function sendWithAuthRetry(session, send) {
@@ -53945,6 +54081,160 @@ async function request(pathname, init = {}) {
   }
   return body;
 }
+function masApiErrorMessage(body, status) {
+  if (body && typeof body === "object") {
+    const obj = body;
+    if (typeof obj.error === "string" && obj.error.trim() && typeof obj.message === "string" && obj.message.trim()) {
+      const error = obj.error.trim();
+      const message = obj.message.trim();
+      return error === message ? message : `${error}: ${message}`;
+    }
+    for (const key2 of ["detail", "error", "message"]) {
+      const value = obj[key2];
+      if (!value || typeof value !== "object" || Array.isArray(value))
+        continue;
+      const nested = value;
+      for (const nestedKey of ["message", "detail", "error"]) {
+        const message = nested[nestedKey];
+        if (typeof message === "string" && message.trim()) {
+          return message.trim();
+        }
+      }
+    }
+  }
+  return apiErrorMessage(body, status);
+}
+function masRetryDelayMs(retryAfterHeader, fallbackMs) {
+  const normalized = retryAfterHeader?.trim();
+  if (!normalized)
+    return fallbackMs;
+  const retryAfterSeconds = Number(normalized);
+  if (!Number.isFinite(retryAfterSeconds) || retryAfterSeconds < 0) {
+    return fallbackMs;
+  }
+  return Math.min(MAS_MAX_RETRY_DELAY_MS, Math.max(MAS_MIN_RETRY_DELAY_MS, retryAfterSeconds * 1000));
+}
+function parseMasTaskCreateResponse(body) {
+  if (!body || typeof body !== "object") {
+    throw new ApiError("Task creation may have succeeded, but MAS returned an invalid response. Check your tasks before running this command again.", undefined, body);
+  }
+  const task = body;
+  if (typeof task.id !== "string" || !task.id.trim() || typeof task.agent_id !== "string" || !task.agent_id.trim() || typeof task.status !== "string" || !task.status.trim()) {
+    throw new ApiError("Task creation may have succeeded, but MAS returned an invalid response. Check your tasks before running this command again.", undefined, body);
+  }
+  return {
+    id: task.id,
+    agent_id: task.agent_id,
+    status: task.status
+  };
+}
+async function masRequest(pathname, init) {
+  const credential = await resolveMasCredential();
+  let currentSession = credential.session;
+  let ambiguousNetworkRetriesRemaining = 1;
+  let requestMayHaveSucceeded = false;
+  let transientHttpRetriesRemaining = 1;
+  let recoveryDeadline = null;
+  let recoveryTaskId = null;
+  const recoveryRequestTimeoutMs = () => {
+    if (recoveryDeadline === null)
+      return MAS_REQUEST_TIMEOUT_MS;
+    const remainingMs = recoveryDeadline - Date.now();
+    if (remainingMs <= 0) {
+      throw new TaskRecoveryDeadlineError(recoveryTaskId ? `Task ${recoveryTaskId} is still being processed. Check its status before starting another task.` : "Task creation may still be processing. Check your tasks before running this command again.");
+    }
+    return Math.min(MAS_REQUEST_TIMEOUT_MS, remainingMs);
+  };
+  while (true) {
+    const retrySession = credential.source === "session" ? currentSession : null;
+    let res;
+    try {
+      res = await sendWithAuthRetry(retrySession, async (refreshed) => {
+        if (refreshed)
+          currentSession = refreshed;
+        while (true) {
+          const signal = AbortSignal.timeout(recoveryRequestTimeoutMs());
+          try {
+            return await sendRequest(`${masApiBase(currentSession)}${pathname}`, {
+              ...init,
+              signal
+            }, currentSession?.access_token ?? credential.bearer);
+          } catch (error) {
+            if (error instanceof NetworkApiError && error.definitelyUnsent) {
+              throw error;
+            }
+            if (ambiguousNetworkRetriesRemaining === 0)
+              throw error;
+            requestMayHaveSucceeded = true;
+            ambiguousNetworkRetriesRemaining -= 1;
+          }
+        }
+      });
+    } catch (error) {
+      if (error instanceof TaskRecoveryDeadlineError)
+        throw error;
+      if (recoveryTaskId || recoveryDeadline !== null || requestMayHaveSucceeded) {
+        throw new ApiError(recoveryTaskId ? `Task ${recoveryTaskId} may still be processing. Check its status before starting another task. ${error.message}` : `Task creation may still be processing. Check your tasks before running this command again. ${error.message}`);
+      }
+      throw error;
+    }
+    let text2;
+    try {
+      text2 = await res.text();
+    } catch (error) {
+      if (ambiguousNetworkRetriesRemaining > 0) {
+        requestMayHaveSucceeded = true;
+        ambiguousNetworkRetriesRemaining -= 1;
+        continue;
+      }
+      throw new ApiError(recoveryTaskId ? `Task ${recoveryTaskId} may still be processing. Check its status before starting another task. ${error.message}` : recoveryDeadline !== null || requestMayHaveSucceeded ? `Task creation may still be processing. Check your tasks before running this command again. ${error.message}` : `Network error while reading response: ${error.message}`);
+    }
+    let body = text2;
+    try {
+      body = text2 ? JSON.parse(text2) : null;
+    } catch {}
+    const detail = body && typeof body === "object" ? body.detail : null;
+    const detailObject = detail && typeof detail === "object" ? detail : null;
+    const code = detailObject?.code;
+    if (res.status === 409 && code === "idempotency_request_in_progress") {
+      if (typeof detailObject?.task_id === "string") {
+        recoveryTaskId = detailObject.task_id;
+      }
+      recoveryDeadline ??= Date.now() + MAS_IN_PROGRESS_MAX_WAIT_MS;
+      const delayMs = masRetryDelayMs(res.headers.get("Retry-After"), 1000);
+      if (Date.now() + delayMs >= recoveryDeadline) {
+        throw new ApiError(recoveryTaskId ? `Task ${recoveryTaskId} is still being processed. Check its status before starting another task.` : masApiErrorMessage(body, res.status), res.status, body);
+      }
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+      continue;
+    }
+    if (res.status >= 500 && transientHttpRetriesRemaining > 0) {
+      transientHttpRetriesRemaining -= 1;
+      requestMayHaveSucceeded = true;
+      const delayMs = masRetryDelayMs(res.headers.get("Retry-After"), 250);
+      if (recoveryDeadline !== null && Date.now() + delayMs >= recoveryDeadline) {
+        throw new TaskRecoveryDeadlineError(recoveryTaskId ? `Task ${recoveryTaskId} is still being processed. Check its status before starting another task.` : "Task creation may still be processing. Check your tasks before running this command again.");
+      }
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+      continue;
+    }
+    if (!res.ok) {
+      const message = masApiErrorMessage(body, res.status);
+      throw new ApiError(res.status >= 500 ? `${message} Task creation may still be processing; check your tasks before running this command again.` : message, res.status, body);
+    }
+    return body;
+  }
+}
+var masApi = {
+  async createTask(input, options) {
+    const body = await masRequest("/tasks", {
+      method: "POST",
+      headers: { "Idempotency-Key": options.idempotencyKey },
+      body: JSON.stringify(input)
+    });
+    return parseMasTaskCreateResponse(body);
+  }
+};
 var api = {
   listOrgs() {
     return request("/orgs");
@@ -54059,64 +54349,6 @@ function proxyBaseUrl(session) {
   return DEFAULT_PROXY_BASE.replace(/\/+$/, "");
 }
 
-// src/core/token.ts
-import path57 from "node:path";
-import fs47 from "node:fs";
-var TOKEN_FILE = path57.join(BRAINBASE_HOME, "token.json");
-var TOKEN_PREFIX = "bbpat_";
-var TOKEN_PREFIX_LEN = 14;
-function tokenPrefix(token) {
-  if (!token.startsWith(TOKEN_PREFIX)) {
-    throw new Error(`not a brainbase PAT: missing ${TOKEN_PREFIX} prefix`);
-  }
-  return token.slice(0, TOKEN_PREFIX_LEN);
-}
-function isValidTokenFormat(token) {
-  if (typeof token !== "string")
-    return false;
-  if (!token.startsWith(TOKEN_PREFIX))
-    return false;
-  return /^bbpat_[A-Za-z0-9]{20,}$/.test(token);
-}
-var StoredTokenSchema = exports_external.object({
-  schemaVersion: exports_external.literal(1),
-  token: exports_external.string(),
-  prefix: exports_external.string(),
-  name: exports_external.string().optional(),
-  createdAt: exports_external.string()
-});
-function readToken() {
-  if (!exists(TOKEN_FILE))
-    return null;
-  try {
-    return StoredTokenSchema.parse(readJson(TOKEN_FILE));
-  } catch {
-    return null;
-  }
-}
-function writeToken(token, name) {
-  if (!isValidTokenFormat(token)) {
-    throw new Error("refusing to store token: invalid format");
-  }
-  ensureDir(BRAINBASE_HOME);
-  const stored = {
-    schemaVersion: 1,
-    token,
-    prefix: tokenPrefix(token),
-    name,
-    createdAt: new Date().toISOString()
-  };
-  writeJson(TOKEN_FILE, stored);
-  try {
-    fs47.chmodSync(TOKEN_FILE, 384);
-  } catch {}
-  return stored;
-}
-function clearToken() {
-  if (exists(TOKEN_FILE))
-    fs47.rmSync(TOKEN_FILE);
-}
-
 // src/core/registry-client.ts
 var DEFAULT_BASE = "https://api.v1.brainbaselabs.com";
 function baseUrl(session) {
@@ -76345,6 +76577,210 @@ async function runMcp(cwd2, sub, _argv, options) {
   }
 }
 
+// src/cli/task.ts
+var import_picocolors43 = __toESM(require_picocolors(), 1);
+
+// src/cli/task-create.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+async function createTask(input, options) {
+  return await masApi.createTask(input, options);
+}
+function requiredValue(value, flag) {
+  const normalized = value?.trim();
+  if (!normalized) {
+    throw new Error(`${flag} is required and must not be blank.`);
+  }
+  return normalized;
+}
+function optionalValue(value, flag) {
+  if (value === undefined)
+    return;
+  const normalized = value.trim();
+  if (!normalized) {
+    throw new Error(`${flag} must not be blank when provided.`);
+  }
+  return normalized;
+}
+function resolveAgentId(cwd2, agentId, readLocalManifest) {
+  if (agentId !== undefined) {
+    return requiredValue(agentId, "--agent");
+  }
+  const manifest = readLocalManifest(cwd2);
+  if (!manifest?.id) {
+    throw new Error("No claimed agent found in brainbase.agent.yaml. Run `brainbase agent create` first, or pass --agent <id>.");
+  }
+  return manifest.id;
+}
+function isPublishScopeError(error2) {
+  const message = error2 instanceof Error ? error2.message : String(error2);
+  const body = error2 && typeof error2 === "object" && "body" in error2 ? JSON.stringify(error2.body) : "";
+  return /PAT lacks required scope:\s*publish/i.test(`${message} ${body}`);
+}
+async function runTaskCreate(cwd2, options, dependencies = {}) {
+  const idempotencyKey = (dependencies.randomUUID ?? randomUUID2)();
+  const message = requiredValue(options.message, "--message");
+  const agentId = resolveAgentId(cwd2, options.agentId, dependencies.readManifest ?? readManifest);
+  const title = optionalValue(options.title, "--title");
+  const model = optionalValue(options.model, "--model");
+  const input = {
+    agent_id: agentId,
+    initial_messages: [{ role: "user", content: message }],
+    auto_run: true,
+    ...title ? { title } : {},
+    ...model ? { default_model: model } : {}
+  };
+  let created;
+  try {
+    created = await (dependencies.createTask ?? createTask)(input, {
+      idempotencyKey
+    });
+  } catch (error2) {
+    if (isPublishScopeError(error2)) {
+      throw new Error("PAT lacks required scope: publish. Mint a replacement with `brainbase token create --scopes read,publish` and try again.");
+    }
+    throw error2;
+  }
+  if (options.json) {
+    console.log(JSON.stringify({
+      task_id: created.id,
+      agent_id: created.agent_id,
+      status: created.status
+    }));
+    return;
+  }
+  console.log([
+    `Task ID: ${created.id}`,
+    `Agent ID: ${created.agent_id}`,
+    `Status: ${created.status}`,
+    "First run accepted."
+  ].join(`
+`));
+}
+
+// src/cli/task.ts
+var VALUE_FLAGS = [
+  ["--agent", "agentId"],
+  ["--message", "message"],
+  ["--title", "title"],
+  ["--model", "model"]
+];
+var TASK_OPTION_NAMES = new Set([
+  ...VALUE_FLAGS.map(([flag]) => flag),
+  "--json"
+]);
+var HELP_FLAGS = new Set(["--help", "-h"]);
+function missingValueError(flag) {
+  if (flag === "--message" || flag === "--agent") {
+    return new Error(`${flag} is required and must not be blank.`);
+  }
+  return new Error(`${flag} must not be blank when provided.`);
+}
+function flagLikeValueError(flag, value) {
+  return new Error(`${flag} requires a value. If you meant the literal "${value}", use ${flag}=${value} or ${flag} -- ${value}.`);
+}
+function parseCreateArgs(args) {
+  const options = {};
+  const seen = new Set;
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index];
+    if (HELP_FLAGS.has(arg)) {
+      return { help: true, options };
+    }
+    if (arg === "--json") {
+      if (seen.has(arg)) {
+        throw new Error(`Duplicate task create option: ${arg}`);
+      }
+      seen.add(arg);
+      options.json = true;
+      continue;
+    }
+    let matched = false;
+    for (const [flag, option] of VALUE_FLAGS) {
+      if (arg === flag) {
+        if (seen.has(flag)) {
+          throw new Error(`Duplicate task create option: ${flag}`);
+        }
+        seen.add(flag);
+        let value = args[index + 1];
+        if (value === undefined) {
+          throw missingValueError(flag);
+        }
+        if (value === "--") {
+          value = args[index + 2];
+          if (value === undefined)
+            throw missingValueError(flag);
+          index += 1;
+        } else if (HELP_FLAGS.has(value) && (option === "agentId" || option === "model")) {
+          return { help: true, options };
+        } else if (TASK_OPTION_NAMES.has(value)) {
+          throw flagLikeValueError(flag, value);
+        }
+        options[option] = value;
+        index += 1;
+        matched = true;
+        break;
+      }
+      const prefix = `${flag}=`;
+      if (arg.startsWith(prefix)) {
+        if (seen.has(flag)) {
+          throw new Error(`Duplicate task create option: ${flag}`);
+        }
+        seen.add(flag);
+        options[option] = arg.slice(prefix.length);
+        matched = true;
+        break;
+      }
+    }
+    if (!matched) {
+      throw new Error(`Unknown task create argument: ${arg}`);
+    }
+  }
+  return { help: false, options };
+}
+async function runTask(cwd2, sub, args) {
+  switch (sub) {
+    case "create": {
+      const parsed = parseCreateArgs(args);
+      if (parsed.help) {
+        printHelp3();
+        return;
+      }
+      await runTaskCreate(cwd2, parsed.options);
+      return;
+    }
+    case undefined:
+    case "help":
+    case "-h":
+    case "--help":
+      printHelp3();
+      return;
+    default:
+      console.error(`Unknown task subcommand: ${sub}
+`);
+      printHelp3();
+      process.exit(1);
+  }
+}
+function printHelp3() {
+  const out = [];
+  out.push("");
+  out.push(`  ${import_picocolors43.default.bold("brainbase task")} ${import_picocolors43.default.dim("<sub> [options]")}`);
+  out.push("");
+  out.push(`  ${import_picocolors43.default.cyan("create")} ${import_picocolors43.default.dim("--message <text>")}   ${import_picocolors43.default.dim("create a task and start its first run")}`);
+  out.push("");
+  out.push(`  ${import_picocolors43.default.bold("create flags")}`);
+  out.push(`  ${import_picocolors43.default.dim("--message <text>")}   required first user message`);
+  out.push(`  ${import_picocolors43.default.dim("--agent <id>")}       override the claimed agent in brainbase.agent.yaml`);
+  out.push(`  ${import_picocolors43.default.dim("--title <text>")}     optional task title`);
+  out.push(`  ${import_picocolors43.default.dim("--model <id>")}       optional model override`);
+  out.push(`  ${import_picocolors43.default.dim("--json")}             print task_id, agent_id, and status as JSON`);
+  out.push("");
+  out.push(`  ${import_picocolors43.default.dim("Flag-like values:")} use ${import_picocolors43.default.cyan("--flag=value")} or ${import_picocolors43.default.cyan("--flag -- <value>")}`);
+  out.push("");
+  console.log(out.join(`
+`));
+}
+
 // src/index.ts
 var PROTECTED = new Set([
   "template",
@@ -76365,100 +76801,108 @@ var STORED_PAT_COMMANDS = new Set([
 function help() {
   const out = [];
   out.push("");
-  out.push(`  ${brandTint("◆")}  ${import_picocolors43.default.bold("brainbase")}  ${import_picocolors43.default.dim(`v${VERSION}`)}`);
-  out.push(`     ${import_picocolors43.default.dim("connect your local agent to the brainbase platform")}`);
+  out.push(`  ${brandTint("◆")}  ${import_picocolors44.default.bold("brainbase")}  ${import_picocolors44.default.dim(`v${VERSION}`)}`);
+  out.push(`     ${import_picocolors44.default.dim("connect your local agent to the brainbase platform")}`);
   out.push("");
   out.push(divider("USAGE"));
   out.push("");
-  out.push(`  ${import_picocolors43.default.bold("brainbase")} ${import_picocolors43.default.dim("<command> [options]")}`);
+  out.push(`  ${import_picocolors44.default.bold("brainbase")} ${import_picocolors44.default.dim("<command> [options]")}`);
   out.push("");
   out.push(divider("AUTH"));
   out.push("");
-  out.push(`  ${import_picocolors43.default.cyan("login")}     ${import_picocolors43.default.dim("  open the web app and connect this device")}`);
-  out.push(`  ${import_picocolors43.default.cyan("logout")}    ${import_picocolors43.default.dim("  clear the local session")}`);
-  out.push(`  ${import_picocolors43.default.cyan("whoami")}    ${import_picocolors43.default.dim("  show the current user")}`);
+  out.push(`  ${import_picocolors44.default.cyan("login")}     ${import_picocolors44.default.dim("  open the web app and connect this device")}`);
+  out.push(`  ${import_picocolors44.default.cyan("logout")}    ${import_picocolors44.default.dim("  clear the local session")}`);
+  out.push(`  ${import_picocolors44.default.cyan("whoami")}    ${import_picocolors44.default.dim("  show the current user")}`);
   out.push("");
   out.push(divider("LINKED AGENT"));
   out.push("");
-  out.push(`  ${import_picocolors43.default.cyan("agent create")}               ${import_picocolors43.default.dim("claim an unclaimed brainbase.agent.yaml and create the cloud agent")}`);
-  out.push(`  ${import_picocolors43.default.cyan("agent pull")} ${import_picocolors43.default.dim("[<id>]")}          ${import_picocolors43.default.dim("bring cloud changes into this folder (--force to override; --run-entrypoint to also execute the agent entrypoint)")}`);
-  out.push(`  ${import_picocolors43.default.cyan("agent push")}                 ${import_picocolors43.default.dim("send local changes to the cloud (--force to overwrite cloud-side conflicts with local)")}`);
-  out.push(`  ${import_picocolors43.default.cyan("agent unpack")}               ${import_picocolors43.default.dim("install the claimed agent into a harness layout")}`);
-  out.push(`  ${import_picocolors43.default.cyan("link")}                       ${import_picocolors43.default.dim("attach this folder to an existing agent")}`);
-  out.push(`  ${import_picocolors43.default.cyan("agent status")}               ${import_picocolors43.default.dim("show what would pull and what would push")}`);
-  out.push(`  ${import_picocolors43.default.cyan("agent env")}                  ${import_picocolors43.default.dim("print export lines for `eval $(brainbase agent env)`")}`);
-  out.push(`  ${import_picocolors43.default.cyan("run")} ${import_picocolors43.default.dim("<cmd> [args...]")}         ${import_picocolors43.default.dim("run <cmd> with secrets.env loaded into env")}`);
-  out.push(`  ${import_picocolors43.default.cyan("status")}                     ${import_picocolors43.default.dim("show what this folder is linked to")}`);
-  out.push(`  ${import_picocolors43.default.cyan("unlink")}                     ${import_picocolors43.default.dim("disconnect this folder")}`);
+  out.push(`  ${import_picocolors44.default.cyan("agent create")}               ${import_picocolors44.default.dim("claim an unclaimed brainbase.agent.yaml and create the cloud agent")}`);
+  out.push(`  ${import_picocolors44.default.cyan("agent pull")} ${import_picocolors44.default.dim("[<id>]")}          ${import_picocolors44.default.dim("bring cloud changes into this folder (--force to override; --run-entrypoint to also execute the agent entrypoint)")}`);
+  out.push(`  ${import_picocolors44.default.cyan("agent push")}                 ${import_picocolors44.default.dim("send local changes to the cloud (--force to overwrite cloud-side conflicts with local)")}`);
+  out.push(`  ${import_picocolors44.default.cyan("agent unpack")}               ${import_picocolors44.default.dim("install the claimed agent into a harness layout")}`);
+  out.push(`  ${import_picocolors44.default.cyan("link")}                       ${import_picocolors44.default.dim("attach this folder to an existing agent")}`);
+  out.push(`  ${import_picocolors44.default.cyan("agent status")}               ${import_picocolors44.default.dim("show what would pull and what would push")}`);
+  out.push(`  ${import_picocolors44.default.cyan("agent env")}                  ${import_picocolors44.default.dim("print export lines for `eval $(brainbase agent env)`")}`);
+  out.push(`  ${import_picocolors44.default.cyan("run")} ${import_picocolors44.default.dim("<cmd> [args...]")}         ${import_picocolors44.default.dim("run <cmd> with secrets.env loaded into env")}`);
+  out.push(`  ${import_picocolors44.default.cyan("status")}                     ${import_picocolors44.default.dim("show what this folder is linked to")}`);
+  out.push(`  ${import_picocolors44.default.cyan("unlink")}                     ${import_picocolors44.default.dim("disconnect this folder")}`);
+  out.push("");
+  out.push(divider("TASKS"));
+  out.push("");
+  out.push(`  ${import_picocolors44.default.cyan("task create")} ${import_picocolors44.default.dim("--message <text>")}   ${import_picocolors44.default.dim("create a managed task and start its first run")}`);
   out.push("");
   out.push(divider("ORCHESTRATIONS"));
   out.push("");
-  out.push(`  ${import_picocolors43.default.cyan("orchestration create")}           ${import_picocolors43.default.dim("claim a local orchestration manifest and create it in the cloud")}`);
-  out.push(`  ${import_picocolors43.default.cyan("orchestration list")}             ${import_picocolors43.default.dim("list orchestrations under a team")}`);
-  out.push(`  ${import_picocolors43.default.cyan("orchestration pull")} ${import_picocolors43.default.dim("<id>")}        ${import_picocolors43.default.dim("recursively fetch an orchestration + every member agent")}`);
-  out.push(`  ${import_picocolors43.default.cyan("orchestration push")}             ${import_picocolors43.default.dim("recursively push each member, then update the graph")}`);
-  out.push(`  ${import_picocolors43.default.cyan("orchestration status")}           ${import_picocolors43.default.dim("show what would push and what would pull")}`);
+  out.push(`  ${import_picocolors44.default.cyan("orchestration create")}           ${import_picocolors44.default.dim("claim a local orchestration manifest and create it in the cloud")}`);
+  out.push(`  ${import_picocolors44.default.cyan("orchestration list")}             ${import_picocolors44.default.dim("list orchestrations under a team")}`);
+  out.push(`  ${import_picocolors44.default.cyan("orchestration pull")} ${import_picocolors44.default.dim("<id>")}        ${import_picocolors44.default.dim("recursively fetch an orchestration + every member agent")}`);
+  out.push(`  ${import_picocolors44.default.cyan("orchestration push")}             ${import_picocolors44.default.dim("recursively push each member, then update the graph")}`);
+  out.push(`  ${import_picocolors44.default.cyan("orchestration status")}           ${import_picocolors44.default.dim("show what would push and what would pull")}`);
   out.push("");
   out.push(divider("TEMPLATES"));
   out.push("");
-  out.push(`  ${import_picocolors43.default.cyan("template pack")}                       ${import_picocolors43.default.dim("bundle the current agent into a template")}`);
-  out.push(`  ${import_picocolors43.default.cyan("template publish")}                    ${import_picocolors43.default.dim("upload a template to the registry")}`);
-  out.push(`  ${import_picocolors43.default.cyan("template search")} ${import_picocolors43.default.dim("[query]")}             ${import_picocolors43.default.dim("search the registry")}`);
-  out.push(`  ${import_picocolors43.default.cyan("template info")}    ${import_picocolors43.default.dim("<creator/slug>")}     ${import_picocolors43.default.dim("show registry details for a template")}`);
-  out.push(`  ${import_picocolors43.default.cyan("template onboard")} ${import_picocolors43.default.dim("<creator/slug>")}     ${import_picocolors43.default.dim("install (or refresh) a template")}`);
-  out.push(`  ${import_picocolors43.default.cyan("template list")}                       ${import_picocolors43.default.dim("show installed templates")}`);
-  out.push(`  ${import_picocolors43.default.cyan("template remove")}  ${import_picocolors43.default.dim("<creator/slug>")}     ${import_picocolors43.default.dim("uninstall a template")}`);
+  out.push(`  ${import_picocolors44.default.cyan("template pack")}                       ${import_picocolors44.default.dim("bundle the current agent into a template")}`);
+  out.push(`  ${import_picocolors44.default.cyan("template publish")}                    ${import_picocolors44.default.dim("upload a template to the registry")}`);
+  out.push(`  ${import_picocolors44.default.cyan("template search")} ${import_picocolors44.default.dim("[query]")}             ${import_picocolors44.default.dim("search the registry")}`);
+  out.push(`  ${import_picocolors44.default.cyan("template info")}    ${import_picocolors44.default.dim("<creator/slug>")}     ${import_picocolors44.default.dim("show registry details for a template")}`);
+  out.push(`  ${import_picocolors44.default.cyan("template onboard")} ${import_picocolors44.default.dim("<creator/slug>")}     ${import_picocolors44.default.dim("install (or refresh) a template")}`);
+  out.push(`  ${import_picocolors44.default.cyan("template list")}                       ${import_picocolors44.default.dim("show installed templates")}`);
+  out.push(`  ${import_picocolors44.default.cyan("template remove")}  ${import_picocolors44.default.dim("<creator/slug>")}     ${import_picocolors44.default.dim("uninstall a template")}`);
   out.push("");
   out.push(divider("SKILLS"));
   out.push("");
-  out.push(`  ${import_picocolors43.default.cyan("skill add")} ${import_picocolors43.default.dim("<source>")}                  ${import_picocolors43.default.dim("install a skill (github / git / brainbase)")}`);
-  out.push(`  ${import_picocolors43.default.cyan("skill list")}                            ${import_picocolors43.default.dim("show locally installed skills + their source")}`);
-  out.push(`  ${import_picocolors43.default.cyan("skill update")} ${import_picocolors43.default.dim("<slug>")}                  ${import_picocolors43.default.dim("re-fetch a skill from its recorded source")}`);
-  out.push(`  ${import_picocolors43.default.cyan("skill remove")} ${import_picocolors43.default.dim("<slug>")}                  ${import_picocolors43.default.dim("uninstall a skill")}`);
-  out.push(`  ${import_picocolors43.default.cyan("skill search")} ${import_picocolors43.default.dim("[query]")}                 ${import_picocolors43.default.dim("search the brainbase skill registry")}`);
-  out.push(`  ${import_picocolors43.default.cyan("skill info")} ${import_picocolors43.default.dim("<creator/slug>")}            ${import_picocolors43.default.dim("show registry details for a skill")}`);
-  out.push(`  ${import_picocolors43.default.cyan("skill publish")} ${import_picocolors43.default.dim("[dir]")}                  ${import_picocolors43.default.dim("publish a SKILL.md folder (defaults to .)")}`);
+  out.push(`  ${import_picocolors44.default.cyan("skill add")} ${import_picocolors44.default.dim("<source>")}                  ${import_picocolors44.default.dim("install a skill (github / git / brainbase)")}`);
+  out.push(`  ${import_picocolors44.default.cyan("skill list")}                            ${import_picocolors44.default.dim("show locally installed skills + their source")}`);
+  out.push(`  ${import_picocolors44.default.cyan("skill update")} ${import_picocolors44.default.dim("<slug>")}                  ${import_picocolors44.default.dim("re-fetch a skill from its recorded source")}`);
+  out.push(`  ${import_picocolors44.default.cyan("skill remove")} ${import_picocolors44.default.dim("<slug>")}                  ${import_picocolors44.default.dim("uninstall a skill")}`);
+  out.push(`  ${import_picocolors44.default.cyan("skill search")} ${import_picocolors44.default.dim("[query]")}                 ${import_picocolors44.default.dim("search the brainbase skill registry")}`);
+  out.push(`  ${import_picocolors44.default.cyan("skill info")} ${import_picocolors44.default.dim("<creator/slug>")}            ${import_picocolors44.default.dim("show registry details for a skill")}`);
+  out.push(`  ${import_picocolors44.default.cyan("skill publish")} ${import_picocolors44.default.dim("[dir]")}                  ${import_picocolors44.default.dim("publish a SKILL.md folder (defaults to .)")}`);
   out.push("");
   out.push(divider("CLI TOKENS"));
   out.push("");
-  out.push(`  ${import_picocolors43.default.cyan("token create")}                        ${import_picocolors43.default.dim("issue a long-lived CLI key for CI / scripts")}`);
-  out.push(`  ${import_picocolors43.default.cyan("token list")}                          ${import_picocolors43.default.dim("show your active tokens")}`);
-  out.push(`  ${import_picocolors43.default.cyan("token revoke")} ${import_picocolors43.default.dim("<id>")}                  ${import_picocolors43.default.dim("revoke a token")}`);
+  out.push(`  ${import_picocolors44.default.cyan("token create")}                        ${import_picocolors44.default.dim("issue a long-lived CLI key for CI / scripts")}`);
+  out.push(`  ${import_picocolors44.default.cyan("token list")}                          ${import_picocolors44.default.dim("show your active tokens")}`);
+  out.push(`  ${import_picocolors44.default.cyan("token revoke")} ${import_picocolors44.default.dim("<id>")}                  ${import_picocolors44.default.dim("revoke a token")}`);
   out.push("");
   out.push(divider("MCP"));
   out.push("");
-  out.push(`  ${import_picocolors43.default.cyan("mcp check")} ${import_picocolors43.default.dim("[--json]")}              ${import_picocolors43.default.dim("verify MCP server connectivity through the brainbase proxy (runs at sandbox bootstrap)")}`);
+  out.push(`  ${import_picocolors44.default.cyan("mcp check")} ${import_picocolors44.default.dim("[--json]")}              ${import_picocolors44.default.dim("verify MCP server connectivity through the brainbase proxy (runs at sandbox bootstrap)")}`);
   out.push("");
   out.push(divider("FLAGS"));
   out.push("");
-  out.push(`  ${import_picocolors43.default.dim("--harness <id>")}     force harness for onboard / sync (e.g. claude-code)`);
-  out.push(`  ${import_picocolors43.default.dim("--scope <s>")}        force scope: global | project`);
-  out.push(`  ${import_picocolors43.default.dim("--yes, -y")}          skip confirmations / auto-overwrite`);
-  out.push(`  ${import_picocolors43.default.dim("--agent <id>")}       for link: attach this folder to an existing agent non-interactively`);
-  out.push(`  ${import_picocolors43.default.dim("--no-tracking")}      for link: skip routing LLM traffic through brainbase`);
-  out.push(`  ${import_picocolors43.default.dim("--track")}            for agent create: enable tracking non-interactively (off without a TTY)`);
-  out.push(`  ${import_picocolors43.default.dim("--shell <sh|fish>")}  for agent env: pick output format (auto-detected from $SHELL)`);
-  out.push(`  ${import_picocolors43.default.dim("--all")}              for template list: include installs from other folders`);
-  out.push(`  ${import_picocolors43.default.dim("--web <url>")}        for login: web app URL (default https://app.brainbaselabs.com)`);
+  out.push(`  ${import_picocolors44.default.dim("--harness <id>")}     force harness for onboard / sync (e.g. claude-code)`);
+  out.push(`  ${import_picocolors44.default.dim("--scope <s>")}        force scope: global | project`);
+  out.push(`  ${import_picocolors44.default.dim("--yes, -y")}          skip confirmations / auto-overwrite`);
+  out.push(`  ${import_picocolors44.default.dim("--agent <id>")}       for link/task create: use this agent id explicitly`);
+  out.push(`  ${import_picocolors44.default.dim("--message <text>")}   for task create: required first user message`);
+  out.push(`  ${import_picocolors44.default.dim("--title <text>")}     for task create: optional task title`);
+  out.push(`  ${import_picocolors44.default.dim("--model <id>")}       for task create: optional model override`);
+  out.push(`  ${import_picocolors44.default.dim("--json")}             for task create/mcp check: machine-readable output`);
+  out.push(`  ${import_picocolors44.default.dim("--no-tracking")}      for link: skip routing LLM traffic through brainbase`);
+  out.push(`  ${import_picocolors44.default.dim("--track")}            for agent create: enable tracking non-interactively (off without a TTY)`);
+  out.push(`  ${import_picocolors44.default.dim("--shell <sh|fish>")}  for agent env: pick output format (auto-detected from $SHELL)`);
+  out.push(`  ${import_picocolors44.default.dim("--all")}              for template list: include installs from other folders`);
+  out.push(`  ${import_picocolors44.default.dim("--web <url>")}        for login: web app URL (default https://app.brainbaselabs.com)`);
   out.push("");
   out.push(divider("ENV"));
   out.push("");
-  out.push(`  ${import_picocolors43.default.dim("BRAINBASE_HOME")}         override the local config dir (default ~/.brainbase)`);
-  out.push(`  ${import_picocolors43.default.dim("BRAINBASE_WEB_URL")}      override the web app URL used by login`);
-  out.push(`  ${import_picocolors43.default.dim("BRAINBASE_CONTROL_PLANE_URL")} override the MAS control-plane host (uses /v2/cli)`);
-  out.push(`  ${import_picocolors43.default.dim("BRAINBASE_API_URL")}      legacy KLS host override (uses /api/cli; proxy/registry fallback)`);
-  out.push(`  ${import_picocolors43.default.dim("BRAINBASE_PROXY_URL")}    override the model-proxy URL used by harness traffic (default https://api.v1.brainbaselabs.com)`);
-  out.push(`  ${import_picocolors43.default.dim("BRAINBASE_REGISTRY_URL")} override the registry API URL (default https://api.v1.brainbaselabs.com)`);
-  out.push(`  ${import_picocolors43.default.dim("BRAINBASE_TOKEN")}        long-lived CLI PAT (overrides token.json)`);
-  out.push(`  ${import_picocolors43.default.dim("BRAINBASE_SKIP_AUTH")}    bypass the auth gate for development`);
-  out.push(`  ${import_picocolors43.default.dim("BRAINBASE_NON_INTERACTIVE")} force non-interactive mode — skip/auto-default prompts (CI & agents)`);
-  out.push(`  ${import_picocolors43.default.dim("BRAINBASE_RUN_ENTRYPOINT")} =1 → agent pull executes the agent entrypoint (sandbox boots; or pass --run-entrypoint)`);
+  out.push(`  ${import_picocolors44.default.dim("BRAINBASE_HOME")}         override the local config dir (default ~/.brainbase)`);
+  out.push(`  ${import_picocolors44.default.dim("BRAINBASE_WEB_URL")}      override the web app URL used by login`);
+  out.push(`  ${import_picocolors44.default.dim("BRAINBASE_CONTROL_PLANE_URL")} override the MAS host (/v2/cli; task create uses /v2/tasks)`);
+  out.push(`  ${import_picocolors44.default.dim("BRAINBASE_API_URL")}      legacy KLS host override (uses /api/cli; proxy/registry fallback)`);
+  out.push(`  ${import_picocolors44.default.dim("BRAINBASE_PROXY_URL")}    override the model-proxy URL used by harness traffic (default https://api.v1.brainbaselabs.com)`);
+  out.push(`  ${import_picocolors44.default.dim("BRAINBASE_REGISTRY_URL")} override the registry API URL (default https://api.v1.brainbaselabs.com)`);
+  out.push(`  ${import_picocolors44.default.dim("BRAINBASE_TOKEN")}        long-lived CLI PAT (overrides token.json)`);
+  out.push(`  ${import_picocolors44.default.dim("BRAINBASE_SKIP_AUTH")}    bypass the auth gate for development`);
+  out.push(`  ${import_picocolors44.default.dim("BRAINBASE_NON_INTERACTIVE")} force non-interactive mode — skip/auto-default prompts (CI & agents)`);
+  out.push(`  ${import_picocolors44.default.dim("BRAINBASE_RUN_ENTRYPOINT")} =1 → agent pull executes the agent entrypoint (sandbox boots; or pass --run-entrypoint)`);
   out.push("");
   out.push(divider("HARNESSES"));
   out.push("");
-  out.push(`  ${import_picocolors43.default.dim("•")} ${import_picocolors43.default.bold("claude-code")}  ${import_picocolors43.default.dim("skills, mcps, agents, commands, playbooks, instructions, files")}`);
-  out.push(`  ${import_picocolors43.default.dim("•")} ${import_picocolors43.default.bold("codex")}        ${import_picocolors43.default.dim("skills, mcps, commands, playbooks, instructions, files")}`);
-  out.push(`  ${import_picocolors43.default.dim("•")} ${import_picocolors43.default.bold("kafka")}        ${import_picocolors43.default.dim("skills, mcps, agents, commands, playbooks, instructions, files")}`);
+  out.push(`  ${import_picocolors44.default.dim("•")} ${import_picocolors44.default.bold("claude-code")}  ${import_picocolors44.default.dim("skills, mcps, agents, commands, playbooks, instructions, files")}`);
+  out.push(`  ${import_picocolors44.default.dim("•")} ${import_picocolors44.default.bold("codex")}        ${import_picocolors44.default.dim("skills, mcps, commands, playbooks, instructions, files")}`);
+  out.push(`  ${import_picocolors44.default.dim("•")} ${import_picocolors44.default.bold("kafka")}        ${import_picocolors44.default.dim("skills, mcps, agents, commands, playbooks, instructions, files")}`);
   out.push("");
   console.log(out.join(`
 `));
@@ -76522,13 +76966,13 @@ async function requireAuth(cmd) {
   if (STORED_PAT_COMMANDS.has(cmd) && readToken())
     return;
   console.error("");
-  console.error(`  ${brandTint("◆")}  ${import_picocolors43.default.bold("brainbase")}`);
+  console.error(`  ${brandTint("◆")}  ${import_picocolors44.default.bold("brainbase")}`);
   console.error("");
-  console.error(`  ${import_picocolors43.default.red("✗")}  You need to sign in to use ${import_picocolors43.default.bold("brainbase " + cmd)}.`);
+  console.error(`  ${import_picocolors44.default.red("✗")}  You need to sign in to use ${import_picocolors44.default.bold("brainbase " + cmd)}.`);
   if (status.reason)
-    console.error(`     ${import_picocolors43.default.dim(status.reason)}`);
+    console.error(`     ${import_picocolors44.default.dim(status.reason)}`);
   console.error("");
-  console.error(`     Run ${import_picocolors43.default.cyan("brainbase login")} to connect this device.`);
+  console.error(`     Run ${import_picocolors44.default.cyan("brainbase login")} to connect this device.`);
   console.error("");
   process14.exit(1);
 }
@@ -76551,36 +76995,37 @@ async function main() {
     await runRun(cwd2, argv);
     return;
   }
-  const yes = hasFlag2(argv, "--yes", "-y");
-  const all = hasFlag2(argv, "--all");
-  const harness = getFlag(argv, "--harness");
-  const scopeFlag = getFlag(argv, "--scope");
-  const web = getFlag(argv, "--web");
-  const visibility = getFlag(argv, "--visibility");
-  const category = getFlag(argv, "--category");
-  const target = getFlag(argv, "--target");
-  const pageRaw = getFlag(argv, "--page");
+  const sharedArgs = cmd === "task" ? [] : argv;
+  const yes = hasFlag2(sharedArgs, "--yes", "-y");
+  const all = hasFlag2(sharedArgs, "--all");
+  const harness = getFlag(sharedArgs, "--harness");
+  const scopeFlag = getFlag(sharedArgs, "--scope");
+  const web = getFlag(sharedArgs, "--web");
+  const visibility = getFlag(sharedArgs, "--visibility");
+  const category = getFlag(sharedArgs, "--category");
+  const target = getFlag(sharedArgs, "--target");
+  const pageRaw = getFlag(sharedArgs, "--page");
   const page = pageRaw && /^\d+$/.test(pageRaw) ? Number(pageRaw) : undefined;
-  const asSlug = getFlag(argv, "--as");
-  const agentFlag = getFlag(argv, "--agent");
-  const shellFlag = getFlag(argv, "--shell");
-  const noTracking = hasFlag2(argv, "--no-tracking");
-  const track = hasFlag2(argv, "--track");
-  const forceFlag = hasFlag2(argv, "--force");
-  const runEntrypointFlag = hasFlag2(argv, "--run-entrypoint");
-  const graphOnlyFlag = hasFlag2(argv, "--graph-only");
-  const nameFlag = getFlag(argv, "--name");
-  const skillVersionFlag = getFlag(argv, "--skill-version");
-  const taglineFlag = getFlag(argv, "--tagline");
-  const orgIdFlag = getFlag(argv, "--org");
-  const teamIdFlag = getFlag(argv, "--team");
-  const fromFlags = getFlagAll(argv, "--from");
-  const toFlags = getFlagAll(argv, "--to");
-  const descriptionFlag = getFlag(argv, "--description");
-  const schemaFlag = getFlag(argv, "--schema");
-  const noPushFlag = hasFlag2(argv, "--no-push");
-  const jsonFlag = hasFlag2(argv, "--json");
-  const acpFlag = hasFlag2(argv, "--acp");
+  const asSlug = getFlag(sharedArgs, "--as");
+  const agentFlag = getFlag(sharedArgs, "--agent");
+  const shellFlag = getFlag(sharedArgs, "--shell");
+  const noTracking = hasFlag2(sharedArgs, "--no-tracking");
+  const track = hasFlag2(sharedArgs, "--track");
+  const forceFlag = hasFlag2(sharedArgs, "--force");
+  const runEntrypointFlag = hasFlag2(sharedArgs, "--run-entrypoint");
+  const graphOnlyFlag = hasFlag2(sharedArgs, "--graph-only");
+  const nameFlag = getFlag(sharedArgs, "--name");
+  const skillVersionFlag = getFlag(sharedArgs, "--skill-version");
+  const taglineFlag = getFlag(sharedArgs, "--tagline");
+  const orgIdFlag = getFlag(sharedArgs, "--org");
+  const teamIdFlag = getFlag(sharedArgs, "--team");
+  const fromFlags = getFlagAll(sharedArgs, "--from");
+  const toFlags = getFlagAll(sharedArgs, "--to");
+  const descriptionFlag = getFlag(sharedArgs, "--description");
+  const schemaFlag = getFlag(sharedArgs, "--schema");
+  const noPushFlag = hasFlag2(sharedArgs, "--no-push");
+  const jsonFlag = hasFlag2(sharedArgs, "--json");
+  const acpFlag = hasFlag2(sharedArgs, "--acp");
   ensureSkillResolversRegistered();
   await requireAuth(cmd);
   try {
@@ -76667,6 +77112,11 @@ async function main() {
         });
         break;
       }
+      case "task": {
+        const sub = argv.shift();
+        await runTask(cwd2, sub, argv);
+        break;
+      }
       case "orchestration":
       case "orch": {
         const sub = argv.shift();
@@ -76706,7 +77156,7 @@ async function main() {
         process14.exit(1);
     }
   } catch (err) {
-    console.error(import_picocolors43.default.red(`
+    console.error(import_picocolors44.default.red(`
 ${err.message}`));
     if (process14.env.BRAINBASE_DEBUG)
       console.error(err.stack);

package/package.json

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