@locusai/sdk 0.8.0 → 0.9.0

package/dist/agent/worker.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;
+  }
+  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})`);
+    }
+    if (!isGhAvailable(this.projectPath)) {
+      throw new Error("GitHub CLI (gh) is not installed or not authenticated. Install from https://cli.github.com/");
+    }
+    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 };
   }
-  async index(onProgress, treeSummarizer, force = false) {
-    if (!treeSummarizer) {
-      throw new Error("A treeSummarizer is required for this indexing method.");
+  validateCreatePrInputs(baseBranch, headBranch) {
+    if (!this.hasRemoteBranch(baseBranch)) {
+      throw new Error(`Base branch "${baseBranch}" does not exist on origin. Push/fetch refs and retry.`);
     }
-    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 (!this.hasRemoteBranch(headBranch)) {
+      throw new Error(`Head branch "${headBranch}" is not available on origin. Ensure it is pushed before PR creation.`);
     }
-    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 baseRef = this.resolveBranchRef(baseBranch);
+    const headRef = this.resolveBranchRef(headBranch);
+    if (!baseRef) {
+      throw new Error(`Could not resolve base branch "${baseBranch}" locally.`);
     }
-  }
-  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 (!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(["**/*"], {
+  }
+  countCommitsAhead(baseRef, headRef) {
+    const output = import_node_child_process4.execFileSync("git", ["rev-list", "--count", `${baseRef}..${headRef}`], {
       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}"
-      ]
-    });
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const value = Number.parseInt(output || "0", 10);
+    return Number.isNaN(value) ? 0 : value;
   }
-  loadIndex() {
-    if (import_node_fs2.existsSync(this.indexPath)) {
-      try {
-        return JSON.parse(import_node_fs2.readFileSync(this.indexPath, "utf-8"));
-      } catch {
-        return null;
-      }
+  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
+    });
+  }
+  submitReview(prIdentifier, body, event) {
+    try {
+      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;
+    }
   }
-  hashFile(filePath) {
+  listLocusPrs() {
     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);
+      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;
+    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 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 });
-        }
-        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({
       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,74 +2424,323 @@ 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");
     }
-    const result = await this.taskExecutor.execute(fullTask, context);
-    await this.indexerService.reindex();
-    return result;
+  }
+  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 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 && this.consecutiveEmpty < this.maxEmpty) {
+    while (this.tasksCompleted < this.maxTasks) {
       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));
-        continue;
+        this.log("No more tasks to process. Exiting.", "info");
+        break;
       }
-      this.consecutiveEmpty = 0;
       this.log(`Claimed: ${task.title}`, "success");
+      this.currentTaskId = task.id;
+      this.sendHeartbeat();
       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++;
+        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: "BACKLOG",
+          status: import_shared3.TaskStatus.BACKLOG,
           assignedTo: null
         });
         await this.client.tasks.addComment(task.id, this.config.workspaceId, {
@@ -2104,11 +2748,18 @@ class AgentWorker {
           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);
   }
 }
-if (process.argv[1]?.includes("agent-worker") || process.argv[1]?.includes("worker")) {
+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 = {};
@@ -2126,8 +2777,14 @@ if (process.argv[1]?.includes("agent-worker") || process.argv[1]?.includes("work
       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("--"))