@usezombie/zombiectl 0.3.0

package/src/lib/walk-dir.js

@@ -0,0 +1,41 @@
+import { readdirSync } from "node:fs";
+import { join } from "node:path";
+
+// Only universally safe ignores — language-specific build dirs (.zig-cache,
+// target, node_modules, vendor, etc.) are deferred to the agent walk milestone.
+const IGNORED_DIRS = new Set([".git", ".worktrees"]);
+
+/**
+ * Walk a directory (BFS, depth-limited) and collect file paths.
+ * @param {string} rootPath
+ * @param {number} maxDepth  default 5 — preview needs one extra level vs spec scan
+ * @returns {string[]} absolute file paths
+ */
+export function walkDir(rootPath, maxDepth = 5) {
+  const results = [];
+  const queue = [{ path: rootPath, depth: 0 }];
+
+  while (queue.length > 0) {
+    const { path: current, depth } = queue.shift();
+    if (depth > maxDepth) continue;
+
+    let entries;
+    try {
+      entries = readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      if (IGNORED_DIRS.has(entry.name)) continue;
+      const fullPath = join(current, entry.name);
+      if (entry.isDirectory()) {
+        queue.push({ path: fullPath, depth: depth + 1 });
+      } else if (entry.isFile()) {
+        results.push(fullPath);
+      }
+    }
+  }
+
+  return results;
+}

package/src/program/args.js

@@ -0,0 +1,95 @@
+const DEFAULT_API_URL = "http://localhost:3000";
+
+function normalizeApiUrl(url) {
+  return String(url || DEFAULT_API_URL).replace(/\/+$/, "");
+}
+
+function splitOption(token) {
+  const idx = token.indexOf("=");
+  if (idx === -1) return { key: token, value: null };
+  return { key: token.slice(0, idx), value: token.slice(idx + 1) };
+}
+
+function parseFlags(tokens) {
+  const options = {};
+  const positionals = [];
+
+  for (let i = 0; i < tokens.length; i += 1) {
+    const token = tokens[i];
+    if (!token.startsWith("--")) {
+      positionals.push(token);
+      continue;
+    }
+
+    const { key, value } = splitOption(token);
+    const normalized = key.slice(2);
+
+    if (value !== null) {
+      options[normalized] = value;
+      continue;
+    }
+
+    const next = tokens[i + 1];
+    if (next && !next.startsWith("--")) {
+      options[normalized] = next;
+      i += 1;
+      continue;
+    }
+
+    options[normalized] = true;
+  }
+
+  return { options, positionals };
+}
+
+function parseGlobalArgs(argv, env = process.env) {
+  const options = {
+    json: false,
+    noInput: false,
+    noOpen: false,
+    help: false,
+    version: false,
+    api: null,
+  };
+
+  const rest = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (token === "--json") {
+      options.json = true;
+    } else if (token === "--no-input") {
+      options.noInput = true;
+    } else if (token === "--no-open") {
+      options.noOpen = true;
+    } else if (token === "--help" || token === "-h") {
+      options.help = true;
+    } else if (token === "--version") {
+      options.version = true;
+    } else if (token === "--api") {
+      options.api = argv[i + 1] || null;
+      i += 1;
+    } else if (token.startsWith("--api=")) {
+      options.api = token.slice("--api=".length);
+    } else {
+      rest.push(token);
+    }
+  }
+
+  const derived = {
+    apiUrl: normalizeApiUrl(options.api || env.ZOMBIE_API_URL || env.API_URL || DEFAULT_API_URL),
+    json: options.json,
+    noInput: options.noInput,
+    noOpen: options.noOpen,
+    help: options.help,
+    version: options.version,
+  };
+
+  return { global: derived, rest };
+}
+
+export {
+  DEFAULT_API_URL,
+  normalizeApiUrl,
+  parseFlags,
+  parseGlobalArgs,
+};

package/src/program/auth-guard.js

@@ -0,0 +1,12 @@
+/**
+ * Authentication guard — blocks unauthenticated access to protected commands.
+ */
+
+export function requireAuth(ctx) {
+  if (ctx.token || ctx.apiKey) {
+    return { ok: true };
+  }
+  return { ok: false };
+}
+
+export const AUTH_FAIL_MESSAGE = "not authenticated \u2014 run `zombiectl login` first";

