@locusai/sdk 0.16.2 → 0.18.1

package/dist/agent/worker.js

@@ -1,2792 +0,0 @@
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __moduleCache = /* @__PURE__ */ new WeakMap;
-var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-
-// src/events.ts
-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 {
-  api;
-  emitter;
-  constructor(api, emitter) {
-    this.api = api;
-    this.emitter = emitter;
-  }
-}
-
-// src/modules/auth.ts
-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
-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
-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
-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
-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
-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, 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
-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/discussion/discussion-types.ts
-var import_zod, DiscussionMessageSchema, DiscussionInsightSchema, DiscussionSchema;
-var init_discussion_types = __esm(() => {
-  import_zod = require("zod");
-  DiscussionMessageSchema = import_zod.z.object({
-    role: import_zod.z.enum(["user", "assistant"]),
-    content: import_zod.z.string(),
-    timestamp: import_zod.z.number()
-  });
-  DiscussionInsightSchema = import_zod.z.object({
-    id: import_zod.z.string(),
-    type: import_zod.z.enum(["decision", "requirement", "idea", "concern", "learning"]),
-    title: import_zod.z.string(),
-    content: import_zod.z.string(),
-    tags: import_zod.z.array(import_zod.z.string()).default([]),
-    createdAt: import_zod.z.string()
-  });
-  DiscussionSchema = import_zod.z.object({
-    id: import_zod.z.string(),
-    title: import_zod.z.string(),
-    topic: import_zod.z.string(),
-    status: import_zod.z.enum(["active", "completed", "archived"]).default("active"),
-    messages: import_zod.z.array(DiscussionMessageSchema).default([]),
-    insights: import_zod.z.array(DiscussionInsightSchema).default([]),
-    createdAt: import_zod.z.string(),
-    updatedAt: import_zod.z.string(),
-    metadata: import_zod.z.object({
-      model: import_zod.z.string(),
-      provider: import_zod.z.string()
-    })
-  });
-});
-
-// 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,
-  DiscussionSchema: () => DiscussionSchema,
-  DiscussionMessageSchema: () => DiscussionMessageSchema,
-  DiscussionInsightSchema: () => DiscussionInsightSchema,
-  CiModule: () => CiModule,
-  AuthModule: () => AuthModule
-});
-module.exports = __toCommonJS(exports_src);
-
-class LocusClient {
-  api;
-  emitter;
-  auth;
-  tasks;
-  sprints;
-  workspaces;
-  organizations;
-  invitations;
-  docs;
-  ci;
-  constructor(config) {
-    this.emitter = new LocusEmitter;
-    this.api = import_axios.default.create({
-      baseURL: config.baseUrl,
-      timeout: config.timeout || 60000,
-      headers: {
-        "Content-Type": "application/json",
-        ...config.token ? { Authorization: `Bearer ${config.token}` } : {}
-      }
-    });
-    this.setupInterceptors();
-    this.auth = new AuthModule(this.api, this.emitter);
-    this.tasks = new TasksModule(this.api, this.emitter);
-    this.sprints = new SprintsModule(this.api, this.emitter);
-    this.workspaces = new WorkspacesModule(this.api, this.emitter);
-    this.organizations = new OrganizationsModule(this.api, this.emitter);
-    this.invitations = new InvitationsModule(this.api, this.emitter);
-    this.docs = new DocsModule(this.api, this.emitter);
-    this.ci = new CiModule(this.api, this.emitter);
-    if (config.retryOptions) {
-      this.setupRetryInterceptor(config.retryOptions);
-    }
-  }
-  setupRetryInterceptor(retryOptions) {
-    this.api.interceptors.response.use(undefined, async (error) => {
-      const config = error.config;
-      if (!config || !retryOptions) {
-        return Promise.reject(error);
-      }
-      config._retryCount = config._retryCount || 0;
-      const maxRetries = retryOptions.maxRetries ?? 3;
-      const shouldRetry = config._retryCount < maxRetries && (retryOptions.retryCondition ? retryOptions.retryCondition(error) : !error.response || error.response.status >= 500);
-      if (shouldRetry) {
-        config._retryCount++;
-        const delay = Math.min((retryOptions.initialDelay ?? 1000) * Math.pow(retryOptions.factor ?? 2, config._retryCount - 1), retryOptions.maxDelay ?? 5000);
-        await new Promise((resolve) => setTimeout(resolve, delay));
-        return this.api(config);
-      }
-      return Promise.reject(error);
-    });
-  }
-  setupInterceptors() {
-    this.api.interceptors.response.use((response) => {
-      if (response.data && typeof response.data === "object" && "data" in response.data) {
-        response.data = response.data.data;
-      }
-      return response;
-    }, (error) => {
-      const status = error.response?.status;
-      let message;
-      if (error.response?.data?.error?.message && typeof error.response.data.error.message === "string") {
-        message = error.response.data.error.message;
-      } else if (error.response?.data?.message && typeof error.response.data.message === "string") {
-        message = error.response.data.message;
-      } else if (error.message && typeof error.message === "string") {
-        message = error.message;
-      } else {
-        message = "An error occurred";
-      }
-      const enhancedError = new Error(message);
-      enhancedError.name = `HTTP${status || "Error"}`;
-      if (status === 401) {
-        this.emitter.emit("TOKEN_EXPIRED" /* TOKEN_EXPIRED */);
-        this.emitter.emit("AUTH_ERROR" /* AUTH_ERROR */, enhancedError);
-      } else {
-        this.emitter.emit("REQUEST_ERROR" /* REQUEST_ERROR */, enhancedError);
-      }
-      return Promise.reject(enhancedError);
-    });
-  }
-  setToken(token) {
-    if (token) {
-      this.api.defaults.headers.common.Authorization = `Bearer ${token}`;
-    } else {
-      delete this.api.defaults.headers.common.Authorization;
-    }
-  }
-}
-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();
-  init_discussion_types();
-  import_axios = __toESM(require("axios"));
-  init_events();
-  init_auth();
-  init_ci();
-  init_docs();
-  init_invitations();
-  init_organizations();
-  init_sprints();
-  init_tasks();
-  init_workspaces();
-});
-
-// src/core/config.ts
-function isValidModelForProvider(provider, model) {
-  return PROVIDER_MODELS[provider].includes(model);
-}
-function getModelsForProvider(provider) {
-  return PROVIDER_MODELS[provider];
-}
-function getLocusPath(projectPath, fileName) {
-  return import_node_path.join(projectPath, LOCUS_CONFIG.dir, LOCUS_CONFIG[fileName]);
-}
-function getAgentArtifactsPath(projectPath, agentId) {
-  const shortId = agentId.slice(-8);
-  return import_node_path.join(projectPath, LOCUS_CONFIG.dir, LOCUS_CONFIG.artifactsDir, shortId);
-}
-var import_node_path, PROVIDER, CLAUDE_MODELS, CODEX_MODELS, PROVIDER_MODELS, 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"
-  };
-  CLAUDE_MODELS = {
-    OPUS: "opus",
-    SONNET: "sonnet",
-    HAIKU: "haiku",
-    OPUS_PLAN: "opusplan",
-    CLAUDE_OPUS_4_6: "claude-opus-4-6",
-    CLAUDE_SONNET_4_5: "claude-sonnet-4-5-20250929",
-    CLAUDE_SONNET_4_6: "claude-sonnet-4-6",
-    CLAUDE_HAIKU_4_5: "claude-haiku-4-5-20251001"
-  };
-  CODEX_MODELS = {
-    GPT_5_3_CODEX: "gpt-5.3-codex",
-    GPT_5_3_CODEX_SPARK: "gpt-5.3-codex-spark",
-    GPT_5_CODEX_MINI: "gpt-5-codex-mini",
-    GPT_5_2_CODEX: "gpt-5.2-codex"
-  };
-  PROVIDER_MODELS = {
-    [PROVIDER.CLAUDE]: Object.values(CLAUDE_MODELS),
-    [PROVIDER.CODEX]: Object.values(CODEX_MODELS)
-  };
-  DEFAULT_MODEL = {
-    [PROVIDER.CLAUDE]: CLAUDE_MODELS.OPUS,
-    [PROVIDER.CODEX]: CODEX_MODELS.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",
-    learningsFile: "LEARNINGS.md",
-    artifactsDir: "artifacts",
-    documentsDir: "documents",
-    sessionsDir: "sessions",
-    reviewsDir: "reviews",
-    plansDir: "plans",
-    discussionsDir: "discussions"
-  };
-  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 - Discussions (AI discussion sessions)",
-    ".locus/discussions/",
-    "",
-    "# Locus AI - Settings (contains API key, telegram config, etc.)",
-    ".locus/settings.json",
-    "",
-    "# Locus AI - Configuration (contains project context, etc.)",
-    ".locus/config.json"
-  ];
-});
-
-// src/utils/colors.ts
-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
-function getNvmNodeBinDir() {
-  const nvmDir = process.env.NVM_DIR || import_node_path2.join(import_node_os.homedir(), ".nvm");
-  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;
-  }
-  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 {}
-  }
-  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 = [];
-  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 = {}) {
-  const env = {
-    ...process.env,
-    ...overrides,
-    PATH: getAugmentedPath()
-  };
-  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-stream-parser.ts
-class ClaudeStreamParser {
-  activeTools = new Map;
-  parseLineToChunk(line) {
-    if (!line.trim())
-      return null;
-    try {
-      const item = JSON.parse(line);
-      return this.processItemToChunk(item);
-    } catch {
-      return null;
-    }
-  }
-  parseLine(line, log) {
-    if (!line.trim())
-      return null;
-    try {
-      const item = JSON.parse(line);
-      return this.processItem(item, log);
-    } catch {
-      return null;
-    }
-  }
-  processItemToChunk(item) {
-    if (item.type === "result") {
-      return { type: "result", content: item.result || "" };
-    }
-    if (item.type === "stream_event" && item.event) {
-      return this.handleEventToChunk(item.event);
-    }
-    return null;
-  }
-  handleEventToChunk(event) {
-    const { type, delta, content_block, index } = event;
-    if (type === "content_block_delta" && delta?.type === "text_delta") {
-      return { type: "text_delta", content: delta.text || "" };
-    }
-    if (type === "content_block_delta" && delta?.type === "input_json_delta" && delta.partial_json !== undefined && index !== undefined) {
-      const activeTool = this.activeTools.get(index);
-      if (activeTool) {
-        activeTool.parameterJson += delta.partial_json;
-      }
-      return null;
-    }
-    if (type === "content_block_start" && content_block) {
-      if (content_block.type === "tool_use" && content_block.name) {
-        if (index !== undefined) {
-          this.activeTools.set(index, {
-            name: content_block.name,
-            id: content_block.id,
-            index,
-            parameterJson: "",
-            startTime: Date.now()
-          });
-        }
-        return {
-          type: "tool_use",
-          tool: content_block.name,
-          id: content_block.id
-        };
-      }
-      if (content_block.type === "thinking") {
-        return { type: "thinking" };
-      }
-    }
-    if (type === "content_block_stop" && index !== undefined) {
-      const activeTool = this.activeTools.get(index);
-      if (activeTool?.parameterJson) {
-        try {
-          const parameters = JSON.parse(activeTool.parameterJson);
-          return {
-            type: "tool_parameters",
-            tool: activeTool.name,
-            id: activeTool.id,
-            parameters
-          };
-        } catch {}
-      }
-      return null;
-    }
-    return null;
-  }
-  processItem(item, log) {
-    if (item.type === "result") {
-      return item.result || "";
-    }
-    if (item.type === "stream_event" && item.event) {
-      this.handleEvent(item.event, log);
-    }
-    return null;
-  }
-  handleEvent(event, log) {
-    const { type, content_block } = event;
-    if (type === "content_block_start" && content_block) {
-      if (content_block.type === "tool_use" && content_block.name) {
-        log?.(`
-${c.primary("[Claude]")} ${c.bold(`Running ${content_block.name}...`)}
-`, "info");
-      }
-    }
-  }
-}
-var init_claude_stream_parser = __esm(() => {
-  init_colors();
-});
-
-// src/ai/claude-runner.ts
-class ClaudeRunner {
-  model;
-  log;
-  projectPath;
-  eventEmitter;
-  currentToolName;
-  activeProcess = null;
-  aborted = false;
-  timeoutMs;
-  constructor(projectPath, model = DEFAULT_MODEL[PROVIDER.CLAUDE], log, timeoutMs) {
-    this.model = model;
-    this.log = log;
-    this.projectPath = import_node_path3.resolve(projectPath);
-    this.timeoutMs = timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  }
-  setEventEmitter(emitter) {
-    this.eventEmitter = emitter;
-  }
-  abort() {
-    if (this.activeProcess && !this.activeProcess.killed) {
-      this.aborted = true;
-      this.activeProcess.kill("SIGTERM");
-      this.activeProcess = null;
-    }
-  }
-  async run(prompt) {
-    const maxRetries = 3;
-    let lastError = null;
-    for (let attempt = 1;attempt <= maxRetries; attempt++) {
-      try {
-        return await this.withTimeout(this.executeRun(prompt));
-      } catch (error) {
-        const err = error;
-        lastError = err;
-        const isLastAttempt = attempt === maxRetries;
-        if (err.message.includes("timed out")) {
-          throw err;
-        }
-        if (!isLastAttempt) {
-          const delay = Math.pow(2, attempt) * 1000;
-          this.log?.(`Claude CLI attempt ${attempt} failed: ${err.message}. Retrying in ${delay}ms...`, "warn");
-          await new Promise((resolve2) => setTimeout(resolve2, delay));
-        }
-      }
-    }
-    throw lastError || new Error("Claude CLI failed after multiple attempts");
-  }
-  withTimeout(promise) {
-    if (this.timeoutMs <= 0)
-      return promise;
-    return new Promise((resolve2, reject) => {
-      const timer = setTimeout(() => {
-        this.abort();
-        reject(new Error(`Claude CLI execution timed out after ${Math.round(this.timeoutMs / 60000)} minutes`));
-      }, this.timeoutMs);
-      promise.then((value) => {
-        clearTimeout(timer);
-        resolve2(value);
-      }, (err) => {
-        clearTimeout(timer);
-        reject(err);
-      });
-    });
-  }
-  buildCliArgs() {
-    const args = [
-      "--print",
-      "--output-format",
-      "stream-json",
-      "--verbose",
-      "--dangerously-skip-permissions",
-      "--no-session-persistence",
-      "--include-partial-messages",
-      "--model",
-      this.model
-    ];
-    return args;
-  }
-  async* runStream(prompt) {
-    this.aborted = false;
-    const parser = new ClaudeStreamParser;
-    const args = this.buildCliArgs();
-    const env = getAugmentedEnv({
-      FORCE_COLOR: "1",
-      TERM: "xterm-256color"
-    });
-    this.eventEmitter?.emitSessionStarted({
-      model: this.model,
-      provider: "claude"
-    });
-    this.eventEmitter?.emitPromptSubmitted(prompt, prompt.length > 500);
-    const claude = import_node_child_process.spawn("claude", args, {
-      cwd: this.projectPath,
-      stdio: ["pipe", "pipe", "pipe"],
-      env
-    });
-    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);
-      if (chunk.type === "thinking") {
-        isThinking = true;
-      } else if (chunk.type === "text_delta" || chunk.type === "tool_use") {
-        if (isThinking) {
-          this.eventEmitter?.emitThinkingStoped();
-          isThinking = false;
-        }
-      }
-      if (chunk.type === "text_delta") {
-        finalContent += chunk.content;
-      }
-      if (resolveChunk) {
-        const resolve2 = resolveChunk;
-        resolveChunk = null;
-        resolve2(chunk);
-      } else {
-        chunkQueue.push(chunk);
-      }
-    };
-    const signalEnd = () => {
-      processEnded = true;
-      if (resolveChunk) {
-        resolveChunk(null);
-        resolveChunk = null;
-      }
-    };
-    claude.stdout.on("data", (data) => {
-      buffer += data.toString();
-      const lines = buffer.split(`
-`);
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        const chunk = parser.parseLineToChunk(line);
-        if (chunk) {
-          if (chunk.type === "result") {
-            lastResultContent = chunk.content;
-          }
-          enqueueChunk(chunk);
-        }
-      }
-    });
-    claude.stderr.on("data", (data) => {
-      const chunk = data.toString();
-      stderrBuffer += chunk;
-      stderrFull += chunk;
-      const lines = stderrBuffer.split(`
-`);
-      stderrBuffer = lines.pop() || "";
-      for (const line of lines) {
-        if (!this.shouldSuppressLine(line)) {
-          process.stderr.write(`${line}
-`);
-        }
-      }
-    });
-    claude.on("error", (err) => {
-      errorMessage = `Failed to start Claude CLI: ${err.message}. Please ensure the 'claude' command is available in your PATH.`;
-      this.eventEmitter?.emitErrorOccurred(errorMessage, "SPAWN_ERROR");
-      signalEnd();
-    });
-    claude.on("close", (code) => {
-      this.activeProcess = null;
-      if (stderrBuffer && !this.shouldSuppressLine(stderrBuffer)) {
-        process.stderr.write(`${stderrBuffer}
-`);
-      }
-      if (code !== 0 && !errorMessage && !this.aborted) {
-        const detail = stderrFull.trim() || lastResultContent.trim();
-        errorMessage = this.createExecutionError(code, detail).message;
-        this.eventEmitter?.emitErrorOccurred(errorMessage, `EXIT_${code}`);
-      }
-      signalEnd();
-    });
-    claude.stdin.write(prompt);
-    claude.stdin.end();
-    while (true) {
-      if (chunkQueue.length > 0) {
-        const chunk = chunkQueue.shift();
-        if (chunk)
-          yield chunk;
-      } else if (processEnded) {
-        if (errorMessage) {
-          yield { type: "error", error: errorMessage };
-          this.eventEmitter?.emitSessionEnded(false);
-        } else {
-          if (finalContent) {
-            this.eventEmitter?.emitResponseCompleted(finalContent);
-          }
-          this.eventEmitter?.emitSessionEnded(true);
-        }
-        break;
-      } else {
-        const chunk = await new Promise((resolve2) => {
-          resolveChunk = resolve2;
-        });
-        if (chunk === null) {
-          if (errorMessage) {
-            yield { type: "error", error: errorMessage };
-            this.eventEmitter?.emitSessionEnded(false);
-          } else {
-            if (finalContent) {
-              this.eventEmitter?.emitResponseCompleted(finalContent);
-            }
-            this.eventEmitter?.emitSessionEnded(true);
-          }
-          break;
-        }
-        yield chunk;
-      }
-    }
-  }
-  emitEventForChunk(chunk, isThinking) {
-    if (!this.eventEmitter)
-      return;
-    switch (chunk.type) {
-      case "text_delta":
-        this.eventEmitter.emitTextDelta(chunk.content);
-        break;
-      case "tool_use":
-        if (this.currentToolName) {
-          this.eventEmitter.emitToolCompleted(this.currentToolName);
-        }
-        this.currentToolName = chunk.tool;
-        this.eventEmitter.emitToolStarted(chunk.tool, chunk.id);
-        break;
-      case "thinking":
-        if (!isThinking) {
-          this.eventEmitter.emitThinkingStarted(chunk.content);
-        }
-        break;
-      case "result":
-        if (this.currentToolName) {
-          this.eventEmitter.emitToolCompleted(this.currentToolName);
-          this.currentToolName = undefined;
-        }
-        break;
-      case "error":
-        this.eventEmitter.emitErrorOccurred(chunk.error);
-        break;
-    }
-  }
-  executeRun(prompt) {
-    this.aborted = false;
-    const parser = new ClaudeStreamParser;
-    return new Promise((resolve2, reject) => {
-      const args = this.buildCliArgs();
-      const env = getAugmentedEnv({
-        FORCE_COLOR: "1",
-        TERM: "xterm-256color"
-      });
-      const claude = import_node_child_process.spawn("claude", args, {
-        cwd: this.projectPath,
-        stdio: ["pipe", "pipe", "pipe"],
-        env
-      });
-      this.activeProcess = claude;
-      let finalResult = "";
-      let errorOutput = "";
-      let buffer = "";
-      let stderrBuffer = "";
-      claude.stdout.on("data", (data) => {
-        buffer += data.toString();
-        const lines = buffer.split(`
-`);
-        buffer = lines.pop() || "";
-        for (const line of lines) {
-          const result = parser.parseLine(line, this.log);
-          if (result)
-            finalResult = result;
-        }
-      });
-      claude.stderr.on("data", (data) => {
-        const chunk = data.toString();
-        errorOutput += chunk;
-        stderrBuffer += chunk;
-        const lines = stderrBuffer.split(`
-`);
-        stderrBuffer = lines.pop() || "";
-        for (const line of lines) {
-          if (!this.shouldSuppressLine(line)) {
-            process.stderr.write(`${line}
-`);
-          }
-        }
-      });
-      claude.on("error", (err) => {
-        reject(new Error(`Failed to start Claude CLI: ${err.message}. Please ensure the 'claude' command is available in your PATH.`));
-      });
-      claude.on("close", (code) => {
-        this.activeProcess = null;
-        if (stderrBuffer && !this.shouldSuppressLine(stderrBuffer)) {
-          process.stderr.write(`${stderrBuffer}
-`);
-        }
-        process.stdout.write(`
-`);
-        if (code === 0 || this.aborted) {
-          resolve2(finalResult);
-        } else {
-          const detail = errorOutput.trim() || finalResult.trim();
-          reject(this.createExecutionError(code, detail));
-        }
-      });
-      claude.stdin.write(prompt);
-      claude.stdin.end();
-    });
-  }
-  shouldSuppressLine(line) {
-    const infoLogRegex = /^\[\d{2}:\d{2}:\d{2}\]\s\[.*?\]\sℹ\s*$/;
-    return infoLogRegex.test(line.trim());
-  }
-  createExecutionError(code, detail) {
-    const errorMsg = detail.trim();
-    const message = errorMsg ? `Claude CLI error (exit code ${code}): ${errorMsg}` : `Claude CLI exited with code ${code}. Please ensure the Claude CLI is installed and you are logged in.`;
-    return new Error(message);
-  }
-}
-var import_node_child_process, import_node_path3, DEFAULT_TIMEOUT_MS;
-var init_claude_runner = __esm(() => {
-  init_config();
-  init_resolve_bin();
-  init_claude_stream_parser();
-  import_node_child_process = require("node:child_process");
-  import_node_path3 = require("node:path");
-  DEFAULT_TIMEOUT_MS = 60 * 60 * 1000;
-});
-
-// src/ai/codex-runner.ts
-class CodexRunner {
-  projectPath;
-  model;
-  log;
-  reasoningEffort;
-  activeProcess = null;
-  aborted = false;
-  eventEmitter;
-  currentToolName;
-  timeoutMs;
-  constructor(projectPath, model = DEFAULT_MODEL[PROVIDER.CODEX], log, reasoningEffort, timeoutMs) {
-    this.projectPath = projectPath;
-    this.model = model;
-    this.log = log;
-    this.reasoningEffort = reasoningEffort;
-    this.timeoutMs = timeoutMs ?? DEFAULT_TIMEOUT_MS2;
-  }
-  setEventEmitter(emitter) {
-    this.eventEmitter = emitter;
-  }
-  abort() {
-    if (this.activeProcess && !this.activeProcess.killed) {
-      this.aborted = true;
-      this.activeProcess.kill("SIGTERM");
-      this.activeProcess = null;
-    }
-  }
-  async run(prompt) {
-    this.aborted = false;
-    const maxRetries = 3;
-    let lastError = null;
-    for (let attempt = 1;attempt <= maxRetries; attempt++) {
-      try {
-        return await this.withTimeout(this.executeRun(prompt));
-      } catch (error) {
-        lastError = error;
-        if (lastError.message.includes("timed out")) {
-          throw lastError;
-        }
-        if (attempt < maxRetries) {
-          const delay = Math.pow(2, attempt) * 1000;
-          this.log?.(`Codex CLI attempt ${attempt} failed: ${lastError.message}. Retrying in ${delay}ms...`, "warn");
-          await this.sleep(delay);
-        }
-      }
-    }
-    throw lastError || new Error("Codex CLI failed after multiple attempts");
-  }
-  withTimeout(promise) {
-    if (this.timeoutMs <= 0)
-      return promise;
-    return new Promise((resolve2, reject) => {
-      const timer = setTimeout(() => {
-        this.abort();
-        reject(new Error(`Codex CLI execution timed out after ${Math.round(this.timeoutMs / 60000)} minutes`));
-      }, this.timeoutMs);
-      promise.then((value) => {
-        clearTimeout(timer);
-        resolve2(value);
-      }, (err) => {
-        clearTimeout(timer);
-        reject(err);
-      });
-    });
-  }
-  async* runStream(prompt) {
-    const outputPath = import_node_path4.join(import_node_os2.tmpdir(), `locus-codex-${import_node_crypto.randomUUID()}.txt`);
-    const args = this.buildArgs(outputPath);
-    this.eventEmitter?.emitSessionStarted({
-      model: this.model,
-      provider: "codex"
-    });
-    this.eventEmitter?.emitPromptSubmitted(prompt, prompt.length > 500);
-    const codex = import_node_child_process2.spawn("codex", args, {
-      cwd: this.projectPath,
-      stdio: ["pipe", "pipe", "pipe"],
-      env: getAugmentedEnv(),
-      shell: false
-    });
-    this.activeProcess = codex;
-    let resolveChunk = null;
-    const chunkQueue = [];
-    let processEnded = false;
-    let errorMessage = "";
-    let finalOutput = "";
-    let finalContent = "";
-    let isThinking = false;
-    const enqueueChunk = (chunk) => {
-      this.emitEventForChunk(chunk, isThinking);
-      if (chunk.type === "thinking") {
-        isThinking = true;
-      } else if (chunk.type === "text_delta" || chunk.type === "tool_use") {
-        if (isThinking) {
-          this.eventEmitter?.emitThinkingStoped();
-          isThinking = false;
-        }
-      }
-      if (chunk.type === "text_delta") {
-        finalContent += chunk.content;
-      }
-      if (resolveChunk) {
-        const resolve2 = resolveChunk;
-        resolveChunk = null;
-        resolve2(chunk);
-      } else {
-        chunkQueue.push(chunk);
-      }
-    };
-    const signalEnd = () => {
-      processEnded = true;
-      if (resolveChunk) {
-        resolveChunk(null);
-        resolveChunk = null;
-      }
-    };
-    const processOutput = (data) => {
-      const msg = data.toString();
-      finalOutput += msg;
-      for (const rawLine of msg.split(`
-`)) {
-        const line = rawLine.trim();
-        if (!line)
-          continue;
-        if (/^thinking\b/i.test(line)) {
-          enqueueChunk({ type: "thinking", content: line });
-        } else if (/^[→•✓]/.test(line) || /^Plan update\b/.test(line)) {
-          enqueueChunk({
-            type: "tool_use",
-            tool: line.replace(/^[→•✓]\s*/, "")
-          });
-        }
-      }
-    };
-    codex.stdout.on("data", processOutput);
-    codex.stderr.on("data", (data) => {
-      finalOutput += data.toString();
-    });
-    codex.on("error", (err) => {
-      errorMessage = `Failed to start Codex CLI: ${err.message}. Ensure 'codex' is installed and available in PATH.`;
-      this.eventEmitter?.emitErrorOccurred(errorMessage, "SPAWN_ERROR");
-      signalEnd();
-    });
-    codex.on("close", (code) => {
-      this.activeProcess = null;
-      if (code === 0 || this.aborted) {
-        const result = this.readOutput(outputPath, finalOutput);
-        this.cleanupTempFile(outputPath);
-        if (result && finalContent.trim().length === 0) {
-          enqueueChunk({ type: "text_delta", content: result });
-        }
-        enqueueChunk({ type: "result", content: result });
-      } else {
-        this.cleanupTempFile(outputPath);
-        if (!errorMessage) {
-          errorMessage = this.createErrorFromOutput(code, finalOutput).message;
-          this.eventEmitter?.emitErrorOccurred(errorMessage, `EXIT_${code}`);
-        }
-      }
-      signalEnd();
-    });
-    codex.stdin.write(prompt);
-    codex.stdin.end();
-    while (true) {
-      if (chunkQueue.length > 0) {
-        const chunk = chunkQueue.shift();
-        if (chunk)
-          yield chunk;
-      } else if (processEnded) {
-        if (errorMessage) {
-          yield { type: "error", error: errorMessage };
-          this.eventEmitter?.emitSessionEnded(false);
-        } else {
-          if (finalContent) {
-            this.eventEmitter?.emitResponseCompleted(finalContent);
-          }
-          this.eventEmitter?.emitSessionEnded(true);
-        }
-        break;
-      } else {
-        const chunk = await new Promise((resolve2) => {
-          resolveChunk = resolve2;
-        });
-        if (chunk === null) {
-          if (errorMessage) {
-            yield { type: "error", error: errorMessage };
-            this.eventEmitter?.emitSessionEnded(false);
-          } else {
-            if (finalContent) {
-              this.eventEmitter?.emitResponseCompleted(finalContent);
-            }
-            this.eventEmitter?.emitSessionEnded(true);
-          }
-          break;
-        }
-        yield chunk;
-      }
-    }
-  }
-  emitEventForChunk(chunk, isThinking) {
-    if (!this.eventEmitter)
-      return;
-    switch (chunk.type) {
-      case "text_delta":
-        this.eventEmitter.emitTextDelta(chunk.content);
-        break;
-      case "tool_use":
-        if (this.currentToolName) {
-          this.eventEmitter.emitToolCompleted(this.currentToolName);
-        }
-        this.currentToolName = chunk.tool;
-        this.eventEmitter.emitToolStarted(chunk.tool);
-        break;
-      case "thinking":
-        if (!isThinking) {
-          this.eventEmitter.emitThinkingStarted(chunk.content);
-        }
-        break;
-      case "result":
-        if (this.currentToolName) {
-          this.eventEmitter.emitToolCompleted(this.currentToolName);
-          this.currentToolName = undefined;
-        }
-        break;
-      case "error":
-        this.eventEmitter.emitErrorOccurred(chunk.error);
-        break;
-    }
-  }
-  executeRun(prompt) {
-    return new Promise((resolve2, reject) => {
-      const outputPath = import_node_path4.join(import_node_os2.tmpdir(), `locus-codex-${import_node_crypto.randomUUID()}.txt`);
-      const args = this.buildArgs(outputPath);
-      const codex = import_node_child_process2.spawn("codex", args, {
-        cwd: this.projectPath,
-        stdio: ["pipe", "pipe", "pipe"],
-        env: getAugmentedEnv(),
-        shell: false
-      });
-      this.activeProcess = codex;
-      let output = "";
-      let errorOutput = "";
-      const handleOutput = (data) => {
-        const msg = data.toString();
-        output += msg;
-        this.streamToConsole(msg);
-      };
-      codex.stdout.on("data", handleOutput);
-      codex.stderr.on("data", (data) => {
-        const msg = data.toString();
-        errorOutput += msg;
-        this.streamToConsole(msg);
-      });
-      codex.on("error", (err) => {
-        reject(new Error(`Failed to start Codex CLI: ${err.message}. ` + `Ensure 'codex' is installed and available in PATH.`));
-      });
-      codex.on("close", (code) => {
-        this.activeProcess = null;
-        if (code === 0 || this.aborted) {
-          const result = this.readOutput(outputPath, output);
-          this.cleanupTempFile(outputPath);
-          resolve2(result);
-        } else {
-          this.cleanupTempFile(outputPath);
-          reject(this.createErrorFromOutput(code, errorOutput));
-        }
-      });
-      codex.stdin.write(prompt);
-      codex.stdin.end();
-    });
-  }
-  buildArgs(outputPath) {
-    const args = [
-      "exec",
-      "--full-auto",
-      "--skip-git-repo-check",
-      "--output-last-message",
-      outputPath
-    ];
-    if (this.model) {
-      args.push("--model", this.model);
-    }
-    if (this.reasoningEffort) {
-      args.push("-c", `model_reasoning_effort=${this.reasoningEffort}`);
-    }
-    args.push("-");
-    return args;
-  }
-  streamToConsole(chunk) {
-    for (const rawLine of chunk.split(`
-`)) {
-      const line = rawLine.trim();
-      if (line && this.shouldDisplay(line)) {
-        const formattedLine = "[Codex]: ".concat(line.replace(/\*/g, ""));
-        this.log?.(formattedLine, "info");
-      }
-    }
-  }
-  shouldDisplay(line) {
-    return /^Plan update\b/.test(line);
-  }
-  readOutput(outputPath, fallback) {
-    if (import_node_fs2.existsSync(outputPath)) {
-      try {
-        const text = import_node_fs2.readFileSync(outputPath, "utf-8").trim();
-        if (text)
-          return text;
-      } catch {}
-    }
-    return fallback.trim();
-  }
-  createErrorFromOutput(code, errorOutput) {
-    const detail = errorOutput.trim();
-    const message = detail ? `Codex CLI error (exit code ${code}): ${detail}` : `Codex CLI exited with code ${code}. ` + `Ensure Codex CLI is installed and you are logged in.`;
-    return new Error(message);
-  }
-  cleanupTempFile(path) {
-    try {
-      if (import_node_fs2.existsSync(path))
-        import_node_fs2.unlinkSync(path);
-    } catch {}
-  }
-  sleep(ms) {
-    return new Promise((resolve2) => setTimeout(resolve2, ms));
-  }
-}
-var import_node_child_process2, import_node_crypto, import_node_fs2, import_node_os2, import_node_path4, DEFAULT_TIMEOUT_MS2;
-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");
-  DEFAULT_TIMEOUT_MS2 = 60 * 60 * 1000;
-});
-
-// src/ai/factory.ts
-function createWorkerLogger(agentId, prefix) {
-  const tag = prefix ? `${prefix}:${agentId.slice(-8)}` : agentId.slice(-8);
-  return (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 icon = { info: "ℹ", success: "✓", warn: "⚠", error: "✗" }[level];
-    console.log(`${c.dim(`[${timestamp}]`)} ${c.bold(`[${tag}]`)} ${colorFn(`${icon} ${message}`)}`);
-  };
-}
-function createAiRunner(provider, config) {
-  const resolvedProvider = provider ?? PROVIDER.CLAUDE;
-  const model = config.model ?? DEFAULT_MODEL[resolvedProvider];
-  if (!isValidModelForProvider(resolvedProvider, model)) {
-    const validModels = getModelsForProvider(resolvedProvider);
-    throw new Error(`Model "${model}" is not valid for provider "${resolvedProvider}". ` + `Valid models: ${validModels.join(", ")}`);
-  }
-  switch (resolvedProvider) {
-    case PROVIDER.CODEX:
-      return new CodexRunner(config.projectPath, model, config.log, config.reasoningEffort ?? "high", config.timeoutMs);
-    default:
-      return new ClaudeRunner(config.projectPath, model, config.log, config.timeoutMs);
-  }
-}
-var noopLogger = () => {};
-var init_factory = __esm(() => {
-  init_config();
-  init_colors();
-  init_claude_runner();
-  init_codex_runner();
-});
-
-// src/git/git-utils.ts
-function isGitAvailable() {
-  try {
-    import_node_child_process3.execFileSync("git", ["--version"], {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function isGhAvailable(projectPath) {
-  try {
-    import_node_child_process3.execFileSync("gh", ["auth", "status"], {
-      cwd: projectPath,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getGhUsername() {
-  try {
-    const output = import_node_child_process3.execFileSync("gh", ["api", "user", "--jq", ".login"], {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    return output || null;
-  } catch {
-    return null;
-  }
-}
-function detectRemoteProvider(projectPath) {
-  const url = getRemoteUrl(projectPath);
-  if (!url)
-    return "unknown";
-  if (url.includes("github.com"))
-    return "github";
-  if (url.includes("gitlab.com") || url.includes("gitlab"))
-    return "gitlab";
-  if (url.includes("bitbucket.org"))
-    return "bitbucket";
-  return "unknown";
-}
-function getRemoteUrl(projectPath, remote = "origin") {
-  try {
-    return import_node_child_process3.execFileSync("git", ["remote", "get-url", remote], {
-      cwd: projectPath,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-  } catch {
-    return null;
-  }
-}
-function getCurrentBranch(projectPath) {
-  return import_node_child_process3.execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
-    cwd: projectPath,
-    encoding: "utf-8",
-    stdio: ["pipe", "pipe", "pipe"]
-  }).trim();
-}
-function getDefaultBranch(projectPath, remote = "origin") {
-  try {
-    const ref = import_node_child_process3.execFileSync("git", ["symbolic-ref", `refs/remotes/${remote}/HEAD`], {
-      cwd: projectPath,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    return ref.replace(`refs/remotes/${remote}/`, "");
-  } catch {
-    for (const candidate of ["main", "master"]) {
-      try {
-        import_node_child_process3.execFileSync("git", ["ls-remote", "--exit-code", "--heads", remote, candidate], {
-          cwd: projectPath,
-          encoding: "utf-8",
-          stdio: ["pipe", "pipe", "pipe"]
-        });
-        return candidate;
-      } catch {}
-    }
-    try {
-      return getCurrentBranch(projectPath);
-    } catch {
-      return "main";
-    }
-  }
-}
-var import_node_child_process3;
-var init_git_utils = __esm(() => {
-  import_node_child_process3 = require("node:child_process");
-});
-
-// src/agent/git-workflow.ts
-class GitWorkflow {
-  config;
-  log;
-  projectPath;
-  branchName = null;
-  baseBranch = null;
-  ghUsername;
-  constructor(config, log) {
-    this.config = config;
-    this.log = log;
-    this.projectPath = config.projectPath || process.cwd();
-    this.ghUsername = getGhUsername();
-    if (this.ghUsername) {
-      this.log(`GitHub user: ${this.ghUsername}`, "info");
-    }
-  }
-  createBranch(sprintId) {
-    const defaultBranch = getDefaultBranch(this.projectPath);
-    this.baseBranch = defaultBranch;
-    try {
-      this.gitExec(["checkout", defaultBranch]);
-      this.gitExec(["pull", "origin", defaultBranch]);
-    } catch {
-      this.log(`Could not pull latest from ${defaultBranch}, continuing with current state`, "warn");
-    }
-    const suffix = sprintId ? sprintId.slice(0, 8) : Date.now().toString(36);
-    this.branchName = `locus/${suffix}`;
-    try {
-      this.gitExec(["checkout", this.branchName]);
-    } catch {
-      this.log(`Branch ${this.branchName} does not exist, creating it`, "info");
-      this.gitExec(["checkout", "-b", this.branchName]);
-      this.log(`Created branch: ${this.branchName} (from ${defaultBranch})`, "success");
-    }
-    return this.branchName;
-  }
-  commitAndPush(task) {
-    if (!this.branchName) {
-      this.log("No branch created yet, skipping commit", "warn");
-      return { branch: null, pushed: false, pushFailed: false };
-    }
-    try {
-      const status = this.gitExec(["status", "--porcelain"]).trim();
-      if (!status) {
-        const baseBranchCommit = this.getBaseCommit();
-        const headCommit = this.gitExec(["rev-parse", "HEAD"]).trim();
-        if (baseBranchCommit && headCommit !== baseBranchCommit) {
-          return this.pushBranch();
-        }
-        this.log("No changes to commit for this task", "info");
-        return {
-          branch: this.branchName,
-          pushed: false,
-          pushFailed: false,
-          noChanges: true,
-          skipReason: "No changes were made for this task."
-        };
-      }
-      this.gitExec(["add", "-A"]);
-      const staged = this.gitExec(["diff", "--cached", "--name-only"]).trim();
-      if (!staged) {
-        this.log("All changes were ignored by .gitignore — nothing to commit", "warn");
-        return {
-          branch: this.branchName,
-          pushed: false,
-          pushFailed: false,
-          noChanges: true,
-          skipReason: "All changes were ignored by .gitignore."
-        };
-      }
-      this.log(`Staging ${staged.split(`
-`).length} file(s) for commit`, "info");
-      const trailers = [
-        `Task-ID: ${task.id}`,
-        `Agent: ${this.config.agentId}`,
-        "Co-authored-by: LocusAI <agent@locusai.team>"
-      ];
-      if (this.ghUsername) {
-        trailers.push(`Co-authored-by: ${this.ghUsername} <${this.ghUsername}@users.noreply.github.com>`);
-      }
-      const commitMessage = `feat(agent): ${task.title}
-
-${trailers.join(`
-`)}`;
-      this.gitExec(["commit", "-m", commitMessage]);
-      const hash = this.gitExec(["rev-parse", "HEAD"]).trim();
-      this.log(`Committed: ${hash.slice(0, 8)}`, "success");
-      return this.pushBranch();
-    } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : String(err);
-      this.log(`Git commit failed: ${errorMessage}`, "error");
-      return {
-        branch: this.branchName,
-        pushed: false,
-        pushFailed: true,
-        pushError: `Git commit/push failed: ${errorMessage}`
-      };
-    }
-  }
-  pushBranch() {
-    if (!this.branchName) {
-      return { branch: null, pushed: false, pushFailed: false };
-    }
-    try {
-      this.gitExec(["push", "-u", "origin", this.branchName]);
-      this.log(`Pushed ${this.branchName} to origin`, "success");
-      return { branch: this.branchName, pushed: true, pushFailed: false };
-    } catch (error) {
-      const msg = error instanceof Error ? error.message : String(error);
-      if (msg.includes("non-fast-forward") || msg.includes("[rejected]") || msg.includes("fetch first")) {
-        this.log(`Push rejected (non-fast-forward). Retrying with --force-with-lease.`, "warn");
-        try {
-          this.gitExec([
-            "push",
-            "--force-with-lease",
-            "-u",
-            "origin",
-            this.branchName
-          ]);
-          this.log(`Pushed ${this.branchName} to origin with --force-with-lease`, "success");
-          return { branch: this.branchName, pushed: true, pushFailed: false };
-        } catch (retryErr) {
-          const retryMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
-          this.log(`Git push retry failed: ${retryMsg}`, "error");
-          return {
-            branch: this.branchName,
-            pushed: false,
-            pushFailed: true,
-            pushError: retryMsg
-          };
-        }
-      }
-      this.log(`Git push failed: ${msg}`, "error");
-      return {
-        branch: this.branchName,
-        pushed: false,
-        pushFailed: true,
-        pushError: msg
-      };
-    }
-  }
-  createPullRequest(completedTasks, summaries) {
-    if (!this.branchName || !this.baseBranch) {
-      return { url: null, error: "No branch or base branch available." };
-    }
-    const provider = detectRemoteProvider(this.projectPath);
-    if (provider !== "github") {
-      return {
-        url: null,
-        error: `PR creation is only supported for GitHub repositories (detected: ${provider})`
-      };
-    }
-    if (!isGhAvailable(this.projectPath)) {
-      return {
-        url: null,
-        error: "GitHub CLI (gh) is not installed or not authenticated. Install from https://cli.github.com/"
-      };
-    }
-    const title = `[Locus] Sprint tasks (${completedTasks.length} task${completedTasks.length !== 1 ? "s" : ""})`;
-    const body = this.buildPrBody(completedTasks, summaries);
-    this.log(`Creating PR: ${title} (${this.branchName} → ${this.baseBranch})`, "info");
-    try {
-      const output = import_node_child_process4.execFileSync("gh", [
-        "pr",
-        "create",
-        "--title",
-        title,
-        "--body",
-        body,
-        "--base",
-        this.baseBranch,
-        "--head",
-        this.branchName
-      ], {
-        cwd: this.projectPath,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      }).trim();
-      this.log(`PR created: ${output}`, "success");
-      return { url: output };
-    } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : String(err);
-      this.log(`PR creation failed: ${errorMessage}`, "error");
-      return { url: null, error: errorMessage };
-    }
-  }
-  checkoutBaseBranch() {
-    if (!this.baseBranch)
-      return;
-    try {
-      this.gitExec(["checkout", this.baseBranch]);
-      this.log(`Checked out base branch: ${this.baseBranch}`, "info");
-    } catch (err) {
-      this.log(`Could not checkout base branch: ${err instanceof Error ? err.message : String(err)}`, "warn");
-    }
-  }
-  getBranchName() {
-    return this.branchName;
-  }
-  getBaseBranch() {
-    return this.baseBranch;
-  }
-  getBaseCommit() {
-    if (!this.baseBranch)
-      return null;
-    try {
-      return this.gitExec(["rev-parse", this.baseBranch]).trim();
-    } catch {
-      return null;
-    }
-  }
-  buildPrBody(completedTasks, summaries) {
-    const sections = [];
-    sections.push("## Completed Tasks");
-    sections.push("");
-    for (let i = 0;i < completedTasks.length; i++) {
-      const task = completedTasks[i];
-      sections.push(`### ${i + 1}. ${task.title}`);
-      sections.push(`Task ID: \`${task.id}\``);
-      if (summaries[i]) {
-        sections.push("");
-        sections.push(summaries[i]);
-      }
-      sections.push("");
-    }
-    sections.push("---");
-    sections.push(`*Created by Locus Agent \`${this.config.agentId.slice(-8)}\`*`);
-    return sections.join(`
-`);
-  }
-  gitExec(args) {
-    return import_node_child_process4.execFileSync("git", args, {
-      cwd: this.projectPath,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-  }
-}
-var import_node_child_process4;
-var init_git_workflow = __esm(() => {
-  init_git_utils();
-  import_node_child_process4 = require("node:child_process");
-});
-
-// src/discussion/discussion-manager.ts
-class DiscussionManager {
-  discussionsDir;
-  constructor(projectPath) {
-    this.discussionsDir = getLocusPath(projectPath, "discussionsDir");
-  }
-  create(topic, model, provider) {
-    this.ensureDir();
-    const now = new Date().toISOString();
-    const id = `disc-${Date.now()}`;
-    const discussion = {
-      id,
-      title: topic,
-      topic,
-      status: "active",
-      messages: [],
-      insights: [],
-      createdAt: now,
-      updatedAt: now,
-      metadata: { model, provider }
-    };
-    this.save(discussion);
-    return discussion;
-  }
-  save(discussion) {
-    this.ensureDir();
-    const jsonPath = import_node_path5.join(this.discussionsDir, `${discussion.id}.json`);
-    const mdPath = import_node_path5.join(this.discussionsDir, `summary-${discussion.id}.md`);
-    import_node_fs3.writeFileSync(jsonPath, JSON.stringify(discussion, null, 2), "utf-8");
-    import_node_fs3.writeFileSync(mdPath, this.toMarkdown(discussion), "utf-8");
-  }
-  load(id) {
-    this.ensureDir();
-    const filePath = import_node_path5.join(this.discussionsDir, `${id}.json`);
-    if (!import_node_fs3.existsSync(filePath)) {
-      return null;
-    }
-    try {
-      return JSON.parse(import_node_fs3.readFileSync(filePath, "utf-8"));
-    } catch {
-      return null;
-    }
-  }
-  list(status) {
-    this.ensureDir();
-    const files = import_node_fs3.readdirSync(this.discussionsDir).filter((f) => f.endsWith(".json"));
-    const discussions = [];
-    for (const file of files) {
-      try {
-        const discussion = JSON.parse(import_node_fs3.readFileSync(import_node_path5.join(this.discussionsDir, file), "utf-8"));
-        if (!status || discussion.status === status) {
-          discussions.push(discussion);
-        }
-      } catch {}
-    }
-    discussions.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
-    return discussions;
-  }
-  complete(id) {
-    const discussion = this.load(id);
-    if (!discussion) {
-      throw new Error(`Discussion not found: ${id}`);
-    }
-    discussion.status = "completed";
-    discussion.updatedAt = new Date().toISOString();
-    this.save(discussion);
-    return discussion;
-  }
-  archive(id) {
-    const discussion = this.load(id);
-    if (!discussion) {
-      throw new Error(`Discussion not found: ${id}`);
-    }
-    discussion.status = "archived";
-    discussion.updatedAt = new Date().toISOString();
-    this.save(discussion);
-  }
-  delete(id) {
-    this.ensureDir();
-    const jsonPath = import_node_path5.join(this.discussionsDir, `${id}.json`);
-    const mdPath = import_node_path5.join(this.discussionsDir, `summary-${id}.md`);
-    if (import_node_fs3.existsSync(jsonPath)) {
-      import_node_fs3.unlinkSync(jsonPath);
-    }
-    if (import_node_fs3.existsSync(mdPath)) {
-      import_node_fs3.unlinkSync(mdPath);
-    }
-  }
-  addMessage(id, role, content) {
-    const discussion = this.load(id);
-    if (!discussion) {
-      throw new Error(`Discussion not found: ${id}`);
-    }
-    discussion.messages.push({
-      role,
-      content,
-      timestamp: Date.now()
-    });
-    discussion.updatedAt = new Date().toISOString();
-    this.save(discussion);
-    return discussion;
-  }
-  addInsight(id, insight) {
-    const discussion = this.load(id);
-    if (!discussion) {
-      throw new Error(`Discussion not found: ${id}`);
-    }
-    discussion.insights.push(insight);
-    discussion.updatedAt = new Date().toISOString();
-    this.save(discussion);
-    return discussion;
-  }
-  getAllInsights() {
-    const discussions = this.list("completed");
-    const insights = [];
-    for (const discussion of discussions) {
-      insights.push(...discussion.insights);
-    }
-    insights.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
-    return insights;
-  }
-  getMarkdown(id) {
-    const discussion = this.load(id);
-    if (!discussion)
-      return null;
-    return this.toMarkdown(discussion);
-  }
-  toMarkdown(discussion) {
-    const lines = [];
-    lines.push(`# Discussion: ${discussion.title}`);
-    lines.push("");
-    lines.push(`**Status:** ${discussion.status.toUpperCase()}`);
-    lines.push(`**Topic:** ${discussion.topic}`);
-    lines.push(`**Created:** ${discussion.createdAt}`);
-    lines.push(`**Updated:** ${discussion.updatedAt}`);
-    lines.push(`**Model:** ${discussion.metadata.model} (${discussion.metadata.provider})`);
-    lines.push("");
-    if (discussion.messages.length > 0) {
-      lines.push(`## Messages (${discussion.messages.length})`);
-      lines.push("");
-      for (const msg of discussion.messages) {
-        const time = new Date(msg.timestamp).toISOString();
-        const roleLabel = msg.role === "user" ? "User" : "Assistant";
-        lines.push(`### ${roleLabel} — ${time}`);
-        lines.push("");
-        lines.push(msg.content);
-        lines.push("");
-      }
-    }
-    if (discussion.insights.length > 0) {
-      lines.push(`## Insights (${discussion.insights.length})`);
-      lines.push("");
-      for (const insight of discussion.insights) {
-        lines.push(`### [${insight.type.toUpperCase()}] ${insight.title}`);
-        lines.push("");
-        lines.push(insight.content);
-        if (insight.tags.length > 0) {
-          lines.push("");
-          lines.push(`**Tags:** ${insight.tags.join(", ")}`);
-        }
-        lines.push("");
-      }
-    }
-    lines.push("---");
-    lines.push(`*Discussion ID: ${discussion.id}*`);
-    return lines.join(`
-`);
-  }
-  ensureDir() {
-    if (!import_node_fs3.existsSync(this.discussionsDir)) {
-      import_node_fs3.mkdirSync(this.discussionsDir, { recursive: true });
-    }
-  }
-}
-var import_node_fs3, import_node_path5;
-var init_discussion_manager = __esm(() => {
-  init_config();
-  import_node_fs3 = require("node:fs");
-  import_node_path5 = require("node:path");
-});
-
-// src/core/prompt-builder.ts
-class PromptBuilder {
-  projectPath;
-  constructor(projectPath) {
-    this.projectPath = projectPath;
-  }
-  async build(task) {
-    const roleText = this.roleToText(task.assigneeRole);
-    const description = task.description || "No description provided.";
-    const context = this.getProjectContext();
-    const learnings = this.getLearningsContent();
-    const knowledgeBase = this.getKnowledgeBaseSection();
-    let sections = "";
-    if (roleText) {
-      sections += `
-<role>
-You are acting as a ${roleText}.
-</role>
-`;
-    }
-    if (context) {
-      sections += `
-<project_context>
-${context}
-</project_context>
-`;
-    }
-    sections += `
-<knowledge_base>
-${knowledgeBase}
-</knowledge_base>
-`;
-    if (learnings) {
-      sections += `
-<learnings>
-These are accumulated lessons from past tasks. Follow them to avoid repeating mistakes:
-${learnings}
-</learnings>
-`;
-    }
-    const discussionInsights = this.getDiscussionInsightsContent();
-    if (discussionInsights) {
-      sections += `
-<discussion_insights>
-These are key decisions and insights from product discussions. Follow them to maintain product coherence:
-${discussionInsights}
-</discussion_insights>
-`;
-    }
-    if (task.docs && task.docs.length > 0) {
-      let docsContent = "";
-      for (const doc of task.docs) {
-        const content = doc.content || "";
-        const limit = 800;
-        const preview = content.slice(0, limit);
-        const isTruncated = content.length > limit;
-        docsContent += `### ${doc.title}
-${preview}${isTruncated ? `
-...(truncated)...` : ""}
-
-`;
-      }
-      sections += `
-<documents>
-${docsContent.trimEnd()}
-</documents>
-`;
-    }
-    if (task.acceptanceChecklist && task.acceptanceChecklist.length > 0) {
-      let criteria = "";
-      for (const item of task.acceptanceChecklist) {
-        criteria += `- ${item.done ? "[x]" : "[ ]"} ${item.text}
-`;
-      }
-      sections += `
-<acceptance_criteria>
-${criteria.trimEnd()}
-</acceptance_criteria>
-`;
-    }
-    if (task.comments && task.comments.length > 0) {
-      const filteredComments = task.comments.filter((comment) => comment.author !== "system");
-      const comments = filteredComments.slice(0, 3);
-      if (comments.length > 0) {
-        let commentsContent = "";
-        for (const comment of comments) {
-          const date = new Date(comment.createdAt).toLocaleString();
-          commentsContent += `- ${comment.author} (${date}): ${comment.text}
-`;
-        }
-        sections += `
-<feedback>
-${commentsContent.trimEnd()}
-</feedback>
-`;
-      }
-    }
-    return `<task_execution>
-Complete this task: ${task.title}
-
-<description>
-${description}
-</description>
-${sections}
-<rules>
-- Complete the task as described
-- Save any high-level documentation (PRDs, technical drafts, architecture docs) in \`.locus/artifacts/\`
-- Use relative paths from the project root at all times — no absolute local paths
-- Do NOT run \`git add\`, \`git commit\`, \`git push\`, or create branches — Locus handles git automatically
-</rules>
-</task_execution>`;
-  }
-  async buildGenericPrompt(query) {
-    const context = this.getProjectContext();
-    const learnings = this.getLearningsContent();
-    const knowledgeBase = this.getKnowledgeBaseSection();
-    let sections = "";
-    if (context) {
-      sections += `
-<project_context>
-${context}
-</project_context>
-`;
-    }
-    sections += `
-<knowledge_base>
-${knowledgeBase}
-</knowledge_base>
-`;
-    if (learnings) {
-      sections += `
-<learnings>
-These are accumulated lessons from past tasks. Follow them to avoid repeating mistakes:
-${learnings}
-</learnings>
-`;
-    }
-    const discussionInsights = this.getDiscussionInsightsContent();
-    if (discussionInsights) {
-      sections += `
-<discussion_insights>
-These are key decisions and insights from product discussions. Follow them to maintain product coherence:
-${discussionInsights}
-</discussion_insights>
-`;
-    }
-    return `<direct_execution>
-Execute this prompt: ${query}
-${sections}
-<rules>
-- Execute the prompt based on the provided project context
-- Use relative paths from the project root at all times — no absolute local paths
-- Do NOT run \`git add\`, \`git commit\`, \`git push\`, or create branches — Locus handles git automatically
-</rules>
-</direct_execution>`;
-  }
-  getProjectContext() {
-    const contextPath = getLocusPath(this.projectPath, "contextFile");
-    if (import_node_fs4.existsSync(contextPath)) {
-      try {
-        const context = import_node_fs4.readFileSync(contextPath, "utf-8");
-        if (context.trim().length > 20) {
-          return context;
-        }
-      } catch (err) {
-        console.warn(`Warning: Could not read context file: ${err}`);
-      }
-    }
-    return this.getFallbackContext() || null;
-  }
-  getFallbackContext() {
-    const readmePath = import_node_path6.join(this.projectPath, "README.md");
-    if (import_node_fs4.existsSync(readmePath)) {
-      try {
-        const content = import_node_fs4.readFileSync(readmePath, "utf-8");
-        const limit = 1000;
-        return content.slice(0, limit) + (content.length > limit ? `
-...(truncated)...` : "");
-      } catch {
-        return "";
-      }
-    }
-    return "";
-  }
-  getKnowledgeBaseSection() {
-    return `You have access to the following documentation directories for context:
-- Artifacts: \`.locus/artifacts\` (local-only, not synced to cloud)
-- Documents: \`.locus/documents\` (synced from cloud)
-- Discussions: \`.locus/discussions\` (product discussion insights and decisions)
-If you need more information about the project strategies, plans, or architecture, read files in these directories.`;
-  }
-  getLearningsContent() {
-    const learningsPath = getLocusPath(this.projectPath, "learningsFile");
-    if (!import_node_fs4.existsSync(learningsPath)) {
-      return null;
-    }
-    try {
-      const content = import_node_fs4.readFileSync(learningsPath, "utf-8");
-      const lines = content.split(`
-`).filter((l) => l.startsWith("- "));
-      if (lines.length === 0) {
-        return null;
-      }
-      return lines.join(`
-`);
-    } catch {
-      return null;
-    }
-  }
-  getDiscussionInsightsContent() {
-    try {
-      const manager = new DiscussionManager(this.projectPath);
-      const insights = manager.getAllInsights();
-      if (insights.length === 0) {
-        return null;
-      }
-      const groups = {};
-      for (const insight of insights) {
-        const key = insight.type;
-        if (!groups[key]) {
-          groups[key] = [];
-        }
-        groups[key].push(insight);
-      }
-      const typeLabels = {
-        decision: "Decisions",
-        requirement: "Requirements",
-        idea: "Ideas",
-        concern: "Concerns",
-        learning: "Learnings"
-      };
-      let output = "";
-      for (const [type, label] of Object.entries(typeLabels)) {
-        const items = groups[type];
-        if (!items || items.length === 0)
-          continue;
-        output += `## ${label}
-`;
-        for (const item of items) {
-          output += `- [${item.title}]: ${item.content}
-`;
-        }
-        output += `
-`;
-      }
-      if (output.length === 0) {
-        return null;
-      }
-      if (output.length > 2000) {
-        output = `${output.slice(0, 1997)}...`;
-      }
-      return output.trimEnd();
-    } catch {
-      return null;
-    }
-  }
-  roleToText(role) {
-    if (!role) {
-      return null;
-    }
-    switch (role) {
-      case import_shared2.AssigneeRole.BACKEND:
-        return "Backend Engineer";
-      case import_shared2.AssigneeRole.FRONTEND:
-        return "Frontend Engineer";
-      case import_shared2.AssigneeRole.PM:
-        return "Product Manager";
-      case import_shared2.AssigneeRole.QA:
-        return "QA Engineer";
-      case import_shared2.AssigneeRole.DESIGN:
-        return "Product Designer";
-      default:
-        return "engineer";
-    }
-  }
-}
-var import_node_fs4, import_node_path6, import_shared2;
-var init_prompt_builder = __esm(() => {
-  init_discussion_manager();
-  init_config();
-  import_node_fs4 = require("node:fs");
-  import_node_path6 = require("node:path");
-  import_shared2 = require("@locusai/shared");
-});
-
-// src/agent/task-executor.ts
-class TaskExecutor {
-  deps;
-  promptBuilder;
-  constructor(deps) {
-    this.deps = deps;
-    this.promptBuilder = new PromptBuilder(deps.projectPath);
-  }
-  async execute(task) {
-    this.deps.log(`Executing: ${task.title}`, "info");
-    const basePrompt = await this.promptBuilder.build(task);
-    try {
-      const output = await this.deps.aiRunner.run(basePrompt);
-      const summary = this.extractSummary(output);
-      return { success: true, summary };
-    } catch (error) {
-      return { success: false, summary: `Error: ${error}` };
-    }
-  }
-  extractSummary(output) {
-    if (!output || !output.trim()) {
-      return "Task completed by the agent";
-    }
-    const paragraphs = output.split(/\n\n+/).map((p) => p.trim()).filter((p) => p.length > 0);
-    if (paragraphs.length === 0) {
-      return "Task completed by the agent";
-    }
-    const last = paragraphs[paragraphs.length - 1];
-    if (last.length > 500) {
-      return `${last.slice(0, 497)}...`;
-    }
-    return last;
-  }
-}
-var init_task_executor = __esm(() => {
-  init_prompt_builder();
-});
-
-// 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 === "--model")
-      config.model = args[++i];
-    else if (arg === "--provider") {
-      const value = args[i + 1];
-      if (value && !value.startsWith("--"))
-        i++;
-      config.provider = resolveProvider(value);
-    } else if (arg === "--reasoning-effort")
-      config.reasoningEffort = args[++i];
-  }
-  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;
-  gitWorkflow;
-  maxTasks = 50;
-  tasksCompleted = 0;
-  heartbeatInterval = null;
-  currentTaskId = null;
-  completedTaskList = [];
-  taskSummaries = [];
-  log;
-  constructor(config) {
-    this.config = config;
-    const projectPath = config.projectPath || process.cwd();
-    this.log = createWorkerLogger(config.agentId);
-    this.client = new LocusClient({
-      baseUrl: config.apiBase,
-      token: config.apiKey,
-      retryOptions: {
-        maxRetries: 3,
-        initialDelay: 1000,
-        maxDelay: 5000,
-        factor: 2
-      }
-    });
-    if (!isGitAvailable()) {
-      this.log("git is not installed — branch management will not work", "error");
-    }
-    if (!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 provider = config.provider ?? PROVIDER.CLAUDE;
-    this.aiRunner = createAiRunner(provider, {
-      projectPath,
-      model: config.model,
-      log: this.log,
-      reasoningEffort: config.reasoningEffort
-    });
-    this.taskExecutor = new TaskExecutor({
-      aiRunner: this.aiRunner,
-      projectPath,
-      log: this.log
-    });
-    this.gitWorkflow = new GitWorkflow(config, this.log);
-    const providerLabel = provider === "codex" ? "Codex" : "Claude";
-    this.log(`Using ${providerLabel} CLI for all phases`, "info");
-  }
-  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);
-    try {
-      const result = await this.taskExecutor.execute(fullTask);
-      let noChanges = false;
-      let taskBranch = null;
-      if (result.success) {
-        const commitResult = this.gitWorkflow.commitAndPush(fullTask);
-        taskBranch = commitResult.branch;
-        noChanges = Boolean(commitResult.noChanges);
-      }
-      return {
-        ...result,
-        branch: taskBranch ?? undefined,
-        noChanges: noChanges || undefined
-      };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return {
-        success: false,
-        summary: `Execution error: ${msg}`
-      };
-    }
-  }
-  startHeartbeat() {
-    this.sendHeartbeat();
-    this.heartbeatInterval = setInterval(() => this.sendHeartbeat(), 60000);
-  }
-  stopHeartbeat() {
-    if (this.heartbeatInterval) {
-      clearInterval(this.heartbeatInterval);
-      this.heartbeatInterval = null;
-    }
-  }
-  sendHeartbeat() {
-    this.client.workspaces.heartbeat(this.config.workspaceId, this.config.agentId, this.currentTaskId, this.currentTaskId ? "WORKING" : "IDLE").catch((err) => {
-      this.log(`Heartbeat failed: ${err instanceof Error ? err.message : String(err)}`, "warn");
-    });
-  }
-  async run() {
-    this.log(`Agent started in ${this.config.projectPath || process.cwd()}`, "success");
-    const handleShutdown = () => {
-      this.log("Received shutdown signal. Aborting...", "warn");
-      this.aiRunner.abort();
-      this.stopHeartbeat();
-      this.gitWorkflow.checkoutBaseBranch();
-      process.exit(1);
-    };
-    process.on("SIGTERM", handleShutdown);
-    process.on("SIGINT", handleShutdown);
-    this.startHeartbeat();
-    const sprint = await this.getActiveSprint();
-    if (sprint) {
-      this.log(`Active sprint found: ${sprint.name}`, "info");
-    } else {
-      this.log("No active sprint found.", "warn");
-    }
-    const branchName = this.gitWorkflow.createBranch(this.config.sprintId);
-    this.log(`Working on branch: ${branchName}`, "info");
-    while (this.tasksCompleted < this.maxTasks) {
-      const task = await this.getNextTask();
-      if (!task) {
-        this.log("No more tasks to process.", "info");
-        break;
-      }
-      this.log(`Claimed: ${task.title}`, "success");
-      this.currentTaskId = task.id;
-      this.sendHeartbeat();
-      const result = await this.executeTask(task);
-      if (result.success) {
-        if (result.noChanges) {
-          this.log(`Blocked: ${task.title} - execution produced no file changes`, "warn");
-          await this.client.tasks.update(task.id, this.config.workspaceId, {
-            status: import_shared3.TaskStatus.BLOCKED,
-            assignedTo: null
-          });
-          await this.client.tasks.addComment(task.id, this.config.workspaceId, {
-            author: "system",
-            text: `⚠️ Agent execution finished with no file changes, so no commit was created.
-
-${result.summary}`
-          });
-        } else {
-          this.log(`Completed: ${task.title}`, "success");
-          const updatePayload = {
-            status: import_shared3.TaskStatus.IN_REVIEW
-          };
-          await this.client.tasks.update(task.id, this.config.workspaceId, updatePayload);
-          const branchInfo = result.branch ? `
-
-Branch: \`${result.branch}\`` : "";
-          await this.client.tasks.addComment(task.id, this.config.workspaceId, {
-            author: "system",
-            text: `✅ ${result.summary}${branchInfo}`
-          });
-          this.tasksCompleted++;
-          this.completedTaskList.push({ title: task.title, id: task.id });
-          this.taskSummaries.push(result.summary);
-        }
-      } else {
-        this.log(`Failed: ${task.title} - ${result.summary}`, "error");
-        await this.client.tasks.update(task.id, this.config.workspaceId, {
-          status: import_shared3.TaskStatus.BACKLOG,
-          assignedTo: null
-        });
-        await this.client.tasks.addComment(task.id, this.config.workspaceId, {
-          author: "system",
-          text: `❌ ${result.summary}`
-        });
-      }
-      this.currentTaskId = null;
-      this.sendHeartbeat();
-    }
-    if (this.completedTaskList.length > 0) {
-      this.log("All tasks done. Creating pull request...", "info");
-      const prResult = this.gitWorkflow.createPullRequest(this.completedTaskList, this.taskSummaries);
-      if (prResult.url) {
-        for (const task of this.completedTaskList) {
-          try {
-            await this.client.tasks.update(task.id, this.config.workspaceId, {
-              prUrl: prResult.url
-            });
-          } catch {}
-        }
-      } else if (prResult.error) {
-        this.log(`PR creation failed: ${prResult.error}`, "error");
-      }
-    }
-    this.gitWorkflow.checkoutBaseBranch();
-    this.currentTaskId = null;
-    this.stopHeartbeat();
-    this.client.workspaces.heartbeat(this.config.workspaceId, this.config.agentId, null, "COMPLETED").catch(() => {});
-    process.exit(0);
-  }
-}
-var import_shared3, workerEntrypoint;
-var init_worker = __esm(() => {
-  init_factory();
-  init_config();
-  init_git_utils();
-  init_src();
-  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);
-      });
-    });
-  }
-});
-init_worker();