mcoda 0.1.0

package/packages/core/src/api/AgentsApi.ts

@@ -0,0 +1,219 @@
+import {
+  Agent,
+  AgentAuthMetadata,
+  AgentHealth,
+  AgentPromptManifest,
+  CreateAgentInput,
+  UpdateAgentInput,
+  CryptoHelper,
+} from "@mcoda/shared";
+import { GlobalCommandRun, GlobalRepository } from "@mcoda/db";
+import { AgentService, InvocationResult } from "@mcoda/agents";
+import { RoutingService } from "../services/agents/RoutingService.js";
+
+export interface AgentResponse extends Agent {
+  capabilities: string[];
+  prompts?: AgentPromptManifest;
+  health?: AgentHealth;
+  auth?: AgentAuthMetadata;
+  models?: Agent["models"];
+}
+
+export class AgentsApi {
+  constructor(private repo: GlobalRepository, private agentService: AgentService, private routingService: RoutingService) {}
+
+  static async create(): Promise<AgentsApi> {
+    const repo = await GlobalRepository.create();
+    const agentService = new AgentService(repo);
+    const routingService = await RoutingService.create();
+    return new AgentsApi(repo, agentService, routingService);
+  }
+
+  async close(): Promise<void> {
+    await this.repo.close();
+    if ((this.routingService as any)?.close) {
+      await (this.routingService as any).close();
+    }
+  }
+
+  private async resolveAgent(idOrSlug: string): Promise<Agent> {
+    return this.agentService.resolveAgent(idOrSlug);
+  }
+
+  private async withCommandRun<T>(
+    commandName: string,
+    payload: Record<string, unknown> | undefined,
+    fn: (run: GlobalCommandRun) => Promise<T>,
+  ): Promise<T> {
+    const run = await this.repo.createCommandRun({
+      commandName,
+      startedAt: new Date().toISOString(),
+      status: "running",
+      payload,
+    });
+    try {
+      const result = await fn(run);
+      await this.repo.completeCommandRun(run.id, {
+        status: "succeeded",
+        completedAt: new Date().toISOString(),
+        exitCode: 0,
+        result: payload ? { payload, output: result } : { output: result },
+      });
+      return result;
+    } catch (error) {
+      await this.repo.completeCommandRun(run.id, {
+        status: "failed",
+        completedAt: new Date().toISOString(),
+        exitCode: 1,
+        errorSummary: (error as Error).message,
+      });
+      throw error;
+    }
+  }
+
+  async listAgents(): Promise<AgentResponse[]> {
+    const agents = await this.repo.listAgents();
+    const health = await this.repo.listAgentHealthSummary();
+    const healthById = new Map(health.map((h) => [h.agentId, h]));
+    const results: AgentResponse[] = [];
+    for (const agent of agents) {
+      const [capabilities, models] = await Promise.all([
+        this.repo.getAgentCapabilities(agent.id),
+        this.repo.getAgentModels(agent.id),
+      ]);
+      results.push({
+        ...agent,
+        capabilities,
+        models,
+        health: healthById.get(agent.id),
+      });
+    }
+    return results;
+  }
+
+  async createAgent(input: CreateAgentInput): Promise<AgentResponse> {
+    return this.withCommandRun("agent.add", { slug: input.slug, adapter: input.adapter }, async () => {
+      const agent = await this.repo.createAgent(input);
+      const [capabilities, models] = await Promise.all([
+        this.repo.getAgentCapabilities(agent.id),
+        this.repo.getAgentModels(agent.id),
+      ]);
+      return { ...agent, capabilities, models };
+    });
+  }
+
+  async getAgent(idOrSlug: string): Promise<AgentResponse> {
+    const agent = await this.resolveAgent(idOrSlug);
+    const [capabilities, prompts, health, auth, models] = await Promise.all([
+      this.repo.getAgentCapabilities(agent.id),
+      this.repo.getAgentPrompts(agent.id),
+      this.repo.getAgentHealth(agent.id),
+      this.repo.getAgentAuthMetadata(agent.id),
+      this.repo.getAgentModels(agent.id),
+    ]);
+    return { ...agent, capabilities, prompts, health, auth, models };
+  }
+
+  async updateAgent(idOrSlug: string, patch: UpdateAgentInput): Promise<AgentResponse> {
+    const agent = await this.resolveAgent(idOrSlug);
+    return this.withCommandRun("agent.update", { id: agent.id, patch }, async () => {
+      const updated = await this.repo.updateAgent(agent.id, patch);
+      const [capabilities, models] = await Promise.all([
+        this.repo.getAgentCapabilities(agent.id),
+        this.repo.getAgentModels(agent.id),
+      ]);
+      return { ...(updated as Agent), capabilities, models };
+    });
+  }
+
+  async deleteAgent(idOrSlug: string, force = false): Promise<void> {
+    const agent = await this.resolveAgent(idOrSlug);
+    if (!force) {
+      const refs = await this.repo.findWorkspaceReferences(agent.id);
+      if (refs.length > 0) {
+        const details = refs
+          .map((r) => `${r.workspaceId === "__GLOBAL__" ? "global" : r.workspaceId}:${r.commandName}`)
+          .join(", ");
+        throw new Error(
+          `Agent is referenced by routing defaults (${details}); re-run with --force to delete`,
+        );
+      }
+    }
+    await this.withCommandRun("agent.delete", { id: agent.id, slug: agent.slug }, async () => {
+      await this.repo.deleteAgent(agent.id);
+    });
+  }
+
+  async setAgentAuth(idOrSlug: string, secret: string): Promise<AgentAuthMetadata> {
+    const agent = await this.resolveAgent(idOrSlug);
+    return this.withCommandRun("agent.auth.set", { id: agent.id }, async () => {
+      const encrypted = await CryptoHelper.encryptSecret(secret);
+      await this.repo.setAgentAuth(agent.id, encrypted);
+      return this.repo.getAgentAuthMetadata(agent.id);
+    });
+  }
+
+  async getAgentPrompts(idOrSlug: string): Promise<AgentPromptManifest | undefined> {
+    const agent = await this.resolveAgent(idOrSlug);
+    return this.repo.getAgentPrompts(agent.id);
+  }
+
+  async testAgent(idOrSlug: string): Promise<AgentHealth> {
+    const agent = await this.resolveAgent(idOrSlug);
+    return this.withCommandRun("agent.test", { id: agent.id, slug: agent.slug }, async (run) => {
+      const health = await this.agentService.healthCheck(agent.id);
+      await this.repo.recordTokenUsage({
+        agentId: agent.id,
+        commandRunId: run.id,
+        modelName: agent.defaultModel,
+        tokensPrompt: 0,
+        tokensCompletion: 0,
+        tokensTotal: 0,
+        timestamp: new Date().toISOString(),
+        metadata: { reason: "agent.test", healthStatus: health.status },
+      });
+      return health;
+    });
+  }
+
+  async probeAgent(
+    idOrSlug: string,
+    prompt = "Hello from mcoda test-agent. Please reply with a short acknowledgement.",
+  ): Promise<{ health: AgentHealth; response: InvocationResult; prompt: string }> {
+    const agent = await this.resolveAgent(idOrSlug);
+    const trimmedPrompt = prompt.trim() || "Hello from mcoda test-agent. Please reply with a short acknowledgement.";
+    return this.withCommandRun(
+      "agent.test",
+      { id: agent.id, slug: agent.slug, prompt: trimmedPrompt },
+      async (run) => {
+        const health = await this.agentService.healthCheck(agent.id);
+        const response = await this.agentService.invoke(agent.id, {
+          input: trimmedPrompt,
+          metadata: { command: "test-agent" },
+        });
+        await this.repo.recordTokenUsage({
+          agentId: agent.id,
+          commandRunId: run.id,
+          modelName: agent.defaultModel,
+          tokensPrompt: 0,
+          tokensCompletion: 0,
+          tokensTotal: 0,
+          timestamp: new Date().toISOString(),
+          metadata: { reason: "agent.test", healthStatus: health.status, adapter: response.adapter },
+        });
+        return { health, response, prompt: trimmedPrompt };
+      },
+    );
+  }
+
+  async setDefaultAgent(
+    idOrSlug: string,
+    workspaceId = "__GLOBAL__",
+    commandName = "default",
+  ): Promise<void> {
+    const agent = await this.resolveAgent(idOrSlug);
+    await this.withCommandRun("agent.set-default", { workspaceId, commandName, agent: agent.slug }, async () => {
+      await this.routingService.updateWorkspaceDefaults(workspaceId, { set: { [commandName]: agent.slug } });
+    });
+  }
+}