package/src/program/auth-token.js

@@ -0,0 +1,44 @@
+function decodeTokenPayload(token) {
+  if (!token || typeof token !== "string") return null;
+  const parts = token.split(".");
+  if (parts.length < 2 || !parts[1]) return null;
+  try {
+    const base64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+    const padded = base64 + "===".slice((base64.length + 3) % 4);
+    return JSON.parse(Buffer.from(padded, "base64").toString("utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function extractDistinctIdFromToken(token) {
+  const payload = decodeTokenPayload(token);
+  if (payload && typeof payload.sub === "string" && payload.sub.trim().length > 0) {
+    return payload.sub.trim();
+  }
+  return null;
+}
+
+function extractRoleFromToken(token) {
+  const payload = decodeTokenPayload(token);
+  if (!payload) return null;
+
+  const candidates = [
+    payload.role,
+    payload.metadata?.role,
+    payload.custom_claims?.role,
+    payload.app_metadata?.role,
+    payload["https://usezombie.dev/role"],
+    payload["https://usezombie.com/role"],
+    payload.metadata?.["https://usezombie.dev/role"],
+    payload.metadata?.["https://usezombie.com/role"],
+  ];
+  for (const raw of candidates) {
+    if (typeof raw !== "string") continue;
+    const value = raw.toLowerCase();
+    if (value === "user" || value === "operator" || value === "admin") return value;
+  }
+  return null;
+}
+
+export { decodeTokenPayload, extractDistinctIdFromToken, extractRoleFromToken };

package/src/program/banner.js

@@ -0,0 +1,46 @@
+/**
+ * CLI banner for --help and --version output.
+ */
+
+export function printBanner(stream, version, opts = {}) {
+  const noColor = opts.noColor || false;
+  const jsonMode = opts.jsonMode || false;
+
+  if (jsonMode) return;
+
+  const label = `  zombiectl v${version}   `;
+
+  if (noColor) {
+    stream.write(`zombiectl v${version}\n`);
+    return;
+  }
+
+  const c = (code, s) => `\u001b[${code}m${s}\u001b[0m`;
+  const bar = "\u2500".repeat(label.length);
+
+  stream.write(`    ${c("1;36", `\u256D${bar}\u256E`)}\n`);
+  stream.write(` \u{1F9DF} ${c("1;36", "\u2502")}${c("1;37", label)}${c("1;36", "\u2502")}\n`);
+  stream.write(`    ${c("1;36", `\u2570${bar}\u256F`)}\n`);
+  stream.write(`    ${c("2", "  autonomous agent cli")}\n`);
+}
+
+export function printPreReleaseWarning(stream, opts = {}) {
+  const noColor = opts.noColor || false;
+  const jsonMode = opts.jsonMode || false;
+  const ttyOnly = opts.ttyOnly || false;
+
+  if (jsonMode) return;
+  if (ttyOnly) return;
+
+  if (noColor) {
+    stream.write(`\n[PRE-RELEASE] This is a pre-release build for early access testing.\n`);
+    stream.write(`Contact nkishore@megam.io to get access.\n`);
+    stream.write(`General availability: April 5, 2026\n\n`);
+    return;
+  }
+
+  const c = (code, s) => `\u001b[${code}m${s}\u001b[0m`;
+  stream.write(`\n  ${c("1;33", "⚠  Pre-release build")} — not for production use.\n`);
+  stream.write(`     Early access testing only. Contact ${c("1;37", "nkishore@megam.io")} to get access.\n`);
+  stream.write(`     General availability: ${c("1;37", "April 5, 2026")}\n\n`);
+}

package/src/program/command-registry.js

@@ -0,0 +1,17 @@
+export function registerProgramCommands(handlers) {
+  return {
+    login: handlers.login,
+    logout: handlers.logout,
+    workspace: handlers.workspace,
+    "specs.sync": handlers.specsSync,
+    "spec.init": handlers.specInit,
+    run: handlers.run,
+    "runs.list": handlers.runsList,
+    "runs.cancel": handlers.runsCancel,
+    doctor: handlers.doctor,
+    harness: handlers.harness,
+    "skill-secret": handlers.skillSecret,
+    agent: handlers.agent,
+    admin: handlers.admin,
+  };
+}

package/src/program/http-client.js

@@ -0,0 +1,38 @@
+import { ApiError, apiRequest, authHeaders } from "../lib/http.js";
+
+function apiHeaders(ctx) {
+  return authHeaders({ token: ctx.token, apiKey: ctx.apiKey });
+}
+
+async function request(ctx, reqPath, options = {}) {
+  const url = `${ctx.apiUrl}${reqPath}`;
+  return apiRequest(url, {
+    ...options,
+    fetchImpl: ctx.fetchImpl,
+  });
+}
+
+function printApiError(stderr, err, jsonMode, printJson, writeLine) {
+  if (!(err instanceof ApiError)) throw err;
+  const payload = {
+    error: {
+      code: err.code || "API_ERROR",
+      message: err.message,
+      status: err.status || null,
+      request_id: err.requestId || null,
+    },
+  };
+  if (jsonMode) {
+    printJson(stderr, payload);
+  } else {
+    writeLine(stderr, `error: ${payload.error.code} ${payload.error.message}`);
+    if (payload.error.request_id) writeLine(stderr, `request_id: ${payload.error.request_id}`);
+  }
+}
+
+export {
+  ApiError,
+  apiHeaders,
+  printApiError,
+  request,
+};

package/src/program/io.js

@@ -0,0 +1,83 @@
+import { printBanner } from "./banner.js";
+
+function writeLine(stream, line = "") {
+  stream.write(`${line}\n`);
+}
+
+function printJson(stream, value) {
+  writeLine(stream, JSON.stringify(value, null, 2));
+}
+
+function printHelp(stdout, ui, opts = {}) {
+  const version = opts.version || "0.1.0";
+  const noColor = Boolean(opts.env?.NO_COLOR === "1" || opts.env?.NO_COLOR === "true");
+  const jsonMode = opts.jsonMode || false;
+  const showOperator = Boolean(opts.env?.ZOMBIE_OPERATOR === "1" || opts.authRole === "operator" || opts.authRole === "admin" || opts.operator);
+
+  printBanner(stdout, version, { noColor, jsonMode });
+  writeLine(stdout);
+  writeLine(stdout, "  " + ui.head("UseZombie CLI") + ui.dim("  —  autonomous agent platform"));
+  writeLine(stdout);
+  writeLine(stdout, ui.head("USAGE"));
+  writeLine(stdout, "  zombiectl [--api URL] [--json] <command> [subcommand] [flags]");
+  writeLine(stdout);
+  writeLine(stdout, ui.head("USER COMMANDS"));
+  writeLine(stdout, "  login [--timeout-sec N] [--poll-ms N] [--no-open]");
+  writeLine(stdout, "  logout");
+  writeLine(stdout, "  workspace add <repo_url> [--default-branch BRANCH]");
+  writeLine(stdout, "  workspace list");
+  writeLine(stdout, "  workspace remove <workspace_id>");
+  writeLine(stdout, "  spec init [--path DIR] [--output PATH]");
+  writeLine(stdout, "  specs sync [--workspace-id ID]");
+  writeLine(stdout, "  run [--workspace-id ID] [--spec-id ID] [--mode MODE] [--requested-by USER] [--idempotency-key KEY]");
+  writeLine(stdout, "  run [--spec FILE] [--preview] [--preview-only] [--path DIR]");
+  writeLine(stdout, "  run status <run_id>");
+  writeLine(stdout, "  runs list [--workspace-id ID]");
+  writeLine(stdout, "  doctor");
+
+  if (showOperator) {
+    writeLine(stdout);
+    writeLine(stdout, ui.head("OPERATOR COMMANDS"));
+    writeLine(stdout, "  harness source put --workspace-id ID --file PATH [--agent-id ID] [--name NAME]");
+    writeLine(stdout, "  harness compile --workspace-id ID [--agent-id ID] [--config-version-id ID]");
+    writeLine(stdout, "  harness activate --workspace-id ID --config-version-id ID [--activated-by USER]");
+    writeLine(stdout, "  harness active --workspace-id ID");
+    writeLine(stdout, "  workspace upgrade-scale --workspace-id ID --subscription-id SUBSCRIPTION_ID");
+    writeLine(stdout, "  skill-secret put --workspace-id ID --skill-ref REF --key KEY --value VALUE [--scope host|sandbox]");
+    writeLine(stdout, "  skill-secret delete --workspace-id ID --skill-ref REF --key KEY");
+    writeLine(stdout, "  agent scores <agent-id> [--limit N] [--starting-after ID]");
+    writeLine(stdout, "  agent profile <agent-id>");
+    writeLine(stdout, "  agent improvement-report <agent-id>");
+    writeLine(stdout, "  agent proposals <agent-id>");
+    writeLine(stdout, "  agent proposals <agent-id> approve <proposal-id>");
+    writeLine(stdout, "  agent proposals <agent-id> reject <proposal-id> [--reason TEXT]");
+    writeLine(stdout, "  agent proposals <agent-id> veto <proposal-id> [--reason TEXT]");
+    writeLine(stdout, "  agent harness revert <agent-id> --to-change <change-id>");
+    writeLine(stdout, "  admin config set scoring_context_max_tokens <value> --workspace-id ID");
+  }
+
+  writeLine(stdout);
+  writeLine(stdout, ui.head("GLOBAL FLAGS"));
+  writeLine(stdout, "  --api URL        API base URL");
+  writeLine(stdout, "  --json           Machine-readable JSON output");
+  writeLine(stdout, "  --no-input       Disable interactive prompts");
+  writeLine(stdout, "  --no-open        Skip auto-opening browser");
+  writeLine(stdout, "  --version        Show version");
+  writeLine(stdout, "  --help, -h       Show this help");
+
+  writeLine(stdout);
+  writeLine(stdout, ui.head("ENVIRONMENT VARIABLES"));
+  writeLine(stdout, "  ZOMBIE_API_URL   API base URL (overridden by --api)");
+  writeLine(stdout, "  ZOMBIE_TOKEN     Auth token (overridden by login)");
+  writeLine(stdout, "  ZOMBIE_API_KEY   API key for service auth");
+  writeLine(stdout, "  ZOMBIE_OPERATOR  Set to 1 to force-show operator commands in help");
+  writeLine(stdout, "  NO_COLOR         Set to 1 to disable color output");
+  writeLine(stdout);
+  writeLine(stdout, ui.dim("workspace add opens UseZombie GitHub App install and binds via callback."));
+}
+
+export {
+  printHelp,
+  printJson,
+  writeLine,
+};

package/src/program/routes.js

@@ -0,0 +1,20 @@
+const routes = [
+  { key: "login", match: (cmd) => cmd === "login" },
+  { key: "logout", match: (cmd) => cmd === "logout" },
+  { key: "workspace", match: (cmd) => cmd === "workspace" },
+  { key: "specs.sync", match: (cmd, args) => cmd === "specs" && args[0] === "sync" },
+  { key: "spec.init", match: (cmd, args) => cmd === "spec" && args[0] === "init" },
+  { key: "run", match: (cmd) => cmd === "run" },
+  { key: "runs.list", match: (cmd, args) => cmd === "runs" && args[0] === "list" },
+  // M17_001 §3: runs cancel
+  { key: "runs.cancel", match: (cmd, args) => cmd === "runs" && args[0] === "cancel" },
+  { key: "doctor", match: (cmd) => cmd === "doctor" },
+  { key: "harness", match: (cmd) => cmd === "harness" },
+  { key: "skill-secret", match: (cmd) => cmd === "skill-secret" },
+  { key: "agent", match: (cmd) => cmd === "agent" },
+  { key: "admin", match: (cmd) => cmd === "admin" },
+];
+
+export function findRoute(command, args) {
+  return routes.find((r) => r.match(command, args)) || null;
+}

package/src/program/suggest.js

@@ -0,0 +1,76 @@
+/**
+ * Levenshtein distance and command suggestion utilities.
+ */
+
+const KNOWN_COMMANDS = [
+  "login",
+  "logout",
+  "workspace",
+  "spec",
+  "specs",
+  "run",
+  "runs",
+  "doctor",
+  "harness",
+  "skill-secret",
+  "agent",
+];
+
+const KNOWN_SUBCOMMANDS = {
+  workspace: ["add", "list", "remove"],
+  spec: ["init"],
+  specs: ["sync"],
+  runs: ["list"],
+  run: ["status"],
+  harness: ["source", "compile", "activate", "active"],
+  "skill-secret": ["put", "delete"],
+  agent: ["scores", "profile"],
+};
+
+export function levenshteinDistance(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i][j] = Math.min(
+        dp[i - 1][j] + 1,
+        dp[i][j - 1] + 1,
+        dp[i - 1][j - 1] + cost,
+      );
+    }
+  }
+  return dp[m][n];
+}
+
+export function suggestCommand(input, knownCommands = KNOWN_COMMANDS, subcommands = KNOWN_SUBCOMMANDS) {
+  const maxDistance = 3;
+  const candidates = [];
+
+  // Match against top-level commands
+  for (const cmd of knownCommands) {
+    const d = levenshteinDistance(input.toLowerCase(), cmd.toLowerCase());
+    if (d > 0 && d <= maxDistance) {
+      candidates.push({ label: cmd, distance: d });
+    }
+  }
+
+  // Match against "command subcommand" combos
+  for (const [cmd, subs] of Object.entries(subcommands)) {
+    for (const sub of subs) {
+      const full = `${cmd} ${sub}`;
+      const d = levenshteinDistance(input.toLowerCase(), full.toLowerCase());
+      if (d > 0 && d <= maxDistance) {
+        candidates.push({ label: full, distance: d });
+      }
+    }
+  }
+
+  candidates.sort((a, b) => a.distance - b.distance);
+  return candidates.map((c) => c.label);
+}

