@locusai/sdk 0.4.6 → 0.4.9

package/dist/index-node.js

@@ -1,20 +1,1590 @@
-/**
- * Node.js-only exports
- * This is a separate entry point for Node.js/CLI only
- * It should NOT be imported by browser applications
- *
- * These modules use Node.js APIs (fs, child_process, etc.)
- * and will break in browser environments
- */
-// Node.js-only: Agent system
-export * from "./agent/index.js";
-// Node.js-only: AI clients
-export * from "./ai/index.js";
-// Node.js-only: Core utilities (uses fs)
-export * from "./core/index.js";
-// Re-export everything from main index (browser-safe)
-export * from "./index.js";
-// Node.js-only: Orchestrator
-export { AgentOrchestrator } from "./orchestrator.js";
-// Utilities
-export { c } from "./utils/colors.js";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  WorkspacesModule: () => WorkspacesModule,
+  TasksModule: () => TasksModule,
+  SprintsModule: () => SprintsModule,
+  OrganizationsModule: () => OrganizationsModule,
+  LocusEvent: () => LocusEvent,
+  LocusEmitter: () => LocusEmitter,
+  LocusClient: () => LocusClient,
+  InvitationsModule: () => InvitationsModule,
+  DocsModule: () => DocsModule,
+  CiModule: () => CiModule,
+  AuthModule: () => AuthModule
+});
+module.exports = __toCommonJS(exports_src);
+var import_axios = __toESM(require("axios"));
+
+// src/events.ts
+var import_events = require("events");
+var LocusEvent;
+((LocusEvent2) => {
+  LocusEvent2["TOKEN_EXPIRED"] = "TOKEN_EXPIRED";
+  LocusEvent2["AUTH_ERROR"] = "AUTH_ERROR";
+  LocusEvent2["REQUEST_ERROR"] = "REQUEST_ERROR";
+})(LocusEvent ||= {});
+
+class LocusEmitter extends import_events.EventEmitter {
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+}
+
+// src/modules/base.ts
+class BaseModule {
+  api;
+  emitter;
+  constructor(api, emitter) {
+    this.api = api;
+    this.emitter = emitter;
+  }
+}
+
+// src/modules/auth.ts
+class AuthModule extends BaseModule {
+  async getMe() {
+    const { data } = await this.api.get("/auth/me");
+    return data;
+  }
+  async requestRegisterOtp(email) {
+    const { data } = await this.api.post("/auth/register-otp", { email });
+    return data;
+  }
+  async requestLoginOtp(email) {
+    const { data } = await this.api.post("/auth/login-otp", { email });
+    return data;
+  }
+  async verifyLogin(body) {
+    const { data } = await this.api.post("/auth/verify-login", body);
+    return data;
+  }
+  async completeRegistration(body) {
+    const { data } = await this.api.post("/auth/complete-registration", body);
+    return data;
+  }
+}
+
+// src/modules/ci.ts
+class CiModule extends BaseModule {
+  async report(body) {
+    const { data } = await this.api.post("/ci/report", body);
+    return data;
+  }
+}
+
+// src/modules/docs.ts
+class DocsModule extends BaseModule {
+  async create(workspaceId, body) {
+    const { data } = await this.api.post(`/workspaces/${workspaceId}/docs`, body);
+    return data.doc;
+  }
+  async list(workspaceId) {
+    const { data } = await this.api.get(`/workspaces/${workspaceId}/docs`);
+    return data.docs;
+  }
+  async getById(id, workspaceId) {
+    const { data } = await this.api.get(`/workspaces/${workspaceId}/docs/${id}`);
+    return data.doc;
+  }
+  async update(id, workspaceId, body) {
+    const { data } = await this.api.put(`/workspaces/${workspaceId}/docs/${id}`, body);
+    return data.doc;
+  }
+  async delete(id, workspaceId) {
+    await this.api.delete(`/workspaces/${workspaceId}/docs/${id}`);
+  }
+  async listGroups(workspaceId) {
+    const { data } = await this.api.get(`/workspaces/${workspaceId}/doc-groups`);
+    return data.groups;
+  }
+  async createGroup(workspaceId, body) {
+    const { data } = await this.api.post(`/workspaces/${workspaceId}/doc-groups`, body);
+    return data.group;
+  }
+  async updateGroup(id, workspaceId, body) {
+    const { data } = await this.api.patch(`/workspaces/${workspaceId}/doc-groups/${id}`, body);
+    return data.group;
+  }
+  async deleteGroup(id, workspaceId) {
+    await this.api.delete(`/workspaces/${workspaceId}/doc-groups/${id}`);
+  }
+}
+
+// src/modules/invitations.ts
+class InvitationsModule extends BaseModule {
+  async create(orgId, body) {
+    const { data } = await this.api.post(`/org/${orgId}/invitations`, body);
+    return data.invitation;
+  }
+  async list(orgId) {
+    const { data } = await this.api.get(`/org/${orgId}/invitations`);
+    return data.invitations;
+  }
+  async verify(token) {
+    const { data } = await this.api.get(`/invitations/verify/${token}`);
+    return data;
+  }
+  async accept(body) {
+    const { data } = await this.api.post("/invitations/accept", body);
+    return data;
+  }
+  async revoke(orgId, id) {
+    await this.api.delete(`/org/${orgId}/invitations/${id}`);
+  }
+}
+
+// src/modules/organizations.ts
+class OrganizationsModule extends BaseModule {
+  async list() {
+    const { data } = await this.api.get("/organizations");
+    return data.organizations;
+  }
+  async getById(id) {
+    const { data } = await this.api.get(`/organizations/${id}`);
+    return data.organization;
+  }
+  async listMembers(id) {
+    const { data } = await this.api.get(`/organizations/${id}/members`);
+    return data.members;
+  }
+  async addMember(id, body) {
+    const { data } = await this.api.post(`/organizations/${id}/members`, body);
+    return data.membership;
+  }
+  async removeMember(orgId, userId) {
+    await this.api.delete(`/organizations/${orgId}/members/${userId}`);
+  }
+  async delete(orgId) {
+    await this.api.delete(`/organizations/${orgId}`);
+  }
+  async listApiKeys(orgId) {
+    const { data } = await this.api.get(`/organizations/${orgId}/api-keys`);
+    return data.apiKeys;
+  }
+  async createApiKey(orgId, name) {
+    const { data } = await this.api.post(`/organizations/${orgId}/api-keys`, { name });
+    return data.apiKey;
+  }
+  async deleteApiKey(orgId, keyId) {
+    await this.api.delete(`/organizations/${orgId}/api-keys/${keyId}`);
+  }
+}
+
+// src/modules/sprints.ts
+class SprintsModule extends BaseModule {
+  async list(workspaceId) {
+    const { data } = await this.api.get(`/workspaces/${workspaceId}/sprints`);
+    return data.sprints;
+  }
+  async getActive(workspaceId) {
+    const { data } = await this.api.get(`/workspaces/${workspaceId}/sprints/active`);
+    return data.sprint;
+  }
+  async getById(id, workspaceId) {
+    const { data } = await this.api.get(`/workspaces/${workspaceId}/sprints/${id}`);
+    return data.sprint;
+  }
+  async create(workspaceId, body) {
+    const { data } = await this.api.post(`/workspaces/${workspaceId}/sprints`, body);
+    return data.sprint;
+  }
+  async update(id, workspaceId, body) {
+    const { data } = await this.api.patch(`/workspaces/${workspaceId}/sprints/${id}`, body);
+    return data.sprint;
+  }
+  async delete(id, workspaceId) {
+    await this.api.delete(`/workspaces/${workspaceId}/sprints/${id}`);
+  }
+  async start(id, workspaceId) {
+    const { data } = await this.api.post(`/workspaces/${workspaceId}/sprints/${id}/start`);
+    return data.sprint;
+  }
+  async complete(id, workspaceId) {
+    const { data } = await this.api.post(`/workspaces/${workspaceId}/sprints/${id}/complete`);
+    return data.sprint;
+  }
+}
+
+// src/modules/tasks.ts
+var import_shared = require("@locusai/shared");
+class TasksModule extends BaseModule {
+  async list(workspaceId, options) {
+    const { data } = await this.api.get(`/workspaces/${workspaceId}/tasks`);
+    let tasks = data.tasks;
+    if (options?.sprintId) {
+      tasks = tasks.filter((t) => t.sprintId === options.sprintId);
+    }
+    if (options?.status) {
+      const statuses = Array.isArray(options.status) ? options.status : [options.status];
+      tasks = tasks.filter((t) => statuses.includes(t.status));
+    }
+    return tasks;
+  }
+  async getAvailable(workspaceId, sprintId) {
+    const tasks = await this.list(workspaceId, {
+      sprintId
+    });
+    return tasks.filter((t) => t.status === import_shared.TaskStatus.BACKLOG || t.status === import_shared.TaskStatus.IN_PROGRESS && !t.assignedTo);
+  }
+  async getById(id, workspaceId) {
+    const { data } = await this.api.get(`/workspaces/${workspaceId}/tasks/${id}`);
+    return data.task;
+  }
+  async create(workspaceId, body) {
+    const { data } = await this.api.post(`/workspaces/${workspaceId}/tasks`, body);
+    return data.task;
+  }
+  async update(id, workspaceId, body) {
+    const { data } = await this.api.patch(`/workspaces/${workspaceId}/tasks/${id}`, body);
+    return data.task;
+  }
+  async delete(id, workspaceId) {
+    await this.api.delete(`/workspaces/${workspaceId}/tasks/${id}`);
+  }
+  async getBacklog(workspaceId) {
+    const { data } = await this.api.get(`/workspaces/${workspaceId}/tasks/backlog`);
+    return data.tasks;
+  }
+  async addComment(id, workspaceId, body) {
+    const { data } = await this.api.post(`/workspaces/${workspaceId}/tasks/${id}/comment`, body);
+    return data.comment;
+  }
+}
+
+// src/modules/workspaces.ts
+class WorkspacesModule extends BaseModule {
+  async listAll() {
+    const { data } = await this.api.get("/workspaces");
+    return data.workspaces;
+  }
+  async listByOrg(orgId) {
+    const { data } = await this.api.get(`/workspaces/org/${orgId}`);
+    return data.workspaces;
+  }
+  async create(body) {
+    const { orgId, ...bodyWithoutOrgId } = body;
+    const { data } = await this.api.post(`/workspaces/org/${orgId}`, bodyWithoutOrgId);
+    return data.workspace;
+  }
+  async createWithAutoOrg(body) {
+    const { data } = await this.api.post("/workspaces", body);
+    return data.workspace;
+  }
+  async getById(id) {
+    const { data } = await this.api.get(`/workspaces/${id}`);
+    return data.workspace;
+  }
+  async update(id, body) {
+    const { data } = await this.api.put(`/workspaces/${id}`, body);
+    return data.workspace;
+  }
+  async delete(id) {
+    await this.api.delete(`/workspaces/${id}`);
+  }
+  async getStats(id) {
+    const { data } = await this.api.get(`/workspaces/${id}/stats`);
+    return data;
+  }
+  async getActivity(id, limit) {
+    const { data } = await this.api.get(`/workspaces/${id}/activity`, {
+      params: { limit }
+    });
+    return data.activity;
+  }
+  async dispatch(id, workerId, sprintId) {
+    const { data } = await this.api.post(`/workspaces/${id}/dispatch`, { workerId, sprintId });
+    return data.task;
+  }
+}
+
+// src/index.ts
+class LocusClient {
+  api;
+  emitter;
+  auth;
+  tasks;
+  sprints;
+  workspaces;
+  organizations;
+  invitations;
+  docs;
+  ci;
+  constructor(config) {
+    this.emitter = new LocusEmitter;
+    this.api = import_axios.default.create({
+      baseURL: config.baseUrl,
+      timeout: config.timeout || 1e4,
+      headers: {
+        "Content-Type": "application/json",
+        ...config.token ? { Authorization: `Bearer ${config.token}` } : {}
+      }
+    });
+    this.setupInterceptors();
+    this.auth = new AuthModule(this.api, this.emitter);
+    this.tasks = new TasksModule(this.api, this.emitter);
+    this.sprints = new SprintsModule(this.api, this.emitter);
+    this.workspaces = new WorkspacesModule(this.api, this.emitter);
+    this.organizations = new OrganizationsModule(this.api, this.emitter);
+    this.invitations = new InvitationsModule(this.api, this.emitter);
+    this.docs = new DocsModule(this.api, this.emitter);
+    this.ci = new CiModule(this.api, this.emitter);
+    if (config.retryOptions) {
+      this.setupRetryInterceptor(config.retryOptions);
+    }
+  }
+  setupRetryInterceptor(retryOptions) {
+    this.api.interceptors.response.use(undefined, async (error) => {
+      const config = error.config;
+      if (!config || !retryOptions) {
+        return Promise.reject(error);
+      }
+      config._retryCount = config._retryCount || 0;
+      const maxRetries = retryOptions.maxRetries ?? 3;
+      const shouldRetry = config._retryCount < maxRetries && (retryOptions.retryCondition ? retryOptions.retryCondition(error) : !error.response || error.response.status >= 500);
+      if (shouldRetry) {
+        config._retryCount++;
+        const delay = Math.min((retryOptions.initialDelay ?? 1000) * Math.pow(retryOptions.factor ?? 2, config._retryCount - 1), retryOptions.maxDelay ?? 5000);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        return this.api(config);
+      }
+      return Promise.reject(error);
+    });
+  }
+  setupInterceptors() {
+    this.api.interceptors.response.use((response) => {
+      if (response.data && typeof response.data === "object" && "data" in response.data) {
+        response.data = response.data.data;
+      }
+      return response;
+    }, (error) => {
+      const status = error.response?.status;
+      let message;
+      if (error.response?.data?.error?.message && typeof error.response.data.error.message === "string") {
+        message = error.response.data.error.message;
+      } else if (error.response?.data?.message && typeof error.response.data.message === "string") {
+        message = error.response.data.message;
+      } else if (error.message && typeof error.message === "string") {
+        message = error.message;
+      } else {
+        message = "An error occurred";
+      }
+      const enhancedError = new Error(message);
+      enhancedError.name = `HTTP${status || "Error"}`;
+      if (status === 401) {
+        this.emitter.emit("TOKEN_EXPIRED" /* TOKEN_EXPIRED */);
+        this.emitter.emit("AUTH_ERROR" /* AUTH_ERROR */, enhancedError);
+      } else {
+        this.emitter.emit("REQUEST_ERROR" /* REQUEST_ERROR */, enhancedError);
+      }
+      return Promise.reject(enhancedError);
+    });
+  }
+  setToken(token) {
+    if (token) {
+      this.api.defaults.headers.common.Authorization = `Bearer ${token}`;
+    } else {
+      delete this.api.defaults.headers.common.Authorization;
+    }
+  }
+}
+
+// src/index-node.ts
+var exports_index_node = {};
+__export(exports_index_node, {
+  getLocusPath: () => getLocusPath,
+  c: () => c,
+  WorkspacesModule: () => WorkspacesModule,
+  TasksModule: () => TasksModule,
+  TaskExecutor: () => TaskExecutor,
+  SprintsModule: () => SprintsModule,
+  SprintPlanner: () => SprintPlanner,
+  PromptBuilder: () => PromptBuilder,
+  OrganizationsModule: () => OrganizationsModule,
+  LocusEvent: () => LocusEvent,
+  LocusEmitter: () => LocusEmitter,
+  LocusClient: () => LocusClient,
+  LOCUS_CONFIG: () => LOCUS_CONFIG,
+  InvitationsModule: () => InvitationsModule,
+  DocsModule: () => DocsModule,
+  DEFAULT_MODEL: () => DEFAULT_MODEL,
+  CodebaseIndexerService: () => CodebaseIndexerService,
+  CodebaseIndexer: () => CodebaseIndexer,
+  ClaudeRunner: () => ClaudeRunner,
+  CiModule: () => CiModule,
+  AuthModule: () => AuthModule,
+  ArtifactSyncer: () => ArtifactSyncer,
+  AnthropicClient: () => AnthropicClient,
+  AgentWorker: () => AgentWorker,
+  AgentOrchestrator: () => AgentOrchestrator
+});
+module.exports = __toCommonJS(exports_index_node);
+
+// src/agent/artifact-syncer.ts
+var import_node_fs = require("node:fs");
+var import_node_path2 = require("node:path");
+
+// src/core/config.ts
+var import_node_path = require("node:path");
+var DEFAULT_MODEL = "sonnet";
+var LOCUS_CONFIG = {
+  dir: ".locus",
+  configFile: "config.json",
+  indexFile: "codebase-index.json",
+  contextFile: "CLAUDE.md",
+  artifactsDir: "artifacts"
+};
+function getLocusPath(projectPath, fileName) {
+  if (fileName === "contextFile") {
+    return import_node_path.join(projectPath, LOCUS_CONFIG.contextFile);
+  }
+  return import_node_path.join(projectPath, LOCUS_CONFIG.dir, LOCUS_CONFIG[fileName]);
+}
+
+// src/agent/artifact-syncer.ts
+class ArtifactSyncer {
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  async getOrCreateArtifactsGroup() {
+    try {
+      const groups = await this.deps.client.docs.listGroups(this.deps.workspaceId);
+      const artifactsGroup = groups.find((g) => g.name === "Artifacts");
+      if (artifactsGroup) {
+        return artifactsGroup.id;
+      }
+      const newGroup = await this.deps.client.docs.createGroup(this.deps.workspaceId, {
+        name: "Artifacts",
+        order: 999
+      });
+      this.deps.log("Created 'Artifacts' group for agent-generated docs", "info");
+      return newGroup.id;
+    } catch (error) {
+      this.deps.log(`Failed to get/create Artifacts group: ${error}`, "error");
+      throw error;
+    }
+  }
+  async sync() {
+    const artifactsDir = getLocusPath(this.deps.projectPath, "artifactsDir");
+    if (!import_node_fs.existsSync(artifactsDir)) {
+      import_node_fs.mkdirSync(artifactsDir, { recursive: true });
+      return;
+    }
+    try {
+      const files = import_node_fs.readdirSync(artifactsDir);
+      if (files.length === 0)
+        return;
+      this.deps.log(`Syncing ${files.length} artifacts to server...`, "info");
+      const artifactsGroupId = await this.getOrCreateArtifactsGroup();
+      const existingDocs = await this.deps.client.docs.list(this.deps.workspaceId);
+      for (const file of files) {
+        const filePath = import_node_path2.join(artifactsDir, file);
+        if (import_node_fs.statSync(filePath).isFile()) {
+          const content = import_node_fs.readFileSync(filePath, "utf-8");
+          const title = file.replace(/\.md$/, "").trim();
+          if (!title)
+            continue;
+          const existing = existingDocs.find((d) => d.title === title);
+          if (existing) {
+            if (existing.content !== content || existing.groupId !== artifactsGroupId) {
+              await this.deps.client.docs.update(existing.id, this.deps.workspaceId, { content, groupId: artifactsGroupId });
+              this.deps.log(`Updated artifact: ${file}`, "success");
+            }
+          } else {
+            await this.deps.client.docs.create(this.deps.workspaceId, {
+              title,
+              content,
+              groupId: artifactsGroupId
+            });
+            this.deps.log(`Created artifact: ${file}`, "success");
+          }
+        }
+      }
+    } catch (error) {
+      this.deps.log(`Failed to sync artifacts: ${error}`, "error");
+    }
+  }
+}
+// src/core/indexer.ts
+var import_node_fs2 = require("node:fs");
+var import_node_path3 = require("node:path");
+var import_globby = require("globby");
+
+class CodebaseIndexer {
+  projectPath;
+  indexPath;
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+    this.indexPath = import_node_path3.join(projectPath, ".locus", "codebase-index.json");
+  }
+  async index(onProgress, treeSummarizer) {
+    if (!treeSummarizer) {
+      throw new Error("A treeSummarizer is required for this indexing method.");
+    }
+    if (onProgress)
+      onProgress("Generating file tree...");
+    const gitmodulesPath = import_node_path3.join(this.projectPath, ".gitmodules");
+    const submoduleIgnores = [];
+    if (import_node_fs2.existsSync(gitmodulesPath)) {
+      try {
+        const content = import_node_fs2.readFileSync(gitmodulesPath, "utf-8");
+        const lines = content.split(`
+`);
+        for (const line of lines) {
+          const match = line.match(/^\s*path\s*=\s*(.*)$/);
+          const path = match?.[1]?.trim();
+          if (path) {
+            submoduleIgnores.push(`${path}/**`);
+            submoduleIgnores.push(`**/${path}/**`);
+          }
+        }
+      } catch {}
+    }
+    const files = await import_globby.globby(["**/*"], {
+      cwd: this.projectPath,
+      gitignore: true,
+      ignore: [
+        ...submoduleIgnores,
+        "**/node_modules/**",
+        "**/dist/**",
+        "**/build/**",
+        "**/target/**",
+        "**/bin/**",
+        "**/obj/**",
+        "**/.next/**",
+        "**/.svelte-kit/**",
+        "**/.nuxt/**",
+        "**/.cache/**",
+        "**/out/**",
+        "**/__tests__/**",
+        "**/coverage/**",
+        "**/*.test.*",
+        "**/*.spec.*",
+        "**/*.d.ts",
+        "**/tsconfig.tsbuildinfo",
+        "**/.locus/*.json",
+        "**/.locus/*.md",
+        "**/.locus/!(artifacts)/**",
+        "**/.git/**",
+        "**/.svn/**",
+        "**/.hg/**",
+        "**/.vscode/**",
+        "**/.idea/**",
+        "**/.DS_Store",
+        "**/bun.lock",
+        "**/package-lock.json",
+        "**/yarn.lock",
+        "**/pnpm-lock.yaml",
+        "**/Cargo.lock",
+        "**/go.sum",
+        "**/poetry.lock",
+        "**/*.{png,jpg,jpeg,gif,svg,ico,mp4,webm,wav,mp3,woff,woff2,eot,ttf,otf,pdf,zip,tar.gz,rar}"
+      ]
+    });
+    const treeString = files.join(`
+`);
+    if (onProgress)
+      onProgress("AI is analyzing codebase structure...");
+    const index = await treeSummarizer(treeString);
+    index.lastIndexed = new Date().toISOString();
+    return index;
+  }
+  loadIndex() {
+    if (import_node_fs2.existsSync(this.indexPath)) {
+      try {
+        return JSON.parse(import_node_fs2.readFileSync(this.indexPath, "utf-8"));
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  saveIndex(index) {
+    const dir = import_node_path3.dirname(this.indexPath);
+    if (!import_node_fs2.existsSync(dir)) {
+      import_node_fs2.mkdirSync(dir, { recursive: true });
+    }
+    import_node_fs2.writeFileSync(this.indexPath, JSON.stringify(index, null, 2));
+  }
+}
+
+// src/agent/codebase-indexer-service.ts
+class CodebaseIndexerService {
+  deps;
+  indexer;
+  constructor(deps) {
+    this.deps = deps;
+    this.indexer = new CodebaseIndexer(deps.projectPath);
+  }
+  async reindex() {
+    try {
+      this.deps.log("Reindexing codebase...", "info");
+      const index = await this.indexer.index((msg) => this.deps.log(msg, "info"), async (tree) => {
+        const prompt = `You are a codebase analysis expert. Analyze the file tree and extract:
+1. Key symbols (classes, functions, types) and their locations
+2. Responsibilities of each directory/file
+3. Overall project structure
+
+Analyze this file tree and provide a JSON response with:
+- "symbols": object mapping symbol names to file paths (array)
+- "responsibilities": object mapping paths to brief descriptions
+
+File tree:
+${tree}
+
+Return ONLY valid JSON, no markdown formatting.`;
+        let response;
+        if (this.deps.anthropicClient) {
+          response = await this.deps.anthropicClient.run({
+            systemPrompt: "You are a codebase analysis expert specialized in extracting structure and symbols from file trees.",
+            userPrompt: prompt
+          });
+        } else {
+          response = await this.deps.claudeRunner.run(prompt, true);
+        }
+        const jsonMatch = response.match(/\{[\s\S]*\}/);
+        if (jsonMatch) {
+          return JSON.parse(jsonMatch[0]);
+        }
+        return { symbols: {}, responsibilities: {}, lastIndexed: "" };
+      });
+      this.indexer.saveIndex(index);
+      this.deps.log("Codebase reindexed successfully", "success");
+    } catch (error) {
+      this.deps.log(`Failed to reindex codebase: ${error}`, "error");
+    }
+  }
+}
+// src/agent/sprint-planner.ts
+class SprintPlanner {
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  async planSprint(sprint, tasks2) {
+    this.deps.log(`Planning sprint: ${sprint.name}`, "info");
+    try {
+      const taskList = tasks2.map((t) => `- [${t.id}] ${t.title}: ${t.description || "No description"}`).join(`
+`);
+      let plan;
+      if (this.deps.anthropicClient) {
+        const systemPrompt = `You are an expert project manager and lead engineer specialized in sprint planning and task prioritization.`;
+        const userPrompt = `# Sprint Planning: ${sprint.name}
+
+## Tasks
+${taskList}
+
+## Instructions
+1. Analyze dependencies between these tasks.
+2. Prioritize them for the most efficient execution.
+3. Create a mindmap (in Markdown or Mermaid format) that visualizes the sprint structure.
+4. Output your final plan. The plan should clearly state the order of execution.
+
+**IMPORTANT**: 
+- Do NOT create any files on the filesystem during this planning phase. 
+- Avoid using absolute local paths (e.g., /Users/...) in your output. Use relative paths starting from the project root if necessary.
+- Your output will be saved as the official sprint mindmap on the server.`;
+        plan = await this.deps.anthropicClient.run({
+          systemPrompt,
+          userPrompt
+        });
+      } else {
+        const planningPrompt = `# Sprint Planning: ${sprint.name}
+
+You are an expert project manager and lead engineer. You need to create a mindmap and execution plan for the following tasks in this sprint.
+
+## Tasks
+${taskList}
+
+## Instructions
+1. Analyze dependencies between these tasks.
+2. Prioritize them for the most efficient execution.
+3. Create a mindmap (in Markdown or Mermaid format) that visualizes the sprint structure.
+4. Output your final plan. The plan should clearly state the order of execution.
+
+**IMPORTANT**: 
+- Do NOT create any files on the filesystem during this planning phase. 
+- Avoid using absolute local paths (e.g., /Users/...) in your output. Use relative paths starting from the project root if necessary.
+- Your output will be saved as the official sprint mindmap on the server.`;
+        plan = await this.deps.claudeRunner.run(planningPrompt, true);
+      }
+      this.deps.log("Sprint mindmap generated and posted to server.", "success");
+      return plan;
+    } catch (error) {
+      this.deps.log(`Sprint planning failed: ${error}`, "error");
+      return sprint.mindmap || "";
+    }
+  }
+}
+// src/core/prompt-builder.ts
+var import_node_fs3 = require("node:fs");
+var import_shared2 = require("@locusai/shared");
+class PromptBuilder {
+  projectPath;
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+  }
+  async build(task) {
+    let prompt = `# Task: ${task.title}
+
+`;
+    const roleText = this.roleToText(task.assigneeRole);
+    if (roleText) {
+      prompt += `## Role
+You are acting as a ${roleText}.
+
+`;
+    }
+    prompt += `## Description
+${task.description || "No description provided."}
+
+`;
+    const contextPath = getLocusPath(this.projectPath, "contextFile");
+    if (import_node_fs3.existsSync(contextPath)) {
+      try {
+        const context = import_node_fs3.readFileSync(contextPath, "utf-8");
+        prompt += `## Project Context (from CLAUDE.md)
+${context}
+
+`;
+      } catch (err) {
+        console.warn(`Warning: Could not read context file: ${err}`);
+      }
+    }
+    const indexPath = getLocusPath(this.projectPath, "indexFile");
+    if (import_node_fs3.existsSync(indexPath)) {
+      prompt += `## Codebase Overview
+There is an index file in the .locus/codebase-index.json and if you need you can check it.
+
+`;
+    }
+    if (task.docs && task.docs.length > 0) {
+      prompt += `## Attached Documents
+`;
+      for (const doc of task.docs) {
+        prompt += `### ${doc.title}
+${doc.content || "(No content)"}
+
+`;
+      }
+    }
+    if (task.acceptanceChecklist && task.acceptanceChecklist.length > 0) {
+      prompt += `## Acceptance Criteria
+`;
+      for (const item of task.acceptanceChecklist) {
+        prompt += `- ${item.done ? "[x]" : "[ ]"} ${item.text}
+`;
+      }
+      prompt += `
+`;
+    }
+    if (task.comments && task.comments.length > 0) {
+      const comments = task.comments.slice(0, 5);
+      prompt += `## Task History & Feedback
+`;
+      prompt += `Review the following comments for context or rejection feedback:
+
+`;
+      for (const comment of comments) {
+        const date = new Date(comment.createdAt).toLocaleString();
+        prompt += `### ${comment.author} (${date})
+${comment.text}
+
+`;
+      }
+    }
+    prompt += `## Instructions
+1. Complete this task. 
+2. **Artifact Management**: If you create any high-level documentation (PRDs, technical drafts, architecture docs), you MUST save them in \`.locus/artifacts/\`. Do NOT create them in the root directory.
+3. **Paths**: Use relative paths from the project root at all times. Do NOT use absolute local paths (e.g., /Users/...).
+4. When finished successfully, output: <promise>COMPLETE</promise>
+`;
+    return prompt;
+  }
+  roleToText(role) {
+    if (!role) {
+      return null;
+    }
+    switch (role) {
+      case import_shared2.AssigneeRole.BACKEND:
+        return "Backend Engineer";
+      case import_shared2.AssigneeRole.FRONTEND:
+        return "Frontend Engineer";
+      case import_shared2.AssigneeRole.PM:
+        return "Product Manager";
+      case import_shared2.AssigneeRole.QA:
+        return "QA Engineer";
+      case import_shared2.AssigneeRole.DESIGN:
+        return "Product Designer";
+      default:
+        return "engineer";
+    }
+  }
+}
+
+// src/agent/task-executor.ts
+class TaskExecutor {
+  deps;
+  promptBuilder;
+  constructor(deps) {
+    this.deps = deps;
+    this.promptBuilder = new PromptBuilder(deps.projectPath);
+  }
+  updateSprintPlan(sprintPlan) {
+    this.deps.sprintPlan = sprintPlan;
+  }
+  async execute(task) {
+    this.deps.log(`Executing: ${task.title}`, "info");
+    let basePrompt = await this.promptBuilder.build(task);
+    if (this.deps.sprintPlan) {
+      basePrompt = `## Sprint Context
+${this.deps.sprintPlan}
+
+${basePrompt}`;
+    }
+    try {
+      let plan = "";
+      if (this.deps.anthropicClient) {
+        this.deps.log("Phase 1: Planning (Anthropic SDK)...", "info");
+        const cacheableContext = [basePrompt];
+        plan = await this.deps.anthropicClient.run({
+          systemPrompt: "You are an expert software engineer. Analyze the task carefully and create a detailed implementation plan.",
+          cacheableContext,
+          userPrompt: `## Phase 1: Planning
+Analyze and create a detailed plan for THIS SPECIFIC TASK. Do NOT execute changes yet.`
+        });
+      } else {
+        this.deps.log("Skipping Phase 1: Planning (No Anthropic API Key)...", "info");
+      }
+      this.deps.log("Starting Execution...", "info");
+      let executionPrompt = basePrompt;
+      if (plan) {
+        executionPrompt += `
+
+## Phase 2: Execution
+Based on the plan, execute the task:
+
+${plan}`;
+      } else {
+        executionPrompt += `
+
+## Execution
+Execute the task directly.`;
+      }
+      executionPrompt += `
+
+When finished, output: <promise>COMPLETE</promise>`;
+      const output = await this.deps.claudeRunner.run(executionPrompt);
+      const success = output.includes("<promise>COMPLETE</promise>");
+      return {
+        success,
+        summary: success ? "Task completed by Claude" : "Claude did not signal completion"
+      };
+    } catch (error) {
+      return { success: false, summary: `Error: ${error}` };
+    }
+  }
+}
+// src/ai/anthropic-client.ts
+var import_sdk = __toESM(require("@anthropic-ai/sdk"));
+class AnthropicClient {
+  client;
+  model;
+  constructor(config) {
+    this.client = new import_sdk.default({
+      apiKey: config.apiKey
+    });
+    this.model = config.model || DEFAULT_MODEL;
+  }
+  async run(options) {
+    const { systemPrompt, cacheableContext = [], userPrompt } = options;
+    const systemContent = [];
+    if (systemPrompt) {
+      systemContent.push({
+        type: "text",
+        text: systemPrompt
+      });
+    }
+    for (let i = 0;i < cacheableContext.length; i++) {
+      const isLast = i === cacheableContext.length - 1;
+      systemContent.push({
+        type: "text",
+        text: cacheableContext[i],
+        ...isLast && {
+          cache_control: { type: "ephemeral" }
+        }
+      });
+    }
+    const response = await this.client.messages.create({
+      model: this.model,
+      max_tokens: 8000,
+      system: systemContent,
+      messages: [
+        {
+          role: "user",
+          content: userPrompt
+        }
+      ]
+    });
+    const textBlocks = response.content.filter((block) => block.type === "text");
+    return textBlocks.map((block) => block.text).join(`
+`);
+  }
+  async runSimple(prompt) {
+    return this.run({
+      userPrompt: prompt
+    });
+  }
+}
+
+// src/ai/claude-runner.ts
+var import_node_child_process = require("node:child_process");
+class ClaudeRunner {
+  projectPath;
+  model;
+  constructor(projectPath, model = DEFAULT_MODEL) {
+    this.projectPath = projectPath;
+    this.model = model;
+  }
+  async run(prompt, _isPlanning = false) {
+    const maxRetries = 3;
+    let lastError = null;
+    for (let attempt = 1;attempt <= maxRetries; attempt++) {
+      try {
+        return await this.executeRun(prompt);
+      } catch (error) {
+        const err = error;
+        lastError = err;
+        const isLastAttempt = attempt === maxRetries;
+        if (!isLastAttempt) {
+          const delay = Math.pow(2, attempt) * 1000;
+          console.warn(`Claude CLI attempt ${attempt} failed: ${err.message}. Retrying in ${delay}ms...`);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+      }
+    }
+    throw lastError || new Error("Claude CLI failed after multiple attempts");
+  }
+  executeRun(prompt) {
+    return new Promise((resolve, reject) => {
+      const args = [
+        "--dangerously-skip-permissions",
+        "--print",
+        "--model",
+        this.model
+      ];
+      const claude = import_node_child_process.spawn("claude", args, {
+        cwd: this.projectPath,
+        stdio: ["pipe", "pipe", "pipe"],
+        env: process.env,
+        shell: true
+      });
+      let output = "";
+      let errorOutput = "";
+      claude.stdout.on("data", (data) => {
+        output += data.toString();
+      });
+      claude.stderr.on("data", (data) => {
+        errorOutput += data.toString();
+      });
+      claude.on("error", (err) => reject(new Error(`Failed to start Claude CLI (shell: true): ${err.message}. Please ensure the 'claude' command is available in your PATH.`)));
+      claude.on("close", (code) => {
+        if (code === 0)
+          resolve(output);
+        else {
+          const detail = errorOutput.trim();
+          const message = detail ? `Claude CLI error (exit code ${code}): ${detail}` : `Claude CLI exited with code ${code}. Please ensure the Claude CLI is installed and you are logged in (run 'claude' manually to check).`;
+          reject(new Error(message));
+        }
+      });
+      claude.stdin.write(prompt);
+      claude.stdin.end();
+    });
+  }
+}
+
+// src/utils/colors.ts
+var ESC = "\x1B[";
+var RESET = `${ESC}0m`;
+var colors = {
+  reset: RESET,
+  bold: `${ESC}1m`,
+  dim: `${ESC}2m`,
+  italic: `${ESC}3m`,
+  underline: `${ESC}4m`,
+  black: `${ESC}30m`,
+  red: `${ESC}31m`,
+  green: `${ESC}32m`,
+  yellow: `${ESC}33m`,
+  blue: `${ESC}34m`,
+  magenta: `${ESC}35m`,
+  cyan: `${ESC}36m`,
+  white: `${ESC}37m`,
+  gray: `${ESC}90m`,
+  brightRed: `${ESC}91m`,
+  brightGreen: `${ESC}92m`,
+  brightYellow: `${ESC}93m`,
+  brightBlue: `${ESC}94m`,
+  brightMagenta: `${ESC}95m`,
+  brightCyan: `${ESC}96m`,
+  brightWhite: `${ESC}97m`
+};
+var c = {
+  text: (text, ...colorNames) => {
+    const codes = colorNames.map((name) => colors[name]).join("");
+    return `${codes}${text}${RESET}`;
+  },
+  bold: (t) => c.text(t, "bold"),
+  dim: (t) => c.text(t, "dim"),
+  red: (t) => c.text(t, "red"),
+  green: (t) => c.text(t, "green"),
+  yellow: (t) => c.text(t, "yellow"),
+  blue: (t) => c.text(t, "blue"),
+  magenta: (t) => c.text(t, "magenta"),
+  cyan: (t) => c.text(t, "cyan"),
+  gray: (t) => c.text(t, "gray"),
+  success: (t) => c.text(t, "green", "bold"),
+  error: (t) => c.text(t, "red", "bold"),
+  warning: (t) => c.text(t, "yellow", "bold"),
+  info: (t) => c.text(t, "cyan", "bold"),
+  primary: (t) => c.text(t, "blue", "bold"),
+  underline: (t) => c.text(t, "underline")
+};
+
+// src/agent/worker.ts
+class AgentWorker {
+  config;
+  client;
+  claudeRunner;
+  anthropicClient;
+  sprintPlanner;
+  indexerService;
+  artifactSyncer;
+  taskExecutor;
+  consecutiveEmpty = 0;
+  maxEmpty = 10;
+  maxTasks = 50;
+  tasksCompleted = 0;
+  pollInterval = 1e4;
+  sprintPlan = null;
+  constructor(config) {
+    this.config = config;
+    const projectPath = config.projectPath || process.cwd();
+    this.client = new LocusClient({
+      baseUrl: config.apiBase,
+      token: config.apiKey,
+      retryOptions: {
+        maxRetries: 3,
+        initialDelay: 1000,
+        maxDelay: 5000,
+        factor: 2
+      }
+    });
+    this.claudeRunner = new ClaudeRunner(projectPath, config.model);
+    this.anthropicClient = config.anthropicApiKey ? new AnthropicClient({
+      apiKey: config.anthropicApiKey,
+      model: config.model
+    }) : null;
+    const logFn = this.log.bind(this);
+    this.sprintPlanner = new SprintPlanner({
+      anthropicClient: this.anthropicClient,
+      claudeRunner: this.claudeRunner,
+      log: logFn
+    });
+    this.indexerService = new CodebaseIndexerService({
+      anthropicClient: this.anthropicClient,
+      claudeRunner: this.claudeRunner,
+      projectPath,
+      log: logFn
+    });
+    this.artifactSyncer = new ArtifactSyncer({
+      client: this.client,
+      workspaceId: config.workspaceId,
+      projectPath,
+      log: logFn
+    });
+    this.taskExecutor = new TaskExecutor({
+      anthropicClient: this.anthropicClient,
+      claudeRunner: this.claudeRunner,
+      projectPath,
+      sprintPlan: null,
+      log: logFn
+    });
+    if (this.anthropicClient) {
+      this.log("Using Anthropic SDK with prompt caching for planning phases", "info");
+    } else {
+      this.log("Using Claude CLI for all phases (no Anthropic API key provided)", "info");
+    }
+  }
+  log(message, level = "info") {
+    const timestamp = new Date().toISOString().split("T")[1]?.slice(0, 8) ?? "";
+    const colorFn = {
+      info: c.cyan,
+      success: c.green,
+      warn: c.yellow,
+      error: c.red
+    }[level];
+    const prefix = { info: "ℹ", success: "✓", warn: "⚠", error: "✗" }[level];
+    console.log(`${c.dim(`[${timestamp}]`)} ${c.bold(`[${this.config.agentId.slice(-8)}]`)} ${colorFn(`${prefix} ${message}`)}`);
+  }
+  async getActiveSprint() {
+    try {
+      if (this.config.sprintId) {
+        return await this.client.sprints.getById(this.config.sprintId, this.config.workspaceId);
+      }
+      return await this.client.sprints.getActive(this.config.workspaceId);
+    } catch (_error) {
+      return null;
+    }
+  }
+  async getNextTask() {
+    try {
+      const task = await this.client.workspaces.dispatch(this.config.workspaceId, this.config.agentId, this.config.sprintId);
+      return task;
+    } catch (error) {
+      this.log(`No task dispatched: ${error instanceof Error ? error.message : String(error)}`, "info");
+      return null;
+    }
+  }
+  async executeTask(task) {
+    const fullTask = await this.client.tasks.getById(task.id, this.config.workspaceId);
+    this.taskExecutor.updateSprintPlan(this.sprintPlan);
+    const result = await this.taskExecutor.execute(fullTask);
+    await this.indexerService.reindex();
+    return result;
+  }
+  async run() {
+    this.log(`Agent started in ${this.config.projectPath || process.cwd()}`, "success");
+    const sprint = await this.getActiveSprint();
+    if (sprint) {
+      this.log(`Found active sprint: ${sprint.name} (${sprint.id})`, "info");
+      const tasks2 = await this.client.tasks.list(this.config.workspaceId, {
+        sprintId: sprint.id
+      });
+      this.log(`Sprint tasks found: ${tasks2.length}`, "info");
+      const latestTaskCreation = tasks2.reduce((latest, task) => {
+        const taskDate = new Date(task.createdAt);
+        return taskDate > latest ? taskDate : latest;
+      }, new Date(0));
+      const mindmapDate = sprint.mindmapUpdatedAt ? new Date(sprint.mindmapUpdatedAt) : new Date(0);
+      if (tasks2.length <= 1) {
+        this.log("Skipping mindmap generation (only one task in sprint).", "info");
+        this.sprintPlan = null;
+      } else {
+        const needsPlanning = !sprint.mindmap || sprint.mindmap.trim() === "" || latestTaskCreation > mindmapDate;
+        if (needsPlanning) {
+          if (sprint.mindmap && latestTaskCreation > mindmapDate) {
+            this.log("New tasks have been added to the sprint since last mindmap. Regenerating...", "warn");
+          }
+          this.sprintPlan = await this.sprintPlanner.planSprint(sprint, tasks2);
+          await this.client.sprints.update(sprint.id, this.config.workspaceId, {
+            mindmap: this.sprintPlan,
+            mindmapUpdatedAt: new Date
+          });
+        } else {
+          this.log("Using existing sprint mindmap.", "info");
+          this.sprintPlan = sprint.mindmap ?? null;
+        }
+      }
+    } else {
+      this.log("No active sprint found for planning.", "warn");
+    }
+    while (this.tasksCompleted < this.maxTasks && this.consecutiveEmpty < this.maxEmpty) {
+      const task = await this.getNextTask();
+      if (!task) {
+        this.consecutiveEmpty++;
+        if (this.consecutiveEmpty >= this.maxEmpty)
+          break;
+        await new Promise((r) => setTimeout(r, this.pollInterval));
+        continue;
+      }
+      this.consecutiveEmpty = 0;
+      this.log(`Claimed: ${task.title}`, "success");
+      const result = await this.executeTask(task);
+      await this.artifactSyncer.sync();
+      if (result.success) {
+        await this.client.tasks.update(task.id, this.config.workspaceId, {
+          status: "VERIFICATION"
+        });
+        await this.client.tasks.addComment(task.id, this.config.workspaceId, {
+          author: this.config.agentId,
+          text: `✅ ${result.summary}`
+        });
+        this.tasksCompleted++;
+      } else {
+        await this.client.tasks.update(task.id, this.config.workspaceId, {
+          status: "BACKLOG",
+          assignedTo: null
+        });
+        await this.client.tasks.addComment(task.id, this.config.workspaceId, {
+          author: this.config.agentId,
+          text: `❌ ${result.summary}`
+        });
+      }
+    }
+    process.exit(0);
+  }
+}
+if (process.argv[1]?.includes("agent-worker") || process.argv[1]?.includes("worker")) {
+  const args = process.argv.slice(2);
+  const config = {};
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--agent-id")
+      config.agentId = args[++i];
+    else if (arg === "--workspace-id")
+      config.workspaceId = args[++i];
+    else if (arg === "--sprint-id")
+      config.sprintId = args[++i];
+    else if (arg === "--api-base")
+      config.apiBase = args[++i];
+    else if (arg === "--api-key")
+      config.apiKey = args[++i];
+    else if (arg === "--anthropic-api-key")
+      config.anthropicApiKey = args[++i];
+    else if (arg === "--project-path")
+      config.projectPath = args[++i];
+    else if (arg === "--model")
+      config.model = args[++i];
+  }
+  if (!config.agentId || !config.workspaceId || !config.apiBase || !config.apiKey || !config.projectPath) {
+    console.error("Missing required arguments");
+    process.exit(1);
+  }
+  const worker = new AgentWorker(config);
+  worker.run().catch((err) => {
+    console.error("Fatal worker error:", err);
+    process.exit(1);
+  });
+}
+// src/orchestrator.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_fs4 = require("node:fs");
+var import_node_path4 = require("node:path");
+var import_shared3 = require("@locusai/shared");
+var import_events3 = require("events");
+var __dirname = "/home/runner/work/locusai/locusai/packages/sdk/src";
+
+class AgentOrchestrator extends import_events3.EventEmitter {
+  client;
+  config;
+  agents = new Map;
+  isRunning = false;
+  processedTasks = new Set;
+  resolvedSprintId = null;
+  constructor(config) {
+    super();
+    this.config = config;
+    this.client = new LocusClient({
+      baseUrl: config.apiBase,
+      token: config.apiKey
+    });
+  }
+  async resolveSprintId() {
+    if (this.config.sprintId) {
+      return this.config.sprintId;
+    }
+    try {
+      const sprint = await this.client.sprints.getActive(this.config.workspaceId);
+      if (sprint?.id) {
+        console.log(c.info(`\uD83D\uDCCB Using active sprint: ${sprint.name}`));
+        return sprint.id;
+      }
+    } catch {}
+    console.log(c.dim("ℹ  No sprint specified, working with all workspace tasks"));
+    return "";
+  }
+  async start() {
+    if (this.isRunning) {
+      throw new Error("Orchestrator is already running");
+    }
+    this.isRunning = true;
+    this.processedTasks.clear();
+    try {
+      await this.orchestrationLoop();
+    } catch (error) {
+      this.emit("error", error);
+      throw error;
+    } finally {
+      await this.cleanup();
+    }
+  }
+  async orchestrationLoop() {
+    this.resolvedSprintId = await this.resolveSprintId();
+    this.emit("started", {
+      timestamp: new Date,
+      config: this.config,
+      sprintId: this.resolvedSprintId
+    });
+    console.log(`
+${c.primary("\uD83E\uDD16 Locus Agent Orchestrator")}`);
+    console.log(c.dim("----------------------------------------------"));
+    console.log(`${c.bold("Workspace:")} ${this.config.workspaceId}`);
+    if (this.resolvedSprintId) {
+      console.log(`${c.bold("Sprint:")} ${this.resolvedSprintId}`);
+    }
+    console.log(`${c.bold("API Base:")} ${this.config.apiBase}`);
+    console.log(c.dim(`----------------------------------------------
+`));
+    const tasks2 = await this.getAvailableTasks();
+    if (tasks2.length === 0) {
+      console.log(c.dim("ℹ  No available tasks found in the backlog."));
+      return;
+    }
+    await this.spawnAgent();
+    while (this.agents.size > 0 && this.isRunning) {
+      await this.reapAgents();
+      if (this.agents.size === 0) {
+        break;
+      }
+      await this.sleep(2000);
+    }
+    console.log(`
+${c.success("✅ Orchestrator finished")}`);
+  }
+  findPackageRoot(startPath) {
+    let currentDir = startPath;
+    while (currentDir !== "/") {
+      if (import_node_fs4.existsSync(import_node_path4.join(currentDir, "package.json"))) {
+        return currentDir;
+      }
+      currentDir = import_node_path4.dirname(currentDir);
+    }
+    return startPath;
+  }
+  async spawnAgent() {
+    const agentId = `agent-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    const agentState = {
+      id: agentId,
+      status: "IDLE",
+      currentTaskId: null,
+      tasksCompleted: 0,
+      tasksFailed: 0,
+      lastHeartbeat: new Date
+    };
+    this.agents.set(agentId, agentState);
+    console.log(`${c.primary("\uD83D\uDE80 Agent started:")} ${c.bold(agentId)}
+`);
+    const potentialPaths = [];
+    try {
+      const sdkIndexPath = require.resolve("@locusai/sdk");
+      const sdkDir = import_node_path4.dirname(sdkIndexPath);
+      const sdkRoot = this.findPackageRoot(sdkDir);
+      potentialPaths.push(import_node_path4.join(sdkRoot, "dist", "agent", "worker.js"), import_node_path4.join(sdkRoot, "src", "agent", "worker.ts"));
+    } catch {}
+    const packageRoot = this.findPackageRoot(__dirname);
+    potentialPaths.push(import_node_path4.join(packageRoot, "dist", "agent", "worker.js"), import_node_path4.join(packageRoot, "src", "agent", "worker.ts"), import_node_path4.join(__dirname, "agent", "worker.ts"), import_node_path4.join(__dirname, "agent", "worker.js"));
+    const workerPath = potentialPaths.find((p) => import_node_fs4.existsSync(p));
+    if (!workerPath) {
+      throw new Error(`Worker file not found. Checked: ${potentialPaths.join(", ")}. ` + `Make sure the SDK is properly built and installed.`);
+    }
+    const workerArgs = [
+      "--agent-id",
+      agentId,
+      "--workspace-id",
+      this.config.workspaceId,
+      "--api-base",
+      this.config.apiBase,
+      "--api-key",
+      this.config.apiKey,
+      "--project-path",
+      this.config.projectPath
+    ];
+    if (this.config.anthropicApiKey) {
+      workerArgs.push("--anthropic-api-key", this.config.anthropicApiKey);
+    }
+    if (this.config.model) {
+      workerArgs.push("--model", this.config.model);
+    }
+    if (this.resolvedSprintId) {
+      workerArgs.push("--sprint-id", this.resolvedSprintId);
+    }
+    const agentProcess = import_node_child_process2.spawn(process.execPath, [workerPath, ...workerArgs]);
+    agentState.process = agentProcess;
+    agentProcess.on("message", (msg) => {
+      if (msg.type === "stats") {
+        agentState.tasksCompleted = msg.tasksCompleted || 0;
+        agentState.tasksFailed = msg.tasksFailed || 0;
+      }
+    });
+    agentProcess.stdout?.on("data", (data) => {
+      process.stdout.write(data.toString());
+    });
+    agentProcess.stderr?.on("data", (data) => {
+      process.stderr.write(`[${agentId}] ERR: ${data.toString()}`);
+    });
+    agentProcess.on("exit", (code) => {
+      console.log(`
+${agentId} finished (exit code: ${code})`);
+      const agent = this.agents.get(agentId);
+      if (agent) {
+        agent.status = code === 0 ? "COMPLETED" : "FAILED";
+        this.emit("agent:completed", {
+          agentId,
+          status: agent.status,
+          tasksCompleted: agent.tasksCompleted,
+          tasksFailed: agent.tasksFailed
+        });
+        this.agents.delete(agentId);
+      }
+    });
+    this.emit("agent:spawned", { agentId });
+  }
+  async reapAgents() {}
+  async getAvailableTasks() {
+    try {
+      const tasks2 = await this.client.tasks.getAvailable(this.config.workspaceId, this.resolvedSprintId || undefined);
+      return tasks2.filter((task) => !this.processedTasks.has(task.id));
+    } catch (error) {
+      this.emit("error", error);
+      return [];
+    }
+  }
+  async assignTaskToAgent(agentId) {
+    const agent = this.agents.get(agentId);
+    if (!agent)
+      return null;
+    try {
+      const tasks2 = await this.getAvailableTasks();
+      const priorityOrder = [
+        import_shared3.TaskPriority.CRITICAL,
+        import_shared3.TaskPriority.HIGH,
+        import_shared3.TaskPriority.MEDIUM,
+        import_shared3.TaskPriority.LOW
+      ];
+      let task = tasks2.sort((a, b) => priorityOrder.indexOf(a.priority) - priorityOrder.indexOf(b.priority))[0];
+      if (!task && tasks2.length > 0) {
+        task = tasks2[0];
+      }
+      if (!task)
+        return null;
+      agent.currentTaskId = task.id;
+      agent.status = "WORKING";
+      this.emit("task:assigned", {
+        agentId,
+        taskId: task.id,
+        title: task.title
+      });
+      return task;
+    } catch (error) {
+      this.emit("error", error);
+      return null;
+    }
+  }
+  async completeTask(taskId, agentId, summary) {
+    try {
+      await this.client.tasks.update(taskId, this.config.workspaceId, {
+        status: import_shared3.TaskStatus.VERIFICATION
+      });
+      if (summary) {
+        await this.client.tasks.addComment(taskId, this.config.workspaceId, {
+          author: agentId,
+          text: `✅ Task completed
+
+${summary}`
+        });
+      }
+      this.processedTasks.add(taskId);
+      const agent = this.agents.get(agentId);
+      if (agent) {
+        agent.tasksCompleted += 1;
+        agent.currentTaskId = null;
+        agent.status = "IDLE";
+      }
+      this.emit("task:completed", { agentId, taskId });
+    } catch (error) {
+      this.emit("error", error);
+    }
+  }
+  async failTask(taskId, agentId, error) {
+    try {
+      await this.client.tasks.update(taskId, this.config.workspaceId, {
+        status: import_shared3.TaskStatus.BACKLOG,
+        assignedTo: null
+      });
+      await this.client.tasks.addComment(taskId, this.config.workspaceId, {
+        author: agentId,
+        text: `❌ Agent failed: ${error}`
+      });
+      const agent = this.agents.get(agentId);
+      if (agent) {
+        agent.tasksFailed += 1;
+        agent.currentTaskId = null;
+        agent.status = "IDLE";
+      }
+      this.emit("task:failed", { agentId, taskId, error });
+    } catch (error2) {
+      this.emit("error", error2);
+    }
+  }
+  async stop() {
+    this.isRunning = false;
+    await this.cleanup();
+    this.emit("stopped", { timestamp: new Date });
+  }
+  async cleanup() {
+    for (const [agentId, agent] of this.agents.entries()) {
+      if (agent.process && !agent.process.killed) {
+        console.log(`Killing agent: ${agentId}`);
+        agent.process.kill();
+      }
+    }
+    this.agents.clear();
+  }
+  getStats() {
+    return {
+      activeAgents: this.agents.size,
+      processedTasks: this.processedTasks.size,
+      totalTasksCompleted: Array.from(this.agents.values()).reduce((sum, agent) => sum + agent.tasksCompleted, 0),
+      totalTasksFailed: Array.from(this.agents.values()).reduce((sum, agent) => sum + agent.tasksFailed, 0)
+    };
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}