@tuned-tensor/cli 0.13.0-beta.0 → 0.13.0-beta.1

package/dist/index.js

@@ -2,16 +2,19 @@
 import {
   TRAINING_MODELS,
   assertLocalRunInputReady,
+  createLocalStore,
+  defaultLocalHome,
   loadLocalRunInput,
   loadLocalRunnerConfig,
-  runLocalPipeline
-} from "./chunk-HDGBDHOB.js";
+  runLocalPipeline,
+  runReportSchema
+} from "./chunk-2VJ3VVZF.js";
 
 // src/cli.ts
 import { spawn as spawn2 } from "child_process";
 import { constants as osConstants2 } from "os";
 import { Command } from "commander";
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 
 // src/local-agent-client.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -1585,6 +1588,10 @@ function updateConfig(partial) {
   const current = readConfig();
   writeConfig({ ...current, ...partial });
 }
+var DEFAULT_BASE_URL = "https://tunedtensor.com";
+function getBaseUrl(opts) {
+  return opts?.baseUrl || process.env.TUNED_TENSOR_URL || readConfig().base_url || DEFAULT_BASE_URL;
+}
 function getApiKey(opts) {
   return opts?.apiKey || process.env.TUNED_TENSOR_API_KEY || readConfig().api_key;
 }
@@ -1608,7 +1615,7 @@ function getAgentSelection(env = process.env) {
 }
 
 // src/cli.ts
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 
 // src/agent.ts
 import chalk3 from "chalk";
