mcoda 0.1.2 → 0.1.4

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

@@ -1,219 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,203 +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 { 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

@@ -1,51 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

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

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

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

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

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

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

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

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

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

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

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

package/packages/core/src/index.ts

@@ -1,27 +0,0 @@
-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";