package/src/program/validate.js

@@ -0,0 +1,24 @@
+/**
+ * ID format validation utilities.
+ */
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const SAFE_ID_RE = /^[a-zA-Z0-9_-]{4,128}$/;
+
+export function isValidId(value) {
+  if (!value || typeof value !== "string") return false;
+  return UUID_RE.test(value) || SAFE_ID_RE.test(value);
+}
+
+export function validateRequiredId(value, name) {
+  if (!value || typeof value !== "string" || value.trim().length === 0) {
+    return { ok: false, message: `${name} is required` };
+  }
+  if (!isValidId(value)) {
+    return {
+      ok: false,
+      message: `invalid ${name}: expected UUID format (e.g. 550e8400-e29b-41d4-a716-446655440000) or alphanumeric identifier (4-128 chars)`,
+    };
+  }
+  return { ok: true };
+}

package/src/ui-progress.js

@@ -0,0 +1,59 @@
+function spinnerFrames(style) {
+  if (style === "dotmatrix" || style === "matrix") {
+    return ["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"];
+  }
+
+  return ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+}
+
+export async function withSpinner(opts, work) {
+  const spin = createSpinner(opts);
+  spin.start();
+
+  try {
+    const out = await work();
+    spin.succeed();
+    return out;
+  } catch (err) {
+    spin.fail();
+    throw err;
+  }
+}
+
+export function createSpinner(opts = {}) {
+  const enabled = opts.enabled === true;
+  const stream = opts.stream || process.stderr;
+  const label = opts.label || "working";
+  const style = opts.style || process.env.ZOMBIE_PROGRESS_STYLE || "spinner";
+  const frames = spinnerFrames(style);
+  let i = 0;
+  let timer = null;
+
+  return {
+    start() {
+      if (!enabled || timer) return;
+      timer = setInterval(() => {
+        stream.write(`\r${frames[i % frames.length]} ${label}`);
+        i += 1;
+      }, 80);
+    },
+    succeed(message) {
+      if (!enabled) return;
+      if (timer) clearInterval(timer);
+      timer = null;
+      stream.write(`\r✔ ${message || label}\n`);
+    },
+    fail(message) {
+      if (!enabled) return;
+      if (timer) clearInterval(timer);
+      timer = null;
+      stream.write(`\r✖ ${message || label}\n`);
+    },
+    stop() {
+      if (!enabled) return;
+      if (timer) clearInterval(timer);
+      timer = null;
+      stream.write("\r");
+    },
+  };
+}

