@locusai/sdk 0.9.18 → 0.10.2

package/dist/agent/worker.js

@@ -38,42 +38,26 @@ var __export = (target, all) => {
       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"));
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
 // 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);
-  }
-}
+var import_events, LocusEvent, LocusEmitter;
+var init_events = __esm(() => {
+  import_events = require("events");
+  ((LocusEvent2) => {
+    LocusEvent2["TOKEN_EXPIRED"] = "TOKEN_EXPIRED";
+    LocusEvent2["AUTH_ERROR"] = "AUTH_ERROR";
+    LocusEvent2["REQUEST_ERROR"] = "REQUEST_ERROR";
+  })(LocusEvent ||= {});
+  LocusEmitter = 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 {
@@ -86,304 +70,344 @@ class BaseModule {
 }
 
 // src/modules/auth.ts
-class AuthModule extends BaseModule {
-  async getProfile() {
-    const { data } = await this.api.get("/auth/me");
-    return data;
-  }
-  async getApiKeyInfo() {
-    const { data } = await this.api.get("/auth/api-key");
-    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;
-  }
-  async deleteAccount() {
-    const { data } = await this.api.delete("/auth/account");
-    return data;
-  }
-}
+var AuthModule;
+var init_auth = __esm(() => {
+  AuthModule = class AuthModule extends BaseModule {
+    async getProfile() {
+      const { data } = await this.api.get("/auth/me");
+      return data;
+    }
+    async getApiKeyInfo() {
+      const { data } = await this.api.get("/auth/api-key");
+      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;
+    }
+    async deleteAccount() {
+      const { data } = await this.api.delete("/auth/account");
+      return data;
+    }
+  };
+});
 
 // src/modules/ci.ts
-class CiModule extends BaseModule {
-  async report(body) {
-    const { data } = await this.api.post("/ci/report", body);
-    return data;
-  }
-}
+var CiModule;
+var init_ci = __esm(() => {
+  CiModule = 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}`);
-  }
-}
+var DocsModule;
+var init_docs = __esm(() => {
+  DocsModule = 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}`);
-  }
-}
+var InvitationsModule;
+var init_invitations = __esm(() => {
+  InvitationsModule = 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}`);
-  }
-}
+var OrganizationsModule;
+var init_organizations = __esm(() => {
+  OrganizationsModule = 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;
-  }
-  async triggerAIPlanning(id, workspaceId) {
-    const { data } = await this.api.post(`/workspaces/${workspaceId}/sprints/${id}/trigger-ai-planning`);
-    return data.sprint;
-  }
-}
+var SprintsModule;
+var init_sprints = __esm(() => {
+  SprintsModule = 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;
+    }
+    async triggerAIPlanning(id, workspaceId) {
+      const { data } = await this.api.post(`/workspaces/${workspaceId}/sprints/${id}/trigger-ai-planning`);
+      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;
-  }
-  async batchUpdate(ids, workspaceId, updates) {
-    await this.api.patch(`/workspaces/${workspaceId}/tasks/batch`, {
-      ids,
-      updates
-    });
-  }
-}
+var import_shared, TasksModule;
+var init_tasks = __esm(() => {
+  import_shared = require("@locusai/shared");
+  TasksModule = 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;
+    }
+    async batchUpdate(ids, workspaceId, updates) {
+      await this.api.patch(`/workspaces/${workspaceId}/tasks/batch`, {
+        ids,
+        updates
+      });
+    }
+  };
+});
 
 // 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;
-  }
-  async heartbeat(workspaceId, agentId, currentTaskId, status) {
-    const { data } = await this.api.post(`/workspaces/${workspaceId}/agents/heartbeat`, {
-      agentId,
-      currentTaskId: currentTaskId ?? null,
-      status: status ?? "WORKING"
-    });
-    return data.agent;
-  }
-  async getAgents(workspaceId) {
-    const { data } = await this.api.get(`/workspaces/${workspaceId}/agents`);
-    return data.agents;
-  }
-  async listApiKeys(workspaceId) {
-    const { data } = await this.api.get(`/workspaces/${workspaceId}/api-keys`);
-    return data.apiKeys;
-  }
-  async createApiKey(workspaceId, name) {
-    const { data } = await this.api.post(`/workspaces/${workspaceId}/api-keys`, { name });
-    return data.apiKey;
-  }
-  async deleteApiKey(workspaceId, keyId) {
-    await this.api.delete(`/workspaces/${workspaceId}/api-keys/${keyId}`);
-  }
-}
+var WorkspacesModule;
+var init_workspaces = __esm(() => {
+  WorkspacesModule = 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;
+    }
+    async heartbeat(workspaceId, agentId, currentTaskId, status) {
+      const { data } = await this.api.post(`/workspaces/${workspaceId}/agents/heartbeat`, {
+        agentId,
+        currentTaskId: currentTaskId ?? null,
+        status: status ?? "WORKING"
+      });
+      return data.agent;
+    }
+    async getAgents(workspaceId) {
+      const { data } = await this.api.get(`/workspaces/${workspaceId}/agents`);
+      return data.agents;
+    }
+    async listApiKeys(workspaceId) {
+      const { data } = await this.api.get(`/workspaces/${workspaceId}/api-keys`);
+      return data.apiKeys;
+    }
+    async createApiKey(workspaceId, name) {
+      const { data } = await this.api.post(`/workspaces/${workspaceId}/api-keys`, { name });
+      return data.apiKey;
+    }
+    async deleteApiKey(workspaceId, keyId) {
+      await this.api.delete(`/workspaces/${workspaceId}/api-keys/${keyId}`);
+    }
+  };
+});
 
 // 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);
+
 class LocusClient {
   api;
   emitter;
@@ -473,70 +497,30 @@ class LocusClient {
     }
   }
 }
-
-// src/agent/worker.ts
-var exports_worker = {};
-__export(exports_worker, {
-  AgentWorker: () => AgentWorker
+var import_axios;
+var init_src = __esm(() => {
+  init_events();
+  init_auth();
+  init_ci();
+  init_docs();
+  init_invitations();
+  init_organizations();
+  init_sprints();
+  init_tasks();
+  init_workspaces();
+  import_axios = __toESM(require("axios"));
+  init_events();
+  init_auth();
+  init_ci();
+  init_docs();
+  init_invitations();
+  init_organizations();
+  init_sprints();
+  init_tasks();
+  init_workspaces();
 });
-module.exports = __toCommonJS(exports_worker);
-var import_shared3 = require("@locusai/shared");
 
 // src/core/config.ts
-var import_node_path = require("node:path");
-var PROVIDER = {
-  CLAUDE: "claude",
-  CODEX: "codex"
-};
-var DEFAULT_MODEL = {
-  [PROVIDER.CLAUDE]: "opus",
-  [PROVIDER.CODEX]: "gpt-5.3-codex"
-};
-var LOCUS_SCHEMA_BASE_URL = "https://locusai.dev/schemas";
-var LOCUS_SCHEMAS = {
-  config: `${LOCUS_SCHEMA_BASE_URL}/config.schema.json`,
-  settings: `${LOCUS_SCHEMA_BASE_URL}/settings.schema.json`
-};
-var LOCUS_CONFIG = {
-  dir: ".locus",
-  configFile: "config.json",
-  settingsFile: "settings.json",
-  indexFile: "codebase-index.json",
-  contextFile: "LOCUS.md",
-  artifactsDir: "artifacts",
-  documentsDir: "documents",
-  sessionsDir: "sessions",
-  reviewsDir: "reviews",
-  plansDir: "plans",
-  projectDir: "project",
-  projectContextFile: "context.md",
-  projectProgressFile: "progress.md"
-};
-var LOCUS_GITIGNORE_PATTERNS = [
-  "# Locus AI - Session data (user-specific, can grow large)",
-  ".locus/sessions/",
-  "",
-  "# Locus AI - Artifacts (local-only, user-specific)",
-  ".locus/artifacts/",
-  "",
-  "# Locus AI - Review reports (generated per sprint)",
-  ".locus/reviews/",
-  "",
-  "# Locus AI - Plans (generated per task)",
-  ".locus/plans/",
-  "",
-  "# Locus AI - Agent worktrees (parallel execution)",
-  ".locus-worktrees/",
-  "",
-  "# Locus AI - Settings (contains API key, telegram config, etc.)",
-  ".locus/settings.json",
-  "",
-  "# Locus AI - Configuration (contains project context, progress, etc.)",
-  ".locus/config.json",
-  "",
-  "# Locus AI - Project progress (contains project progress, etc.)",
-  ".locus/project/progress.md"
-];
 function getLocusPath(projectPath, fileName) {
   if (fileName === "projectContextFile" || fileName === "projectProgressFile") {
     return import_node_path.join(projectPath, LOCUS_CONFIG.dir, LOCUS_CONFIG.projectDir, LOCUS_CONFIG[fileName]);
@@ -547,123 +531,235 @@ function getAgentArtifactsPath(projectPath, agentId) {
   const shortId = agentId.slice(-8);
   return import_node_path.join(projectPath, LOCUS_CONFIG.dir, LOCUS_CONFIG.artifactsDir, shortId);
 }
-
-// src/ai/claude-runner.ts
-var import_node_child_process = require("node:child_process");
-var import_node_path3 = require("node:path");
+var import_node_path, PROVIDER, DEFAULT_MODEL, LOCUS_SCHEMA_BASE_URL = "https://locusai.dev/schemas", LOCUS_SCHEMAS, LOCUS_CONFIG, LOCUS_GITIGNORE_PATTERNS;
+var init_config = __esm(() => {
+  import_node_path = require("node:path");
+  PROVIDER = {
+    CLAUDE: "claude",
+    CODEX: "codex"
+  };
+  DEFAULT_MODEL = {
+    [PROVIDER.CLAUDE]: "opus",
+    [PROVIDER.CODEX]: "gpt-5.3-codex"
+  };
+  LOCUS_SCHEMAS = {
+    config: `${LOCUS_SCHEMA_BASE_URL}/config.schema.json`,
+    settings: `${LOCUS_SCHEMA_BASE_URL}/settings.schema.json`
+  };
+  LOCUS_CONFIG = {
+    dir: ".locus",
+    configFile: "config.json",
+    settingsFile: "settings.json",
+    indexFile: "codebase-index.json",
+    contextFile: "LOCUS.md",
+    artifactsDir: "artifacts",
+    documentsDir: "documents",
+    sessionsDir: "sessions",
+    reviewsDir: "reviews",
+    plansDir: "plans",
+    projectDir: "project",
+    projectContextFile: "context.md",
+    projectProgressFile: "progress.md"
+  };
+  LOCUS_GITIGNORE_PATTERNS = [
+    "# Locus AI - Session data (user-specific, can grow large)",
+    ".locus/sessions/",
+    "",
+    "# Locus AI - Artifacts (local-only, user-specific)",
+    ".locus/artifacts/",
+    "",
+    "# Locus AI - Review reports (generated per sprint)",
+    ".locus/reviews/",
+    "",
+    "# Locus AI - Plans (generated per task)",
+    ".locus/plans/",
+    "",
+    "# Locus AI - Agent worktrees (parallel execution)",
+    ".locus-worktrees/",
+    "",
+    "# Locus AI - Settings (contains API key, telegram config, etc.)",
+    ".locus/settings.json",
+    "",
+    "# Locus AI - Configuration (contains project context, progress, etc.)",
+    ".locus/config.json",
+    "",
+    "# Locus AI - Project progress (contains project progress, etc.)",
+    ".locus/project/progress.md"
+  ];
+});
 
 // 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`,
-  bgBlack: `${ESC}40m`,
-  bgRed: `${ESC}41m`,
-  bgGreen: `${ESC}42m`,
-  bgYellow: `${ESC}43m`,
-  bgBlue: `${ESC}44m`,
-  bgMagenta: `${ESC}45m`,
-  bgCyan: `${ESC}46m`,
-  bgWhite: `${ESC}47m`
-};
-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"),
-  white: (t) => c.text(t, "white"),
-  brightBlue: (t) => c.text(t, "brightBlue"),
-  bgBlue: (t) => c.text(t, "bgBlue", "white", "bold"),
-  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"),
-  secondary: (t) => c.text(t, "magenta", "bold"),
-  header: (t) => c.text(` ${t} `, "bgBlue", "white", "bold"),
-  step: (t) => c.text(` ${t} `, "bgCyan", "black", "bold"),
-  underline: (t) => c.text(t, "underline")
-};
+var ESC = "\x1B[", RESET, colors, c;
+var init_colors = __esm(() => {
+  RESET = `${ESC}0m`;
+  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`,
+    bgBlack: `${ESC}40m`,
+    bgRed: `${ESC}41m`,
+    bgGreen: `${ESC}42m`,
+    bgYellow: `${ESC}43m`,
+    bgBlue: `${ESC}44m`,
+    bgMagenta: `${ESC}45m`,
+    bgCyan: `${ESC}46m`,
+    bgWhite: `${ESC}47m`
+  };
+  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"),
+    white: (t) => c.text(t, "white"),
+    brightBlue: (t) => c.text(t, "brightBlue"),
+    bgBlue: (t) => c.text(t, "bgBlue", "white", "bold"),
+    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"),
+    secondary: (t) => c.text(t, "magenta", "bold"),
+    header: (t) => c.text(` ${t} `, "bgBlue", "white", "bold"),
+    step: (t) => c.text(` ${t} `, "bgCyan", "black", "bold"),
+    underline: (t) => c.text(t, "underline")
+  };
+});
 
 // src/utils/resolve-bin.ts
-var import_node_fs = require("node:fs");
-var import_node_os = require("node:os");
-var import_node_path2 = require("node:path");
-var EXTRA_BIN_DIRS = [
-  import_node_path2.join(import_node_os.homedir(), ".local", "bin"),
-  import_node_path2.join(import_node_os.homedir(), ".npm", "bin"),
-  import_node_path2.join(import_node_os.homedir(), ".npm-global", "bin"),
-  import_node_path2.join(import_node_os.homedir(), ".yarn", "bin"),
-  "/usr/local/bin"
-];
-function getNodeManagerDirs() {
-  const dirs = [];
+function getNvmNodeBinDir() {
   const nvmDir = process.env.NVM_DIR || import_node_path2.join(import_node_os.homedir(), ".nvm");
-  const nvmCurrent = import_node_path2.join(nvmDir, "current", "bin");
-  if (import_node_fs.existsSync(nvmCurrent)) {
-    dirs.push(nvmCurrent);
+  const versionsDir = import_node_path2.join(nvmDir, "versions", "node");
+  if (!import_node_fs.existsSync(versionsDir))
+    return null;
+  let versions;
+  try {
+    versions = import_node_fs.readdirSync(versionsDir).filter((d) => d.startsWith("v"));
+  } catch {
+    return null;
   }
-  const fnmDir = process.env.FNM_DIR || import_node_path2.join(import_node_os.homedir(), ".fnm");
-  const fnmCurrent = import_node_path2.join(fnmDir, "current", "bin");
-  if (import_node_fs.existsSync(fnmCurrent)) {
-    dirs.push(fnmCurrent);
+  if (versions.length === 0)
+    return null;
+  const currentNodeVersion = `v${process.versions.node}`;
+  const currentBin = import_node_path2.join(versionsDir, currentNodeVersion, "bin");
+  if (versions.includes(currentNodeVersion) && import_node_fs.existsSync(currentBin)) {
+    return currentBin;
+  }
+  const aliasPath = import_node_path2.join(nvmDir, "alias", "default");
+  if (import_node_fs.existsSync(aliasPath)) {
+    try {
+      const alias = import_node_fs.readFileSync(aliasPath, "utf-8").trim();
+      const match = versions.find((v) => v === `v${alias}` || v.startsWith(`v${alias}.`));
+      if (match) {
+        const bin2 = import_node_path2.join(versionsDir, match, "bin");
+        if (import_node_fs.existsSync(bin2))
+          return bin2;
+      }
+    } catch {}
   }
-  return dirs;
+  const sorted = versions.sort((a, b) => {
+    const pa = a.slice(1).split(".").map(Number);
+    const pb = b.slice(1).split(".").map(Number);
+    for (let i = 0;i < 3; i++) {
+      if ((pa[i] || 0) !== (pb[i] || 0))
+        return (pb[i] || 0) - (pa[i] || 0);
+    }
+    return 0;
+  });
+  const bin = import_node_path2.join(versionsDir, sorted[0], "bin");
+  return import_node_fs.existsSync(bin) ? bin : null;
+}
+function getFnmNodeBinDir() {
+  const fnmDir = process.env.FNM_DIR || import_node_path2.join(import_node_os.homedir(), ".fnm");
+  const currentBin = import_node_path2.join(fnmDir, "current", "bin");
+  if (import_node_fs.existsSync(currentBin))
+    return currentBin;
+  const aliasDir = import_node_path2.join(fnmDir, "aliases", "default");
+  if (import_node_fs.existsSync(aliasDir)) {
+    const bin = import_node_path2.join(aliasDir, "bin");
+    if (import_node_fs.existsSync(bin))
+      return bin;
+  }
+  return null;
 }
 function getAugmentedPath() {
   const currentPath = process.env.PATH || "";
   const currentDirs = new Set(currentPath.split(import_node_path2.delimiter));
-  const extra = [...EXTRA_BIN_DIRS, ...getNodeManagerDirs()].filter((dir) => !currentDirs.has(dir) && import_node_fs.existsSync(dir));
+  const extra = [];
+  for (const dir of EXTRA_BIN_DIRS) {
+    if (!currentDirs.has(dir) && import_node_fs.existsSync(dir)) {
+      extra.push(dir);
+    }
+  }
+  const nvmBin = getNvmNodeBinDir();
+  if (nvmBin && !currentDirs.has(nvmBin)) {
+    extra.push(nvmBin);
+  }
+  const fnmBin = getFnmNodeBinDir();
+  if (fnmBin && !currentDirs.has(fnmBin)) {
+    extra.push(fnmBin);
+  }
   if (extra.length === 0)
     return currentPath;
   return currentPath + import_node_path2.delimiter + extra.join(import_node_path2.delimiter);
 }
 function getAugmentedEnv(overrides = {}) {
-  return {
+  const env = {
     ...process.env,
     ...overrides,
     PATH: getAugmentedPath()
   };
-}
-
-// src/ai/claude-runner.ts
-var SANDBOX_SETTINGS = JSON.stringify({
-  sandbox: {
-    enabled: true,
-    autoAllow: true,
-    allowUnsandboxedCommands: false
+  for (const key of ENV_VARS_TO_STRIP) {
+    delete env[key];
   }
+  return env;
+}
+var import_node_fs, import_node_os, import_node_path2, EXTRA_BIN_DIRS, ENV_VARS_TO_STRIP;
+var init_resolve_bin = __esm(() => {
+  import_node_fs = require("node:fs");
+  import_node_os = require("node:os");
+  import_node_path2 = require("node:path");
+  EXTRA_BIN_DIRS = [
+    import_node_path2.join(import_node_os.homedir(), ".local", "bin"),
+    import_node_path2.join(import_node_os.homedir(), ".npm", "bin"),
+    import_node_path2.join(import_node_os.homedir(), ".npm-global", "bin"),
+    import_node_path2.join(import_node_os.homedir(), ".yarn", "bin"),
+    import_node_path2.join(import_node_os.homedir(), ".bun", "bin"),
+    import_node_path2.join(import_node_os.homedir(), "Library", "pnpm"),
+    "/usr/local/bin",
+    "/opt/homebrew/bin",
+    "/opt/homebrew/sbin"
+  ];
+  ENV_VARS_TO_STRIP = ["ANTHROPIC_API_KEY", "OPENAI_API_KEY"];
 });
 
+// src/ai/claude-runner.ts
 class ClaudeRunner {
   model;
   log;
@@ -735,11 +831,13 @@ class ClaudeRunner {
     this.activeProcess = claude;
     let buffer = "";
     let stderrBuffer = "";
+    let stderrFull = "";
     let resolveChunk = null;
     const chunkQueue = [];
     let processEnded = false;
     let errorMessage = "";
     let finalContent = "";
+    let lastResultContent = "";
     let isThinking = false;
     const enqueueChunk = (chunk) => {
       this.emitEventForChunk(chunk, isThinking);
@@ -777,6 +875,9 @@ class ClaudeRunner {
       for (const line of lines) {
         const chunk = this.parseStreamLineToChunk(line);
         if (chunk) {
+          if (chunk.type === "result") {
+            lastResultContent = chunk.content;
+          }
           enqueueChunk(chunk);
         }
       }
@@ -784,6 +885,7 @@ class ClaudeRunner {
     claude.stderr.on("data", (data) => {
       const chunk = data.toString();
       stderrBuffer += chunk;
+      stderrFull += chunk;
       const lines = stderrBuffer.split(`
 `);
       stderrBuffer = lines.pop() || "";
@@ -806,7 +908,8 @@ class ClaudeRunner {
 `);
       }
       if (code !== 0 && !errorMessage) {
-        errorMessage = this.createExecutionError(code, stderrBuffer).message;
+        const detail = stderrFull.trim() || lastResultContent.trim();
+        errorMessage = this.createExecutionError(code, detail).message;
         this.eventEmitter?.emitErrorOccurred(errorMessage, `EXIT_${code}`);
       }
       signalEnd();
