mcoda 0.1.2 → 0.1.4

package/packages/cli/src/__tests__/QaTasksCommand.test.ts

@@ -1,58 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import path from "node:path";
-import { parseQaTasksArgs } from "../commands/planning/QaTasksCommand.js";
-
-describe("qa-tasks argument parsing", () => {
-  it("defaults to auto mode, ready_to_qa status, and streaming", () => {
-    const parsed = parseQaTasksArgs([]);
-    assert.equal(parsed.mode, "auto");
-    assert.deepEqual(parsed.statusFilter, ["ready_to_qa"]);
-    assert.equal(parsed.agentStream, true);
-    assert.equal(parsed.dryRun, false);
-    assert.equal(parsed.createFollowupTasks, "auto");
-  });
-
-  it("parses manual flags, statuses, and overrides", () => {
-    const parsed = parseQaTasksArgs([
-      "--mode",
-      "manual",
-      "--result",
-      "fail",
-      "--status",
-      "ready_to_qa,in_progress",
-      "--agent-stream",
-      "false",
-      "--profile",
-      "ui",
-      "--level",
-      "integration",
-      "--test-command",
-      "npm test",
-      "--create-followup-tasks",
-      "none",
-      "--notes",
-      "needs fix",
-      "--evidence-url",
-      "https://ci.example",
-    ]);
-    assert.equal(parsed.mode, "manual");
-    assert.equal(parsed.result, "fail");
-    assert.deepEqual(parsed.statusFilter, ["ready_to_qa", "in_progress"]);
-    assert.equal(parsed.agentStream, false);
-    assert.equal(parsed.profileName, "ui");
-    assert.equal(parsed.level, "integration");
-    assert.equal(parsed.testCommand, "npm test");
-    assert.equal(parsed.createFollowupTasks, "none");
-    assert.equal(parsed.notes, "needs fix");
-    assert.equal(parsed.evidenceUrl, "https://ci.example");
-  });
-
-  it("captures task selection and workspace metadata", () => {
-    const root = path.resolve("/tmp/demo-workspace");
-    const parsed = parseQaTasksArgs(["--workspace-root", root, "--project", "proj", "--task", "T1", "--task", "T2"]);
-    assert.equal(parsed.workspaceRoot, root);
-    assert.equal(parsed.projectKey, "proj");
-    assert.deepEqual(parsed.taskKeys, ["T1", "T2"]);
-  });
-});

package/packages/cli/src/__tests__/RefineTasksCommand.test.ts

@@ -1,63 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import path from "node:path";
-import { parseRefineTasksArgs } from "../commands/planning/RefineTasksCommand.js";
-
-describe("refine-tasks argument parsing", () => {
-  it("defaults booleans correctly", () => {
-    const parsed = parseRefineTasksArgs([]);
-    assert.equal(parsed.agentStream, true);
-    assert.equal(parsed.fromDb, true);
-    assert.equal(parsed.dryRun, false);
-    assert.equal(parsed.apply, false);
-    assert.equal(parsed.resume, false);
-    assert.equal(parsed.runAll, false);
-    assert.equal(parsed.json, false);
-  });
-
-  it("captures repeated tasks and statuses", () => {
-    const parsed = parseRefineTasksArgs([
-      "--task",
-      "alpha",
-      "--task=beta",
-      "--status",
-      "not_started,in_progress",
-      "--status=blocked",
-    ]);
-    assert.deepEqual(parsed.taskKeys, ["alpha", "beta"]);
-    assert.deepEqual(parsed.statusFilter, ["not_started", "in_progress", "blocked"]);
-  });
-
-  it("parses boolean flags from inline values", () => {
-    const parsed = parseRefineTasksArgs(["--agent-stream=false", "--from-db", "false"]);
-    assert.equal(parsed.agentStream, false);
-    assert.equal(parsed.fromDb, false);
-  });
-
-  it("captures workspace root, strategy, and numeric flags", () => {
-    const root = path.resolve("/tmp/work");
-    const parsed = parseRefineTasksArgs([
-      "--workspace-root",
-      root,
-      "--project",
-      "demo",
-      "--strategy",
-      "estimate",
-      "--max-tasks",
-      "5",
-    ]);
-    assert.equal(parsed.workspaceRoot, root);
-    assert.equal(parsed.projectKey, "demo");
-    assert.equal(parsed.strategy, "estimate");
-    assert.equal(parsed.maxTasks, 5);
-  });
-
-  it("parses apply/resume/run-all controls", () => {
-    const parsed = parseRefineTasksArgs(["--apply", "--resume", "--run-all", "--batch-size", "50", "--max-batches", "3"]);
-    assert.equal(parsed.apply, true);
-    assert.equal(parsed.resume, true);
-    assert.equal(parsed.runAll, true);
-    assert.equal(parsed.batchSize, 50);
-    assert.equal(parsed.maxBatches, 3);
-  });
-});