package/packages/core/src/api/QaTasksApi.ts

@@ -0,0 +1,38 @@
+import { WorkspaceResolver } from "../workspace/WorkspaceManager.js";
+import { QaTasksService, QaTasksRequest, QaTasksResponse } from "../services/execution/QaTasksService.js";
+
+export class QaTasksApi {
+  static async runQa(
+    request: Partial<QaTasksRequest> & { workspaceRoot?: string; noTelemetry?: boolean },
+  ): Promise<QaTasksResponse> {
+    const workspace = await WorkspaceResolver.resolveWorkspace({
+      cwd: process.cwd(),
+      explicitWorkspace: request.workspaceRoot,
+    });
+    const service = await QaTasksService.create(workspace, { noTelemetry: request.noTelemetry ?? false });
+    try {
+      return await service.run({
+        workspace,
+        projectKey: request.projectKey,
+        epicKey: request.epicKey,
+        storyKey: request.storyKey,
+        taskKeys: request.taskKeys,
+        statusFilter: request.statusFilter,
+        mode: request.mode,
+        resumeJobId: request.resumeJobId,
+        profileName: request.profileName,
+        level: request.level,
+        testCommand: request.testCommand,
+        agentName: request.agentName,
+        agentStream: request.agentStream,
+        createFollowupTasks: request.createFollowupTasks,
+        dryRun: request.dryRun,
+        result: request.result,
+        notes: request.notes,
+        evidenceUrl: request.evidenceUrl,
+      });
+    } finally {
+      await service.close();
+    }
+  }
+}

