@locusai/sdk 0.8.0 → 0.9.0

package/dist/index-node.js

@@ -52,8 +52,7 @@ __export(exports_src, {
   InvitationsModule: () => InvitationsModule,
   DocsModule: () => DocsModule,
   CiModule: () => CiModule,
-  AuthModule: () => AuthModule,
-  AIModule: () => AIModule
+  AuthModule: () => AuthModule
 });
 module.exports = __toCommonJS(exports_src);
 var import_axios = __toESM(require("axios"));
@@ -86,43 +85,6 @@ class BaseModule {
   }
 }
 
-// src/modules/ai.ts
-class AIModule extends BaseModule {
-  async chat(workspaceId, body) {
-    const { data } = await this.api.post(`/ai/${workspaceId}/chat`, body, { timeout: 300000 });
-    return data;
-  }
-  async detectIntent(workspaceId, body) {
-    const { data } = await this.api.post(`/ai/${workspaceId}/chat/intent`, body, { timeout: 300000 });
-    return data;
-  }
-  async executeIntent(workspaceId, body) {
-    const { data } = await this.api.post(`/ai/${workspaceId}/chat/execute`, body, { timeout: 300000 });
-    return data;
-  }
-  async listSessions(workspaceId) {
-    const { data } = await this.api.get(`/ai/${workspaceId}/sessions`);
-    return data;
-  }
-  async getSession(workspaceId, sessionId) {
-    const { data } = await this.api.get(`/ai/${workspaceId}/session/${sessionId}`);
-    return data;
-  }
-  getChatStreamUrl(workspaceId, sessionId) {
-    return `${this.api.defaults.baseURL}/ai/${workspaceId}/chat/stream?sessionId=${sessionId}`;
-  }
-  async deleteSession(workspaceId, sessionId) {
-    await this.api.delete(`/ai/${workspaceId}/session/${sessionId}`);
-  }
-  async shareSession(workspaceId, sessionId, body) {
-    await this.api.post(`/ai/${workspaceId}/session/${sessionId}/share`, body);
-  }
-  async getSharedSession(sessionId) {
-    const { data } = await this.api.get(`/ai/shared/${sessionId}`);
-    return data;
-  }
-}
-
 // src/modules/auth.ts
 class AuthModule extends BaseModule {
   async getProfile() {
@@ -149,6 +111,10 @@ class AuthModule extends BaseModule {
     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
@@ -346,10 +312,6 @@ class TasksModule extends BaseModule {
       updates
     });
   }
-  async getContext(id, workspaceId) {
-    const { data } = await this.api.get(`/workspaces/${workspaceId}/tasks/${id}/context`);
-    return data;
-  }
 }
 
 // src/modules/workspaces.ts
@@ -386,10 +348,6 @@ class WorkspacesModule extends BaseModule {
     const { data } = await this.api.get(`/workspaces/${id}/stats`);
     return data;
   }