package/packages/cli/src/__tests__/RoutingCommands.test.ts

@@ -1,302 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { RoutingCommands } from "../commands/routing/RoutingCommands.js";
-import { RoutingService, WorkspaceResolver, JobService } from "@mcoda/core";
-
-const withPatched = async <T, K extends keyof T>(
-  target: T,
-  key: K,
-  impl: T[K],
-  fn: () => Promise<void>,
-) => {
-  const original = target[key];
-  (target as any)[key] = impl;
-  try {
-    await fn();
-  } finally {
-    (target as any)[key] = original;
-  }
-};
-
-const captureLogs = async (fn: () => Promise<void>): Promise<string[]> => {
-  const logs: string[] = [];
-  const original = console.log;
-  (console as any).log = (...args: any[]) => {
-    logs.push(args.join(" "));
-  };
-  try {
-    await fn();
-  } finally {
-    (console as any).log = original;
-  }
-  return logs;
-};
-
-const workspace = {
-  workspaceRoot: "/tmp/ws-routing",
-  workspaceId: "ws-routing",
-  id: "ws-routing",
-  legacyWorkspaceIds: [],
-  mcodaDir: "/tmp/ws-routing/.mcoda",
-  workspaceDbPath: "/tmp/ws-routing/.mcoda/mcoda.db",
-  globalDbPath: "/tmp/global/mcoda.db",
-};
-
-describe("RoutingCommands", () => {
-  it("shows help for defaults", async () => {
-    const logs = await captureLogs(async () => RoutingCommands.run(["defaults", "--help"]));
-    assert.ok(logs.join("\n").includes("Manage per-workspace routing defaults"));
-  });
-
-  it("lists defaults in json", async () => {
-    const stubRouting: any = {
-      normalizeCommand: (c: string) => c,
-      getWorkspaceDefaults: async (id: string) =>
-        id === "__GLOBAL__"
-          ? [{ workspaceId: "__GLOBAL__", commandName: "default", agentId: "agent-global", updatedAt: "t1" }]
-          : [{ workspaceId: workspace.workspaceId, commandName: "create-tasks", agentId: "agent-local", updatedAt: "t2" }],
-      getAgentSummary: async (agentId: string) => ({
-        id: agentId,
-        slug: agentId,
-        adapter: "local-model",
-        createdAt: "t",
-        updatedAt: "t",
-      }),
-      close: async () => {},
-    };
-
-    await withPatched(RoutingService as any, "create", async () => stubRouting, async () => {
-      await withPatched(WorkspaceResolver as any, "resolveWorkspace", async () => workspace, async () => {
-        await withPatched(JobService.prototype as any, "startCommandRun", async () => ({ id: "cmd-1" }), async () => {
-          await withPatched(JobService.prototype as any, "finishCommandRun", async () => {}, async () => {
-            await withPatched(JobService.prototype as any, "close", async () => {}, async () => {
-              const logs = await captureLogs(async () => RoutingCommands.run(["defaults", "--json"]));
-              const parsed = JSON.parse(logs.join("\n"));
-              assert.equal(parsed.defaults.length, 1);
-              assert.equal(parsed.globalDefaults.length, 1);
-            });
-          });
-        });
-      });
-    });
-  });
-
-  it("updates defaults with set-command", async () => {
-    const calls: any[] = [];
-    const stubRouting: any = {
-      normalizeCommand: (c: string) => c,
-      updateWorkspaceDefaults: async (workspaceId: string, update: any) => {
-        calls.push({ workspaceId, update });
-        return [{ workspaceId, commandName: "create-tasks", agentId: "codex", updatedAt: "now" }];
-      },
-      getAgentSummary: async () => ({ id: "codex", slug: "codex", adapter: "local", createdAt: "t", updatedAt: "t" }),
-      close: async () => {},
-    };
-    await withPatched(RoutingService as any, "create", async () => stubRouting, async () => {
-      await withPatched(WorkspaceResolver as any, "resolveWorkspace", async () => workspace, async () => {
-        await withPatched(JobService.prototype as any, "startCommandRun", async () => ({ id: "cmd-2" }), async () => {
-          await withPatched(JobService.prototype as any, "finishCommandRun", async () => {}, async () => {
-            await withPatched(JobService.prototype as any, "close", async () => {}, async () => {
-              await RoutingCommands.run(["defaults", "--set-command", "create-tasks=codex", "--json"]);
-              assert.equal(calls[0]?.workspaceId, workspace.workspaceId);
-              assert.deepEqual(calls[0]?.update?.set, { "create-tasks": "codex" });
-            });
-          });
-        });
-      });
-    });
-  });
-
-  it("updates qa/doc defaults", async () => {
-    const calls: any[] = [];
-    const stubRouting: any = {
-      normalizeCommand: (c: string) => c,
-      updateWorkspaceDefaults: async (workspaceId: string, update: any) => {
-        calls.push({ workspaceId, update });
-        return [];
-      },
-      getAgentSummary: async () => undefined,
-      close: async () => {},
-    };
-    await withPatched(RoutingService as any, "create", async () => stubRouting, async () => {
-      await withPatched(WorkspaceResolver as any, "resolveWorkspace", async () => workspace, async () => {
-        await withPatched(JobService.prototype as any, "startCommandRun", async () => ({ id: "cmd-qa" }), async () => {
-          await withPatched(JobService.prototype as any, "finishCommandRun", async () => {}, async () => {
-            await withPatched(JobService.prototype as any, "close", async () => {}, async () => {
-              await RoutingCommands.run(["defaults", "--set-qa-profile", "integration", "--set-docdex-scope", "sds"]);
-              assert.equal(calls[0]?.update?.qaProfile, "integration");
-              assert.equal(calls[0]?.update?.docdexScope, "sds");
-            });
-          });
-        });
-      });
-    });
-  });
-
-  it("shows preview output", async () => {
-    const stubRouting: any = {
-      normalizeCommand: (c: string) => c,
-      resolveAgentForCommand: async () => ({
-        agentId: "a1",
-        agentSlug: "agent-one",
-        agent: { id: "a1", slug: "agent-one" },
-        model: "stub",
-        capabilities: ["code_write"],
-        healthStatus: "healthy",
-        source: "workspace_default",
-        routingPreview: { workspaceId: workspace.workspaceId, commandName: "work-on-tasks" },
-        requiredCapabilities: ["code_write"],
-      }),
-      close: async () => {},
-    };
-    const tokenCalls: any[] = [];
-    await withPatched(RoutingService as any, "create", async () => stubRouting, async () => {
-      await withPatched(WorkspaceResolver as any, "resolveWorkspace", async () => workspace, async () => {
-        await withPatched(JobService.prototype as any, "startCommandRun", async () => ({ id: "cmd-3" }), async () => {
-          await withPatched(JobService.prototype as any, "finishCommandRun", async () => {}, async () => {
-            await withPatched(JobService.prototype as any, "recordTokenUsage", async (...args: any[]) => {
-              tokenCalls.push(args);
-            }, async () => {
-              await withPatched(JobService.prototype as any, "close", async () => {}, async () => {
-                const logs = await captureLogs(async () =>
-                  RoutingCommands.run(["preview", "--command", "work-on-tasks"]),
-                );
-                assert.ok(logs.join("\n").includes("agent-one"));
-                assert.equal(tokenCalls.length, 1);
-              });
-            });
-          });
-        });
-      });
-    });
-  });
-
-  it("prints explain json", async () => {
-    const stubRouting: any = {
-      normalizeCommand: (c: string) => c,
-      resolveAgentForCommand: async () => ({
-        agentId: "a1",
-        agentSlug: "agent-one",
-        agent: { id: "a1", slug: "agent-one" },
-        model: "stub",
-        capabilities: ["code_review"],
-        healthStatus: "healthy",
-        source: "workspace_default",
-        routingPreview: {
-          workspaceId: workspace.workspaceId,
-          commandName: "code-review",
-          resolvedAgent: { id: "a1" },
-          candidates: [{ agentId: "a1", agentSlug: "agent-one", source: "workspace_default" }],
-          provenance: "workspace_default",
-        },
-        requiredCapabilities: ["code_review"],
-      }),
-      close: async () => {},
-    };
-    await withPatched(RoutingService as any, "create", async () => stubRouting, async () => {
-      await withPatched(WorkspaceResolver as any, "resolveWorkspace", async () => workspace, async () => {
-        await withPatched(JobService.prototype as any, "startCommandRun", async () => ({ id: "cmd-4" }), async () => {
-          await withPatched(JobService.prototype as any, "finishCommandRun", async () => {}, async () => {
-            await withPatched(JobService.prototype as any, "recordTokenUsage", async () => {}, async () => {
-              await withPatched(JobService.prototype as any, "close", async () => {}, async () => {
-                const logs = await captureLogs(async () =>
-                  RoutingCommands.run(["explain", "--command", "code-review", "--json"]),
-                );
-                const parsed = JSON.parse(logs.join("\n"));
-                assert.equal(parsed.commandName ?? parsed.command_name, "code-review");
-              });
-            });
-          });
-        });
-      });
-    });
-  });
-
-  it("prints preview json with provenance", async () => {
-    const stubRouting: any = {
-      normalizeCommand: (c: string) => c,
-      resolveAgentForCommand: async () => ({
-        agentId: "a2",
-        agentSlug: "agent-two",
-        agent: { id: "a2", slug: "agent-two" },
-        model: "stub",
-        capabilities: ["plan"],
-        healthStatus: "healthy",
-        source: "global_default",
-        routingPreview: {
-          workspaceId: workspace.workspaceId,
-          commandName: "create-tasks",
-          resolvedAgent: { id: "a2" },
-          provenance: "global_default",
-        },
-        requiredCapabilities: ["plan"],
-      }),
-      close: async () => {},
-    };
-    await withPatched(RoutingService as any, "create", async () => stubRouting, async () => {
-      await withPatched(WorkspaceResolver as any, "resolveWorkspace", async () => workspace, async () => {
-        await withPatched(JobService.prototype as any, "startCommandRun", async () => ({ id: "cmd-5" }), async () => {
-          await withPatched(JobService.prototype as any, "finishCommandRun", async () => {}, async () => {
-            await withPatched(JobService.prototype as any, "recordTokenUsage", async () => {}, async () => {
-              await withPatched(JobService.prototype as any, "close", async () => {}, async () => {
-                const logs = await captureLogs(async () =>
-                  RoutingCommands.run(["preview", "--command", "create-tasks", "--json"]),
-                );
-                const parsed = JSON.parse(logs.join("\n"));
-                assert.equal(parsed.provenance, "global_default");
-                assert.equal(parsed.commandName ?? parsed.command_name, "create-tasks");
-              });
-            });
-          });
-        });
-      });
-    });
-  });
-
-  it("prints explain table with provenance", async () => {
-    const stubRouting: any = {
-      normalizeCommand: (c: string) => c,
-      resolveAgentForCommand: async () => ({
-        agentId: "a3",
-        agentSlug: "agent-three",
-        agent: { id: "a3", slug: "agent-three" },
-        model: "stub",
-        capabilities: ["plan"],
-        healthStatus: "degraded",
-        source: "override",
-        routingPreview: {
-          workspaceId: workspace.workspaceId,
-          commandName: "create-tasks",
-          resolvedAgent: { id: "a3" },
-          provenance: "override",
-          candidates: [
-            { agentId: "a3", agentSlug: "agent-three", source: "override", health: { status: "degraded" } as any },
-          ],
-          notes: "override used",
-        },
-        requiredCapabilities: ["plan"],
-      }),
-      close: async () => {},
-    };
-    await withPatched(RoutingService as any, "create", async () => stubRouting, async () => {
-      await withPatched(WorkspaceResolver as any, "resolveWorkspace", async () => workspace, async () => {
-        await withPatched(JobService.prototype as any, "startCommandRun", async () => ({ id: "cmd-6" }), async () => {
-          await withPatched(JobService.prototype as any, "finishCommandRun", async () => {}, async () => {
-            await withPatched(JobService.prototype as any, "recordTokenUsage", async () => {}, async () => {
-              await withPatched(JobService.prototype as any, "close", async () => {}, async () => {
-                const logs = await captureLogs(async () =>
-                  RoutingCommands.run(["explain", "--command", "create-tasks", "--agent", "agent-three"]),
-                );
-                const output = logs.join("\n");
-                assert.ok(output.includes("override"));
-                assert.ok(output.includes("agent-three"));
-                assert.ok(output.includes("degraded"));
-                assert.ok(output.includes("Required capabilities: plan"));
-              });
-            });
-          });
-        });
-      });
-    });
-  });
-});

