@usezombie/zombiectl 0.3.0

package/test/agent_profile.unit.test.js

@@ -0,0 +1,156 @@
+import { test } from "bun:test";
+import assert from "node:assert/strict";
+import { commandAgentProfile } from "../src/commands/agent_profile.js";
+import {
+  makeNoop,
+  ui, ApiError,
+  AGENT_ID, AGENT_NAME, WS_ID,
+} from "./helpers.js";
+
+const SAMPLE_AGENT = {
+  agent_id:     AGENT_ID,
+  name:         AGENT_NAME,
+  status:       "ACTIVE",
+  workspace_id: WS_ID,
+  trust_level:  "TRUSTED",
+  trust_streak_runs: 10,
+  improvement_stalled_warning: false,
+  created_at:   1700000000000,
+  updated_at:   1700000001000,
+};
+
+// ── T1: Happy path ────────────────────────────────────────────────────────────
+
+test("commandAgentProfile calls GET /v1/agents/{agent_id}", async () => {
+  let calledUrl = null;
+  const deps = {
+    request: async (_ctx, url) => { calledUrl = url; return SAMPLE_AGENT; },
+    apiHeaders: () => ({}),
+    ui, printJson: () => {}, printKeyValue: () => {}, writeLine: () => {},
+  };
+  const parsed = { options: {}, positionals: [] };
+  const code = await commandAgentProfile({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, AGENT_ID, deps);
+  assert.equal(code, 0);
+  assert.match(calledUrl, new RegExp(AGENT_ID));
+});
+
+test("commandAgentProfile json mode outputs raw response", async () => {
+  let printed = null;
+  const deps = {
+    request: async () => SAMPLE_AGENT,
+    apiHeaders: () => ({}),
+    ui, printJson: (_stream, v) => { printed = v; }, printKeyValue: () => {}, writeLine: () => {},
+  };
+  const parsed = { options: {}, positionals: [] };
+  const code = await commandAgentProfile({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: true }, parsed, AGENT_ID, deps);
+  assert.equal(code, 0);
+  assert.deepEqual(printed, SAMPLE_AGENT);
+});
+
+test("commandAgentProfile human mode calls printKeyValue with agent fields", async () => {
+  let kvData = null;
+  const deps = {
+    request: async () => SAMPLE_AGENT,
+    apiHeaders: () => ({}),
+    ui, printJson: () => {},
+    printKeyValue: (_stream, v) => { kvData = v; },
+    writeLine: () => {},
+  };
+  const parsed = { options: {}, positionals: [] };
+  await commandAgentProfile({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, AGENT_ID, deps);
+  assert.equal(kvData.agent_id, SAMPLE_AGENT.agent_id);
+  assert.equal(kvData.name, SAMPLE_AGENT.name);
+  assert.equal(kvData.status, SAMPLE_AGENT.status);
+  assert.equal(kvData.trust_level, SAMPLE_AGENT.trust_level);
+  assert.equal(kvData.trust_streak_runs, SAMPLE_AGENT.trust_streak_runs);
+  assert.equal(kvData.improvement_stalled_warning, SAMPLE_AGENT.improvement_stalled_warning);
+});
+
+// ── T2: Edge cases ────────────────────────────────────────────────────────────
+
+test("commandAgentProfile URL-encodes agent_id with special characters", async () => {
+  let calledUrl = null;
+  const deps = {
+    request: async (_ctx, url) => { calledUrl = url; return SAMPLE_AGENT; },
+    apiHeaders: () => ({}),
+    ui, printJson: () => {}, printKeyValue: () => {}, writeLine: () => {},
+  };
+  const parsed = { options: {}, positionals: [] };
+  await commandAgentProfile({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, "agent/with spaces", deps);
+  assert.match(calledUrl, /agent%2Fwith%20spaces/);
+});
+
+test("commandAgentProfile human mode includes all expected keys", async () => {
+  let kvData = null;
+  const deps = {
+    request: async () => SAMPLE_AGENT,
+    apiHeaders: () => ({}),
+    ui, printJson: () => {},
+    printKeyValue: (_stream, v) => { kvData = v; },
+    writeLine: () => {},
+  };
+  const parsed = { options: {}, positionals: [] };
+  await commandAgentProfile({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, AGENT_ID, deps);
+  assert.ok(Object.prototype.hasOwnProperty.call(kvData, "workspace_id"), "missing workspace_id");
+  assert.ok(Object.prototype.hasOwnProperty.call(kvData, "trust_level"), "missing trust_level");
+  assert.ok(Object.prototype.hasOwnProperty.call(kvData, "trust_streak_runs"), "missing trust_streak_runs");
+  assert.ok(Object.prototype.hasOwnProperty.call(kvData, "improvement_stalled_warning"), "missing improvement_stalled_warning");
+  assert.ok(Object.prototype.hasOwnProperty.call(kvData, "created_at"),  "missing created_at");
+  assert.ok(Object.prototype.hasOwnProperty.call(kvData, "updated_at"),  "missing updated_at");
+});
+
+// ── T3: Error paths ───────────────────────────────────────────────────────────
+
+test("commandAgentProfile propagates ApiError 404 when agent not found", async () => {
+  const deps = {
+    request: async () => { throw new ApiError("not found", { status: 404, code: "UZ-AGENT-001" }); },
+    apiHeaders: () => ({}),
+    ui, printJson: () => {}, printKeyValue: () => {}, writeLine: () => {},
+  };
+  const parsed = { options: {}, positionals: [] };
+  await assert.rejects(
+    () => commandAgentProfile({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, AGENT_ID, deps),
+    (err) => err instanceof ApiError && err.status === 404,
+  );
+});
+
+test("commandAgentProfile propagates ApiError 403 when forbidden", async () => {
+  const deps = {
+    request: async () => { throw new ApiError("forbidden", { status: 403, code: "HTTP_403" }); },
+    apiHeaders: () => ({}),
+    ui, printJson: () => {}, printKeyValue: () => {}, writeLine: () => {},
+  };
+  const parsed = { options: {}, positionals: [] };
+  await assert.rejects(
+    () => commandAgentProfile({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, AGENT_ID, deps),
+    (err) => err instanceof ApiError && err.status === 403,
+  );
+});
+
+test("commandAgentProfile propagates network timeout error", async () => {
+  const deps = {
+    request: async () => { throw new ApiError("request timed out after 15000ms", { status: 408, code: "TIMEOUT" }); },
+    apiHeaders: () => ({}),
+    ui, printJson: () => {}, printKeyValue: () => {}, writeLine: () => {},
+  };
+  const parsed = { options: {}, positionals: [] };
+  await assert.rejects(
+    () => commandAgentProfile({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, AGENT_ID, deps),
+    (err) => err.code === "TIMEOUT",
+  );
+});
+
+// ── T4: Output fidelity ───────────────────────────────────────────────────────
+
+test("commandAgentProfile json mode output is JSON.stringify-serializable", async () => {
+  let printed = null;
+  const deps = {
+    request: async () => SAMPLE_AGENT,
+    apiHeaders: () => ({}),
+    ui, printJson: (_stream, v) => { printed = v; }, printKeyValue: () => {}, writeLine: () => {},
+  };
+  const parsed = { options: {}, positionals: [] };
+  await commandAgentProfile({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: true }, parsed, AGENT_ID, deps);
+  const roundTripped = JSON.parse(JSON.stringify(printed));
+  assert.deepEqual(roundTripped, SAMPLE_AGENT);
+});

package/test/agent_proposals.unit.test.js

@@ -0,0 +1,167 @@
+import { test } from "bun:test";
+import assert from "node:assert/strict";
+import { commandAgentProposals } from "../src/commands/agent_proposals.js";
+import {
+  makeNoop,
+  ui,
+  AGENT_ID,
+} from "./helpers.js";
+
+const PROPOSAL_ID = "0195b4ba-8d3a-7f13-8abc-000000000091";
+
+test("commandAgentProposals lists proposal rows", async () => {
+  const realNow = Date.now;
+  Date.now = () => 1700000000000;
+  let calledUrl = null;
+  let columns = null;
+  let rows = null;
+  const deps = {
+    request: async (_ctx, url) => {
+      calledUrl = url;
+      return {
+        data: [
+          {
+            proposal_id: PROPOSAL_ID,
+            status: "VETO_WINDOW",
+            trigger_reason: "DECLINING_SCORE",
+            auto_apply_at: 1700003600000,
+            config_version_id: "0195b4ba-8d3a-7f13-8abc-000000000092",
+            created_at: 1700000000000,
+          },
+        ],
+      };
+    },
+    apiHeaders: () => ({}),
+    printJson: () => {},
+    printTable: (_stream, cols, items) => {
+      columns = cols;
+      rows = items;
+    },
+    ui,
+    writeLine: () => {},
+  };
+
+  const parsed = { options: {}, positionals: [AGENT_ID] };
+  try {
+    const code = await commandAgentProposals({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, AGENT_ID, deps);
+    assert.equal(code, 0);
+    assert.match(calledUrl, /\/proposals$/);
+    assert.equal(columns[0].key, "proposal_id");
+    assert.equal(columns[1].key, "status");
+    assert.equal(rows[0].proposal_id, PROPOSAL_ID);
+    assert.match(rows[0].action, /Auto-applies in 1h 0m/);
+    assert.match(rows[0].action, /agent proposals veto/);
+  } finally {
+    Date.now = realNow;
+  }
+});
+
+test("commandAgentProposals approve posts to the approve endpoint", async () => {
+  let called = null;
+  const deps = {
+    request: async (_ctx, url, init) => {
+      called = { url, init };
+      return { proposal_id: PROPOSAL_ID, status: "APPLIED" };
+    },
+    apiHeaders: () => ({ authorization: "Bearer t" }),
+    printJson: () => {},
+    printTable: () => {},
+    ui,
+    writeLine: () => {},
+  };
+
+  const parsed = { options: {}, positionals: [AGENT_ID, "approve", PROPOSAL_ID] };
+  const code = await commandAgentProposals({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, AGENT_ID, deps);
+  assert.equal(code, 0);
+  assert.match(called.url, /:approve$/);
+  assert.equal(called.init.method, "POST");
+});
+
+test("commandAgentProposals reject sends optional reason body", async () => {
+  let called = null;
+  const deps = {
+    request: async (_ctx, url, init) => {
+      called = { url, init };
+      return { proposal_id: PROPOSAL_ID, rejection_reason: "EXPIRED", status: "REJECTED" };
+    },
+    apiHeaders: () => ({ authorization: "Bearer t" }),
+    printJson: () => {},
+    printTable: () => {},
+    ui,
+    writeLine: () => {},
+  };
+
+  const parsed = { options: { reason: "needs operator follow-up" }, positionals: [AGENT_ID, "reject", PROPOSAL_ID] };
+  const code = await commandAgentProposals({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, AGENT_ID, deps);
+  assert.equal(code, 0);
+  assert.match(called.url, /:reject$/);
+  assert.equal(JSON.parse(called.init.body).reason, "needs operator follow-up");
+});
+
+test("commandAgentProposals veto sends optional reason body", async () => {
+  let called = null;
+  const deps = {
+    request: async (_ctx, url, init) => {
+      called = { url, init };
+      return { proposal_id: PROPOSAL_ID, rejection_reason: "operator pause", status: "VETOED" };
+    },
+    apiHeaders: () => ({ authorization: "Bearer t" }),
+    printJson: () => {},
+    printTable: () => {},
+    ui,
+    writeLine: () => {},
+  };
+
+  const parsed = { options: { reason: "operator pause" }, positionals: [AGENT_ID, "veto", PROPOSAL_ID] };
+  const code = await commandAgentProposals({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, AGENT_ID, deps);
+  assert.equal(code, 0);
+  assert.match(called.url, /:veto$/);
+  assert.equal(JSON.parse(called.init.body).reason, "operator pause");
+});
+
+test("commandAgentProposals json mode preserves proposal response shape", async () => {
+  let jsonValue = null;
+  const deps = {
+    request: async () => ({
+      data: [{
+        proposal_id: PROPOSAL_ID,
+        status: "VETO_WINDOW",
+        approval_mode: "AUTO",
+        auto_apply_at: 1700003600000,
+        trigger_reason: "DECLINING_SCORE",
+        config_version_id: "0195b4ba-8d3a-7f13-8abc-000000000092",
+        created_at: 1700000000000,
+        updated_at: 1700000000001,
+      }],
+    }),
+    apiHeaders: () => ({}),
+    printJson: (_stream, value) => { jsonValue = value; },
+    printTable: () => {},
+    ui,
+    writeLine: () => {},
+  };
+
+  const parsed = { options: {}, positionals: [AGENT_ID] };
+  const code = await commandAgentProposals({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: true }, parsed, AGENT_ID, deps);
+  assert.equal(code, 0);
+  assert.equal(jsonValue.data[0].status, "VETO_WINDOW");
+  assert.equal(jsonValue.data[0].approval_mode, "AUTO");
+  assert.equal(jsonValue.data[0].auto_apply_at, 1700003600000);
+});
+
+test("commandAgentProposals rejects missing proposal id for decision commands", async () => {
+  const stderr = [];
+  const deps = {
+    request: async () => ({ data: [] }),
+    apiHeaders: () => ({}),
+    printJson: () => {},
+    printTable: () => {},
+    ui,
+    writeLine: (_stream, line) => { stderr.push(line); },
+  };
+
+  const parsed = { options: {}, positionals: [AGENT_ID, "approve"] };
+  const code = await commandAgentProposals({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, AGENT_ID, deps);
+  assert.equal(code, 2);
+  assert.match(stderr.join("\n"), /requires <proposal-id>/);
+});

package/test/agent_scores.unit.test.js

@@ -0,0 +1,220 @@
+import { test } from "bun:test";
+import assert from "node:assert/strict";
+import { commandAgentScores } from "../src/commands/agent_scores.js";
+import {
+  makeNoop, makeBufferStream,
+  ui, ApiError,
+  AGENT_ID, SCORE_ID_1, SCORE_ID_2, RUN_ID_1, RUN_ID_2,
+} from "./helpers.js";
+
+const SAMPLE_SCORES = [
+  { score_id: SCORE_ID_1, run_id: RUN_ID_1, score: 87, scored_at: 1700000002000 },
+  { score_id: SCORE_ID_2, run_id: RUN_ID_2, score: 72, scored_at: 1700000001000 },
+];
+
+// ── T1: Happy path ────────────────────────────────────────────────────────────
+
+test("commandAgentScores builds correct URL with limit", async () => {
+  let calledUrl = null;
+  const deps = {
+    request: async (_ctx, url) => { calledUrl = url; return { data: [], has_more: false, next_cursor: null }; },
+    apiHeaders: () => ({}),
+    ui, printJson: () => {}, printTable: () => {}, writeLine: () => {},
+  };
+  const parsed = { options: { limit: 10 }, positionals: [] };
+  const code = await commandAgentScores({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, AGENT_ID, deps);
+  assert.equal(code, 0);
+  assert.match(calledUrl, /limit=10/);
+  assert.match(calledUrl, new RegExp(`/v1/agents/${AGENT_ID}/scores`));
+});
+
+test("commandAgentScores appends starting_after to URL when provided", async () => {
+  let calledUrl = null;
+  const deps = {
+    request: async (_ctx, url) => { calledUrl = url; return { data: [], has_more: false, next_cursor: null }; },
+    apiHeaders: () => ({}),
+    ui, printJson: () => {}, printTable: () => {}, writeLine: () => {},
+  };
+  const parsed = { options: { "starting-after": SCORE_ID_1 }, positionals: [] };
+  await commandAgentScores({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, AGENT_ID, deps);
+  assert.match(calledUrl, new RegExp(`starting_after=${encodeURIComponent(SCORE_ID_1)}`));
+});
+
+test("commandAgentScores json mode outputs raw response", async () => {
+  let printed = null;
+  const res = { data: SAMPLE_SCORES, has_more: false, next_cursor: null };
+  const deps = {
+    request: async () => res,
+    apiHeaders: () => ({}),
+    ui, printJson: (_stream, v) => { printed = v; }, printTable: () => {}, writeLine: () => {},
+  };
+  const parsed = { options: {}, positionals: [] };
+  const code = await commandAgentScores({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: true }, parsed, AGENT_ID, deps);
+  assert.equal(code, 0);
+  assert.deepEqual(printed, res);
+});
+
+test("commandAgentScores prints table in human mode", async () => {
+  let tableRows = null;
+  const deps = {
+    request: async () => ({ data: SAMPLE_SCORES, has_more: false, next_cursor: null }),
+    apiHeaders: () => ({}),
+    ui, printJson: () => {},
+    printTable: (_stream, _cols, rows) => { tableRows = rows; },
+    writeLine: () => {},
+  };
+  const parsed = { options: {}, positionals: [] };
+  await commandAgentScores({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, AGENT_ID, deps);
+  assert.equal(tableRows.length, 2);
+});
+
+test("commandAgentScores shows next_cursor hint when has_more", async () => {
+  let output = "";
+  const deps = {
+    request: async () => ({ data: SAMPLE_SCORES, has_more: true, next_cursor: SCORE_ID_1 }),
+    apiHeaders: () => ({}),
+    ui, printJson: () => {},
+    printTable: () => {},
+    writeLine: (_stream, line = "") => { output += line; },
+  };
+  const parsed = { options: {}, positionals: [] };
+  await commandAgentScores({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, AGENT_ID, deps);
+  assert.match(output, new RegExp(SCORE_ID_1));
+});
+
+test("commandAgentScores shows no scores message when data is empty", async () => {
+  let output = "";
+  const deps = {
+    request: async () => ({ data: [], has_more: false, next_cursor: null }),
+    apiHeaders: () => ({}),
+    ui, printJson: () => {},
+    printTable: () => {},
+    writeLine: (_stream, line = "") => { output += line; },
+  };
+  const parsed = { options: {}, positionals: [] };
+  await commandAgentScores({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, AGENT_ID, deps);
+  assert.match(output, /no scores/);
+});
+
+// ── T2: Edge cases ────────────────────────────────────────────────────────────
+
+test("commandAgentScores uses default limit 20 when none specified", async () => {
+  let calledUrl = null;
+  const deps = {
+    request: async (_ctx, url) => { calledUrl = url; return { data: [], has_more: false, next_cursor: null }; },
+    apiHeaders: () => ({}),
+    ui, printJson: () => {}, printTable: () => {}, writeLine: () => {},
+  };
+  const parsed = { options: {}, positionals: [] };
+  await commandAgentScores({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, AGENT_ID, deps);
+  assert.match(calledUrl, /limit=20/);
+});
+
+test("commandAgentScores with limit=0 sends limit=0 in URL", async () => {
+  let calledUrl = null;
+  const deps = {
+    request: async (_ctx, url) => { calledUrl = url; return { data: [], has_more: false, next_cursor: null }; },
+    apiHeaders: () => ({}),
+    ui, printJson: () => {}, printTable: () => {}, writeLine: () => {},
+  };
+  const parsed = { options: { limit: 0 }, positionals: [] };
+  await commandAgentScores({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, AGENT_ID, deps);
+  // limit=0 is falsy so falls back to default 20 — verify the documented behavior
+  assert.match(calledUrl, /limit=/);
+});
+
+test("commandAgentScores omits starting_after when not provided", async () => {
+  let calledUrl = null;
+  const deps = {
+    request: async (_ctx, url) => { calledUrl = url; return { data: [], has_more: false, next_cursor: null }; },
+    apiHeaders: () => ({}),
+    ui, printJson: () => {}, printTable: () => {}, writeLine: () => {},
+  };
+  const parsed = { options: {}, positionals: [] };
+  await commandAgentScores({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, AGENT_ID, deps);
+  assert.doesNotMatch(calledUrl, /starting_after/);
+});
+
+test("commandAgentScores suppresses cursor hint when has_more=true but next_cursor=null", async () => {
+  let output = "";
+  const deps = {
+    request: async () => ({ data: SAMPLE_SCORES, has_more: true, next_cursor: null }),
+    apiHeaders: () => ({}),
+    ui, printJson: () => {},
+    printTable: () => {},
+    writeLine: (_stream, line = "") => { output += line; },
+  };
+  const parsed = { options: {}, positionals: [] };
+  await commandAgentScores({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, AGENT_ID, deps);
+  assert.doesNotMatch(output, /--starting-after/);
+});
+
+test("commandAgentScores URL-encodes agent_id with special characters", async () => {
+  let calledUrl = null;
+  const deps = {
+    request: async (_ctx, url) => { calledUrl = url; return { data: [], has_more: false, next_cursor: null }; },
+    apiHeaders: () => ({}),
+    ui, printJson: () => {}, printTable: () => {}, writeLine: () => {},
+  };
+  const parsed = { options: {}, positionals: [] };
+  await commandAgentScores({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, "agent/with spaces", deps);
+  assert.match(calledUrl, /agent%2Fwith%20spaces/);
+});
+
+// ── T3: Error paths ───────────────────────────────────────────────────────────
+
+test("commandAgentScores propagates ApiError 404 from request", async () => {
+  const deps = {
+    request: async () => { throw new ApiError("not found", { status: 404, code: "UZ-AGENT-001" }); },
+    apiHeaders: () => ({}),
+    ui, printJson: () => {}, printTable: () => {}, writeLine: () => {},
+  };
+  const parsed = { options: {}, positionals: [] };
+  await assert.rejects(
+    () => commandAgentScores({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, AGENT_ID, deps),
+    (err) => err instanceof ApiError && err.status === 404,
+  );
+});
+
+test("commandAgentScores propagates ApiError 500 from request", async () => {
+  const deps = {
+    request: async () => { throw new ApiError("internal error", { status: 500, code: "HTTP_500" }); },
+    apiHeaders: () => ({}),
+    ui, printJson: () => {}, printTable: () => {}, writeLine: () => {},
+  };
+  const parsed = { options: {}, positionals: [] };
+  await assert.rejects(
+    () => commandAgentScores({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, AGENT_ID, deps),
+    (err) => err instanceof ApiError && err.status === 500,
+  );
+});
+
+test("commandAgentScores propagates network timeout error", async () => {
+  const deps = {
+    request: async () => { throw new ApiError("request timed out after 15000ms", { status: 408, code: "TIMEOUT" }); },
+    apiHeaders: () => ({}),
+    ui, printJson: () => {}, printTable: () => {}, writeLine: () => {},
+  };
+  const parsed = { options: {}, positionals: [] };
+  await assert.rejects(
+    () => commandAgentScores({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, AGENT_ID, deps),
+    (err) => err.code === "TIMEOUT",
+  );
+});
+
+// ── T4: Output fidelity ───────────────────────────────────────────────────────
+
+test("commandAgentScores json mode output is JSON.stringify-serializable", async () => {
+  const res = { data: SAMPLE_SCORES, has_more: false, next_cursor: null };
+  let printed = null;
+  const deps = {
+    request: async () => res,
+    apiHeaders: () => ({}),
+    ui, printJson: (_stream, v) => { printed = v; }, printTable: () => {}, writeLine: () => {},
+  };
+  const parsed = { options: {}, positionals: [] };
+  await commandAgentScores({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: true }, parsed, AGENT_ID, deps);
+  const serialized = JSON.stringify(printed);
+  const roundTripped = JSON.parse(serialized);
+  assert.deepEqual(roundTripped, res);
+});

package/test/analytics.unit.test.js

@@ -0,0 +1,41 @@
+import { test } from "bun:test";
+import assert from "node:assert/strict";
+import { cliAnalyticsInternals } from "../src/lib/analytics.js";
+
+test("analytics resolveConfig enables bundled default key when env key is absent", () => {
+  const cfg = cliAnalyticsInternals.resolveConfig({});
+  assert.equal(cfg.enabled, true);
+  assert.equal(cfg.host, "https://us.i.posthog.com");
+  assert.equal(cfg.key, cliAnalyticsInternals.DEFAULT_POSTHOG_KEY);
+});
+
+test("analytics resolveConfig honors explicit env key override", () => {
+  const cfg = cliAnalyticsInternals.resolveConfig({
+    ZOMBIE_POSTHOG_KEY: "phc_test",
+  });
+  assert.equal(cfg.enabled, true);
+  assert.equal(cfg.key, "phc_test");
+});
+
+test("analytics resolveConfig allows opt-out even with bundled key", () => {
+  const cfg = cliAnalyticsInternals.resolveConfig({
+    ZOMBIE_POSTHOG_ENABLED: "false",
+  });
+  assert.equal(cfg.enabled, false);
+  assert.equal(cfg.key, cliAnalyticsInternals.DEFAULT_POSTHOG_KEY);
+});
+
+test("analytics sanitizeProperties stringifies values and drops nullish", () => {
+  const properties = cliAnalyticsInternals.sanitizeProperties({
+    command: "run",
+    exit_code: 0,
+    empty: null,
+    ignored: undefined,
+    ok: false,
+  });
+  assert.deepEqual(properties, {
+    command: "run",
+    exit_code: "0",
+    ok: "false",
+  });
+});

package/test/args.unit.test.js

@@ -0,0 +1,69 @@
+import { test } from "bun:test";
+import assert from "node:assert/strict";
+import { parseFlags, parseGlobalArgs, normalizeApiUrl } from "../src/program/args.js";
+
+test("parseFlags parses mixed forms: inline values, separated values, booleans, and positionals", () => {
+  const parsed = parseFlags([
+    "--workspace-id=ws_123",
+    "--mode",
+    "api",
+    "run",
+    "status",
+    "run_123",
+    "--dry-run",
+  ]);
+
+  assert.equal(parsed.options["workspace-id"], "ws_123");
+  assert.equal(parsed.options.mode, "api");
+  assert.equal(parsed.options["dry-run"], true);
+  assert.deepEqual(parsed.positionals, ["run", "status", "run_123"]);
+});
+
+test("parseFlags treats subsequent option token as a new flag", () => {
+  const parsed = parseFlags(["--json", "--no-open", "--help"]);
+  assert.equal(parsed.options.json, true);
+  assert.equal(parsed.options["no-open"], true);
+  assert.equal(parsed.options.help, true);
+  assert.deepEqual(parsed.positionals, []);
+});
+
+test("parseFlags preserves equals-containing values", () => {
+  const parsed = parseFlags(["--filter=a=b=c", "--empty=", "--name", "alpha=beta"]);
+  assert.equal(parsed.options.filter, "a=b=c");
+  assert.equal(parsed.options.empty, "");
+  assert.equal(parsed.options.name, "alpha=beta");
+});
+
+test("parseFlags keeps unicode and whitespace positionals unchanged", () => {
+  const parsed = parseFlags(["--scope", "sandbox", "नमस्ते", "emoji_😀"]);
+  assert.equal(parsed.options.scope, "sandbox");
+  assert.deepEqual(parsed.positionals, ["नमस्ते", "emoji_😀"]);
+});
+
+test("normalizeApiUrl strips trailing slashes but keeps core URL", () => {
+  assert.equal(normalizeApiUrl("https://api.example.com///"), "https://api.example.com");
+  assert.equal(normalizeApiUrl("http://localhost:3000"), "http://localhost:3000");
+});
+
+test("parseGlobalArgs prioritizes --api over env and forwards remaining args", () => {
+  const env = { ZOMBIE_API_URL: "https://env.example" };
+  const out = parseGlobalArgs(["--api", "https://flag.example/", "doctor"], env);
+  assert.equal(out.global.apiUrl, "https://flag.example");
+  assert.deepEqual(out.rest, ["doctor"]);
+});
+
+test("parseGlobalArgs falls back through env chain and defaults", () => {
+  const outApiUrl = parseGlobalArgs(["doctor"], { API_URL: "https://api-url.example" });
+  assert.equal(outApiUrl.global.apiUrl, "https://api-url.example");
+
+  const outDefault = parseGlobalArgs(["doctor"], {});
+  assert.equal(outDefault.global.apiUrl, "http://localhost:3000");
+});
+
+test("parseGlobalArgs sets global boolean options and leaves command argv intact", () => {
+  const out = parseGlobalArgs(["--json", "--no-input", "--no-open", "run", "status", "run_1"], {});
+  assert.equal(out.global.json, true);
+  assert.equal(out.global.noInput, true);
+  assert.equal(out.global.noOpen, true);
+  assert.deepEqual(out.rest, ["run", "status", "run_1"]);
+});