package/packages/core/src/api/TasksApi.ts

@@ -0,0 +1,35 @@
+import { RefineTasksRequest, RefineTasksResult } from "@mcoda/shared";
+import { WorkspaceResolver } from "../workspace/WorkspaceManager.js";
+import { RefineTasksService } from "../services/planning/RefineTasksService.js";
+
+export class TasksApi {
+  static async refineTasks(request: RefineTasksRequest & { workspaceRoot?: string }): Promise<RefineTasksResult> {
+    const workspace = await WorkspaceResolver.resolveWorkspace({
+      cwd: process.cwd(),
+      explicitWorkspace: request.workspaceRoot,
+    });
+    const service = await RefineTasksService.create(workspace);
+    try {
+      return await service.refineTasks({
+        workspace,
+        projectKey: request.projectKey,
+        epicKey: request.epicKey,
+        storyKey: request.userStoryKey,
+        taskKeys: request.taskKeys,
+        statusFilter: request.statusFilter,
+        maxTasks: request.maxTasks,
+        strategy: request.strategy,
+        agentName: request.agentIdOverride,
+        agentStream: true,
+        fromDb: true,
+        dryRun: request.dryRun,
+        planInPath: request.planInPath,
+        planOutPath: request.planOutPath,
+        jobId: undefined,
+        outputJson: false,
+      });
+    } finally {
+      await service.close();
+    }
+  }
+}

package/packages/core/src/api/__tests__/AgentsApi.test.ts