package/packages/cli/src/__tests__/SetWorkspaceCommand.test.ts

@@ -1,18 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { parseSetWorkspaceArgs } from "../commands/workspace/SetWorkspaceCommand.js";
-
-describe("set-workspace argument parsing", () => {
-  it("defaults to git and docdex enabled", () => {
-    const parsed = parseSetWorkspaceArgs([]);
-    assert.equal(parsed.git, true);
-    assert.equal(parsed.docdex, true);
-  });
-
-  it("parses workspace root and disables features", () => {
-    const parsed = parseSetWorkspaceArgs(["--workspace-root", "/tmp/ws", "--no-git", "--no-docdex"]);
-    assert.equal(parsed.workspaceRoot, "/tmp/ws");
-    assert.equal(parsed.git, false);
-    assert.equal(parsed.docdex, false);
-  });
-});

package/packages/cli/src/__tests__/TaskShowCommands.test.ts

@@ -1,130 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it, beforeEach, afterEach } from "node:test";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { Connection, WorkspaceMigrations, WorkspaceRepository } from "@mcoda/db";
-import { PathHelper } from "@mcoda/shared";
-import { parseTaskShowArgs, TaskShowCommands } from "../commands/backlog/TaskShowCommands.js";
-
-describe("task show arg parsing", () => {
-  it("parses positional task key with options", () => {
-    const parsed = parseTaskShowArgs([
-      "show",
-      "web-01-us-01-t01",
-      "--project",
-      "WEB",
-      "--include-logs",
-      "--include-history",
-      "--format",
-      "json",
-    ]);
-    assert.equal(parsed.taskKey, "web-01-us-01-t01");
-    assert.equal(parsed.project, "WEB");
-    assert.equal(parsed.includeLogs, true);
-    assert.equal(parsed.includeHistory, true);
-    assert.equal(parsed.format, "json");
-  });
-
-  it("parses task-detail alias", () => {
-    const parsed = parseTaskShowArgs(["--project", "WEB", "--task", "web-01-us-01-t01"]);
-    assert.equal(parsed.taskKey, "web-01-us-01-t01");
-    assert.equal(parsed.project, "WEB");
-    assert.equal(parsed.format, "table");
-  });
-});
-
-describe("task show rendering", () => {
-  let workspaceRoot: string;
-  let taskKey: string;
-
-  beforeEach(async () => {
-    workspaceRoot = await fs.mkdtemp(path.join(os.tmpdir(), "mcoda-cli-task-"));
-    await fs.mkdir(path.join(workspaceRoot, ".mcoda"), { recursive: true });
-    const dbPath = PathHelper.getWorkspaceDbPath(workspaceRoot);
-    const connection = await Connection.open(dbPath);
-    await WorkspaceMigrations.run(connection.db);
-    const repo = new WorkspaceRepository(connection.db, connection);
-
-    const project = await repo.createProjectIfMissing({ key: "WEB", name: "Web" });
-    const [epic] = await repo.insertEpics(
-      [
-        {
-          projectId: project.id,
-          key: "web-01",
-          title: "Auth",
-          description: "Authentication work",
-        },
-      ],
-      true,
-    );
-    const [story] = await repo.insertStories(
-      [
-        {
-          projectId: project.id,
-          epicId: epic.id,
-          key: "web-01-us-01",
-          title: "Login",
-          description: "Login feature",
-        },
-      ],
-      true,
-    );
-    const [task] = await repo.insertTasks(
-      [
-        {
-          projectId: project.id,
-          epicId: epic.id,
-          userStoryId: story.id,
-          key: "web-01-us-01-t01",
-          title: "Implement login",
-          description: "Implement UI and API wiring",
-          status: "in_progress",
-          storyPoints: 5,
-          priority: 1,
-          vcsBranch: "mcoda/task/web-01-us-01-t01",
-        },
-      ],
-      true,
-    );
-    taskKey = task.key;
-
-    const now = new Date().toISOString();
-    await repo.createTaskComment({
-      taskId: task.id,
-      sourceCommand: "work-on-tasks",
-      authorType: "agent",
-      body: "Initial work started.",
-      createdAt: now,
-    });
-
-    await repo.close();
-  });
-
-  afterEach(async () => {
-    await fs.rm(workspaceRoot, { recursive: true, force: true });
-  });
-
-  it("prints key fields in table mode", async () => {
-    const logs: string[] = [];
-    const originalLog = console.log;
-    console.log = (...args: unknown[]) => {
-      logs.push(args.join(" "));
-    };
-    try {
-      await TaskShowCommands.run(["--workspace-root", workspaceRoot, taskKey]);
-    } finally {
-      console.log = originalLog;
-    }
-
-    const output = logs.join("\n");
-    assert.ok(output.includes(taskKey));
-    assert.ok(output.includes("Implement login"));
-    assert.ok(output.includes("SP: 5"));
-    assert.ok(output.includes("Project: WEB"));
-    assert.ok(output.includes("Epic: web-01"));
-    assert.ok(output.includes("Story: web-01-us-01"));
-    assert.ok(output.includes("Branch: mcoda/task/web-01-us-01-t01"));
-    assert.ok(output.includes("Initial work started."));
-  });
-});

