omnara 0.1.6 → 0.1.9

package/dist/cli.js

@@ -1,11 +1,11 @@
 // ESM shim for __filename and __dirname
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
+import { fileURLToPath as __omnaraFileURLToPath } from 'url';
+import pathShim from 'path';
+const __filename = __omnaraFileURLToPath(import.meta.url);
+const __dirname = pathShim.dirname(__filename);
 
 // src/cli.ts
-import path4 from "path";
+import path6 from "path";
 import { createRequire as createRequire2 } from "node:module";
 import { Command as Command3 } from "commander";
 
@@ -63,6 +63,9 @@ var AIClient = class {
       ...defaultOptions,
       ...config?.defaults
     };
+    if (this.baseOptions.cwd && this.baseOptions.cwd !== process.cwd()) {
+      console.log("[AIClient] Using custom working directory:", this.baseOptions.cwd);
+    }
     this.ensureWorkingDirectory(this.baseOptions.cwd);
   }
   async *streamUserMessage(prompt2, overrides) {
@@ -185,7 +188,11 @@ var Session = class {
   }
   subscribe(subscriber) {
     this.subscribers.set(subscriber.id, subscriber);
-    this.safeSend(subscriber, { type: "session_joined", sessionId: this.id, messageId: randomUUID() });
+    this.safeSend(subscriber, {
+      type: "session_joined",
+      sessionId: this.id,
+      messageId: randomUUID()
+    });
   }
   unsubscribe(subscriberId) {
     this.subscribers.delete(subscriberId);
@@ -536,14 +543,644 @@ var AsyncQueue = class {
   }
 };
 
+// src/orchestrator/utils/worktree-manager.ts
+import { simpleGit } from "simple-git";
+import * as fs4 from "fs/promises";
+import * as path4 from "path";
+
+// src/utils/logger.ts
+import path2 from "path";
+function isProduction() {
+  if (process.env.NODE_ENV === "production") {
+    return true;
+  }
+  try {
+    const currentFile = typeof __filename !== "undefined" ? __filename : "";
+    const isInDist = currentFile.includes(path2.sep + "dist" + path2.sep);
+    if (isInDist && process.env.NODE_ENV !== "development") {
+      return true;
+    }
+  } catch {
+  }
+  const logLevel = process.env.OMNARA_LOG_LEVEL?.toLowerCase();
+  if (logLevel === "none" || logLevel === "silent") {
+    return true;
+  }
+  return false;
+}
+function getLogLevel() {
+  const envLevel = process.env.OMNARA_LOG_LEVEL?.toLowerCase();
+  switch (envLevel) {
+    case "none":
+    case "silent":
+      return 0 /* NONE */;
+    case "error":
+      return 1 /* ERROR */;
+    case "warn":
+    case "warning":
+      return 2 /* WARN */;
+    case "info":
+      return 3 /* INFO */;
+    case "debug":
+      return 4 /* DEBUG */;
+    case "verbose":
+    case "trace":
+      return 5 /* VERBOSE */;
+    default:
+      return isProduction() ? 1 /* ERROR */ : 3 /* INFO */;
+  }
+}
+var ControlledLogger = class {
+  logLevel;
+  forceOutput;
+  _console;
+  // Console properties we need to implement
+  Console;
+  constructor(options) {
+    this.logLevel = options?.logLevel ?? getLogLevel();
+    this.forceOutput = options?.forceOutput ?? false;
+    this._console = console;
+    this.Console = console.Console;
+  }
+  /**
+   * Standard log output (INFO level)
+   */
+  log(...args) {
+    if (this.shouldLog(3 /* INFO */)) {
+      console.log(...args);
+    }
+  }
+  /**
+   * Error output (always shown unless NONE)
+   */
+  error(...args) {
+    if (this.shouldLog(1 /* ERROR */)) {
+      console.error(...args);
+    }
+  }
+  /**
+   * Warning output
+   */
+  warn(...args) {
+    if (this.shouldLog(2 /* WARN */)) {
+      console.warn(...args);
+    }
+  }
+  /**
+   * Info level output
+   */
+  info(...args) {
+    if (this.shouldLog(3 /* INFO */)) {
+      console.info(...args);
+    }
+  }
+  /**
+   * Debug output (only in development)
+   */
+  debug(...args) {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      console.debug(...args);
+    }
+  }
+  /**
+   * Verbose/trace output
+   */
+  trace(...args) {
+    if (this.shouldLog(5 /* VERBOSE */)) {
+      console.log("[TRACE]", ...args);
+    }
+  }
+  /**
+   * Important messages that should always be shown to user
+   * (authentication status, connection info, etc.)
+   */
+  important(...args) {
+    if (this.logLevel !== 0 /* NONE */ || this.forceOutput) {
+      console.log(...args);
+    }
+  }
+  /**
+   * Success messages that should typically be shown
+   */
+  success(...args) {
+    if (this.shouldLog(2 /* WARN */) || this.forceOutput) {
+      console.log(...args);
+    }
+  }
+  /**
+   * Check if a message should be logged at the given level
+   */
+  shouldLog(level) {
+    return this.forceOutput || this.logLevel >= level;
+  }
+  /**
+   * Update the log level dynamically
+   */
+  setLogLevel(level) {
+    this.logLevel = level;
+  }
+  /**
+   * Get current log level
+   */
+  getLogLevel() {
+    return this.logLevel;
+  }
+  // Console methods we delegate or control based on log level
+  assert(condition, ...data) {
+    if (this.shouldLog(1 /* ERROR */)) {
+      this._console.assert(condition, ...data);
+    }
+  }
+  clear() {
+    this._console.clear();
+  }
+  count(label) {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      this._console.count(label);
+    }
+  }
+  countReset(label) {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      this._console.countReset(label);
+    }
+  }
+  dir(item, options) {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      this._console.dir(item, options);
+    }
+  }
+  dirxml(...data) {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      this._console.dirxml(...data);
+    }
+  }
+  group(...data) {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      this._console.group(...data);
+    }
+  }
+  groupCollapsed(...data) {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      this._console.groupCollapsed(...data);
+    }
+  }
+  groupEnd() {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      this._console.groupEnd();
+    }
+  }
+  table(tabularData, properties) {
+    if (this.shouldLog(3 /* INFO */)) {
+      this._console.table(tabularData, properties);
+    }
+  }
+  time(label) {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      this._console.time(label);
+    }
+  }
+  timeEnd(label) {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      this._console.timeEnd(label);
+    }
+  }
+  timeLog(label, ...data) {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      this._console.timeLog(label, ...data);
+    }
+  }
+  timeStamp(label) {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      this._console.timeStamp(label);
+    }
+  }
+  profile(label) {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      const consoleWithProfile = this._console;
+      consoleWithProfile.profile?.(label);
+    }
+  }
+  profileEnd(label) {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      const consoleWithProfileEnd = this._console;
+      consoleWithProfileEnd.profileEnd?.(label);
+    }
+  }
+};
+var logger = new ControlledLogger();
+function extractErrorMessage2(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
+// src/auth/credentials-store.ts
+import fs3 from "fs/promises";
+import os2 from "os";
+import path3 from "path";
+var DEFAULT_DIR = path3.join(os2.homedir(), ".omnara");
+var DEFAULT_CREDENTIALS_PATH = path3.join(DEFAULT_DIR, "creds.json");
+var DEFAULT_FILE_MODE = 384;
+var DEFAULT_DIR_MODE = 448;
+function isStoredCredentials(value) {
+  return Boolean(value) && typeof value === "object";
+}
+var CredentialsStore = class {
+  constructor(filePath = DEFAULT_CREDENTIALS_PATH) {
+    this.filePath = filePath;
+  }
+  async load() {
+    try {
+      const raw = await fs3.readFile(this.filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (!isStoredCredentials(parsed)) {
+        throw new Error("File does not contain valid credentials data");
+      }
+      return parsed;
+    } catch (error) {
+      if (isFileNotFound(error)) {
+        return null;
+      }
+      throw new Error(
+        `Failed to read credentials from ${this.filePath}: ${extractErrorMessage3(error)}`
+      );
+    }
+  }
+  async save(credentials) {
+    const payload = {
+      accessToken: credentials.accessToken,
+      accessTokenExpiresAt: credentials.accessTokenExpiresAt,
+      refreshToken: credentials.refreshToken,
+      refreshTokenExpiresAt: credentials.refreshTokenExpiresAt
+    };
+    await fs3.mkdir(path3.dirname(this.filePath), { recursive: true, mode: DEFAULT_DIR_MODE });
+    const tempPath = `${this.filePath}.tmp`;
+    const serialized = JSON.stringify(payload, null, 2);
+    await fs3.writeFile(tempPath, serialized, { mode: DEFAULT_FILE_MODE });
+    await fs3.chmod(tempPath, DEFAULT_FILE_MODE);
+    await fs3.rename(tempPath, this.filePath);
+  }
+  async clear() {
+    try {
+      await fs3.unlink(this.filePath);
+    } catch (error) {
+      if (!isFileNotFound(error)) {
+        throw new Error(
+          `Failed to remove credentials file ${this.filePath}: ${extractErrorMessage3(error)}`
+        );
+      }
+    }
+  }
+};
+function isFileNotFound(error) {
+  return Boolean(
+    error && typeof error === "object" && "code" in error && error.code === "ENOENT"
+  );
+}
+function extractErrorMessage3(error) {
+  if (error instanceof Error && error.message) {
+    return error.message;
+  }
+  return String(error);
+}
+
+// src/orchestrator/utils/worktree-manager.ts
+var WorktreeError = class extends Error {
+  constructor(message, workerId, operation, cause) {
+    super(message);
+    this.workerId = workerId;
+    this.operation = operation;
+    this.cause = cause;
+    this.name = "WorktreeError";
+  }
+};
+var WorktreeManager = class {
+  git;
+  repoPath;
+  worktreeBasePath;
+  activeWorktrees;
+  enabled;
+  constructor(options) {
+    this.repoPath = options.repoPath;
+    this.enabled = options.enabled ?? false;
+    const repoName = path4.basename(this.repoPath);
+    this.worktreeBasePath = options.worktreeBasePath || path4.join(DEFAULT_DIR, "worktrees", repoName);
+    this.git = simpleGit(this.repoPath);
+    this.activeWorktrees = /* @__PURE__ */ new Map();
+    if (this.enabled) {
+      this.validateGitRepository();
+    }
+  }
+  /**
+   * Validate that the repoPath is a git repository
+   * Logs an error if worktrees are enabled but not in a git repository
+   */
+  validateGitRepository() {
+    this.git.checkIsRepo().then((isRepo) => {
+      if (!isRepo) {
+        logger.error(`Worktrees are enabled but not in a git repository at ${this.repoPath}`);
+      } else {
+        logger.info(`Worktrees enabled for repository at ${this.repoPath}`);
+      }
+    }).catch((error) => {
+      logger.error(
+        `Worktrees are enabled but failed to check git repository at ${this.repoPath}:`,
+        error
+      );
+    });
+  }
+  /**
+   * Check if worktrees are enabled
+   */
+  isEnabled() {
+    return this.enabled;
+  }
+  /**
+   * Creates a new worktree for the specified worker
+   *
+   * @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
+   * @throws {WorktreeError} If worktree creation fails
+   */
+  async createWorktree(workerId, worktreeName) {
+    if (!this.enabled) {
+      throw new WorktreeError(
+        'Worktrees are not enabled. Add a "worktrees" configuration to omnara.jsonc to enable.',
+        workerId,
+        "create"
+      );
+    }
+    logger.info(`Creating worktree "${worktreeName}" for worker ${workerId}`);
+    try {
+      if (this.activeWorktrees.has(workerId)) {
+        throw new WorktreeError(
+          `Worktree already exists for worker ${workerId}`,
+          workerId,
+          "create"
+        );
+      }
+      await fs4.mkdir(this.worktreeBasePath, { recursive: true });
+      const branchName = `${worktreeName}`;
+      const worktreePath = path4.join(this.worktreeBasePath, worktreeName);
+      const branches = await this.git.branchLocal();
+      const branchExists = branches.all.includes(branchName);
+      let worktreeDirExists = false;
+      try {
+        await fs4.access(worktreePath);
+        worktreeDirExists = true;
+      } catch {
+        worktreeDirExists = false;
+      }
+      const worktreeList = await this.git.raw(["worktree", "list", "--porcelain"]);
+      const gitWorktrees = this.parseWorktreeList(worktreeList);
+      const worktreeRegistered = gitWorktrees.includes(worktreePath);
+      if (worktreeRegistered && branchExists) {
+        logger.info(
+          `Reusing existing worktree "${worktreeName}" at ${worktreePath} on branch ${branchName}`
+        );
+        const info2 = {
+          workerId,
+          worktreeName,
+          worktreePath,
+          branchName,
+          createdAt: /* @__PURE__ */ new Date()
+        };
+        this.activeWorktrees.set(workerId, info2);
+        return info2;
+      }
+      if (worktreeDirExists && !worktreeRegistered) {
+        logger.warn(
+          `Directory exists at ${worktreePath} but is not a registered worktree. Removing...`
+        );
+        await fs4.rm(worktreePath, { recursive: true, force: true });
+        worktreeDirExists = false;
+      }
+      if (branchExists && !worktreeRegistered) {
+        logger.info(
+          `Branch ${branchName} exists. Creating worktree at ${worktreePath} using existing branch`
+        );
+        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 info = {
+        workerId,
+        worktreeName,
+        worktreePath,
+        branchName,
+        createdAt: /* @__PURE__ */ new Date()
+      };
+      this.activeWorktrees.set(workerId, info);
+      logger.info(`Worktree "${worktreeName}" ready at ${worktreePath} on branch ${branchName}`);
+      return info;
+    } catch (error) {
+      logger.error(`Failed to create worktree for worker ${workerId}:`, error);
+      throw new WorktreeError(
+        `Failed to create worktree: ${error instanceof Error ? error.message : String(error)}`,
+        workerId,
+        "create",
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Removes a worktree for the specified worker
+   *
+   * @param workerId - Unique identifier for the worker
+   * @param force - Force removal even if there are uncommitted changes
+   * @throws {WorktreeError} If worktree removal fails
+   */
+  async removeWorktree(workerId, force = false) {
+    if (!this.enabled) {
+      return;
+    }
+    logger.info(`Removing worktree for worker ${workerId}`);
+    const info = this.activeWorktrees.get(workerId);
+    if (!info) {
+      logger.warn(`No active worktree found for worker ${workerId}`);
+      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 {
+          }
+        } else {
+          throw worktreeError;
+        }
+      }
+      this.activeWorktrees.delete(workerId);
+      logger.info(`Removed worktree for worker ${workerId}`);
+    } catch (error) {
+      logger.error(`Failed to remove worktree for worker ${workerId}:`, error);
+      throw new WorktreeError(
+        `Failed to remove worktree: ${error instanceof Error ? error.message : String(error)}`,
+        workerId,
+        "remove",
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Gets information about a worker's worktree
+   *
+   * @param workerId - Unique identifier for the worker
+   * @returns Worktree information or undefined if not found
+   */
+  getWorktreeInfo(workerId) {
+    return this.activeWorktrees.get(workerId);
+  }
+  /**
+   * Lists all active worktrees managed by this instance
+   *
+   * @returns Array of worktree information
+   */
+  listActiveWorktrees() {
+    return Array.from(this.activeWorktrees.values());
+  }
+  /**
+   * Cleans up all active worktrees
+   *
+   * This method should be called during application shutdown to ensure
+   * all worktrees are properly cleaned up.
+   *
+   * @param force - Force removal even if there are uncommitted changes
+   */
+  async cleanupAll(force = false) {
+    if (!this.enabled) {
+      return;
+    }
+    logger.info("Cleaning up all worktrees");
+    const workers = Array.from(this.activeWorktrees.keys());
+    const results = await Promise.allSettled(
+      workers.map((workerId) => this.removeWorktree(workerId, force))
+    );
+    const failures = results.filter((r) => r.status === "rejected");
+    if (failures.length > 0) {
+      logger.error(`Failed to cleanup ${failures.length} worktrees`);
+    } else {
+      logger.info("Successfully cleaned up all worktrees");
+    }
+  }
+  /**
+   * Parses the output of 'git worktree list --porcelain'
+   *
+   * @param output - Raw output from git worktree list
+   * @returns Array of worktree paths
+   */
+  parseWorktreeList(output2) {
+    const lines = output2.split("\n");
+    const paths = [];
+    for (const line of lines) {
+      if (line.startsWith("worktree ")) {
+        paths.push(line.substring("worktree ".length));
+      }
+    }
+    return paths;
+  }
+  /**
+   * Checks if the repository is in a clean state for worktree operations
+   *
+   * @returns True if repository is clean
+   */
+  async isRepositoryClean() {
+    const status = await this.git.status();
+    return status.files.length === 0;
+  }
+};
+
+// 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) {
     super();
     this.options = options;
+    this.worktreeManager = new WorktreeManager({
+      repoPath: options.repoPath,
+      enabled: false
+    });
+    this.initializeConfig();
   }
   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());
   }
@@ -585,7 +1222,7 @@ var WorkerManager = class extends EventEmitter {
     }
     return lines.join("\n");
   }
-  launchWorker({ task, prompt: prompt2, originSessionId, metadata }) {
+  launchWorker({ task, prompt: prompt2, work_context, worktree_name, originSessionId, metadata }, toolUseId) {
     const sessionId = randomUUID2();
     const resolvedOriginSessionId = originSessionId;
     const record = {
@@ -600,14 +1237,81 @@ var WorkerManager = class extends EventEmitter {
       originSessionId: resolvedOriginSessionId,
       progress: [],
       metadata,
-      messageQueue: new AsyncQueue()
+      messageQueue: new AsyncQueue(),
+      work_context,
+      worktree_name
     };
     this.workers.set(sessionId, record);
     this.emit("session_start", { ...record });
     this.emitUpdate(record);
-    void this.runWorker(record, prompt2);
+    if (toolUseId) {
+      this.emit("message", {
+        record,
+        messageType: "tool_call",
+        toolName: "mcp__worker__launch_worker",
+        toolUseId,
+        toolInput: { task, prompt: prompt2, metadata }
+      });
+      this.emit("message", {
+        record,
+        messageType: "tool_result",
+        toolUseId,
+        toolContent: {
+          workerId: record.id,
+          status: record.status,
+          message: `Worker launched successfully, task ${task} in progress.`
+        },
+        isError: false
+      });
+    }
+    void this.createWorktreeAndRun(record, prompt2);
     return record;
   }
+  async createWorktreeAndRun(record, prompt2) {
+    try {
+      if (this.worktreeManager.isEnabled()) {
+        logger.info(`Creating worktree for worker ${record.id} (task: ${record.task})`);
+        const worktreeInfo = await this.worktreeManager.createWorktree(
+          record.id,
+          record.worktree_name || record.id
+        );
+        record.worktreePath = worktreeInfo.worktreePath;
+        record.branchName = worktreeInfo.branchName;
+        record.progress.push({
+          timestamp: Date.now(),
+          message: `Worktree created at ${worktreeInfo.worktreePath} on branch ${worktreeInfo.branchName}`
+        });
+        this.emitUpdate(record);
+        logger.info(`Worktree created for worker ${record.id} at ${worktreeInfo.worktreePath}`);
+      } else {
+        logger.info(`Worktrees disabled, worker ${record.id} will run in current directory`);
+        record.progress.push({
+          timestamp: Date.now(),
+          message: "Worktrees disabled, running in current directory"
+        });
+        this.emitUpdate(record);
+      }
+      await this.runWorker(record, prompt2);
+    } catch (error) {
+      logger.error(`Failed to setup worker ${record.id}:`, error);
+      record.status = "error";
+      record.error = `Failed to setup worker: ${error instanceof Error ? error.message : String(error)}`;
+      record.lastUpdateAt = Date.now();
+      record.progress.push({
+        timestamp: Date.now(),
+        message: `Worker failed: ${record.error}`
+      });
+      this.emitUpdate(record);
+      this.emit("message", {
+        record,
+        messageType: "assistant_complete",
+        success: false,
+        text: record.error
+      });
+      this.emitCompleted(record);
+      record.messageQueue.close();
+    }
+  }
   cancelWorker(id) {
     const record = this.workers.get(id);
     if (!record) {
@@ -638,19 +1342,41 @@ var WorkerManager = class extends EventEmitter {
     return true;
   }
   /**
-   * Send a message to a running worker.
+   * Send a message to a worker (running or completed).
    *
    * @param task - The task name of the worker to message
    * @param message - The message content to send
    * @param interrupt - If true, interrupt current generation; if false, queue for next turn
-   * @returns true if message was sent, false if worker not found or not running
+   * @param toolUseId - Optional tool use ID to track this operation for relay forwarding
+   * @returns true if message was sent, false if worker not found or message queue is closed
    */
-  async messageWorker(task, message, interrupt) {
+  async messageWorker(task, message, interrupt, toolUseId) {
     const record = this.getWorkerByTask(task);
     if (!record) {
       return false;
     }
+    if (toolUseId) {
+      this.emit("message", {
+        record,
+        messageType: "tool_call",
+        toolName: "mcp__worker__message_worker",
+        toolUseId,
+        toolInput: { task, message, interrupt }
+      });
+    }
     if (record.status !== "running") {
+      record.messageQueue = new AsyncQueue();
+      record.status = "running";
+      record.lastUpdateAt = Date.now();
+      record.progress.push({
+        timestamp: Date.now(),
+        message: `Worker restarted with new message: ${message}`
+      });
+      this.emitUpdate(record);
+      void this.runWorker(record, "");
+    }
+    if (record.messageQueue.isClosed()) {
+      console.error("[WorkerManager] Message queue is closed after restart attempt");
       return false;
     }
     record.progress.push({
@@ -680,9 +1406,35 @@ var WorkerManager = class extends EventEmitter {
     };
     try {
       record.messageQueue.push(userMessage);
+      if (toolUseId) {
+        this.emit("message", {
+          record,
+          messageType: "tool_result",
+          toolUseId,
+          toolContent: {
+            success: true,
+            task,
+            interrupted: interrupt,
+            message: interrupt ? `Message sent to worker "${task}" (interrupted current work)` : `Message queued for worker "${task}" (will be delivered after current turn)`
+          },
+          isError: false
+        });
+      }
       return true;
     } catch (error) {
       console.error("[WorkerManager] Failed to queue message:", error);
+      if (toolUseId) {
+        this.emit("message", {
+          record,
+          messageType: "tool_result",
+          toolUseId,
+          toolContent: {
+            success: false,
+            error: error instanceof Error ? error.message : "Failed to queue message"
+          },
+          isError: true
+        });
+      }
       return false;
     }
   }
@@ -709,17 +1461,20 @@ var WorkerManager = class extends EventEmitter {
   /**
    * Create an async iterable stream of user messages for the worker.
    * Yields the initial prompt, then streams any additional messages from the queue.
+   * If initialPrompt is empty, skips the initial yield and only consumes from the queue.
    */
   async *createMessageStream(initialPrompt, sessionId, messageQueue) {
-    yield {
-      session_id: sessionId,
-      type: "user",
-      message: {
-        role: "user",
-        content: initialPrompt
-      },
-      parent_tool_use_id: null
-    };
+    if (initialPrompt.trim()) {
+      yield {
+        session_id: sessionId,
+        type: "user",
+        message: {
+          role: "user",
+          content: initialPrompt
+        },
+        parent_tool_use_id: null
+      };
+    }
     for await (const message of messageQueue) {
       yield message;
     }
@@ -731,12 +1486,17 @@ var WorkerManager = class extends EventEmitter {
     console.log("[WorkerManager] Creating worker client with status MCP server:", {
       workerId: record.id,
       task: record.task,
-      hasMcpServer: !!statusMcpServer
+      hasMcpServer: !!statusMcpServer,
+      worktreePath: record.worktreePath,
+      branchName: record.branchName
     });
-    const client = this.options.createClient({
-      worker_status: statusMcpServer
-    });
-    const workerPrompt = this.wrapPrompt(prompt2);
+    const client = this.options.createClient(
+      {
+        worker_status: statusMcpServer
+      },
+      record.worktreePath
+    );
+    const workerPrompt = this.wrapPrompt(prompt2, record.worktreePath, record.branchName);
     const messageStream = this.createMessageStream(
       workerPrompt,
       record.sessionId,
@@ -744,12 +1504,12 @@ var WorkerManager = class extends EventEmitter {
     );
     const query2 = client.createQuery(messageStream, {
       hooks: {
-        "PostToolUse": [
+        PostToolUse: [
           {
             // No matcher means it applies to all tools (Bash, Read, Write, etc.)
             // If we wanted to only capture Bash results, we could add: matcher: 'Bash'
             hooks: [
-              async (input2, toolUseID, options) => {
+              async (input2, toolUseID) => {
                 if (input2.hook_event_name !== "PostToolUse") {
                   return {};
                 }
@@ -823,7 +1583,6 @@ var WorkerManager = class extends EventEmitter {
       });
       this.emitCompleted(record);
     } finally {
-      record.messageQueue.close();
       this.runningQueries.delete(record.id);
     }
   }
@@ -863,7 +1622,9 @@ var WorkerManager = class extends EventEmitter {
           }
         }
         if (!hasToolUse && !record.messageQueue.isClosed()) {
-          console.log("[WorkerManager] Assistant message without tool use - closing message queue to signal completion");
+          console.log(
+            "[WorkerManager] Assistant message without tool use - closing message queue to signal completion"
+          );
           record.messageQueue.close();
         }
         break;
@@ -954,22 +1715,58 @@ var WorkerManager = class extends EventEmitter {
       return "Unknown worker error";
     }
   }
-  wrapPrompt(userPrompt) {
-    const directive = `
+  wrapPrompt(userPrompt, worktreePath, branchName) {
+    let directive = `
 
 IMPORTANT:
 - Use the mcp__worker_status__send_status_update tool to report progress as you work.
 - When finished, output a final summary.
 - Do not include raw diffs or large file dumps unless explicitly asked.
 `;
+    if (worktreePath && branchName) {
+      directive += `
+WORKTREE ISOLATION:
+- You are working in an isolated git worktree at: ${worktreePath}
+- Your dedicated branch is: ${branchName}
+- 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.
+`;
+    }
     return `${userPrompt.trim()}
 ${directive}`;
   }
+  /**
+   * Shutdown the worker manager and cleanup all resources
+   * This should be called during application shutdown to ensure all worktrees are cleaned up
+   */
+  async shutdown() {
+    logger.info("Shutting down worker manager");
+    const runningWorkers = Array.from(this.workers.values()).filter((w) => w.status === "running");
+    for (const worker of runningWorkers) {
+      logger.info(`Canceling worker ${worker.id} during shutdown`);
+      this.cancelWorker(worker.id);
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+    try {
+      await this.worktreeManager.cleanupAll(true);
+      logger.info("All worktrees cleaned up successfully");
+    } catch (error) {
+      logger.error("Error during worktree cleanup:", error);
+    }
+    logger.info("Worker manager shutdown complete");
+  }
 };
 
 // src/orchestrator/tools/worker-tools.ts
 import { createSdkMcpServer as createSdkMcpServer2, tool as tool2 } from "@anthropic-ai/claude-agent-sdk";
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 function createWorkerMcpServer(workerManager, context) {
   return createSdkMcpServer2({
     name: "worker",
@@ -977,7 +1774,13 @@ function createWorkerMcpServer(workerManager, context) {
     tools: [
       tool2(
         "launch_worker",
-        `Launch a background worker agent to handle tasks autonomously.
+        `Launch a background worker agent to handle tasks autonomously in an isolated git worktree.
+
+Each worker operates in its own git worktree, providing complete isolation:
+- Separate working directory (no shared file changes)
+- Dedicated git branch
+- Independent git operations (staging, committing, etc.)
+- The worker's worktree is automatically cleaned up when the worker completes
 
 When to use this tool:
 - Complex tasks requiring multiple steps or operations
@@ -993,9 +1796,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: 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: z2.string().min(1, "prompt is required"),
-          metadata: z2.record(z2.any()).optional()
+          task: z3.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(
+            "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()
         },
         async (args, extra) => {
           const typedExtra = extra;
@@ -1008,19 +1816,28 @@ Usage notes:
             if (!parentSessionId && toolUseId) {
               parentSessionId = context.resolveSessionIdByToolUse(toolUseId);
             }
-            console.warn("[WorkerTools] Main coding session not available, falling back to SDK resolution:", parentSessionId);
+            console.warn(
+              "[WorkerTools] Main coding session not available, falling back to SDK resolution:",
+              parentSessionId
+            );
           }
           console.log("[WorkerTools] Launching worker:", {
             task: args.task,
             parentSessionId,
-            mainCodingSession: context.getMainCodingSessionId()
-          });
-          const record = workerManager.launchWorker({
-            task: args.task,
-            prompt: args.prompt,
-            originSessionId: parentSessionId,
-            metadata: args.metadata
+            mainCodingSession: context.getMainCodingSessionId(),
+            toolUseId
           });
+          const record = workerManager.launchWorker(
+            {
+              task: args.task,
+              prompt: args.prompt,
+              work_context: args.worktree_name,
+              worktree_name: args.worktree_name,
+              originSessionId: parentSessionId,
+              metadata: args.metadata
+            },
+            toolUseId
+          );
           return {
             content: [
               {
@@ -1028,6 +1845,8 @@ Usage notes:
                 text: JSON.stringify({
                   workerId: record.id,
                   status: record.status,
+                  worktree_path: record.worktreePath,
+                  branch_name: record.branchName,
                   message: `Worker launched successfully, task ${args.task} in progress. You will be notified for progress updates.`
                 })
               }
@@ -1082,12 +1901,30 @@ 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: 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: z2.boolean().default(false).describe("If true, interrupt current generation immediately; if false (default), queue message for next turn")
+          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(
+            "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(
+            "If true, interrupt current generation immediately; if false (default), queue message for next turn"
+          )
         },
-        async (args) => {
-          const success = await workerManager.messageWorker(args.task, args.message, args.interrupt);
+        async (args, extra) => {
+          const typedExtra = extra;
+          const toolUseIdRaw = typedExtra?._meta?.["claudecode/toolUseId"];
+          const toolUseId = typeof toolUseIdRaw === "string" ? toolUseIdRaw : void 0;
+          console.log("[WorkerTools] Messaging worker:", {
+            task: args.task,
+            message: args.message.substring(0, 100),
+            interrupt: args.interrupt,
+            toolUseId
+          });
+          const success = await workerManager.messageWorker(
+            args.task,
+            args.message,
+            args.interrupt,
+            toolUseId
+          );
           if (!success) {
             const worker = workerManager.getWorkerByTask(args.task);
             if (!worker) {
@@ -1134,8 +1971,10 @@ Orchestrator: [message_worker: task="refactor database", message="User wants to
   });
 }
 
-// src/orchestrator/orchestrator-prompt.md
-var orchestrator_prompt_default = '# Role: Task Orchestrator\n\nYou are Omnara, an orchestrator agent responsible for coordinating work through delegation. Your primary job is to DELEGATE implementation work to background worker agents while using read-only task management tools for information gathering.\n\n## Core Principles\n\n**STAY RESPONSIVE - Your Most Important Job**:\n\nThe orchestrator must remain responsive to handle user interactions in a conversational environment. When you execute tool calls or perform work directly, you BLOCK your own context and cannot respond to new user messages.\n\n**Why this matters**:\n- Users need to interact with you conversationally while work is happening\n- Users may want to add new tasks, ask questions, or modify ongoing work\n- Blocking your context means the user has to wait for you to finish before they can interact\n- Workers run in parallel and don\'t block your ability to respond\n\n**Therefore**: Delegate almost everything. Even tasks that seem quick can block you from being responsive. Your job is to stay available for user interaction, not to do work yourself.\n\n**INFORMATION vs ACTION - The Key Distinction**:\n- **INFORMATION**: Use tools directly ONLY for quick lookups (1-2 tool calls max). If unsure, delegate.\n- **ACTION**: ALWAYS delegate to workers for implementation or complex research tasks (Write, Edit, Bash, complex analysis). Track high level todos via TodoWrite.\n\n**MAXIMIZE PARALLELIZATION - Speed Through Concurrency**:\n- Default assumption: Tasks are INDEPENDENT and should run in PARALLEL\n- Only group tasks together if one task absolutely REQUIRES the other\'s output\n- When user requests multiple things \u2192 Launch multiple workers (one per task)\n- More parallel workers = faster completion and better user experience\n- Don\'t make users wait for sequential execution when tasks could run simultaneously\n\n**Your workflow**:\n1. Understand what the user wants\n2. Optionally: Make 1-2 quick tool calls for context IF it helps (prefer skipping this and delegating)\n3. Launch worker(s) with complete context and clear instructions\n4. Return control immediately - stay responsive for user interaction\n\n**When to use tools yourself (RARE)**:\n- Single quick lookup (1-2 tool calls max, < 5 seconds)\n- Answering "what/where/how does X work?" questions IF it\'s a single file or simple pattern\n- If you\'re uncertain or it might take longer: delegate instead\n\n**When to delegate to workers (ALMOST ALWAYS)**:\n- ANY code modification, file writing, or command execution\n- Reading 2+ files or doing any analysis\n- Multi-step research or investigation tasks\n- Running tests, git operations, deployments\n- ANY task that takes more than a few seconds\n- When in doubt: delegate\n\n**Best practices**:\n- **MAXIMIZE PARALLELIZATION**: Launch separate workers for independent tasks - DO NOT group tasks together unless they truly depend on each other\n- **DEFAULT TO PARALLEL**: If tasks CAN run in parallel, they SHOULD run in parallel\n- Delegate liberally - keep your context free and responsive\n- Trust worker outputs - don\'t verify or double-check\n- Use TodoWrite for complex multi-step work (Any sequential worker tasks with 2+ distinct steps)\n- Reference code with `file_path:line_number` format\n\n## Using Your Tools Effectively\n\nYou have read-only tools available: **Read, Grep, Glob, WebFetch, WebSearch, TodoWrite**\n\n**Key tips**:\n- **Stay responsive**: Avoid blocking your context with work - delegate instead of using tools directly\n- **Limit tool use**: If you must use tools, limit to 1-2 calls maximum, then delegate\n- **Code references**: Use `file_path:line_number` format when explaining locations\n- **Prefer delegation**: When in doubt, delegate to a worker to keep your context responsive\n\n## Managing Todos with TodoWrite\n\nUse the TodoWrite tool to track and manage complex tasks. This is CRITICAL for giving users visibility into progress.\n\n### When to Use TodoWrite\n\n**Use TodoWrite for:**\n- Complex multi-step tasks requiring 2+ distinct sequential steps\n- Non-trivial tasks that need careful planning or multiple operations\n- When the user explicitly requests a todo list\n- When users provide multiple tasks (numbered list, comma-separated, etc.)\n- To track progress on ongoing work and give users visibility into what workers are doing\n\n**DO NOT use TodoWrite for:**\n- Single, straightforward tasks\n- Trivial tasks where tracking provides no benefit\n- Tasks completable in less than 2 trivial steps\n- Purely conversational or informational requests\n\n### Todo States\n\nTodos have three states:\n- **pending**: Task not yet started\n- **in_progress**: Currently working on this task (ONLY ONE todo should be in_progress at a time)\n- **completed**: Task finished successfully\n\n### Todo Descriptions\n\nEach todo needs two forms:\n- **content**: Imperative form - what needs to be done (e.g., "Implement authentication", "Run tests")\n- **activeForm**: Present continuous form - shown during execution (e.g., "Implementing authentication", "Running tests")\n\n### Best Practices\n\n**Todo Management**:\n- Update todo status in real-time as work progresses\n- Mark todos complete IMMEDIATELY after finishing (don\'t batch completions)\n- Exactly ONE todo should be in_progress at any time (not less, not more)\n- Complete current todos before starting new ones\n- Remove todos that are no longer relevant from the list entirely\n\n**Todo Completion Requirements**:\n- ONLY mark a todo as completed when you have FULLY accomplished it\n- If workers encounter errors, blockers, or cannot finish, keep the todo as in_progress\n- When blocked, create a new todo describing what needs to be resolved\n- Never mark a todo as completed if:\n  - Workers reported failures or errors\n  - Implementation is partial\n  - Tests are failing\n  - You couldn\'t complete the work for any reason\n\n**Todo Breakdown**:\n- Create specific, actionable items\n- Break complex tasks into smaller, manageable steps\n- Use clear, descriptive todo names\n- Always provide both content and activeForm\n\n### Examples\n\n**Example 1 - Multi-step implementation:**\n```\nUser: "Add authentication with Google OAuth to the API"\n\nYou: [TodoWrite with todos:]\n  1. content: "Research authentication implementation", activeForm: "Researching authentication implementation", status: in_progress\n  2. content: "Implement Google OAuth integration", activeForm: "Implementing Google OAuth integration", status: pending\n  3. content: "Add authentication middleware", activeForm: "Adding authentication middleware", status: pending\n  4. content: "Test authentication flow", activeForm: "Testing authentication flow", status: pending\n\n[Launch worker for step 1]\n... worker completes research ...\n[TodoWrite: mark todo 1 as completed, mark todo 2 as in_progress]\n[Launch worker for step 2]\n... and so on ...\n```\n\n**Example 2 - User provides list:**\n```\nUser: "I need you to: 1) refactor the database layer, 2) add error handling, 3) write tests"\n\nYou: [TodoWrite with todos:]\n  1. content: "Refactor database layer", activeForm: "Refactoring database layer", status: pending\n  2. content: "Add error handling to database layer", activeForm: "Adding error handling", status: pending\n  3. content: "Write tests for database layer", activeForm: "Writing tests", status: pending\n\n[Launch workers for each task - can be parallel or sequential depending on dependencies]\n```\n\n**Example 3 - DO NOT use todos for simple tasks:**\n```\nUser: "What authentication method does the API use?"\n\nYou: [No todos needed - single information lookup]\n     [Launch worker or use Grep to find the answer]\n```\n\n### Todo Lifecycle\n\nWhen using todos with workers:\n1. Create todos before launching workers (gives user visibility)\n2. Mark the corresponding todo as `in_progress` when launching a worker\n3. When worker completes successfully \u2192 mark todo as `completed`\n4. When worker fails or encounters issues \u2192 keep as `in_progress`, possibly add new todo for resolution\n5. Only ONE todo should be `in_progress` at a time\n\n## How You Get Triggered\n\nYou will generate responses in two scenarios:\n\n1. **User sends a message** - Normal user interaction. You should acknowledge and launch workers if needed.\n\n2. **Worker completes** - When a worker finishes (success, error, or cancel), a [WORKER STATUS UPDATE] message is automatically added to the conversation, and you are triggered to generate a response. You should:\n   - Look at the status update message to see ALL worker states\n   - The completed worker is marked with >>> and "JUST COMPLETED"\n   - Provide an INCREMENTAL summary of only the NEW completion\n   - DO NOT re-summarize workers you\'ve already reported on\n\nThink of it like notifications: you\'re "woken up" when something changes, the status update message shows you what changed, and you report the change.\n\n## When to Launch Workers\n\nLaunch workers for ALMOST EVERYTHING to stay responsive:\n\n- **Writing or modifying code** - "Add error handling to the login function" \u2192 Delegate immediately\n- **Running commands or tests** - "Run the test suite and report any failures" \u2192 Delegate immediately\n- **Git operations** - "Create a commit with these changes" \u2192 Delegate immediately\n- **Multi-step implementation tasks** - "Implement a new feature for user notifications" \u2192 Delegate immediately\n- **Complex analysis requiring multiple files** - "Analyze the entire authentication flow" \u2192 Delegate immediately\n- **Complex sequential tasks** - "Research and implement an OAuth provider integration" \u2192 Delegate in sequence\n- **Research tasks** - "Find all API endpoints and document their parameters" \u2192 Delegate immediately\n- **Parallel work** - Launch multiple workers when tasks can happen simultaneously (DEFAULT: tasks are parallel unless proven otherwise)\n- **Independent changes** - "Fix bug X and add feature Y" \u2192 Launch 2 separate workers, don\'t combine\n- **Most questions beyond simple lookups** - "How does the auth system work?" \u2192 Delegate to worker to research\n\n**When launching workers:**\n- **Skip context gathering** - Let the worker handle it. Delegate immediately to stay responsive.\n- **Add a Todo** to track the worker\'s task (use TodoWrite for 2+ sequential steps)\n- **Trust workers** to read files, explore code, and gather their own context\n- **Provide clear instructions** - What to do, what to return, what the goal is\n\n**ONLY use tools directly for:**\n- Single, trivial information requests (1 grep, 1 file read - if truly quick)\n- If you\'re uncertain or it might block you: delegate instead\n\n## When to Message Existing Workers (Resteering)\n\nUse the **message_worker** tool to send additional context or requirements to running workers:\n\n**When to message an existing worker:**\n- User provides clarifications or additions to an in-progress task\n- User adds requirements that logically belong to the current task\n- User provides context that would help the running worker\n- The new request is clearly related to what the worker has been working on and would benefit from shared context\n\n**When to launch a NEW worker instead:**\n- The request is completely unrelated to existing tasks\n- The user explicitly wants a separate task\n- The work would conflict with or duplicate an existing worker\'s goal\n- Clean context would be beneficial to a subsequent task\n\n**Choosing interrupt vs queue:**\n- **interrupt=false (default)**: Queue the message to be delivered after the worker\'s current turn\n  - Use for: Adding requirements, providing context, clarifications\n  - The worker continues current work, then receives your message\n- **interrupt=true**: Stop current work immediately and redirect\n  - Use ONLY when: User explicitly says to stop/interrupt, or the new requirement significantly contradicts the current direction\n  - The worker\'s current generation is stopped and your message is delivered immediately\n\n**After Messaging a Worker:**\n- **DO NOT** use get_workers to check the status after messaging a worker\n- The worker will automatically notify you when it completes (you\'ll be triggered with a [WORKER STATUS UPDATE])\n- Just acknowledge that you sent the message and wait for the completion notification\n\n## How to Delegate Effectively\n\nWhen launching workers, provide:\n\n**Clear, autonomous instructions**: Tell the worker exactly what to do and what information to return. Workers cannot ask you for clarification.\n\n**Complete context**: Include all relevant details the worker needs to complete the task independently. Use Read/Grep/Glob tools first to gather context, then provide it to the worker.\n\n**Expected output format**: Specify what information you need back from the worker.\n\n**Gather context before delegating**: For implementation tasks, use read-only tools first to understand the current state, then provide that context to workers.\n\n**Example excellent delegation (with context gathering)**:\n```\nUser: "Add rate limiting to the API"\n\n1. [Read: src/api/server.ts] - See current API setup\n2. [Grep: pattern="middleware", output_mode="content"] - Check existing middleware\n\n3. launch_worker with prompt: "Add rate limiting middleware to the API. Current setup:\n   - Express server in src/api/server.ts using middleware pattern\n   - Existing middleware: helmet, cors, body-parser\n   - Routes defined in src/api/routes/\n\n   Add rate limiting using express-rate-limit. Apply globally with 100 requests per 15 minutes.\n   Document the configuration in comments."\n```\n\n## Multiple Workers\n\n**CRITICAL: MAXIMIZE PARALLELIZATION**\n\nLaunch workers concurrently whenever possible by calling launch_worker multiple times in a single response. DO NOT group independent tasks into a single worker.\n\n**The Parallelization Rule**:\n- If tasks are independent and don\'t strictly depend on each other\'s results \u2192 Launch SEPARATE workers\n- Only combine tasks into one worker if the second task absolutely REQUIRES the first task\'s output\n- When in doubt, launch separate workers - err on the side of more parallelization\n\n**Examples of PARALLEL tasks** (launch separate workers):\n- "Add logging to the API and update the documentation" \u2192 2 workers (independent changes)\n- "Fix the auth bug and add unit tests" \u2192 2 workers (can test independently)\n- "Refactor component A and refactor component B" \u2192 2 workers (independent refactors)\n- "Update the database schema and update the API endpoints" \u2192 2 workers (likely independent unless explicitly linked)\n- "Check the tests and review the API docs" \u2192 2 workers (completely independent)\n\n**Examples of SEQUENTIAL tasks** (must be one after another):\n- "Research the best logging library, then implement it" \u2192 Worker 1 researches, then Worker 2 implements with that info\n- "Run the tests, then fix any failures found" \u2192 Worker 1 runs tests, then Worker 2 fixes based on results\n- "Analyze the performance bottleneck, then optimize it" \u2192 Worker 1 analyzes, Worker 2 uses those findings\n\n**Good Example** (maximizing parallelization):\n```\nUser: "Add error handling to the API, update the docs, and write tests"\n\nResponse:\n- Launch worker 1: "Add comprehensive error handling to the API"\n- Launch worker 2: "Update documentation to reflect new error handling patterns"\n- Launch worker 3: "Write tests for error handling scenarios"\n```\n\n**Bad Example** (unnecessary grouping):\n```\nUser: "Add error handling to the API, update the docs, and write tests"\n\nResponse:\n- Launch worker 1: "Add error handling, update docs, and write tests"\n  \u274C This is BAD - these are independent tasks that could run in parallel\n```\n\n**Edge Case - Minor Dependencies**: Even if there\'s a soft dependency (e.g., docs should reflect the code), prefer parallel execution. Workers can read the latest code state, so documentation can be written based on the new code even if both workers run simultaneously.\n\n## Worker Status Tracking\n\n**Status in Message History**: When workers complete, a special status update message is added to the conversation history. This message shows:\n- ALL current worker statuses\n- Which worker just completed (marked with >>> and "JUST COMPLETED" note)\n- Which workers are still running\n- **FULL PROGRESS LOG** for completed workers - showing everything the worker did\n\n**CRITICAL: Read the Full Progress Log**\n\nWhen a worker completes, you receive the COMPLETE history of everything it did:\n- All status updates the worker sent\n- All orchestrator messages you sent to the worker (marked with [ORCHESTRATOR MESSAGE])\n- The entire sequence of work from start to finish\n\n**Before creating new workers:**\n1. **CHECK THE PROGRESS LOG** - See what the completed worker actually did\n2. **Look for [ORCHESTRATOR MESSAGE] entries** - These show you already resteered this worker\n3. **DO NOT create duplicate workers** - If you already messaged a worker to do something, it\'s done or in the log\n4. **Trust the progress log** - It shows you the complete picture of what was accomplished\n\n**DO NOT use get_workers tool**: All worker information is already in your conversation history via status update messages. Only use get_workers if you have a specific edge case reason. Specifically:\n- **Never** call get_workers immediately after launching a worker\n- **Never** call get_workers after messaging a worker with message_worker\n- **Never** poll workers - you will be automatically notified when they complete\n\n**Automatic Notifications**: When a worker completes, a status update message is automatically added to the conversation, and you are triggered to generate a response. This happens automatically - you don\'t need to check or poll.\n\n## Your Response Pattern\n\n### When User Makes Initial Request:\n1. **Acknowledge the request** - Briefly confirm what you\'ll do\n2. **Launch worker(s)** - Delegate with clear instructions using meaningful task names\n3. **Inform about tracking** - Let user know workers are running and they\'ll be notified upon completion\n\n### When Workers Complete (Automatic Trigger):\n1. **Check the "Current Worker Status" section** - Review what just completed and what\'s still running\n2. **Identify NEW completions** - Only summarize workers that just finished. DO NOT repeat summaries for workers you already reported on.\n3. **Provide incremental summary** - Report ONLY the new information:\n   - Which worker(s) just completed\n   - Their results (success/error)\n   - Next steps if applicable\n4. **Avoid repetition** - If you\'ve already told the user about a worker\'s completion in a previous message, don\'t mention it again unless directly relevant to a new development\n\n### Incremental Summary Guidelines:\n\n**CRITICAL: DO NOT RE-SUMMARIZE ALREADY-REPORTED COMPLETIONS**\n\nYou will be automatically triggered when workers complete. Each time this happens, you receive a [WORKER STATUS UPDATE] message showing ALL workers (both completed and running). However, you should ONLY report on the worker that JUST completed (marked with >>> and "JUST COMPLETED").\n\n**Rules:**\n- **ONLY report the NEW completion** - The worker marked with >>> in the status update\n- **DO NOT re-explain or re-summarize** previous completions you\'ve already told the user about\n- **DO NOT provide recaps** of what previous workers did unless the user explicitly asks\n- **Keep responses minimal** - Just acknowledge the new completion briefly\n- **Trust your previous summaries** - You already explained things once, don\'t repeat\n\n**Example responses:**\n- **First completion**: "The [task name] worker completed. [Brief 1-2 sentence result summary]"\n- **Second completion**: "The [task name] worker also finished. [Brief result]." \u2190 DO NOT re-mention first worker\n- **Third completion**: "The [task name] worker is done. All tasks complete." \u2190 DO NOT re-mention first two workers\n\n**When ALL workers complete:**\n- If you\'ve been reporting each completion incrementally, just say: "All tasks complete."\n- DO NOT provide a comprehensive summary of everything unless user asks\n\n## Remember\n\n**Your primary goal: STAY RESPONSIVE**\n- Your context must remain unblocked for user interaction\n- Tool calls and work block your ability to respond to users\n- Delegate liberally - it\'s not just good practice, it\'s architecturally required\n- Users need a responsive conversational partner, not a busy worker\n\n**Your role:**\n- You are a COORDINATOR, not an IMPLEMENTER\n- Workers are your hands - you are the brain\n- Delegation is not optional - it\'s required for responsiveness\n- The faster you delegate, the faster work gets done AND the more responsive you stay\n- Never apologize for delegating - it\'s your job and keeps you responsive\n\n**About Worker Status:**\n- ALL worker statuses are in your conversation history via [WORKER STATUS UPDATE] messages\n- The completed worker is marked with >>> and "JUST COMPLETED (triggered this generation)"\n- DO NOT use get_workers tool unless absolutely necessary (you already have the info in message history)\n- You\'ll be automatically triggered when workers complete with a status update message\n\n**About Summaries:**\n- Provide INCREMENTAL summaries - only report NEW completions\n- DO NOT repeat information about workers you already told the user about\n- Focus on what changed since your last message\n- Avoid comprehensive recaps unless explicitly requested\n\n**When in doubt: DELEGATE**. Even if you think you can handle it quickly - delegate to stay responsive.\n';
+// src/orchestrator/orchestrator-prompt.ts
+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
 var WORKER_LAUNCH_TOOL = "mcp__worker__launch_worker";
@@ -1155,15 +1994,17 @@ var AgentOrchestrator = class {
   started = false;
   constructor(dependencies) {
     const resolveSessionIdBySdk = (sdkSessionId) => this.findSessionIdBySdkSession(sdkSessionId);
-    const workerClientFactory = dependencies?.createWorkerClient ?? ((mcpServers) => new AIClient({
+    const workerClientFactory = dependencies?.createWorkerClient ?? ((mcpServers, cwd) => new AIClient({
       defaults: {
         allowedTools: [...BASE_ALLOWED_WORKER_TOOLS, "mcp__worker_status__send_status_update"],
-        mcpServers
+        mcpServers,
+        cwd: cwd || process.cwd()
       }
     }));
     this.workerManager = dependencies?.workerManager ?? new WorkerManager({
       createClient: workerClientFactory,
-      resolveSessionIdBySdk
+      resolveSessionIdBySdk,
+      repoPath: dependencies?.repoPath ?? process.cwd()
     });
     const workerMcpServer = createWorkerMcpServer(this.workerManager, {
       resolveSessionIdBySdk,
@@ -1173,11 +2014,16 @@ var AgentOrchestrator = class {
     });
     const mainClientFactory = dependencies?.createMainClient ?? (() => new AIClient({
       defaults: {
-        allowedTools: [...BASE_ALLOWED_ORCHESTRATOR_TOOLS, WORKER_LAUNCH_TOOL, WORKER_GET_TOOL, WORKER_MESSAGE_TOOL],
+        allowedTools: [
+          ...BASE_ALLOWED_ORCHESTRATOR_TOOLS,
+          WORKER_LAUNCH_TOOL,
+          WORKER_GET_TOOL,
+          WORKER_MESSAGE_TOOL
+        ],
         mcpServers: {
           worker: workerMcpServer
         },
-        systemPrompt: orchestrator_prompt_default
+        systemPrompt: ORCHESTRATOR_SYSTEM_PROMPT
       }
     }));
     this.aiClient = mainClientFactory();
@@ -1247,6 +2093,7 @@ var AgentOrchestrator = class {
     this.started = true;
   }
   async stop() {
+    await this.workerManager.shutdown();
     for (const connection of Array.from(this.clients.values())) {
       this.handleDisconnect(connection);
       try {
@@ -1648,7 +2495,12 @@ var AgentOrchestrator = class {
       metadata,
       messageId: randomUUID3()
     });
-    session.logInbound({ type: "worker_result", workerId: record.id, workerTask: record.task, summary });
+    session.logInbound({
+      type: "worker_result",
+      workerId: record.id,
+      workerTask: record.task,
+      summary
+    });
     session.announceInboundMessage(summary, "worker", record.id, record.task);
     const statusMessage = this.buildWorkerStatusMessage(record.id);
     session.enqueueUserMessage(statusMessage, {
@@ -1744,76 +2596,6 @@ var AgentOrchestrator = class {
   }
 };
 
-// src/auth/credentials-store.ts
-import fs3 from "fs/promises";
-import os2 from "os";
-import path2 from "path";
-var DEFAULT_DIR = path2.join(os2.homedir(), ".omnara");
-var DEFAULT_CREDENTIALS_PATH = path2.join(DEFAULT_DIR, "creds.json");
-var DEFAULT_FILE_MODE = 384;
-var DEFAULT_DIR_MODE = 448;
-function isStoredCredentials(value) {
-  return Boolean(value) && typeof value === "object";
-}
-var CredentialsStore = class {
-  constructor(filePath = DEFAULT_CREDENTIALS_PATH) {
-    this.filePath = filePath;
-  }
-  async load() {
-    try {
-      const raw = await fs3.readFile(this.filePath, "utf8");
-      const parsed = JSON.parse(raw);
-      if (!isStoredCredentials(parsed)) {
-        throw new Error("File does not contain valid credentials data");
-      }
-      return parsed;
-    } catch (error) {
-      if (isFileNotFound(error)) {
-        return null;
-      }
-      throw new Error(
-        `Failed to read credentials from ${this.filePath}: ${extractErrorMessage2(error)}`
-      );
-    }
-  }
-  async save(credentials) {
-    const payload = {
-      accessToken: credentials.accessToken,
-      accessTokenExpiresAt: credentials.accessTokenExpiresAt,
-      refreshToken: credentials.refreshToken,
-      refreshTokenExpiresAt: credentials.refreshTokenExpiresAt
-    };
-    await fs3.mkdir(path2.dirname(this.filePath), { recursive: true, mode: DEFAULT_DIR_MODE });
-    const tempPath = `${this.filePath}.tmp`;
-    const serialized = JSON.stringify(payload, null, 2);
-    await fs3.writeFile(tempPath, serialized, { mode: DEFAULT_FILE_MODE });
-    await fs3.chmod(tempPath, DEFAULT_FILE_MODE);
-    await fs3.rename(tempPath, this.filePath);
-  }
-  async clear() {
-    try {
-      await fs3.unlink(this.filePath);
-    } catch (error) {
-      if (!isFileNotFound(error)) {
-        throw new Error(
-          `Failed to remove credentials file ${this.filePath}: ${extractErrorMessage2(error)}`
-        );
-      }
-    }
-  }
-};
-function isFileNotFound(error) {
-  return Boolean(
-    error && typeof error === "object" && "code" in error && error.code === "ENOENT"
-  );
-}
-function extractErrorMessage2(error) {
-  if (error instanceof Error && error.message) {
-    return error.message;
-  }
-  return String(error);
-}
-
 // src/relay/relay-bridge.ts
 import { randomUUID as randomUUID4 } from "crypto";
 import EventEmitter2 from "events";
@@ -1834,8 +2616,8 @@ var ApiClient = class {
   constructor(options) {
     this.baseUrl = normalizeBaseUrl(options.baseUrl);
   }
-  async getJson(path5, options) {
-    const url = resolveUrl(this.baseUrl, path5);
+  async getJson(path7, options) {
+    const url = resolveUrl(this.baseUrl, path7);
     const headers = this.buildHeaders(options);
     const response = await fetch(url, {
       method: "GET",
@@ -1844,8 +2626,8 @@ var ApiClient = class {
     });
     return await this.handleResponse(response);
   }
-  async postJson(path5, body, options) {
-    const url = resolveUrl(this.baseUrl, path5);
+  async postJson(path7, body, options) {
+    const url = resolveUrl(this.baseUrl, path7);
     const headers = this.buildHeaders(options, { includeJson: true });
     const response = await fetch(url, {
       method: "POST",
@@ -1883,7 +2665,7 @@ var ApiClient = class {
         if (response.ok) {
           throw new ApiError(
             response.status,
-            `Failed to parse JSON response: ${extractErrorMessage3(error)}`
+            `Failed to parse JSON response: ${extractErrorMessage4(error)}`
           );
         }
       }
@@ -1903,12 +2685,12 @@ function normalizeBaseUrl(raw) {
   }
   return raw.endsWith("/") ? raw : `${raw}/`;
 }
-function resolveUrl(base, path5) {
+function resolveUrl(base, path7) {
   const baseUrl = new URL(base);
-  if (!path5.startsWith("/")) {
-    path5 = `/${path5}`;
+  if (!path7.startsWith("/")) {
+    path7 = `/${path7}`;
   }
-  const resolved = new URL(path5, baseUrl);
+  const resolved = new URL(path7, baseUrl);
   return resolved.toString();
 }
 function extractDetail(payload) {
@@ -1931,7 +2713,7 @@ function extractDetail(payload) {
   }
   return null;
 }
-function extractErrorMessage3(error) {
+function extractErrorMessage4(error) {
   if (error instanceof Error) {
     return error.message;
   }
@@ -2212,7 +2994,11 @@ var LoopbackListener = class _LoopbackListener {
     const sessionId = url.searchParams.get("session");
     const state = url.searchParams.get("state");
     if (!code) {
-      this.respond(response, 400, buildMessageHtml("Missing authorization code. Return to your CLI and try again."));
+      this.respond(
+        response,
+        400,
+        buildMessageHtml("Missing authorization code. Return to your CLI and try again.")
+      );
       return;
     }
     this.respond(response, 200, buildSuccessHtml());
@@ -2445,14 +3231,14 @@ function reportLoopbackError(error) {
     );
     return;
   }
-  console.log(`Automatic login failed: ${extractErrorMessage4(error)}`);
+  console.log(`Automatic login failed: ${extractErrorMessage5(error)}`);
 }
 function printSessionInstructions(session) {
   console.log("\nOpen this link in your browser if it did not open automatically:");
   console.log(`  ${session.verificationUriComplete}`);
   console.log("Approve the request, then return to the CLI.");
 }
-function extractErrorMessage4(error) {
+function extractErrorMessage5(error) {
   if (error instanceof Error && error.message) {
     return error.message;
   }
@@ -2475,7 +3261,7 @@ async function waitForLoopback(listener, sessionId, onCode) {
       reportLoopbackError(error);
     }
   } catch (error) {
-    console.log(`Loopback listener error: ${extractErrorMessage4(error)}`);
+    console.log(`Loopback listener error: ${extractErrorMessage5(error)}`);
   }
 }
 
@@ -4423,6 +5209,58 @@ var api_billing_subscription_response_schema_default = {
       ],
       default: null,
       title: "Provider"
+    },
+    plan_display_name: {
+      anyOf: [
+        {
+          type: "string"
+        },
+        {
+          type: "null"
+        }
+      ],
+      default: null,
+      description: "Human-friendly plan label (e.g. Pro, Starter).",
+      title: "Plan Display Name"
+    },
+    plan_price_amount: {
+      anyOf: [
+        {
+          type: "number"
+        },
+        {
+          type: "null"
+        }
+      ],
+      default: null,
+      description: "Recurring charge amount for the plan (in major currency units).",
+      title: "Plan Price Amount"
+    },
+    plan_price_currency: {
+      anyOf: [
+        {
+          type: "string"
+        },
+        {
+          type: "null"
+        }
+      ],
+      default: null,
+      description: "ISO currency for the recurring charge (e.g. usd).",
+      title: "Plan Price Currency"
+    },
+    plan_price_interval: {
+      anyOf: [
+        {
+          type: "string"
+        },
+        {
+          type: "null"
+        }
+      ],
+      default: null,
+      description: "Billing interval for the recurring charge (e.g. month, year).",
+      title: "Plan Price Interval"
     }
   },
   required: [
@@ -4631,6 +5469,77 @@ var api_billing_promo_validation_response_schema_default = {
   type: "object"
 };
 
+// ../shared-js/schemas/api_billing_customer_portal_request.schema.json
+var api_billing_customer_portal_request_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://schemas.omnara.dev/CustomerPortalSessionRequest",
+  title: "CustomerPortalSessionRequest",
+  description: "Request to create a Stripe Billing customer portal session.",
+  properties: {
+    return_url: {
+      anyOf: [
+        {
+          type: "string"
+        },
+        {
+          type: "null"
+        }
+      ],
+      default: null,
+      description: "Where Stripe should send the customer after they leave the portal.",
+      title: "Return Url"
+    }
+  },
+  type: "object"
+};
+
+// ../shared-js/schemas/api_billing_customer_portal_response.schema.json
+var api_billing_customer_portal_response_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://schemas.omnara.dev/CustomerPortalSessionResponse",
+  title: "CustomerPortalSessionResponse",
+  description: "Response containing the Stripe Billing customer portal session URL.",
+  properties: {
+    url: {
+      description: "Hosted Stripe customer portal URL.",
+      title: "Url",
+      type: "string"
+    },
+    created: {
+      anyOf: [
+        {
+          format: "date-time",
+          type: "string"
+        },
+        {
+          type: "null"
+        }
+      ],
+      default: null,
+      description: "Timestamp when the session was created.",
+      title: "Created"
+    },
+    expires_at: {
+      anyOf: [
+        {
+          format: "date-time",
+          type: "string"
+        },
+        {
+          type: "null"
+        }
+      ],
+      default: null,
+      description: "When the portal session expires (if provided by Stripe).",
+      title: "Expires At"
+    }
+  },
+  required: [
+    "url"
+  ],
+  type: "object"
+};
+
 // ../shared-js/schemas/api_settings_notification_request.schema.json
 var api_settings_notification_request_schema_default = {
   $schema: "https://json-schema.org/draft/2020-12/schema",
@@ -4766,6 +5675,8 @@ var validateCreateCheckoutSessionRequest = ajv.compile(api_billing_create_checko
 var validateCheckoutSessionResponse = ajv.compile(api_billing_checkout_response_schema_default);
 var validateValidatePromoCodeRequest = ajv.compile(api_billing_validate_promo_request_schema_default);
 var validatePromoCodeValidationResponse = ajv.compile(api_billing_promo_validation_response_schema_default);
+var validateCustomerPortalSessionRequest = ajv.compile(api_billing_customer_portal_request_schema_default);
+var validateCustomerPortalSessionResponse = ajv.compile(api_billing_customer_portal_response_schema_default);
 var validateUserNotificationSettingsRequest = ajv.compile(api_settings_notification_request_schema_default);
 var validateUserNotificationSettingsResponse = ajv.compile(api_settings_notification_response_schema_default);
 
@@ -4820,7 +5731,7 @@ var RelayBridge = class extends EventEmitter2 {
           break;
         }
         this.logger.error(
-          `Relay connection failed: ${extractErrorMessage5(error)}. Retrying in ${Math.round(backoffMs / 1e3)}s.`
+          `Relay connection failed: ${extractErrorMessage6(error)}. Retrying in ${Math.round(backoffMs / 1e3)}s.`
         );
         await delay(backoffMs);
         backoffMs = Math.min(backoffMs * 2, 3e4);
@@ -4943,7 +5854,7 @@ var RelayBridge = class extends EventEmitter2 {
         target.send(serialized);
         return;
       } catch (error) {
-        this.logger.error(`Failed to send relay frame: ${extractErrorMessage5(error)}`);
+        this.logger.error(`Failed to send relay frame: ${extractErrorMessage6(error)}`);
         if (target === this.ws) {
           this.closeCurrentSocket();
         }
@@ -5002,7 +5913,7 @@ var RelayBridge = class extends EventEmitter2 {
       const text = typeof data === "string" ? data : data.toString("utf8");
       parsed = JSON.parse(text);
     } catch (error) {
-      this.logger.error(`Received invalid JSON from relay: ${extractErrorMessage5(error)}`);
+      this.logger.error(`Received invalid JSON from relay: ${extractErrorMessage6(error)}`);
       return;
     }
     if (this.tryHandleControlMessage(parsed)) {
@@ -5032,6 +5943,8 @@ var RelayBridge = class extends EventEmitter2 {
         }
         return frame;
       }
+      case "user_text":
+        return this.buildUserTextEnvelope(message);
       case "assistant_text":
         return this.buildTextEnvelope(message);
       case "tool_call":
@@ -5177,6 +6090,30 @@ var RelayBridge = class extends EventEmitter2 {
   isTextContent(content) {
     return typeof content.text === "string";
   }
+  buildUserTextEnvelope(message) {
+    const content = {
+      type: "text",
+      text: message.text
+    };
+    const payloadMetadata = message.workerId || message.workerTask ? {
+      worker_id: message.workerId,
+      worker_task: message.workerTask
+    } : void 0;
+    const senderSessionId = message.workerId ?? message.sessionId;
+    const envelope = this.buildEnvelope({
+      sessionId: message.sessionId,
+      senderSessionId,
+      content,
+      payloadMetadata,
+      messageId: message.messageId
+    });
+    envelope.metadata = {
+      ...envelope.metadata,
+      role: "user",
+      transport: "relay"
+    };
+    return envelope;
+  }
   buildTextEnvelope(message) {
     const content = {
       type: "text",
@@ -5344,7 +6281,7 @@ var RelayBridge = class extends EventEmitter2 {
       try {
         this.ws.send(payload);
       } catch (error) {
-        this.logger.error(`Failed to flush relay queue: ${extractErrorMessage5(error)}`);
+        this.logger.error(`Failed to flush relay queue: ${extractErrorMessage6(error)}`);
         this.pendingOutbound.unshift(payload);
         this.closeCurrentSocket();
         break;
@@ -5375,23 +6312,23 @@ var RelayBridge = class extends EventEmitter2 {
     }
   }
 };
-function buildRelayWebsocketUrl(baseUrl, path5) {
+function buildRelayWebsocketUrl(baseUrl, path7) {
   const url = new URL(baseUrl);
   url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
   url.search = "";
   url.hash = "";
-  if (path5.startsWith("/")) {
-    url.pathname = path5;
+  if (path7.startsWith("/")) {
+    url.pathname = path7;
   } else {
     const basePath = url.pathname.endsWith("/") ? url.pathname : `${url.pathname}/`;
-    url.pathname = `${basePath}${path5}`;
+    url.pathname = `${basePath}${path7}`;
   }
   return url.toString();
 }
 function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function extractErrorMessage5(error) {
+function extractErrorMessage6(error) {
   if (error instanceof Error) {
     return error.message;
   }
@@ -5595,13 +6532,17 @@ function handleOutboundMessage(message, onPrompt, onSessionChange, onTurnComplet
   }
   switch (message.type) {
     case "session_created":
-      console.log(`
-${formatSessionPrefix(message.sessionId)} [server] Session created: ${message.sessionId}`);
+      console.log(
+        `
+${formatSessionPrefix(message.sessionId)} [server] Session created: ${message.sessionId}`
+      );
       onSessionChange(message.sessionId);
       break;
     case "session_joined":
-      console.log(`
-${formatSessionPrefix(message.sessionId)} [server] Joined session: ${message.sessionId}`);
+      console.log(
+        `
+${formatSessionPrefix(message.sessionId)} [server] Joined session: ${message.sessionId}`
+      );
       onSessionChange(message.sessionId);
       break;
     case "session_init":
@@ -5679,10 +6620,8 @@ ${formatSessionPrefix(message.sessionId)} [system] ${message.subtype}`);
       }
       break;
     case "error":
-      console.error(
-        `
-${formatSessionPrefix(message.sessionId)} [error] ${message.message}`
-      );
+      console.error(`
+${formatSessionPrefix(message.sessionId)} [error] ${message.message}`);
       onTurnComplete();
       break;
     case "pong":
@@ -5725,7 +6664,7 @@ Commands:
 
 // src/voice/voice-service.ts
 async function launchVoiceForSession(client, accessToken, options) {
-  const path5 = `/api/v1/voice/sessions/${options.sessionId}/launch`;
+  const path7 = `/api/v1/voice/sessions/${options.sessionId}/launch`;
   const requestBody = {};
   if (options.force) {
     requestBody.force = true;
@@ -5734,7 +6673,7 @@ async function launchVoiceForSession(client, accessToken, options) {
     requestBody.room_name = options.roomName;
   }
   const response = await client.postJson(
-    path5,
+    path7,
     requestBody,
     { accessToken }
   );
@@ -5759,278 +6698,52 @@ function checkClaudeCodeInstallation() {
   try {
     execSync("claude --version", {
       stdio: "ignore",
-      encoding: "utf-8"
+      encoding: "utf-8",
+      env: process.env
     });
     return true;
-  } catch (error) {
+  } catch {
     return false;
   }
 }
+function checkAnthropicApiKey() {
+  return !!process.env.ANTHROPIC_API_KEY && process.env.ANTHROPIC_API_KEY.trim().length > 0;
+}
 function displayClaudeCodeWarning() {
-  console.log(chalk.yellow("\nWarning: Claude Code is not installed or not found in PATH"));
-  console.log(chalk.red("\nIMPORTANT: Claude Code is REQUIRED for authentication with your account."));
-  console.log(chalk.white("\nClaude Code provides:"));
-  console.log(chalk.gray("  - AI-powered code assistance"));
-  console.log(chalk.gray("  - Intelligent code completion"));
-  console.log(chalk.gray("  - Natural language to code translation"));
-  console.log(chalk.gray("  - User authentication for API access"));
-  console.log(chalk.white("\nTo install Claude Code:"));
-  console.log(chalk.cyan("  1. Visit: https://claude.ai/download"));
-  console.log(chalk.cyan("  2. Download and install Claude Code for your platform"));
-  console.log(chalk.cyan('  3. Make sure the "claude" command is available in your PATH'));
-  console.log(chalk.yellow("\nNote: Without Claude Code, you cannot authenticate and access"));
-  console.log(chalk.yellow("personalized features that require your user credentials.\n"));
+  console.log(
+    chalk.yellow(
+      "\nWarning: Omnara needs access to the Anthropic API. Omnara didn't detect claude installed, nor did it find a valid API key. If you run into authentication errors, login via `claude login` or pass in an ANTHROPIC_API_KEY as an environment variable.\n"
+    )
+  );
 }
 function performClaudeCodeCheck(options = {}) {
   const { silent = false, exitOnMissing = false } = options;
   if (process.env.OMNARA_SKIP_CLAUDE_CHECK === "true") {
     return true;
   }
-  const isInstalled = checkClaudeCodeInstallation();
-  if (!isInstalled && !silent) {
+  const isClaudeInstalled = checkClaudeCodeInstallation();
+  const hasApiKey = checkAnthropicApiKey();
+  const hasAuthentication = isClaudeInstalled || hasApiKey;
+  if (!hasAuthentication && !silent) {
     displayClaudeCodeWarning();
     if (exitOnMissing) {
-      console.error(chalk.red("Exiting: Claude Code is required for this operation."));
+      console.error(chalk.red("Exiting: Authentication is required for this operation."));
       process.exit(1);
     }
   }
-  return isInstalled;
+  return hasAuthentication;
 }
 function getClaudeCodeVersion() {
   try {
     const version = execSync("claude --version", {
       encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"]
+      stdio: ["ignore", "pipe", "ignore"],
+      env: process.env
     }).trim();
     return version;
-  } catch (error) {
-    return null;
-  }
-}
-
-// src/utils/logger.ts
-import path3 from "path";
-function isProduction() {
-  if (process.env.NODE_ENV === "production") {
-    return true;
-  }
-  try {
-    const currentFile = typeof __filename !== "undefined" ? __filename : "";
-    const isInDist = currentFile.includes(path3.sep + "dist" + path3.sep);
-    if (isInDist && process.env.NODE_ENV !== "development") {
-      return true;
-    }
   } catch {
+    return null;
   }
-  const logLevel = process.env.OMNARA_LOG_LEVEL?.toLowerCase();
-  if (logLevel === "none" || logLevel === "silent") {
-    return true;
-  }
-  return false;
-}
-function getLogLevel() {
-  const envLevel = process.env.OMNARA_LOG_LEVEL?.toLowerCase();
-  switch (envLevel) {
-    case "none":
-    case "silent":
-      return 0 /* NONE */;
-    case "error":
-      return 1 /* ERROR */;
-    case "warn":
-    case "warning":
-      return 2 /* WARN */;
-    case "info":
-      return 3 /* INFO */;
-    case "debug":
-      return 4 /* DEBUG */;
-    case "verbose":
-    case "trace":
-      return 5 /* VERBOSE */;
-    default:
-      return isProduction() ? 1 /* ERROR */ : 3 /* INFO */;
-  }
-}
-var ControlledLogger = class {
-  logLevel;
-  forceOutput;
-  _console;
-  // Console properties we need to implement
-  Console;
-  constructor(options) {
-    this.logLevel = options?.logLevel ?? getLogLevel();
-    this.forceOutput = options?.forceOutput ?? false;
-    this._console = console;
-    this.Console = console.Console;
-  }
-  /**
-   * Standard log output (INFO level)
-   */
-  log(...args) {
-    if (this.shouldLog(3 /* INFO */)) {
-      console.log(...args);
-    }
-  }
-  /**
-   * Error output (always shown unless NONE)
-   */
-  error(...args) {
-    if (this.shouldLog(1 /* ERROR */)) {
-      console.error(...args);
-    }
-  }
-  /**
-   * Warning output
-   */
-  warn(...args) {
-    if (this.shouldLog(2 /* WARN */)) {
-      console.warn(...args);
-    }
-  }
-  /**
-   * Info level output
-   */
-  info(...args) {
-    if (this.shouldLog(3 /* INFO */)) {
-      console.info(...args);
-    }
-  }
-  /**
-   * Debug output (only in development)
-   */
-  debug(...args) {
-    if (this.shouldLog(4 /* DEBUG */)) {
-      console.debug(...args);
-    }
-  }
-  /**
-   * Verbose/trace output
-   */
-  trace(...args) {
-    if (this.shouldLog(5 /* VERBOSE */)) {
-      console.log("[TRACE]", ...args);
-    }
-  }
-  /**
-   * Important messages that should always be shown to user
-   * (authentication status, connection info, etc.)
-   */
-  important(...args) {
-    if (this.logLevel !== 0 /* NONE */ || this.forceOutput) {
-      console.log(...args);
-    }
-  }
-  /**
-   * Success messages that should typically be shown
-   */
-  success(...args) {
-    if (this.shouldLog(2 /* WARN */) || this.forceOutput) {
-      console.log(...args);
-    }
-  }
-  /**
-   * Check if a message should be logged at the given level
-   */
-  shouldLog(level) {
-    return this.forceOutput || this.logLevel >= level;
-  }
-  /**
-   * Update the log level dynamically
-   */
-  setLogLevel(level) {
-    this.logLevel = level;
-  }
-  /**
-   * Get current log level
-   */
-  getLogLevel() {
-    return this.logLevel;
-  }
-  // Console methods we delegate or control based on log level
-  assert(condition, ...data) {
-    if (this.shouldLog(1 /* ERROR */)) {
-      this._console.assert(condition, ...data);
-    }
-  }
-  clear() {
-    this._console.clear();
-  }
-  count(label) {
-    if (this.shouldLog(4 /* DEBUG */)) {
-      this._console.count(label);
-    }
-  }
-  countReset(label) {
-    if (this.shouldLog(4 /* DEBUG */)) {
-      this._console.countReset(label);
-    }
-  }
-  dir(item, options) {
-    if (this.shouldLog(4 /* DEBUG */)) {
-      this._console.dir(item, options);
-    }
-  }
-  dirxml(...data) {
-    if (this.shouldLog(4 /* DEBUG */)) {
-      this._console.dirxml(...data);
-    }
-  }
-  group(...data) {
-    if (this.shouldLog(4 /* DEBUG */)) {
-      this._console.group(...data);
-    }
-  }
-  groupCollapsed(...data) {
-    if (this.shouldLog(4 /* DEBUG */)) {
-      this._console.groupCollapsed(...data);
-    }
-  }
-  groupEnd() {
-    if (this.shouldLog(4 /* DEBUG */)) {
-      this._console.groupEnd();
-    }
-  }
-  table(tabularData, properties) {
-    if (this.shouldLog(3 /* INFO */)) {
-      this._console.table(tabularData, properties);
-    }
-  }
-  time(label) {
-    if (this.shouldLog(4 /* DEBUG */)) {
-      this._console.time(label);
-    }
-  }
-  timeEnd(label) {
-    if (this.shouldLog(4 /* DEBUG */)) {
-      this._console.timeEnd(label);
-    }
-  }
-  timeLog(label, ...data) {
-    if (this.shouldLog(4 /* DEBUG */)) {
-      this._console.timeLog(label, ...data);
-    }
-  }
-  timeStamp(label) {
-    if (this.shouldLog(4 /* DEBUG */)) {
-      this._console.timeStamp(label);
-    }
-  }
-  profile(label) {
-    if (this.shouldLog(4 /* DEBUG */)) {
-      this._console.profile?.(label);
-    }
-  }
-  profileEnd(label) {
-    if (this.shouldLog(4 /* DEBUG */)) {
-      this._console.profileEnd?.(label);
-    }
-  }
-};
-var logger = new ControlledLogger();
-function extractErrorMessage6(error) {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  return String(error);
 }
 
 // src/commands/agent.ts
@@ -6077,7 +6790,7 @@ async function runAgentOrchestrator(options = {}) {
   try {
     await bridge.start();
   } catch (error) {
-    logger.error(`Relay orchestrator terminated: ${extractErrorMessage6(error)}`);
+    logger.error(`Relay orchestrator terminated: ${extractErrorMessage2(error)}`);
     process.exitCode = process.exitCode || 1;
   } finally {
     await stop();
@@ -6162,16 +6875,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, path5) {
+function buildRelayWebsocketUrl2(baseUrl, path7) {
   const url = new URL(baseUrl);
   url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
   url.search = "";
   url.hash = "";
-  if (path5.startsWith("/")) {
-    url.pathname = path5;
+  if (path7.startsWith("/")) {
+    url.pathname = path7;
   } else {
     const basePath = url.pathname.endsWith("/") ? url.pathname : `${url.pathname}/`;
-    url.pathname = `${basePath}${path5}`;
+    url.pathname = `${basePath}${path7}`;
   }
   return url.toString();
 }
@@ -6344,9 +7057,9 @@ function isMainModule() {
   if (!import.meta.url || !process.argv[1]) {
     return false;
   }
-  const executedPath = path4.resolve(process.argv[1]);
+  const executedPath = path6.resolve(process.argv[1]);
   const currentPath = import.meta.url.startsWith("file://") ? decodeURIComponent(import.meta.url.slice(7)) : import.meta.url;
-  return path4.normalize(currentPath) === path4.normalize(executedPath);
+  return path6.normalize(currentPath) === path6.normalize(executedPath);
 }
 if (isMainModule()) {
   run(process.argv).catch((error) => {