package/src/ui-theme.js

@@ -0,0 +1,62 @@
+// NO_COLOR spec: any non-empty value disables color
+const useColor = !process.env.NO_COLOR && process.stdout.isTTY === true;
+
+function color(code, text) {
+  return useColor ? `\u001b[${code}m${text}\u001b[0m` : text;
+}
+
+export const ui = {
+  ok:    (s) => color("32",   `✔ ${s}`),
+  info:  (s) => color("36",   `ℹ ${s}`),
+  warn:  (s) => color("33",   `▲ ${s}`),
+  err:   (s) => color("31",   `✖ ${s}`),
+  head:  (s) => color("1;36", s),
+  dim:   (s) => color("2",    s),
+  label: (s) => color("2",    s),          // dim alias for KV labels
+  run:   (s) => color("1;35", `◉ ${s}`),  // bold magenta — active/running state
+  step:  (s) => color("1;37", s),          // bold white — numbered steps
+};
+
+export function printSection(stream, title, theme = ui) {
+  const heading = theme.head ? theme.head(title) : title;
+  const rule = "─".repeat(title.length);
+  stream.write(`\n${heading}\n`);
+  stream.write(`${theme.dim ? theme.dim(rule) : rule}\n`);
+}
+
+export function printKeyValue(stream, rows, theme = ui) {
+  const entries = Object.entries(rows);
+  if (entries.length === 0) return;
+  const width = Math.max(...entries.map(([k]) => k.length), 0);
+  const sep = theme.dim ? theme.dim("  ·  ") : "  ·  ";
+  for (const [key, value] of entries) {
+    const label = theme.dim ? theme.dim(key.padEnd(width)) : key.padEnd(width);
+    stream.write(`  ${label}${sep}${value}\n`);
+  }
+}
+
+export function printTable(stream, columns, rows, theme = ui) {
+  if (rows.length === 0) {
+    const none = theme.dim ? theme.dim("(none)") : "(none)";
+    stream.write(`${none}\n`);
+    return;
+  }
+  const widths = columns.map((c) =>
+    Math.max(
+      c.label.length,
+      ...rows.map((r) => String(r[c.key] ?? "").length),
+    ),
+  );
+
+  const headerStr = columns.map((c, i) => c.label.padEnd(widths[i])).join("  ");
+  stream.write(`${theme.head ? theme.head(headerStr) : headerStr}\n`);
+
+  const sepStr = widths.map((w) => "\u2500".repeat(w)).join("  ");
+  stream.write(`${theme.dim ? theme.dim(sepStr) : sepStr}\n`);
+
+  for (const row of rows) {
+    stream.write(
+      `${columns.map((c, i) => String(row[c.key] ?? "").padEnd(widths[i])).join("  ")}\n`,
+    );
+  }
+}

package/test/admin_config.unit.test.js

@@ -0,0 +1,25 @@
+import { test } from "bun:test";
+import assert from "node:assert/strict";
+import { commandAdmin } from "../src/commands/admin.js";
+import { makeNoop, ui, WS_ID } from "./helpers.js";
+
+test("admin config set scoring_context_max_tokens posts workspace config update", async () => {
+  let called = null;
+  const deps = {
+    parseFlags: () => ({ options: { "workspace-id": WS_ID }, positionals: ["1024"] }),
+    request: async (_ctx, url, opts) => {
+      called = { url, opts };
+      return { workspace_id: WS_ID, scoring_context_max_tokens: 1024 };
+    },
+    apiHeaders: () => ({ Authorization: "Bearer token" }),
+    ui,
+    printJson: () => {},
+    writeLine: () => {},
+  };
+
+  const code = await commandAdmin({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, ["config", "set", "scoring_context_max_tokens"], null, deps);
+  assert.equal(code, 0);
+  assert.equal(called.url, `/v1/workspaces/${encodeURIComponent(WS_ID)}/scoring/config`);
+  assert.equal(called.opts.method, "POST");
+  assert.deepEqual(JSON.parse(called.opts.body), { scoring_context_max_tokens: 1024 });
+});