package/packages/cli/src/__tests__/TelemetryCommands.test.ts

@@ -1,35 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { parseTelemetryArgs, parseTokensArgs } from "../commands/telemetry/TelemetryCommands.js";
-
-describe("telemetry CLI parsing", () => {
-  it("parses tokens args with explicit group-by and format", () => {
-    const parsed = parseTokensArgs([
-      "--project",
-      "PROJ",
-      "--agent",
-      "agent-1",
-      "--group-by",
-      "project,day,model",
-      "--format",
-      "json",
-    ]);
-    assert.equal(parsed.project, "PROJ");
-    assert.equal(parsed.agent, "agent-1");
-    assert.deepEqual(parsed.groupBy, ["project", "day", "model"]);
-    assert.equal(parsed.format, "json");
-  });
-
-  it("defaults tokens args when omitted", () => {
-    const parsed = parseTokensArgs([]);
-    assert.deepEqual(parsed.groupBy, ["project", "command", "agent"]);
-    assert.equal(parsed.format, "table");
-  });
-
-  it("parses telemetry opt-out strict flag", () => {
-    const parsed = parseTelemetryArgs(["opt-out", "--strict", "--format", "json"]);
-    assert.equal(parsed.subcommand, "opt-out");
-    assert.equal(parsed.strict, true);
-    assert.equal(parsed.format, "json");
-  });
-});