@@ -1015,7 +1118,8 @@ class ClaudeRunner {
         if (code === 0) {
           resolve2(finalResult);
         } else {
-          reject(this.createExecutionError(code, errorOutput));
+          const detail = errorOutput.trim() || finalResult.trim();
+          reject(this.createExecutionError(code, detail));
         }
       });
       claude.stdin.write(prompt);
@@ -1061,13 +1165,23 @@ ${c.primary("[Claude]")} ${c.bold(`Running ${content_block.name}...`)}
     return new Error(message);
   }
 }
+var import_node_child_process, import_node_path3, SANDBOX_SETTINGS;
+var init_claude_runner = __esm(() => {
+  init_config();
+  init_colors();
+  init_resolve_bin();
+  import_node_child_process = require("node:child_process");
+  import_node_path3 = require("node:path");
+  SANDBOX_SETTINGS = JSON.stringify({
+    sandbox: {
+      enabled: true,
+      autoAllow: true,
+      allowUnsandboxedCommands: false
+    }
+  });
+});
 
 // src/ai/codex-runner.ts
-var import_node_child_process2 = require("node:child_process");
-var import_node_crypto = require("node:crypto");
-var import_node_fs2 = require("node:fs");
-var import_node_os2 = require("node:os");
-var import_node_path4 = require("node:path");
 class CodexRunner {
   projectPath;
   model;
@@ -1294,6 +1408,16 @@ class CodexRunner {
     return new Promise((resolve2) => setTimeout(resolve2, ms));
   }
 }
