@locusai/telegram 0.9.10 → 0.9.12

package/bin/telegram.js

@@ -19454,7 +19454,7 @@ var require_follow_redirects = __commonJS((exports, module) => {
 });
 
 // src/index.ts
-var import_config = __toESM(require_config(), 1);
+var import_config13 = __toESM(require_config(), 1);
 
 // src/bot.ts
 var import_telegraf = __toESM(require_lib3(), 1);
@@ -20103,6 +20103,11 @@ var HELP_TEXT = `<b>Locus Bot — Command Center</b>
 /git &lt;command&gt; — Run whitelisted git/gh commands
 /dev &lt;command&gt; — Run lint, typecheck, build, test
 
+<b>Worktrees:</b>
+/worktrees — List agent worktrees
+/worktree &lt;number&gt; — View worktree details
+/rmworktree &lt;number|all&gt; — Remove a worktree
+
 <b>Status:</b>
 /status — Show running processes
 /agents — List agent worktrees
@@ -20268,29 +20273,36 @@ async function runCommand(ctx, executor, config) {
     outputBuffer += chunk;
   });
   activeRunKill = kill;
-  const result = await done;
-  activeRunKill = null;
-  clearInterval(sendInterval);
-  if (outputBuffer.length > lastSentLength) {
-    const remaining = stripAnsi(outputBuffer.slice(lastSentLength));
-    const messages = splitMessage(`<pre>${escapeHtml(remaining)}</pre>`, 4000);
-    for (const msg of messages) {
-      try {
-        await ctx.reply(msg, { parse_mode: "HTML" });
-      } catch {}
+  done.then(async (result) => {
+    activeRunKill = null;
+    clearInterval(sendInterval);
+    if (outputBuffer.length > lastSentLength) {
+      const remaining = stripAnsi(outputBuffer.slice(lastSentLength));
+      const messages = splitMessage(`<pre>${escapeHtml(remaining)}</pre>`, 4000);
+      for (const msg of messages) {
+        try {
+          await ctx.reply(msg, { parse_mode: "HTML" });
+        } catch {}
+      }
     }
-  }
-  if (result.exitCode === 0) {
-    await ctx.reply(formatSuccess("Agents finished successfully."), {
-      parse_mode: "HTML"
-    });
-  } else if (result.killed) {
-    await ctx.reply(formatInfo("Agents were stopped."), {
-      parse_mode: "HTML"
-    });
-  } else {
-    await ctx.reply(formatError(`Agents exited with code ${result.exitCode}.`), { parse_mode: "HTML" });
-  }
+    if (result.exitCode === 0) {
+      await ctx.reply(formatSuccess("Agents finished successfully."), {
+        parse_mode: "HTML"
+      });
+    } else if (result.killed) {
+      await ctx.reply(formatInfo("Agents were stopped."), {
+        parse_mode: "HTML"
+      });
+    } else {
+      await ctx.reply(formatError(`Agents exited with code ${result.exitCode}.`), { parse_mode: "HTML" });
+    }
+  }, async (err) => {
+    activeRunKill = null;
+    clearInterval(sendInterval);
+    try {
+      await ctx.reply(formatError(`Run failed: ${err instanceof Error ? err.message : String(err)}`), { parse_mode: "HTML" });
+    } catch {}
+  });
 }
 async function stopCommand(ctx, executor) {
   console.log("[stop] Stopping all processes");
@@ -38523,9 +38535,3902 @@ Feedback: <i>${escapeHtml(feedback)}</i>`, { parse_mode: "HTML" });
     await ctx.reply(formatError(`Failed to reject task: ${err instanceof Error ? err.message : String(err)}`), { parse_mode: "HTML" });
   }
 }
-// src/executor.ts
-import { spawn as spawn2 } from "node:child_process";
+// ../sdk/src/core/config.ts
 import { join as join2 } from "node:path";