package/packages/cli/src/__tests__/TestAgentCommand.test.ts

@@ -1,41 +0,0 @@
-import assert from "node:assert/strict";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import test from "node:test";
-import { AgentsCommands } from "../commands/agents/AgentsCommands.js";
-import { TestAgentCommand } from "../commands/agents/TestAgentCommand.js";
-import { GlobalRepository } from "@mcoda/db";
-
-const withTempHome = async (fn: (home: string) => Promise<void>): Promise<void> => {
-  const originalHome = process.env.HOME;
-  const tempHome = await fs.mkdtemp(path.join(os.tmpdir(), "mcoda-test-agent-"));
-  const originalSkip = process.env.MCODA_SKIP_CLI_CHECKS;
-  process.env.HOME = tempHome;
-  process.env.MCODA_SKIP_CLI_CHECKS = "1";
-  try {
-    await fn(tempHome);
-  } finally {
-    process.env.HOME = originalHome;
-    process.env.MCODA_SKIP_CLI_CHECKS = originalSkip;
-    await fs.rm(tempHome, { recursive: true, force: true });
-  }
-};
-
-test("mcoda test-agent records health, command_runs, and token_usage", { concurrency: false }, async () => {
-  await withTempHome(async () => {
-    await AgentsCommands.run(["add", "qa", "--adapter", "qa-cli", "--capability", "chat"]);
-    await TestAgentCommand.run(["qa"]);
-
-    const repo = await GlobalRepository.create();
-    const agent = await repo.getAgentBySlug("qa");
-    assert.ok(agent);
-    const health = await repo.getAgentHealth(agent.id);
-    assert.equal(health?.status, "healthy");
-    const runs = await repo["db"].all("SELECT command_name FROM command_runs WHERE command_name = 'agent.test'");
-    assert.ok(runs.length >= 1);
-    const tokens = await repo["db"].all("SELECT agent_id FROM token_usage WHERE command_run_id IS NOT NULL");
-    assert.ok(tokens.length >= 1);
-    await repo.close();
-  });
-});