@@ -0,0 +1,203 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { after, test } from "node:test";
+import { AgentsApi } from "../AgentsApi.js";
+import { Connection, GlobalMigrations, GlobalRepository } from "@mcoda/db";
+import { AgentService } from "@mcoda/agents";
+import { PathHelper } from "@mcoda/shared";
+
+const withTempHome = async (fn: (home: string) => Promise<void>): Promise<void> => {
+  const originalHome = process.env.HOME;
+  const home = await fs.mkdtemp(path.join(os.tmpdir(), "mcoda-agents-api-"));
+  process.env.HOME = home;
+  try {
+    await fn(home);
+  } finally {
+    process.env.HOME = originalHome;
+    await fs.rm(home, { recursive: true, force: true });
+  }
+};
+
+const originalSkipCliChecks = process.env.MCODA_SKIP_CLI_CHECKS;
+const originalCliStub = process.env.MCODA_CLI_STUB;
+process.env.MCODA_SKIP_CLI_CHECKS = "1";
+process.env.MCODA_CLI_STUB = "1";
+
+const makeApi = async () => {
+  const conn = await Connection.open(PathHelper.getGlobalDbPath());
+  await GlobalMigrations.run(conn.db);
+  const repo = new GlobalRepository(conn.db, conn);
+  const agentService = new AgentService(repo);
+  const routingService = {
+    updateWorkspaceDefaults: async () => {},
+    close: async () => {},
+  };
+  const api = new AgentsApi(repo, agentService as any, routingService as any);
+  return { api, repo, conn };
+};
+
+test("setAgentAuth stores encrypted secret and returns redacted metadata", async () => {
+  await withTempHome(async () => {
+    const { api, repo } = await makeApi();
+    await repo.createAgent({ slug: "openai", adapter: "openai-api" });
+
+    const auth = await api.setAgentAuth("openai", "super-secret");
+    assert.equal(auth.configured, true);
+    assert.ok(auth.lastUpdatedAt);
+    // ensure secrets are not returned
+    assert.equal((auth as any).encryptedSecret, undefined);
+
+    const agent = await api.getAgent("openai");
+    assert.equal(agent.auth?.configured, true);
+    assert.equal((agent.auth as any)?.encryptedSecret, undefined);
+    const stored = await repo.getAgentAuthSecret(agent.id);
+    assert.ok(stored?.encryptedSecret);
+    assert.notEqual(stored?.encryptedSecret, "super-secret");
+
+    await api.close();
+  });
+});
+
+after(() => {
+  process.env.MCODA_SKIP_CLI_CHECKS = originalSkipCliChecks;
+  if (originalCliStub === undefined) {
+    delete process.env.MCODA_CLI_STUB;
+  } else {
+    process.env.MCODA_CLI_STUB = originalCliStub;
+  }
+});
+
+test("getAgentPrompts returns stored prompt manifest", async () => {
+  await withTempHome(async () => {
+    const { api, repo } = await makeApi();
+    await repo.createAgent({
+      slug: "prompted",
+      adapter: "local-model",
+      prompts: { jobPrompt: "job", characterPrompt: "character", commandPrompts: { test: "cmd" } },
+    });
+
+    const manifest = await api.getAgentPrompts("prompted");
+    assert.ok(manifest);
+    assert.equal(manifest?.jobPrompt, "job");
+    assert.equal(manifest?.commandPrompts?.test, "cmd");
+
+    await api.close();
+  });
+});
+
+test("testAgent stores health and command_runs entry", async () => {
+  await withTempHome(async () => {
+    const { api, repo, conn } = await makeApi();
+    await repo.createAgent({ slug: "codex", adapter: "codex-cli", capabilities: ["chat"] });
+
+    const health = await api.testAgent("codex");
+    assert.equal(health.status, "healthy");
+    const stored = await repo.getAgentHealth((await repo.getAgentBySlug("codex"))!.id);
+    assert.equal(stored?.status, "healthy");
+    const runs = await conn.db.all<{ command_name: string }[]>(
+      "SELECT command_name FROM command_runs WHERE command_name = 'agent.test'",
+    );
+    assert.ok(runs.length >= 1);
+    const tokenUsage = await conn.db.all<{ command_run_id: string }[]>("SELECT command_run_id FROM token_usage");
+    assert.ok(tokenUsage.length >= 1);
+
+    await api.close();
+  });
+});
+
+test("deleteAgent blocks referenced agents unless forced and logs deletion", async () => {
+  await withTempHome(async () => {
+    const { api, repo, conn } = await makeApi();
+    const agent = await repo.createAgent({ slug: "used", adapter: "local-model" });
+    await repo.setWorkspaceDefault("ws-1", "work-on-tasks", agent.id);
+
+    await assert.rejects(() => api.deleteAgent("used"), /routing defaults/i);
+    const stillExists = await repo.getAgentBySlug("used");
+    assert.ok(stillExists);
+
+    await api.deleteAgent("used", true);
+    const missing = await repo.getAgentBySlug("used");
+    assert.equal(missing, undefined);
+    const runs = await conn.db.all<{ command_name: string }[]>(
+      "SELECT command_name FROM command_runs WHERE command_name = 'agent.delete'",
+    );
+    assert.ok(runs.length >= 1);
+
+    await api.close();
+  });
+});
+
+test("listAgents returns capabilities, models, and stored health", async () => {
+  await withTempHome(async () => {
+    const { api, repo } = await makeApi();
+    const agent = await repo.createAgent({
+      slug: "cap-agent",
+      adapter: "openai-api",
+      defaultModel: "gpt-4o",
+      capabilities: ["chat", "code_write"],
+      models: [
+        { agentId: "ignore", modelName: "gpt-4o", isDefault: true },
+        { agentId: "ignore", modelName: "gpt-4.1-mini", isDefault: false },
+      ],
+    });
+    await repo.setAgentHealth({
+      agentId: agent.id,
+      status: "healthy",
+      lastCheckedAt: new Date().toISOString(),
+      latencyMs: 1,
+    });
+
+    const agents = await api.listAgents();
+    const found = agents.find((a) => a.slug === "cap-agent");
+    assert.ok(found);
+    assert.equal(found.health?.status, "healthy");
+    assert.deepEqual(found.capabilities?.sort(), ["chat", "code_write"].sort());
+    assert.ok(found.models?.find((m) => m.modelName === "gpt-4o"));
+
+    await api.close();
+  });
+});
+
+test("createAgent/updateAgent round trip with auth redaction", async () => {
+  await withTempHome(async () => {
+    const { api, repo } = await makeApi();
+    await api.createAgent({ slug: "crud", adapter: "openai-api", defaultModel: "gpt-4o", capabilities: ["chat"] });
+    await api.setAgentAuth("crud", "super-secret");
+    const updated = await api.updateAgent("crud", { defaultModel: "gpt-4.1-mini", capabilities: ["chat", "plan"] });
+    assert.equal(updated.defaultModel, "gpt-4.1-mini");
+    assert.deepEqual(updated.capabilities?.sort(), ["chat", "plan"].sort());
+
+    const agent = await api.getAgent("crud");
+    assert.equal(agent.auth?.configured, true);
+    assert.equal((agent.auth as any)?.encryptedSecret, undefined);
+    const stored = await repo.getAgentAuthSecret(agent.id);
+    assert.ok(stored?.encryptedSecret);
+
+    await api.close();
+  });
+});
+
+test("setDefaultAgent delegates to routing service", async () => {
+  await withTempHome(async () => {
+    const conn = await Connection.open(PathHelper.getGlobalDbPath());
+    await GlobalMigrations.run(conn.db);
+    const repo = new GlobalRepository(conn.db, conn);
+    const agentService = new AgentService(repo);
+    const agent = await repo.createAgent({ slug: "router", adapter: "local-model" });
+    let called = 0;
+    const routingService = {
+      updateWorkspaceDefaults: async (workspaceId: string, update: any) => {
+        called += 1;
+        assert.equal(workspaceId, "ws-routing");
+        assert.equal(update.set?.default, agent.slug);
+      },
+      close: async () => {},
+    };
+    const api = new AgentsApi(repo, agentService as any, routingService as any);
+    await api.setDefaultAgent(agent.slug, "ws-routing");
+    assert.equal(called, 1);
+    await api.close();
+  });
+});