+var PROVIDER = {
+  CLAUDE: "claude",
+  CODEX: "codex"
+};
+var DEFAULT_MODEL = {
+  [PROVIDER.CLAUDE]: "opus",
+  [PROVIDER.CODEX]: "gpt-5.3-codex"
+};
+var LOCUS_SCHEMA_BASE_URL = "https://locusai.dev/schemas";
+var LOCUS_SCHEMAS = {
+  config: `${LOCUS_SCHEMA_BASE_URL}/config.schema.json`,
+  settings: `${LOCUS_SCHEMA_BASE_URL}/settings.schema.json`
+};
+var LOCUS_CONFIG = {
+  dir: ".locus",
+  configFile: "config.json",
+  settingsFile: "settings.json",
+  indexFile: "codebase-index.json",
+  contextFile: "LOCUS.md",
+  artifactsDir: "artifacts",
+  documentsDir: "documents",
+  sessionsDir: "sessions",
+  reviewsDir: "reviews",
+  plansDir: "plans",
+  projectDir: "project",
+  projectContextFile: "context.md",
+  projectProgressFile: "progress.md"
+};
+function getLocusPath(projectPath, fileName) {
+  if (fileName === "projectContextFile" || fileName === "projectProgressFile") {
+    return join2(projectPath, LOCUS_CONFIG.dir, LOCUS_CONFIG.projectDir, LOCUS_CONFIG[fileName]);
+  }
+  return join2(projectPath, LOCUS_CONFIG.dir, LOCUS_CONFIG[fileName]);
+}
+// ../sdk/src/ai/claude-runner.ts
+import { spawn as spawn2 } from "node:child_process";
+import { resolve } from "node:path";
+
+// ../sdk/src/utils/colors.ts
+var ESC = "\x1B[";
+var RESET = `${ESC}0m`;
+var colors = {
+  reset: RESET,
+  bold: `${ESC}1m`,
+  dim: `${ESC}2m`,
+  italic: `${ESC}3m`,
+  underline: `${ESC}4m`,
+  black: `${ESC}30m`,
+  red: `${ESC}31m`,
+  green: `${ESC}32m`,
+  yellow: `${ESC}33m`,
+  blue: `${ESC}34m`,
+  magenta: `${ESC}35m`,
+  cyan: `${ESC}36m`,
+  white: `${ESC}37m`,
+  gray: `${ESC}90m`,
+  brightRed: `${ESC}91m`,
+  brightGreen: `${ESC}92m`,
+  brightYellow: `${ESC}93m`,
+  brightBlue: `${ESC}94m`,
+  brightMagenta: `${ESC}95m`,
+  brightCyan: `${ESC}96m`,
+  brightWhite: `${ESC}97m`,
+  bgBlack: `${ESC}40m`,
+  bgRed: `${ESC}41m`,
+  bgGreen: `${ESC}42m`,
+  bgYellow: `${ESC}43m`,
+  bgBlue: `${ESC}44m`,
+  bgMagenta: `${ESC}45m`,
+  bgCyan: `${ESC}46m`,
+  bgWhite: `${ESC}47m`
+};
+var c = {
+  text: (text, ...colorNames) => {
+    const codes = colorNames.map((name) => colors[name]).join("");
+    return `${codes}${text}${RESET}`;
+  },
+  bold: (t) => c.text(t, "bold"),
+  dim: (t) => c.text(t, "dim"),
+  red: (t) => c.text(t, "red"),
+  green: (t) => c.text(t, "green"),
+  yellow: (t) => c.text(t, "yellow"),
+  blue: (t) => c.text(t, "blue"),
+  magenta: (t) => c.text(t, "magenta"),
+  cyan: (t) => c.text(t, "cyan"),
+  gray: (t) => c.text(t, "gray"),
+  white: (t) => c.text(t, "white"),
+  brightBlue: (t) => c.text(t, "brightBlue"),
+  bgBlue: (t) => c.text(t, "bgBlue", "white", "bold"),
+  success: (t) => c.text(t, "green", "bold"),
+  error: (t) => c.text(t, "red", "bold"),
+  warning: (t) => c.text(t, "yellow", "bold"),
+  info: (t) => c.text(t, "cyan", "bold"),
+  primary: (t) => c.text(t, "blue", "bold"),
+  secondary: (t) => c.text(t, "magenta", "bold"),
+  header: (t) => c.text(` ${t} `, "bgBlue", "white", "bold"),
+  step: (t) => c.text(` ${t} `, "bgCyan", "black", "bold"),
+  underline: (t) => c.text(t, "underline")
+};
+
+// ../sdk/src/utils/resolve-bin.ts
+import { existsSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { delimiter, join as join3 } from "node:path";
+var EXTRA_BIN_DIRS = [
+  join3(homedir2(), ".local", "bin"),
+  join3(homedir2(), ".npm", "bin"),
+  join3(homedir2(), ".npm-global", "bin"),
+  join3(homedir2(), ".yarn", "bin"),
+  "/usr/local/bin"
+];
+function getNodeManagerDirs() {
+  const dirs = [];
+  const nvmDir = process.env.NVM_DIR || join3(homedir2(), ".nvm");
+  const nvmCurrent = join3(nvmDir, "current", "bin");
+  if (existsSync(nvmCurrent)) {
+    dirs.push(nvmCurrent);
+  }
+  const fnmDir = process.env.FNM_DIR || join3(homedir2(), ".fnm");
+  const fnmCurrent = join3(fnmDir, "current", "bin");
+  if (existsSync(fnmCurrent)) {
+    dirs.push(fnmCurrent);
+  }
+  return dirs;
+}
+function getAugmentedPath() {
+  const currentPath = process.env.PATH || "";
+  const currentDirs = new Set(currentPath.split(delimiter));
+  const extra = [...EXTRA_BIN_DIRS, ...getNodeManagerDirs()].filter((dir) => !currentDirs.has(dir) && existsSync(dir));
+  if (extra.length === 0)
+    return currentPath;
+  return currentPath + delimiter + extra.join(delimiter);
+}
+function getAugmentedEnv(overrides = {}) {
+  return {
+    ...process.env,
+    ...overrides,
+    PATH: getAugmentedPath()
+  };
+}
+
+// ../sdk/src/ai/claude-runner.ts
+var SANDBOX_SETTINGS = JSON.stringify({
+  sandbox: {
+    enabled: true,
+    autoAllow: true,
+    allowUnsandboxedCommands: false
+  }
+});
+
+class ClaudeRunner {
+  model;
+  log;
+  projectPath;
+  eventEmitter;
+  currentToolName;
+  activeTools = new Map;
+  activeProcess = null;
+  constructor(projectPath, model = DEFAULT_MODEL[PROVIDER.CLAUDE], log2) {
+    this.model = model;
+    this.log = log2;
+    this.projectPath = resolve(projectPath);
+  }
+  setEventEmitter(emitter) {
+    this.eventEmitter = emitter;
+  }
+  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++) {
+      try {
+        return await this.executeRun(prompt);
+      } catch (error48) {
+        const err = error48;
+        lastError = err;
+        const isLastAttempt = attempt === maxRetries;
+        if (!isLastAttempt) {
+          const delay = Math.pow(2, attempt) * 1000;
+          console.warn(`Claude CLI attempt ${attempt} failed: ${err.message}. Retrying in ${delay}ms...`);
+          await new Promise((resolve2) => setTimeout(resolve2, delay));
+        }
+      }
+    }
+    throw lastError || new Error("Claude CLI failed after multiple attempts");
+  }
+  async* runStream(prompt) {
+    const args = [
+      "--dangerously-skip-permissions",
+      "--print",
+      "--verbose",
+      "--output-format",
+      "stream-json",
+      "--include-partial-messages",
+      "--model",
+      this.model,
+      "--settings",
+      SANDBOX_SETTINGS
+    ];
+    const env = getAugmentedEnv({
+      FORCE_COLOR: "1",
+      TERM: "xterm-256color"
+    });
+    this.eventEmitter?.emitSessionStarted({
+      model: this.model,
+      provider: "claude"
+    });
+    this.eventEmitter?.emitPromptSubmitted(prompt, prompt.length > 500);
+    const claude = spawn2("claude", args, {
+      cwd: this.projectPath,
+      stdio: ["pipe", "pipe", "pipe"],
+      env
+    });
+    this.activeProcess = claude;
+    let buffer = "";
+    let stderrBuffer = "";
+    let resolveChunk = null;
+    const chunkQueue = [];
+    let processEnded = false;
+    let errorMessage = "";
+    let finalContent = "";
+    let isThinking = false;
+    const enqueueChunk = (chunk) => {
+      this.emitEventForChunk(chunk, isThinking);
+      if (chunk.type === "thinking") {
+        isThinking = true;
+      } else if (chunk.type === "text_delta" || chunk.type === "tool_use") {
+        if (isThinking) {
+          this.eventEmitter?.emitThinkingStoped();
+          isThinking = false;
+        }
+      }
+      if (chunk.type === "text_delta") {
+        finalContent += chunk.content;
+      }
+      if (resolveChunk) {
+        const resolve2 = resolveChunk;
+        resolveChunk = null;
+        resolve2(chunk);
+      } else {
+        chunkQueue.push(chunk);
+      }
+    };
+    const signalEnd = () => {
+      processEnded = true;
+      if (resolveChunk) {
+        resolveChunk(null);
+        resolveChunk = null;
+      }
+    };
+    claude.stdout.on("data", (data) => {
+      buffer += data.toString();
+      const lines = buffer.split(`
+`);
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const chunk = this.parseStreamLineToChunk(line);
+        if (chunk) {
+          enqueueChunk(chunk);
+        }
+      }
+    });
+    claude.stderr.on("data", (data) => {
+      const chunk = data.toString();
+      stderrBuffer += chunk;
+      const lines = stderrBuffer.split(`
+`);
+      stderrBuffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!this.shouldSuppressLine(line)) {
+          process.stderr.write(`${line}
+`);
+        }
+      }
+    });
+    claude.on("error", (err) => {
+      errorMessage = `Failed to start Claude CLI: ${err.message}. Please ensure the 'claude' command is available in your PATH.`;
+      this.eventEmitter?.emitErrorOccurred(errorMessage, "SPAWN_ERROR");
+      signalEnd();
+    });
+    claude.on("close", (code) => {
+      this.activeProcess = null;
+      if (stderrBuffer && !this.shouldSuppressLine(stderrBuffer)) {
+        process.stderr.write(`${stderrBuffer}
+`);
+      }
+      if (code !== 0 && !errorMessage) {
+        errorMessage = this.createExecutionError(code, stderrBuffer).message;
+        this.eventEmitter?.emitErrorOccurred(errorMessage, `EXIT_${code}`);
+      }
+      signalEnd();
+    });
+    claude.stdin.write(prompt);
+    claude.stdin.end();
+    while (true) {
+      if (chunkQueue.length > 0) {
+        const chunk = chunkQueue.shift();
+        if (chunk)
+          yield chunk;
+      } else if (processEnded) {
+        if (errorMessage) {
+          yield { type: "error", error: errorMessage };
+          this.eventEmitter?.emitSessionEnded(false);
+        } else {
+          if (finalContent) {
+            this.eventEmitter?.emitResponseCompleted(finalContent);
+          }
+          this.eventEmitter?.emitSessionEnded(true);
+        }
+        break;
+      } else {
+        const chunk = await new Promise((resolve2) => {
+          resolveChunk = resolve2;
+        });
+        if (chunk === null) {
+          if (errorMessage) {
+            yield { type: "error", error: errorMessage };
+            this.eventEmitter?.emitSessionEnded(false);
+          } else {
+            if (finalContent) {
+              this.eventEmitter?.emitResponseCompleted(finalContent);
+            }
+            this.eventEmitter?.emitSessionEnded(true);
+          }
+          break;
+        }
+        yield chunk;
+      }
+    }
+  }
+  emitEventForChunk(chunk, isThinking) {
+    if (!this.eventEmitter)
+      return;
+    switch (chunk.type) {
+      case "text_delta":
+        this.eventEmitter.emitTextDelta(chunk.content);
+        break;
+      case "tool_use":
+        if (this.currentToolName) {
+          this.eventEmitter.emitToolCompleted(this.currentToolName);
+        }
+        this.currentToolName = chunk.tool;
+        this.eventEmitter.emitToolStarted(chunk.tool, chunk.id);
+        break;
+      case "thinking":
+        if (!isThinking) {
+          this.eventEmitter.emitThinkingStarted(chunk.content);
+        }
+        break;
+      case "result":
+        if (this.currentToolName) {
+          this.eventEmitter.emitToolCompleted(this.currentToolName);
+          this.currentToolName = undefined;
+        }
+        break;
+      case "error":
+        this.eventEmitter.emitErrorOccurred(chunk.error);
+        break;
+    }
+  }
+  parseStreamLineToChunk(line) {
+    if (!line.trim())
+      return null;
+    try {
+      const item = JSON.parse(line);
+      return this.processStreamItemToChunk(item);
+    } catch {
+      return null;
+    }
+  }
+  processStreamItemToChunk(item) {
+    if (item.type === "result") {
+      return { type: "result", content: item.result || "" };
+    }
+    if (item.type === "stream_event" && item.event) {
+      return this.handleEventToChunk(item.event);
+    }
+    return null;
+  }
+  handleEventToChunk(event) {
+    const { type, delta, content_block, index } = event;
+    if (type === "content_block_delta" && delta?.type === "text_delta") {
+      return { type: "text_delta", content: delta.text || "" };
+    }
+    if (type === "content_block_delta" && delta?.type === "input_json_delta" && delta.partial_json !== undefined && index !== undefined) {
+      const activeTool = this.activeTools.get(index);
+      if (activeTool) {
+        activeTool.parameterJson += delta.partial_json;
+      }
+      return null;
+    }
+    if (type === "content_block_start" && content_block) {
+      if (content_block.type === "tool_use" && content_block.name) {
+        if (index !== undefined) {
+          this.activeTools.set(index, {
+            name: content_block.name,
+            id: content_block.id,
+            index,
+            parameterJson: "",
+            startTime: Date.now()
+          });
+        }
+        return {
+          type: "tool_use",
+          tool: content_block.name,
+          id: content_block.id
+        };
+      }
+      if (content_block.type === "thinking") {
+        return { type: "thinking" };
+      }
+    }
+    if (type === "content_block_stop" && index !== undefined) {
+      const activeTool = this.activeTools.get(index);
+      if (activeTool?.parameterJson) {
+        try {
+          const parameters = JSON.parse(activeTool.parameterJson);
+          return {
+            type: "tool_parameters",
+            tool: activeTool.name,
+            id: activeTool.id,
+            parameters
+          };
+        } catch {}
+      }
+      return null;
+    }
+    return null;
+  }
+  executeRun(prompt) {
+    return new Promise((resolve2, reject) => {
+      const args = [
+        "--dangerously-skip-permissions",
+        "--print",
+        "--verbose",
+        "--output-format",
+        "stream-json",
+        "--include-partial-messages",
+        "--model",
+        this.model,
+        "--settings",
+        SANDBOX_SETTINGS
+      ];
+      const env = getAugmentedEnv({
+        FORCE_COLOR: "1",
+        TERM: "xterm-256color"
+      });
+      const claude = spawn2("claude", args, {
+        cwd: this.projectPath,
+        stdio: ["pipe", "pipe", "pipe"],
+        env
+      });
+      this.activeProcess = claude;
+      let finalResult = "";
+      let errorOutput = "";
+      let buffer = "";
+      let stderrBuffer = "";
+      claude.stdout.on("data", (data) => {
+        buffer += data.toString();
+        const lines = buffer.split(`
+`);
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          const result = this.handleStreamLine(line);
+          if (result)
+            finalResult = result;
+        }
+      });
+      claude.stderr.on("data", (data) => {
+        const chunk = data.toString();
+        errorOutput += chunk;
+        stderrBuffer += chunk;
+        const lines = stderrBuffer.split(`
+`);
+        stderrBuffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!this.shouldSuppressLine(line)) {
+            process.stderr.write(`${line}
+`);
+          }
+        }
+      });
+      claude.on("error", (err) => {
+        reject(new Error(`Failed to start Claude CLI: ${err.message}. Please ensure the 'claude' command is available in your PATH.`));
+      });
+      claude.on("close", (code) => {
+        this.activeProcess = null;
+        if (stderrBuffer && !this.shouldSuppressLine(stderrBuffer)) {
+          process.stderr.write(`${stderrBuffer}
+`);
+        }
+        process.stdout.write(`
+`);
+        if (code === 0) {
+          resolve2(finalResult);
+        } else {
+          reject(this.createExecutionError(code, errorOutput));
+        }
+      });
+      claude.stdin.write(prompt);
+      claude.stdin.end();
+    });
+  }
+  handleStreamLine(line) {
+    if (!line.trim())
+      return null;
+    try {
+      const item = JSON.parse(line);
+      return this.processStreamItem(item);
+    } catch {
+      return null;
+    }
+  }
+  processStreamItem(item) {
+    if (item.type === "result") {
+      return item.result || "";
+    }
+    if (item.type === "stream_event" && item.event) {
+      this.handleEvent(item.event);
+    }
+    return null;
+  }
+  handleEvent(event) {
+    const { type, content_block } = event;
+    if (type === "content_block_start" && content_block) {
+      if (content_block.type === "tool_use" && content_block.name) {
+        this.log?.(`
+${c.primary("[Claude]")} ${c.bold(`Running ${content_block.name}...`)}
+`, "info");
+      }
+    }
+  }
+  shouldSuppressLine(line) {
+    const infoLogRegex = /^\[\d{2}:\d{2}:\d{2}\]\s\[.*?\]\sℹ\s*$/;
+    return infoLogRegex.test(line.trim());
+  }
+  createExecutionError(code, detail) {
+    const errorMsg = detail.trim();
+    const message = errorMsg ? `Claude CLI error (exit code ${code}): ${errorMsg}` : `Claude CLI exited with code ${code}. Please ensure the Claude CLI is installed and you are logged in.`;
+    return new Error(message);
+  }
+}
+
+// ../sdk/src/ai/codex-runner.ts
+import { spawn as spawn3 } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync as existsSync2, readFileSync, unlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join4 } from "node:path";
+class CodexRunner {
+  projectPath;
+  model;
+  log;
+  activeProcess = null;
+  constructor(projectPath, model = DEFAULT_MODEL[PROVIDER.CODEX], log2) {
+    this.projectPath = projectPath;
+    this.model = model;
+    this.log = log2;
+  }
+  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++) {
+      try {
+        return await this.executeRun(prompt);
+      } catch (error48) {
+        lastError = error48;
+        if (attempt < maxRetries) {
+          const delay = Math.pow(2, attempt) * 1000;
+          console.warn(`Codex CLI attempt ${attempt} failed: ${lastError.message}. Retrying in ${delay}ms...`);
+          await this.sleep(delay);
+        }
+      }
+    }
+    throw lastError || new Error("Codex CLI failed after multiple attempts");
+  }
+  async* runStream(prompt) {
+    const outputPath = join4(tmpdir(), `locus-codex-${randomUUID()}.txt`);
+    const args = this.buildArgs(outputPath);
+    const codex = spawn3("codex", args, {
+      cwd: this.projectPath,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: getAugmentedEnv(),
+      shell: false
+    });
+    this.activeProcess = codex;
+    let resolveChunk = null;
+    const chunkQueue = [];
+    let processEnded = false;
+    let errorMessage = "";
+    let finalOutput = "";
+    const enqueueChunk = (chunk) => {
+      if (resolveChunk) {
+        const resolve2 = resolveChunk;
+        resolveChunk = null;
+        resolve2(chunk);
+      } else {
+        chunkQueue.push(chunk);
+      }
+    };
+    const signalEnd = () => {
+      processEnded = true;
+      if (resolveChunk) {
+        resolveChunk(null);
+        resolveChunk = null;
+      }
+    };
+    const processOutput = (data) => {
+      const msg = data.toString();
+      finalOutput += msg;
+      for (const rawLine of msg.split(`
+`)) {
+        const line = rawLine.trim();
+        if (!line)
+          continue;
+        if (/^thinking\b/i.test(line)) {
+          enqueueChunk({ type: "thinking", content: line });
+        } else if (/^[→•✓]/.test(line) || /^Plan update\b/.test(line)) {
+          enqueueChunk({
+            type: "tool_use",
+            tool: line.replace(/^[→•✓]\s*/, "")
+          });
+        } else if (this.shouldDisplay(line)) {
+          enqueueChunk({ type: "text_delta", content: `${line}
+` });
+        }
+      }
+    };
+    codex.stdout.on("data", processOutput);
+    codex.stderr.on("data", processOutput);
+    codex.on("error", (err) => {
+      errorMessage = `Failed to start Codex CLI: ${err.message}. Ensure 'codex' is installed and available in PATH.`;
+      signalEnd();
+    });
+    codex.on("close", (code) => {
+      this.activeProcess = null;
+      this.cleanupTempFile(outputPath);
+      if (code === 0) {
+        const result = this.readOutput(outputPath, finalOutput);
+        enqueueChunk({ type: "result", content: result });
+      } else if (!errorMessage) {
+        errorMessage = this.createErrorFromOutput(code, finalOutput).message;
+      }
+      signalEnd();
+    });
+    codex.stdin.write(prompt);
+    codex.stdin.end();
+    while (true) {
+      if (chunkQueue.length > 0) {
+        const chunk = chunkQueue.shift();
+        if (chunk)
+          yield chunk;
+      } else if (processEnded) {
+        if (errorMessage) {
+          yield { type: "error", error: errorMessage };
+        }
+        break;
+      } else {
+        const chunk = await new Promise((resolve2) => {
+          resolveChunk = resolve2;
+        });
+        if (chunk === null) {
+          if (errorMessage) {
+            yield { type: "error", error: errorMessage };
+          }
+          break;
+        }
+        yield chunk;
+      }
+    }
+  }
+  executeRun(prompt) {
+    return new Promise((resolve2, reject) => {
+      const outputPath = join4(tmpdir(), `locus-codex-${randomUUID()}.txt`);
+      const args = this.buildArgs(outputPath);
+      const codex = spawn3("codex", args, {
+        cwd: this.projectPath,
+        stdio: ["pipe", "pipe", "pipe"],
+        env: getAugmentedEnv(),
+        shell: false
+      });
+      this.activeProcess = codex;
+      let output = "";
+      let errorOutput = "";
+      const handleOutput = (data) => {
+        const msg = data.toString();
+        output += msg;
+        this.streamToConsole(msg);
+      };
+      codex.stdout.on("data", handleOutput);
+      codex.stderr.on("data", (data) => {
+        const msg = data.toString();
+        errorOutput += msg;
+        this.streamToConsole(msg);
+      });
+      codex.on("error", (err) => {
+        reject(new Error(`Failed to start Codex CLI: ${err.message}. ` + `Ensure 'codex' is installed and available in PATH.`));
+      });
+      codex.on("close", (code) => {
+        this.activeProcess = null;
+        this.cleanupTempFile(outputPath);
+        if (code === 0) {
+          resolve2(this.readOutput(outputPath, output));
+        } else {
+          reject(this.createErrorFromOutput(code, errorOutput));
+        }
+      });
+      codex.stdin.write(prompt);
+      codex.stdin.end();
+    });
+  }
+  buildArgs(outputPath) {
+    const args = [
+      "exec",
+      "--sandbox",
+      "workspace-write",
+      "--skip-git-repo-check",
+      "--output-last-message",
+      outputPath
+    ];
+    if (this.model) {
+      args.push("--model", this.model);
+    }
+    args.push("-");
+    return args;
+  }
+  streamToConsole(chunk) {
+    for (const rawLine of chunk.split(`
+`)) {
+      const line = rawLine.trim();
+      if (line && this.shouldDisplay(line)) {
+        const formattedLine = "[Codex]: ".concat(line.replace(/\*/g, ""));
+        this.log?.(formattedLine, "info");
+      }
+    }
+  }
+  shouldDisplay(line) {
+    return [
+      /^thinking\b/,
+      /^\*\*/,
+      /^Plan update\b/,
+      /^[→•✓]/
+    ].some((pattern) => pattern.test(line));
+  }
+  readOutput(outputPath, fallback) {
+    if (existsSync2(outputPath)) {
+      try {
+        const text = readFileSync(outputPath, "utf-8").trim();
+        if (text)
+          return text;
+      } catch {}
+    }
+    return fallback.trim();
+  }
+  createErrorFromOutput(code, errorOutput) {
+    const detail = errorOutput.trim();
+    const message = detail ? `Codex CLI error (exit code ${code}): ${detail}` : `Codex CLI exited with code ${code}. ` + `Ensure Codex CLI is installed and you are logged in.`;
+    return new Error(message);
+  }
+  cleanupTempFile(path) {
+    try {
+      if (existsSync2(path))
+        unlinkSync(path);
+    } catch {}
+  }
+  sleep(ms) {
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
+  }
+}
+
+// ../sdk/src/ai/factory.ts
+function createAiRunner(provider, config2) {
+  const resolvedProvider = provider ?? PROVIDER.CLAUDE;
+  const model = config2.model ?? DEFAULT_MODEL[resolvedProvider];
+  switch (resolvedProvider) {
+    case PROVIDER.CODEX:
+      return new CodexRunner(config2.projectPath, model, config2.log);
+    default:
+      return new ClaudeRunner(config2.projectPath, model, config2.log);
+  }
+}
+
+// ../sdk/src/git/git-utils.ts
+import { execFileSync } from "node:child_process";
+function isGitAvailable() {
+  try {
+    execFileSync("git", ["--version"], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isGhAvailable(projectPath) {
+  try {
+    execFileSync("gh", ["auth", "status"], {
+      cwd: projectPath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getGhUsername() {
+  try {
+    const output = execFileSync("gh", ["api", "user", "--jq", ".login"], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return output || null;
+  } catch {
+    return null;
+  }
+}
+function detectRemoteProvider(projectPath) {
+  const url3 = getRemoteUrl(projectPath);
+  if (!url3)
+    return "unknown";
+  if (url3.includes("github.com"))
+    return "github";
+  if (url3.includes("gitlab.com") || url3.includes("gitlab"))
+    return "gitlab";
+  if (url3.includes("bitbucket.org"))
+    return "bitbucket";
+  return "unknown";
+}
+function getRemoteUrl(projectPath, remote = "origin") {
+  try {
+    return execFileSync("git", ["remote", "get-url", remote], {
+      cwd: projectPath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function getCurrentBranch(projectPath) {
+  return 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 = 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 {
+        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";
+    }
+  }
+}
+
+// ../sdk/src/git/pr-service.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+class PrService {
+  projectPath;
+  log;
+  constructor(projectPath, log2) {
+    this.projectPath = projectPath;
+    this.log = log2;
+  }
+  createPr(options) {
+    const {
+      task: task2,
+      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] ${task2.title}`;
+    const body = this.buildPrBody(task2, agentId, summary);
+    const baseBranch = requestedBaseBranch ?? getDefaultBranch(this.projectPath);
+    this.validateCreatePrInputs(baseBranch, branch);
+    this.log(`Creating PR: ${title} (${branch} → ${baseBranch})`, "info");
+    const output = execFileSync2("gh", [
+      "pr",
+      "create",
+      "--title",
+      title,
+      "--body",
+      body,
+      "--base",
+      baseBranch,
+      "--head",
+      branch
+    ], {
+      cwd: this.projectPath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const url3 = output;
+    const prNumber = this.extractPrNumber(url3);
+    this.log(`PR created: ${url3}`, "success");
+    return { url: url3, 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.`);
+    }
+    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.`);
+    }
+  }
+  countCommitsAhead(baseRef, headRef) {
+    const output = execFileSync2("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;
+  }
+  hasLocalBranch(branch) {
+    try {
+      execFileSync2("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`], {
+        cwd: this.projectPath,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  hasRemoteTrackingBranch(branch) {
+    try {
+      execFileSync2("git", ["show-ref", "--verify", "--quiet", `refs/remotes/origin/${branch}`], {
+        cwd: this.projectPath,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  hasRemoteBranch(branch) {
+    try {
+      execFileSync2("git", ["ls-remote", "--exit-code", "--heads", "origin", branch], {
+        cwd: this.projectPath,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getPrDiff(branch) {
+    return execFileSync2("gh", ["pr", "diff", branch], {
+      cwd: this.projectPath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      maxBuffer: 10 * 1024 * 1024
+    });
+  }
+  submitReview(prIdentifier, body, event) {
+    try {
+      execFileSync2("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")) {
+        execFileSync2("gh", ["pr", "review", prIdentifier, "--body", body, "--comment"], {
+          cwd: this.projectPath,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        return;
+      }
+      throw err;
+    }
+  }
+  listLocusPrs() {
+    try {
+      const output = execFileSync2("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 {
+      this.log("Failed to list Locus PRs", "warn");
+      return [];
+    }
+  }
+  hasLocusReview(prNumber) {
+    try {
+      const output = execFileSync2("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;
+    }
+  }
+  listUnreviewedLocusPrs() {
+    const allPrs = this.listLocusPrs();
+    return allPrs.filter((pr) => !this.hasLocusReview(String(pr.number)));
+  }
+  buildPrBody(task2, agentId, summary) {
+    const sections = [];
+    sections.push(`## Task: ${task2.title}`);
+    sections.push("");
+    if (task2.description) {
+      sections.push(task2.description);
+      sections.push("");
+    }
+    if (task2.acceptanceChecklist?.length > 0) {
+      sections.push("## Acceptance Criteria");
+      for (const item of task2.acceptanceChecklist) {
+        sections.push(`- [ ] ${item.text}`);
+      }
+      sections.push("");
+    }
+    if (summary) {
+      sections.push("## Agent Summary");
+      sections.push(summary);
+      sections.push("");
+    }
+    sections.push("---");
+    sections.push(`*Created by Locus Agent \`${agentId.slice(-8)}\`* | Task ID: \`${task2.id}\``);
+    return sections.join(`
+`);
+  }
+  extractPrNumber(url3) {
+    const match = url3.match(/\/pull\/(\d+)/);
+    return match ? Number.parseInt(match[1], 10) : 0;
+  }
+}
+
+// ../sdk/src/project/knowledge-base.ts
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+class KnowledgeBase {
+  contextPath;
+  progressPath;
+  constructor(projectPath) {
+    this.contextPath = getLocusPath(projectPath, "projectContextFile");
+    this.progressPath = getLocusPath(projectPath, "projectProgressFile");
+  }
+  readContext() {
+    if (!existsSync3(this.contextPath)) {
+      return "";
+    }
+    return readFileSync2(this.contextPath, "utf-8");
+  }
+  readProgress() {
+    if (!existsSync3(this.progressPath)) {
+      return "";
+    }
+    return readFileSync2(this.progressPath, "utf-8");
+  }
+  updateContext(content) {
+    this.ensureDir(this.contextPath);
+    writeFileSync(this.contextPath, content);
+  }
+  updateProgress(event) {
+    this.ensureDir(this.progressPath);
+    const existing = this.readProgress();
+    const timestamp2 = (event.timestamp ?? new Date).toISOString();
+    let entry = "";
+    switch (event.type) {
+      case "task_completed":
+        entry = `- [x] ${event.title} — completed ${timestamp2}`;
+        break;
+      case "sprint_started":
+        entry = `
+## Current Sprint: ${event.title}
+**Status:** ACTIVE | Started: ${timestamp2}
+`;
+        break;
+      case "sprint_completed":
+        entry = `
+### Sprint Completed: ${event.title} — ${timestamp2}
+`;
+        break;
+      case "blocker":
+        entry = `- BLOCKER: ${event.title}`;
+        break;
+      case "pr_opened":
+        entry = `- [ ] ${event.title} — PR opened ${timestamp2}`;
+        break;
+      case "pr_reviewed":
+        entry = `- ${event.title} — reviewed ${timestamp2}`;
+        break;
+      case "pr_merged":
+        entry = `- [x] ${event.title} — PR merged ${timestamp2}`;
+        break;
+      case "exec_completed":
+        entry = `- [x] ${event.title} — exec ${timestamp2}`;
+        break;
+    }
+    if (event.details) {
+      entry += `
+  ${event.details}`;
+    }
+    const updated = existing ? `${existing}
+${entry}` : `# Project Progress
+
+${entry}`;
+    writeFileSync(this.progressPath, updated);
+  }
+  getFullContext() {
+    const context = this.readContext();
+    const progress = this.readProgress();
+    const parts = [];
+    if (context.trim()) {
+      parts.push(context.trim());
+    }
+    if (progress.trim()) {
+      parts.push(progress.trim());
+    }
+    return parts.join(`
+
+---
+
+`);
+  }
+  initialize(info) {
+    this.ensureDir(this.contextPath);
+    this.ensureDir(this.progressPath);
+    const techStackList = info.techStack.map((t) => `- ${t}`).join(`
+`);
+    const contextContent = `# Project: ${info.name}
+
+## Mission
+${info.mission}
+
+## Tech Stack
+${techStackList}
+
+## Architecture
+<!-- Describe your high-level architecture here -->
+
+## Key Decisions
+<!-- Document important technical decisions and their rationale -->
+
+## Feature Areas
+<!-- List your main feature areas and their status -->
+`;
+    const progressContent = `# Project Progress
+
+No sprints started yet.
+`;
+    writeFileSync(this.contextPath, contextContent);
+    writeFileSync(this.progressPath, progressContent);
+  }
+  get exists() {
+    return existsSync3(this.contextPath) || existsSync3(this.progressPath);
+  }
+  ensureDir(filePath) {
+    const dir = dirname(filePath);
+    if (!existsSync3(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+}
+
+// ../sdk/src/agent/reviewer-worker.ts
+function resolveProvider(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(config2) {
+    this.config = config2;
+    const projectPath = config2.projectPath || process.cwd();
+    this.client = new LocusClient({
+      baseUrl: config2.apiBase,
+      token: config2.apiKey,
+      retryOptions: {
+        maxRetries: 3,
+        initialDelay: 1000,
+        maxDelay: 5000,
+        factor: 2
+      }
+    });
+    const log2 = this.log.bind(this);
+    const provider = config2.provider ?? PROVIDER.CLAUDE;
+    this.aiRunner = createAiRunner(provider, {
+      projectPath,
+      model: config2.model,
+      log: log2
+    });
+    this.prService = new PrService(projectPath, log2);
+    this.knowledgeBase = new KnowledgeBase(projectPath);
+    const providerLabel = provider === "codex" ? "Codex" : "Claude";
+    this.log(`Reviewer agent using ${providerLabel} CLI`, "info");
+  }
+  log(message, level = "info") {
+    const timestamp2 = 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(`[${timestamp2}]`)} ${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);
+    }
+    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.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(`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);
+  }
+}
+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 config2 = {};
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--agent-id")
+      config2.agentId = args[++i];
+    else if (arg === "--workspace-id")
+      config2.workspaceId = args[++i];
+    else if (arg === "--sprint-id")
+      config2.sprintId = args[++i];
+    else if (arg === "--api-url")
+      config2.apiBase = args[++i];
+    else if (arg === "--api-key")
+      config2.apiKey = args[++i];
+    else if (arg === "--project-path")
+      config2.projectPath = args[++i];
+    else if (arg === "--model")
+      config2.model = args[++i];
+    else if (arg === "--provider") {
+      const value = args[i + 1];
+      if (value && !value.startsWith("--"))
+        i++;
+      config2.provider = resolveProvider(value);
+    }
+  }
+  if (!config2.agentId || !config2.workspaceId || !config2.apiBase || !config2.apiKey || !config2.projectPath) {
+    console.error("Missing required arguments");
+    process.exit(1);
+  }
+  const worker = new ReviewerWorker(config2);
+  worker.run().catch((err) => {
+    console.error("Fatal reviewer error:", err);
+    process.exit(1);
+  });
+}
+// ../sdk/src/core/prompt-builder.ts
+import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync3, statSync } from "node:fs";
+import { join as join5 } from "node:path";
+class PromptBuilder {
+  projectPath;
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+  }
+  async build(task2, options = {}) {
+    let prompt = `# Task: ${task2.title}
+
+`;
+    const roleText = this.roleToText(task2.assigneeRole);
+    if (roleText) {
+      prompt += `## Role
+You are acting as a ${roleText}.
+
+`;
+    }
+    prompt += `## Description
+${task2.description || "No description provided."}
+
+`;
+    const projectConfig = this.getProjectConfig();
+    if (projectConfig) {
+      prompt += `## Project Metadata
+`;
+      prompt += `- Version: ${projectConfig.version || "Unknown"}
+`;
+      prompt += `- Created At: ${projectConfig.createdAt || "Unknown"}
+
+`;
+    }
+    let serverContext = null;
+    if (options.taskContext) {
+      try {
+        serverContext = JSON.parse(options.taskContext);
+      } catch {
+        serverContext = { context: options.taskContext };
+      }
+    }
+    const contextPath = getLocusPath(this.projectPath, "contextFile");
+    let hasLocalContext = false;
+    if (existsSync4(contextPath)) {
+      try {
+        const context = readFileSync3(contextPath, "utf-8");
+        if (context.trim().length > 20) {
+          prompt += `## Project Context (Local)
+${context}
+
+`;
+          hasLocalContext = true;
+        }
+      } catch (err) {
+        console.warn(`Warning: Could not read context file: ${err}`);
+      }
+    }
+    if (!hasLocalContext) {
+      const fallback = this.getFallbackContext();
+      if (fallback) {
+        prompt += `## Project Context (README Fallback)
+${fallback}
+
+`;
+      }
+    }
+    if (serverContext) {
+      prompt += `## Project Context (Server)
+`;
+      const project = serverContext.project;
+      if (project) {
+        prompt += `- Project: ${project.name || "Unknown"}
+`;
+        if (!hasLocalContext && project.techStack?.length) {
+          prompt += `- Tech Stack: ${project.techStack.join(", ")}
+`;
+        }
+      }
+      if (serverContext.context) {
+        prompt += `
+${serverContext.context}
+`;
+      }
+      prompt += `
+`;
+    }
+    prompt += this.getProjectStructure();
+    prompt += `## Project Knowledge Base
+`;
+    prompt += `You have access to the following documentation directories for context:
+`;
+    prompt += `- Artifacts: \`.locus/artifacts\`
+`;
+    prompt += `- Documents: \`.locus/documents\`
+`;
+    prompt += `If you need more information about the project strategies, plans, or architecture, please read files in these directories.
+
+`;
+    const indexPath = getLocusPath(this.projectPath, "indexFile");
+    if (existsSync4(indexPath)) {
+      prompt += `## Codebase Overview
+There is an index file in the .locus/codebase-index.json and if you need you can check it.
+
+`;
+    }
+    if (task2.docs && task2.docs.length > 0) {
+      prompt += `## Attached Documents (Summarized)
+`;
+      prompt += `> Full content available on server. Rely on Task Description for specific requirements.
+
+`;
+      for (const doc3 of task2.docs) {
+        const content = doc3.content || "";
+        const limit = 800;
+        const preview = content.slice(0, limit);
+        const isTruncated = content.length > limit;
+        prompt += `### Doc: ${doc3.title}
+${preview}${isTruncated ? `
+...(truncated)...` : ""}
+
+`;
+      }
+    }
+    if (task2.acceptanceChecklist && task2.acceptanceChecklist.length > 0) {
+      prompt += `## Acceptance Criteria
+`;
+      for (const item of task2.acceptanceChecklist) {
+        prompt += `- ${item.done ? "[x]" : "[ ]"} ${item.text}
+`;
+      }
+      prompt += `
+`;
+    }
+    if (task2.comments && task2.comments.length > 0) {
+      const comments = task2.comments.slice(0, 3);
+      prompt += `## Task History & Feedback
+`;
+      prompt += `Review the following comments for context or rejection feedback:
+
+`;
+      for (const comment of comments) {
+        const date5 = new Date(comment.createdAt).toLocaleString();
+        prompt += `### ${comment.author} (${date5})
+${comment.text}
+
+`;
+      }
+    }
+    prompt += `## Instructions
+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. **Git**: Do NOT run \`git add\`, \`git commit\`, \`git push\`, or create branches. The Locus system handles all git operations automatically after your execution completes.
+5. **Progress**: Do NOT modify \`.locus/project/progress.md\`. The system updates it automatically.`;
+    return prompt;
+  }
+  async buildGenericPrompt(query) {
+    let prompt = `# Direct Execution
+
+`;
+    prompt += `## Prompt
+${query}
+
+`;
+    const projectConfig = this.getProjectConfig();
+    if (projectConfig) {
+      prompt += `## Project Metadata
+`;
+      prompt += `- Version: ${projectConfig.version || "Unknown"}
+`;
+      prompt += `- Created At: ${projectConfig.createdAt || "Unknown"}
+
+`;
+    }
+    const contextPath = getLocusPath(this.projectPath, "contextFile");
+    let hasLocalContext = false;
+    if (existsSync4(contextPath)) {
+      try {
+        const context = readFileSync3(contextPath, "utf-8");
+        if (context.trim().length > 20) {
+          prompt += `## Project Context (Local)
+${context}
+
+`;
+          hasLocalContext = true;
+        }
+      } catch (err) {
+        console.warn(`Warning: Could not read context file: ${err}`);
+      }
+    }
+    if (!hasLocalContext) {
+      const fallback = this.getFallbackContext();
+      if (fallback) {
+        prompt += `## Project Context (README Fallback)
+${fallback}
+
+`;
+      }
+    }
+    prompt += this.getProjectStructure();
+    prompt += `## Project Knowledge Base
+`;
+    prompt += `You have access to the following documentation directories for context:
+`;
+    prompt += `- Artifacts: \`.locus/artifacts\` (local-only, not synced to cloud)
+`;
+    prompt += `- Documents: \`.locus/documents\` (synced from cloud)
+`;
+    prompt += `If you need more information about the project strategies, plans, or architecture, please read files in these directories.
+
+`;
+    const indexPath = getLocusPath(this.projectPath, "indexFile");
+    if (existsSync4(indexPath)) {
+      prompt += `## Codebase Overview
+There is an index file in the .locus/codebase-index.json and if you need you can check it.
+
+`;
+    }
+    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. **Git**: Do NOT run \`git add\`, \`git commit\`, \`git push\`, or create branches. The Locus system handles all git operations automatically after your execution completes.
+4. **Progress**: Do NOT modify \`.locus/project/progress.md\`. The system updates it automatically.`;
+    return prompt;
+  }
+  getProjectConfig() {
+    const configPath = getLocusPath(this.projectPath, "configFile");
+    if (existsSync4(configPath)) {
+      try {
+        return JSON.parse(readFileSync3(configPath, "utf-8"));
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  getFallbackContext() {
+    const readmePath = join5(this.projectPath, "README.md");
+    if (existsSync4(readmePath)) {
+      try {
+        const content = readFileSync3(readmePath, "utf-8");
+        const limit = 1000;
+        return content.slice(0, limit) + (content.length > limit ? `
+...(truncated)...` : "");
+      } catch {
+        return "";
+      }
+    }
+    return "";
+  }
+  getProjectStructure() {
+    try {
+      const entries = readdirSync(this.projectPath);
+      const folders = entries.filter((e) => {
+        if (e.startsWith(".") || e === "node_modules")
+          return false;
+        try {
+          return statSync(join5(this.projectPath, e)).isDirectory();
+        } catch {
+          return false;
+        }
+      });
+      if (folders.length === 0)
+        return "";
+      let structure = `## Project Structure
+`;
+      structure += `Key directories in this project:
+`;
+      for (const folder of folders) {
+        structure += `- \`${folder}/\`
+`;
+      }
+      return `${structure}
+`;
+    } catch {
+      return "";
+    }
+  }
+  roleToText(role) {
+    if (!role) {
+      return null;
+    }
+    switch (role) {
+      case "BACKEND" /* BACKEND */:
+        return "Backend Engineer";
+      case "FRONTEND" /* FRONTEND */:
+        return "Frontend Engineer";
+      case "PM" /* PM */:
+        return "Product Manager";
+      case "QA" /* QA */:
+        return "QA Engineer";
+      case "DESIGN" /* DESIGN */:
+        return "Product Designer";
+      default:
+        return "engineer";
+    }
+  }
+}
+
+// ../sdk/src/agent/task-executor.ts
+class TaskExecutor {
+  deps;
+  promptBuilder;
+  constructor(deps) {
+    this.deps = deps;
+    this.promptBuilder = new PromptBuilder(deps.projectPath);
+  }
+  async execute(task2) {
+    this.deps.log(`Executing: ${task2.title}`, "info");
+    const basePrompt = await this.promptBuilder.build(task2);
+    try {
+      this.deps.log("Starting Execution...", "info");
+      await this.deps.aiRunner.run(basePrompt);
+      return {
+        success: true,
+        summary: "Task completed by the agent"
+      };
+    } catch (error48) {
+      return { success: false, summary: `Error: ${error48}` };
+    }
+  }
+}
+// ../sdk/src/worktree/worktree-manager.ts
+import { execFileSync as execFileSync3, execSync } from "node:child_process";
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, rmSync, statSync as statSync2 } from "node:fs";
+import { join as join6, resolve as resolve2, sep } from "node:path";
+
+// ../sdk/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"
+};
+
+// ../sdk/src/worktree/worktree-manager.ts
+class WorktreeManager {
+  config;
+  projectPath;
+  log;
+  constructor(projectPath, config2, log2) {
+    this.projectPath = resolve2(projectPath);
+    this.config = { ...DEFAULT_WORKTREE_CONFIG, ...config2 };
+    this.log = log2 ?? ((_msg) => {
+      return;
+    });
+  }
+  get rootPath() {
+    return join6(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 = join6(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 (existsSync5(worktreePath)) {
+      this.log(`Removing stale worktree directory: ${worktreePath}`, "warn");
+      try {
+        this.git(`worktree remove "${worktreePath}" --force`, this.projectPath);
+      } catch {
+        rmSync(worktreePath, { recursive: true, force: true });
+        this.git("worktree prune", this.projectPath);
+      }
+    }
+    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 = resolve2(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.`);
+        }
+        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 (error48) {
+      if (!this.isMissingDirectoryError(error48)) {
+        throw error48;
+      }
+      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 (resolve2(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 = resolve2(worktreePath);
+    const worktrees = this.list();
+    const worktree = worktrees.find((wt) => resolve2(wt.path) === absolutePath);
+    const branchToDelete = worktree?.branch;
+    this.log(`Removing worktree: ${absolutePath}`, "info");
+    try {
+      this.git(`worktree remove "${absolutePath}" --force`, this.projectPath);
+    } catch {
+      if (existsSync5(absolutePath)) {
+        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 (existsSync5(this.rootPath)) {
+      try {
+        rmSync(this.rootPath, { recursive: true, force: true });
+      } catch {}
+    }
+    return removed;
+  }
+  hasChanges(worktreePath) {
+    const status = this.git("status --porcelain", worktreePath).trim();
+    return status.length > 0;
+  }
+  hasCommitsAhead(worktreePath, baseBranch) {
+    try {
+      const count = this.git(`rev-list --count "${baseBranch}..HEAD"`, worktreePath).trim();
+      return Number.parseInt(count, 10) > 0;
+    } catch {
+      return false;
+    }
+  }
+  commitChanges(worktreePath, message, baseBranch) {
+    const hasUncommittedChanges = this.hasChanges(worktreePath);
+    if (!hasUncommittedChanges) {
+      if (baseBranch && this.hasCommitsAhead(worktreePath, baseBranch)) {
+        const hash3 = this.git("rev-parse HEAD", worktreePath).trim();
+        this.log(`Agent already committed changes (${hash3.slice(0, 8)}); skipping additional commit`, "info");
+        return hash3;
+      }
+      this.log("No changes to commit", "info");
+      return null;
+    }
+    this.git("add -A", worktreePath);
+    const staged = this.git("diff --cached --name-only", worktreePath).trim();
+    if (!staged) {
+      this.log("No changes to commit", "info");
+      return null;
+    }
+    this.gitExec(["commit", "-m", message], worktreePath);
+    const hash2 = this.git("rev-parse HEAD", worktreePath).trim();
+    this.log(`Committed: ${hash2.slice(0, 8)}`, "success");
+    return hash2;
+  }
+  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 (error48) {
+      if (!this.isNonFastForwardPushError(error48)) {
+        throw error48;
+      }
+      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 = resolve2(this.rootPath);
+    const candidate = resolve2(worktreePath);
+    const rootWithSep = rootPath.endsWith(sep) ? rootPath : `${rootPath}${sep}`;
+    return candidate.startsWith(rootWithSep);
+  }
+  ensureDirectory(dirPath, label) {
+    if (existsSync5(dirPath)) {
+      if (!statSync2(dirPath).isDirectory()) {
+        throw new Error(`${label} exists but is not a directory: ${dirPath}`);
+      }
+      return;
+    }
+    mkdirSync2(dirPath, { recursive: true });
+  }
+  isMissingDirectoryError(error48) {
+    const message = error48 instanceof Error ? error48.message : String(error48);
+    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 (existsSync5(worktreePath)) {
+      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(error48) {
+    const message = error48 instanceof Error ? error48.message : String(error48);
+    return message.includes("non-fast-forward") || message.includes("[rejected]") || message.includes("fetch first");
+  }
+  git(args, cwd) {
+    return execSync(`git ${args}`, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  }
+  gitExec(args, cwd) {
+    return execFileSync3("git", args, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  }
+}
+
+// ../sdk/src/agent/worker.ts
+function resolveProvider2(value) {
+  if (!value || value.startsWith("--")) {
+    console.warn("Warning: --provider requires a value. Falling back to 'claude'.");
+    return PROVIDER.CLAUDE;
+  }
+  if (value === PROVIDER.CLAUDE || value === PROVIDER.CODEX)
+    return value;
+  console.warn(`Warning: invalid --provider value '${value}'. Falling back to 'claude'.`);
+  return PROVIDER.CLAUDE;
+}
+
+class AgentWorker {
+  config;
+  client;
+  aiRunner;
+  taskExecutor;
+  knowledgeBase;
+  worktreeManager = null;
+  prService = null;
+  maxTasks = 50;
+  tasksCompleted = 0;
+  heartbeatInterval = null;
+  currentTaskId = null;
+  currentWorktreePath = null;
+  postCleanupDelayMs = 5000;
+  ghUsername = null;
+  constructor(config2) {
+    this.config = config2;
+    const projectPath = config2.projectPath || process.cwd();
+    this.client = new LocusClient({
+      baseUrl: config2.apiBase,
+      token: config2.apiKey,
+      retryOptions: {
+        maxRetries: 3,
+        initialDelay: 1000,
+        maxDelay: 5000,
+        factor: 2
+      }
+    });
+    const log2 = this.log.bind(this);
+    if (config2.useWorktrees && !isGitAvailable()) {
+      this.log("git is not installed — worktree isolation will not work", "error");
+      config2.useWorktrees = false;
+    }
+    if (config2.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 (config2.autoPush) {
+      this.ghUsername = getGhUsername();
+      if (this.ghUsername) {
+        this.log(`GitHub user: ${this.ghUsername}`, "info");
+      }
+    }
+    const provider = config2.provider ?? PROVIDER.CLAUDE;
+    this.aiRunner = createAiRunner(provider, {
+      projectPath,
+      model: config2.model,
+      log: log2
+    });
+    this.taskExecutor = new TaskExecutor({
+      aiRunner: this.aiRunner,
+      projectPath,
+      log: log2
+    });
+    this.knowledgeBase = new KnowledgeBase(projectPath);
+    if (config2.useWorktrees) {
+      this.worktreeManager = new WorktreeManager(projectPath, {
+        cleanupPolicy: "auto"
+      });
+    }
+    if (config2.autoPush) {
+      this.prService = new PrService(projectPath, log2);
+    }
+    const providerLabel = provider === "codex" ? "Codex" : "Claude";
+    this.log(`Using ${providerLabel} CLI for all phases`, "info");
+    if (config2.useWorktrees) {
+      this.log("Per-task worktree isolation enabled", "info");
+      if (config2.autoPush) {
+        this.log("Auto-push enabled: branches will be pushed to remote", "info");
+      }
+    }
+  }
+  log(message, level = "info") {
+    const timestamp2 = 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(`[${timestamp2}]`)} ${c.bold(`[${this.config.agentId.slice(-8)}]`)} ${colorFn(`${prefix} ${message}`)}`);
+  }
+  async getActiveSprint() {
+    try {
+      if (this.config.sprintId) {
+        return await this.client.sprints.getById(this.config.sprintId, this.config.workspaceId);
+      }
+      return await this.client.sprints.getActive(this.config.workspaceId);
+    } catch (_error) {
+      return null;
+    }
+  }
+  async getNextTask() {
+    const maxRetries = 10;
+    for (let attempt = 1;attempt <= maxRetries; attempt++) {
+      try {
+        const task2 = await this.client.workspaces.dispatch(this.config.workspaceId, this.config.agentId, this.config.sprintId);
+        return task2;
+      } catch (error48) {
+        const isAxiosError2 = error48 != null && typeof error48 === "object" && "response" in error48 && typeof error48.response?.status === "number";
+        const status = isAxiosError2 ? error48.response.status : 0;
+        if (status === 404) {
+          this.log("No tasks available in the backlog.", "info");
+          return null;
+        }
+        const msg = error48 instanceof Error ? error48.message : String(error48);
+        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(task2) {
+    if (!this.worktreeManager) {
+      return {
+        worktreePath: null,
+        baseBranch: null,
+        executor: this.taskExecutor
+      };
+    }
+    const slug = task2.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
+    const result = this.worktreeManager.create({
+      taskId: task2.id,
+      taskSlug: slug,
+      agentId: this.config.agentId
+    });
+    this.log(`Worktree created: ${result.worktreePath} (${result.branch})`, "info");
+    const log2 = this.log.bind(this);
+    const provider = this.config.provider ?? PROVIDER.CLAUDE;
+    const taskAiRunner = createAiRunner(provider, {
+      projectPath: result.worktreePath,
+      model: this.config.model,
+      log: log2
+    });
+    const taskExecutor = new TaskExecutor({
+      aiRunner: taskAiRunner,
+      projectPath: result.worktreePath,
+      log: log2
+    });
+    return {
+      worktreePath: result.worktreePath,
+      baseBranch: result.baseBranch,
+      executor: taskExecutor
+    };
+  }
+  commitAndPushWorktree(worktreePath, task2, baseBranch) {
+    if (!this.worktreeManager) {
+      return { branch: null, pushed: false, pushFailed: false };
+    }
+    try {
+      const trailers = [
+        `Task-ID: ${task2.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): ${task2.title}
+
+${trailers.join(`
+`)}`;
+      const hash2 = this.worktreeManager.commitChanges(worktreePath, commitMessage, baseBranch);
+      if (!hash2) {
+        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(task2, 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: task2,
+        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(task2) {
+    const fullTask = await this.client.tasks.getById(task2.id, this.config.workspaceId);
+    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, baseBranch ?? undefined);
+        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(task2, success2) {
+    try {
+      if (success2) {
+        this.knowledgeBase.updateProgress({
+          type: "task_completed",
+          title: task2.title,
+          details: `Agent: ${this.config.agentId.slice(-8)}`
+        });
+        this.log(`Updated progress.md: ${task2.title}`, "info");
+      }
+    } catch (err) {
+      this.log(`Failed to update progress: ${err instanceof Error ? err.message : String(err)}`, "warn");
+    }
+  }
+  startHeartbeat() {
+    this.sendHeartbeat();
+    this.heartbeatInterval = setInterval(() => {
+      this.sendHeartbeat();
+    }, 60000);
+  }
+  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 sprint2 = await this.getActiveSprint();
+    if (sprint2) {
+      this.log(`Active sprint found: ${sprint2.name}`, "info");
+    } else {
+      this.log("No active sprint found.", "warn");
+    }
+    while (this.tasksCompleted < this.maxTasks) {
+      const task2 = await this.getNextTask();
+      if (!task2) {
+        this.log("No more tasks to process. Exiting.", "info");
+        break;
+      }
+      this.log(`Claimed: ${task2.title}`, "success");
+      this.currentTaskId = task2.id;
+      this.sendHeartbeat();
+      const result = await this.executeTask(task2);
+      if (result.success) {
+        if (result.noChanges) {
+          this.log(`Blocked: ${task2.title} - execution produced no file changes`, "warn");
+          await this.client.tasks.update(task2.id, this.config.workspaceId, {
+            status: "BLOCKED" /* BLOCKED */,
+            assignedTo: null
+          });
+          await this.client.tasks.addComment(task2.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: ${task2.title}`, "success");
+          const updatePayload = {
+            status: "IN_REVIEW" /* IN_REVIEW */
+          };
+          if (result.prUrl) {
+            updatePayload.prUrl = result.prUrl;
+          }
+          await this.client.tasks.update(task2.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(task2.id, this.config.workspaceId, {
+            author: this.config.agentId,
+            text: `✅ ${result.summary}${branchInfo}${prInfo}${prErrorInfo}`
+          });
+          this.tasksCompleted++;
+          this.updateProgress(task2, true);
+          if (result.prUrl) {
+            try {
+              this.knowledgeBase.updateProgress({
+                type: "pr_opened",
+                title: task2.title,
+                details: `PR: ${result.prUrl}`
+              });
+            } catch {}
+          }
+        }
+      } else {
+        this.log(`Failed: ${task2.title} - ${result.summary}`, "error");
+        await this.client.tasks.update(task2.id, this.config.workspaceId, {
+          status: "BACKLOG" /* BACKLOG */,
+          assignedTo: null
+        });
+        await this.client.tasks.addComment(task2.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 config2 = {};
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--agent-id")
+      config2.agentId = args[++i];
+    else if (arg === "--workspace-id")
+      config2.workspaceId = args[++i];
+    else if (arg === "--sprint-id")
+      config2.sprintId = args[++i];
+    else if (arg === "--api-url")
+      config2.apiBase = args[++i];
+    else if (arg === "--api-key")
+      config2.apiKey = args[++i];
+    else if (arg === "--project-path")
+      config2.projectPath = args[++i];
+    else if (arg === "--main-project-path")
+      config2.mainProjectPath = args[++i];
+    else if (arg === "--model")
+      config2.model = args[++i];
+    else if (arg === "--use-worktrees")
+      config2.useWorktrees = true;
+    else if (arg === "--auto-push")
+      config2.autoPush = true;
+    else if (arg === "--provider") {
+      const value = args[i + 1];
+      if (value && !value.startsWith("--"))
+        i++;
+      config2.provider = resolveProvider2(value);
+    }
+  }
+  if (!config2.agentId || !config2.workspaceId || !config2.apiBase || !config2.apiKey || !config2.projectPath) {
+    console.error("Missing required arguments");
+    process.exit(1);
+  }
+  const worker = new AgentWorker(config2);
+  worker.run().catch((err) => {
+    console.error("Fatal worker error:", err);
+    process.exit(1);
+  });
+}
+// ../sdk/src/exec/context-tracker.ts
+var REFERENCE_ALIASES = {
+  plan: ["the plan", "sprint plan", "project plan", "implementation plan"],
+  document: ["the doc", "that doc", "the document", "that document"],
+  code: ["the code", "that code", "the implementation"],
+  "task-list": ["the tasks", "the task list", "todo list", "todos"],
+  diagram: ["the diagram", "that diagram", "the chart"],
+  config: ["the config", "configuration", "settings"],
+  report: ["the report", "that report"]
+};
+function generateArtifactId() {
+  const timestamp2 = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 7);
+  return `artifact-${timestamp2}-${random}`;
+}
+function generateTaskId() {
+  const timestamp2 = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 7);
+  return `task-${timestamp2}-${random}`;
+}
+
+class ContextTracker {
+  artifacts = new Map;
+  tasks = new Map;
+  createArtifact(params) {
+    const now = Date.now();
+    const artifact = {
+      ...params,
+      id: generateArtifactId(),
+      createdAt: now,
+      updatedAt: now
+    };
+    this.artifacts.set(artifact.id, artifact);
+    return artifact;
+  }
+  trackArtifact(artifact) {
+    this.artifacts.set(artifact.id, artifact);
+  }
+  updateArtifact(id, updates) {
+    const artifact = this.artifacts.get(id);
+    if (!artifact) {
+      return null;
+    }
+    const updated = {
+      ...artifact,
+      ...updates,
+      updatedAt: Date.now()
+    };
+    this.artifacts.set(id, updated);
+    return updated;
+  }
+  getArtifact(id) {
+    return this.artifacts.get(id) ?? null;
+  }
+  getAllArtifacts() {
+    return Array.from(this.artifacts.values());
+  }
+  createTask(params) {
+    const now = Date.now();
+    const task2 = {
+      ...params,
+      id: generateTaskId(),
+      createdAt: now,
+      updatedAt: now
+    };
+    this.tasks.set(task2.id, task2);
+    return task2;
+  }
+  trackTask(task2) {
+    this.tasks.set(task2.id, task2);
+  }
+  updateTask(id, updates) {
+    const task2 = this.tasks.get(id);
+    if (!task2) {
+      return null;
+    }
+    const updated = {
+      ...task2,
+      ...updates,
+      updatedAt: Date.now()
+    };
+    this.tasks.set(id, updated);
+    return updated;
+  }
+  getTask(id) {
+    return this.tasks.get(id) ?? null;
+  }
+  getAllTasks() {
+    return Array.from(this.tasks.values());
+  }
+  getTasksByStatus(status) {
+    return Array.from(this.tasks.values()).filter((t) => t.status === status);
+  }
+  getReferencedArtifact(reference) {
+    const normalizedRef = reference.toLowerCase().trim();
+    const byId = this.artifacts.get(reference);
+    if (byId) {
+      return byId;
+    }
+    for (const artifact of this.artifacts.values()) {
+      if (artifact.title.toLowerCase().includes(normalizedRef)) {
+        return artifact;
+      }
+    }
+    for (const [type, aliases] of Object.entries(REFERENCE_ALIASES)) {
+      if (aliases.some((alias) => normalizedRef.includes(alias))) {
+        const ofType = Array.from(this.artifacts.values()).filter((a) => a.type === type).sort((a, b) => b.updatedAt - a.updatedAt);
+        if (ofType.length > 0) {
+          return ofType[0];
+        }
+      }
+    }
+    const keywords = normalizedRef.split(/\s+/).filter((w) => w.length > 2);
+    for (const artifact of this.artifacts.values()) {
+      const titleLower = artifact.title.toLowerCase();
+      if (keywords.some((kw) => titleLower.includes(kw))) {
+        return artifact;
+      }
+    }
+    return null;
+  }
+  getReferencedTask(reference) {
+    const normalizedRef = reference.toLowerCase().trim();
+    const byId = this.tasks.get(reference);
+    if (byId) {
+      return byId;
+    }
+    for (const task2 of this.tasks.values()) {
+      if (task2.title.toLowerCase().includes(normalizedRef)) {
+        return task2;
+      }
+    }
+    const keywords = normalizedRef.split(/\s+/).filter((w) => w.length > 2);
+    for (const task2 of this.tasks.values()) {
+      const titleLower = task2.title.toLowerCase();
+      if (keywords.some((kw) => titleLower.includes(kw))) {
+        return task2;
+      }
+    }
+    return null;
+  }
+  buildContextSummary() {
+    const artifacts = Array.from(this.artifacts.values());
+    const tasks2 = Array.from(this.tasks.values());
+    if (artifacts.length === 0 && tasks2.length === 0) {
+      return "";
+    }
+    const sections = [];
+    sections.push("## Active Context");
+    if (artifacts.length > 0) {
+      sections.push("");
+      sections.push("### Artifacts Created");
+      for (const artifact of artifacts) {
+        const filePath = artifact.filePath ? ` [${artifact.filePath}]` : "";
+        sections.push(`- ${artifact.title} (${artifact.type})${filePath}`);
+      }
+    }
+    if (tasks2.length > 0) {
+      sections.push("");
+      sections.push("### Tasks");
+      const byStatus = {
+        pending: [],
+        in_progress: [],
+        completed: [],
+        cancelled: []
+      };
+      for (const task2 of tasks2) {
+        byStatus[task2.status].push(task2);
+      }
+      const statusOrder = [
+        "in_progress",
+        "pending",
+        "completed",
+        "cancelled"
+      ];
+      for (const status of statusOrder) {
+        const statusTasks = byStatus[status];
+        if (statusTasks.length > 0) {
+          for (const task2 of statusTasks) {
+            const icon = this.getStatusIcon(task2.status);
+            sections.push(`- ${icon} ${task2.title}`);
+          }
+        }
+      }
+    }
+    return sections.join(`
+`);
+  }
+  getStatusIcon(status) {
+    switch (status) {
+      case "pending":
+        return "○";
+      case "in_progress":
+        return "◐";
+      case "completed":
+        return "●";
+      case "cancelled":
+        return "✕";
+    }
+  }
+  hasContent() {
+    return this.artifacts.size > 0 || this.tasks.size > 0;
+  }
+  clear() {
+    this.artifacts.clear();
+    this.tasks.clear();
+  }
+  toJSON() {
+    return {
+      artifacts: Array.from(this.artifacts.values()),
+      tasks: Array.from(this.tasks.values())
+    };
+  }
+  static fromJSON(state) {
+    const tracker = new ContextTracker;
+    for (const artifact of state.artifacts) {
+      tracker.artifacts.set(artifact.id, artifact);
+    }
+    for (const task2 of state.tasks) {
+      tracker.tasks.set(task2.id, task2);
+    }
+    return tracker;
+  }
+  restore(state) {
+    this.clear();
+    for (const artifact of state.artifacts) {
+      this.artifacts.set(artifact.id, artifact);
+    }
+    for (const task2 of state.tasks) {
+      this.tasks.set(task2.id, task2);
+    }
+  }
+}
+// ../sdk/src/exec/event-emitter.ts
+import { EventEmitter as EventEmitter3 } from "node:events";
+function generateSessionId() {
+  return `exec-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}
+
+class ExecEventEmitter {
+  emitter;
+  sessionId;
+  isSessionActive = false;
+  eventLog = [];
+  debugMode = false;
+  constructor(options) {
+    this.emitter = new EventEmitter3;
+    this.sessionId = generateSessionId();
+    this.debugMode = options?.debug ?? false;
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  isActive() {
+    return this.isSessionActive;
+  }
+  getEventLog() {
+    return [...this.eventLog];
+  }
+  clearEventLog() {
+    this.eventLog = [];
+  }
+  on(eventType, listener) {
+    this.emitter.on(eventType, listener);
+    return this;
+  }
+  once(eventType, listener) {
+    this.emitter.once(eventType, listener);
+    return this;
+  }
+  off(eventType, listener) {
+    this.emitter.off(eventType, listener);
+    return this;
+  }
+  removeAllListeners(eventType) {
+    if (eventType) {
+      this.emitter.removeAllListeners(eventType);
+    } else {
+      this.emitter.removeAllListeners();
+    }
+    return this;
+  }
+  emit(event) {
+    if (this.debugMode) {
+      this.eventLog.push(event);
+    }
+    this.emitter.emit(event.type, event);
+  }
+  createEventBase(type) {
+    return {
+      type,
+      timestamp: Date.now()
+    };
+  }
+  emitSessionStarted(options) {
+    this.isSessionActive = true;
+    this.emit({
+      ...this.createEventBase("session:started" /* SESSION_STARTED */),
+      data: {
+        sessionId: this.sessionId,
+        model: options?.model,
+        provider: options?.provider
+      }
+    });
+  }
+  emitPromptSubmitted(prompt, truncated = false) {
+    this.emit({
+      ...this.createEventBase("prompt:submitted" /* PROMPT_SUBMITTED */),
+      data: {
+        prompt: truncated ? `${prompt.substring(0, 500)}...` : prompt,
+        truncated
+      }
+    });
+  }
+  emitThinkingStarted(content) {
+    this.emit({
+      ...this.createEventBase("thinking:started" /* THINKING_STARTED */),
+      data: {
+        content
+      }
+    });
+  }
+  emitThinkingStoped() {
+    this.emit({
+      ...this.createEventBase("thinking:stopped" /* THINKING_STOPPED */),
+      data: {}
+    });
+  }
+  emitToolStarted(toolName, toolId) {
+    this.emit({
+      ...this.createEventBase("tool:started" /* TOOL_STARTED */),
+      data: {
+        toolName,
+        toolId
+      }
+    });
+  }
+  emitToolCompleted(toolName, toolId, result, duration3) {
+    this.emit({
+      ...this.createEventBase("tool:completed" /* TOOL_COMPLETED */),
+      data: {
+        toolName,
+        toolId,
+        result,
+        duration: duration3
+      }
+    });
+  }
+  emitToolFailed(toolName, error48, toolId) {
+    this.emit({
+      ...this.createEventBase("tool:failed" /* TOOL_FAILED */),
+      data: {
+        toolName,
+        toolId,
+        error: error48
+      }
+    });
+  }
+  emitTextDelta(content) {
+    this.emit({
+      ...this.createEventBase("text:delta" /* TEXT_DELTA */),
+      data: {
+        content
+      }
+    });
+  }
+  emitResponseCompleted(content) {
+    this.emit({
+      ...this.createEventBase("response:completed" /* RESPONSE_COMPLETED */),
+      data: {
+        content
+      }
+    });
+  }
+  emitErrorOccurred(error48, code) {
+    this.emit({
+      ...this.createEventBase("error:occurred" /* ERROR_OCCURRED */),
+      data: {
+        error: error48,
+        code
+      }
+    });
+  }
+  emitSessionEnded(success2) {
+    this.isSessionActive = false;
+    this.emit({
+      ...this.createEventBase("session:ended" /* SESSION_ENDED */),
+      data: {
+        sessionId: this.sessionId,
+        success: success2
+      }
+    });
+  }
+}
+// ../sdk/src/exec/history-manager.ts
+import {
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync3,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync4,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { join as join7 } from "node:path";
+var DEFAULT_MAX_SESSIONS = 30;
+function generateSessionId2() {
+  const timestamp2 = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 9);
+  return `session-${timestamp2}-${random}`;
+}
+
+class HistoryManager {
+  historyDir;
+  maxSessions;
+  constructor(projectPath, options) {
+    this.historyDir = options?.historyDir ?? join7(projectPath, LOCUS_CONFIG.dir, LOCUS_CONFIG.sessionsDir);
+    this.maxSessions = options?.maxSessions ?? DEFAULT_MAX_SESSIONS;
+    this.ensureHistoryDir();
+  }
+  ensureHistoryDir() {
+    if (!existsSync6(this.historyDir)) {
+      mkdirSync3(this.historyDir, { recursive: true });
+    }
+  }
+  getSessionPath(sessionId) {
+    return join7(this.historyDir, `${sessionId}.json`);
+  }
+  saveSession(session) {
+    const filePath = this.getSessionPath(session.id);
+    session.updatedAt = Date.now();
+    writeFileSync2(filePath, JSON.stringify(session, null, 2), "utf-8");
+  }
+  loadSession(sessionId) {
+    const filePath = this.getSessionPath(sessionId);
+    if (!existsSync6(filePath)) {
+      return null;
+    }
+    try {
+      const content = readFileSync4(filePath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  deleteSession(sessionId) {
+    const filePath = this.getSessionPath(sessionId);
+    if (!existsSync6(filePath)) {
+      return false;
+    }
+    try {
+      rmSync2(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  listSessions(options) {
+    const files = readdirSync2(this.historyDir);
+    let sessions = [];
+    for (const file2 of files) {
+      if (file2.endsWith(".json")) {
+        const session = this.loadSession(file2.replace(".json", ""));
+        if (session) {
+          sessions.push(session);
+        }
+      }
+    }
+    sessions.sort((a, b) => b.updatedAt - a.updatedAt);
+    if (options) {
+      sessions = this.filterSessions(sessions, options);
+    }
+    return sessions;
+  }
+  filterSessions(sessions, options) {
+    let filtered = sessions;
+    if (options.after !== undefined) {
+      const after = options.after;
+      filtered = filtered.filter((s) => s.createdAt >= after);
+    }
+    if (options.before !== undefined) {
+      const before = options.before;
+      filtered = filtered.filter((s) => s.createdAt <= before);
+    }
+    if (options.query) {
+      const query = options.query.toLowerCase();
+      filtered = filtered.filter((session) => session.messages.some((msg) => msg.content.toLowerCase().includes(query)));
+    }
+    const offset = options.offset ?? 0;
+    const limit = options.limit ?? filtered.length;
+    filtered = filtered.slice(offset, offset + limit);
+    return filtered;
+  }
+  searchSessions(query, limit) {
+    return this.listSessions({ query, limit });
+  }
+  getCurrentSession(model = "claude-sonnet-4-5", provider = "claude") {
+    const sessions = this.listSessions({ limit: 1 });
+    if (sessions.length > 0) {
+      return sessions[0];
+    }
+    return this.createNewSession(model, provider);
+  }
+  createNewSession(model = "claude-sonnet-4-5", provider = "claude") {
+    const now = Date.now();
+    return {
+      id: generateSessionId2(),
+      projectPath: this.historyDir.replace(`/${LOCUS_CONFIG.dir}/${LOCUS_CONFIG.sessionsDir}`, ""),
+      messages: [],
+      createdAt: now,
+      updatedAt: now,
+      metadata: {
+        model,
+        provider
+      }
+    };
+  }
+  pruneSessions() {
+    const sessions = this.listSessions();
+    let deleted = 0;
+    if (sessions.length > this.maxSessions) {
+      const sessionsToDelete = sessions.slice(this.maxSessions);
+      for (const session of sessionsToDelete) {
+        if (this.deleteSession(session.id)) {
+          deleted++;
+        }
+      }
+    }
+    return deleted;
+  }
+  getSessionCount() {
+    const files = readdirSync2(this.historyDir);
+    return files.filter((f) => f.endsWith(".json")).length;
+  }
+  sessionExists(sessionId) {
+    return existsSync6(this.getSessionPath(sessionId));
+  }
+  findSessionByPartialId(partialId) {
+    const sessions = this.listSessions();
+    const exact = sessions.find((s) => s.id === partialId);
+    if (exact)
+      return exact;
+    const partial2 = sessions.find((s) => s.id.includes(partialId) || s.id.startsWith(`session-${partialId}`));
+    return partial2 ?? null;
+  }
+  getHistoryDir() {
+    return this.historyDir;
+  }
+  clearAllSessions() {
+    const files = readdirSync2(this.historyDir);
+    let deleted = 0;
+    for (const file2 of files) {
+      if (file2.endsWith(".json")) {
+        try {
+          rmSync2(join7(this.historyDir, file2));
+          deleted++;
+        } catch {}
+      }
+    }
+    return deleted;
+  }
+}
+
+// ../sdk/src/exec/exec-session.ts
+var DEFAULT_MAX_CONTEXT_MESSAGES = 10;
+
+class ExecSession {
+  aiRunner;
+  history;
+  currentSession = null;
+  eventEmitter;
+  contextTracker;
+  maxContextMessages;
+  model;
+  provider;
+  sessionId;
+  toolStartTimes = new Map;
+  constructor(config2) {
+    this.aiRunner = config2.aiRunner;
+    this.history = new HistoryManager(config2.projectPath);
+    this.eventEmitter = new ExecEventEmitter({ debug: config2.debug });
+    this.contextTracker = new ContextTracker;
+    this.maxContextMessages = config2.maxContextMessages ?? DEFAULT_MAX_CONTEXT_MESSAGES;
+    this.model = config2.model;
+    this.provider = config2.provider;
+    this.sessionId = config2.sessionId;
+  }
+  initialize() {
+    if (this.sessionId) {
+      const loaded = this.history.loadSession(this.sessionId);
+      if (loaded) {
+        this.currentSession = loaded;
+        const metadata = loaded.metadata;
+        if (metadata.contextTracker) {
+          this.contextTracker.restore(metadata.contextTracker);
+        }
+      } else {
+        this.currentSession = this.history.createNewSession(this.model, this.provider);
+      }
+    } else {
+      this.currentSession = this.history.createNewSession(this.model, this.provider);
+    }
+    this.eventEmitter.emitSessionStarted({
+      model: this.model,
+      provider: this.provider
+    });
+  }
+  getSession() {
+    return this.currentSession;
+  }
+  getSessionId() {
+    return this.currentSession?.id ?? null;
+  }
+  getEventEmitter() {
+    return this.eventEmitter;
+  }
+  getHistoryManager() {
+    return this.history;
+  }
+  getContextTracker() {
+    return this.contextTracker;
+  }
+  createArtifact(params) {
+    return this.contextTracker.createArtifact(params);
+  }
+  createTask(params) {
+    return this.contextTracker.createTask(params);
+  }
+  resolveArtifactReference(reference) {
+    return this.contextTracker.getReferencedArtifact(reference);
+  }
+  resolveTaskReference(reference) {
+    return this.contextTracker.getReferencedTask(reference);
+  }
+  getMessages() {
+    return this.currentSession?.messages ?? [];
+  }
+  addMessage(message) {
+    if (!this.currentSession) {
+      throw new Error("Session not initialized. Call initialize() first.");
+    }
+    this.currentSession.messages.push({
+      ...message,
+      timestamp: Date.now()
+    });
+  }
+  async* executeStreaming(userPrompt) {
+    if (!this.currentSession) {
+      throw new Error("Session not initialized. Call initialize() first.");
+    }
+    const startTime = Date.now();
+    this.eventEmitter.emitPromptSubmitted(userPrompt, userPrompt.length > 500);
+    this.currentSession.messages.push({
+      role: "user",
+      content: userPrompt,
+      timestamp: Date.now()
+    });
+    const fullPrompt = this.buildPromptWithHistory(userPrompt);
+    const assistantMessage = {
+      role: "assistant",
+      content: "",
+      timestamp: Date.now(),
+      metadata: { toolsUsed: [], duration: 0 }
+    };
+    let hasError = false;
+    let errorMessage = "";
+    try {
+      const stream4 = this.aiRunner.runStream(fullPrompt);
+      for await (const chunk of stream4) {
+        switch (chunk.type) {
+          case "text_delta":
+            assistantMessage.content += chunk.content;
+            this.eventEmitter.emitTextDelta(chunk.content);
+            break;
+          case "tool_use": {
+            assistantMessage.metadata?.toolsUsed?.push(chunk.tool);
+            const toolKey = chunk.id ?? `${chunk.tool}-${Date.now()}`;
+            this.toolStartTimes.set(toolKey, Date.now());
+            this.eventEmitter.emitToolStarted(chunk.tool, chunk.id);
+            break;
+          }
+          case "thinking":
+            this.eventEmitter.emitThinkingStarted(chunk.content);
+            break;
+          case "tool_result": {
+            const resultKey = chunk.id ?? chunk.tool;
+            const startTime2 = this.toolStartTimes.get(resultKey);
+            const duration4 = startTime2 ? Date.now() - startTime2 : undefined;
+            if (chunk.success) {
+              this.eventEmitter.emitToolCompleted(chunk.tool, chunk.id, undefined, duration4);
+            } else {
+              this.eventEmitter.emitToolFailed(chunk.tool, chunk.error ?? "Unknown error", chunk.id);
+            }
+            if (resultKey) {
+              this.toolStartTimes.delete(resultKey);
+            }
+            break;
+          }
+          case "result":
+            this.eventEmitter.emitResponseCompleted(chunk.content);
+            break;
+          case "error":
+            hasError = true;
+            errorMessage = chunk.error;
+            this.eventEmitter.emitErrorOccurred(chunk.error);
+            break;
+        }
+        yield chunk;
+      }
+    } catch (error48) {
+      hasError = true;
+      errorMessage = error48 instanceof Error ? error48.message : String(error48);
+      this.eventEmitter.emitErrorOccurred(errorMessage);
+      yield {
+        type: "error",
+        error: errorMessage
+      };
+    }
+    const duration3 = Date.now() - startTime;
+    if (assistantMessage.metadata) {
+      assistantMessage.metadata.duration = duration3;
+    }
+    if (assistantMessage.content || hasError) {
+      if (hasError && !assistantMessage.content) {
+        assistantMessage.content = `Error: ${errorMessage}`;
+      }
+      this.currentSession.messages.push(assistantMessage);
+    }
+    this.currentSession.updatedAt = Date.now();
+  }
+  async execute(userPrompt) {
+    const chunks = [];
+    let content = "";
+    const toolsUsed = [];
+    const startTime = Date.now();
+    let hasError = false;
+    let errorMessage = "";
+    for await (const chunk of this.executeStreaming(userPrompt)) {
+      chunks.push(chunk);
+      if (chunk.type === "text_delta") {
+        content += chunk.content;
+      } else if (chunk.type === "tool_use") {
+        toolsUsed.push(chunk.tool);
+      } else if (chunk.type === "error") {
+        hasError = true;
+        errorMessage = chunk.error;
+      }
+    }
+    return {
+      content,
+      toolsUsed,
+      duration: Date.now() - startTime,
+      success: !hasError,
+      error: hasError ? errorMessage : undefined
+    };
+  }
+  buildPromptWithHistory(currentPrompt) {
+    const sections = [];
+    const contextSummary = this.contextTracker.buildContextSummary();
+    if (contextSummary) {
+      sections.push(contextSummary);
+    }
+    if (this.currentSession && this.currentSession.messages.length > 1) {
+      const recentMessages = this.currentSession.messages.slice(-(this.maxContextMessages + 1), -1).map((msg) => `${msg.role === "user" ? "User" : "Assistant"}: ${msg.content}`).join(`
+
+`);
+      if (recentMessages) {
+        sections.push(`## Conversation History
+${recentMessages}`);
+      }
+    }
+    if (sections.length === 0) {
+      return currentPrompt;
+    }
+    sections.push(`## Current Request
+${currentPrompt}`);
+    return sections.join(`
+
+`);
+  }
+  save() {
+    if (!this.currentSession) {
+      throw new Error("Session not initialized. Call initialize() first.");
+    }
+    if (this.contextTracker.hasContent()) {
+      this.currentSession.metadata.contextTracker = this.contextTracker.toJSON();
+    }
+    this.history.saveSession(this.currentSession);
+    this.history.pruneSessions();
+  }
+  reset() {
+    if (!this.currentSession) {
+      throw new Error("Session not initialized. Call initialize() first.");
+    }
+    this.currentSession.messages = [];
+    this.currentSession.updatedAt = Date.now();
+    this.contextTracker.clear();
+  }
+  startNewSession() {
+    this.currentSession = this.history.createNewSession(this.model, this.provider);
+    this.contextTracker.clear();
+    this.eventEmitter.emitSessionStarted({
+      model: this.model,
+      provider: this.provider
+    });
+  }
+  end(success2 = true) {
+    this.eventEmitter.emitSessionEnded(success2);
+  }
+  on(eventType, listener) {
+    this.eventEmitter.on(eventType, listener);
+    return this;
+  }
+  off(eventType, listener) {
+    this.eventEmitter.off(eventType, listener);
+    return this;
+  }
+}
+// ../sdk/src/orchestrator.ts
+import { spawn as spawn4 } from "node:child_process";
+import { existsSync as existsSync7 } from "node:fs";
+import { dirname as dirname2, join as join8 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { EventEmitter as EventEmitter4 } from "events";
+var MAX_AGENTS = 5;
+
+class AgentOrchestrator extends EventEmitter4 {
+  client;
+  config;
+  agents = new Map;
+  isRunning = false;
+  processedTasks = new Set;
+  resolvedSprintId = null;
+  worktreeManager = null;
+  heartbeatInterval = null;
+  constructor(config2) {
+    super();
+    this.config = config2;
+    this.client = new LocusClient({
+      baseUrl: config2.apiBase,
+      token: config2.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;
+    }
+    try {
+      const sprint2 = await this.client.sprints.getActive(this.config.workspaceId);
+      if (sprint2?.id) {
+        console.log(c.info(`\uD83D\uDCCB Using active sprint: ${sprint2.name}`));
+        return sprint2.id;
+      }
+    } catch {}
+    console.log(c.dim("ℹ  No sprint specified, working with all workspace tasks"));
+    return "";
+  }
+  async start() {
+    if (this.isRunning) {
+      throw new Error("Orchestrator is already running");
+    }
+    this.isRunning = true;
+    this.processedTasks.clear();
+    try {
+      await this.orchestrationLoop();
+    } catch (error48) {
+      this.emit("error", error48);
+      throw error48;
+    } finally {
+      await this.cleanup();
+    }
+  }
+  async orchestrationLoop() {
+    this.resolvedSprintId = await this.resolveSprintId();
+    this.emit("started", {
+      timestamp: new Date,
+      config: this.config,
+      sprintId: this.resolvedSprintId
+    });
+    console.log(`
+${c.primary("\uD83E\uDD16 Locus Agent Orchestrator")}`);
+    console.log(c.dim("----------------------------------------------"));
+    console.log(`${c.bold("Workspace:")} ${this.config.workspaceId}`);
+    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(`----------------------------------------------
+`));
+    const tasks2 = await this.getAvailableTasks();
+    if (tasks2.length === 0) {
+      console.log(c.dim("ℹ  No available tasks found in the backlog."));
+      return;
+    }
+    if (tasks2.length > 0 && this.useWorktrees && !isGitAvailable()) {
+      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) {
+      if (this.agents.size === 0) {
+        break;
+      }
+      await this.sleep(2000);
+    }
+    console.log(`
+${c.success("✅ Orchestrator finished")}`);
+  }
+  async spawnAgent(index) {
+    const agentId = `agent-${index}-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    const agentState = {
+      id: agentId,
+      status: "IDLE",
+      currentTaskId: null,
+      tasksCompleted: 0,
+      tasksFailed: 0,
+      lastHeartbeat: new Date
+    };
+    this.agents.set(agentId, agentState);
+    console.log(`${c.primary("\uD83D\uDE80 Agent started:")} ${c.bold(agentId)}
+`);
+    const workerPath = this.resolveWorkerPath();
+    if (!workerPath) {
+      throw new Error("Worker file not found. Make sure the SDK is properly built and installed.");
+    }
+    const workerArgs = [
+      "--agent-id",
+      agentId,
+      "--workspace-id",
+      this.config.workspaceId,
+      "--api-url",
+      this.config.apiBase,
+      "--api-key",
+      this.config.apiKey,
+      "--project-path",
+      this.config.projectPath
+    ];
+    if (this.config.model) {
+      workerArgs.push("--model", this.config.model);
+    }
+    if (this.config.provider) {
+      workerArgs.push("--provider", this.config.provider);
+    }
+    if (this.resolvedSprintId) {
+      workerArgs.push("--sprint-id", this.resolvedSprintId);
+    }
+    if (this.useWorktrees) {
+      workerArgs.push("--use-worktrees");
+    }
+    if (this.config.autoPush) {
+      workerArgs.push("--auto-push");
+    }
+    const agentProcess = spawn4(process.execPath, [workerPath, ...workerArgs], {
+      stdio: ["pipe", "pipe", "pipe"],
+      detached: true,
+      env: {
+        ...process.env,
+        FORCE_COLOR: "1",
+        TERM: "xterm-256color",
+        LOCUS_WORKER: agentId,
+        LOCUS_WORKSPACE: this.config.workspaceId
+      }
+    });
+    agentState.process = agentProcess;
+    agentProcess.on("message", (msg) => {
+      if (msg.type === "stats") {
+        agentState.tasksCompleted = msg.tasksCompleted || 0;
+        agentState.tasksFailed = msg.tasksFailed || 0;
+      }
+      if (msg.type === "heartbeat") {
+        agentState.lastHeartbeat = new Date;
+      }
+    });
+    agentProcess.stdout?.on("data", (data) => {
+      process.stdout.write(data.toString());
+    });
+    agentProcess.stderr?.on("data", (data) => {
+      process.stderr.write(data.toString());
+    });
+    agentProcess.on("exit", (code) => {
+      console.log(`
+${agentId} finished (exit code: ${code})`);
+      const agent2 = this.agents.get(agentId);
+      if (agent2) {
+        agent2.status = code === 0 ? "COMPLETED" : "FAILED";
+        this.emit("agent:completed", {
+          agentId,
+          status: agent2.status,
+          tasksCompleted: agent2.tasksCompleted,
+          tasksFailed: agent2.tasksFailed
+        });
+        this.agents.delete(agentId);
+      }
+    });
+    this.emit("agent:spawned", { agentId });
+  }
+  resolveWorkerPath() {
+    const currentModulePath = fileURLToPath(import.meta.url);
+    const currentModuleDir = dirname2(currentModulePath);
+    const potentialPaths = [
+      join8(currentModuleDir, "agent", "worker.js"),
+      join8(currentModuleDir, "worker.js"),
+      join8(currentModuleDir, "agent", "worker.ts")
+    ];
+    return potentialPaths.find((p) => existsSync7(p));
+  }
+  startHeartbeatMonitor() {
+    this.heartbeatInterval = setInterval(() => {
+      const now = Date.now();
+      for (const [agentId, agent2] of this.agents.entries()) {
+        if (agent2.status === "WORKING" && now - agent2.lastHeartbeat.getTime() > STALE_AGENT_TIMEOUT_MS) {
+          console.log(c.error(`Agent ${agentId} is stale (no heartbeat for 10 minutes). Killing.`));
+          if (agent2.process && !agent2.process.killed) {
+            this.killProcessTree(agent2.process);
+          }
+          this.emit("agent:stale", { agentId });
+        }
+      }
+    }, 60000);
+  }
+  async getAvailableTasks() {
+    try {
+      const tasks2 = await this.client.tasks.getAvailable(this.config.workspaceId, this.resolvedSprintId || undefined);
+      return tasks2.filter((task2) => !this.processedTasks.has(task2.id));
+    } catch (error48) {
+      this.emit("error", error48);
+      return [];
+    }
+  }
+  async assignTaskToAgent(agentId) {
+    const agent2 = this.agents.get(agentId);
+    if (!agent2)
+      return null;
+    try {
+      const tasks2 = await this.getAvailableTasks();
+      const priorityOrder = [
+        "CRITICAL" /* CRITICAL */,
+        "HIGH" /* HIGH */,
+        "MEDIUM" /* MEDIUM */,
+        "LOW" /* LOW */
+      ];
+      let task2 = tasks2.sort((a, b) => priorityOrder.indexOf(a.priority) - priorityOrder.indexOf(b.priority))[0];
+      if (!task2 && tasks2.length > 0) {
+        task2 = tasks2[0];
+      }
+      if (!task2)
+        return null;
+      agent2.currentTaskId = task2.id;
+      agent2.status = "WORKING";
+      this.emit("task:assigned", {
+        agentId,
+        taskId: task2.id,
+        title: task2.title
+      });
+      return task2;
+    } catch (error48) {
+      this.emit("error", error48);
+      return null;
+    }
+  }
+  async completeTask(taskId, agentId, summary) {
+    try {
+      await this.client.tasks.update(taskId, this.config.workspaceId, {
+        status: "IN_REVIEW" /* IN_REVIEW */
+      });
+      if (summary) {
+        await this.client.tasks.addComment(taskId, this.config.workspaceId, {
+          author: agentId,
+          text: `✅ Task completed
+
+${summary}`
+        });
+      }
+      this.processedTasks.add(taskId);
+      const agent2 = this.agents.get(agentId);
+      if (agent2) {
+        agent2.tasksCompleted += 1;
+        agent2.currentTaskId = null;
+        agent2.status = "IDLE";
+      }
+      this.emit("task:completed", { agentId, taskId });
+    } catch (error48) {
+      this.emit("error", error48);
+    }
+  }
+  async failTask(taskId, agentId, error48) {
+    try {
+      await this.client.tasks.update(taskId, this.config.workspaceId, {
+        status: "BACKLOG" /* BACKLOG */,
+        assignedTo: null
+      });
+      await this.client.tasks.addComment(taskId, this.config.workspaceId, {
+        author: agentId,
+        text: `❌ Agent failed: ${error48}`
+      });
+      const agent2 = this.agents.get(agentId);
+      if (agent2) {
+        agent2.tasksFailed += 1;
+        agent2.currentTaskId = null;
+        agent2.status = "IDLE";
+      }
+      this.emit("task:failed", { agentId, taskId, error: error48 });
+    } catch (error49) {
+      this.emit("error", error49);
+    }
+  }
+  async stop() {
+    this.isRunning = false;
+    await this.cleanup();
+    this.emit("stopped", { timestamp: new Date });
+  }
+  stopAgent(agentId) {
+    const agent2 = this.agents.get(agentId);
+    if (!agent2)
+      return false;
+    if (agent2.process && !agent2.process.killed) {
+      this.killProcessTree(agent2.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, agent2] of this.agents.entries()) {
+      if (agent2.process && !agent2.process.killed) {
+        console.log(`Killing agent: ${agentId}`);
+        this.killProcessTree(agent2.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();
+  }
+  getStats() {
+    return {
+      activeAgents: this.agents.size,
+      agentCount: this.agentCount,
+      useWorktrees: this.useWorktrees,
+      processedTasks: this.processedTasks.size,
+      totalTasksCompleted: Array.from(this.agents.values()).reduce((sum, agent2) => sum + agent2.tasksCompleted, 0),
+      totalTasksFailed: Array.from(this.agents.values()).reduce((sum, agent2) => sum + agent2.tasksFailed, 0)
+    };
+  }
+  getAgentStates() {
+    return Array.from(this.agents.values());
+  }
+  sleep(ms) {
+    return new Promise((resolve3) => setTimeout(resolve3, ms));
+  }
+}
+// src/commands/worktree.ts
+function createWorktreeManager(config2) {
+  return new WorktreeManager(config2.projectPath);
+}
+async function worktreesCommand(ctx, config2) {
+  console.log("[worktrees] Listing agent worktrees");
+  try {
+    const manager = createWorktreeManager(config2);
+    const worktrees = manager.listAgentWorktrees();
+    if (worktrees.length === 0) {
+      await ctx.reply(formatInfo("No agent worktrees found."), {
+        parse_mode: "HTML"
+      });
+      return;
+    }
+    let msg = `<b>Agent Worktrees (${worktrees.length})</b>
+
+`;
+    for (let i = 0;i < worktrees.length; i++) {
+      const wt = worktrees[i];
+      const status = wt.isPrunable ? " ⚠️ stale" : "";
+      msg += `<b>${i + 1}.</b> <code>${escapeHtml(wt.branch)}</code>${status}
+`;
+      msg += `   HEAD: <code>${wt.head.slice(0, 8)}</code>
+`;
+      msg += `   Path: <code>${escapeHtml(wt.path)}</code>
+
+`;
+    }
+    msg += `Use /worktree &lt;number&gt; to view details
+`;
+    msg += "Use /rmworktree &lt;number|all&gt; to remove";
+    await ctx.reply(msg, { parse_mode: "HTML" });
+  } catch (err) {
+    console.error("[worktrees] Failed:", err);
+    await ctx.reply(formatError(`Failed to list worktrees: ${err instanceof Error ? err.message : String(err)}`), { parse_mode: "HTML" });
+  }
+}
+async function worktreeCommand(ctx, config2) {
+  const text = (ctx.message && "text" in ctx.message ? ctx.message.text : "") || "";
+  const arg = text.replace(/^\/worktree\s*/, "").trim();
+  console.log(`[worktree] Select: ${arg || "(empty)"}`);
+  if (!arg) {
+    await ctx.reply(formatError(`Usage: /worktree &lt;number&gt;
+Run /worktrees to see the list.`), { parse_mode: "HTML" });
+    return;
+  }
+  const index = Number.parseInt(arg, 10);
+  if (Number.isNaN(index) || index < 1) {
+    await ctx.reply(formatError("Please provide a valid worktree number."), {
+      parse_mode: "HTML"
+    });
+    return;
+  }
+  try {
+    const manager = createWorktreeManager(config2);
+    const worktrees = manager.listAgentWorktrees();
+    if (index > worktrees.length) {
+      await ctx.reply(formatError(`Worktree #${index} does not exist. There are ${worktrees.length} worktree(s).`), { parse_mode: "HTML" });
+      return;
+    }
+    const wt = worktrees[index - 1];
+    const hasChanges = !wt.isPrunable && manager.hasChanges(wt.path);
+    let msg = `<b>Worktree #${index}</b>
+
+`;
+    msg += `<b>Branch:</b> <code>${escapeHtml(wt.branch)}</code>
+`;
+    msg += `<b>HEAD:</b> <code>${wt.head}</code>
+`;
+    msg += `<b>Path:</b> <code>${escapeHtml(wt.path)}</code>
+`;
+    msg += `<b>Status:</b> ${wt.isPrunable ? "⚠️ stale (directory missing)" : hasChanges ? "\uD83D\uDCDD has uncommitted changes" : "✅ clean"}
+`;
+    await ctx.reply(msg, { parse_mode: "HTML" });
+  } catch (err) {
+    console.error("[worktree] Failed:", err);
+    await ctx.reply(formatError(`Failed to get worktree details: ${err instanceof Error ? err.message : String(err)}`), { parse_mode: "HTML" });
+  }
+}
+async function rmworktreeCommand(ctx, config2) {
+  const text = (ctx.message && "text" in ctx.message ? ctx.message.text : "") || "";
+  const arg = text.replace(/^\/rmworktree\s*/, "").trim();
+  console.log(`[rmworktree] Remove: ${arg || "(empty)"}`);
+  if (!arg) {
+    await ctx.reply(formatError(`Usage: /rmworktree &lt;number|all&gt;
+Run /worktrees to see the list.`), { parse_mode: "HTML" });
+    return;
+  }
+  try {
+    const manager = createWorktreeManager(config2);
+    if (arg === "all") {
+      const count = manager.removeAll();
+      await ctx.reply(formatSuccess(`Removed ${count} worktree(s).`), { parse_mode: "HTML" });
+      return;
+    }
+    const index = Number.parseInt(arg, 10);
+    if (Number.isNaN(index) || index < 1) {
+      await ctx.reply(formatError("Please provide a valid worktree number or 'all'."), { parse_mode: "HTML" });
+      return;
+    }
+    const worktrees = manager.listAgentWorktrees();
+    if (index > worktrees.length) {
+      await ctx.reply(formatError(`Worktree #${index} does not exist. There are ${worktrees.length} worktree(s).`), { parse_mode: "HTML" });
+      return;
+    }
+    const wt = worktrees[index - 1];
+    manager.remove(wt.path, true);
+    await ctx.reply(formatSuccess(`Removed worktree #${index} (${wt.branch}) and its branch.`), { parse_mode: "HTML" });
+  } catch (err) {
+    console.error("[rmworktree] Failed:", err);
+    await ctx.reply(formatError(`Failed to remove worktree: ${err instanceof Error ? err.message : String(err)}`), { parse_mode: "HTML" });
+  }
+}
+// src/executor.ts
+import { spawn as spawn5 } from "node:child_process";
+import { join as join9 } from "node:path";
 function timestamp2() {
   return new Date().toLocaleTimeString("en-GB", { hour12: false });
 }
@@ -38541,7 +42446,7 @@ class CliExecutor {
   }
   resolveCommand(args) {
     if (this.config.testMode) {
-      const cliPath = join2(this.config.projectPath, "packages/cli/src/cli.ts");
+      const cliPath = join9(this.config.projectPath, "packages/cli/src/cli.ts");
       return { cmd: "bun", cmdArgs: ["run", cliPath, ...args] };
     }
     return { cmd: "locus", cmdArgs: args };
@@ -38553,8 +42458,8 @@ class CliExecutor {
     const fullCommand = `${cmd} ${cmdArgs.join(" ")}`;
     const startTime = Date.now();
     log2(id, `Process started: ${fullCommand}`);
-    return new Promise((resolve) => {
-      const proc = spawn2(cmd, cmdArgs, {
+    return new Promise((resolve3) => {
+      const proc = spawn5(cmd, cmdArgs, {
         cwd: this.config.projectPath,
         env: buildSpawnEnv(),
         stdio: ["pipe", "pipe", "pipe"]
@@ -38582,13 +42487,13 @@ class CliExecutor {
         this.runningProcesses.delete(id);
         const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
         log2(id, `Process exited (code: ${exitCode}, ${elapsed}s)${killed ? " [killed]" : ""}`);
-        resolve({ stdout, stderr, exitCode, killed });
+        resolve3({ stdout, stderr, exitCode, killed });
       });
       proc.on("error", (err) => {
         clearTimeout(timer);
         this.runningProcesses.delete(id);
         log2(id, `Process error: ${err.message}`);
-        resolve({
+        resolve3({
           stdout,
           stderr: stderr || err.message,
           exitCode: 1,
@@ -38604,7 +42509,7 @@ class CliExecutor {
     const fullCommand = `${cmd} ${cmdArgs.join(" ")}`;
     const startTime = Date.now();
     log2(id, `Process started (streaming): ${fullCommand}`);
-    const proc = spawn2(cmd, cmdArgs, {
+    const proc = spawn5(cmd, cmdArgs, {
       cwd: this.config.projectPath,
       env: buildSpawnEnv(),
       stdio: ["pipe", "pipe", "pipe"]
@@ -38631,19 +42536,19 @@ class CliExecutor {
       killed = true;
       proc.kill("SIGTERM");
     }, timeout);
-    const done = new Promise((resolve) => {
+    const done = new Promise((resolve3) => {
       proc.on("close", (exitCode) => {
         clearTimeout(timer);
         this.runningProcesses.delete(id);
         const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
         log2(id, `Process exited (code: ${exitCode}, ${elapsed}s)${killed ? " [killed]" : ""}`);
-        resolve({ stdout, stderr, exitCode, killed });
+        resolve3({ stdout, stderr, exitCode, killed });
       });
       proc.on("error", (err) => {
         clearTimeout(timer);
         this.runningProcesses.delete(id);
         log2(id, `Process error: ${err.message}`);
-        resolve({
+        resolve3({
           stdout,
           stderr: stderr || err.message,
           exitCode: 1,
@@ -38736,22 +42641,25 @@ function createBot(config2) {
   bot.command("dev", (ctx) => devCommand(ctx, config2));
   bot.command("status", (ctx) => statusCommand(ctx, executor));
   bot.command("agents", (ctx) => agentsCommand(ctx, executor));
+  bot.command("worktrees", (ctx) => worktreesCommand(ctx, config2));
+  bot.command("worktree", (ctx) => worktreeCommand(ctx, config2));
+  bot.command("rmworktree", (ctx) => rmworktreeCommand(ctx, config2));
   return bot;
 }
 
 // src/config.ts
 var import_dotenv = __toESM(require_main(), 1);
-import { existsSync, readFileSync } from "node:fs";
-import { join as join3 } from "node:path";
+import { existsSync as existsSync8, readFileSync as readFileSync5 } from "node:fs";
+import { join as join10 } from "node:path";
 import_dotenv.default.config();
 var SETTINGS_FILE = "settings.json";
 var CONFIG_DIR = ".locus";
 function loadSettings(projectPath) {
-  const settingsPath = join3(projectPath, CONFIG_DIR, SETTINGS_FILE);
-  if (!existsSync(settingsPath)) {
+  const settingsPath = join10(projectPath, CONFIG_DIR, SETTINGS_FILE);
+  if (!existsSync8(settingsPath)) {
     return null;
   }
-  const raw = readFileSync(settingsPath, "utf-8");
+  const raw = readFileSync5(settingsPath, "utf-8");
   return JSON.parse(raw);
 }
 function resolveConfig() {