-  async getManifestStatus(workspaceId) {
-    const { data } = await this.api.get(`/workspaces/${workspaceId}/manifest-status`);
-    return data;
-  }
   async getActivity(id, limit) {
     const { data } = await this.api.get(`/workspaces/${id}/activity`, {
       params: { limit }
@@ -400,6 +358,18 @@ class WorkspacesModule extends BaseModule {
     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;
@@ -418,7 +388,6 @@ class LocusClient {
   api;
   emitter;
   auth;
-  ai;
   tasks;
   sprints;
   workspaces;
@@ -438,7 +407,6 @@ class LocusClient {
     });
     this.setupInterceptors();
     this.auth = new AuthModule(this.api, this.emitter);
-    this.ai = new AIModule(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);
@@ -512,6 +480,7 @@ __export(exports_worker, {
   AgentWorker: () => AgentWorker
 });
 module.exports = __toCommonJS(exports_worker);
+var import_shared3 = require("@locusai/shared");
 
 // src/core/config.ts
 var import_node_path = require("node:path");
@@ -521,28 +490,50 @@ var PROVIDER = {
 };
 var DEFAULT_MODEL = {
   [PROVIDER.CLAUDE]: "opus",
-  [PROVIDER.CODEX]: "gpt-5.2-codex"
+  [PROVIDER.CODEX]: "gpt-5.3-codex"
+};
+var LOCUS_SCHEMA_BASE_URL = "https://locusai.dev/schemas";
+var LOCUS_SCHEMAS = {
+  config: `${LOCUS_SCHEMA_BASE_URL}/config.schema.json`,
+  settings: `${LOCUS_SCHEMA_BASE_URL}/settings.schema.json`
 };
 var LOCUS_CONFIG = {
   dir: ".locus",
   configFile: "config.json",
+  settingsFile: "settings.json",
   indexFile: "codebase-index.json",
-  contextFile: "CLAUDE.md",
+  contextFile: "LOCUS.md",
   artifactsDir: "artifacts",
   documentsDir: "documents",
-  agentSkillsDir: ".agent/skills",
-  sessionsDir: "sessions"
+  sessionsDir: "sessions",
+  reviewsDir: "reviews",
+  plansDir: "plans",
+  projectDir: "project",
+  projectContextFile: "context.md",
+  projectProgressFile: "progress.md"
 };
 var LOCUS_GITIGNORE_PATTERNS = [
   "# Locus AI - Session data (user-specific, can grow large)",
   ".locus/sessions/",
   "",
   "# Locus AI - Artifacts (local-only, user-specific)",
-  ".locus/artifacts/"
+  ".locus/artifacts/",
+  "",
+  "# Locus AI - Review reports (generated per sprint)",
+  ".locus/reviews/",
+  "",
+  "# Locus AI - Plans (generated per task)",
+  ".locus/plans/",
+  "",
+  "# Locus AI - Agent worktrees (parallel execution)",
+  ".locus-worktrees/",
+  "",
+  "# Locus AI - Settings (contains API key, telegram config, etc.)",
+  ".locus/settings.json"
 ];
 function getLocusPath(projectPath, fileName) {
-  if (fileName === "contextFile") {
-    return import_node_path.join(projectPath, LOCUS_CONFIG.contextFile);
+  if (fileName === "projectContextFile" || fileName === "projectProgressFile") {
+    return import_node_path.join(projectPath, LOCUS_CONFIG.dir, LOCUS_CONFIG.projectDir, LOCUS_CONFIG[fileName]);
   }
   return import_node_path.join(projectPath, LOCUS_CONFIG.dir, LOCUS_CONFIG[fileName]);
 }
@@ -618,6 +609,14 @@ var c = {
 };
 
 // src/ai/claude-runner.ts
+var SANDBOX_SETTINGS = JSON.stringify({
+  sandbox: {
+    enabled: true,
+    autoAllow: true,
+    allowUnsandboxedCommands: false
+  }
+});
+
 class ClaudeRunner {
   model;
   log;
@@ -625,6 +624,7 @@ class ClaudeRunner {
   eventEmitter;
   currentToolName;
   activeTools = new Map;
+  activeProcess = null;
   constructor(projectPath, model = DEFAULT_MODEL[PROVIDER.CLAUDE], log) {
     this.model = model;
     this.log = log;
@@ -633,7 +633,13 @@ class ClaudeRunner {
   setEventEmitter(emitter) {
     this.eventEmitter = emitter;
   }
-  async run(prompt, _isPlanning = false) {
+  abort() {
+    if (this.activeProcess && !this.activeProcess.killed) {
+      this.activeProcess.kill("SIGTERM");
+      this.activeProcess = null;
+    }
+  }
+  async run(prompt) {
     const maxRetries = 3;
     let lastError = null;
     for (let attempt = 1;attempt <= maxRetries; attempt++) {
@@ -661,7 +667,9 @@ class ClaudeRunner {
       "stream-json",
       "--include-partial-messages",
       "--model",
-      this.model
+      this.model,
+      "--settings",
+      SANDBOX_SETTINGS
     ];
     const env = {
       ...process.env,
@@ -678,6 +686,7 @@ class ClaudeRunner {
       stdio: ["pipe", "pipe", "pipe"],
       env
     });
+    this.activeProcess = claude;
     let buffer = "";
     let stderrBuffer = "";
     let resolveChunk = null;
@@ -745,6 +754,7 @@ class ClaudeRunner {
       signalEnd();
     });
     claude.on("close", (code) => {
+      this.activeProcess = null;
       if (stderrBuffer && !this.shouldSuppressLine(stderrBuffer)) {
         process.stderr.write(`${stderrBuffer}
 `);
@@ -902,7 +912,9 @@ class ClaudeRunner {
         "stream-json",
         "--include-partial-messages",
         "--model",
-        this.model
+        this.model,
+        "--settings",
+        SANDBOX_SETTINGS
       ];
       const env = {
         ...process.env,
@@ -914,6 +926,7 @@ class ClaudeRunner {
         stdio: ["pipe", "pipe", "pipe"],
         env
       });
+      this.activeProcess = claude;
       let finalResult = "";
       let errorOutput = "";
       let buffer = "";
@@ -947,6 +960,7 @@ class ClaudeRunner {
         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}
 `);
@@ -1013,11 +1027,18 @@ class CodexRunner {
   projectPath;
   model;
   log;
+  activeProcess = null;
   constructor(projectPath, model = DEFAULT_MODEL[PROVIDER.CODEX], log) {
     this.projectPath = projectPath;
     this.model = model;
     this.log = log;
   }
+  abort() {
+    if (this.activeProcess && !this.activeProcess.killed) {
+      this.activeProcess.kill("SIGTERM");
+      this.activeProcess = null;
+    }
+  }
   async run(prompt) {
     const maxRetries = 3;
     let lastError = null;
@@ -1044,6 +1065,7 @@ class CodexRunner {
       env: process.env,
       shell: false
     });
+    this.activeProcess = codex;
     let resolveChunk = null;
     const chunkQueue = [];
     let processEnded = false;
@@ -1093,6 +1115,7 @@ class CodexRunner {
       signalEnd();
     });
     codex.on("close", (code) => {
+      this.activeProcess = null;
       this.cleanupTempFile(outputPath);
       if (code === 0) {
         const result = this.readOutput(outputPath, finalOutput);
@@ -1138,6 +1161,7 @@ class CodexRunner {
         env: process.env,
         shell: false
       });
+      this.activeProcess = codex;
       let output = "";
       let errorOutput = "";
       const handleOutput = (data) => {
@@ -1155,6 +1179,7 @@ class CodexRunner {
         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;
         this.cleanupTempFile(outputPath);
         if (code === 0) {
           resolve2(this.readOutput(outputPath, output));
@@ -1169,7 +1194,8 @@ class CodexRunner {
   buildArgs(outputPath) {
     const args = [
       "exec",
-      "--full-auto",
+      "--sandbox",
+      "workspace-write",
       "--skip-git-repo-check",
       "--output-last-message",
       outputPath
@@ -1236,315 +1262,745 @@ function createAiRunner(provider, config) {
   }
 }
 
-// src/core/indexer.ts
-var import_node_crypto2 = require("node:crypto");
-var import_node_fs2 = require("node:fs");
-var import_node_path4 = require("node:path");
-var import_globby = require("globby");
+// src/git/git-utils.ts
+var import_node_child_process3 = require("node:child_process");
+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";
+    }
+  }
+}
 
-class CodebaseIndexer {
+// src/git/pr-service.ts
+var import_node_child_process4 = require("node:child_process");
+class PrService {
   projectPath;
-  indexPath;
-  fullReindexRatioThreshold = 0.2;
-  constructor(projectPath) {
+  log;
+  constructor(projectPath, log) {
     this.projectPath = projectPath;
-    this.indexPath = import_node_path4.join(projectPath, ".locus", "codebase-index.json");
+    this.log = log;
   }
-  async index(onProgress, treeSummarizer, force = false) {
-    if (!treeSummarizer) {
-      throw new Error("A treeSummarizer is required for this indexing method.");
+  createPr(options) {
+    const {
+      task,
+      branch,
+      baseBranch: requestedBaseBranch,
+      agentId,
+      summary
+    } = options;
+    const provider = detectRemoteProvider(this.projectPath);
+    if (provider !== "github") {
+      throw new Error(`PR creation is only supported for GitHub repositories (detected: ${provider})`);
     }
-    onProgress?.("Generating file tree...");
-    const currentFiles = await this.getFileTree();
-    const treeString = currentFiles.join(`
-`);
-    const newTreeHash = this.hashTree(treeString);
-    const existingIndex = this.loadIndex();
-    const currentHashes = this.computeFileHashes(currentFiles);
-    const existingHashes = existingIndex?.fileHashes;
-    const hasExistingContent = existingIndex && (Object.keys(existingIndex.symbols).length > 0 || Object.keys(existingIndex.responsibilities).length > 0);
-    const canIncremental = !force && existingIndex && existingHashes && hasExistingContent;
-    if (canIncremental) {
-      onProgress?.("Performing incremental update");
-      const { added, deleted, modified } = this.diffFiles(currentHashes, existingHashes);
-      const changedFiles = [...added, ...modified];
-      const totalChanges = changedFiles.length + deleted.length;
-      const existingFileCount = Object.keys(existingHashes).length;
-      onProgress?.(`File changes detected: ${changedFiles.length} changed, ${added.length} added, ${deleted.length} deleted`);
-      if (existingFileCount > 0) {
-        const changeRatio = totalChanges / existingFileCount;
-        if (changeRatio <= this.fullReindexRatioThreshold && changedFiles.length > 0) {
-          onProgress?.(`Reindexing ${changedFiles.length} changed files and merging with existing index`);
-          const incrementalIndex = await treeSummarizer(changedFiles.join(`
-`));
-          const updatedIndex = this.cloneIndex(existingIndex);
-          this.removeFilesFromIndex(updatedIndex, [...deleted, ...modified]);
-          return this.mergeIndex(updatedIndex, incrementalIndex, currentHashes, newTreeHash);
-        }
-        if (changedFiles.length === 0 && deleted.length > 0) {
-          onProgress?.(`Removing ${deleted.length} deleted files from index`);
-          const updatedIndex = this.cloneIndex(existingIndex);
-          this.removeFilesFromIndex(updatedIndex, deleted);
-          return this.applyIndexMetadata(updatedIndex, currentHashes, newTreeHash);
-        }
-        if (changedFiles.length === 0 && deleted.length === 0) {
-          onProgress?.("No actual file changes, updating hashes only");
-          const updatedIndex = this.cloneIndex(existingIndex);
-          return this.applyIndexMetadata(updatedIndex, currentHashes, newTreeHash);
-        }
-        onProgress?.(`Too many changes (${(changeRatio * 100).toFixed(1)}%), performing full reindex`);
-      }
+    if (!isGhAvailable(this.projectPath)) {
+      throw new Error("GitHub CLI (gh) is not installed or not authenticated. Install from https://cli.github.com/");
     }
-    onProgress?.("AI is analyzing codebase structure...");
-    try {
-      const index = await treeSummarizer(treeString);
-      return this.applyIndexMetadata(index, currentHashes, newTreeHash);
-    } catch (error) {
-      throw new Error(`AI analysis failed: ${error instanceof Error ? error.message : String(error)}`);
+    const title = `[Locus] ${task.title}`;
+    const body = this.buildPrBody(task, agentId, summary);
+    const baseBranch = requestedBaseBranch ?? getDefaultBranch(this.projectPath);
+    this.validateCreatePrInputs(baseBranch, branch);
+    this.log(`Creating PR: ${title} (${branch} → ${baseBranch})`, "info");
+    const output = import_node_child_process4.execFileSync("gh", [
+      "pr",
+      "create",
+      "--title",
+      title,
+      "--body",
+      body,
+      "--base",
+      baseBranch,
+      "--head",
+      branch
+    ], {
+      cwd: this.projectPath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const url = output;
+    const prNumber = this.extractPrNumber(url);
+    this.log(`PR created: ${url}`, "success");
+    return { url, number: prNumber };
+  }
+  validateCreatePrInputs(baseBranch, headBranch) {
+    if (!this.hasRemoteBranch(baseBranch)) {
+      throw new Error(`Base branch "${baseBranch}" does not exist on origin. Push/fetch refs and retry.`);
     }
-  }
-  async getFileTree() {
-    const gitmodulesPath = import_node_path4.join(this.projectPath, ".gitmodules");
-    const submoduleIgnores = [];
-    if (import_node_fs2.existsSync(gitmodulesPath)) {
-      try {
-        const content = import_node_fs2.readFileSync(gitmodulesPath, "utf-8");
-        const lines = content.split(`
-`);
-        for (const line of lines) {
-          const match = line.match(/^\s*path\s*=\s*(.*)$/);
-          const path = match?.[1]?.trim();
-          if (path) {
-            submoduleIgnores.push(`${path}/**`);
-            submoduleIgnores.push(`**/${path}/**`);
-          }
-        }
-      } catch {}
+    if (!this.hasRemoteBranch(headBranch)) {
+      throw new Error(`Head branch "${headBranch}" is not available on origin. Ensure it is pushed before PR creation.`);
+    }
+    const baseRef = this.resolveBranchRef(baseBranch);
+    const headRef = this.resolveBranchRef(headBranch);
+    if (!baseRef) {
+      throw new Error(`Could not resolve base branch "${baseBranch}" locally.`);
+    }
+    if (!headRef) {
+      throw new Error(`Could not resolve head branch "${headBranch}" locally.`);
+    }
+    const commitsAhead = this.countCommitsAhead(baseRef, headRef);
+    if (commitsAhead <= 0) {
+      throw new Error(`No commits between "${baseBranch}" and "${headBranch}". Skipping PR creation.`);
     }
-    return import_globby.globby(["**/*"], {
-      cwd: this.projectPath,
-      gitignore: true,
-      ignore: [
-        ...submoduleIgnores,
-        "**/node_modules/**",
-        "**/dist/**",
-        "**/build/**",
-        "**/target/**",
-        "**/bin/**",
-        "**/obj/**",
-        "**/.next/**",
-        "**/.svelte-kit/**",
-        "**/.nuxt/**",
-        "**/.cache/**",
-        "**/out/**",
-        "**/__tests__/**",
-        "**/coverage/**",
-        "**/*.test.*",
-        "**/*.spec.*",
-        "**/*.d.ts",
-        "**/tsconfig.tsbuildinfo",
-        "**/.locus/*.json",
-        "**/.locus/*.md",
-        "**/.locus/!(artifacts)/**",
-        "**/.git/**",
-        "**/.svn/**",
-        "**/.hg/**",
-        "**/.vscode/**",
-        "**/.idea/**",
-        "**/.DS_Store",
-        "**/bun.lock",
-        "**/package-lock.json",
-        "**/yarn.lock",
-        "**/pnpm-lock.yaml",
-        "**/Cargo.lock",
-        "**/go.sum",
-        "**/poetry.lock",
-        "**/*.{png,jpg,jpeg,gif,svg,ico,mp4,webm,wav,mp3,woff,woff2,eot,ttf,otf,pdf,zip,tar.gz,rar}"
-      ]
-    });
   }
-  loadIndex() {
-    if (import_node_fs2.existsSync(this.indexPath)) {
-      try {
-        return JSON.parse(import_node_fs2.readFileSync(this.indexPath, "utf-8"));
-      } catch {
-        return null;
-      }
+  countCommitsAhead(baseRef, headRef) {
+    const output = import_node_child_process4.execFileSync("git", ["rev-list", "--count", `${baseRef}..${headRef}`], {
+      cwd: this.projectPath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const value = Number.parseInt(output || "0", 10);
+    return Number.isNaN(value) ? 0 : value;
+  }
+  resolveBranchRef(branch) {
+    if (this.hasLocalBranch(branch)) {
+      return branch;
+    }
+    if (this.hasRemoteTrackingBranch(branch)) {
+      return `origin/${branch}`;
     }
     return null;
   }
-  saveIndex(index) {
-    const dir = import_node_path4.dirname(this.indexPath);
-    if (!import_node_fs2.existsSync(dir)) {
-      import_node_fs2.mkdirSync(dir, { recursive: true });
+  hasLocalBranch(branch) {
+    try {
+      import_node_child_process4.execFileSync("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`], {
+        cwd: this.projectPath,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return true;
+    } catch {
+      return false;
     }
-    import_node_fs2.writeFileSync(this.indexPath, JSON.stringify(index, null, 2));
   }
-  cloneIndex(index) {
-    return JSON.parse(JSON.stringify(index));
+  hasRemoteTrackingBranch(branch) {
+    try {
+      import_node_child_process4.execFileSync("git", ["show-ref", "--verify", "--quiet", `refs/remotes/origin/${branch}`], {
+        cwd: this.projectPath,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return true;
+    } catch {
+      return false;
+    }
   }
-  applyIndexMetadata(index, fileHashes, treeHash) {
-    index.lastIndexed = new Date().toISOString();
-    index.treeHash = treeHash;
-    index.fileHashes = fileHashes;
-    return index;
+  hasRemoteBranch(branch) {
+    try {
+      import_node_child_process4.execFileSync("git", ["ls-remote", "--exit-code", "--heads", "origin", branch], {
+        cwd: this.projectPath,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return true;
+    } catch {
+      return false;
+    }
   }
-  hashTree(tree) {
-    return import_node_crypto2.createHash("sha256").update(tree).digest("hex");
+  getPrDiff(branch) {
+    return import_node_child_process4.execFileSync("gh", ["pr", "diff", branch], {
+      cwd: this.projectPath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      maxBuffer: 10 * 1024 * 1024
+    });
   }
-  hashFile(filePath) {
+  submitReview(prIdentifier, body, event) {
     try {
-      const content = import_node_fs2.readFileSync(import_node_path4.join(this.projectPath, filePath), "utf-8");
-      return import_node_crypto2.createHash("sha256").update(content).digest("hex").slice(0, 16);
+      import_node_child_process4.execFileSync("gh", [
+        "pr",
+        "review",
+        prIdentifier,
+        "--body",
+        body,
+        `--${event.toLowerCase().replace("_", "-")}`
+      ], {
+        cwd: this.projectPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (event === "REQUEST_CHANGES" && msg.includes("own pull request")) {
+        import_node_child_process4.execFileSync("gh", ["pr", "review", prIdentifier, "--body", body, "--comment"], {
+          cwd: this.projectPath,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        return;
+      }
+      throw err;
+    }
+  }
+  listLocusPrs() {
+    try {
+      const output = import_node_child_process4.execFileSync("gh", [
+        "pr",
+        "list",
+        "--search",
+        "[Locus] in:title",
+        "--state",
+        "open",
+        "--json",
+        "number,title,url,headRefName"
+      ], {
+        cwd: this.projectPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      const prs = JSON.parse(output || "[]");
+      return prs.map((pr) => ({
+        number: pr.number,
+        title: pr.title,
+        url: pr.url,
+        branch: pr.headRefName
+      }));
     } catch {
-      return null;
+      this.log("Failed to list Locus PRs", "warn");
+      return [];
     }
   }
-  computeFileHashes(files) {
-    const hashes = {};
-    for (const file of files) {
-      const hash = this.hashFile(file);
-      if (hash !== null) {
-        hashes[file] = hash;
-      }
+  hasLocusReview(prNumber) {
+    try {
+      const output = import_node_child_process4.execFileSync("gh", ["pr", "view", prNumber, "--json", "reviews"], {
+        cwd: this.projectPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      const data = JSON.parse(output || "{}");
+      return data.reviews?.some((r) => r.body?.includes("## Locus Agent Review")) ?? false;
+    } catch {
+      return false;
     }
-    return hashes;
   }
-  diffFiles(currentHashes, existingHashes) {
-    const currentFiles = Object.keys(currentHashes);
-    const existingFiles = Object.keys(existingHashes);
-    const existingSet = new Set(existingFiles);
-    const currentSet = new Set(currentFiles);
-    const added = currentFiles.filter((f) => !existingSet.has(f));
-    const deleted = existingFiles.filter((f) => !currentSet.has(f));
-    const modified = currentFiles.filter((f) => existingSet.has(f) && currentHashes[f] !== existingHashes[f]);
-    return { added, deleted, modified };
+  listUnreviewedLocusPrs() {
+    const allPrs = this.listLocusPrs();
+    return allPrs.filter((pr) => !this.hasLocusReview(String(pr.number)));
   }
-  removeFilesFromIndex(index, files) {
-    const fileSet = new Set(files);
-    for (const file of files) {
-      delete index.responsibilities[file];
+  buildPrBody(task, agentId, summary) {
+    const sections = [];
+    sections.push(`## Task: ${task.title}`);
+    sections.push("");
+    if (task.description) {
+      sections.push(task.description);
+      sections.push("");
     }
-    for (const [symbol, paths] of Object.entries(index.symbols)) {
-      index.symbols[symbol] = paths.filter((p) => !fileSet.has(p));
-      if (index.symbols[symbol].length === 0) {
-        delete index.symbols[symbol];
+    if (task.acceptanceChecklist?.length > 0) {
+      sections.push("## Acceptance Criteria");
+      for (const item of task.acceptanceChecklist) {
+        sections.push(`- [ ] ${item.text}`);
       }
+      sections.push("");
     }
-  }
-  mergeIndex(existing, incremental, newHashes, newTreeHash) {
-    const mergedSymbols = { ...existing.symbols };
-    for (const [symbol, paths] of Object.entries(incremental.symbols)) {
-      if (mergedSymbols[symbol]) {
-        mergedSymbols[symbol] = [
-          ...new Set([...mergedSymbols[symbol], ...paths])
-        ];
-      } else {
-        mergedSymbols[symbol] = paths;
-      }
+    if (summary) {
+      sections.push("## Agent Summary");
+      sections.push(summary);
+      sections.push("");
     }
-    const merged = {
-      symbols: mergedSymbols,
-      responsibilities: {
-        ...existing.responsibilities,
-        ...incremental.responsibilities
-      },
-      lastIndexed: ""
-    };
-    return this.applyIndexMetadata(merged, newHashes, newTreeHash);
+    sections.push("---");
+    sections.push(`*Created by Locus Agent \`${agentId.slice(-8)}\`* | Task ID: \`${task.id}\``);
+    return sections.join(`
+`);
+  }
+  extractPrNumber(url) {
+    const match = url.match(/\/pull\/(\d+)/);
+    return match ? Number.parseInt(match[1], 10) : 0;
   }
 }
 
-// src/agent/codebase-indexer-service.ts
-class CodebaseIndexerService {
-  deps;
-  indexer;
-  constructor(deps) {
-    this.deps = deps;
-    this.indexer = new CodebaseIndexer(deps.projectPath);
+// src/project/knowledge-base.ts
+var import_node_fs2 = require("node:fs");
+var import_node_path4 = require("node:path");
+class KnowledgeBase {
+  contextPath;
+  progressPath;
+  constructor(projectPath) {
+    this.contextPath = getLocusPath(projectPath, "projectContextFile");
+    this.progressPath = getLocusPath(projectPath, "projectProgressFile");
   }
-  async reindex(force = false) {
-    try {
-      const index = await this.indexer.index((msg) => this.deps.log(msg, "info"), async (tree) => {
-        const prompt = `You are a codebase analysis expert. Analyze the file tree and extract:
-1. Key symbols (classes, functions, types) and their locations
-2. Responsibilities of each directory/file
-3. Overall project structure
+  readContext() {
+    if (!import_node_fs2.existsSync(this.contextPath)) {
+      return "";
+    }
+    return import_node_fs2.readFileSync(this.contextPath, "utf-8");
+  }
+  readProgress() {
+    if (!import_node_fs2.existsSync(this.progressPath)) {
+      return "";
+    }
+    return import_node_fs2.readFileSync(this.progressPath, "utf-8");
+  }
+  updateContext(content) {
+    this.ensureDir(this.contextPath);
+    import_node_fs2.writeFileSync(this.contextPath, content);
+  }
+  updateProgress(event) {
+    this.ensureDir(this.progressPath);
+    const existing = this.readProgress();
+    const timestamp = (event.timestamp ?? new Date).toISOString();
+    let entry = "";
+    switch (event.type) {
+      case "task_completed":
+        entry = `- [x] ${event.title} — completed ${timestamp}`;
+        break;
+      case "sprint_started":
+        entry = `
+## Current Sprint: ${event.title}
+**Status:** ACTIVE | Started: ${timestamp}
+`;
+        break;
+      case "sprint_completed":
+        entry = `
+### Sprint Completed: ${event.title} — ${timestamp}
+`;
+        break;
+      case "blocker":
+        entry = `- BLOCKER: ${event.title}`;
+        break;
+      case "pr_opened":
+        entry = `- [ ] ${event.title} — PR opened ${timestamp}`;
+        break;
+      case "pr_reviewed":
+        entry = `- ${event.title} — reviewed ${timestamp}`;
+        break;
+      case "pr_merged":
+        entry = `- [x] ${event.title} — PR merged ${timestamp}`;
+        break;
+      case "exec_completed":
+        entry = `- [x] ${event.title} — exec ${timestamp}`;
+        break;
+    }
+    if (event.details) {
+      entry += `
+  ${event.details}`;
+    }
+    const updated = existing ? `${existing}
+${entry}` : `# Project Progress
 
-Analyze this file tree and provide a JSON response with:
-- "symbols": object mapping symbol names to file paths (array)
-- "responsibilities": object mapping paths to brief descriptions
+${entry}`;
+    import_node_fs2.writeFileSync(this.progressPath, updated);
+  }
+  getFullContext() {
+    const context = this.readContext();
+    const progress = this.readProgress();
+    const parts = [];
+    if (context.trim()) {
+      parts.push(context.trim());
+    }
+    if (progress.trim()) {
+      parts.push(progress.trim());
+    }
+    return parts.join(`
 
-File tree:
-${tree}
+---
 
-Return ONLY valid JSON, no markdown formatting.`;
-        const response = await this.deps.aiRunner.run(prompt, true);
-        const jsonMatch = response.match(/\{[\s\S]*\}/);
-        if (jsonMatch) {
-          return JSON.parse(jsonMatch[0]);
-        }
-        return { symbols: {}, responsibilities: {}, lastIndexed: "" };
-      }, force);
-      if (index === null) {
-        this.deps.log("No changes detected, skipping reindex", "info");
-        return;
-      }
-      this.indexer.saveIndex(index);
-      this.deps.log("Codebase reindexed successfully", "success");
-    } catch (error) {
-      this.deps.log(`Failed to reindex codebase: ${error}`, "error");
+`);
+  }
+  initialize(info) {
+    this.ensureDir(this.contextPath);
+    this.ensureDir(this.progressPath);
+    const techStackList = info.techStack.map((t) => `- ${t}`).join(`
+`);
+    const contextContent = `# Project: ${info.name}
+
+## Mission
+${info.mission}
+
+## Tech Stack
+${techStackList}
+
+## Architecture
+<!-- Describe your high-level architecture here -->
+
+## Key Decisions
+<!-- Document important technical decisions and their rationale -->
+
+## Feature Areas
+<!-- List your main feature areas and their status -->
+`;
+    const progressContent = `# Project Progress
+
+No sprints started yet.
+`;
+    import_node_fs2.writeFileSync(this.contextPath, contextContent);
+    import_node_fs2.writeFileSync(this.progressPath, progressContent);
+  }
+  get exists() {
+    return import_node_fs2.existsSync(this.contextPath) || import_node_fs2.existsSync(this.progressPath);
+  }
+  ensureDir(filePath) {
+    const dir = import_node_path4.dirname(filePath);
+    if (!import_node_fs2.existsSync(dir)) {
+      import_node_fs2.mkdirSync(dir, { recursive: true });
     }
   }
 }
 
-// src/agent/document-fetcher.ts
+// src/worktree/worktree-manager.ts
+var import_node_child_process5 = require("node:child_process");
 var import_node_fs3 = require("node:fs");
 var import_node_path5 = require("node:path");
-class DocumentFetcher {
-  deps;
-  constructor(deps) {
-    this.deps = deps;
+
+// src/worktree/worktree-config.ts
+var WORKTREE_ROOT_DIR = ".locus-worktrees";
+var WORKTREE_BRANCH_PREFIX = "agent";
+var DEFAULT_WORKTREE_CONFIG = {
+  rootDir: WORKTREE_ROOT_DIR,
+  branchPrefix: WORKTREE_BRANCH_PREFIX,
+  cleanupPolicy: "retain-on-failure"
+};
+
+// src/worktree/worktree-manager.ts
+class WorktreeManager {
+  config;
+  projectPath;
+  log;
+  constructor(projectPath, config, log) {
+    this.projectPath = import_node_path5.resolve(projectPath);
+    this.config = { ...DEFAULT_WORKTREE_CONFIG, ...config };
+    this.log = log ?? ((_msg) => {
+      return;
+    });
   }
-  async fetch() {
-    const documentsDir = getLocusPath(this.deps.projectPath, "documentsDir");
-    if (!import_node_fs3.existsSync(documentsDir)) {
-      import_node_fs3.mkdirSync(documentsDir, { recursive: true });
+  get rootPath() {
+    return import_node_path5.join(this.projectPath, this.config.rootDir);
+  }
+  buildBranchName(taskId, taskSlug) {
+    const sanitized = taskSlug.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 50);
+    return `${this.config.branchPrefix}/${taskId}-${sanitized}`;
+  }
+  create(options) {
+    const branch = this.buildBranchName(options.taskId, options.taskSlug);
+    const worktreeDir = `${options.agentId}-${options.taskId}`;
+    const worktreePath = import_node_path5.join(this.rootPath, worktreeDir);
+    this.ensureDirectory(this.rootPath, "Worktree root");
+    const baseBranch = options.baseBranch ?? this.config.baseBranch ?? this.getCurrentBranch();
+    this.log(`Creating worktree: ${worktreeDir} (branch: ${branch}, base: ${baseBranch})`, "info");
+    if (import_node_fs3.existsSync(worktreePath)) {
+      this.log(`Removing stale worktree directory: ${worktreePath}`, "warn");
+      try {
+        this.git(`worktree remove "${worktreePath}" --force`, this.projectPath);
+      } catch {
+        import_node_fs3.rmSync(worktreePath, { recursive: true, force: true });
+        this.git("worktree prune", this.projectPath);
+      }
     }
-    try {
-      const groups = await this.deps.client.docs.listGroups(this.deps.workspaceId);
-      const groupMap = new Map(groups.map((g) => [g.id, g.name]));
-      const docs2 = await this.deps.client.docs.list(this.deps.workspaceId);
-      const artifactsGroupId = groups.find((g) => g.name === "Artifacts")?.id;
-      let fetchedCount = 0;
-      for (const doc of docs2) {
-        if (doc.groupId === artifactsGroupId) {
-          continue;
-        }
-        const groupName = groupMap.get(doc.groupId || "") || "General";
-        const groupDir = import_node_path5.join(documentsDir, groupName);
-        if (!import_node_fs3.existsSync(groupDir)) {
-          import_node_fs3.mkdirSync(groupDir, { recursive: true });
+    if (this.branchExists(branch)) {
+      this.log(`Deleting existing branch: ${branch}`, "warn");
+      const branchWorktrees = this.list().filter((wt) => wt.branch === branch);
+      for (const wt of branchWorktrees) {
+        const worktreePath2 = import_node_path5.resolve(wt.path);
+        if (wt.isMain || !this.isManagedWorktreePath(worktreePath2)) {
+          throw new Error(`Branch "${branch}" is checked out at "${worktreePath2}". Remove or detach that worktree before retrying.`);
         }
-        const fileName = `${doc.title}.md`;
-        const filePath = import_node_path5.join(groupDir, fileName);
-        if (!import_node_fs3.existsSync(filePath) || import_node_fs3.readFileSync(filePath, "utf-8") !== doc.content) {
-          import_node_fs3.writeFileSync(filePath, doc.content || "");
-          fetchedCount++;
+        this.log(`Removing existing worktree for branch: ${branch} (${worktreePath2})`, "warn");
+        this.remove(worktreePath2, false);
+      }
+      try {
+        this.git(`branch -D "${branch}"`, this.projectPath);
+      } catch {
+        this.git("worktree prune", this.projectPath);
+        this.git(`branch -D "${branch}"`, this.projectPath);
+      }
+    }
+    const addWorktree = () => this.git(`worktree add "${worktreePath}" -b "${branch}" "${baseBranch}"`, this.projectPath);
+    try {
+      addWorktree();
+    } catch (error) {
+      if (!this.isMissingDirectoryError(error)) {
+        throw error;
+      }
+      this.log(`Worktree creation failed due to missing directories. Retrying after cleanup: ${worktreePath}`, "warn");
+      this.cleanupFailedWorktree(worktreePath, branch);
+      this.ensureDirectory(this.rootPath, "Worktree root");
+      addWorktree();
+    }
+    this.log(`Worktree created at ${worktreePath}`, "success");
+    return { worktreePath, branch, baseBranch };
+  }
+  list() {
+    const output = this.git("worktree list --porcelain", this.projectPath);
+    const worktrees = [];
+    const blocks = output.trim().split(`
+
+`);
+    for (const block of blocks) {
+      if (!block.trim())
+        continue;
+      const lines = block.trim().split(`
+`);
+      let path = "";
+      let head = "";
+      let branch = "";
+      let isMain = false;
+      let isPrunable = false;
+      for (const line of lines) {
+        if (line.startsWith("worktree ")) {
+          path = line.slice("worktree ".length);
+        } else if (line.startsWith("HEAD ")) {
+          head = line.slice("HEAD ".length);
+        } else if (line.startsWith("branch ")) {
+          branch = line.slice("branch ".length).replace("refs/heads/", "");
+        } else if (line === "bare" || path === this.projectPath) {
+          isMain = true;
+        } else if (line === "prunable") {
+          isPrunable = true;
+        } else if (line === "detached") {
+          branch = "(detached)";
         }
       }
-      if (fetchedCount > 0) {
-        this.deps.log(`Fetched ${fetchedCount} document(s) from server`, "info");
+      if (import_node_path5.resolve(path) === this.projectPath) {
+        isMain = true;
+      }
+      if (path) {
+        worktrees.push({ path, branch, head, isMain, isPrunable });
+      }
+    }
+    return worktrees;
+  }
+  listAgentWorktrees() {
+    return this.list().filter((wt) => !wt.isMain);
+  }
+  remove(worktreePath, deleteBranch = true) {
+    const absolutePath = import_node_path5.resolve(worktreePath);
+    const worktrees = this.list();
+    const worktree = worktrees.find((wt) => import_node_path5.resolve(wt.path) === absolutePath);
+    const branchToDelete = worktree?.branch;
+    this.log(`Removing worktree: ${absolutePath}`, "info");
+    try {
+      this.git(`worktree remove "${absolutePath}" --force`, this.projectPath);
+    } catch {
+      if (import_node_fs3.existsSync(absolutePath)) {
+        import_node_fs3.rmSync(absolutePath, { recursive: true, force: true });
+      }
+      this.git("worktree prune", this.projectPath);
+    }
+    if (deleteBranch && branchToDelete && !branchToDelete.startsWith("(")) {
+      try {
+        this.git(`branch -D "${branchToDelete}"`, this.projectPath);
+        this.log(`Deleted branch: ${branchToDelete}`, "success");
+      } catch {
+        this.log(`Could not delete branch: ${branchToDelete} (may already be deleted)`, "warn");
+      }
+    }
+    this.log("Worktree removed", "success");
+  }
+  prune() {
+    const before = this.listAgentWorktrees().filter((wt) => wt.isPrunable).length;
+    this.git("worktree prune", this.projectPath);
+    const after = this.listAgentWorktrees().filter((wt) => wt.isPrunable).length;
+    const pruned = before - after;
+    if (pruned > 0) {
+      this.log(`Pruned ${pruned} stale worktree(s)`, "success");
+    }
+    return pruned;
+  }
+  removeAll() {
+    const agentWorktrees = this.listAgentWorktrees();
+    let removed = 0;
+    for (const wt of agentWorktrees) {
+      try {
+        this.remove(wt.path, true);
+        removed++;
+      } catch {
+        this.log(`Failed to remove worktree: ${wt.path}`, "warn");
       }
+    }
+    if (import_node_fs3.existsSync(this.rootPath)) {
+      try {
+        import_node_fs3.rmSync(this.rootPath, { recursive: true, force: true });
+      } catch {}
+    }
+    return removed;
+  }
+  hasChanges(worktreePath) {
+    const status = this.git("status --porcelain", worktreePath).trim();
+    return status.length > 0;
+  }
+  commitChanges(worktreePath, message) {
+    if (!this.hasChanges(worktreePath)) {
+      this.log("No changes to commit", "info");
+      return null;
+    }
+    this.git("add -A", worktreePath);
+    this.gitExec(["commit", "-m", message], worktreePath);
+    const hash = this.git("rev-parse HEAD", worktreePath).trim();
+    this.log(`Committed: ${hash.slice(0, 8)}`, "success");
+    return hash;
+  }
+  pushBranch(worktreePath, remote = "origin") {
+    const branch = this.getBranch(worktreePath);
+    this.log(`Pushing branch ${branch} to ${remote}`, "info");
+    try {
+      this.gitExec(["push", "-u", remote, branch], worktreePath);
+      this.log(`Pushed ${branch} to ${remote}`, "success");
+      return branch;
     } catch (error) {
-      this.deps.log(`Failed to fetch documents: ${error}`, "error");
+      if (!this.isNonFastForwardPushError(error)) {
+        throw error;
+      }
+      this.log(`Push rejected for ${branch} (non-fast-forward). Retrying with --force-with-lease.`, "warn");
+      try {
+        this.gitExec(["fetch", remote, branch], worktreePath);
+      } catch {}
+      this.gitExec(["push", "--force-with-lease", "-u", remote, branch], worktreePath);
+      this.log(`Pushed ${branch} to ${remote} with --force-with-lease`, "success");
+    }
+    return branch;
+  }
+  getBranch(worktreePath) {
+    return this.git("rev-parse --abbrev-ref HEAD", worktreePath).trim();
+  }
+  hasWorktreeForTask(taskId) {
+    return this.listAgentWorktrees().some((wt) => wt.branch.includes(taskId) || wt.path.includes(taskId));
+  }
+  branchExists(branchName) {
+    try {
+      this.git(`rev-parse --verify "refs/heads/${branchName}"`, this.projectPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getCurrentBranch() {
+    return this.git("rev-parse --abbrev-ref HEAD", this.projectPath).trim();
+  }
+  isManagedWorktreePath(worktreePath) {
+    const rootPath = import_node_path5.resolve(this.rootPath);
+    const candidate = import_node_path5.resolve(worktreePath);
+    const rootWithSep = rootPath.endsWith(import_node_path5.sep) ? rootPath : `${rootPath}${import_node_path5.sep}`;
+    return candidate.startsWith(rootWithSep);
+  }
+  ensureDirectory(dirPath, label) {
+    if (import_node_fs3.existsSync(dirPath)) {
+      if (!import_node_fs3.statSync(dirPath).isDirectory()) {
+        throw new Error(`${label} exists but is not a directory: ${dirPath}`);
+      }
+      return;
+    }
+    import_node_fs3.mkdirSync(dirPath, { recursive: true });
+  }
+  isMissingDirectoryError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.includes("cannot create directory") || message.includes("No such file or directory");
+  }
+  cleanupFailedWorktree(worktreePath, branch) {
+    try {
+      this.git(`worktree remove "${worktreePath}" --force`, this.projectPath);
+    } catch {}
+    if (import_node_fs3.existsSync(worktreePath)) {
+      import_node_fs3.rmSync(worktreePath, { recursive: true, force: true });
+    }
+    try {
+      this.git("worktree prune", this.projectPath);
+    } catch {}
+    if (this.branchExists(branch)) {
+      try {
+        this.git(`branch -D "${branch}"`, this.projectPath);
+      } catch {}
     }
   }
+  isNonFastForwardPushError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.includes("non-fast-forward") || message.includes("[rejected]") || message.includes("fetch first");
+  }
+  git(args, cwd) {
+    return import_node_child_process5.execSync(`git ${args}`, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  }
+  gitExec(args, cwd) {
+    return import_node_child_process5.execFileSync("git", args, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  }
 }
 
 // src/core/prompt-builder.ts
 var import_node_fs4 = require("node:fs");
-var import_node_os2 = require("node:os");
 var import_node_path6 = require("node:path");
 var import_shared2 = require("@locusai/shared");
 class PromptBuilder {
@@ -1613,11 +2069,12 @@ ${fallback}
     if (serverContext) {
       prompt += `## Project Context (Server)
 `;
-      if (serverContext.project) {
-        prompt += `- Project: ${serverContext.project.name || "Unknown"}
+      const project = serverContext.project;
+      if (project) {
+        prompt += `- Project: ${project.name || "Unknown"}
 `;
-        if (!hasLocalContext && serverContext.project.techStack?.length) {
-          prompt += `- Tech Stack: ${serverContext.project.techStack.join(", ")}
+        if (!hasLocalContext && project.techStack?.length) {
+          prompt += `- Tech Stack: ${project.techStack.join(", ")}
 `;
         }
       }
@@ -1630,12 +2087,11 @@ ${serverContext.context}
 `;
     }
     prompt += this.getProjectStructure();
-    prompt += this.getSkillsInfo();
     prompt += `## Project Knowledge Base
 `;
     prompt += `You have access to the following documentation directories for context:
 `;
-    prompt += `- Artifacts: \`.locus/artifacts\`)
+    prompt += `- Artifacts: \`.locus/artifacts\`
 `;
     prompt += `- Documents: \`.locus/documents\`
 `;
@@ -1693,11 +2149,9 @@ ${comment.text}
       }
     }
     prompt += `## Instructions
-1. Complete this task. 
+1. Complete this task.
 2. **Artifact Management**: If you create any high-level documentation (PRDs, technical drafts, architecture docs), you MUST save them in \`.locus/artifacts/\`. Do NOT create them in the root directory.
-3. **Paths**: Use relative paths from the project root at all times. Do NOT use absolute local paths (e.g., /Users/...).
-4. When finished successfully, output: <promise>COMPLETE</promise>
-`;
+3. **Paths**: Use relative paths from the project root at all times. Do NOT use absolute local paths (e.g., /Users/...).`;
     return prompt;
   }
   async buildGenericPrompt(query) {
@@ -1744,7 +2198,6 @@ ${fallback}
       }
     }
     prompt += this.getProjectStructure();
-    prompt += this.getSkillsInfo();
     prompt += `## Project Knowledge Base
 `;
     prompt += `You have access to the following documentation directories for context:
@@ -1765,9 +2218,7 @@ There is an index file in the .locus/codebase-index.json and if you need you can
     }
     prompt += `## Instructions
 1. Execute the prompt based on the provided project context.
-2. **Paths**: Use relative paths from the project root at all times. Do NOT use absolute local paths (e.g., /Users/...).
-3. When finished successfully, output: <promise>COMPLETE</promise>
-`;
+2. **Paths**: Use relative paths from the project root at all times. Do NOT use absolute local paths (e.g., /Users/...).`;
     return prompt;
   }
   getProjectConfig() {
@@ -1823,55 +2274,6 @@ There is an index file in the .locus/codebase-index.json and if you need you can
       return "";
     }
   }
-  getSkillsInfo() {
-    const projectSkillsDirs = [
-      LOCUS_CONFIG.agentSkillsDir,
-      ".cursor/skills",
-      ".claude/skills",
-      ".codex/skills",
-      ".gemini/skills"
-    ];
-    const globalHome = import_node_os2.homedir();
-    const globalSkillsDirs = [
-      import_node_path6.join(globalHome, ".cursor/skills"),
-      import_node_path6.join(globalHome, ".claude/skills"),
-      import_node_path6.join(globalHome, ".codex/skills"),
-      import_node_path6.join(globalHome, ".gemini/skills")
-    ];
-    const allSkillNames = new Set;
-    for (const relativePath of projectSkillsDirs) {
-      const fullPath = import_node_path6.join(this.projectPath, relativePath);
-      this.scanSkillsInDirectory(fullPath, allSkillNames);
-    }
-    for (const fullPath of globalSkillsDirs) {
-      this.scanSkillsInDirectory(fullPath, allSkillNames);
-    }
-    const uniqueSkills = Array.from(allSkillNames).sort();
-    if (uniqueSkills.length === 0)
-      return "";
-    return `## Available Agent Skills
-` + `The project has the following specialized skills available (from project or global locations):
-` + uniqueSkills.map((s) => `- ${s}`).join(`
-`) + `
-
-`;
-  }
-  scanSkillsInDirectory(dirPath, skillSet) {
-    if (!import_node_fs4.existsSync(dirPath))
-      return;
-    try {
-      const entries = import_node_fs4.readdirSync(dirPath).filter((name) => {
-        try {
-          return import_node_fs4.statSync(import_node_path6.join(dirPath, name)).isDirectory();
-        } catch {
-          return false;
-        }
-      });
-      for (const entry of entries) {
-        skillSet.add(entry);
-      }
-    } catch {}
-  }
   roleToText(role) {
     if (!role) {
       return null;
@@ -1901,42 +2303,15 @@ class TaskExecutor {
     this.deps = deps;
     this.promptBuilder = new PromptBuilder(deps.projectPath);
   }
-  async execute(task, context) {
+  async execute(task) {
     this.deps.log(`Executing: ${task.title}`, "info");
-    const basePrompt = await this.promptBuilder.build(task, {
-      taskContext: context
-    });
+    const basePrompt = await this.promptBuilder.build(task);
     try {
-      let plan = null;
-      this.deps.log("Phase 1: Planning (CLI)...", "info");
-      const planningPrompt = `${basePrompt}
-
-## Phase 1: Planning
-Analyze and create a detailed plan for THIS SPECIFIC TASK. Do NOT execute changes yet.`;
-      plan = await this.deps.aiRunner.run(planningPrompt, true);
       this.deps.log("Starting Execution...", "info");
-      let executionPrompt = basePrompt;
-      if (plan != null) {
-        executionPrompt += `
-
-## Phase 2: Execution
-Based on the plan, execute the task:
-
-${plan}`;
-      } else {
-        executionPrompt += `
-
-## Execution
-Execute the task directly.`;
-      }
-      executionPrompt += `
-
-When finished, output: <promise>COMPLETE</promise>`;
-      const output = await this.deps.aiRunner.run(executionPrompt);
-      const success = output.includes("<promise>COMPLETE</promise>");
+      await this.deps.aiRunner.run(basePrompt);
       return {
-        success,
-        summary: success ? "Task completed by the agent" : "The agent did not signal completion"
+        success: true,
+        summary: "Task completed by the agent"
       };
     } catch (error) {
       return { success: false, summary: `Error: ${error}` };
@@ -1960,14 +2335,17 @@ class AgentWorker {
   config;
   client;
   aiRunner;
-  indexerService;
-  documentFetcher;
   taskExecutor;
-  consecutiveEmpty = 0;
-  maxEmpty = 60;
+  knowledgeBase;
+  worktreeManager = null;
+  prService = null;
   maxTasks = 50;
   tasksCompleted = 0;
-  pollInterval = 1e4;
+  heartbeatInterval = null;
+  currentTaskId = null;
+  currentWorktreePath = null;
+  postCleanupDelayMs = 5000;
+  ghUsername = null;
   constructor(config) {
     this.config = config;
     const projectPath = config.projectPath || process.cwd();
@@ -1982,30 +2360,47 @@ class AgentWorker {
       }
     });
     const log = this.log.bind(this);
+    if (config.useWorktrees && !isGitAvailable()) {
+      this.log("git is not installed — worktree isolation will not work", "error");
+      config.useWorktrees = false;
+    }
+    if (config.autoPush && !isGhAvailable(projectPath)) {
+      this.log("GitHub CLI (gh) not available or not authenticated. Branch push can continue, but automatic PR creation may fail until gh is configured. Install from https://cli.github.com/", "warn");
+    }
+    if (config.autoPush) {
+      this.ghUsername = getGhUsername();
+      if (this.ghUsername) {
+        this.log(`GitHub user: ${this.ghUsername}`, "info");
+      }
+    }
     const provider = config.provider ?? PROVIDER.CLAUDE;
     this.aiRunner = createAiRunner(provider, {
       projectPath,
       model: config.model,
       log
     });
-    this.indexerService = new CodebaseIndexerService({
-      aiRunner: this.aiRunner,
-      projectPath,
-      log
-    });
-    this.documentFetcher = new DocumentFetcher({
-      client: this.client,
-      workspaceId: config.workspaceId,
-      projectPath,
-      log
-    });
-    this.taskExecutor = new TaskExecutor({
+    this.taskExecutor = new TaskExecutor({
       aiRunner: this.aiRunner,
       projectPath,
       log
     });
+    this.knowledgeBase = new KnowledgeBase(projectPath);
+    if (config.useWorktrees) {
+      this.worktreeManager = new WorktreeManager(projectPath, {
+        cleanupPolicy: "auto"
+      });
+    }
+    if (config.autoPush) {
+      this.prService = new PrService(projectPath, log);
+    }
     const providerLabel = provider === "codex" ? "Codex" : "Claude";
     this.log(`Using ${providerLabel} CLI for all phases`, "info");
+    if (config.useWorktrees) {
+      this.log("Per-task worktree isolation enabled", "info");
+      if (config.autoPush) {
+        this.log("Auto-push enabled: branches will be pushed to remote", "info");
+      }
+    }
   }
   log(message, level = "info") {
     const timestamp = new Date().toISOString().split("T")[1]?.slice(0, 8) ?? "";
@@ -2029,87 +2424,984 @@ class AgentWorker {
     }
   }
   async getNextTask() {
+    const maxRetries = 10;
+    for (let attempt = 1;attempt <= maxRetries; attempt++) {
+      try {
+        const task = await this.client.workspaces.dispatch(this.config.workspaceId, this.config.agentId, this.config.sprintId);
+        return task;
+      } catch (error) {
+        const isAxiosError = error != null && typeof error === "object" && "response" in error && typeof error.response?.status === "number";
+        const status = isAxiosError ? error.response.status : 0;
+        if (status === 404) {
+          this.log("No tasks available in the backlog.", "info");
+          return null;
+        }
+        const msg = error instanceof Error ? error.message : String(error);
+        if (attempt < maxRetries) {
+          this.log(`Nothing dispatched (attempt ${attempt}/${maxRetries}): ${msg}. Retrying in 30s...`, "warn");
+          await new Promise((r) => setTimeout(r, 30000));
+        } else {
+          this.log(`Nothing dispatched after ${maxRetries} attempts: ${msg}`, "warn");
+          return null;
+        }
+      }
+    }
+    return null;
+  }
+  createTaskWorktree(task) {
+    if (!this.worktreeManager) {
+      return {
+        worktreePath: null,
+        baseBranch: null,
+        executor: this.taskExecutor
+      };
+    }
+    const slug = task.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
+    const result = this.worktreeManager.create({
+      taskId: task.id,
+      taskSlug: slug,
+      agentId: this.config.agentId
+    });
+    this.log(`Worktree created: ${result.worktreePath} (${result.branch})`, "info");
+    const log = this.log.bind(this);
+    const provider = this.config.provider ?? PROVIDER.CLAUDE;
+    const taskAiRunner = createAiRunner(provider, {
+      projectPath: result.worktreePath,
+      model: this.config.model,
+      log
+    });
+    const taskExecutor = new TaskExecutor({
+      aiRunner: taskAiRunner,
+      projectPath: result.worktreePath,
+      log
+    });
+    return {
+      worktreePath: result.worktreePath,
+      baseBranch: result.baseBranch,
+      executor: taskExecutor
+    };
+  }
+  commitAndPushWorktree(worktreePath, task) {
+    if (!this.worktreeManager) {
+      return { branch: null, pushed: false, pushFailed: false };
+    }
     try {
-      const task = await this.client.workspaces.dispatch(this.config.workspaceId, this.config.agentId, this.config.sprintId);
-      return task;
-    } catch (error) {
-      this.log(`No task dispatched: ${error instanceof Error ? error.message : String(error)}`, "info");
-      return null;
+      const trailers = [
+        `Task-ID: ${task.id}`,
+        `Agent: ${this.config.agentId}`,
+        "Co-authored-by: LocusAI <noreply@locusai.dev>"
+      ];
+      if (this.ghUsername) {
+        trailers.push(`Co-authored-by: ${this.ghUsername} <${this.ghUsername}@users.noreply.github.com>`);
+      }
+      const commitMessage = `feat(agent): ${task.title}
+
+${trailers.join(`
+`)}`;
+      const hash = this.worktreeManager.commitChanges(worktreePath, commitMessage);
+      if (!hash) {
+        this.log("No changes to commit for this task", "info");
+        return {
+          branch: null,
+          pushed: false,
+          pushFailed: false,
+          noChanges: true,
+          skipReason: "No changes were committed, so no branch was pushed."
+        };
+      }
+      const localBranch = this.worktreeManager.getBranch(worktreePath);
+      if (this.config.autoPush) {
+        try {
+          return {
+            branch: this.worktreeManager.pushBranch(worktreePath),
+            pushed: true,
+            pushFailed: false
+          };
+        } catch (err) {
+          const errorMessage = err instanceof Error ? err.message : String(err);
+          this.log(`Git push failed: ${errorMessage}`, "error");
+          return {
+            branch: localBranch,
+            pushed: false,
+            pushFailed: true,
+            pushError: errorMessage
+          };
+        }
+      }
+      this.log("Auto-push disabled; skipping branch push", "info");
+      return {
+        branch: localBranch,
+        pushed: false,
+        pushFailed: false,
+        skipReason: "Auto-push is disabled, so PR creation was skipped."
+      };
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      this.log(`Git commit failed: ${errorMessage}`, "error");
+      return { branch: null, pushed: false, pushFailed: false };
+    }
+  }
+  createPullRequest(task, branch, summary, baseBranch) {
+    if (!this.prService) {
+      const errorMessage = "PR service is not initialized. Enable auto-push to allow PR creation.";
+      this.log(`PR creation skipped: ${errorMessage}`, "warn");
+      return { url: null, error: errorMessage };
+    }
+    this.log(`Attempting PR creation from branch: ${branch}`, "info");
+    try {
+      const result = this.prService.createPr({
+        task,
+        branch,
+        baseBranch,
+        agentId: this.config.agentId,
+        summary
+      });
+      return { url: result.url };
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      this.log(`PR creation failed: ${errorMessage}`, "error");
+      return { url: null, error: errorMessage };
+    }
+  }
+  cleanupTaskWorktree(worktreePath, keepBranch) {
+    if (!this.worktreeManager || !worktreePath)
+      return;
+    try {
+      this.worktreeManager.remove(worktreePath, !keepBranch);
+      this.log(keepBranch ? "Worktree cleaned up (branch preserved)" : "Worktree cleaned up", "info");
+    } catch {
+      this.log(`Could not clean up worktree: ${worktreePath}`, "warn");
     }
+    this.currentWorktreePath = null;
   }
   async executeTask(task) {
     const fullTask = await this.client.tasks.getById(task.id, this.config.workspaceId);
-    let context = "";
+    const { worktreePath, baseBranch, executor } = this.createTaskWorktree(fullTask);
+    this.currentWorktreePath = worktreePath;
+    let branchPushed = false;
+    let keepBranch = false;
+    let preserveWorktree = false;
+    try {
+      const result = await executor.execute(fullTask);
+      let taskBranch = null;
+      let prUrl = null;
+      let prError = null;
+      let noChanges = false;
+      if (result.success && worktreePath) {
+        const commitResult = this.commitAndPushWorktree(worktreePath, fullTask);
+        taskBranch = commitResult.branch;
+        branchPushed = commitResult.pushed;
+        keepBranch = taskBranch !== null;
+        noChanges = Boolean(commitResult.noChanges);
+        if (commitResult.pushFailed) {
+          preserveWorktree = true;
+          prError = commitResult.pushError ?? "Git push failed before PR creation. Please retry manually.";
+          this.log(`Preserving worktree after push failure: ${worktreePath}`, "warn");
+        }
+        if (branchPushed && taskBranch) {
+          const prResult = this.createPullRequest(fullTask, taskBranch, result.summary, baseBranch ?? undefined);
+          prUrl = prResult.url;
+          prError = prResult.error ?? null;
+          if (!prUrl) {
+            preserveWorktree = true;
+            this.log(`Preserving worktree for manual follow-up: ${worktreePath}`, "warn");
+          }
+        } else if (commitResult.skipReason) {
+          this.log(`Skipping PR creation: ${commitResult.skipReason}`, "info");
+        }
+      } else if (result.success && !worktreePath) {
+        this.log("Skipping commit/push/PR flow because no task worktree is active.", "warn");
+      }
+      return {
+        ...result,
+        branch: taskBranch ?? undefined,
+        prUrl: prUrl ?? undefined,
+        prError: prError ?? undefined,
+        noChanges: noChanges || undefined
+      };
+    } finally {
+      if (preserveWorktree || keepBranch) {
+        this.currentWorktreePath = null;
+      } else {
+        this.cleanupTaskWorktree(worktreePath, keepBranch);
+      }
+    }
+  }
+  updateProgress(task, success) {
     try {
-      context = await this.client.tasks.getContext(task.id, this.config.workspaceId);
+      if (success) {
+        this.knowledgeBase.updateProgress({
+          type: "task_completed",
+          title: task.title,
+          details: `Agent: ${this.config.agentId.slice(-8)}`
+        });
+        this.log(`Updated progress.md: ${task.title}`, "info");
+      }
     } catch (err) {
-      this.log(`Failed to fetch task context: ${err}`, "warn");
+      this.log(`Failed to update progress: ${err instanceof Error ? err.message : String(err)}`, "warn");
+    }
+  }
+  startHeartbeat() {
+    this.sendHeartbeat();
+    this.heartbeatInterval = setInterval(() => {
+      this.sendHeartbeat();
+    }, 60000);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
     }
-    const result = await this.taskExecutor.execute(fullTask, context);
-    await this.indexerService.reindex();
-    return result;
+  }
+  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 delayAfterCleanup() {
+    if (!this.config.useWorktrees || this.postCleanupDelayMs <= 0)
+      return;
+    this.log(`Waiting ${Math.floor(this.postCleanupDelayMs / 1000)}s after worktree cleanup before next dispatch`, "info");
+    await new Promise((resolve3) => setTimeout(resolve3, this.postCleanupDelayMs));
   }
   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.cleanupTaskWorktree(this.currentWorktreePath, false);
+      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}. Ensuring plan is up to date...`, "info");
-      try {
-        await this.client.sprints.triggerAIPlanning(sprint.id, this.config.workspaceId);
-        this.log(`Sprint plan sync checked on server.`, "success");
-      } catch (err) {
-        this.log(`Sprint planning sync failed (non-critical): ${err instanceof Error ? err.message : String(err)}`, "warn");
-      }
+      this.log(`Active sprint found: ${sprint.name}`, "info");
     } else {
-      this.log("No active sprint found for planning.", "warn");
+      this.log("No active sprint found.", "warn");
+    }
+    while (this.tasksCompleted < this.maxTasks) {
+      const task = await this.getNextTask();
+      if (!task) {
+        this.log("No more tasks to process. Exiting.", "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: this.config.agentId,
+            text: `⚠️ Agent execution finished with no file changes, so no commit/branch/PR was created.
+
+${result.summary}`
+          });
+        } else {
+          this.log(`Completed: ${task.title}`, "success");
+          const updatePayload = {
+            status: import_shared3.TaskStatus.IN_REVIEW
+          };
+          if (result.prUrl) {
+            updatePayload.prUrl = result.prUrl;
+          }
+          await this.client.tasks.update(task.id, this.config.workspaceId, updatePayload);
+          const branchInfo = result.branch ? `
+
+Branch: \`${result.branch}\`` : "";
+          const prInfo = result.prUrl ? `
+PR: ${result.prUrl}` : "";
+          const prErrorInfo = result.prError ? `
+PR automation error: ${result.prError}` : "";
+          await this.client.tasks.addComment(task.id, this.config.workspaceId, {
+            author: this.config.agentId,
+            text: `✅ ${result.summary}${branchInfo}${prInfo}${prErrorInfo}`
+          });
+          this.tasksCompleted++;
+          this.updateProgress(task, true);
+          if (result.prUrl) {
+            try {
+              this.knowledgeBase.updateProgress({
+                type: "pr_opened",
+                title: task.title,
+                details: `PR: ${result.prUrl}`
+              });
+            } catch {}
+          }
+        }
+      } 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: this.config.agentId,
+          text: `❌ ${result.summary}`
+        });
+      }
+      this.currentTaskId = null;
+      this.sendHeartbeat();
+      await this.delayAfterCleanup();
+    }
+    this.currentTaskId = null;
+    this.stopHeartbeat();
+    this.client.workspaces.heartbeat(this.config.workspaceId, this.config.agentId, null, "COMPLETED").catch(() => {});
+    process.exit(0);
+  }
+}
+var workerEntrypoint = process.argv[1]?.split(/[\\/]/).pop();
+if (workerEntrypoint === "worker.js" || workerEntrypoint === "worker.ts") {
+  process.title = "locus-worker";
+  const args = process.argv.slice(2);
+  const config = {};
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--agent-id")
+      config.agentId = args[++i];
+    else if (arg === "--workspace-id")
+      config.workspaceId = args[++i];
+    else if (arg === "--sprint-id")
+      config.sprintId = args[++i];
+    else if (arg === "--api-url")
+      config.apiBase = args[++i];
+    else if (arg === "--api-key")
+      config.apiKey = args[++i];
+    else if (arg === "--project-path")
+      config.projectPath = args[++i];
+    else if (arg === "--main-project-path")
+      config.mainProjectPath = args[++i];
+    else if (arg === "--model")
+      config.model = args[++i];
+    else if (arg === "--use-worktrees")
+      config.useWorktrees = true;
+    else if (arg === "--auto-push")
+      config.autoPush = true;
+    else if (arg === "--provider") {
+      const value = args[i + 1];
+      if (value && !value.startsWith("--"))
+        i++;
+      config.provider = resolveProvider(value);
+    }
+  }
+  if (!config.agentId || !config.workspaceId || !config.apiBase || !config.apiKey || !config.projectPath) {
+    console.error("Missing required arguments");
+    process.exit(1);
+  }
+  const worker = new AgentWorker(config);
+  worker.run().catch((err) => {
+    console.error("Fatal worker error:", err);
+    process.exit(1);
+  });
+}
+
+// src/index-node.ts
+var exports_index_node = {};
+__export(exports_index_node, {
+  sprintPlanToMarkdown: () => sprintPlanToMarkdown,
+  plannedTasksToCreatePayloads: () => plannedTasksToCreatePayloads,
+  parseSprintPlanFromAI: () => parseSprintPlanFromAI,
+  getRemoteUrl: () => getRemoteUrl,
+  getLocusPath: () => getLocusPath,
+  getDefaultBranch: () => getDefaultBranch,
+  getCurrentBranch: () => getCurrentBranch,
+  getAgentArtifactsPath: () => getAgentArtifactsPath,
+  detectRemoteProvider: () => detectRemoteProvider,
+  createAiRunner: () => createAiRunner,
+  c: () => c,
+  WorktreeManager: () => WorktreeManager,
+  WorkspacesModule: () => WorkspacesModule,
+  WORKTREE_ROOT_DIR: () => WORKTREE_ROOT_DIR,
+  WORKTREE_BRANCH_PREFIX: () => WORKTREE_BRANCH_PREFIX,
+  TasksModule: () => TasksModule,
+  TaskExecutor: () => TaskExecutor,
+  SprintsModule: () => SprintsModule,
+  ReviewerWorker: () => ReviewerWorker,
+  ReviewService: () => ReviewService,
+  PromptBuilder: () => PromptBuilder,
+  PrService: () => PrService,
+  PlanningMeeting: () => PlanningMeeting,
+  PlanManager: () => PlanManager,
+  PROVIDER: () => PROVIDER,
+  OrganizationsModule: () => OrganizationsModule,
+  LocusEvent: () => LocusEvent,
+  LocusEmitter: () => LocusEmitter,
+  LocusClient: () => LocusClient,
+  LOCUS_SCHEMA_BASE_URL: () => LOCUS_SCHEMA_BASE_URL,
+  LOCUS_SCHEMAS: () => LOCUS_SCHEMAS,
+  LOCUS_GITIGNORE_PATTERNS: () => LOCUS_GITIGNORE_PATTERNS,
+  LOCUS_CONFIG: () => LOCUS_CONFIG,
+  KnowledgeBase: () => KnowledgeBase,
+  InvitationsModule: () => InvitationsModule,
+  HistoryManager: () => HistoryManager,
+  ExecSession: () => ExecSession,
+  ExecEventType: () => ExecEventType,
+  ExecEventEmitter: () => ExecEventEmitter,
+  DocumentFetcher: () => DocumentFetcher,
+  DocsModule: () => DocsModule,
+  DEFAULT_WORKTREE_CONFIG: () => DEFAULT_WORKTREE_CONFIG,
+  DEFAULT_MODEL: () => DEFAULT_MODEL,
+  ContextTracker: () => ContextTracker,
+  CodexRunner: () => CodexRunner,
+  CodebaseIndexerService: () => CodebaseIndexerService,
+  CodebaseIndexer: () => CodebaseIndexer,
+  ClaudeRunner: () => ClaudeRunner,
+  CiModule: () => CiModule,
+  AuthModule: () => AuthModule,
+  AgentWorker: () => AgentWorker,
+  AgentOrchestrator: () => AgentOrchestrator
+});
+module.exports = __toCommonJS(exports_index_node);
+
+// src/core/indexer.ts
+var import_node_crypto2 = require("node:crypto");
+var import_node_fs5 = require("node:fs");
+var import_node_path7 = require("node:path");
+var import_globby = require("globby");
+
+class CodebaseIndexer {
+  projectPath;
+  indexPath;
+  fullReindexRatioThreshold = 0.2;
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+    this.indexPath = import_node_path7.join(projectPath, ".locus", "codebase-index.json");
+  }
+  async index(onProgress, treeSummarizer, force = false) {
+    if (!treeSummarizer) {
+      throw new Error("A treeSummarizer is required for this indexing method.");
+    }
+    onProgress?.("Generating file tree...");
+    const currentFiles = await this.getFileTree();
+    const treeString = currentFiles.join(`
+`);
+    const newTreeHash = this.hashTree(treeString);
+    const existingIndex = this.loadIndex();
+    const currentHashes = this.computeFileHashes(currentFiles);
+    const existingHashes = existingIndex?.fileHashes;
+    const hasExistingContent = existingIndex && (Object.keys(existingIndex.symbols).length > 0 || Object.keys(existingIndex.responsibilities).length > 0);
+    const canIncremental = !force && existingIndex && existingHashes && hasExistingContent;
+    if (canIncremental) {
+      onProgress?.("Performing incremental update");
+      const { added, deleted, modified } = this.diffFiles(currentHashes, existingHashes);
+      const changedFiles = [...added, ...modified];
+      const totalChanges = changedFiles.length + deleted.length;
+      const existingFileCount = Object.keys(existingHashes).length;
+      onProgress?.(`File changes detected: ${changedFiles.length} changed, ${added.length} added, ${deleted.length} deleted`);
+      if (existingFileCount > 0) {
+        const changeRatio = totalChanges / existingFileCount;
+        if (changeRatio <= this.fullReindexRatioThreshold && changedFiles.length > 0) {
+          onProgress?.(`Reindexing ${changedFiles.length} changed files and merging with existing index`);
+          const incrementalIndex = await treeSummarizer(changedFiles.join(`
+`));
+          const updatedIndex = this.cloneIndex(existingIndex);
+          this.removeFilesFromIndex(updatedIndex, [...deleted, ...modified]);
+          return this.mergeIndex(updatedIndex, incrementalIndex, currentHashes, newTreeHash);
+        }
+        if (changedFiles.length === 0 && deleted.length > 0) {
+          onProgress?.(`Removing ${deleted.length} deleted files from index`);
+          const updatedIndex = this.cloneIndex(existingIndex);
+          this.removeFilesFromIndex(updatedIndex, deleted);
+          return this.applyIndexMetadata(updatedIndex, currentHashes, newTreeHash);
+        }
+        if (changedFiles.length === 0 && deleted.length === 0) {
+          onProgress?.("No actual file changes, updating hashes only");
+          const updatedIndex = this.cloneIndex(existingIndex);
+          return this.applyIndexMetadata(updatedIndex, currentHashes, newTreeHash);
+        }
+        onProgress?.(`Too many changes (${(changeRatio * 100).toFixed(1)}%), performing full reindex`);
+      }
+    }
+    onProgress?.("AI is analyzing codebase structure...");
+    try {
+      const index = await treeSummarizer(treeString);
+      return this.applyIndexMetadata(index, currentHashes, newTreeHash);
+    } catch (error) {
+      throw new Error(`AI analysis failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async getFileTree() {
+    const gitmodulesPath = import_node_path7.join(this.projectPath, ".gitmodules");
+    const submoduleIgnores = [];
+    if (import_node_fs5.existsSync(gitmodulesPath)) {
+      try {
+        const content = import_node_fs5.readFileSync(gitmodulesPath, "utf-8");
+        const lines = content.split(`
+`);
+        for (const line of lines) {
+          const match = line.match(/^\s*path\s*=\s*(.*)$/);
+          const path = match?.[1]?.trim();
+          if (path) {
+            submoduleIgnores.push(`${path}/**`);
+            submoduleIgnores.push(`**/${path}/**`);
+          }
+        }
+      } catch {}
+    }
+    return import_globby.globby(["**/*"], {
+      cwd: this.projectPath,
+      gitignore: true,
+      ignore: [
+        ...submoduleIgnores,
+        "**/node_modules/**",
+        "**/dist/**",
+        "**/build/**",
+        "**/target/**",
+        "**/bin/**",
+        "**/obj/**",
+        "**/.next/**",
+        "**/.svelte-kit/**",
+        "**/.nuxt/**",
+        "**/.cache/**",
+        "**/out/**",
+        "**/__tests__/**",
+        "**/coverage/**",
+        "**/*.test.*",
+        "**/*.spec.*",
+        "**/*.d.ts",
+        "**/tsconfig.tsbuildinfo",
+        "**/.locus/*.json",
+        "**/.locus/*.md",
+        "**/.locus/!(artifacts)/**",
+        "**/.git/**",
+        "**/.svn/**",
+        "**/.hg/**",
+        "**/.vscode/**",
+        "**/.idea/**",
+        "**/.DS_Store",
+        "**/bun.lock",
+        "**/package-lock.json",
+        "**/yarn.lock",
+        "**/pnpm-lock.yaml",
+        "**/Cargo.lock",
+        "**/go.sum",
+        "**/poetry.lock",
+        "**/*.{png,jpg,jpeg,gif,svg,ico,mp4,webm,wav,mp3,woff,woff2,eot,ttf,otf,pdf,zip,tar.gz,rar}"
+      ]
+    });
+  }
+  loadIndex() {
+    if (import_node_fs5.existsSync(this.indexPath)) {
+      try {
+        return JSON.parse(import_node_fs5.readFileSync(this.indexPath, "utf-8"));
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  saveIndex(index) {
+    const dir = import_node_path7.dirname(this.indexPath);
+    if (!import_node_fs5.existsSync(dir)) {
+      import_node_fs5.mkdirSync(dir, { recursive: true });
+    }
+    import_node_fs5.writeFileSync(this.indexPath, JSON.stringify(index, null, 2));
+  }
+  cloneIndex(index) {
+    return JSON.parse(JSON.stringify(index));
+  }
+  applyIndexMetadata(index, fileHashes, treeHash) {
+    index.lastIndexed = new Date().toISOString();
+    index.treeHash = treeHash;
+    index.fileHashes = fileHashes;
+    return index;
+  }
+  hashTree(tree) {
+    return import_node_crypto2.createHash("sha256").update(tree).digest("hex");
+  }
+  hashFile(filePath) {
+    try {
+      const content = import_node_fs5.readFileSync(import_node_path7.join(this.projectPath, filePath), "utf-8");
+      return import_node_crypto2.createHash("sha256").update(content).digest("hex").slice(0, 16);
+    } catch {
+      return null;
+    }
+  }
+  computeFileHashes(files) {
+    const hashes = {};
+    for (const file of files) {
+      const hash = this.hashFile(file);
+      if (hash !== null) {
+        hashes[file] = hash;
+      }
+    }
+    return hashes;
+  }
+  diffFiles(currentHashes, existingHashes) {
+    const currentFiles = Object.keys(currentHashes);
+    const existingFiles = Object.keys(existingHashes);
+    const existingSet = new Set(existingFiles);
+    const currentSet = new Set(currentFiles);
+    const added = currentFiles.filter((f) => !existingSet.has(f));
+    const deleted = existingFiles.filter((f) => !currentSet.has(f));
+    const modified = currentFiles.filter((f) => existingSet.has(f) && currentHashes[f] !== existingHashes[f]);
+    return { added, deleted, modified };
+  }
+  removeFilesFromIndex(index, files) {
+    const fileSet = new Set(files);
+    for (const file of files) {
+      delete index.responsibilities[file];
+    }
+    for (const [symbol, paths] of Object.entries(index.symbols)) {
+      index.symbols[symbol] = paths.filter((p) => !fileSet.has(p));
+      if (index.symbols[symbol].length === 0) {
+        delete index.symbols[symbol];
+      }
+    }
+  }
+  mergeIndex(existing, incremental, newHashes, newTreeHash) {
+    const mergedSymbols = { ...existing.symbols };
+    for (const [symbol, paths] of Object.entries(incremental.symbols)) {
+      if (mergedSymbols[symbol]) {
+        mergedSymbols[symbol] = [
+          ...new Set([...mergedSymbols[symbol], ...paths])
+        ];
+      } else {
+        mergedSymbols[symbol] = paths;
+      }
+    }
+    const merged = {
+      symbols: mergedSymbols,
+      responsibilities: {
+        ...existing.responsibilities,
+        ...incremental.responsibilities
+      },
+      lastIndexed: ""
+    };
+    return this.applyIndexMetadata(merged, newHashes, newTreeHash);
+  }
+}
+
+// src/agent/codebase-indexer-service.ts
+class CodebaseIndexerService {
+  deps;
+  indexer;
+  constructor(deps) {
+    this.deps = deps;
+    this.indexer = new CodebaseIndexer(deps.projectPath);
+  }
+  async reindex(force = false) {
+    try {
+      const index = await this.indexer.index((msg) => this.deps.log(msg, "info"), async (tree) => {
+        const prompt = `You are a codebase analysis expert. Analyze the file tree and extract:
+1. Key symbols (classes, functions, types) and their locations
+2. Responsibilities of each directory/file
+3. Overall project structure
+
+Analyze this file tree and provide a JSON response with:
+- "symbols": object mapping symbol names to file paths (array)
+- "responsibilities": object mapping paths to brief descriptions
+
+File tree:
+${tree}
+
+Return ONLY valid JSON, no markdown formatting.`;
+        const response = await this.deps.aiRunner.run(prompt);
+        const jsonMatch = response.match(/\{[\s\S]*\}/);
+        if (jsonMatch) {
+          return JSON.parse(jsonMatch[0]);
+        }
+        return { symbols: {}, responsibilities: {}, lastIndexed: "" };
+      }, force);
+      if (index === null) {
+        this.deps.log("No changes detected, skipping reindex", "info");
+        return;
+      }
+      this.indexer.saveIndex(index);
+      this.deps.log("Codebase reindexed successfully", "success");
+    } catch (error) {
+      this.deps.log(`Failed to reindex codebase: ${error}`, "error");
+    }
+  }
+}
+// src/agent/document-fetcher.ts
+var import_node_fs6 = require("node:fs");
+var import_node_path8 = require("node:path");
+class DocumentFetcher {
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  async fetch() {
+    const documentsDir = getLocusPath(this.deps.projectPath, "documentsDir");
+    if (!import_node_fs6.existsSync(documentsDir)) {
+      import_node_fs6.mkdirSync(documentsDir, { recursive: true });
+    }
+    try {
+      const groups = await this.deps.client.docs.listGroups(this.deps.workspaceId);
+      const groupMap = new Map(groups.map((g) => [g.id, g.name]));
+      const docs2 = await this.deps.client.docs.list(this.deps.workspaceId);
+      const artifactsGroupId = groups.find((g) => g.name === "Artifacts")?.id;
+      let fetchedCount = 0;
+      for (const doc of docs2) {
+        if (doc.groupId === artifactsGroupId) {
+          continue;
+        }
+        const groupName = groupMap.get(doc.groupId || "") || "General";
+        const groupDir = import_node_path8.join(documentsDir, groupName);
+        if (!import_node_fs6.existsSync(groupDir)) {
+          import_node_fs6.mkdirSync(groupDir, { recursive: true });
+        }
+        const fileName = `${doc.title}.md`;
+        const filePath = import_node_path8.join(groupDir, fileName);
+        if (!import_node_fs6.existsSync(filePath) || import_node_fs6.readFileSync(filePath, "utf-8") !== doc.content) {
+          import_node_fs6.writeFileSync(filePath, doc.content || "");
+          fetchedCount++;
+        }
+      }
+      if (fetchedCount > 0) {
+        this.deps.log(`Fetched ${fetchedCount} document(s) from server`, "info");
+      }
+    } catch (error) {
+      this.deps.log(`Failed to fetch documents: ${error}`, "error");
+      throw error;
+    }
+  }
+}
+// src/agent/review-service.ts
+var import_node_child_process6 = require("node:child_process");
+
+class ReviewService {
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  async reviewStagedChanges(sprint) {
+    const { projectPath, log } = this.deps;
+    try {
+      import_node_child_process6.execSync("git add -A", { cwd: projectPath, stdio: "pipe" });
+      log("Staged all changes for review.", "info");
+    } catch (err) {
+      log(`Failed to stage changes: ${err instanceof Error ? err.message : String(err)}`, "error");
+      return null;
+    }
+    let diff;
+    try {
+      diff = import_node_child_process6.execSync("git diff --cached --stat && echo '---' && git diff --cached", {
+        cwd: projectPath,
+        maxBuffer: 10 * 1024 * 1024
+      }).toString();
+    } catch (err) {
+      log(`Failed to get staged diff: ${err instanceof Error ? err.message : String(err)}`, "error");
+      return null;
+    }
+    if (!diff.trim()) {
+      return null;
+    }
+    const sprintInfo = sprint ? `Sprint: ${sprint.name} (${sprint.id})` : "No active sprint";
+    const reviewPrompt = `# Code Review Request
+
+## Context
+${sprintInfo}
+Date: ${new Date().toISOString()}
+
+## Staged Changes (git diff)
+\`\`\`diff
+${diff}
+\`\`\`
+
+## Instructions
+You are reviewing the staged changes at the end of a sprint. Produce a thorough markdown review report with the following sections:
+
+1. **Summary** — Brief overview of what changed and why.
+2. **Files Changed** — List each file with a short description of changes.
+3. **Code Quality** — Note any code quality concerns (naming, structure, complexity).
+4. **Potential Issues** — Identify bugs, security issues, edge cases, or regressions.
+5. **Recommendations** — Actionable suggestions for improvement.
+6. **Overall Assessment** — A short verdict (e.g., "Looks good", "Needs attention", "Critical issues found").
+
+Keep the review concise but thorough. Focus on substance over style.`;
+    log("Running AI review on staged changes...", "info");
+    const report = await this.deps.aiRunner.run(reviewPrompt);
+    return report;
+  }
+}
+// src/agent/reviewer-worker.ts
+function resolveProvider2(value) {
+  if (!value || value.startsWith("--"))
+    return PROVIDER.CLAUDE;
+  if (value === PROVIDER.CLAUDE || value === PROVIDER.CODEX)
+    return value;
+  return PROVIDER.CLAUDE;
+}
+
+class ReviewerWorker {
+  config;
+  client;
+  aiRunner;
+  prService;
+  knowledgeBase;
+  heartbeatInterval = null;
+  currentTaskId = null;
+  maxReviews = 50;
+  reviewsCompleted = 0;
+  constructor(config) {
+    this.config = config;
+    const projectPath = config.projectPath || process.cwd();
+    this.client = new LocusClient({
+      baseUrl: config.apiBase,
+      token: config.apiKey,
+      retryOptions: {
+        maxRetries: 3,
+        initialDelay: 1000,
+        maxDelay: 5000,
+        factor: 2
+      }
+    });
+    const log = this.log.bind(this);
+    const provider = config.provider ?? PROVIDER.CLAUDE;
+    this.aiRunner = createAiRunner(provider, {
+      projectPath,
+      model: config.model,
+      log
+    });
+    this.prService = new PrService(projectPath, log);
+    this.knowledgeBase = new KnowledgeBase(projectPath);
+    const providerLabel = provider === "codex" ? "Codex" : "Claude";
+    this.log(`Reviewer agent using ${providerLabel} CLI`, "info");
+  }
+  log(message, level = "info") {
+    const timestamp = new Date().toISOString().split("T")[1]?.slice(0, 8) ?? "";
+    const colorFn = {
+      info: c.cyan,
+      success: c.green,
+      warn: c.yellow,
+      error: c.red
+    }[level];
+    const prefix = { info: "ℹ", success: "✓", warn: "⚠", error: "✗" }[level];
+    console.log(`${c.dim(`[${timestamp}]`)} ${c.bold(`[R:${this.config.agentId.slice(-8)}]`)} ${colorFn(`${prefix} ${message}`)}`);
+  }
+  getNextUnreviewedPr() {
+    const prs = this.prService.listUnreviewedLocusPrs();
+    return prs.length > 0 ? prs[0] : null;
+  }
+  async reviewPr(pr) {
+    const prNumber = String(pr.number);
+    this.log(`Reviewing PR #${prNumber}: ${pr.title}`, "info");
+    let diff;
+    try {
+      diff = this.prService.getPrDiff(prNumber);
+    } catch (err) {
+      return {
+        reviewed: false,
+        approved: false,
+        summary: `Failed to get PR diff: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+    if (!diff.trim()) {
+      return {
+        reviewed: true,
+        approved: true,
+        summary: "PR has no changes (empty diff)"
+      };
+    }
+    const reviewPrompt = `# Code Review Request
+
+## PR: ${pr.title}
+
+## PR Diff
+\`\`\`diff
+${diff.slice(0, 1e5)}
+\`\`\`
+
+## Instructions
+You are a code reviewer. Review the PR diff above for:
+
+1. **Correctness** — Does the code do what the PR title suggests?
+2. **Code Quality** — Naming, structure, complexity, readability.
+3. **Potential Issues** — Bugs, security issues, edge cases, regressions.
+
+Output your review in this exact format:
+
+VERDICT: APPROVE or REQUEST_CHANGES
+
+Then provide a concise review with specific findings. Keep it actionable and focused.`;
+    const output = await this.aiRunner.run(reviewPrompt);
+    const approved = output.includes("VERDICT: APPROVE");
+    const summary = output.replace(/VERDICT:\s*(APPROVE|REQUEST_CHANGES)\n?/, "").trim();
+    try {
+      const event = approved ? "APPROVE" : "REQUEST_CHANGES";
+      const reviewBody = `## Locus Agent Review
+
+${summary}`;
+      this.prService.submitReview(prNumber, reviewBody, event);
+      this.log(`Review posted on PR #${prNumber}: ${approved ? "APPROVED" : "CHANGES REQUESTED"}`, approved ? "success" : "warn");
+    } catch (err) {
+      this.log(`Failed to post PR review: ${err instanceof Error ? err.message : String(err)}`, "error");
+    }
+    return { reviewed: true, approved, summary };
+  }
+  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(`Reviewer agent started in ${this.config.projectPath || process.cwd()}`, "success");
+    if (!isGhAvailable(this.config.projectPath)) {
+      this.log("GitHub CLI (gh) not available — reviewer agent cannot operate", "error");
+      process.exit(1);
     }
-    while (this.tasksCompleted < this.maxTasks && this.consecutiveEmpty < this.maxEmpty) {
-      const task = await this.getNextTask();
-      if (!task) {
-        if (this.consecutiveEmpty === 0) {
-          this.log("Queue empty, waiting for tasks...", "info");
-        }
-        this.consecutiveEmpty++;
-        if (this.consecutiveEmpty >= this.maxEmpty)
-          break;
-        await new Promise((r) => setTimeout(r, this.pollInterval));
+    const handleShutdown = () => {
+      this.log("Received shutdown signal. Aborting...", "warn");
+      this.aiRunner.abort();
+      this.stopHeartbeat();
+      process.exit(1);
+    };
+    process.on("SIGTERM", handleShutdown);
+    process.on("SIGINT", handleShutdown);
+    this.startHeartbeat();
+    while (this.reviewsCompleted < this.maxReviews) {
+      const pr = this.getNextUnreviewedPr();
+      if (!pr) {
+        this.log("No unreviewed PRs found. Waiting 30s...", "info");
+        await new Promise((r) => setTimeout(r, 30000));
         continue;
       }
-      this.consecutiveEmpty = 0;
-      this.log(`Claimed: ${task.title}`, "success");
-      const result = await this.executeTask(task);
-      try {
-        await this.documentFetcher.fetch();
-      } catch (err) {
-        this.log(`Document fetch failed: ${err}`, "error");
-      }
-      if (result.success) {
-        this.log(`Completed: ${task.title}`, "success");
-        await this.client.tasks.update(task.id, this.config.workspaceId, {
-          status: "VERIFICATION"
-        });
-        await this.client.tasks.addComment(task.id, this.config.workspaceId, {
-          author: this.config.agentId,
-          text: `✅ ${result.summary}`
-        });
-        this.tasksCompleted++;
+      this.log(`Reviewing: ${pr.title} (PR #${pr.number})`, "success");
+      this.sendHeartbeat();
+      const result = await this.reviewPr(pr);
+      if (result.reviewed) {
+        const status = result.approved ? "APPROVED" : "CHANGES REQUESTED";
+        try {
+          this.knowledgeBase.updateProgress({
+            type: "pr_reviewed",
+            title: pr.title,
+            details: `Review: ${status}`
+          });
+        } catch {}
+        this.reviewsCompleted++;
       } else {
-        this.log(`Failed: ${task.title} - ${result.summary}`, "error");
-        await this.client.tasks.update(task.id, this.config.workspaceId, {
-          status: "BACKLOG",
-          assignedTo: null
-        });
-        await this.client.tasks.addComment(task.id, this.config.workspaceId, {
-          author: this.config.agentId,
-          text: `❌ ${result.summary}`
-        });
+        this.log(`Review skipped: ${result.summary}`, "warn");
       }
+      this.currentTaskId = null;
     }
+    this.stopHeartbeat();
+    this.client.workspaces.heartbeat(this.config.workspaceId, this.config.agentId, null, "COMPLETED").catch(() => {});
     process.exit(0);
   }
 }
-if (process.argv[1]?.includes("agent-worker") || process.argv[1]?.includes("worker")) {
-  process.title = "locus-worker";
+var reviewerEntrypoint = process.argv[1]?.split(/[\\/]/).pop();
+if (reviewerEntrypoint === "reviewer-worker.js" || reviewerEntrypoint === "reviewer-worker.ts") {
+  process.title = "locus-reviewer";
   const args = process.argv.slice(2);
   const config = {};
   for (let i = 0;i < args.length; i++) {
@@ -2132,59 +3424,19 @@ if (process.argv[1]?.includes("agent-worker") || process.argv[1]?.includes("work
       const value = args[i + 1];
       if (value && !value.startsWith("--"))
         i++;
-      config.provider = resolveProvider(value);
+      config.provider = resolveProvider2(value);
     }
   }
   if (!config.agentId || !config.workspaceId || !config.apiBase || !config.apiKey || !config.projectPath) {
     console.error("Missing required arguments");
     process.exit(1);
   }
-  const worker = new AgentWorker(config);
+  const worker = new ReviewerWorker(config);
   worker.run().catch((err) => {
-    console.error("Fatal worker error:", err);
+    console.error("Fatal reviewer error:", err);
     process.exit(1);
   });
 }
-
-// src/index-node.ts
-var exports_index_node = {};
-__export(exports_index_node, {
-  getLocusPath: () => getLocusPath,
-  getAgentArtifactsPath: () => getAgentArtifactsPath,
-  createAiRunner: () => createAiRunner,
-  c: () => c,
-  WorkspacesModule: () => WorkspacesModule,
-  TasksModule: () => TasksModule,
-  TaskExecutor: () => TaskExecutor,
-  SprintsModule: () => SprintsModule,
-  PromptBuilder: () => PromptBuilder,
-  PROVIDER: () => PROVIDER,
-  OrganizationsModule: () => OrganizationsModule,
-  LocusEvent: () => LocusEvent,
-  LocusEmitter: () => LocusEmitter,
-  LocusClient: () => LocusClient,
-  LOCUS_GITIGNORE_PATTERNS: () => LOCUS_GITIGNORE_PATTERNS,
-  LOCUS_CONFIG: () => LOCUS_CONFIG,
-  InvitationsModule: () => InvitationsModule,
-  HistoryManager: () => HistoryManager,
-  ExecSession: () => ExecSession,
-  ExecEventType: () => ExecEventType,
-  ExecEventEmitter: () => ExecEventEmitter,
-  DocumentFetcher: () => DocumentFetcher,
-  DocsModule: () => DocsModule,
-  DEFAULT_MODEL: () => DEFAULT_MODEL,
-  ContextTracker: () => ContextTracker,
-  CodexRunner: () => CodexRunner,
-  CodebaseIndexerService: () => CodebaseIndexerService,
-  CodebaseIndexer: () => CodebaseIndexer,
-  ClaudeRunner: () => ClaudeRunner,
-  CiModule: () => CiModule,
-  AuthModule: () => AuthModule,
-  AgentWorker: () => AgentWorker,
-  AgentOrchestrator: () => AgentOrchestrator,
-  AIModule: () => AIModule
-});
-module.exports = __toCommonJS(exports_index_node);
 // src/exec/context-tracker.ts
 var REFERENCE_ALIASES = {
   plan: ["the plan", "sprint plan", "project plan", "implementation plan"],
@@ -2598,8 +3850,8 @@ class ExecEventEmitter {
   }
 }
 // src/exec/history-manager.ts
-var import_node_fs5 = require("node:fs");
-var import_node_path7 = require("node:path");
+var import_node_fs7 = require("node:fs");
+var import_node_path9 = require("node:path");
 var DEFAULT_MAX_SESSIONS = 30;
 function generateSessionId2() {
   const timestamp = Date.now().toString(36);
@@ -2611,30 +3863,30 @@ class HistoryManager {
   historyDir;
   maxSessions;
   constructor(projectPath, options) {
-    this.historyDir = options?.historyDir ?? import_node_path7.join(projectPath, LOCUS_CONFIG.dir, LOCUS_CONFIG.sessionsDir);
+    this.historyDir = options?.historyDir ?? import_node_path9.join(projectPath, LOCUS_CONFIG.dir, LOCUS_CONFIG.sessionsDir);
     this.maxSessions = options?.maxSessions ?? DEFAULT_MAX_SESSIONS;
     this.ensureHistoryDir();
   }
   ensureHistoryDir() {
-    if (!import_node_fs5.existsSync(this.historyDir)) {
-      import_node_fs5.mkdirSync(this.historyDir, { recursive: true });
+    if (!import_node_fs7.existsSync(this.historyDir)) {
+      import_node_fs7.mkdirSync(this.historyDir, { recursive: true });
     }
   }
   getSessionPath(sessionId) {
-    return import_node_path7.join(this.historyDir, `${sessionId}.json`);
+    return import_node_path9.join(this.historyDir, `${sessionId}.json`);
   }
   saveSession(session) {
     const filePath = this.getSessionPath(session.id);
     session.updatedAt = Date.now();
-    import_node_fs5.writeFileSync(filePath, JSON.stringify(session, null, 2), "utf-8");
+    import_node_fs7.writeFileSync(filePath, JSON.stringify(session, null, 2), "utf-8");
   }
   loadSession(sessionId) {
     const filePath = this.getSessionPath(sessionId);
-    if (!import_node_fs5.existsSync(filePath)) {
+    if (!import_node_fs7.existsSync(filePath)) {
       return null;
     }
     try {
-      const content = import_node_fs5.readFileSync(filePath, "utf-8");
+      const content = import_node_fs7.readFileSync(filePath, "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -2642,18 +3894,18 @@ class HistoryManager {
   }
   deleteSession(sessionId) {
     const filePath = this.getSessionPath(sessionId);
-    if (!import_node_fs5.existsSync(filePath)) {
+    if (!import_node_fs7.existsSync(filePath)) {
       return false;
     }
     try {
-      import_node_fs5.rmSync(filePath);
+      import_node_fs7.rmSync(filePath);
       return true;
     } catch {
       return false;
     }
   }
   listSessions(options) {
-    const files = import_node_fs5.readdirSync(this.historyDir);
+    const files = import_node_fs7.readdirSync(this.historyDir);
     let sessions = [];
     for (const file of files) {
       if (file.endsWith(".json")) {
@@ -2726,11 +3978,11 @@ class HistoryManager {
     return deleted;
   }
   getSessionCount() {
-    const files = import_node_fs5.readdirSync(this.historyDir);
+    const files = import_node_fs7.readdirSync(this.historyDir);
     return files.filter((f) => f.endsWith(".json")).length;
   }
   sessionExists(sessionId) {
-    return import_node_fs5.existsSync(this.getSessionPath(sessionId));
+    return import_node_fs7.existsSync(this.getSessionPath(sessionId));
   }
   findSessionByPartialId(partialId) {
     const sessions = this.listSessions();
@@ -2744,12 +3996,12 @@ class HistoryManager {
     return this.historyDir;
   }
   clearAllSessions() {
-    const files = import_node_fs5.readdirSync(this.historyDir);
+    const files = import_node_fs7.readdirSync(this.historyDir);
     let deleted = 0;
     for (const file of files) {
       if (file.endsWith(".json")) {
         try {
-          import_node_fs5.rmSync(import_node_path7.join(this.historyDir, file));
+          import_node_fs7.rmSync(import_node_path9.join(this.historyDir, file));
           deleted++;
         } catch {}
       }
@@ -3014,12 +4266,14 @@ ${currentPrompt}`);
   }
 }
 // src/orchestrator.ts
-var import_node_child_process3 = require("node:child_process");
-var import_node_fs6 = require("node:fs");
-var import_node_path8 = require("node:path");
+var import_node_child_process7 = require("node:child_process");
+var import_node_fs8 = require("node:fs");
+var import_node_path10 = require("node:path");
 var import_node_url = require("node:url");
-var import_shared3 = require("@locusai/shared");
+var import_shared4 = require("@locusai/shared");
 var import_events4 = require("events");
+var MAX_AGENTS = 5;
+
 class AgentOrchestrator extends import_events4.EventEmitter {
   client;
   config;
@@ -3027,6 +4281,8 @@ class AgentOrchestrator extends import_events4.EventEmitter {
   isRunning = false;
   processedTasks = new Set;
   resolvedSprintId = null;
+  worktreeManager = null;
+  heartbeatInterval = null;
   constructor(config) {
     super();
     this.config = config;
@@ -3035,6 +4291,15 @@ class AgentOrchestrator extends import_events4.EventEmitter {
       token: config.apiKey
     });
   }
+  get agentCount() {
+    return Math.min(Math.max(this.config.agentCount ?? 1, 1), MAX_AGENTS);
+  }
+  get useWorktrees() {
+    return this.config.useWorktrees ?? true;
+  }
+  get worktreeCleanupPolicy() {
+    return this.config.worktreeCleanupPolicy ?? "retain-on-failure";
+  }
   async resolveSprintId() {
     if (this.config.sprintId) {
       return this.config.sprintId;
@@ -3078,6 +4343,12 @@ ${c.primary("\uD83E\uDD16 Locus Agent Orchestrator")}`);
     if (this.resolvedSprintId) {
       console.log(`${c.bold("Sprint:")} ${this.resolvedSprintId}`);
     }
+    console.log(`${c.bold("Agents:")} ${this.agentCount}`);
+    console.log(`${c.bold("Worktrees:")} ${this.useWorktrees ? "enabled" : "disabled"}`);
+    if (this.useWorktrees) {
+      console.log(`${c.bold("Cleanup policy:")} ${this.worktreeCleanupPolicy}`);
+      console.log(`${c.bold("Auto-push:")} ${this.config.autoPush ? "enabled" : "disabled"}`);
+    }
     console.log(`${c.bold("API Base:")} ${this.config.apiBase}`);
     console.log(c.dim(`----------------------------------------------
 `));
@@ -3086,9 +4357,30 @@ ${c.primary("\uD83E\uDD16 Locus Agent Orchestrator")}`);
       console.log(c.dim("ℹ  No available tasks found in the backlog."));
       return;
     }
-    await this.spawnAgent();
+    if (tasks2.length > 0 && this.useWorktrees && !isGitAvailable()) {
+      console.log(c.error("git is not installed. Worktree isolation requires git. Install from https://git-scm.com/"));
+      return;
+    }
+    if (tasks2.length > 0 && this.config.autoPush && !isGhAvailable(this.config.projectPath)) {
+      console.log(c.warning("GitHub CLI (gh) not available or not authenticated. Branch push can continue, but automatic PR creation may fail until gh is configured. Install from https://cli.github.com/"));
+    }
+    if (tasks2.length > 0 && this.useWorktrees) {
+      this.worktreeManager = new WorktreeManager(this.config.projectPath, {
+        cleanupPolicy: this.worktreeCleanupPolicy
+      });
+    }
+    this.startHeartbeatMonitor();
+    const agentsToSpawn = Math.min(this.agentCount, tasks2.length);
+    const SPAWN_DELAY_MS = 5000;
+    const spawnPromises = [];
+    for (let i = 0;i < agentsToSpawn; i++) {
+      if (i > 0) {
+        await this.sleep(SPAWN_DELAY_MS);
+      }
+      spawnPromises.push(this.spawnAgent(i));
+    }
+    await Promise.all(spawnPromises);
     while (this.agents.size > 0 && this.isRunning) {
-      await this.reapAgents();
       if (this.agents.size === 0) {
         break;
       }
@@ -3097,8 +4389,8 @@ ${c.primary("\uD83E\uDD16 Locus Agent Orchestrator")}`);
     console.log(`
 ${c.success("✅ Orchestrator finished")}`);
   }
-  async spawnAgent() {
-    const agentId = `agent-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+  async spawnAgent(index) {
+    const agentId = `agent-${index}-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
     const agentState = {
       id: agentId,
       status: "IDLE",
@@ -3110,13 +4402,9 @@ ${c.success("✅ Orchestrator finished")}`);
     this.agents.set(agentId, agentState);
     console.log(`${c.primary("\uD83D\uDE80 Agent started:")} ${c.bold(agentId)}
 `);
-    const potentialPaths = [];
-    const currentModulePath = import_node_url.fileURLToPath("file:///home/runner/work/locusai/locusai/packages/sdk/src/orchestrator.ts");
-    const currentModuleDir = import_node_path8.dirname(currentModulePath);
-    potentialPaths.push(import_node_path8.join(currentModuleDir, "agent", "worker.js"), import_node_path8.join(currentModuleDir, "worker.js"), import_node_path8.join(currentModuleDir, "agent", "worker.ts"));
-    const workerPath = potentialPaths.find((p) => import_node_fs6.existsSync(p));
+    const workerPath = this.resolveWorkerPath();
     if (!workerPath) {
-      throw new Error(`Worker file not found. Checked: ${potentialPaths.join(", ")}. ` + `Make sure the SDK is properly built and installed.`);
+      throw new Error("Worker file not found. Make sure the SDK is properly built and installed.");
     }
     const workerArgs = [
       "--agent-id",
@@ -3139,8 +4427,15 @@ ${c.success("✅ Orchestrator finished")}`);
     if (this.resolvedSprintId) {
       workerArgs.push("--sprint-id", this.resolvedSprintId);
     }
-    const agentProcess = import_node_child_process3.spawn(process.execPath, [workerPath, ...workerArgs], {
+    if (this.useWorktrees) {
+      workerArgs.push("--use-worktrees");
+    }
+    if (this.config.autoPush) {
+      workerArgs.push("--auto-push");
+    }
+    const agentProcess = import_node_child_process7.spawn(process.execPath, [workerPath, ...workerArgs], {
       stdio: ["pipe", "pipe", "pipe"],
+      detached: true,
       env: {
         ...process.env,
         FORCE_COLOR: "1",
@@ -3155,6 +4450,9 @@ ${c.success("✅ Orchestrator finished")}`);
         agentState.tasksCompleted = msg.tasksCompleted || 0;
         agentState.tasksFailed = msg.tasksFailed || 0;
       }
+      if (msg.type === "heartbeat") {
+        agentState.lastHeartbeat = new Date;
+      }
     });
     agentProcess.stdout?.on("data", (data) => {
       process.stdout.write(data.toString());
@@ -3179,7 +4477,30 @@ ${agentId} finished (exit code: ${code})`);
     });
     this.emit("agent:spawned", { agentId });
   }
-  async reapAgents() {}
+  resolveWorkerPath() {
+    const currentModulePath = import_node_url.fileURLToPath("file:///home/runner/work/locusai/locusai/packages/sdk/src/orchestrator.ts");
+    const currentModuleDir = import_node_path10.dirname(currentModulePath);
+    const potentialPaths = [
+      import_node_path10.join(currentModuleDir, "agent", "worker.js"),
+      import_node_path10.join(currentModuleDir, "worker.js"),
+      import_node_path10.join(currentModuleDir, "agent", "worker.ts")
+    ];
+    return potentialPaths.find((p) => import_node_fs8.existsSync(p));
+  }
+  startHeartbeatMonitor() {
+    this.heartbeatInterval = setInterval(() => {
+      const now = Date.now();
+      for (const [agentId, agent] of this.agents.entries()) {
+        if (agent.status === "WORKING" && now - agent.lastHeartbeat.getTime() > import_shared4.STALE_AGENT_TIMEOUT_MS) {
+          console.log(c.error(`Agent ${agentId} is stale (no heartbeat for 10 minutes). Killing.`));
+          if (agent.process && !agent.process.killed) {
+            this.killProcessTree(agent.process);
+          }
+          this.emit("agent:stale", { agentId });
+        }
+      }
+    }, 60000);
+  }
   async getAvailableTasks() {
     try {
       const tasks2 = await this.client.tasks.getAvailable(this.config.workspaceId, this.resolvedSprintId || undefined);
@@ -3196,10 +4517,10 @@ ${agentId} finished (exit code: ${code})`);
     try {
       const tasks2 = await this.getAvailableTasks();
       const priorityOrder = [
-        import_shared3.TaskPriority.CRITICAL,
-        import_shared3.TaskPriority.HIGH,
-        import_shared3.TaskPriority.MEDIUM,
-        import_shared3.TaskPriority.LOW
+        import_shared4.TaskPriority.CRITICAL,
+        import_shared4.TaskPriority.HIGH,
+        import_shared4.TaskPriority.MEDIUM,
+        import_shared4.TaskPriority.LOW
       ];
       let task = tasks2.sort((a, b) => priorityOrder.indexOf(a.priority) - priorityOrder.indexOf(b.priority))[0];
       if (!task && tasks2.length > 0) {
@@ -3223,7 +4544,7 @@ ${agentId} finished (exit code: ${code})`);
   async completeTask(taskId, agentId, summary) {
     try {
       await this.client.tasks.update(taskId, this.config.workspaceId, {
-        status: import_shared3.TaskStatus.VERIFICATION
+        status: import_shared4.TaskStatus.IN_REVIEW
       });
       if (summary) {
         await this.client.tasks.addComment(taskId, this.config.workspaceId, {
@@ -3248,7 +4569,7 @@ ${summary}`
   async failTask(taskId, agentId, error) {
     try {
       await this.client.tasks.update(taskId, this.config.workspaceId, {
-        status: import_shared3.TaskStatus.BACKLOG,
+        status: import_shared4.TaskStatus.BACKLOG,
         assignedTo: null
       });
       await this.client.tasks.addComment(taskId, this.config.workspaceId, {
@@ -3271,11 +4592,52 @@ ${summary}`
     await this.cleanup();
     this.emit("stopped", { timestamp: new Date });
   }
+  stopAgent(agentId) {
+    const agent = this.agents.get(agentId);
+    if (!agent)
+      return false;
+    if (agent.process && !agent.process.killed) {
+      this.killProcessTree(agent.process);
+    }
+    return true;
+  }
+  killProcessTree(proc) {
+    if (!proc.pid || proc.killed)
+      return;
+    try {
+      process.kill(-proc.pid, "SIGTERM");
+    } catch {
+      try {
+        proc.kill("SIGTERM");
+      } catch {}
+    }
+  }
   async cleanup() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
     for (const [agentId, agent] of this.agents.entries()) {
       if (agent.process && !agent.process.killed) {
         console.log(`Killing agent: ${agentId}`);
-        agent.process.kill();
+        this.killProcessTree(agent.process);
+      }
+    }
+    if (this.worktreeManager) {
+      try {
+        if (this.worktreeCleanupPolicy === "auto") {
+          const removed = this.worktreeManager.removeAll();
+          if (removed > 0) {
+            console.log(c.dim(`Cleaned up ${removed} worktree(s)`));
+          }
+        } else if (this.worktreeCleanupPolicy === "retain-on-failure") {
+          this.worktreeManager.prune();
+          console.log(c.dim("Retaining worktrees for failure analysis (cleanup policy: retain-on-failure)"));
+        } else {
+          console.log(c.dim("Skipping worktree cleanup (cleanup policy: manual)"));
+        }
+      } catch {
+        console.log(c.dim("Could not clean up some worktrees"));
       }
     }
     this.agents.clear();
@@ -3283,12 +4645,543 @@ ${summary}`
   getStats() {
     return {
       activeAgents: this.agents.size,
+      agentCount: this.agentCount,
+      useWorktrees: this.useWorktrees,
       processedTasks: this.processedTasks.size,
       totalTasksCompleted: Array.from(this.agents.values()).reduce((sum, agent) => sum + agent.tasksCompleted, 0),
       totalTasksFailed: Array.from(this.agents.values()).reduce((sum, agent) => sum + agent.tasksFailed, 0)
     };
   }
+  getAgentStates() {
+    return Array.from(this.agents.values());
+  }
   sleep(ms) {
-    return new Promise((resolve2) => setTimeout(resolve2, ms));
+    return new Promise((resolve3) => setTimeout(resolve3, ms));
+  }
+}
+// src/planning/plan-manager.ts
+var import_node_fs9 = require("node:fs");
+var import_node_path11 = require("node:path");
+
+// src/planning/sprint-plan.ts
+var import_shared5 = require("@locusai/shared");
+function sprintPlanToMarkdown(plan) {
+  const lines = [];
+  lines.push(`# Sprint Plan: ${plan.name}`);
+  lines.push("");
+  lines.push(`**Status:** ${plan.status.toUpperCase()}`);
+  lines.push(`**Created:** ${plan.createdAt}`);
+  lines.push(`**Estimated Duration:** ${plan.estimatedDays} day(s)`);
+  lines.push("");
+  lines.push(`## Goal`);
+  lines.push(plan.goal);
+  lines.push("");
+  lines.push(`## CEO Directive`);
+  lines.push(`> ${plan.directive}`);
+  lines.push("");
+  if (plan.feedback) {
+    lines.push(`## CEO Feedback`);
+    lines.push(`> ${plan.feedback}`);
+    lines.push("");
+  }
+  lines.push(`## Tasks (${plan.tasks.length})`);
+  lines.push("");
+  for (const task of plan.tasks) {
+    lines.push(`### ${task.index}. ${task.title}`);
+    lines.push(`- **Role:** ${task.assigneeRole}`);
+    lines.push(`- **Priority:** ${task.priority}`);
+    lines.push(`- **Complexity:** ${"█".repeat(task.complexity)}${"░".repeat(5 - task.complexity)} (${task.complexity}/5)`);
+    if (task.labels.length > 0) {
+      lines.push(`- **Labels:** ${task.labels.join(", ")}`);
+    }
+    lines.push("");
+    lines.push(task.description);
+    lines.push("");
+    if (task.acceptanceCriteria.length > 0) {
+      lines.push(`**Acceptance Criteria:**`);
+      for (const ac of task.acceptanceCriteria) {
+        lines.push(`- [ ] ${ac}`);
+      }
+      lines.push("");
+    }
+  }
+  if (plan.risks.length > 0) {
+    lines.push(`## Risks`);
+    lines.push("");
+    for (const risk of plan.risks) {
+      lines.push(`- **[${risk.severity.toUpperCase()}]** ${risk.description}`);
+      lines.push(`  - Mitigation: ${risk.mitigation}`);
+    }
+    lines.push("");
+  }
+  lines.push(`---`);
+  lines.push(`*Plan ID: ${plan.id}*`);
+  return lines.join(`
+`);
+}
+function plannedTasksToCreatePayloads(plan, sprintId) {
+  return plan.tasks.map((task) => ({
+    title: task.title,
+    description: task.description,
+    status: import_shared5.TaskStatus.BACKLOG,
+    assigneeRole: task.assigneeRole,
+    priority: task.priority,
+    labels: task.labels,
+    sprintId,
+    order: task.index * 10,
+    acceptanceChecklist: task.acceptanceCriteria.map((text, i) => ({
+      id: `ac-${i + 1}`,
+      text,
+      done: false
+    }))
+  }));
+}
+function parseSprintPlanFromAI(raw, directive) {
+  let jsonStr = raw.trim();
+  const jsonMatch = jsonStr.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+  if (jsonMatch) {
+    jsonStr = jsonMatch[1]?.trim() || "";
+  }
+  const parsed = JSON.parse(jsonStr);
+  const now = new Date().toISOString();
+  const id = `plan-${Date.now()}`;
+  const tasks2 = (parsed.tasks || []).map((t, i) => ({
+    index: i + 1,
+    title: t.title || `Task ${i + 1}`,
+    description: t.description || "",
+    assigneeRole: t.assigneeRole || "BACKEND",
+    priority: t.priority || "MEDIUM",
+    complexity: t.complexity || 3,
+    acceptanceCriteria: t.acceptanceCriteria || [],
+    labels: t.labels || []
+  }));
+  return {
+    id,
+    name: parsed.name || "Unnamed Sprint",
+    goal: parsed.goal || directive,
+    directive,
+    tasks: tasks2,
+    risks: (parsed.risks || []).map((r) => ({
+      description: r.description || "",
+      mitigation: r.mitigation || "",
+      severity: r.severity || "medium"
+    })),
+    estimatedDays: parsed.estimatedDays || 1,
+    status: "pending",
+    createdAt: now,
+    updatedAt: now
+  };
+}
+
+// src/planning/plan-manager.ts
+class PlanManager {
+  projectPath;
+  plansDir;
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+    this.plansDir = getLocusPath(projectPath, "plansDir");
+  }
+  save(plan) {
+    this.ensurePlansDir();
+    const slug = this.slugify(plan.name);
+    const jsonPath = import_node_path11.join(this.plansDir, `${slug}.json`);
+    const mdPath = import_node_path11.join(this.plansDir, `sprint-${slug}.md`);
+    import_node_fs9.writeFileSync(jsonPath, JSON.stringify(plan, null, 2), "utf-8");
+    import_node_fs9.writeFileSync(mdPath, sprintPlanToMarkdown(plan), "utf-8");
+    return plan.id;
+  }
+  load(idOrSlug) {
+    this.ensurePlansDir();
+    const files = import_node_fs9.readdirSync(this.plansDir).filter((f) => f.endsWith(".json"));
+    for (const file of files) {
+      const filePath = import_node_path11.join(this.plansDir, file);
+      try {
+        const plan = JSON.parse(import_node_fs9.readFileSync(filePath, "utf-8"));
+        if (plan.id === idOrSlug || this.slugify(plan.name) === idOrSlug) {
+          return plan;
+        }
+      } catch {}
+    }
+    return null;
+  }
+  list(status) {
+    this.ensurePlansDir();
+    const files = import_node_fs9.readdirSync(this.plansDir).filter((f) => f.endsWith(".json"));
+    const plans = [];
+    for (const file of files) {
+      try {
+        const plan = JSON.parse(import_node_fs9.readFileSync(import_node_path11.join(this.plansDir, file), "utf-8"));
+        if (!status || plan.status === status) {
+          plans.push(plan);
+        }
+      } catch {}
+    }
+    plans.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    return plans;
+  }
+  async approve(idOrSlug, client, workspaceId) {
+    const plan = this.load(idOrSlug);
+    if (!plan) {
+      throw new Error(`Plan not found: ${idOrSlug}`);
+    }
+    if (plan.status !== "pending") {
+      throw new Error(`Plan "${plan.name}" is ${plan.status}, can only approve pending plans`);
+    }
+    const sprint = await client.sprints.create(workspaceId, {
+      name: plan.name
+    });
+    const payloads = plannedTasksToCreatePayloads(plan, sprint.id);
+    const tasks2 = [];
+    for (const payload of payloads) {
+      const task = await client.tasks.create(workspaceId, payload);
+      tasks2.push(task);
+    }
+    await client.sprints.start(sprint.id, workspaceId);
+    plan.status = "approved";
+    plan.updatedAt = new Date().toISOString();
+    this.save(plan);
+    const kb = new KnowledgeBase(this.projectPath);
+    kb.updateProgress({
+      type: "sprint_started",
+      title: plan.name,
+      details: `${tasks2.length} tasks created from planning meeting. Sprint goal: ${plan.goal}`
+    });
+    return { sprint, tasks: tasks2 };
+  }
+  reject(idOrSlug, feedback) {
+    const plan = this.load(idOrSlug);
+    if (!plan) {
+      throw new Error(`Plan not found: ${idOrSlug}`);
+    }
+    if (plan.status !== "pending") {
+      throw new Error(`Plan "${plan.name}" is ${plan.status}, can only reject pending plans`);
+    }
+    plan.status = "rejected";
+    plan.feedback = feedback;
+    plan.updatedAt = new Date().toISOString();
+    this.save(plan);
+    return plan;
+  }
+  cancel(idOrSlug) {
+    const plan = this.load(idOrSlug);
+    if (!plan) {
+      throw new Error(`Plan not found: ${idOrSlug}`);
+    }
+    plan.status = "cancelled";
+    plan.updatedAt = new Date().toISOString();
+    this.save(plan);
+  }
+  delete(idOrSlug) {
+    this.ensurePlansDir();
+    const files = import_node_fs9.readdirSync(this.plansDir);
+    for (const file of files) {
+      const filePath = import_node_path11.join(this.plansDir, file);
+      if (!file.endsWith(".json"))
+        continue;
+      try {
+        const plan = JSON.parse(import_node_fs9.readFileSync(filePath, "utf-8"));
+        if (plan.id === idOrSlug || this.slugify(plan.name) === idOrSlug) {
+          import_node_fs9.unlinkSync(filePath);
+          const mdPath = import_node_path11.join(this.plansDir, `sprint-${this.slugify(plan.name)}.md`);
+          if (import_node_fs9.existsSync(mdPath)) {
+            import_node_fs9.unlinkSync(mdPath);
+          }
+          return;
+        }
+      } catch {}
+    }
+  }
+  getMarkdown(idOrSlug) {
+    const plan = this.load(idOrSlug);
+    if (!plan)
+      return null;
+    return sprintPlanToMarkdown(plan);
+  }
+  ensurePlansDir() {
+    if (!import_node_fs9.existsSync(this.plansDir)) {
+      import_node_fs9.mkdirSync(this.plansDir, { recursive: true });
+    }
+  }
+  slugify(name) {
+    return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  }
+}
+// src/planning/planning-meeting.ts
+var import_node_fs10 = require("node:fs");
+
+// src/planning/agents/architect.ts
+function buildArchitectPrompt(input) {
+  let prompt = `# Role: Software Architect
+
+You are a Software Architect participating in an async sprint planning meeting. The Tech Lead has produced an initial task breakdown. Your job is to refine it.
+
+## CEO Directive
+> ${input.directive}
+`;
+  if (input.feedback) {
+    prompt += `
+## CEO Feedback on Previous Plan
+> ${input.feedback}
+
+IMPORTANT: Ensure the refined plan addresses this feedback.
+`;
+  }
+  prompt += `
+## Project Context
+${input.projectContext || "No project context available."}
+
+## Tech Lead's Task Breakdown
+${input.techLeadOutput}
+
+## Your Task
+
+Review and refine the Tech Lead's breakdown:
+
+1. **Ordering** — Order tasks so that foundational work comes first. Tasks that produce outputs consumed by later tasks must appear earlier in the list. Foundation tasks (schemas, config, shared code) must be listed before tasks that build on them. The array index IS the execution order.
+2. **Risk Assessment** — Flag tasks that are risky, underestimated, or have unknowns.
+3. **Task Splitting** — If a task is too large (would take more than a day), split it.
+4. **Task Merging** — If two tasks are trivially small and related, merge them.
+5. **Complexity Scoring** — Rate each task 1-5 (1=trivial, 5=very complex).
+6. **Missing Tasks** — Add any tasks the Tech Lead missed (database migrations, configuration, testing, etc.).
+
+## Output Format
+
+Respond with ONLY a JSON object (no markdown code blocks, no explanation):
+
+{
+  "tasks": [
+    {
+      "title": "string",
+      "description": "string (2-4 sentences)",
+      "assigneeRole": "BACKEND | FRONTEND | QA | PM | DESIGN",
+      "priority": "HIGH | MEDIUM | LOW | CRITICAL",
+      "labels": ["string"],
+      "acceptanceCriteria": ["string"],
+      "complexity": 3
+    }
+  ],
+  "risks": [
+    {
+      "description": "string",
+      "mitigation": "string",
+      "severity": "low | medium | high"
+    }
+  ],
+  "architectureNotes": "string (notes for the Sprint Organizer about parallelism opportunities and constraints)"
+}`;
+  return prompt;
+}
+
+// src/planning/agents/sprint-organizer.ts
+function buildSprintOrganizerPrompt(input) {
+  let prompt = `# Role: Sprint Organizer
+
+You are a Sprint Organizer finalizing the sprint plan from a planning meeting. The Architect has refined the task breakdown. Your job is to produce the final sprint plan document.
+
+## CEO Directive
+> ${input.directive}
+`;
+  if (input.feedback) {
+    prompt += `
+## CEO Feedback on Previous Plan
+> ${input.feedback}
+
+IMPORTANT: The final plan must address this feedback.
+`;
+  }
+  prompt += `
+## Architect's Refined Task Breakdown
+${input.architectOutput}
+
+## Your Task
+
+Produce the final sprint plan:
+
+1. **Sprint Name** — A concise, memorable name for this sprint (e.g., "User Authentication", "Payment Integration")
+2. **Sprint Goal** — One paragraph describing what this sprint delivers
+3. **Task Ordering** — Final ordering so that foundational work comes first. The position in the array IS the execution order — task at index 0 runs first, index 1 runs second, etc.
+4. **Duration Estimate** — How many days this sprint will take with 2-3 agents working in parallel
+5. **Final Task List** — Each task with all fields filled in, ordered by execution priority
+
+Guidelines:
+- The order of tasks in the array determines execution order. Tasks are dispatched sequentially from first to last.
+- Foundation tasks (schemas, config, shared code) must appear before tasks that build on them
+- Group related tasks together when possible
+- Ensure acceptance criteria are specific and testable
+- Keep the sprint focused — if it's too large (>12 tasks), consider reducing scope
+
+## Output Format
+
+Respond with ONLY a JSON object (no markdown code blocks, no explanation):
+
+{
+  "name": "string (2-4 words)",
+  "goal": "string (1 paragraph)",
+  "estimatedDays": 3,
+  "tasks": [
+    {
+      "title": "string",
+      "description": "string",
+      "assigneeRole": "BACKEND | FRONTEND | QA | PM | DESIGN",
+      "priority": "CRITICAL | HIGH | MEDIUM | LOW",
+      "labels": ["string"],
+      "acceptanceCriteria": ["string"],
+      "complexity": 3
+    }
+  ],
+  "risks": [
+    {
+      "description": "string",
+      "mitigation": "string",
+      "severity": "low | medium | high"
+    }
+  ]
+}`;
+  return prompt;
+}
+
+// src/planning/agents/tech-lead.ts
+function buildTechLeadPrompt(input) {
+  let prompt = `# Role: Senior Tech Lead
+
+You are a Senior Tech Lead participating in an async sprint planning meeting. Your job is to take the CEO's directive and produce an initial task breakdown.
+
+## CEO Directive
+> ${input.directive}
+`;
+  if (input.feedback) {
+    prompt += `
+## CEO Feedback on Previous Plan
+> ${input.feedback}
+
+IMPORTANT: Incorporate this feedback into your task breakdown. The CEO has reviewed a previous plan and wants changes.
+`;
+  }
+  prompt += `
+## Project Context
+${input.projectContext || "No project context available."}
+
+## Codebase Structure
+${input.codebaseIndex || "No codebase index available."}
+
+## Your Task
+
+Analyze the CEO's directive and produce a detailed task breakdown. For each task:
+
+1. **Title** — Clear, action-oriented (e.g., "Implement user registration API endpoint")
+2. **Description** — What needs to be done technically, which files/modules are involved
+3. **Assignee Role** — Who should work on this: BACKEND, FRONTEND, QA, PM, or DESIGN
+4. **Priority** — HIGH, MEDIUM, or LOW based on business impact
+5. **Labels** — Relevant tags (e.g., "api", "database", "ui", "auth")
+6. **Acceptance Criteria** — Specific, testable conditions for completion
+
+Think about:
+- What existing code can be reused or extended
+- Which tasks are independent vs. dependent
+- What the right granularity is (not too big, not too small)
+- What risks or unknowns exist
+
+## Output Format
+
+Respond with ONLY a JSON object (no markdown code blocks, no explanation):
+
+{
+  "tasks": [
+    {
+      "title": "string",
+      "description": "string (2-4 sentences)",
+      "assigneeRole": "BACKEND | FRONTEND | QA | PM | DESIGN",
+      "priority": "HIGH | MEDIUM | LOW",
+      "labels": ["string"],
+      "acceptanceCriteria": ["string"]
+    }
+  ],
+  "technicalNotes": "string (brief notes on architecture decisions, risks, or considerations for the Architect phase)"
+}`;
+  return prompt;
+}
+
+// src/planning/planning-meeting.ts
+class PlanningMeeting {
+  projectPath;
+  aiRunner;
+  log;
+  constructor(config) {
+    this.projectPath = config.projectPath;
+    this.aiRunner = config.aiRunner;
+    this.log = config.log ?? ((_msg) => {
+      return;
+    });
+  }
+  async run(directive, feedback) {
+    const projectContext = this.getProjectContext();
+    const codebaseIndex = this.getCodebaseIndex();
+    this.log("Phase 1/3: Tech Lead analyzing directive...", "info");
+    const techLeadPrompt = buildTechLeadPrompt({
+      directive,
+      projectContext,
+      codebaseIndex,
+      feedback
+    });
+    const techLeadOutput = await this.aiRunner.run(techLeadPrompt);
+    this.log("Tech Lead phase complete.", "success");
+    this.log("Phase 2/3: Architect refining task breakdown...", "info");
+    const architectPrompt = buildArchitectPrompt({
+      directive,
+      projectContext,
+      techLeadOutput,
+      feedback
+    });
+    const architectOutput = await this.aiRunner.run(architectPrompt);
+    this.log("Architect phase complete.", "success");
+    this.log("Phase 3/3: Sprint Organizer finalizing plan...", "info");
+    const sprintOrganizerPrompt = buildSprintOrganizerPrompt({
+      directive,
+      architectOutput,
+      feedback
+    });
+    const sprintOrganizerOutput = await this.aiRunner.run(sprintOrganizerPrompt);
+    this.log("Sprint Organizer phase complete.", "success");
+    const plan = parseSprintPlanFromAI(sprintOrganizerOutput, directive);
+    if (feedback) {
+      plan.feedback = feedback;
+    }
+    return {
+      plan,
+      phaseOutputs: {
+        techLead: techLeadOutput,
+        architect: architectOutput,
+        sprintOrganizer: sprintOrganizerOutput
+      }
+    };
+  }
+  getProjectContext() {
+    const kb = new KnowledgeBase(this.projectPath);
+    return kb.getFullContext();
+  }
+  getCodebaseIndex() {
+    const indexPath = getLocusPath(this.projectPath, "indexFile");
+    if (!import_node_fs10.existsSync(indexPath)) {
+      return "";
+    }
+    try {
+      const raw = import_node_fs10.readFileSync(indexPath, "utf-8");
+      const index = JSON.parse(raw);
+      const parts = [];
+      if (index.responsibilities) {
+        parts.push("### File Responsibilities");
+        const entries = Object.entries(index.responsibilities);
+        for (const [file, summary] of entries.slice(0, 50)) {
+          parts.push(`- \`${file}\`: ${summary}`);
+        }
+        if (entries.length > 50) {
+          parts.push(`... and ${entries.length - 50} more files`);
+        }
+      }
+      return parts.join(`
+`);
+    } catch {
+      return "";
+    }
   }
 }