package/packages/core/src/api/__tests__/QaTasksApi.test.ts

@@ -0,0 +1,51 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { WorkspaceRepository } from "@mcoda/db";
+import { WorkspaceResolver } from "../../workspace/WorkspaceManager.js";
+import { QaTasksApi } from "../QaTasksApi.js";
+
+test("QaTasksApi.runQa supports manual dry-run", async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "mcoda-qa-api-"));
+  const workspace = await WorkspaceResolver.resolveWorkspace({ cwd: dir, explicitWorkspace: dir });
+  const repo = await WorkspaceRepository.create(workspace.workspaceRoot);
+  try {
+    const project = await repo.createProjectIfMissing({ key: "proj", name: "Project" });
+    const [epic] = await repo.insertEpics([
+      { projectId: project.id, key: "proj-epic", title: "Epic", description: "", priority: 1 },
+    ]);
+    const [story] = await repo.insertStories([
+      { projectId: project.id, epicId: epic.id, key: "proj-epic-us-01", title: "Story", description: "" },
+    ]);
+    await repo.insertTasks([
+      {
+        projectId: project.id,
+        epicId: epic.id,
+        userStoryId: story.id,
+        key: "proj-epic-us-01-t01",
+        title: "Task QA",
+        description: "",
+        status: "ready_to_qa",
+        storyPoints: 1,
+      },
+    ]);
+
+    const result = await QaTasksApi.runQa({
+      workspaceRoot: dir,
+      projectKey: "proj",
+      mode: "manual",
+      result: "pass",
+      createFollowupTasks: "none",
+      dryRun: false,
+      agentStream: false,
+    });
+
+    assert.equal(result.results.length, 1);
+    assert.equal(result.results[0]?.outcome, "pass");
+  } finally {
+    await repo.close();
+    await fs.rm(dir, { recursive: true, force: true });
+  }
+});