@@ -1644,7 +1651,11 @@ var COMMAND_CATALOG = [
   { path: "models activate", description: "Activate a verified local model.", group: "Serving", modes: LOCAL },
   { path: "models rollback", description: "Roll back the active local model.", group: "Serving", modes: LOCAL },
   { path: "serve", description: "Serve a local adapter, active model, or base model.", group: "Serving", modes: LOCAL },
-  { path: "info", description: "Show local runtime package information.", group: "Inspect", modes: LOCAL }
+  { path: "info", description: "Show local runtime package information.", group: "Inspect", modes: LOCAL },
+  { path: "auth login", description: "Store a Tuned Tensor API key.", group: "Account", modes: LOCAL },
+  { path: "auth logout", description: "Remove the stored Tuned Tensor API key.", group: "Account", modes: LOCAL },
+  { path: "auth status", description: "Show Tuned Tensor authentication status.", group: "Account", modes: LOCAL },
+  { path: "publish", description: "Publish local run evidence to the dashboard.", group: "Account", modes: LOCAL }
 ];
 var SLASH_COMMANDS = [
   { path: "/help", description: "Show commands; add a word to filter." },
@@ -2644,13 +2655,13 @@ async function startInteractiveShell(options) {
   }
   let readline;
   const terminalInput = input;
-  const foregroundRunner = (request) => withForegroundSignalHandoff(
+  const foregroundRunner = (request2) => withForegroundSignalHandoff(
     {
       input: terminalInput,
       pauseReadline: () => readline?.pause(),
       resumeReadline: () => readline?.resume()
     },
-    () => options.runner(request)
+    () => options.runner(request2)
   );
   const session = await createShellSession({
     runner: foregroundRunner,
@@ -2964,10 +2975,10 @@ ${chalk3.yellow.bold("Approval required")}  ${chalk3.dim(action.id.slice(0, 8))}
 `);
     if (action.summary) this.options.io.write(`${sanitizeTerminalText2(action.summary)}
 `);
-    const request = [action.method, action.path].filter(Boolean).join(" ");
+    const request2 = [action.method, action.path].filter(Boolean).join(" ");
     const technical = {
       operation: action.operation,
-      ...request ? { request } : {},
+      ...request2 ? { request: request2 } : {},
       arguments: action.arguments ?? null,
       preview: action.preview ?? null
     };
@@ -3350,6 +3361,59 @@ var ApiError = class extends Error {
     this.name = "ApiError";
   }
 };
+function resolveKey(opts) {
+  const key = getApiKey(opts);
+  if (!key) {
+    throw new ApiError(
+      401,
+      "NO_API_KEY",
+      "No API key found. Run `tt auth login` or set TUNED_TENSOR_API_KEY."
+    );
+  }
+  return key;
+}
+function buildUrl(path, query, opts) {
+  const base = getBaseUrl(opts);
+  const url = new URL(`/api/v1${path}`, base);
+  if (query) {
+    for (const [k, v] of Object.entries(query)) {
+      if (v !== void 0) url.searchParams.set(k, String(v));
+    }
+  }
+  return url.toString();
+}
+async function request(method, path, options = {}) {
+  const key = resolveKey(options.opts);
+  const url = buildUrl(path, options.query, options.opts);
+  const headers = {
+    ...options.headers,
+    Authorization: `Bearer ${key}`
+  };
+  let bodyPayload;
+  if (options.body) {
+    headers["Content-Type"] = "application/json";
+    bodyPayload = JSON.stringify(options.body);
+  }
+  const res = await fetch(url, { method, headers, body: bodyPayload });
+  if (!res.ok) {
+    let errBody;
+    try {
+      errBody = await res.json();
+    } catch {
+      throw new ApiError(res.status, "UNKNOWN", res.statusText);
+    }
+    throw new ApiError(
+      res.status,
+      errBody.error?.code || "UNKNOWN",
+      errBody.error?.message || res.statusText
+    );
+  }
+  if (res.status === 204) return { data: null };
+  return await res.json();
+}
+function post(path, body, opts, headers) {
+  return request("POST", path, { body, opts, headers });
+}
 
 // src/output.ts
 var labelStyle = chalk4.bold.hex("#A78BFA");
@@ -4096,10 +4160,10 @@ function localCommandStreamsStdout(args2) {
   const serves = args2[0] === "serve" || args2[0] === "models" && args2[1] === "serve";
   return serves && !args2.includes("--print-command") && !args2.includes("--help") && !args2.includes("-h");
 }
-function parseJsonOutput(stdout) {
-  if (!stdout.trim()) return { hasJson: false, json: void 0 };
+function parseJsonOutput(stdout2) {
+  if (!stdout2.trim()) return { hasJson: false, json: void 0 };
   try {
-    return { hasJson: true, json: JSON.parse(stdout) };
+    return { hasJson: true, json: JSON.parse(stdout2) };
   } catch {
     return { hasJson: false, json: void 0 };
   }
@@ -4145,7 +4209,7 @@ async function spawnLocalCli(args2) {
     }
   );
   if (pipeInput && args2.stdin && child.stdin) args2.stdin.pipe(child.stdin);
-  let stdout = "";
+  let stdout2 = "";
   let stderr = "";
   child.stdout?.setEncoding("utf8");
   child.stderr?.setEncoding("utf8");
@@ -4155,7 +4219,7 @@ async function spawnLocalCli(args2) {
       args2.pathReplacements
     );
     if (args2.streamingStdout) writeStream(output, normalized);
-    else stdout += normalized;
+    else stdout2 += normalized;
   });
   child.stderr?.on("data", (chunk) => {
     const normalized = normalizeProjectedPaths(
@@ -4200,7 +4264,7 @@ async function spawnLocalCli(args2) {
       resolveChild({
         exitCode: spawnError ? 1 : code2 ?? signalExitCode(signal),
         signal,
-        stdout,
+        stdout: stdout2,
         stderr,
         ...spawnError ? { errorMessage: spawnError.message } : {}
       });
@@ -4414,9 +4478,294 @@ function registerAgentCommands(parent, options) {
   });
 }
 
+// src/commands/auth.ts
+import { createInterface as createInterface2 } from "readline/promises";
+import { stdin, stdout } from "process";
+import { Writable } from "stream";
+import chalk6 from "chalk";
+async function promptForApiKey(input = stdin, output = stdout) {
+  if (input.isTTY !== true || output.isTTY !== true) {
+    throw new Error(
+      "An API key is required in non-interactive mode. Pass it to `tt auth login <key>` or set TUNED_TENSOR_API_KEY."
+    );
+  }
+  let muted = false;
+  const maskedOutput = new Writable({
+    write(chunk, _encoding, callback) {
+      if (!muted) output.write(chunk);
+      callback();
+    }
+  });
+  const rl = createInterface2({
+    input,
+    output: maskedOutput,
+    terminal: true
+  });
+  try {
+    const pending = rl.question("Enter your API key (tt_...): ");
+    muted = true;
+    return await pending;
+  } finally {
+    muted = false;
+    output.write("\n");
+    rl.close();
+  }
+}
+function registerAuthCommands(parent) {
+  const auth = parent.command("auth").description("Manage authentication");
+  auth.command("login").description("Store an API key for authentication").argument("[key]", "API key (tt_...). If omitted, you will be prompted.").action(async (key) => {
+    let apiKey = key;
+    if (!apiKey) {
+      if (isJsonMode()) {
+        throw new Error(
+          "An API key argument is required in JSON mode. Use `tt --json auth login <key>`."
+        );
+      }
+      const settingsUrl = `${DEFAULT_BASE_URL}/dashboard/settings`;
+      console.log();
+      console.log(
+        `  To get your API key, go to ${chalk6.bold("Settings \u2192 API Keys")} in the Tuned Tensor dashboard:`
+      );
+      console.log(`  ${chalk6.hex("#A78BFA").underline(settingsUrl)}`);
+      console.log();
+      apiKey = await promptForApiKey();
+    }
+    apiKey = apiKey.trim();
+    if (!apiKey.startsWith("tt_") || apiKey.length !== 51) {
+      throw new Error(
+        "Invalid API key format. Keys start with tt_ and are 51 characters long."
+      );
+    }
+    updateConfig({ api_key: apiKey });
+    if (isJsonMode()) {
+      printJson({
+        authenticated: true,
+        key_prefix: `${apiKey.slice(0, 8)}...`,
+        base_url: getBaseUrl(parent.opts())
+      });
+      return;
+    }
+    printSuccess(
+      `API key stored (${apiKey.slice(0, 8)}...). You're ready to go.`
+    );
+  });
+  auth.command("logout").description("Remove stored credentials").action(() => {
+    const current = readConfig();
+    const { api_key: _removed, ...rest } = current;
+    writeConfig(rest);
+    if (isJsonMode()) {
+      printJson({ authenticated: false });
+      return;
+    }
+    printSuccess("Credentials removed.");
+  });
+  auth.command("status").description("Show current authentication status").action(() => {
+    const opts = parent.opts();
+    const apiKey = getApiKey(opts);
+    const baseUrl = getBaseUrl(opts);
+    if (isJsonMode()) {
+      printJson({
+        authenticated: !!apiKey,
+        key_prefix: apiKey ? apiKey.slice(0, 8) + "..." : null,
+        base_url: baseUrl
+      });
+      return;
+    }
+    if (apiKey) {
+      printDetail([
+        ["Authenticated", "Yes"],
+        ["API Key", apiKey.slice(0, 8) + "..."],
+        ["Base URL", baseUrl]
+      ]);
+    } else {
+      printWarning(
+        "Not authenticated. Run `tt auth login` to store an API key."
+      );
+      printDetail([["Base URL", baseUrl]]);
+    }
+  });
+}
+
+// src/commands/publish.ts
+import { createInterface as createInterface3 } from "readline/promises";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { homedir as homedir4 } from "os";
+import { isAbsolute as isAbsolute4, join as join7, resolve as resolve4 } from "path";
+import { stdin as defaultStdin, stdout as defaultStdout } from "process";
+var MAX_PUBLISH_BYTES = 2 * 1024 * 1024;
+function expandPath2(value, baseDirectory, homeDirectory) {
+  if (value === "~") return homeDirectory;
+  if (value.startsWith("~/")) return resolve4(homeDirectory, value.slice(2));
+  return isAbsolute4(value) ? resolve4(value) : resolve4(baseDirectory, value);
+}
+function resolvePublishStoreRoot(options) {
+  const cwd = options?.cwd ?? process.cwd();
+  const env = options?.env ?? process.env;
+  const homeDirectory = options?.homeDirectory ?? (env.HOME ? resolve4(env.HOME) : homedir4());
+  const localConfigPath = join7(cwd, "local-runner.json");
+  if (existsSync4(localConfigPath)) {
+    try {
+      const raw = JSON.parse(readFileSync4(localConfigPath, "utf-8"));
+      if (typeof raw.storeRoot === "string" && raw.storeRoot.trim()) {
+        return expandPath2(raw.storeRoot, cwd, homeDirectory);
+      }
+    } catch {
+    }
+  }
+  if (env.TT_LOCAL_HOME && env.TT_LOCAL_HOME.trim()) {
+    return expandPath2(env.TT_LOCAL_HOME, cwd, homeDirectory);
+  }
+  return defaultLocalHome();
+}
+async function confirmPublish(question, input = defaultStdin, output = defaultStdout) {
+  if (input.isTTY !== true || output.isTTY !== true) {
+    throw new Error(
+      "Publishing requires confirmation in interactive mode. Re-run with --yes."
+    );
+  }
+  const rl = createInterface3({ input, output, terminal: true });
+  try {
+    const answer = (await rl.question(question)).trim().toLowerCase();
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+function pickPublishableRun(runs, runId) {
+  if (runId) {
+    const exact = runs.find((run) => run.id === runId);
+    const prefixMatches = exact ? [exact] : runs.filter((run) => run.id.startsWith(runId));
+    if (prefixMatches.length === 0) {
+      throw new Error(`Run not found: ${runId}`);
+    }
+    if (prefixMatches.length > 1) {
+      throw new Error(
+        `Ambiguous run id prefix ${JSON.stringify(runId)}; matches ${prefixMatches.map((run) => shortId(run.id)).join(", ")}. Pass a longer prefix or the full id.`
+      );
+    }
+    const match = prefixMatches[0];
+    if (match.status !== "completed" && match.status !== "failed") {
+      throw new Error(
+        `Run ${shortId(match.id)} is still ${match.status}; only completed or failed runs can be published.`
+      );
+    }
+    return match;
+  }
+  const candidates = runs.filter((run) => run.status === "completed" || run.status === "failed").sort((a, b) => b.updated_at.localeCompare(a.updated_at));
+  const latest = candidates[0];
+  if (!latest) {
+    throw new Error(
+      "No completed or failed local runs found. Run `tt run` first, then publish."
+    );
+  }
+  return latest;
+}
+function assertPublishPayloadSize(payload) {
+  const bytes = Buffer.byteLength(JSON.stringify(payload), "utf8");
+  if (bytes > MAX_PUBLISH_BYTES) {
+    throw new Error(
+      `Publish payload is ${bytes} bytes; maximum is ${MAX_PUBLISH_BYTES} bytes. Reduce eval examples or publish a smaller run.`
+    );
+  }
+}
+function registerPublishCommand(parent) {
+  parent.command("publish").description("Publish local run evidence to the Tuned Tensor dashboard").argument("[runId]", "Local run id or prefix (defaults to latest completed/failed run)").option("-k, --api-key <key>", "API key (tt_...)").option("-u, --base-url <url>", "API base URL").option("-y, --yes", "Skip confirmation prompt").option("--dry-run", "Show what would be published without uploading").action(async (runId, cmdOpts) => {
+    const opts = {
+      apiKey: cmdOpts.apiKey,
+      baseUrl: cmdOpts.baseUrl
+    };
+    if (!cmdOpts.dryRun && !getApiKey(opts)) {
+      throw new Error(
+        "No API key found. Run `tt auth login` or set TUNED_TENSOR_API_KEY."
+      );
+    }
+    const storeRoot = resolvePublishStoreRoot();
+    const store = createLocalStore(storeRoot);
+    const runs = await store.listRuns();
+    const run = pickPublishableRun(runs, runId);
+    const rawReport = await store.getRunReport(run.id);
+    const report = runReportSchema.parse(rawReport);
+    const specRecord = await store.getSpec(run.behavior_spec_id);
+    const exampleCount = report.candidate.results.length || report.baseline.results.length;
+    const payload = {
+      spec: {
+        id: specRecord.id,
+        ...specRecord.spec
+      },
+      report
+    };
+    assertPublishPayloadSize(payload);
+    if (isJsonMode() && cmdOpts.dryRun) {
+      printJson({
+        dry_run: true,
+        store_root: storeRoot,
+        run_id: run.id,
+        spec_id: specRecord.id,
+        spec_name: specRecord.spec.name,
+        run_number: run.run_number,
+        status: run.status,
+        example_count: exampleCount,
+        payload
+      });
+      return;
+    }
+    if (!isJsonMode()) {
+      printDetail([
+        ["Spec", specRecord.spec.name],
+        ["Run", `${shortId(run.id)} (#${run.run_number})`],
+        ["Status", run.status],
+        ["Examples", String(exampleCount)],
+        ["Store", storeRoot]
+      ]);
+      printWarning(
+        "Prompts and model outputs from the run report will be uploaded to your Tuned Tensor account."
+      );
+    }
+    if (cmdOpts.dryRun) {
+      if (isJsonMode()) {
+        printJson({
+          dry_run: true,
+          run_id: run.id,
+          spec_id: specRecord.id,
+          example_count: exampleCount
+        });
+        return;
+      }
+      printSuccess("Dry run only \u2014 nothing was uploaded.");
+      return;
+    }
+    if (!cmdOpts.yes && !isJsonMode()) {
+      const ok = await confirmPublish("Publish this run evidence? [y/N] ");
+      if (!ok) {
+        printWarning("Publish cancelled.");
+        return;
+      }
+    }
+    if (!cmdOpts.yes && isJsonMode()) {
+      throw new Error(
+        "JSON mode requires --yes to publish without an interactive prompt."
+      );
+    }
+    const { data: data3 } = await post("/publish/runs", payload, opts);
+    const baseUrl = getBaseUrl(opts).replace(/\/$/, "");
+    const dashboardUrl = `${baseUrl}/dashboard/runs/${data3.id}`;
+    if (isJsonMode()) {
+      printJson({ ...data3, dashboard_url: dashboardUrl });
+      return;
+    }
+    printSuccess(
+      `Published run #${data3.run_number} (${shortId(data3.id)}) for ${specRecord.spec.name}`
+    );
+    printDetail([
+      ["Dashboard", dashboardUrl],
+      ["Spec ID", shortId(data3.spec_id)]
+    ]);
+  });
+}
+
 // src/commands/pipeline.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
-import { resolve as resolve4 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { resolve as resolve5 } from "path";
 var DEFAULT_PIPELINE_FILE = "tunedtensor.pipeline.json";
 function parseList(value) {
   if (!value) return void 0;
@@ -4425,10 +4774,10 @@ function parseList(value) {
   return ids;
 }
 function loadPipeline(path) {
-  const resolved = resolve4(path);
-  if (!existsSync4(resolved)) throw new Error(`Pipeline file not found: ${path}. Run \`tt pipeline init\` to create one.`);
+  const resolved = resolve5(path);
+  if (!existsSync5(resolved)) throw new Error(`Pipeline file not found: ${path}. Run \`tt pipeline init\` to create one.`);
   try {
-    return JSON.parse(readFileSync4(resolved, "utf8"));
+    return JSON.parse(readFileSync5(resolved, "utf8"));
   } catch (error) {
     throw new Error(`Pipeline file must be JSON: ${error.message}`);
   }
@@ -4444,8 +4793,8 @@ function outputPlan(plan) {
 function registerPipelineCommands(parent) {
   const pipeline = parent.command("pipeline").description("Create, validate, inspect, and safely dry-run ordered pipeline recipes");
   pipeline.command("init").description("Write a canonical v1 pipeline recipe").option("-f, --file <path>", "Output file", DEFAULT_PIPELINE_FILE).action((options) => {
-    const path = resolve4(options.file);
-    if (existsSync4(path)) throw new Error(`Pipeline file already exists: ${options.file}.`);
+    const path = resolve5(options.file);
+    if (existsSync5(path)) throw new Error(`Pipeline file already exists: ${options.file}.`);
     const recipe = canonicalPipeline("local");
     writeFileSync3(path, `${JSON.stringify(recipe, null, 2)}
 `);
@@ -4474,9 +4823,9 @@ function registerPipelineCommands(parent) {
     if (remote) {
       throw new Error(`Step "${remote.id}" targets cloud execution. This CLI is local-only; rewrite that step to local or use --dry-run.`);
     }
-    const input = await loadLocalRunInput(resolve4(options.spec));
+    const input = await loadLocalRunInput(resolve5(options.spec));
     assertLocalRunInputReady(input.request);
-    const config = await loadLocalRunnerConfig(options.config ? resolve4(options.config) : void 0);
+    const config = await loadLocalRunnerConfig(options.config ? resolve5(options.config) : void 0);
     const localPipeline = {
       version: 1,
       ...plan.name ? { name: plan.name } : {},
@@ -4539,7 +4888,7 @@ async function checkForCliUpdate(currentVersion, options = {}) {
   const controller = new AbortController();
   const timeoutMs = options.timeoutMs ?? 750;
   let timeout;
-  const request = (async () => {
+  const request2 = (async () => {
     try {
       const response = await (options.fetchImpl ?? fetch)(PACKAGE_LATEST_URL, {
         headers: { accept: "application/json" },
@@ -4558,14 +4907,14 @@ async function checkForCliUpdate(currentVersion, options = {}) {
       return null;
     }
   })();
-  const deadline = new Promise((resolve5) => {
+  const deadline = new Promise((resolve6) => {
     timeout = setTimeout(() => {
       controller.abort();
-      resolve5(null);
+      resolve6(null);
     }, timeoutMs);
   });
   try {
-    return await Promise.race([request, deadline]);
+    return await Promise.race([request2, deadline]);
   } finally {
     if (timeout) clearTimeout(timeout);
   }
@@ -4609,7 +4958,7 @@ async function createDefaultAgentClient(runtime, env, workspaceRoot, getModelRun
   const secret = getApiKey({ apiKey: env.TUNED_TENSOR_API_KEY });
   const providerSecrets = Object.entries(env).filter(([name, value]) => value && /(?:API_KEY|TOKEN|SECRET)$/i.test(name)).map(([, value]) => value).filter((value) => value.length >= 8 && value !== secret);
   return createLocalAgentClient({
-    store: runtime.agentStore ?? new LocalAgentStore(join7(getConfigDir(), "agent"), {
+    store: runtime.agentStore ?? new LocalAgentStore(join8(getConfigDir(), "agent"), {
       secretValues: [...secret ? [secret] : [], ...providerSecrets]
     }),
     workspaceRoot,
@@ -4658,7 +5007,7 @@ async function runSelfCommand(args2, options = {}) {
   if (!entrypoint) {
     throw new Error("Cannot locate the tt CLI entrypoint.");
   }
-  return await new Promise((resolve5, reject) => {
+  return await new Promise((resolve6, reject) => {
     const child = spawn2(process.execPath, [entrypoint, ...args2], {
       cwd: options.cwd,
       env: options.env ?? process.env,
@@ -4694,7 +5043,7 @@ async function runSelfCommand(args2, options = {}) {
     child.once("close", (exitCode, signal) => {
       cleanup();
       const signalNumber = signal ? osConstants2.signals[signal] : void 0;
-      resolve5({
+      resolve6({
         exitCode: exitCode ?? (typeof signalNumber === "number" ? 128 + signalNumber : 1),
         signal
       });
@@ -4715,10 +5064,10 @@ function createProgram(version, runtime = {}) {
   const launchShell = runtime.startShell ?? startInteractiveShell;
   const cwd = runtime.cwd ?? process.cwd();
   const getModelRuntime = createModelRuntimeGetter(runtime);
-  const shellRunner = async (request) => {
+  const shellRunner = async (request2) => {
     const root = program.opts();
-    return await invokeSelf(request.args, {
-      cwd: request.cwd,
+    return await invokeSelf(request2.args, {
+      cwd: request2.cwd,
       env: childEnvironment2(root, env),
       entrypoint: runtime.argv?.[1]
     });
@@ -4755,7 +5104,7 @@ function createProgram(version, runtime = {}) {
     if (root.json) setJsonMode(true);
     if (root.color === false) {
       process.env.FORCE_COLOR = "0";
-      chalk6.level = 0;
+      chalk7.level = 0;
     }
   });
   registerLocalCommands(program, {
@@ -4766,6 +5115,8 @@ function createProgram(version, runtime = {}) {
     stdout: runtime.stdout ?? process.stdout,
     stderr: runtime.stderr ?? process.stderr
   });
+  registerAuthCommands(program);
+  registerPublishCommand(program);
   registerPipelineCommands(program);
   registerAgentCommands(program, {
     env,
@@ -4784,12 +5135,12 @@ function createProgram(version, runtime = {}) {
 `);
       return;
     }
-    output.write(`${chalk6.bold.hex("#8B5CF6")("Tuned Tensor status")}
+    output.write(`${chalk7.bold.hex("#8B5CF6")("Tuned Tensor status")}
 `);
     output.write(`${formatShellStatus(context).join("\n")}
 
 `);
-    output.write(`${chalk6.bold("Context")}
+    output.write(`${chalk7.bold("Context")}
 `);
     output.write(`${formatShellContext(context).join("\n")}
 `);
@@ -4803,11 +5154,14 @@ Commands:
   tt status              Inspect local project context
   tt doctor              Check the host and run prerequisites
   tt run                 Fine-tune and evaluate on your GPU
+  tt auth                Store a dashboard API key
+  tt publish             Upload local run evidence to the dashboard
 
 Examples:
   tt doctor tunedtensor.json
   tt run tunedtensor.json --dry-run
   tt runs list
+  tt publish --yes
 `
   );
   return program;
@@ -4863,10 +5217,10 @@ async function runCli(version, runtime = {}) {
       error
     });
     await (runtime.startShell ?? startInteractiveShell)({
-      runner: async (request) => await invokeSelf(
-        request.args,
+      runner: async (request2) => await invokeSelf(
+        request2.args,
         {
-          cwd: request.cwd,
+          cwd: request2.cwd,
           env,
           entrypoint: argv[1]
         }
@@ -4887,7 +5241,7 @@ async function runCli(version, runtime = {}) {
 }
 
 // src/index.ts
-runCli("0.13.0-beta.0").catch((err) => {
+runCli("0.13.0-beta.1").catch((err) => {
   reportError(err);
   process.exit(1);
 });