omnara 0.1.9 → 0.1.11

package/dist/cli.js

@@ -5,7 +5,7 @@ const __filename = __omnaraFileURLToPath(import.meta.url);
 const __dirname = pathShim.dirname(__filename);
 
 // src/cli.ts
-import path6 from "path";
+import path7 from "path";
 import { createRequire as createRequire2 } from "node:module";
 import { Command as Command3 } from "commander";
 
@@ -51,13 +51,15 @@ var BASE_ALLOWED_WORKER_TOOLS = [
 ];
 var AIClient = class {
   baseOptions;
+  runningQuery;
   constructor(config) {
     const defaultOptions = {
       maxTurns: 100,
       model: "sonnet",
       cwd: process.cwd(),
       includePartialMessages: false,
-      allowedTools: [...BASE_ALLOWED_ORCHESTRATOR_TOOLS]
+      allowedTools: [...BASE_ALLOWED_ORCHESTRATOR_TOOLS],
+      settingSources: ["user", "project", "local"]
     };
     this.baseOptions = {
       ...defaultOptions,
@@ -70,9 +72,11 @@ var AIClient = class {
   }
   async *streamUserMessage(prompt2, overrides) {
     const q = this.createQuery(prompt2, overrides);
+    this.runningQuery = q;
     for await (const message of q) {
       yield message;
     }
+    this.runningQuery = void 0;
   }
   createQuery(prompt2, overrides) {
     const merged = {
@@ -85,6 +89,9 @@ var AIClient = class {
       options: merged
     });
   }
+  async cancel() {
+    await this.runningQuery?.interrupt();
+  }
   ensureWorkingDirectory(cwd) {
     if (!cwd) {
       return;
@@ -433,6 +440,7 @@ function extractUserContent(content) {
 // src/orchestrator/worker-manager.ts
 import { EventEmitter } from "events";
 import { randomUUID as randomUUID2 } from "crypto";
+import { simpleGit as simpleGit2 } from "simple-git";
 
 // src/orchestrator/tools/worker-status-tool.ts
 import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
@@ -861,9 +869,16 @@ var WorktreeManager = class {
   worktreeBasePath;
   activeWorktrees;
   enabled;
+  base_ref;
+  // Queue mechanism for sequential worktree creation
+  creationQueue = [];
+  isProcessingQueue = false;
+  // Map to track worktrees by name (not workerId) to enable reuse
+  worktreesByName = /* @__PURE__ */ new Map();
   constructor(options) {
     this.repoPath = options.repoPath;
     this.enabled = options.enabled ?? false;
+    this.base_ref = options.base_ref;
     const repoName = path4.basename(this.repoPath);
     this.worktreeBasePath = options.worktreeBasePath || path4.join(DEFAULT_DIR, "worktrees", repoName);
     this.git = simpleGit(this.repoPath);
@@ -872,6 +887,33 @@ var WorktreeManager = class {
       this.validateGitRepository();
     }
   }
+  /**
+   * Find a valid base ref to use when creating new branches
+   * Tries in order: configured base_ref, main, master, origin/HEAD
+   * @returns The first valid ref found, or undefined if none exist
+   */
+  async findValidBaseRef() {
+    if (this.base_ref) {
+      try {
+        await this.git.raw(["rev-parse", "--verify", this.base_ref]);
+        logger.info(`Using configured base_ref: ${this.base_ref}`);
+        return this.base_ref;
+      } catch {
+        logger.warn(`Configured base_ref "${this.base_ref}" does not exist, trying fallbacks`);
+      }
+    }
+    const fallbackRefs = ["main", "master", "origin/HEAD"];
+    for (const ref of fallbackRefs) {
+      try {
+        await this.git.raw(["rev-parse", "--verify", ref]);
+        logger.info(`Using fallback base_ref: ${ref}`);
+        return ref;
+      } catch {
+      }
+    }
+    logger.warn("No valid base ref found (tried: configured base_ref, main, master, origin/HEAD)");
+    return void 0;
+  }
   /**
    * Validate that the repoPath is a git repository
    * Logs an error if worktrees are enabled but not in a git repository
@@ -899,6 +941,10 @@ var WorktreeManager = class {
   /**
    * Creates a new worktree for the specified worker
    *
+   * This method uses a sequential queue to ensure that worktree creation
+   * happens one at a time, eliminating race conditions when multiple workers
+   * request the same worktree simultaneously.
+   *
    * @param workerId - Unique identifier for the worker
    * @param worktreeName - Semantic name for the worktree (e.g., "main-feature", "bugfix-auth")
    * @returns Information about the created worktree
@@ -912,15 +958,81 @@ var WorktreeManager = class {
         "create"
       );
     }
-    logger.info(`Creating worktree "${worktreeName}" for worker ${workerId}`);
+    if (this.activeWorktrees.has(workerId)) {
+      throw new WorktreeError(`Worktree already exists for worker ${workerId}`, workerId, "create");
+    }
+    return new Promise((resolve, reject) => {
+      this.creationQueue.push({
+        workerId,
+        worktreeName,
+        resolve,
+        reject
+      });
+      logger.info(
+        `Queued worktree creation for "${worktreeName}" (worker: ${workerId}). Queue size: ${this.creationQueue.length}`
+      );
+      if (!this.isProcessingQueue) {
+        this.processCreationQueue();
+      }
+    });
+  }
+  /**
+   * Processes the creation queue sequentially
+   * Ensures only one worktree creation happens at a time
+   */
+  async processCreationQueue() {
+    if (this.isProcessingQueue) {
+      return;
+    }
+    this.isProcessingQueue = true;
     try {
-      if (this.activeWorktrees.has(workerId)) {
-        throw new WorktreeError(
-          `Worktree already exists for worker ${workerId}`,
-          workerId,
-          "create"
-        );
+      while (this.creationQueue.length > 0) {
+        const request = this.creationQueue.shift();
+        try {
+          const existingWorktree = this.worktreesByName.get(request.worktreeName);
+          if (existingWorktree) {
+            logger.info(
+              `Worker ${request.workerId} reusing existing worktree "${request.worktreeName}" at ${existingWorktree.worktreePath}`
+            );
+            const info = {
+              workerId: request.workerId,
+              worktreeName: request.worktreeName,
+              worktreePath: existingWorktree.worktreePath,
+              branchName: existingWorktree.branchName,
+              createdAt: /* @__PURE__ */ new Date()
+            };
+            this.activeWorktrees.set(request.workerId, info);
+            request.resolve(info);
+          } else {
+            const info = await this.doCreateWorktree(request.workerId, request.worktreeName);
+            request.resolve(info);
+          }
+        } catch (error) {
+          logger.error(
+            `Failed to process worktree creation for worker ${request.workerId}:`,
+            error
+          );
+          request.reject(
+            error instanceof WorktreeError ? error : new WorktreeError(
+              `Failed to create worktree: ${error instanceof Error ? error.message : String(error)}`,
+              request.workerId,
+              "create",
+              error instanceof Error ? error : void 0
+            )
+          );
+        }
       }
+    } finally {
+      this.isProcessingQueue = false;
+    }
+  }
+  /**
+   * Internal method that performs the actual worktree creation
+   * This should only be called by processCreationQueue
+   */
+  async doCreateWorktree(workerId, worktreeName) {
+    logger.info(`Creating worktree "${worktreeName}" for worker ${workerId}`);
+    try {
       await fs4.mkdir(this.worktreeBasePath, { recursive: true });
       const branchName = `${worktreeName}`;
       const worktreePath = path4.join(this.worktreeBasePath, worktreeName);
@@ -948,6 +1060,7 @@ var WorktreeManager = class {
           createdAt: /* @__PURE__ */ new Date()
         };
         this.activeWorktrees.set(workerId, info2);
+        this.worktreesByName.set(worktreeName, info2);
         return info2;
       }
       if (worktreeDirExists && !worktreeRegistered) {
@@ -963,10 +1076,18 @@ var WorktreeManager = class {
         );
         await this.git.raw(["worktree", "add", worktreePath, branchName]);
       } else if (!branchExists && !worktreeRegistered) {
-        logger.info(
-          `Creating new worktree "${worktreeName}" at ${worktreePath} with new branch ${branchName}`
-        );
-        await this.git.raw(["worktree", "add", "-b", branchName, worktreePath]);
+        const baseRef = await this.findValidBaseRef();
+        if (baseRef) {
+          logger.info(
+            `Creating new worktree "${worktreeName}" at ${worktreePath} with new branch ${branchName} from base ref ${baseRef}`
+          );
+          await this.git.raw(["worktree", "add", "-b", branchName, worktreePath, baseRef]);
+        } else {
+          logger.info(
+            `Creating new worktree "${worktreeName}" at ${worktreePath} with new branch ${branchName} (no base ref specified)`
+          );
+          await this.git.raw(["worktree", "add", "-b", branchName, worktreePath]);
+        }
       }
       const info = {
         workerId,
@@ -976,6 +1097,7 @@ var WorktreeManager = class {
         createdAt: /* @__PURE__ */ new Date()
       };
       this.activeWorktrees.set(workerId, info);
+      this.worktreesByName.set(worktreeName, info);
       logger.info(`Worktree "${worktreeName}" ready at ${worktreePath} on branch ${branchName}`);
       return info;
     } catch (error) {
@@ -1006,30 +1128,42 @@ var WorktreeManager = class {
       return;
     }
     try {
-      const args = ["worktree", "remove", info.worktreePath];
-      if (force) {
-        args.push("--force");
-      }
-      try {
-        await this.git.raw(args);
-      } catch (worktreeError) {
-        const errorMessage = worktreeError instanceof Error ? worktreeError.message : String(worktreeError);
-        if (errorMessage.includes("is not a working tree") || errorMessage.includes("does not exist")) {
-          logger.warn(
-            `Worktree ${info.worktreePath} doesn't exist, may have been manually removed. Cleaning up...`
-          );
-          await this.git.raw(["worktree", "prune"]);
-          try {
-            await fs4.rm(info.worktreePath, { recursive: true, force: true });
-            logger.info(`Manually removed stale worktree directory: ${info.worktreePath}`);
-          } catch {
+      const otherWorkersUsingWorktree = Array.from(this.activeWorktrees.values()).filter(
+        (wt) => wt.worktreeName === info.worktreeName && wt.workerId !== workerId
+      );
+      const shouldRemoveWorktree = otherWorkersUsingWorktree.length === 0;
+      if (shouldRemoveWorktree) {
+        const args = ["worktree", "remove", info.worktreePath];
+        if (force) {
+          args.push("--force");
+        }
+        try {
+          await this.git.raw(args);
+          logger.info(`Removed worktree "${info.worktreeName}" at ${info.worktreePath}`);
+        } catch (worktreeError) {
+          const errorMessage = worktreeError instanceof Error ? worktreeError.message : String(worktreeError);
+          if (errorMessage.includes("is not a working tree") || errorMessage.includes("does not exist")) {
+            logger.warn(
+              `Worktree ${info.worktreePath} doesn't exist, may have been manually removed. Cleaning up...`
+            );
+            await this.git.raw(["worktree", "prune"]);
+            try {
+              await fs4.rm(info.worktreePath, { recursive: true, force: true });
+              logger.info(`Manually removed stale worktree directory: ${info.worktreePath}`);
+            } catch {
+            }
+          } else {
+            throw worktreeError;
           }
-        } else {
-          throw worktreeError;
         }
+        this.worktreesByName.delete(info.worktreeName);
+      } else {
+        logger.info(
+          `Not removing worktree "${info.worktreeName}" - still in use by ${otherWorkersUsingWorktree.length} other worker(s)`
+        );
       }
       this.activeWorktrees.delete(workerId);
-      logger.info(`Removed worktree for worker ${workerId}`);
+      logger.info(`Removed worktree reference for worker ${workerId}`);
     } catch (error) {
       logger.error(`Failed to remove worktree for worker ${workerId}:`, error);
       throw new WorktreeError(
@@ -1108,41 +1242,6 @@ var WorktreeManager = class {
   }
 };
 
-// src/config/omnara-config.ts
-import { parse as parseJsonc } from "jsonc-parser";
-import * as fs5 from "fs/promises";
-import * as path5 from "path";
-import * as z2 from "zod";
-var OmnaraConfig = z2.object({
-  worktrees: z2.object({
-    enabled: z2.boolean().default(false)
-  }).default({
-    enabled: false
-  })
-});
-async function readOmnaraConfig(configPath) {
-  const resolveConfig = async (path7) => {
-    if (!path7) {
-      return null;
-    }
-    await fs5.access(path7);
-    const content = await fs5.readFile(path7, "utf-8");
-    const errors = [];
-    const config = parseJsonc(content, errors, {
-      allowTrailingComma: true,
-      allowEmptyContent: true
-    });
-    return OmnaraConfig.parse(config);
-  };
-  const resolveDefault = () => {
-    return OmnaraConfig.parse(void 0);
-  };
-  return await resolveConfig(configPath).catch(() => null) ?? await resolveConfig(path5.join(process.cwd(), "omnara.jsonc")).catch(() => null) ?? await resolveConfig(path5.join(process.cwd(), "omnara.json")).catch(() => null) ?? await resolveDefault();
-}
-function isWorktreesEnabled(config) {
-  return config.worktrees.enabled;
-}
-
 // src/orchestrator/worker-manager.ts
 var WorkerManager = class extends EventEmitter {
   constructor(options) {
@@ -1150,37 +1249,16 @@ var WorkerManager = class extends EventEmitter {
     this.options = options;
     this.worktreeManager = new WorktreeManager({
       repoPath: options.repoPath,
-      enabled: false
+      enabled: options.worktreesEnabled,
+      base_ref: options.worktreesBaseRef
     });
-    this.initializeConfig();
+    logger.info(
+      `WorkerManager initialized with worktrees ${options.worktreesEnabled ? "enabled" : "disabled"}`
+    );
   }
   workers = /* @__PURE__ */ new Map();
   runningQueries = /* @__PURE__ */ new Map();
   worktreeManager;
-  configInitialized = false;
-  /**
-   * Initialize the configuration and update WorktreeManager accordingly
-   */
-  async initializeConfig() {
-    try {
-      const config = await readOmnaraConfig();
-      const worktreesEnabled = isWorktreesEnabled(config);
-      if (worktreesEnabled) {
-        logger.info("Worktrees enabled via omnara.jsonc configuration");
-      } else {
-        logger.info("Worktrees disabled (no worktrees config found in omnara.jsonc)");
-      }
-      this.worktreeManager = new WorktreeManager({
-        repoPath: this.options.repoPath,
-        enabled: worktreesEnabled
-      });
-      this.configInitialized = true;
-    } catch (err) {
-      logger.error("Failed to read omnara.jsonc configuration:", err);
-      logger.info("Worktrees disabled due to config read error");
-      this.configInitialized = true;
-    }
-  }
   listWorkers() {
     return Array.from(this.workers.values());
   }
@@ -1333,9 +1411,9 @@ var WorkerManager = class extends EventEmitter {
       success: false,
       text: "Worker canceled by user request."
     });
-    const query2 = this.runningQueries.get(id);
-    if (query2) {
-      void query2.interrupt().catch(() => {
+    const query3 = this.runningQueries.get(id);
+    if (query3) {
+      void query3.interrupt().catch(() => {
       });
     }
     record.messageQueue.close();
@@ -1385,10 +1463,10 @@ var WorkerManager = class extends EventEmitter {
     });
     record.lastUpdateAt = Date.now();
     if (interrupt) {
-      const query2 = this.runningQueries.get(record.id);
-      if (query2) {
+      const query3 = this.runningQueries.get(record.id);
+      if (query3) {
         try {
-          await query2.interrupt();
+          await query3.interrupt();
         } catch (error) {
           console.error("[WorkerManager] Failed to interrupt worker:", error);
         }
@@ -1502,7 +1580,7 @@ var WorkerManager = class extends EventEmitter {
       record.sessionId,
       record.messageQueue
     );
-    const query2 = client.createQuery(messageStream, {
+    const query3 = client.createQuery(messageStream, {
       hooks: {
         PostToolUse: [
           {
@@ -1543,13 +1621,37 @@ var WorkerManager = class extends EventEmitter {
         ]
       }
     });
-    this.runningQueries.set(record.id, query2);
+    this.runningQueries.set(record.id, query3);
     const summarizedChunks = [];
     try {
-      for await (const message of query2) {
+      for await (const message of query3) {
         this.handleMessage(record, message, summarizedChunks);
       }
       if (record.status === "running") {
+        if (record.worktreePath) {
+          try {
+            logger.info(
+              `Auto-committing changes for worker ${record.id} in worktree ${record.worktreePath}`
+            );
+            const worktreeGit = simpleGit2(record.worktreePath);
+            await worktreeGit.add("-A");
+            const commitMessage = `Worker task: ${record.task}
+
+Automatically committed changes from worker completion.`;
+            await worktreeGit.commit(commitMessage);
+            logger.info(`Successfully auto-committed changes for worker ${record.id}`);
+            record.progress.push({
+              timestamp: Date.now(),
+              message: "Auto-committed all changes to git"
+            });
+          } catch (commitError) {
+            logger.error(`Failed to auto-commit changes for worker ${record.id}:`, commitError);
+            record.progress.push({
+              timestamp: Date.now(),
+              message: `Failed to auto-commit changes: ${commitError instanceof Error ? commitError.message : String(commitError)}`
+            });
+          }
+        }
         record.status = "completed";
         record.result = summarizedChunks.join("\n").trim() || "Worker completed without additional details.";
         record.lastUpdateAt = Date.now();
@@ -1731,12 +1833,7 @@ WORKTREE ISOLATION:
 - All your file operations, git commands, and changes are isolated to this worktree.
 - Other workers cannot see your changes and you cannot see theirs.
 - When you're done, your worktree will be automatically cleaned up.
-
-COMMIT YOUR CHANGES:
-- Before completing your task, commit your changes using git.
-- Use a descriptive commit message that explains what you did.
-- Your commits will stay on your isolated branch and can be reviewed before merging.
-- This ensures your work is preserved even if cleanup happens unexpectedly.
+- Your changes will be automatically committed when you complete your task. Focus on making your changes and reporting your results.
 `;
     }
     return `${userPrompt.trim()}
@@ -1766,7 +1863,7 @@ ${directive}`;
 
 // src/orchestrator/tools/worker-tools.ts
 import { createSdkMcpServer as createSdkMcpServer2, tool as tool2 } from "@anthropic-ai/claude-agent-sdk";
-import { z as z3 } from "zod";
+import { z as z2 } from "zod";
 function createWorkerMcpServer(workerManager, context) {
   return createSdkMcpServer2({
     name: "worker",
@@ -1796,14 +1893,14 @@ Usage notes:
 - The worker's result is returned to you, not the user - you must summarize or forward relevant information
 - Worker progress status is automatically included in your context - you can see their current state without additional tools`,
         {
-          task: z3.string().min(1, "task name is required").describe(
+          task: z2.string().min(1, "task name is required").describe(
             'A short, unique name for this task (e.g., "FizzBuzz Python", "Search codebase", "Fix bug #123"). Used to identify and track this worker.'
           ),
-          prompt: z3.string().min(1, "prompt is required"),
-          worktree_name: z3.string().min(1, "worktree_name is required").describe(
+          prompt: z2.string().min(1, "prompt is required"),
+          worktree_name: z2.string().min(1, "worktree_name is required").describe(
             "A short descriptive name for a worktree to create that can be used by workers simultaneously. This is synonymous with branch."
           ),
-          metadata: z3.record(z3.any()).optional()
+          metadata: z2.record(z2.any()).optional()
         },
         async (args, extra) => {
           const typedExtra = extra;
@@ -1901,11 +1998,11 @@ Orchestrator: [launches worker: "refactor database"]
 User: "Wait, actually don't touch the database - just refactor the API layer instead"
 Orchestrator: [message_worker: task="refactor database", message="User wants to change scope - refactor API layer instead, leave database alone", interrupt=true]`,
         {
-          task: z3.string().min(1, "task name is required").describe("The task name of the worker to message"),
-          message: z3.string().min(1, "message is required").describe(
+          task: z2.string().min(1, "task name is required").describe("The task name of the worker to message"),
+          message: z2.string().min(1, "message is required").describe(
             "The message to send to the worker. Be clear and specific about what has changed or what additional context is being provided."
           ),
-          interrupt: z3.boolean().default(false).describe(
+          interrupt: z2.boolean().default(false).describe(
             "If true, interrupt current generation immediately; if false (default), queue message for next turn"
           )
         },
@@ -1976,11 +2073,234 @@ import { readFileSync } from "fs";
 var orchestratorPromptUrl = new URL("./orchestrator-prompt.md", import.meta.url);
 var ORCHESTRATOR_SYSTEM_PROMPT = readFileSync(orchestratorPromptUrl, "utf-8");
 
+// src/orchestrator/agent-orchestrator.ts
+import "@anthropic-ai/claude-agent-sdk";
+
+// src/orchestrator/utils/completions-manager.ts
+import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
+import { glob } from "glob";
+import * as path5 from "path";
+var CompletionsManager = class {
+  slashCommandsCache;
+  filesCache = /* @__PURE__ */ new Map();
+  async fetchSlashCommands() {
+    if (this.slashCommandsCache && Date.now() - this.slashCommandsCache.fetched.getTime() < 5 * 60 * 1e3) {
+      return this.slashCommandsCache.slashCommands;
+    }
+    let commands = [];
+    for await (const message of query2({
+      prompt: "Respond with one word.",
+      options: { maxTurns: 1, model: "haiku", settingSources: ["user", "project", "local"] }
+    })) {
+      if (message.type === "system" && message.subtype === "init") {
+        console.log("Fetched available slash commands:", message.slash_commands);
+        commands = message.slash_commands;
+      }
+    }
+    this.slashCommandsCache = {
+      fetched: /* @__PURE__ */ new Date(),
+      slashCommands: commands
+    };
+    return commands;
+  }
+  async fetchFiles(searchPattern = "") {
+    const cached = this.filesCache.get(searchPattern);
+    if (cached && Date.now() - cached.fetched.getTime() < 30 * 1e3) {
+      return cached.files;
+    }
+    try {
+      let patterns = [];
+      if (searchPattern === "") {
+        patterns = [
+          "package.json",
+          "tsconfig.json",
+          "pyproject.toml",
+          "Cargo.toml",
+          "README.md",
+          "CLAUDE.md",
+          "src/index.*",
+          "src/main.*",
+          "src/app.*",
+          "index.*",
+          "main.*",
+          "app.*",
+          "*.config.*",
+          "src/**/*.tsx",
+          "src/**/*.ts",
+          "*.py"
+        ];
+      } else {
+        if (searchPattern.includes("/")) {
+          patterns.push(
+            `**/${searchPattern}*`,
+            // Match in any directory
+            `**/${searchPattern}*/**`,
+            // Match directories
+            `${searchPattern}*`,
+            // Match from root
+            `${searchPattern}*/**`
+            // Match root directories
+          );
+        } else {
+          patterns.push(
+            `**/*${searchPattern}*`,
+            // Files containing the pattern
+            `**/*${searchPattern}*.*`,
+            // Files with extensions containing pattern
+            `**/${searchPattern}*`,
+            // Files starting with the pattern
+            `${searchPattern}*`
+            // Files in current directory
+          );
+        }
+      }
+      const allFiles = /* @__PURE__ */ new Set();
+      for (const pattern of patterns) {
+        try {
+          const files = await glob(pattern, {
+            ignore: [
+              "**/node_modules/**",
+              "**/.git/**",
+              "**/dist/**",
+              "**/build/**",
+              "**/.venv/**",
+              "**/target/**",
+              "**/__pycache__/**",
+              "**/.pytest_cache/**",
+              "**/.next/**",
+              "**/.nuxt/**",
+              "**/coverage/**",
+              "**/*.min.js",
+              "**/*.map",
+              "**/vendor/**",
+              "**/.cache/**"
+            ],
+            maxDepth: 10,
+            absolute: false,
+            nodir: true
+            // Only files, not directories
+          });
+          files.forEach((f) => allFiles.add(f));
+        } catch {
+        }
+      }
+      const fileList = Array.from(allFiles).sort((a, b) => {
+        if (searchPattern === "") {
+          const importantFiles = [
+            "package.json",
+            "tsconfig.json",
+            "pyproject.toml",
+            "README.md",
+            "CLAUDE.md"
+          ];
+          const aName2 = path5.basename(a);
+          const bName2 = path5.basename(b);
+          const aImportant = importantFiles.includes(aName2);
+          const bImportant = importantFiles.includes(bName2);
+          if (aImportant && !bImportant) return -1;
+          if (!aImportant && bImportant) return 1;
+          const aDepth2 = (a.match(/\//g) || []).length;
+          const bDepth2 = (b.match(/\//g) || []).length;
+          if (aDepth2 !== bDepth2) return aDepth2 - bDepth2;
+          return a.localeCompare(b);
+        }
+        const aName = path5.basename(a).toLowerCase();
+        const bName = path5.basename(b).toLowerCase();
+        const searchLower = searchPattern.toLowerCase();
+        const aExact = aName === searchLower;
+        const bExact = bName === searchLower;
+        if (aExact && !bExact) return -1;
+        if (!aExact && bExact) return 1;
+        const aStarts = aName.startsWith(searchLower);
+        const bStarts = bName.startsWith(searchLower);
+        if (aStarts && !bStarts) return -1;
+        if (!aStarts && bStarts) return 1;
+        const aDepth = (a.match(/\//g) || []).length;
+        const bDepth = (b.match(/\//g) || []).length;
+        if (aDepth !== bDepth) return aDepth - bDepth;
+        return a.localeCompare(b);
+      }).slice(0, searchPattern === "" ? 20 : 50);
+      this.filesCache.set(searchPattern, {
+        fetched: /* @__PURE__ */ new Date(),
+        files: fileList
+      });
+      if (this.filesCache.size > 100) {
+        const entries = Array.from(this.filesCache.entries());
+        entries.sort((a, b) => a[1].fetched.getTime() - b[1].fetched.getTime()).slice(0, 50).forEach(([key]) => this.filesCache.delete(key));
+      }
+      return fileList;
+    } catch (error) {
+      console.error("Error fetching files:", error);
+      return [];
+    }
+  }
+  async getCompletion(query3, limit = 50) {
+    const completions = [];
+    if (query3.startsWith("/")) {
+      const slashQuery = query3.slice(1);
+      const commands = (await this.fetchSlashCommands()).filter((cmd) => cmd.startsWith(slashQuery)).slice(0, limit);
+      for (const cmd of commands) {
+        completions.push({
+          type: "slash_command",
+          result: cmd
+        });
+      }
+    } else if (query3.startsWith("@")) {
+      const fileQuery = query3.slice(1);
+      const files = await this.fetchFiles(fileQuery);
+      for (const file of files.slice(0, limit)) {
+        completions.push({
+          type: "file",
+          result: file
+        });
+      }
+    }
+    return completions;
+  }
+};
+
+// src/config/omnara-config.ts
+import { parse as parseJsonc } from "jsonc-parser";
+import * as fs5 from "fs/promises";
+import * as path6 from "path";
+import * as z3 from "zod";
+var OmnaraConfig = z3.object({
+  worktrees: z3.object({
+    enabled: z3.boolean().default(false),
+    base_ref: z3.string().optional()
+  }).default({
+    enabled: false
+  })
+});
+async function readOmnaraConfig(configPath) {
+  const resolveConfig = async (path8) => {
+    if (!path8) {
+      return null;
+    }
+    await fs5.access(path8);
+    const content = await fs5.readFile(path8, "utf-8");
+    const errors = [];
+    const config = parseJsonc(content, errors, {
+      allowTrailingComma: true,
+      allowEmptyContent: true
+    });
+    return OmnaraConfig.parse(config);
+  };
+  const resolveDefault = () => {
+    return OmnaraConfig.parse({});
+  };
+  return await resolveConfig(configPath).catch(() => null) ?? await resolveConfig(path6.join(process.cwd(), "omnara.jsonc")).catch(() => null) ?? await resolveConfig(path6.join(process.cwd(), "omnara.json")).catch(() => null) ?? await resolveDefault();
+}
+function isWorktreesEnabled(config) {
+  return config.worktrees.enabled;
+}
+
 // src/orchestrator/agent-orchestrator.ts
 var WORKER_LAUNCH_TOOL = "mcp__worker__launch_worker";
 var WORKER_GET_TOOL = "mcp__worker__get_workers";
 var WORKER_MESSAGE_TOOL = "mcp__worker__message_worker";
 var AgentOrchestrator = class {
+  completionsManager;
   aiClient;
   workerManager;
   sessions = /* @__PURE__ */ new Map();
@@ -2004,7 +2324,9 @@ var AgentOrchestrator = class {
     this.workerManager = dependencies?.workerManager ?? new WorkerManager({
       createClient: workerClientFactory,
       resolveSessionIdBySdk,
-      repoPath: dependencies?.repoPath ?? process.cwd()
+      repoPath: dependencies?.repoPath ?? process.cwd(),
+      worktreesEnabled: dependencies?.worktreesEnabled ?? false,
+      worktreesBaseRef: dependencies?.worktreesBaseRef
     });
     const workerMcpServer = createWorkerMcpServer(this.workerManager, {
       resolveSessionIdBySdk,
@@ -2028,6 +2350,7 @@ var AgentOrchestrator = class {
     }));
     this.aiClient = mainClientFactory();
     this.registerWorkerListeners();
+    this.completionsManager = new CompletionsManager();
   }
   ensureSessionExists(sessionId) {
     const existing = this.sessions.get(sessionId);
@@ -2109,6 +2432,14 @@ var AgentOrchestrator = class {
     this.sessions.clear();
     this.started = false;
   }
+  async cancel() {
+    await Promise.all(
+      this.getWorkerManager().listWorkers().filter((w) => w.status === "running").map((worker) => {
+        return this.getWorkerManager().cancelWorker(worker.id);
+      })
+    );
+    await this.aiClient.cancel();
+  }
   handleDisconnect(connection) {
     for (const sessionId of connection.sessionIds) {
       const session = this.sessions.get(sessionId);
@@ -2528,10 +2859,17 @@ var AgentOrchestrator = class {
   buildWorkerStatusMessage(triggerWorkerId) {
     const allWorkers = this.workerManager.listWorkers();
     if (allWorkers.length === 0) {
-      return "[WORKER STATUS UPDATE]\n\nNo active workers.";
-    }
-    const lines = ["[WORKER STATUS UPDATE - Generation Triggered]"];
-    lines.push("");
+      return "\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n[AUTOMATED SYSTEM NOTIFICATION: WORKER STATUS UPDATE]\n\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n\nNo active workers.\n\n\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\nEND OF AUTOMATED NOTIFICATION\n\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550";
+    }
+    const lines = [
+      "\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550",
+      "[AUTOMATED SYSTEM NOTIFICATION: WORKER STATUS UPDATE]",
+      "\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550",
+      "",
+      "This is an automated notification triggered by a worker completion.",
+      "You should provide an INCREMENTAL summary of only the NEW completion to the user.",
+      ""
+    ];
     for (const worker of allWorkers) {
       const isTrigger = worker.id === triggerWorkerId;
       const prefix = isTrigger ? ">>> " : "    ";
@@ -2565,6 +2903,9 @@ var AgentOrchestrator = class {
       }
       lines.push("");
     }
+    lines.push("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+    lines.push("END OF AUTOMATED NOTIFICATION");
+    lines.push("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
     return lines.join("\n");
   }
   broadcastToAll(message) {
@@ -2594,7 +2935,41 @@ var AgentOrchestrator = class {
       this.handleDisconnect(connection);
     }
   }
+  async getCompletions(request) {
+    return {
+      type: "completions",
+      completions: await this.completionsManager.getCompletion(request.query)
+    };
+  }
 };
+async function startAgentOrchestrator(dependencies) {
+  let worktreesEnabled = dependencies?.worktreesEnabled ?? false;
+  let worktreesBaseRef = dependencies?.worktreesBaseRef;
+  if (dependencies?.worktreesEnabled === void 0) {
+    try {
+      const config = await readOmnaraConfig();
+      worktreesEnabled = isWorktreesEnabled(config);
+      worktreesBaseRef = config.worktrees.base_ref;
+      if (worktreesEnabled) {
+        logger.info("Worktrees enabled via omnara.jsonc configuration");
+      } else {
+        logger.info("Worktrees disabled (no worktrees config found in omnara.jsonc)");
+      }
+    } catch (err) {
+      logger.error("Failed to read omnara.jsonc configuration:", err);
+      logger.info("Worktrees disabled due to config read error");
+      worktreesEnabled = false;
+      worktreesBaseRef = void 0;
+    }
+  }
+  const server = new AgentOrchestrator({
+    ...dependencies,
+    worktreesEnabled,
+    worktreesBaseRef
+  });
+  await server.start();
+  return server;
+}
 
 // src/relay/relay-bridge.ts
 import { randomUUID as randomUUID4 } from "crypto";
@@ -2616,8 +2991,8 @@ var ApiClient = class {
   constructor(options) {
     this.baseUrl = normalizeBaseUrl(options.baseUrl);
   }
-  async getJson(path7, options) {
-    const url = resolveUrl(this.baseUrl, path7);
+  async getJson(path8, options) {
+    const url = resolveUrl(this.baseUrl, path8);
     const headers = this.buildHeaders(options);
     const response = await fetch(url, {
       method: "GET",
@@ -2626,8 +3001,8 @@ var ApiClient = class {
     });
     return await this.handleResponse(response);
   }
-  async postJson(path7, body, options) {
-    const url = resolveUrl(this.baseUrl, path7);
+  async postJson(path8, body, options) {
+    const url = resolveUrl(this.baseUrl, path8);
     const headers = this.buildHeaders(options, { includeJson: true });
     const response = await fetch(url, {
       method: "POST",
@@ -2685,12 +3060,12 @@ function normalizeBaseUrl(raw) {
   }
   return raw.endsWith("/") ? raw : `${raw}/`;
 }
-function resolveUrl(base, path7) {
+function resolveUrl(base, path8) {
   const baseUrl = new URL(base);
-  if (!path7.startsWith("/")) {
-    path7 = `/${path7}`;
+  if (!path8.startsWith("/")) {
+    path8 = `/${path8}`;
   }
-  const resolved = new URL(path7, baseUrl);
+  const resolved = new URL(path8, baseUrl);
   return resolved.toString();
 }
 function extractDetail(payload) {
@@ -3433,6 +3808,166 @@ var control_message_schema_default = {
       title: "AgentWorkStatus",
       type: "string"
     },
+    CancelAgentMessage: {
+      additionalProperties: false,
+      description: "Request to cancel a running agent generation.",
+      properties: {
+        type: {
+          const: "cancel_agent",
+          default: "cancel_agent",
+          title: "Type",
+          type: "string"
+        },
+        target_session_id: {
+          format: "uuid",
+          title: "Target Session Id",
+          type: "string"
+        },
+        reason: {
+          anyOf: [
+            {
+              type: "string"
+            },
+            {
+              type: "null"
+            }
+          ],
+          default: null,
+          title: "Reason"
+        }
+      },
+      required: [
+        "target_session_id"
+      ],
+      title: "CancelAgentMessage",
+      type: "object"
+    },
+    CompletionItem: {
+      description: "A single completion item with type and result",
+      properties: {
+        type: {
+          enum: [
+            "slash_command",
+            "file",
+            "agent"
+          ],
+          title: "Type",
+          type: "string"
+        },
+        result: {
+          title: "Result",
+          type: "string"
+        }
+      },
+      required: [
+        "type",
+        "result"
+      ],
+      title: "CompletionItem",
+      type: "object"
+    },
+    CompletionsRequest: {
+      description: "Query for autocomplete options",
+      properties: {
+        type: {
+          const: "completions",
+          default: "completions",
+          title: "Type",
+          type: "string"
+        },
+        query: {
+          title: "Query",
+          type: "string"
+        }
+      },
+      required: [
+        "query"
+      ],
+      title: "CompletionsRequest",
+      type: "object"
+    },
+    CompletionsResponse: {
+      description: "List of autocomplete options (i.e. files or /commands)",
+      properties: {
+        type: {
+          const: "completions",
+          default: "completions",
+          title: "Type",
+          type: "string"
+        },
+        completions: {
+          items: {
+            $ref: "#/$defs/CompletionItem"
+          },
+          title: "Completions",
+          type: "array"
+        }
+      },
+      required: [
+        "completions"
+      ],
+      title: "CompletionsResponse",
+      type: "object"
+    },
+    ErrorResponse: {
+      properties: {
+        type: {
+          const: "error",
+          default: "error",
+          title: "Type",
+          type: "string"
+        },
+        error: {
+          title: "Error",
+          type: "string"
+        }
+      },
+      required: [
+        "error"
+      ],
+      title: "ErrorResponse",
+      type: "object"
+    },
+    GitDiffRequest: {
+      description: "Query the git diff on a branch",
+      properties: {
+        type: {
+          const: "git_diff",
+          default: "git_diff",
+          title: "Type",
+          type: "string"
+        },
+        branch: {
+          title: "Branch",
+          type: "string"
+        }
+      },
+      required: [
+        "branch"
+      ],
+      title: "GitDiffRequest",
+      type: "object"
+    },
+    GitDiffResponse: {
+      description: "Git diff response for a given branch\nTODO: add the actual definition",
+      properties: {
+        type: {
+          const: "git_diff",
+          default: "git_diff",
+          title: "Type",
+          type: "string"
+        },
+        diff: {
+          title: "Diff",
+          type: "null"
+        }
+      },
+      required: [
+        "diff"
+      ],
+      title: "GitDiffResponse",
+      type: "object"
+    },
     Heartbeat: {
       additionalProperties: false,
       description: "Ping/pong heartbeat frames.",
@@ -3469,6 +4004,77 @@ var control_message_schema_default = {
       title: "Heartbeat",
       type: "object"
     },
+    RelayRequestMessage: {
+      additionalProperties: false,
+      description: "RPC message for generic requests",
+      properties: {
+        type: {
+          const: "request",
+          default: "request",
+          title: "Type",
+          type: "string"
+        },
+        request_id: {
+          format: "uuid",
+          title: "Request Id",
+          type: "string"
+        },
+        request: {
+          anyOf: [
+            {
+              $ref: "#/$defs/CompletionsRequest"
+            },
+            {
+              $ref: "#/$defs/GitDiffRequest"
+            }
+          ],
+          title: "Request"
+        }
+      },
+      required: [
+        "request_id",
+        "request"
+      ],
+      title: "RelayRequestMessage",
+      type: "object"
+    },
+    RelayResponseMessage: {
+      additionalProperties: false,
+      description: "RPC message for responses",
+      properties: {
+        type: {
+          const: "response",
+          default: "response",
+          title: "Type",
+          type: "string"
+        },
+        request_id: {
+          format: "uuid",
+          title: "Request Id",
+          type: "string"
+        },
+        response: {
+          anyOf: [
+            {
+              $ref: "#/$defs/ErrorResponse"
+            },
+            {
+              $ref: "#/$defs/CompletionsResponse"
+            },
+            {
+              $ref: "#/$defs/GitDiffResponse"
+            }
+          ],
+          title: "Response"
+        }
+      },
+      required: [
+        "request_id",
+        "response"
+      ],
+      title: "RelayResponseMessage",
+      type: "object"
+    },
     SessionAnnounce: {
       additionalProperties: false,
       description: "Notification that a session was created or updated.",
@@ -3769,6 +4375,15 @@ var control_message_schema_default = {
     },
     {
       $ref: "#/$defs/Heartbeat"
+    },
+    {
+      $ref: "#/$defs/CancelAgentMessage"
+    },
+    {
+      $ref: "#/$defs/RelayRequestMessage"
+    },
+    {
+      $ref: "#/$defs/RelayResponseMessage"
     }
   ]
 };
@@ -5698,6 +6313,7 @@ var RelayBridge = class extends EventEmitter2 {
   userSessionId = null;
   currentAgentSessionId = null;
   browserOpened = false;
+  canceled = false;
   constructor(orchestrator, options) {
     super();
     this.orchestrator = orchestrator;
@@ -5711,7 +6327,7 @@ var RelayBridge = class extends EventEmitter2 {
       throw new Error("Relay bridge already started");
     }
     this.connectionHandle = this.orchestrator.addClient({
-      canSend: () => this.ws?.readyState === WebSocket.OPEN,
+      canSend: () => !this.canceled && this.ws?.readyState === WebSocket.OPEN,
       send: (message) => {
         this.handleOutbound(message);
       }
@@ -5742,6 +6358,7 @@ var RelayBridge = class extends EventEmitter2 {
     this.stopped = true;
     this.currentAgentSessionId = null;
     this.browserOpened = false;
+    this.canceled = false;
     if (this.pingTimer) {
       clearInterval(this.pingTimer);
       this.pingTimer = null;
@@ -5976,9 +6593,7 @@ var RelayBridge = class extends EventEmitter2 {
         this.handleSessionAnnounce(control);
         break;
       case "session_closed":
-        this.logger.info(
-          `Session closed: ${control.session_id} -> status ${control.status}`
-        );
+        this.handleSessionClosed(control);
         break;
       case "heartbeat":
         if (control.mode === "ping") {
@@ -5990,6 +6605,12 @@ var RelayBridge = class extends EventEmitter2 {
           this.sendFrame(response);
         }
         break;
+      case "cancel_agent":
+        this.handleCancelAgent(control);
+        break;
+      case "request":
+        this.handleRelayRequest(control);
+        break;
       default:
         this.logger.debug(`Ignoring control message ${type ?? "unknown"}`);
     }
@@ -6056,6 +6677,68 @@ var RelayBridge = class extends EventEmitter2 {
       this.orchestrator.ensureSessionExists(control.session.session_id);
     }
   }
+  async handleCancelAgent(control) {
+    this.logger.info(
+      `Received cancel request for session ${control.target_session_id}${control.reason ? ` (reason: ${control.reason})` : ""}`
+    );
+    if (control.target_session_id === this.currentAgentSessionId) {
+      this.logger.info("Cancel request for main orchestrator session");
+      await this.orchestrator.cancel();
+    } else {
+      const success = this.orchestrator.getWorkerManager().cancelWorker(control.target_session_id);
+      if (success) {
+        this.logger.info(`Worker cancellation succeeded for ${control.target_session_id}`);
+      } else {
+        this.logger.warn(
+          `Worker cancellation failed for ${control.target_session_id} (worker not found or already completed)`
+        );
+      }
+    }
+  }
+  handleSessionClosed(control) {
+    const closedSessionId = control.session_id;
+    this.logger.info(`Session closed: ${closedSessionId} -> status ${control.status}`);
+    if (closedSessionId === this.currentAgentSessionId) {
+      this.logger.info(
+        `Main orchestrator session ${closedSessionId} was canceled. Stopping message sending.`
+      );
+      this.canceled = true;
+    }
+  }
+  async handleRelayRequest(control) {
+    const requestId = control.request_id;
+    const request = control.request;
+    let response;
+    switch (request.type) {
+      case "completions":
+        response = await this.orchestrator.getCompletions(
+          request
+        );
+        break;
+      case "git_diff":
+        this.logger.warn("Git diff not implemented");
+        response = {
+          type: "git_diff",
+          diff: null
+        };
+        break;
+      default:
+        response = {
+          type: "error",
+          error: `Request failed: Unknown relay request type ${request.type}`
+        };
+    }
+    const socket = this.ws;
+    if (!socket || socket.readyState !== WebSocket.OPEN) {
+      return;
+    }
+    const frame = {
+      type: "response",
+      request_id: requestId,
+      response
+    };
+    this.sendFrame(frame, socket);
+  }
   handleMessageEnvelope(envelope) {
     const content = envelope.payload.content;
     const isUserMessage = envelope.sender.kind === "user";
@@ -6312,16 +6995,16 @@ var RelayBridge = class extends EventEmitter2 {
     }
   }
 };
-function buildRelayWebsocketUrl(baseUrl, path7) {
+function buildRelayWebsocketUrl(baseUrl, path8) {
   const url = new URL(baseUrl);
   url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
   url.search = "";
   url.hash = "";
-  if (path7.startsWith("/")) {
-    url.pathname = path7;
+  if (path8.startsWith("/")) {
+    url.pathname = path8;
   } else {
     const basePath = url.pathname.endsWith("/") ? url.pathname : `${url.pathname}/`;
-    url.pathname = `${basePath}${path7}`;
+    url.pathname = `${basePath}${path8}`;
   }
   return url.toString();
 }
@@ -6664,7 +7347,7 @@ Commands:
 
 // src/voice/voice-service.ts
 async function launchVoiceForSession(client, accessToken, options) {
-  const path7 = `/api/v1/voice/sessions/${options.sessionId}/launch`;
+  const path8 = `/api/v1/voice/sessions/${options.sessionId}/launch`;
   const requestBody = {};
   if (options.force) {
     requestBody.force = true;
@@ -6673,7 +7356,7 @@ async function launchVoiceForSession(client, accessToken, options) {
     requestBody.room_name = options.roomName;
   }
   const response = await client.postJson(
-    path7,
+    path8,
     requestBody,
     { accessToken }
   );
@@ -6769,8 +7452,7 @@ async function runAgentOrchestrator(options = {}) {
   } else {
     logger.info("\u2139 Running without Claude Code integration");
   }
-  const orchestrator = new AgentOrchestrator();
-  await orchestrator.start();
+  const orchestrator = await startAgentOrchestrator();
   const backendUrl = resolveBackendUrl(options.backendUrl);
   const frontendUrl = resolveFrontendUrl(options.frontendUrl);
   const store = new CredentialsStore();
@@ -6875,16 +7557,16 @@ async function runVoice(options) {
   logger.debug(launch.relayToken);
   logger.important("\nKeep this information secure\u2014tokens grant access to your agent session.");
 }
-function buildRelayWebsocketUrl2(baseUrl, path7) {
+function buildRelayWebsocketUrl2(baseUrl, path8) {
   const url = new URL(baseUrl);
   url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
   url.search = "";
   url.hash = "";
-  if (path7.startsWith("/")) {
-    url.pathname = path7;
+  if (path8.startsWith("/")) {
+    url.pathname = path8;
   } else {
     const basePath = url.pathname.endsWith("/") ? url.pathname : `${url.pathname}/`;
-    url.pathname = `${basePath}${path7}`;
+    url.pathname = `${basePath}${path8}`;
   }
   return url.toString();
 }
@@ -7057,9 +7739,9 @@ function isMainModule() {
   if (!import.meta.url || !process.argv[1]) {
     return false;
   }
-  const executedPath = path6.resolve(process.argv[1]);
+  const executedPath = path7.resolve(process.argv[1]);
   const currentPath = import.meta.url.startsWith("file://") ? decodeURIComponent(import.meta.url.slice(7)) : import.meta.url;
-  return path6.normalize(currentPath) === path6.normalize(executedPath);
+  return path7.normalize(currentPath) === path7.normalize(executedPath);
 }
 if (isMainModule()) {
   run(process.argv).catch((error) => {