+var import_node_child_process2, import_node_crypto, import_node_fs2, import_node_os2, import_node_path4;
+var init_codex_runner = __esm(() => {
+  init_config();
+  init_resolve_bin();
+  import_node_child_process2 = require("node:child_process");
+  import_node_crypto = require("node:crypto");
+  import_node_fs2 = require("node:fs");
+  import_node_os2 = require("node:os");
+  import_node_path4 = require("node:path");
+});
 
 // src/ai/factory.ts
 function createAiRunner(provider, config) {
@@ -1306,9 +1430,13 @@ function createAiRunner(provider, config) {
       return new ClaudeRunner(config.projectPath, model, config.log);
   }
 }
+var init_factory = __esm(() => {
+  init_config();
+  init_claude_runner();
+  init_codex_runner();
+});
 
 // src/git/git-utils.ts
-var import_node_child_process3 = require("node:child_process");
 function isGitAvailable() {
   try {
     import_node_child_process3.execFileSync("git", ["--version"], {
@@ -1399,23 +1527,126 @@ function getDefaultBranch(projectPath, remote = "origin") {
     }
   }
 }
+var import_node_child_process3;
+var init_git_utils = __esm(() => {
+  import_node_child_process3 = require("node:child_process");
+});
 
-// src/git/pr-service.ts
-var import_node_child_process4 = require("node:child_process");
-class PrService {
-  projectPath;
-  log;
-  constructor(projectPath, log) {
-    this.projectPath = projectPath;
-    this.log = log;
+// src/project/knowledge-base.ts
+class KnowledgeBase {
+  contextPath;
+  progressPath;
+  constructor(projectPath) {
+    this.contextPath = getLocusPath(projectPath, "projectContextFile");
+    this.progressPath = getLocusPath(projectPath, "projectProgressFile");
   }
-  createPr(options) {
-    const {
-      task,
-      branch,
-      baseBranch: requestedBaseBranch,
-      agentId,
-      summary
+  readContext() {
+    if (!import_node_fs3.existsSync(this.contextPath)) {
+      return "";
+    }
+    return import_node_fs3.readFileSync(this.contextPath, "utf-8");
+  }
+  readProgress() {
+    if (!import_node_fs3.existsSync(this.progressPath)) {
+      return "";
+    }
+    return import_node_fs3.readFileSync(this.progressPath, "utf-8");
+  }
+  updateContext(content) {
+    this.ensureDir(this.contextPath);
+    import_node_fs3.writeFileSync(this.contextPath, content);
+  }
+  updateProgress(entry) {
+    this.ensureDir(this.progressPath);
+    const existing = this.readProgress();
+    const timestamp = (entry.timestamp ?? new Date).toISOString();
+    const label = entry.role === "user" ? "User" : "Assistant";
+    const line = `**${label}** (${timestamp}):
+${entry.content}`;
+    const updated = existing ? `${existing}
+
+---
+
+${line}` : `# Conversation History
+
+${line}`;
+    import_node_fs3.writeFileSync(this.progressPath, updated);
+  }
+  getFullContext() {
+    const context = this.readContext();
+    const progress = this.readProgress();
+    const parts = [];
+    if (context.trim()) {
+      parts.push(context.trim());
+    }
+    if (progress.trim()) {
+      parts.push(progress.trim());
+    }
+    return parts.join(`
+
+---
+
+`);
+  }
+  initialize(info) {
+    this.ensureDir(this.contextPath);
+    this.ensureDir(this.progressPath);
+    const techStackList = info.techStack.map((t) => `- ${t}`).join(`
+`);
+    const contextContent = `# Project: ${info.name}
+
+## Mission
+${info.mission}
+
+## Tech Stack
+${techStackList}
+
+## Architecture
+<!-- Describe your high-level architecture here -->
+
+## Key Decisions
+<!-- Document important technical decisions and their rationale -->
+
+## Feature Areas
+<!-- List your main feature areas and their status -->
+`;
+    const progressContent = `# Conversation History
+`;
+    import_node_fs3.writeFileSync(this.contextPath, contextContent);
+    import_node_fs3.writeFileSync(this.progressPath, progressContent);
+  }
+  get exists() {
+    return import_node_fs3.existsSync(this.contextPath) || import_node_fs3.existsSync(this.progressPath);
+  }
+  ensureDir(filePath) {
+    const dir = import_node_path5.dirname(filePath);
+    if (!import_node_fs3.existsSync(dir)) {
+      import_node_fs3.mkdirSync(dir, { recursive: true });
+    }
+  }
+}
+var import_node_fs3, import_node_path5;
+var init_knowledge_base = __esm(() => {
+  init_config();
+  import_node_fs3 = require("node:fs");
+  import_node_path5 = require("node:path");
+});
+
+// src/git/pr-service.ts
+class PrService {
+  projectPath;
+  log;
+  constructor(projectPath, log) {
+    this.projectPath = projectPath;
+    this.log = log;
+  }
+  createPr(options) {
+    const {
+      task,
+      branch,
+      baseBranch: requestedBaseBranch,
+      agentId,
+      summary
     } = options;
     const provider = detectRemoteProvider(this.projectPath);
     if (provider !== "github") {
@@ -1631,148 +1862,21 @@ class PrService {
     return match ? Number.parseInt(match[1], 10) : 0;
   }
 }
-
-// src/project/knowledge-base.ts
-var import_node_fs3 = require("node:fs");
-var import_node_path5 = require("node:path");
-class KnowledgeBase {
-  contextPath;
-  progressPath;
-  constructor(projectPath) {
-    this.contextPath = getLocusPath(projectPath, "projectContextFile");
-    this.progressPath = getLocusPath(projectPath, "projectProgressFile");
-  }
-  readContext() {
-    if (!import_node_fs3.existsSync(this.contextPath)) {
-      return "";
-    }
-    return import_node_fs3.readFileSync(this.contextPath, "utf-8");
-  }
-  readProgress() {
-    if (!import_node_fs3.existsSync(this.progressPath)) {
-      return "";
-    }
-    return import_node_fs3.readFileSync(this.progressPath, "utf-8");
-  }
-  updateContext(content) {
-    this.ensureDir(this.contextPath);
-    import_node_fs3.writeFileSync(this.contextPath, content);
-  }
-  updateProgress(event) {
-    this.ensureDir(this.progressPath);
-    const existing = this.readProgress();
-    const timestamp = (event.timestamp ?? new Date).toISOString();
-    let entry = "";
-    switch (event.type) {
-      case "task_completed":
-        entry = `- [x] ${event.title} — completed ${timestamp}`;
-        break;
-      case "sprint_started":
-        entry = `
-## Current Sprint: ${event.title}
-**Status:** ACTIVE | Started: ${timestamp}
-`;
-        break;
-      case "sprint_completed":
-        entry = `
-### Sprint Completed: ${event.title} — ${timestamp}
-`;
-        break;
-      case "blocker":
-        entry = `- BLOCKER: ${event.title}`;
-        break;
-      case "pr_opened":
-        entry = `- [ ] ${event.title} — PR opened ${timestamp}`;
-        break;
-      case "pr_reviewed":
-        entry = `- ${event.title} — reviewed ${timestamp}`;
-        break;
-      case "pr_merged":
-        entry = `- [x] ${event.title} — PR merged ${timestamp}`;
-        break;
-      case "exec_completed":
-        entry = `- [x] ${event.title} — exec ${timestamp}`;
-        break;
-    }
-    if (event.details) {
-      entry += `
-  ${event.details}`;
-    }
-    const updated = existing ? `${existing}
-${entry}` : `# Project Progress
-
-${entry}`;
-    import_node_fs3.writeFileSync(this.progressPath, updated);
-  }
-  getFullContext() {
-    const context = this.readContext();
-    const progress = this.readProgress();
-    const parts = [];
-    if (context.trim()) {
-      parts.push(context.trim());
-    }
-    if (progress.trim()) {
-      parts.push(progress.trim());
-    }
-    return parts.join(`
-
----
-
-`);
-  }
-  initialize(info) {
-    this.ensureDir(this.contextPath);
-    this.ensureDir(this.progressPath);
-    const techStackList = info.techStack.map((t) => `- ${t}`).join(`
-`);
-    const contextContent = `# Project: ${info.name}
-
-## Mission
-${info.mission}
-
-## Tech Stack
-${techStackList}
-
-## Architecture
-<!-- Describe your high-level architecture here -->
-
-## Key Decisions
-<!-- Document important technical decisions and their rationale -->
-
-## Feature Areas
-<!-- List your main feature areas and their status -->
-`;
-    const progressContent = `# Project Progress
-
-No sprints started yet.
-`;
-    import_node_fs3.writeFileSync(this.contextPath, contextContent);
-    import_node_fs3.writeFileSync(this.progressPath, progressContent);
-  }
-  get exists() {
-    return import_node_fs3.existsSync(this.contextPath) || import_node_fs3.existsSync(this.progressPath);
-  }
-  ensureDir(filePath) {
-    const dir = import_node_path5.dirname(filePath);
-    if (!import_node_fs3.existsSync(dir)) {
-      import_node_fs3.mkdirSync(dir, { recursive: true });
-    }
-  }
-}
-
-// src/worktree/worktree-manager.ts
-var import_node_child_process5 = require("node:child_process");
-var import_node_fs4 = require("node:fs");
-var import_node_path6 = require("node:path");
+var import_node_child_process4;
+var init_pr_service = __esm(() => {
+  init_git_utils();
+  import_node_child_process4 = require("node:child_process");
+});
 
 // src/worktree/worktree-config.ts
-var WORKTREE_ROOT_DIR = ".locus-worktrees";
-var WORKTREE_BRANCH_PREFIX = "agent";
-var DEFAULT_WORKTREE_CONFIG = {
-  rootDir: WORKTREE_ROOT_DIR,
-  branchPrefix: WORKTREE_BRANCH_PREFIX,
-  cleanupPolicy: "retain-on-failure"
-};
+var WORKTREE_ROOT_DIR = ".locus-worktrees", WORKTREE_BRANCH_PREFIX = "agent", DEFAULT_WORKTREE_CONFIG;
+var init_worktree_config = __esm(() => {
+  DEFAULT_WORKTREE_CONFIG = {
+    rootDir: WORKTREE_ROOT_DIR,
+    branchPrefix: WORKTREE_BRANCH_PREFIX,
+    cleanupPolicy: "retain-on-failure"
+  };
+});
 
 // src/worktree/worktree-manager.ts
 class WorktreeManager {
@@ -1799,6 +1903,15 @@ class WorktreeManager {
     const worktreePath = import_node_path6.join(this.rootPath, worktreeDir);
     this.ensureDirectory(this.rootPath, "Worktree root");
     const baseBranch = options.baseBranch ?? this.config.baseBranch ?? this.getCurrentBranch();
+    if (!this.branchExists(baseBranch)) {
+      this.log(`Base branch "${baseBranch}" not found locally, fetching from origin`, "info");
+      try {
+        this.gitExec(["fetch", "origin", baseBranch], this.projectPath);
+        this.gitExec(["branch", baseBranch, `origin/${baseBranch}`], this.projectPath);
+      } catch {
+        this.log(`Could not fetch/create local branch for "${baseBranch}", falling back to current branch`, "warn");
+      }
+    }
     this.log(`Creating worktree: ${worktreeDir} (branch: ${branch}, base: ${baseBranch})`, "info");
     if (import_node_fs4.existsSync(worktreePath)) {
       this.log(`Removing stale worktree directory: ${worktreePath}`, "warn");
@@ -2062,11 +2175,15 @@ class WorktreeManager {
     });
   }
 }
+var import_node_child_process5, import_node_fs4, import_node_path6;
+var init_worktree_manager = __esm(() => {
+  init_worktree_config();
+  import_node_child_process5 = require("node:child_process");
+  import_node_fs4 = require("node:fs");
+  import_node_path6 = require("node:path");
+});
 
 // src/core/prompt-builder.ts
-var import_node_fs5 = require("node:fs");
-var import_node_path7 = require("node:path");
-var import_shared2 = require("@locusai/shared");
 class PromptBuilder {
   projectPath;
   constructor(projectPath) {
@@ -2362,6 +2479,13 @@ There is an index file in the .locus/codebase-index.json and if you need you can
     }
   }
 }
+var import_node_fs5, import_node_path7, import_shared2;
+var init_prompt_builder = __esm(() => {
+  init_config();
+  import_node_fs5 = require("node:fs");
+  import_node_path7 = require("node:path");
+  import_shared2 = require("@locusai/shared");
+});
 
 // src/agent/task-executor.ts
 class TaskExecutor {
@@ -2386,162 +2510,51 @@ class TaskExecutor {
     }
   }
 }
+var init_task_executor = __esm(() => {
+  init_prompt_builder();
+});
 
-// src/agent/worker.ts
-function resolveProvider(value) {
-  if (!value || value.startsWith("--")) {
-    console.warn("Warning: --provider requires a value. Falling back to 'claude'.");
-    return PROVIDER.CLAUDE;
-  }
-  if (value === PROVIDER.CLAUDE || value === PROVIDER.CODEX)
-    return value;
-  console.warn(`Warning: invalid --provider value '${value}'. Falling back to 'claude'.`);
-  return PROVIDER.CLAUDE;
-}
-
-class AgentWorker {
+// src/agent/git-workflow.ts
+class GitWorkflow {
   config;
-  client;
-  aiRunner;
-  taskExecutor;
-  knowledgeBase;
-  worktreeManager = null;
-  prService = null;
-  maxTasks = 50;
-  tasksCompleted = 0;
-  heartbeatInterval = null;
-  currentTaskId = null;
-  currentWorktreePath = null;
-  postCleanupDelayMs = 5000;
-  ghUsername = null;
-  constructor(config) {
+  log;
+  ghUsername;
+  worktreeManager;
+  prService;
+  constructor(config, log, ghUsername) {
     this.config = config;
+    this.log = log;
+    this.ghUsername = ghUsername;
     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
-      }
-    });
-    const log = this.log.bind(this);
-    if (config.useWorktrees && !isGitAvailable()) {
-      this.log("git is not installed — worktree isolation will not work", "error");
-      config.useWorktrees = false;
-    }
-    if (config.autoPush && !isGhAvailable(projectPath)) {
-      this.log("GitHub CLI (gh) not available or not authenticated. Branch push can continue, but automatic PR creation may fail until gh is configured. Install from https://cli.github.com/", "warn");
-    }
-    if (config.autoPush) {
-      this.ghUsername = getGhUsername();
-      if (this.ghUsername) {
-        this.log(`GitHub user: ${this.ghUsername}`, "info");
-      }
-    }
-    const provider = config.provider ?? PROVIDER.CLAUDE;
-    this.aiRunner = createAiRunner(provider, {
-      projectPath,
-      model: config.model,
-      log
-    });
-    this.taskExecutor = new TaskExecutor({
-      aiRunner: this.aiRunner,
-      projectPath,
-      log
-    });
-    this.knowledgeBase = new KnowledgeBase(projectPath);
-    if (config.useWorktrees) {
-      this.worktreeManager = new WorktreeManager(projectPath, {
-        cleanupPolicy: "auto"
-      });
-    }
-    if (config.autoPush) {
-      this.prService = new PrService(projectPath, log);
-    }
-    const providerLabel = provider === "codex" ? "Codex" : "Claude";
-    this.log(`Using ${providerLabel} CLI for all phases`, "info");
-    if (config.useWorktrees) {
-      this.log("Per-task worktree isolation enabled", "info");
-      if (config.autoPush) {
-        this.log("Auto-push enabled: branches will be pushed to remote", "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() {
-    const maxRetries = 10;
-    for (let attempt = 1;attempt <= maxRetries; attempt++) {
-      try {
-        const task = await this.client.workspaces.dispatch(this.config.workspaceId, this.config.agentId, this.config.sprintId);
-        return task;
-      } catch (error) {
-        const isAxiosError = error != null && typeof error === "object" && "response" in error && typeof error.response?.status === "number";
-        const status = isAxiosError ? error.response.status : 0;
-        if (status === 404) {
-          this.log("No tasks available in the backlog.", "info");
-          return null;
-        }
-        const msg = error instanceof Error ? error.message : String(error);
-        if (attempt < maxRetries) {
-          this.log(`Nothing dispatched (attempt ${attempt}/${maxRetries}): ${msg}. Retrying in 30s...`, "warn");
-          await new Promise((r) => setTimeout(r, 30000));
-        } else {
-          this.log(`Nothing dispatched after ${maxRetries} attempts: ${msg}`, "warn");
-          return null;
-        }
-      }
-    }
-    return null;
-  }
-  createTaskWorktree(task) {
-    if (!this.worktreeManager) {
-      return {
-        worktreePath: null,
-        baseBranch: null,
-        executor: this.taskExecutor
-      };
+    this.worktreeManager = config.useWorktrees ? new WorktreeManager(projectPath, { cleanupPolicy: "auto" }) : null;
+    this.prService = config.autoPush ? new PrService(projectPath, log) : null;
+  }
+  createTaskWorktree(task, defaultExecutor) {
+    if (!this.worktreeManager) {
+      return {
+        worktreePath: null,
+        baseBranch: null,
+        executor: defaultExecutor
+      };
     }
     const slug = task.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
     const result = this.worktreeManager.create({
       taskId: task.id,
       taskSlug: slug,
-      agentId: this.config.agentId
+      agentId: this.config.agentId,
+      baseBranch: this.config.baseBranch
     });
     this.log(`Worktree created: ${result.worktreePath} (${result.branch})`, "info");
-    const log = this.log.bind(this);
     const provider = this.config.provider ?? PROVIDER.CLAUDE;
     const taskAiRunner = createAiRunner(provider, {
       projectPath: result.worktreePath,
       model: this.config.model,
-      log
+      log: this.log
     });
     const taskExecutor = new TaskExecutor({
       aiRunner: taskAiRunner,
       projectPath: result.worktreePath,
-      log
+      log: this.log
     });
     return {
       worktreePath: result.worktreePath,
@@ -2549,7 +2562,7 @@ class AgentWorker {
       executor: taskExecutor
     };
   }
-  commitAndPushWorktree(worktreePath, task, baseBranch) {
+  commitAndPush(worktreePath, task, baseBranch) {
     if (!this.worktreeManager) {
       return { branch: null, pushed: false, pushFailed: false };
     }
@@ -2631,7 +2644,7 @@ ${trailers.join(`
       return { url: null, error: errorMessage };
     }
   }
-  cleanupTaskWorktree(worktreePath, keepBranch) {
+  cleanupWorktree(worktreePath, keepBranch) {
     if (!this.worktreeManager || !worktreePath)
       return;
     try {
@@ -2640,11 +2653,205 @@ ${trailers.join(`
     } catch {
       this.log(`Could not clean up worktree: ${worktreePath}`, "warn");
     }
-    this.currentWorktreePath = null;
+  }
+}
+var init_git_workflow = __esm(() => {
+  init_factory();
+  init_config();
+  init_pr_service();
+  init_worktree_manager();
+  init_task_executor();
+});
+
+// src/agent/worker-cli.ts
+var exports_worker_cli = {};
+__export(exports_worker_cli, {
+  parseWorkerArgs: () => parseWorkerArgs
+});
+function resolveProvider(value) {
+  if (!value || value.startsWith("--")) {
+    console.warn("Warning: --provider requires a value. Falling back to 'claude'.");
+    return PROVIDER.CLAUDE;
+  }
+  if (value === PROVIDER.CLAUDE || value === PROVIDER.CODEX)
+    return value;
+  console.warn(`Warning: invalid --provider value '${value}'. Falling back to 'claude'.`);
+  return PROVIDER.CLAUDE;
+}
+function parseWorkerArgs(argv) {
+  const args = 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-url")
+      config.apiBase = args[++i];
+    else if (arg === "--api-key")
+      config.apiKey = args[++i];
+    else if (arg === "--project-path")
+      config.projectPath = args[++i];
+    else if (arg === "--main-project-path")
+      config.mainProjectPath = args[++i];
+    else if (arg === "--model")
+      config.model = args[++i];
+    else if (arg === "--use-worktrees")
+      config.useWorktrees = true;
+    else if (arg === "--auto-push")
+      config.autoPush = true;
+    else if (arg === "--base-branch")
+      config.baseBranch = args[++i];
+    else if (arg === "--provider") {
+      const value = args[i + 1];
+      if (value && !value.startsWith("--"))
+        i++;
+      config.provider = resolveProvider(value);
+    }
+  }
+  if (!config.agentId || !config.workspaceId || !config.apiBase || !config.apiKey || !config.projectPath) {
+    console.error("Missing required arguments");
+    process.exit(1);
+  }
+  return config;
+}
+var entrypoint;
+var init_worker_cli = __esm(() => {
+  init_config();
+  init_worker();
+  entrypoint = process.argv[1]?.split(/[\\/]/).pop();
+  if (entrypoint === "worker-cli.js" || entrypoint === "worker-cli.ts") {
+    process.title = "locus-worker";
+    const config = parseWorkerArgs(process.argv);
+    const worker = new AgentWorker(config);
+    worker.run().catch((err) => {
+      console.error("Fatal worker error:", err);
+      process.exit(1);
+    });
+  }
+});
+
+// src/agent/worker.ts
+var exports_worker = {};
+__export(exports_worker, {
+  AgentWorker: () => AgentWorker
+});
+module.exports = __toCommonJS(exports_worker);
+
+class AgentWorker {
+  config;
+  client;
+  aiRunner;
+  taskExecutor;
+  knowledgeBase;
+  gitWorkflow;
+  maxTasks = 50;
+  tasksCompleted = 0;
+  heartbeatInterval = null;
+  currentTaskId = null;
+  currentWorktreePath = null;
+  postCleanupDelayMs = 5000;
+  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
+      }
+    });
+    const log = this.log.bind(this);
+    if (config.useWorktrees && !isGitAvailable()) {
+      this.log("git is not installed — worktree isolation will not work", "error");
+      config.useWorktrees = false;
+    }
+    if (config.autoPush && !isGhAvailable(projectPath)) {
+      this.log("GitHub CLI (gh) not available or not authenticated. Branch push can continue, but automatic PR creation may fail until gh is configured. Install from https://cli.github.com/", "warn");
+    }
+    const ghUsername = config.autoPush ? getGhUsername() : null;
+    if (ghUsername) {
+      this.log(`GitHub user: ${ghUsername}`, "info");
+    }
+    const provider = config.provider ?? PROVIDER.CLAUDE;
+    this.aiRunner = createAiRunner(provider, {
+      projectPath,
+      model: config.model,
+      log
+    });
+    this.taskExecutor = new TaskExecutor({
+      aiRunner: this.aiRunner,
+      projectPath,
+      log
+    });
+    this.knowledgeBase = new KnowledgeBase(projectPath);
+    this.gitWorkflow = new GitWorkflow(config, log, ghUsername);
+    const providerLabel = provider === "codex" ? "Codex" : "Claude";
+    this.log(`Using ${providerLabel} CLI for all phases`, "info");
+    if (config.useWorktrees) {
+      this.log("Per-task worktree isolation enabled", "info");
+      if (config.baseBranch) {
+        this.log(`Base branch for worktrees: ${config.baseBranch}`, "info");
+      }
+      if (config.autoPush) {
+        this.log("Auto-push enabled: branches will be pushed to remote", "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() {
+    const maxRetries = 10;
+    for (let attempt = 1;attempt <= maxRetries; attempt++) {
+      try {
+        return await this.client.workspaces.dispatch(this.config.workspaceId, this.config.agentId, this.config.sprintId);
+      } catch (error) {
+        const isAxiosError = error != null && typeof error === "object" && "response" in error && typeof error.response?.status === "number";
+        const status = isAxiosError ? error.response.status : 0;
+        if (status === 404) {
+          this.log("No tasks available in the backlog.", "info");
+          return null;
+        }
+        const msg = error instanceof Error ? error.message : String(error);
+        if (attempt < maxRetries) {
+          this.log(`Nothing dispatched (attempt ${attempt}/${maxRetries}): ${msg}. Retrying in 30s...`, "warn");
+          await new Promise((r) => setTimeout(r, 30000));
+        } else {
+          this.log(`Nothing dispatched after ${maxRetries} attempts: ${msg}`, "warn");
+          return null;
+        }
+      }
+    }
+    return null;
   }
   async executeTask(task) {
     const fullTask = await this.client.tasks.getById(task.id, this.config.workspaceId);
-    const { worktreePath, baseBranch, executor } = this.createTaskWorktree(fullTask);
+    const { worktreePath, baseBranch, executor } = this.gitWorkflow.createTaskWorktree(fullTask, this.taskExecutor);
     this.currentWorktreePath = worktreePath;
     let branchPushed = false;
     let keepBranch = false;
@@ -2656,7 +2863,7 @@ ${trailers.join(`
       let prError = null;
       let noChanges = false;
       if (result.success && worktreePath) {
-        const commitResult = this.commitAndPushWorktree(worktreePath, fullTask, baseBranch ?? undefined);
+        const commitResult = this.gitWorkflow.commitAndPush(worktreePath, fullTask, baseBranch ?? undefined);
         taskBranch = commitResult.branch;
         branchPushed = commitResult.pushed;
         keepBranch = taskBranch !== null;
@@ -2667,7 +2874,7 @@ ${trailers.join(`
           this.log(`Preserving worktree after push failure: ${worktreePath}`, "warn");
         }
         if (branchPushed && taskBranch) {
-          const prResult = this.createPullRequest(fullTask, taskBranch, result.summary, baseBranch ?? undefined);
+          const prResult = this.gitWorkflow.createPullRequest(fullTask, taskBranch, result.summary, baseBranch ?? undefined);
           prUrl = prResult.url;
           prError = prResult.error ?? null;
           if (!prUrl) {
@@ -2691,29 +2898,29 @@ ${trailers.join(`
       if (preserveWorktree || keepBranch) {
         this.currentWorktreePath = null;
       } else {
-        this.cleanupTaskWorktree(worktreePath, keepBranch);
+        this.gitWorkflow.cleanupWorktree(worktreePath, keepBranch);
+        this.currentWorktreePath = null;
       }
     }
   }
-  updateProgress(task, success) {
+  updateProgress(task, summary) {
     try {
-      if (success) {
-        this.knowledgeBase.updateProgress({
-          type: "task_completed",
-          title: task.title,
-          details: `Agent: ${this.config.agentId.slice(-8)}`
-        });
-        this.log(`Updated progress.md: ${task.title}`, "info");
-      }
+      this.knowledgeBase.updateProgress({
+        role: "user",
+        content: task.title
+      });
+      this.knowledgeBase.updateProgress({
+        role: "assistant",
+        content: summary
+      });
+      this.log(`Updated progress.md: ${task.title}`, "info");
     } catch (err) {
       this.log(`Failed to update progress: ${err instanceof Error ? err.message : String(err)}`, "warn");
     }
   }
   startHeartbeat() {
     this.sendHeartbeat();
-    this.heartbeatInterval = setInterval(() => {
-      this.sendHeartbeat();
-    }, 60000);
+    this.heartbeatInterval = setInterval(() => this.sendHeartbeat(), 60000);
   }
   stopHeartbeat() {
     if (this.heartbeatInterval) {
@@ -2738,7 +2945,7 @@ ${trailers.join(`
       this.log("Received shutdown signal. Aborting...", "warn");
       this.aiRunner.abort();
       this.stopHeartbeat();
-      this.cleanupTaskWorktree(this.currentWorktreePath, false);
+      this.gitWorkflow.cleanupWorktree(this.currentWorktreePath, false);
       process.exit(1);
     };
     process.on("SIGTERM", handleShutdown);
@@ -2794,16 +3001,7 @@ PR automation error: ${result.prError}` : "";
             text: `✅ ${result.summary}${branchInfo}${prInfo}${prErrorInfo}`
           });
           this.tasksCompleted++;
-          this.updateProgress(task, true);
-          if (result.prUrl) {
-            try {
-              this.knowledgeBase.updateProgress({
-                type: "pr_opened",
-                title: task.title,
-                details: `PR: ${result.prUrl}`
-              });
-            } catch {}
-          }
+          this.updateProgress(task, result.summary);
         }
       } else {
         this.log(`Failed: ${task.title} - ${result.summary}`, "error");
@@ -2826,47 +3024,28 @@ PR automation error: ${result.prError}` : "";
     process.exit(0);
   }
 }
-var workerEntrypoint = process.argv[1]?.split(/[\\/]/).pop();
-if (workerEntrypoint === "worker.js" || workerEntrypoint === "worker.ts") {
-  process.title = "locus-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-url")
-      config.apiBase = args[++i];
-    else if (arg === "--api-key")
-      config.apiKey = args[++i];
-    else if (arg === "--project-path")
-      config.projectPath = args[++i];
-    else if (arg === "--main-project-path")
-      config.mainProjectPath = args[++i];
-    else if (arg === "--model")
-      config.model = args[++i];
-    else if (arg === "--use-worktrees")
-      config.useWorktrees = true;
-    else if (arg === "--auto-push")
-      config.autoPush = true;
-    else if (arg === "--provider") {
-      const value = args[i + 1];
-      if (value && !value.startsWith("--"))
-        i++;
-      config.provider = resolveProvider(value);
-    }
-  }
-  if (!config.agentId || !config.workspaceId || !config.apiBase || !config.apiKey || !config.projectPath) {
-    console.error("Missing required arguments");
-    process.exit(1);
+var import_shared3, workerEntrypoint;
+var init_worker = __esm(() => {
+  init_factory();
+  init_config();
+  init_git_utils();
+  init_src();
+  init_knowledge_base();
+  init_colors();
+  init_git_workflow();
+  init_task_executor();
+  import_shared3 = require("@locusai/shared");
+  workerEntrypoint = process.argv[1]?.split(/[\\/]/).pop();
+  if (workerEntrypoint === "worker.js" || workerEntrypoint === "worker.ts") {
+    process.title = "locus-worker";
+    Promise.resolve().then(() => (init_worker_cli(), exports_worker_cli)).then(({ parseWorkerArgs: parseWorkerArgs2 }) => {
+      const config = parseWorkerArgs2(process.argv);
+      const worker = new AgentWorker(config);
+      worker.run().catch((err) => {
+        console.error("Fatal worker error:", err);
+        process.exit(1);
+      });
+    });
   }
-  const worker = new AgentWorker(config);
-  worker.run().catch((err) => {
-    console.error("Fatal worker error:", err);
-    process.exit(1);
-  });
-}
+});
+init_worker();