@locusai/sdk 0.9.18 → 0.10.2

package/dist/index-node.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,18 +1527,121 @@ 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 {
+  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,
@@ -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");
@@ -2820,56 +3018,36 @@ PR automation error: ${result.prError}` : "";
       this.sendHeartbeat();
       await this.delayAfterCleanup();
     }
-    this.currentTaskId = null;
-    this.stopHeartbeat();
-    this.client.workspaces.heartbeat(this.config.workspaceId, this.config.agentId, null, "COMPLETED").catch(() => {});
-    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);
+    this.currentTaskId = null;
+    this.stopHeartbeat();
+    this.client.workspaces.heartbeat(this.config.workspaceId, this.config.agentId, null, "COMPLETED").catch(() => {});
+    process.exit(0);
   }
-  const worker = new AgentWorker(config);
-  worker.run().catch((err) => {
-    console.error("Fatal worker error:", err);
-    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);
+      });
+    });
+  }
+});
 
 // src/index-node.ts
 var exports_index_node = {};
@@ -2911,6 +3089,7 @@ __export(exports_index_node, {
   KnowledgeBase: () => KnowledgeBase,
   InvitationsModule: () => InvitationsModule,
   HistoryManager: () => HistoryManager,
+  GitWorkflow: () => GitWorkflow,
   ExecSession: () => ExecSession,
   ExecEventType: () => ExecEventType,
   ExecEventEmitter: () => ExecEventEmitter,
@@ -3238,8 +3417,10 @@ Return ONLY valid JSON, no markdown formatting.`;
   }
 }
 // src/agent/document-fetcher.ts
+init_config();
 var import_node_fs7 = require("node:fs");
 var import_node_path9 = require("node:path");
+
 class DocumentFetcher {
   deps;
   constructor(deps) {
@@ -3281,6 +3462,10 @@ class DocumentFetcher {
     }
   }
 }
+
+// src/agent/index.ts
+init_git_workflow();
+
 // src/agent/review-service.ts
 var import_node_child_process6 = require("node:child_process");
 
@@ -3340,6 +3525,13 @@ Keep the review concise but thorough. Focus on substance over style.`;
   }
 }
 // src/agent/reviewer-worker.ts
+init_factory();
+init_config();
+init_git_utils();
+init_pr_service();
+init_src();
+init_knowledge_base();
+init_colors();
 function resolveProvider2(value) {
   if (!value || value.startsWith("--"))
     return PROVIDER.CLAUDE;
@@ -3498,9 +3690,12 @@ ${summary}`;
         const status = result.approved ? "APPROVED" : "CHANGES REQUESTED";
         try {
           this.knowledgeBase.updateProgress({
-            type: "pr_reviewed",
-            title: pr.title,
-            details: `Review: ${status}`
+            role: "user",
+            content: `Review PR #${pr.number}: ${pr.title}`
+          });
+          this.knowledgeBase.updateProgress({
+            role: "assistant",
+            content: `${status}: ${result.summary}`
           });
         } catch {}
         this.reviewsCompleted++;
@@ -3552,6 +3747,21 @@ if (reviewerEntrypoint === "reviewer-worker.js" || reviewerEntrypoint === "revie
     process.exit(1);
   });
 }
+
+// src/agent/index.ts
+init_task_executor();
+init_worker();
+// src/ai/index.ts
+init_claude_runner();
+init_codex_runner();
+init_factory();
+// src/core/index.ts
+init_config();
+init_prompt_builder();
+
+// src/index-node.ts
+init_prompt_builder();
+
 // src/exec/context-tracker.ts
 var REFERENCE_ALIASES = {
   plan: ["the plan", "sprint plan", "project plan", "implementation plan"],
@@ -3965,6 +4175,7 @@ class ExecEventEmitter {
   }
 }
 // src/exec/history-manager.ts
+init_config();
 var import_node_fs8 = require("node:fs");
 var import_node_path10 = require("node:path");
 var DEFAULT_MAX_SESSIONS = 30;
@@ -4342,62 +4553,474 @@ ${currentPrompt}`);
 
 `);
   }