package/packages/core/src/api/__tests__/TasksApi.test.ts

@@ -0,0 +1,56 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { WorkspaceRepository } from "@mcoda/db";
+import { WorkspaceResolver } from "../../workspace/WorkspaceManager.js";
+import { TasksApi } from "../TasksApi.js";
+
+
+test("TasksApi.refineTasks wires plan-in requests", async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "mcoda-tasks-api-"));
+  const workspace = await WorkspaceResolver.resolveWorkspace({ cwd: dir, explicitWorkspace: dir });
+  const repo = await WorkspaceRepository.create(workspace.workspaceRoot);
+  try {
+    const project = await repo.createProjectIfMissing({ key: "demo", name: "demo" });
+    const [epic] = await repo.insertEpics([
+      { projectId: project.id, key: "demo-01", title: "Epic", description: "", priority: 1 },
+    ]);
+    const [story] = await repo.insertStories([
+      { projectId: project.id, epicId: epic.id, key: "demo-01-us-01", title: "Story", description: "" },
+    ]);
+    const [task] = await repo.insertTasks([
+      {
+        projectId: project.id,
+        epicId: epic.id,
+        userStoryId: story.id,
+        key: "demo-01-us-01-t01",
+        title: "Task",
+        description: "",
+        status: "not_started",
+      },
+    ]);
+
+    const plan = {
+      strategy: "estimate",
+      operations: [{ op: "update_estimate", taskKey: task.key, storyPoints: 5 }],
+    };
+    const planPath = path.join(dir, "plan.json");
+    await fs.writeFile(planPath, JSON.stringify(plan, null, 2), "utf8");
+
+    const result = await TasksApi.refineTasks({
+      workspaceRoot: dir,
+      projectKey: "demo",
+      planInPath: planPath,
+      strategy: "estimate",
+      dryRun: true,
+    } as any);
+
+    assert.equal(result.plan.operations.length, 1);
+    assert.equal(result.plan.operations[0]?.op, "update_estimate");
+  } finally {
+    await repo.close();
+    await fs.rm(dir, { recursive: true, force: true });
+  }
+});

package/packages/core/src/config/ConfigService.ts

@@ -0,0 +1 @@
+export class ConfigService {}

package/packages/core/src/domain/dependencies/Dependency.ts

@@ -0,0 +1 @@
+export class Dependency {}

package/packages/core/src/domain/epics/Epic.ts

@@ -0,0 +1 @@
+export class Epic {}

package/packages/core/src/domain/projects/Project.ts

@@ -0,0 +1 @@
+export class Project {}

package/packages/core/src/domain/tasks/Task.ts

@@ -0,0 +1 @@
+export class Task {}

package/packages/core/src/domain/userStories/UserStory.ts

@@ -0,0 +1 @@
+export class UserStory {}

package/packages/core/src/index.ts

@@ -0,0 +1,27 @@
+export * from "./api/AgentsApi.js";
+export * from "./services/docs/DocsService.js";
+export * from "./services/openapi/OpenApiService.js";
+export * from "./services/jobs/JobService.js";
+export * from "./services/jobs/JobInsightsService.js";
+export * from "./services/jobs/JobResumeService.js";
+export * from "./services/planning/CreateTasksService.js";
+export * from "./services/planning/RefineTasksService.js";
+export * from "./services/planning/KeyHelpers.js";
+export * from "./services/execution/TaskSelectionService.js";
+export * from "./services/execution/TaskStateService.js";
+export * from "./services/execution/WorkOnTasksService.js";
+export * from "./services/execution/QaTasksService.js";
+export * from "./services/review/CodeReviewService.js";
+export * from "./api/TasksApi.js";
+export * from "./api/QaTasksApi.js";
+export * from "./services/backlog/BacklogService.js";
+export * from "./services/estimate/EstimateService.js";
+export * from "./services/estimate/VelocityService.js";
+export * from "./services/estimate/types.js";
+export * from "./services/telemetry/TelemetryService.js";
+export * from "./services/tasks/TaskDetailService.js";
+export * from "./services/backlog/TaskOrderingService.js";
+export * from "./services/agents/RoutingService.js";
+export * from "./services/agents/GatewayAgentService.js";
+export * from "./workspace/WorkspaceManager.js";
+export * from "./services/system/SystemUpdateService.js";