-  save() {
-    if (!this.currentSession) {
-      throw new Error("Session not initialized. Call initialize() first.");
+  save() {
+    if (!this.currentSession) {
+      throw new Error("Session not initialized. Call initialize() first.");
+    }
+    if (this.contextTracker.hasContent()) {
+      this.currentSession.metadata.contextTracker = this.contextTracker.toJSON();
+    }
+    this.history.saveSession(this.currentSession);
+    this.history.pruneSessions();
+  }
+  reset() {
+    if (!this.currentSession) {
+      throw new Error("Session not initialized. Call initialize() first.");
+    }
+    this.currentSession.messages = [];
+    this.currentSession.updatedAt = Date.now();
+    this.contextTracker.clear();
+  }
+  startNewSession() {
+    this.currentSession = this.history.createNewSession(this.model, this.provider);
+    this.contextTracker.clear();
+    this.eventEmitter.emitSessionStarted({
+      model: this.model,
+      provider: this.provider
+    });
+  }
+  end(success = true) {
+    this.eventEmitter.emitSessionEnded(success);
+  }
+  on(eventType, listener) {
+    this.eventEmitter.on(eventType, listener);
+    return this;
+  }
+  off(eventType, listener) {
+    this.eventEmitter.off(eventType, listener);
+    return this;
+  }
+}
+// src/git/index.ts
+init_git_utils();
+init_pr_service();
+
+// src/index-node.ts
+init_src();
+
+// src/orchestrator/index.ts
+init_git_utils();
+init_src();
+init_colors();
+init_worktree_manager();
+var import_shared6 = require("@locusai/shared");
+var import_events5 = require("events");
+
+// src/orchestrator/agent-pool.ts
+init_colors();
+init_resolve_bin();
+var import_node_child_process7 = require("node:child_process");
+var import_node_fs9 = require("node:fs");
+var import_node_path11 = require("node:path");
+var import_node_url = require("node:url");
+var import_shared4 = require("@locusai/shared");
+var import_events4 = require("events");
+var MAX_AGENTS = 5;
+
+class AgentPool extends import_events4.EventEmitter {
+  config;
+  agents = new Map;
+  heartbeatInterval = null;
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  get size() {
+    return this.agents.size;
+  }
+  get effectiveAgentCount() {
+    return Math.min(Math.max(this.config.agentCount ?? 1, 1), MAX_AGENTS);
+  }
+  getAll() {
+    return Array.from(this.agents.values());
+  }
+  get(agentId) {
+    return this.agents.get(agentId);
+  }
+  async spawn(index, resolvedSprintId, baseBranch) {
+    const agentId = `agent-${index}-${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 workerPath = this.resolveWorkerPath();
+    if (!workerPath) {
+      throw new Error("Worker file not found. Make sure the SDK is properly built and installed.");
+    }
+    const workerArgs = this.buildWorkerArgs(agentId, resolvedSprintId, baseBranch);
+    const agentProcess = import_node_child_process7.spawn(process.execPath, [workerPath, ...workerArgs], {
+      stdio: ["pipe", "pipe", "pipe"],
+      detached: true,
+      env: getAugmentedEnv({
+        FORCE_COLOR: "1",
+        TERM: "xterm-256color",
+        LOCUS_WORKER: agentId,
+        LOCUS_WORKSPACE: this.config.workspaceId
+      })
+    });
+    agentState.process = agentProcess;
+    this.attachProcessHandlers(agentId, agentState, agentProcess);
+    this.emit("agent:spawned", { agentId });
+  }
+  async waitForAll(isRunning) {
+    while (this.agents.size > 0 && isRunning()) {
+      await sleep(2000);
+    }
+  }
+  startHeartbeatMonitor() {
+    this.heartbeatInterval = setInterval(() => {
+      const now = Date.now();
+      for (const [agentId, agent] of this.agents.entries()) {
+        if (agent.status === "WORKING" && now - agent.lastHeartbeat.getTime() > import_shared4.STALE_AGENT_TIMEOUT_MS) {
+          console.log(c.error(`Agent ${agentId} is stale (no heartbeat for 10 minutes). Killing.`));
+          if (agent.process && !agent.process.killed) {
+            killProcessTree(agent.process);
+          }
+          this.emit("agent:stale", { agentId });
+        }
+      }
+    }, 60000);
+  }
+  stopAgent(agentId) {
+    const agent = this.agents.get(agentId);
+    if (!agent)
+      return false;
+    if (agent.process && !agent.process.killed) {
+      killProcessTree(agent.process);
+    }
+    return true;
+  }
+  shutdown() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+    for (const [agentId, agent] of this.agents.entries()) {
+      if (agent.process && !agent.process.killed) {
+        console.log(`Killing agent: ${agentId}`);
+        killProcessTree(agent.process);
+      }
+    }
+    this.agents.clear();
+  }
+  getStats() {
+    return {
+      activeAgents: this.agents.size,
+      agentCount: this.effectiveAgentCount,
+      totalTasksCompleted: this.getAll().reduce((sum, a) => sum + a.tasksCompleted, 0),
+      totalTasksFailed: this.getAll().reduce((sum, a) => sum + a.tasksFailed, 0)
+    };
+  }
+  buildWorkerArgs(agentId, resolvedSprintId, baseBranch) {
+    const args = [
+      "--agent-id",
+      agentId,
+      "--workspace-id",
+      this.config.workspaceId,
+      "--api-url",
+      this.config.apiBase,
+      "--api-key",
+      this.config.apiKey,
+      "--project-path",
+      this.config.projectPath
+    ];
+    if (this.config.model) {
+      args.push("--model", this.config.model);
+    }
+    if (this.config.provider) {
+      args.push("--provider", this.config.provider);
+    }
+    if (resolvedSprintId) {
+      args.push("--sprint-id", resolvedSprintId);
+    }
+    if (this.config.useWorktrees ?? true) {
+      args.push("--use-worktrees");
+    }
+    if (this.config.autoPush) {
+      args.push("--auto-push");
+    }
+    if (baseBranch) {
+      args.push("--base-branch", baseBranch);
+    }
+    return args;
+  }
+  attachProcessHandlers(agentId, agentState, proc) {
+    proc.on("message", (msg) => {
+      if (msg.type === "stats") {
+        agentState.tasksCompleted = msg.tasksCompleted || 0;
+        agentState.tasksFailed = msg.tasksFailed || 0;
+      }
+      if (msg.type === "heartbeat") {
+        agentState.lastHeartbeat = new Date;
+      }
+    });
+    proc.stdout?.on("data", (data) => {
+      process.stdout.write(data.toString());
+    });
+    proc.stderr?.on("data", (data) => {
+      process.stderr.write(data.toString());
+    });
+    proc.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);
+      }
+    });
+  }
+  resolveWorkerPath() {
+    const currentModulePath = import_node_url.fileURLToPath("file:///home/runner/work/locusai/locusai/packages/sdk/src/orchestrator/agent-pool.ts");
+    const currentModuleDir = import_node_path11.dirname(currentModulePath);
+    const potentialPaths = [
+      import_node_path11.join(currentModuleDir, "..", "agent", "worker.js"),
+      import_node_path11.join(currentModuleDir, "agent", "worker.js"),
+      import_node_path11.join(currentModuleDir, "worker.js"),
+      import_node_path11.join(currentModuleDir, "..", "agent", "worker.ts")
+    ];
+    return potentialPaths.find((p) => import_node_fs9.existsSync(p));
+  }
+}
+function killProcessTree(proc) {
+  if (!proc.pid || proc.killed)
+    return;
+  try {
+    process.kill(-proc.pid, "SIGTERM");
+  } catch {
+    try {
+      proc.kill("SIGTERM");
+    } catch {}
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+
+// src/orchestrator/execution.ts
+init_git_utils();
+init_colors();
+var import_shared5 = require("@locusai/shared");
+var SPAWN_DELAY_MS = 5000;
+
+class ExecutionStrategy {
+  config;
+  pool;
+  tierMerge;
+  resolvedSprintId;
+  isRunning;
+  constructor(config, pool, tierMerge, resolvedSprintId, isRunning) {
+    this.config = config;
+    this.pool = pool;
+    this.tierMerge = tierMerge;
+    this.resolvedSprintId = resolvedSprintId;
+    this.isRunning = isRunning;
+  }
+  async execute(tasks2) {
+    const hasTiers = tasks2.some((t) => t.tier !== null && t.tier !== undefined);
+    const useWorktrees = this.config.useWorktrees ?? true;
+    if (hasTiers && useWorktrees) {
+      await this.tierBasedExecution(tasks2);
+    } else {
+      await this.legacyExecution(tasks2);
+    }
+  }
+  async tierBasedExecution(allTasks) {
+    const tierMap = groupByTier(allTasks);
+    const tiers = Array.from(tierMap.keys()).sort((a, b) => a - b);
+    const defaultBranch = getDefaultBranch(this.config.projectPath);
+    console.log(c.primary(`\uD83D\uDCCA Tier-based execution: ${tiers.length} tier(s) detected [${tiers.join(", ")}]`));
+    let currentBaseBranch = defaultBranch;
+    for (const tier of tiers) {
+      if (!this.isRunning())
+        break;
+      const tierTasks = tierMap.get(tier) ?? [];
+      const dispatchable = tierTasks.filter(isDispatchable);
+      if (dispatchable.length === 0) {
+        console.log(c.dim(`ℹ  Tier ${tier}: all ${tierTasks.length} task(s) already completed, skipping`));
+        const tierBranch = this.tierMerge.tierBranchName(tier);
+        if (this.tierMerge.remoteBranchExists(tierBranch)) {
+          currentBaseBranch = tierBranch;
+        }
+        continue;
+      }
+      console.log(`
+${c.primary(`\uD83C\uDFD7️  Tier ${tier}:`)} ${dispatchable.length} task(s) | base: ${c.bold(currentBaseBranch)}`);
+      await this.spawnAgentsForTasks(dispatchable.length, currentBaseBranch);
+      await this.pool.waitForAll(this.isRunning);
+      console.log(c.success(`✓ Tier ${tier} complete`));
+      if (this.config.autoPush && tiers.indexOf(tier) < tiers.length - 1) {
+        const mergeBranch = this.tierMerge.createMergeBranch(tier, currentBaseBranch);
+        if (mergeBranch) {
+          currentBaseBranch = mergeBranch;
+          console.log(c.success(`\uD83D\uDCCC Created merge branch: ${mergeBranch} (base for tier ${tier + 1})`));
+        }
+      }
+    }
+  }
+  async legacyExecution(tasks2) {
+    const defaultBranch = getDefaultBranch(this.config.projectPath);
+    await this.spawnAgentsForTasks(tasks2.length, defaultBranch);
+    await this.pool.waitForAll(this.isRunning);
+  }
+  async spawnAgentsForTasks(taskCount, baseBranch) {
+    const agentsToSpawn = Math.min(this.pool.effectiveAgentCount, taskCount);
+    const spawnPromises = [];
+    for (let i = 0;i < agentsToSpawn; i++) {
+      if (i > 0) {
+        await sleep2(SPAWN_DELAY_MS);
+      }
+      spawnPromises.push(this.pool.spawn(i, this.resolvedSprintId, baseBranch));
+    }
+    await Promise.all(spawnPromises);
+  }
+}
+function groupByTier(tasks2) {
+  const tierMap = new Map;
+  for (const task of tasks2) {
+    const tier = task.tier ?? 0;
+    const existing = tierMap.get(tier);
+    if (existing) {
+      existing.push(task);
+    } else {
+      tierMap.set(tier, [task]);
+    }
+  }
+  return tierMap;
+}
+function isDispatchable(task) {
+  return task.status === import_shared5.TaskStatus.BACKLOG || task.status === import_shared5.TaskStatus.IN_PROGRESS && !task.assignedTo;
+}
+function sleep2(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+
+// src/orchestrator/tier-merge.ts
+init_colors();
+var import_node_child_process8 = require("node:child_process");
+var TIER_BRANCH_PREFIX = "locus/tier";
+
+class TierMergeService {
+  projectPath;
+  sprintId;
+  tierTaskIds = new Map;
+  constructor(projectPath, sprintId) {
+    this.projectPath = projectPath;
+    this.sprintId = sprintId;
+  }
+  registerTierTasks(tasks2) {
+    for (const task of tasks2) {
+      const tier = task.tier ?? 0;
+      const existing = this.tierTaskIds.get(tier);
+      if (existing) {
+        existing.push(task.id);
+      } else {
+        this.tierTaskIds.set(tier, [task.id]);
+      }
+    }
+  }
+  tierBranchName(tier) {
+    const suffix = this.sprintId ? `-${this.sprintId.slice(0, 8)}` : "";
+    return `${TIER_BRANCH_PREFIX}-${tier}${suffix}`;
+  }
+  remoteBranchExists(branch) {
+    try {
+      import_node_child_process8.execFileSync("git", ["ls-remote", "--exit-code", "--heads", "origin", branch], {
+        cwd: this.projectPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return true;
+    } catch {
+      return false;
     }
-    if (this.contextTracker.hasContent()) {
-      this.currentSession.metadata.contextTracker = this.contextTracker.toJSON();
+  }
+  createMergeBranch(tier, baseBranch) {
+    const mergeBranchName = this.tierBranchName(tier);
+    try {
+      this.gitExec(["fetch", "origin"]);
+      const tierTaskBranches = this.findTierTaskBranches(tier);
+      if (tierTaskBranches.length === 0) {
+        console.log(c.dim(`   Tier ${tier}: no pushed task branches found, skipping merge branch creation`));
+        return null;
+      }
+      console.log(c.dim(`   Merging ${tierTaskBranches.length} branch(es) into ${mergeBranchName}: ${tierTaskBranches.join(", ")}`));
+      try {
+        this.gitExec(["branch", "-D", mergeBranchName]);
+      } catch {}
+      this.gitExec(["checkout", "-b", mergeBranchName, `origin/${baseBranch}`]);
+      for (const branch of tierTaskBranches) {
+        try {
+          this.gitExec(["merge", `origin/${branch}`, "--no-edit"]);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          console.log(c.error(`   Merge conflict merging ${branch} into ${mergeBranchName}: ${msg}`));
+          try {
+            this.gitExec(["merge", "--abort"]);
+          } catch {}
+        }
+      }
+      this.gitExec(["push", "-u", "origin", mergeBranchName, "--force"]);
+      this.gitExec(["checkout", baseBranch]);
+      return mergeBranchName;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.log(c.error(`Failed to create tier merge branch: ${msg}`));
+      try {
+        this.gitExec(["checkout", baseBranch]);
+      } catch {}
+      return null;
     }
-    this.history.saveSession(this.currentSession);
-    this.history.pruneSessions();
   }
-  reset() {
-    if (!this.currentSession) {
-      throw new Error("Session not initialized. Call initialize() first.");
+  findTierTaskBranches(tier) {
+    try {
+      const output = import_node_child_process8.execSync('git branch -r --list "origin/agent/*" --format="%(refname:short)"', { cwd: this.projectPath, encoding: "utf-8" }).trim();
+      if (!output)
+        return [];
+      const remoteBranches = output.split(`
+`).map((b) => b.replace("origin/", ""));
+      return remoteBranches.filter((branch) => {
+        const match = branch.match(/^agent\/([^-]+)/);
+        if (!match)
+          return false;
+        const taskIdPrefix = match[1];
+        return this.tierTaskIds.get(tier)?.some((id) => id.startsWith(taskIdPrefix) || taskIdPrefix.startsWith(id.slice(0, 8))) ?? false;
+      });
+    } catch {
+      return [];
     }
-    this.currentSession.messages = [];
-    this.currentSession.updatedAt = Date.now();
-    this.contextTracker.clear();
   }
-  startNewSession() {
-    this.currentSession = this.history.createNewSession(this.model, this.provider);
-    this.contextTracker.clear();
-    this.eventEmitter.emitSessionStarted({
-      model: this.model,
-      provider: this.provider
+  gitExec(args) {
+    return import_node_child_process8.execFileSync("git", args, {
+      cwd: this.projectPath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
     });
   }
-  end(success = true) {
-    this.eventEmitter.emitSessionEnded(success);
-  }
-  on(eventType, listener) {
-    this.eventEmitter.on(eventType, listener);
-    return this;
-  }
-  off(eventType, listener) {
-    this.eventEmitter.off(eventType, listener);
-    return this;
-  }
 }
-// src/orchestrator.ts
-var import_node_child_process7 = require("node:child_process");
-var import_node_fs9 = require("node:fs");
-var import_node_path11 = require("node:path");
-var import_node_url = require("node:url");
-var import_shared4 = require("@locusai/shared");
-var import_events4 = require("events");
-var MAX_AGENTS = 5;
 
-class AgentOrchestrator extends import_events4.EventEmitter {
+// src/orchestrator/index.ts
+class AgentOrchestrator extends import_events5.EventEmitter {
   client;
   config;
-  agents = new Map;
+  pool;
   isRunning = false;
   processedTasks = new Set;
   resolvedSprintId = null;
   worktreeManager = null;
-  heartbeatInterval = null;
   constructor(config) {
     super();
     this.config = config;
@@ -4405,9 +5028,10 @@ class AgentOrchestrator extends import_events4.EventEmitter {
       baseUrl: config.apiBase,
       token: config.apiKey
     });
-  }
-  get agentCount() {
-    return Math.min(Math.max(this.config.agentCount ?? 1, 1), MAX_AGENTS);
+    this.pool = new AgentPool(config);
+    this.pool.on("agent:spawned", (data) => this.emit("agent:spawned", data));
+    this.pool.on("agent:completed", (data) => this.emit("agent:completed", data));
+    this.pool.on("agent:stale", (data) => this.emit("agent:stale", data));
   }
   get useWorktrees() {
     return this.config.useWorktrees ?? true;
@@ -4451,6 +5075,28 @@ class AgentOrchestrator extends import_events4.EventEmitter {
       config: this.config,
       sprintId: this.resolvedSprintId
     });
+    this.printBanner();
+    const tasks2 = await this.getAvailableTasks();
+    if (tasks2.length === 0) {
+      console.log(c.dim("ℹ  No available tasks found in the backlog."));
+      return;
+    }
+    if (!this.preflightChecks(tasks2))
+      return;
+    if (this.useWorktrees) {
+      this.worktreeManager = new WorktreeManager(this.config.projectPath, {
+        cleanupPolicy: this.worktreeCleanupPolicy
+      });
+    }
+    this.pool.startHeartbeatMonitor();
+    const tierMerge = new TierMergeService(this.config.projectPath, this.resolvedSprintId);
+    tierMerge.registerTierTasks(tasks2);
+    const execution = new ExecutionStrategy(this.config, this.pool, tierMerge, this.resolvedSprintId, () => this.isRunning);
+    await execution.execute(tasks2);
+    console.log(`
+${c.success("✅ Orchestrator finished")}`);
+  }
+  printBanner() {
     console.log(`
 ${c.primary("\uD83E\uDD16 Locus Agent Orchestrator")}`);
     console.log(c.dim("----------------------------------------------"));
@@ -4458,7 +5104,7 @@ ${c.primary("\uD83E\uDD16 Locus Agent Orchestrator")}`);
     if (this.resolvedSprintId) {
       console.log(`${c.bold("Sprint:")} ${this.resolvedSprintId}`);
     }
-    console.log(`${c.bold("Agents:")} ${this.agentCount}`);
+    console.log(`${c.bold("Agents:")} ${this.pool.effectiveAgentCount}`);
     console.log(`${c.bold("Worktrees:")} ${this.useWorktrees ? "enabled" : "disabled"}`);
     if (this.useWorktrees) {
       console.log(`${c.bold("Cleanup policy:")} ${this.worktreeCleanupPolicy}`);
@@ -4467,154 +5113,16 @@ ${c.primary("\uD83E\uDD16 Locus Agent Orchestrator")}`);
     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;
-    }
-    if (tasks2.length > 0 && this.useWorktrees && !isGitAvailable()) {
+  }
+  preflightChecks(_tasks) {
+    if (this.useWorktrees && !isGitAvailable()) {
       console.log(c.error("git is not installed. Worktree isolation requires git. Install from https://git-scm.com/"));
-      return;
+      return false;
     }
-    if (tasks2.length > 0 && this.config.autoPush && !isGhAvailable(this.config.projectPath)) {
+    if (this.config.autoPush && !isGhAvailable(this.config.projectPath)) {
       console.log(c.warning("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/"));
     }
-    if (tasks2.length > 0 && this.useWorktrees) {
-      this.worktreeManager = new WorktreeManager(this.config.projectPath, {
-        cleanupPolicy: this.worktreeCleanupPolicy
-      });
-    }
-    this.startHeartbeatMonitor();
-    const agentsToSpawn = Math.min(this.agentCount, tasks2.length);
-    const SPAWN_DELAY_MS = 5000;
-    const spawnPromises = [];
-    for (let i = 0;i < agentsToSpawn; i++) {
-      if (i > 0) {
-        await this.sleep(SPAWN_DELAY_MS);
-      }
-      spawnPromises.push(this.spawnAgent(i));
-    }
-    await Promise.all(spawnPromises);
-    while (this.agents.size > 0 && this.isRunning) {
-      if (this.agents.size === 0) {
-        break;
-      }
-      await this.sleep(2000);
-    }
-    console.log(`
-${c.success("✅ Orchestrator finished")}`);
-  }
-  async spawnAgent(index) {
-    const agentId = `agent-${index}-${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 workerPath = this.resolveWorkerPath();
-    if (!workerPath) {
-      throw new Error("Worker file not found. Make sure the SDK is properly built and installed.");
-    }
-    const workerArgs = [
-      "--agent-id",
-      agentId,
-      "--workspace-id",
-      this.config.workspaceId,
-      "--api-url",
-      this.config.apiBase,
-      "--api-key",
-      this.config.apiKey,
-      "--project-path",
-      this.config.projectPath
-    ];
-    if (this.config.model) {
-      workerArgs.push("--model", this.config.model);
-    }
-    if (this.config.provider) {
-      workerArgs.push("--provider", this.config.provider);
-    }
-    if (this.resolvedSprintId) {
-      workerArgs.push("--sprint-id", this.resolvedSprintId);
-    }
-    if (this.useWorktrees) {
-      workerArgs.push("--use-worktrees");
-    }
-    if (this.config.autoPush) {
-      workerArgs.push("--auto-push");
-    }
-    const agentProcess = import_node_child_process7.spawn(process.execPath, [workerPath, ...workerArgs], {
-      stdio: ["pipe", "pipe", "pipe"],
-      detached: true,
-      env: {
-        ...process.env,
-        FORCE_COLOR: "1",
-        TERM: "xterm-256color",
-        LOCUS_WORKER: agentId,
-        LOCUS_WORKSPACE: this.config.workspaceId
-      }
-    });
-    agentState.process = agentProcess;
-    agentProcess.on("message", (msg) => {
-      if (msg.type === "stats") {
-        agentState.tasksCompleted = msg.tasksCompleted || 0;
-        agentState.tasksFailed = msg.tasksFailed || 0;
-      }
-      if (msg.type === "heartbeat") {
-        agentState.lastHeartbeat = new Date;
-      }
-    });
-    agentProcess.stdout?.on("data", (data) => {
-      process.stdout.write(data.toString());
-    });
-    agentProcess.stderr?.on("data", (data) => {
-      process.stderr.write(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 });
-  }
-  resolveWorkerPath() {
-    const currentModulePath = import_node_url.fileURLToPath("file:///home/runner/work/locusai/locusai/packages/sdk/src/orchestrator.ts");
-    const currentModuleDir = import_node_path11.dirname(currentModulePath);
-    const potentialPaths = [
-      import_node_path11.join(currentModuleDir, "agent", "worker.js"),
-      import_node_path11.join(currentModuleDir, "worker.js"),
-      import_node_path11.join(currentModuleDir, "agent", "worker.ts")
-    ];
-    return potentialPaths.find((p) => import_node_fs9.existsSync(p));
-  }
-  startHeartbeatMonitor() {
-    this.heartbeatInterval = setInterval(() => {
-      const now = Date.now();
-      for (const [agentId, agent] of this.agents.entries()) {
-        if (agent.status === "WORKING" && now - agent.lastHeartbeat.getTime() > import_shared4.STALE_AGENT_TIMEOUT_MS) {
-          console.log(c.error(`Agent ${agentId} is stale (no heartbeat for 10 minutes). Killing.`));
-          if (agent.process && !agent.process.killed) {
-            this.killProcessTree(agent.process);
-          }
-          this.emit("agent:stale", { agentId });
-        }
-      }
-    }, 60000);
+    return true;
   }
   async getAvailableTasks() {
     try {
@@ -4626,16 +5134,16 @@ ${agentId} finished (exit code: ${code})`);
     }
   }
   async assignTaskToAgent(agentId) {
-    const agent = this.agents.get(agentId);
+    const agent = this.pool.get(agentId);
     if (!agent)
       return null;
     try {
       const tasks2 = await this.getAvailableTasks();
       const priorityOrder = [
-        import_shared4.TaskPriority.CRITICAL,
-        import_shared4.TaskPriority.HIGH,
-        import_shared4.TaskPriority.MEDIUM,
-        import_shared4.TaskPriority.LOW
+        import_shared6.TaskPriority.CRITICAL,
+        import_shared6.TaskPriority.HIGH,
+        import_shared6.TaskPriority.MEDIUM,
+        import_shared6.TaskPriority.LOW
       ];
       let task = tasks2.sort((a, b) => priorityOrder.indexOf(a.priority) - priorityOrder.indexOf(b.priority))[0];
       if (!task && tasks2.length > 0) {
@@ -4659,7 +5167,7 @@ ${agentId} finished (exit code: ${code})`);
   async completeTask(taskId, agentId, summary) {
     try {
       await this.client.tasks.update(taskId, this.config.workspaceId, {
-        status: import_shared4.TaskStatus.IN_REVIEW
+        status: import_shared6.TaskStatus.IN_REVIEW
       });
       if (summary) {
         await this.client.tasks.addComment(taskId, this.config.workspaceId, {
@@ -4670,7 +5178,7 @@ ${summary}`
         });
       }
       this.processedTasks.add(taskId);
-      const agent = this.agents.get(agentId);
+      const agent = this.pool.get(agentId);
       if (agent) {
         agent.tasksCompleted += 1;
         agent.currentTaskId = null;
@@ -4684,14 +5192,14 @@ ${summary}`
   async failTask(taskId, agentId, error) {
     try {
       await this.client.tasks.update(taskId, this.config.workspaceId, {
-        status: import_shared4.TaskStatus.BACKLOG,
+        status: import_shared6.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);
+      const agent = this.pool.get(agentId);
       if (agent) {
         agent.tasksFailed += 1;
         agent.currentTaskId = null;
@@ -4708,36 +5216,10 @@ ${summary}`
     this.emit("stopped", { timestamp: new Date });
   }
   stopAgent(agentId) {
-    const agent = this.agents.get(agentId);
-    if (!agent)
-      return false;
-    if (agent.process && !agent.process.killed) {
-      this.killProcessTree(agent.process);
-    }
-    return true;
-  }
-  killProcessTree(proc) {
-    if (!proc.pid || proc.killed)
-      return;
-    try {
-      process.kill(-proc.pid, "SIGTERM");
-    } catch {
-      try {
-        proc.kill("SIGTERM");
-      } catch {}
-    }
+    return this.pool.stopAgent(agentId);
   }
   async cleanup() {
-    if (this.heartbeatInterval) {
-      clearInterval(this.heartbeatInterval);
-      this.heartbeatInterval = null;
-    }
-    for (const [agentId, agent] of this.agents.entries()) {
-      if (agent.process && !agent.process.killed) {
-        console.log(`Killing agent: ${agentId}`);
-        this.killProcessTree(agent.process);
-      }
-    }
+    this.pool.shutdown();
     if (this.worktreeManager) {
       try {
         if (this.worktreeCleanupPolicy === "auto") {
@@ -4755,31 +5237,27 @@ ${summary}`
         console.log(c.dim("Could not clean up some worktrees"));
       }
     }
-    this.agents.clear();
   }
   getStats() {
+    const poolStats = this.pool.getStats();
     return {
-      activeAgents: this.agents.size,
-      agentCount: this.agentCount,
+      ...poolStats,
       useWorktrees: this.useWorktrees,
-      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)
+      processedTasks: this.processedTasks.size
     };
   }
   getAgentStates() {
-    return Array.from(this.agents.values());
-  }
-  sleep(ms) {
-    return new Promise((resolve3) => setTimeout(resolve3, ms));
+    return this.pool.getAll();
   }
 }
 // src/planning/plan-manager.ts
+init_config();
+init_knowledge_base();
 var import_node_fs10 = require("node:fs");
 var import_node_path12 = require("node:path");
 
 // src/planning/sprint-plan.ts
-var import_shared5 = require("@locusai/shared");
+var import_shared7 = require("@locusai/shared");
 function sprintPlanToMarkdown(plan) {
   const lines = [];
   lines.push(`# Sprint Plan: ${plan.name}`);
@@ -4801,23 +5279,32 @@ function sprintPlanToMarkdown(plan) {
   }
   lines.push(`## Tasks (${plan.tasks.length})`);
   lines.push("");
-  for (const task of plan.tasks) {
-    lines.push(`### ${task.index}. ${task.title}`);
-    lines.push(`- **Role:** ${task.assigneeRole}`);
-    lines.push(`- **Priority:** ${task.priority}`);
-    lines.push(`- **Complexity:** ${"█".repeat(task.complexity)}${"░".repeat(5 - task.complexity)} (${task.complexity}/5)`);
-    if (task.labels.length > 0) {
-      lines.push(`- **Labels:** ${task.labels.join(", ")}`);
-    }
-    lines.push("");
-    lines.push(task.description);
+  const maxTier = Math.max(0, ...plan.tasks.map((t) => t.tier ?? 0));
+  for (let tier = 0;tier <= maxTier; tier++) {
+    const tierTasks = plan.tasks.filter((t) => (t.tier ?? 0) === tier);
+    if (tierTasks.length === 0)
+      continue;
+    lines.push(`### Tier ${tier}${tier === 0 ? " (Foundation)" : ""}`);
+    lines.push(tier === 0 ? "_These tasks run first and must complete before higher tiers start._" : `_These tasks run in parallel after Tier ${tier - 1} completes._`);
     lines.push("");
-    if (task.acceptanceCriteria.length > 0) {
-      lines.push(`**Acceptance Criteria:**`);
-      for (const ac of task.acceptanceCriteria) {
-        lines.push(`- [ ] ${ac}`);
+    for (const task of tierTasks) {
+      lines.push(`#### ${task.index}. ${task.title}`);
+      lines.push(`- **Role:** ${task.assigneeRole}`);
+      lines.push(`- **Priority:** ${task.priority}`);
+      lines.push(`- **Complexity:** ${"█".repeat(task.complexity)}${"░".repeat(5 - task.complexity)} (${task.complexity}/5)`);
+      if (task.labels.length > 0) {
+        lines.push(`- **Labels:** ${task.labels.join(", ")}`);
       }
       lines.push("");
+      lines.push(task.description);
+      lines.push("");
+      if (task.acceptanceCriteria.length > 0) {
+        lines.push(`**Acceptance Criteria:**`);
+        for (const ac of task.acceptanceCriteria) {
+          lines.push(`- [ ] ${ac}`);
+        }
+        lines.push("");
+      }
     }
   }
   if (plan.risks.length > 0) {
@@ -4838,12 +5325,13 @@ function plannedTasksToCreatePayloads(plan, sprintId) {
   return plan.tasks.map((task) => ({
     title: task.title,
     description: task.description,
-    status: import_shared5.TaskStatus.BACKLOG,
+    status: import_shared7.TaskStatus.BACKLOG,
     assigneeRole: task.assigneeRole,
     priority: task.priority,
     labels: task.labels,
     sprintId,
     order: task.index * 10,
+    tier: task.tier,
     acceptanceChecklist: task.acceptanceCriteria.map((text, i) => ({
       id: `ac-${i + 1}`,
       text,
@@ -4867,7 +5355,8 @@ function parseSprintPlanFromAI(raw, directive) {
     priority: t.priority || "MEDIUM",
     complexity: t.complexity || 3,
     acceptanceCriteria: t.acceptanceCriteria || [],
-    labels: t.labels || []
+    labels: t.labels || [],
+    tier: typeof t.tier === "number" ? t.tier : 0
   }));
   return {
     id,
@@ -4956,9 +5445,12 @@ class PlanManager {
     this.save(plan);
     const kb = new KnowledgeBase(this.projectPath);
     kb.updateProgress({
-      type: "sprint_started",
-      title: plan.name,
-      details: `${tasks2.length} tasks created from planning meeting. Sprint goal: ${plan.goal}`
+      role: "user",
+      content: `Start sprint: ${plan.name}`
+    });
+    kb.updateProgress({
+      role: "assistant",
+      content: `Sprint started with ${tasks2.length} tasks. Goal: ${plan.goal}`
     });
     return { sprint, tasks: tasks2 };
   }
@@ -5021,6 +5513,8 @@ class PlanManager {
   }
 }
 // src/planning/planning-meeting.ts
+init_config();
+init_knowledge_base();
 var import_node_fs11 = require("node:fs");
 
 // src/planning/agents/architect.ts
@@ -5109,13 +5603,16 @@ You are a combined Architect, Senior Engineer, and Sprint Planner performing a F
 
 ## Context
 
-In this system, each task is executed by an independent AI agent that:
-- Works on its own git branch (worktree)
-- Has NO knowledge of what other agents are working on
-- Cannot see changes made by other concurrent agents
-- Its branch will be merged into main after completion
+In this system, tasks are organized into execution **tiers** (0, 1, 2, ...):
+- All tasks within the same tier run IN PARALLEL on separate git branches (worktrees)
+- Agents within a tier have NO knowledge of what other agents in that tier are doing
+- After ALL tasks in tier N complete and merge, tier N+1 starts
+- Tier N+1 branches are created FROM the merged tier N result, so they can see tier N's work
 
-This means that if two tasks modify the same file, add the same dependency, or introduce the same config variable — they WILL cause merge conflicts and duplicated code.
+This means:
+- Two tasks in the SAME tier that modify the same file WILL cause merge conflicts
+- Two tasks in DIFFERENT tiers are safe — the later tier sees the earlier tier's merged output
+- Tier assignment is critical: foundational work must be in tier 0, dependent work in higher tiers
 
 ## CEO Directive
 > ${input.directive}
@@ -5139,29 +5636,37 @@ ${input.sprintOrganizerOutput}
 
 Go through EACH pair of tasks and check for:
 
-### 1. File Overlap Analysis
+### 1. File Overlap Analysis (WITHIN the same tier)
 For each task, list the files it will likely modify. Then check:
-- Do any two tasks modify the same file? (e.g., app.module.ts, configuration.ts, package.json, shared DTOs)
-- If yes: MERGE those tasks or move shared changes to a foundational task
+- Do any two tasks **in the same tier** modify the same file? (e.g., app.module.ts, configuration.ts, package.json, shared DTOs)
+- If yes: MERGE those tasks, move them to different tiers, or move shared changes to a foundational task in a lower tier
+- Note: tasks in different tiers are safe because higher tiers branch from merged lower-tier results
 
-### 2. Duplicated Work Detection
-Check if multiple tasks:
+### 2. Duplicated Work Detection (WITHIN the same tier)
+Check if multiple tasks **in the same tier**:
 - Add the same environment variable or config field
 - Install or configure the same dependency
 - Register the same module or provider
 - Create the same helper function, guard, interceptor, or middleware
 - Add the same import to a shared file
-If yes: consolidate into ONE task
+If yes: consolidate into ONE task or move the shared work to a lower tier
 
 ### 3. Self-Containment Validation
 For each task, verify:
 - Does it include ALL config/env changes it needs?
 - Does it include ALL module registrations it needs?
 - Does it include ALL dependency installations it needs?
-- Can it be completed without ANY output from concurrent tasks?
+- Can it be completed without ANY output from tasks in the SAME tier? (It CAN depend on lower-tier tasks that are already merged)
+
+### 4. Tier Assignment Validation
+Verify tier assignments are correct:
+- Foundational tasks (schemas, config, shared code) MUST be in tier 0
+- Tasks that depend on another task's output must be in a HIGHER tier
+- Tasks in the same tier must be truly independent of each other
+- No circular dependencies between tiers
 
-### 4. Merge Conflict Risk Zones
-Identify the highest-risk files (files that multiple tasks might touch) and ensure only ONE task modifies each.
+### 5. Merge Conflict Risk Zones
+Identify the highest-risk files (files that multiple same-tier tasks might touch) and ensure only ONE task per tier modifies each.
 
 ## Output Format
 
@@ -5171,10 +5676,10 @@ Your entire response must be a single JSON object — no text before it, no text
   "hasIssues": true | false,
   "issues": [
     {
-      "type": "file_overlap" | "duplicated_work" | "not_self_contained" | "merge_conflict_risk",
+      "type": "file_overlap" | "duplicated_work" | "not_self_contained" | "merge_conflict_risk" | "wrong_tier",
       "description": "string describing the specific issue",
       "affectedTasks": ["Task Title 1", "Task Title 2"],
-      "resolution": "string describing how to fix it (merge, move, consolidate)"
+      "resolution": "string describing how to fix it (merge, move to different tier, consolidate)"
     }
   ],
   "revisedPlan": {
@@ -5189,7 +5694,8 @@ Your entire response must be a single JSON object — no text before it, no text
         "priority": "CRITICAL | HIGH | MEDIUM | LOW",
         "labels": ["string"],
         "acceptanceCriteria": ["string"],
-        "complexity": 3
+        "complexity": 3,
+        "tier": 0
       }
     ],
     "risks": [
@@ -5203,11 +5709,14 @@ Your entire response must be a single JSON object — no text before it, no text
 }
 
 IMPORTANT:
-- If hasIssues is true, the revisedPlan MUST contain the corrected task list with issues resolved (tasks merged, duplicated work consolidated, etc.)
+- If hasIssues is true, the revisedPlan MUST contain the corrected task list with issues resolved (tasks merged, duplicated work consolidated, tier assignments fixed, etc.)
 - If hasIssues is false, the revisedPlan should be identical to the input plan (no changes needed)
 - The revisedPlan is ALWAYS required — it becomes the final plan
 - When merging tasks, combine their acceptance criteria and update descriptions to cover all consolidated work
-- Prefer fewer, larger, self-contained tasks over many small conflicting ones`;
+- Prefer fewer, larger, self-contained tasks over many small conflicting ones
+- Every task MUST have a "tier" field (integer >= 0)
+- tier 0 = foundational (runs first), tier 1 = depends on tier 0, tier 2 = depends on tier 1, etc.
+- Tasks within the same tier run in parallel — they MUST NOT conflict with each other`;
   return prompt;
 }
 
@@ -5239,13 +5748,16 @@ Produce the final sprint plan:
 1. **Sprint Name** — A concise, memorable name for this sprint (e.g., "User Authentication", "Payment Integration")
 2. **Sprint Goal** — One paragraph describing what this sprint delivers
 3. **Task Ordering** — Final ordering so that foundational work comes first. The position in the array IS the execution order — task at index 0 runs first, index 1 runs second, etc.
-4. **Duration Estimate** — How many days this sprint will take with 2-3 agents working in parallel
-5. **Final Task List** — Each task with all fields filled in, ordered by execution priority
+4. **Tier Assignment** — Assign each task an execution tier (integer, starting at 0). Tasks within the same tier run IN PARALLEL on separate git branches. Tasks in tier N+1 only start AFTER all tier N tasks are complete and merged. Tier 0 = foundational tasks (config, schemas, shared code). Higher tiers build on lower tier outputs.
+5. **Duration Estimate** — How many days this sprint will take with 2-3 agents working in parallel
+6. **Final Task List** — Each task with all fields filled in, ordered by execution priority
 
 Guidelines:
 - The order of tasks in the array determines execution order. Tasks are dispatched sequentially from first to last.
-- Foundation tasks (schemas, config, shared code) must appear before tasks that build on them
-- Group related tasks together when possible
+- Foundation tasks (schemas, config, shared code) must appear before tasks that build on them AND must be in tier 0
+- Tasks within the same tier MUST be truly independent — no shared file modifications, no dependencies between them
+- Tasks that depend on outputs from other tasks must be in a higher tier than those dependencies
+- Group related independent tasks in the same tier for maximum parallelism
 - Ensure acceptance criteria are specific and testable
 - Keep the sprint focused — if it's too large (>12 tasks), consider reducing scope
 
@@ -5255,7 +5767,7 @@ Before finalizing, validate that EVERY task is fully self-contained and conflict
 
 1. **No two tasks should modify the same file.** If they do, merge them or restructure so shared changes live in one foundational task.
 2. **No duplicated work.** Each env var, config field, dependency, module import, or helper function must be introduced by exactly ONE task.
-3. **Each task is independently executable.** An agent working on task N must be able to complete it without knowing what tasks N-1 or N+1 are doing. The only exception is foundational tasks that are merged BEFORE dependent tasks start.
+3. **Each task is independently executable within its tier.** An agent working on a task must be able to complete it without knowing what other tasks in the same tier are doing. Tasks CAN depend on lower-tier tasks since those are merged before the current tier starts.
 4. **Prefer fewer, larger self-contained tasks over many small overlapping ones.** Do not split a task if the parts would conflict with each other.
 
 ## Output Format
@@ -5274,7 +5786,8 @@ Your entire response must be a single JSON object — no text before it, no text
       "priority": "CRITICAL | HIGH | MEDIUM | LOW",
       "labels": ["string"],
       "acceptanceCriteria": ["string"],
-      "complexity": 3
+      "complexity": 3,
+      "tier": 0
     }
   ],
   "risks": [
@@ -5284,7 +5797,14 @@ Your entire response must be a single JSON object — no text before it, no text
       "severity": "low | medium | high"
     }
   ]
-}`;
+}
+
+IMPORTANT about tiers:
+- tier 0 = foundational tasks (run first, merged before anything else)
+- tier 1 = tasks that depend on tier 0 outputs (run in parallel after tier 0 merges)
+- tier 2 = tasks that depend on tier 1 outputs (run in parallel after tier 1 merges)
+- Tasks within the same tier run in parallel on separate branches — they MUST NOT conflict
+- Every task MUST have a "tier" field (integer >= 0)`;
   return prompt;
 }
 
@@ -5453,3 +5973,10 @@ class PlanningMeeting {
     }
   }
 }
+// src/index-node.ts
+init_knowledge_base();
+init_colors();
+
+// src/worktree/index.ts
+init_worktree_config();
+init_worktree_manager();