@love-moon/conductor-cli 0.2.37 → 0.2.39

package/bin/conductor-fire.js

@@ -53,6 +53,14 @@ export function isLaunchedByDaemon(env = process.env) {
   );
 }
 
+export function syncPwdEnvWithProcessCwdForDaemonLaunch(env = process.env, cwdFn = process.cwd) {
+  if (!isLaunchedByDaemon(env)) {
+    return false;
+  }
+  env.PWD = cwdFn();
+  return true;
+}
+
 const ENABLE_FIRE_LOCAL_LOG = !isLaunchedByDaemon(process.env);
 
 const pkgJson = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, "package.json"), "utf-8"));
@@ -81,6 +89,13 @@ export function shouldRunReconnectRecovery({
   return !runner.shouldSuppressReconnectRecovery();
 }
 
+export function shouldFireReportTaskStatus({ launchedByDaemon = false, phase } = {}) {
+  if (phase === "final") {
+    return true;
+  }
+  return !launchedByDaemon;
+}
+
 // Load allow_cli_list from config file (no defaults - must be configured)
 function loadFireConfigYaml(configFilePath) {
   const home = os.homedir();
@@ -569,7 +584,41 @@ export class FireWatchdog {
   }
 }
 
+export function createPendingRemoteInterruptQueue() {
+  const pending = [];
+
+  return {
+    enqueue(event) {
+      return new Promise((resolve) => {
+        pending.push({ event, resolve });
+      });
+    },
+
+    async flushWith(dispatch) {
+      while (pending.length > 0) {
+        const next = pending.shift();
+        if (!next) {
+          continue;
+        }
+        try {
+          next.resolve(await dispatch(next.event));
+        } catch {
+          next.resolve(false);
+        }
+      }
+    },
+
+    rejectAll() {
+      while (pending.length > 0) {
+        const next = pending.shift();
+        next?.resolve(false);
+      }
+    },
+  };
+}
+
 async function main() {
+  syncPwdEnvWithProcessCwdForDaemonLaunch();
   const cliArgs = await parseCliArgs();
   let runtimeProjectPath = process.cwd();
   let backendSession = null;
@@ -628,6 +677,7 @@ async function main() {
   let reconnectRunner = null;
   let reconnectTaskId = null;
   let pendingRemoteStopEvent = null;
+  const pendingRemoteInterruptQueue = createPendingRemoteInterruptQueue();
   let conductor = null;
   let reconnectResumeInFlight = false;
   let fireShuttingDown = false;
@@ -667,7 +717,7 @@ async function main() {
           source: "conductor-fire",
           metadata: { reconnect: true },
         });
-        if (!launchedByDaemon) {
+        if (shouldFireReportTaskStatus({ launchedByDaemon, phase: "reconnect_running" })) {
           await conductor.sendTaskStatus(reconnectTaskId, {
             status: "RUNNING",
             summary: "conductor fire reconnected",
@@ -697,6 +747,21 @@ async function main() {
     pendingRemoteStopEvent = event;
   };
 
+  const handleInterruptTurnCommand = async (event) => {
+    fireWatchdog.onInbound();
+    if (!event || typeof event !== "object") {
+      return false;
+    }
+    const taskId = typeof event.taskId === "string" ? event.taskId : "";
+    if (reconnectTaskId && taskId && taskId !== reconnectTaskId) {
+      return false;
+    }
+    if (reconnectRunner && typeof reconnectRunner.requestInterruptFromRemote === "function") {
+      return await reconnectRunner.requestInterruptFromRemote(event);
+    }
+    return await pendingRemoteInterruptQueue.enqueue(event);
+  };
+
   if (cliArgs.configFile) {
     env.CONDUCTOR_CONFIG = cliArgs.configFile;
   }
@@ -747,6 +812,7 @@ async function main() {
         fireWatchdog.onPong(event);
       },
       onStopTask: handleStopTaskCommand,
+      onInterruptTurn: handleInterruptTurnCommand,
     });
 
     const taskContext = await ensureTaskContext(conductor, {
@@ -844,6 +910,7 @@ async function main() {
       await runner.requestStopFromRemote(pendingRemoteStopEvent);
       pendingRemoteStopEvent = null;
     }
+    await pendingRemoteInterruptQueue.flushWith((event) => runner.requestInterruptFromRemote(event));
 
     const signals = new AbortController();
     let shutdownSignal = null;
@@ -878,7 +945,7 @@ async function main() {
     process.on("SIGINT", onSigint);
     process.on("SIGTERM", onSigterm);
 
-    if (!launchedByDaemon) {
+    if (shouldFireReportTaskStatus({ launchedByDaemon, phase: "running" })) {
       try {
         await conductor.sendTaskStatus(taskContext.taskId, {
           status: "RUNNING",
@@ -902,7 +969,7 @@ async function main() {
     } finally {
       process.off("SIGINT", onSigint);
       process.off("SIGTERM", onSigterm);
-      if (!launchedByDaemon) {
+      if (shouldFireReportTaskStatus({ launchedByDaemon, phase: "final" })) {
         const remoteStopReason = typeof runner.getRemoteStopReason === "function" ? runner.getRemoteStopReason() : null;
         const remoteStopSummary = typeof runner.getRemoteStopSummary === "function" ? runner.getRemoteStopSummary() : null;
         // When the task was deleted by the user, the DB record is already gone —
@@ -925,10 +992,10 @@ async function main() {
                   status: "KILLED",
                   summary: remoteStopSummary,
                 }
-            : {
-                status: "COMPLETED",
-                summary: "conductor fire exited",
-              };
+              : {
+                  status: "COMPLETED",
+                  summary: "conductor fire exited",
+                };
         if (!taskDeletedByUser) {
           try {
             const statusResult = await conductor.sendTaskStatus(taskContext.taskId, finalStatus);
@@ -957,6 +1024,7 @@ async function main() {
       }
     }
   } finally {
+    pendingRemoteInterruptQueue.rejectAll();
     fireShuttingDown = true;
     fireWatchdog.stop();
     if (backendSession && typeof backendSession.close === "function") {
@@ -1722,6 +1790,9 @@ export class BridgeRunner {
       os.hostname();
     this.needsReconnectRecovery = false;
     this.remoteStopInfo = null;
+    this.remoteInterruptsByReplyTo = new Map();
+    this.pendingInterruptRetryTimers = new Map();
+    this.activeTurnReplyTo = "";
     this.sessionAnnouncementSent = false;
     this.boundSessionId = "";
     this.errorLoop = null;
@@ -1981,6 +2052,200 @@ export class BridgeRunner {
     }
   }
 
+  normalizeReplyTarget(replyTo) {
+    return typeof replyTo === "string" ? replyTo.trim() : "";
+  }
+
+  isTurnInterruptedError(error) {
+    const reason = typeof error?.reason === "string" ? error.reason.trim().toLowerCase() : "";
+    if (reason === "turn_interrupted" || reason === "turn_cancelled") {
+      return true;
+    }
+    const turnStatus = typeof error?.turnStatus === "string" ? error.turnStatus.trim().toLowerCase() : "";
+    if (
+      turnStatus === "interrupted" ||
+      turnStatus === "cancelled" ||
+      turnStatus === "canceled" ||
+      turnStatus === "aborted"
+    ) {
+      return true;
+    }
+    const name = typeof error?.name === "string" ? error.name.trim().toLowerCase() : "";
+    if (name === "aborterror") {
+      return true;
+    }
+    const message = String(error?.message || error || "").toLowerCase();
+    return (
+      message.includes(" interrupted") ||
+      message.includes("interrupt ") ||
+      message.includes("turn interrupted") ||
+      message.includes("cancelled") ||
+      message.includes("canceled") ||
+      message.includes("aborted")
+    );
+  }
+
+  async requestInterruptFromRemote(event = {}) {
+    const taskId = typeof event.taskId === "string" ? event.taskId.trim() : "";
+    if (taskId && taskId !== this.taskId) {
+      return false;
+    }
+    const requestId = typeof event.requestId === "string" ? event.requestId.trim() : "";
+    const reason = typeof event.reason === "string" ? event.reason.trim() : "";
+    const targetReplyTo = this.normalizeReplyTarget(event.targetReplyTo);
+    if (!targetReplyTo) {
+      return false;
+    }
+    if (this.processedMessageIds.has(targetReplyTo)) {
+      this.copilotLog(`ignore late interrupt_turn for processed replyTo=${targetReplyTo}`);
+      return false;
+    }
+
+    const existing = this.remoteInterruptsByReplyTo.get(targetReplyTo) || {};
+    const interruptInfo = {
+      requestId: requestId || existing.requestId || null,
+      reason: reason || existing.reason || "user_interrupt",
+      issued: Boolean(existing.issued),
+    };
+    this.remoteInterruptsByReplyTo.set(targetReplyTo, interruptInfo);
+    log(
+      `Received interrupt_turn for ${this.taskId} replyTo=${targetReplyTo}${
+        interruptInfo.reason ? ` (${interruptInfo.reason})` : ""
+      }`,
+    );
+    return await this.issueInterruptForReplyTarget(targetReplyTo);
+  }
+
+  async issueInterruptForReplyTarget(replyTo) {
+    const normalizedReplyTo = this.normalizeReplyTarget(replyTo);
+    if (!normalizedReplyTo) {
+      return false;
+    }
+    const interruptInfo = this.remoteInterruptsByReplyTo.get(normalizedReplyTo);
+    if (!interruptInfo) {
+      return false;
+    }
+    if (interruptInfo.issued) {
+      return true;
+    }
+    const supportsTurnInterrupt = typeof this.backendSession?.interruptCurrentTurn === "function";
+    const isActiveTarget = this.runningTurn && normalizedReplyTo === this.activeTurnReplyTo;
+    const isInFlightTarget = this.inFlightMessageIds.has(normalizedReplyTo);
+
+    if (!isActiveTarget && isInFlightTarget) {
+      this.copilotLog(`interrupt arrived after replyTo=${normalizedReplyTo} stopped being interruptible`);
+      return false;
+    }
+
+    if (!isActiveTarget) {
+      if (!supportsTurnInterrupt) {
+        log(`Backend session for ${this.taskId} does not support turn interruption`);
+        return false;
+      }
+      this.copilotLog(`queued interrupt request for future replyTo=${normalizedReplyTo}`);
+      return true;
+    }
+
+    if (!supportsTurnInterrupt) {
+      log(`Backend session for ${this.taskId} does not support turn interruption`);
+      return false;
+    }
+    try {
+      const interrupted = await this.backendSession.interruptCurrentTurn();
+      if (interrupted === false) {
+        interruptInfo.issued = false;
+        this.remoteInterruptsByReplyTo.set(normalizedReplyTo, interruptInfo);
+        if (
+          this.runningTurn &&
+          this.activeTurnReplyTo === normalizedReplyTo &&
+          this.inFlightMessageIds.has(normalizedReplyTo)
+        ) {
+          this.copilotLog(`backend interrupt not ready replyTo=${normalizedReplyTo}; retrying`);
+          this.scheduleInterruptRetryForReplyTarget(normalizedReplyTo);
+          return true;
+        }
+        return false;
+      }
+      interruptInfo.issued = true;
+      this.remoteInterruptsByReplyTo.set(normalizedReplyTo, interruptInfo);
+      this.copilotLog(`requested backend interrupt replyTo=${normalizedReplyTo}`);
+      return true;
+    } catch (error) {
+      interruptInfo.issued = false;
+      this.remoteInterruptsByReplyTo.set(normalizedReplyTo, interruptInfo);
+      log(`Failed to interrupt replyTo=${normalizedReplyTo} for ${this.taskId}: ${error?.message || error}`);
+      return false;
+    }
+  }
+
+  scheduleInterruptRetryForReplyTarget(replyTo) {
+    const normalizedReplyTo = this.normalizeReplyTarget(replyTo);
+    if (!normalizedReplyTo || this.pendingInterruptRetryTimers.has(normalizedReplyTo)) {
+      return;
+    }
+
+    const timer = setTimeout(() => {
+      this.pendingInterruptRetryTimers.delete(normalizedReplyTo);
+      const interruptInfo = this.remoteInterruptsByReplyTo.get(normalizedReplyTo);
+      if (
+        !interruptInfo ||
+        interruptInfo.issued ||
+        this.processedMessageIds.has(normalizedReplyTo) ||
+        !this.runningTurn ||
+        this.activeTurnReplyTo !== normalizedReplyTo ||
+        !this.inFlightMessageIds.has(normalizedReplyTo)
+      ) {
+        return;
+      }
+      void this.issueInterruptForReplyTarget(normalizedReplyTo);
+    }, 50);
+    if (typeof timer.unref === "function") {
+      timer.unref();
+    }
+    this.pendingInterruptRetryTimers.set(normalizedReplyTo, timer);
+  }
+
+  clearInterruptRetryForReplyTarget(replyTo) {
+    const normalizedReplyTo = this.normalizeReplyTarget(replyTo);
+    const timer = this.pendingInterruptRetryTimers.get(normalizedReplyTo);
+    if (!timer) {
+      return;
+    }
+    clearTimeout(timer);
+    this.pendingInterruptRetryTimers.delete(normalizedReplyTo);
+  }
+
+  async handleInterruptedTurn(replyTo, interruptInfo) {
+    const normalizedReplyTo = this.normalizeReplyTarget(replyTo);
+    this.clearInterruptRetryForReplyTarget(normalizedReplyTo);
+    this.copilotLog(`turn interrupted replyTo=${normalizedReplyTo || "latest"}`);
+    await this.reportRuntimeStatus(
+      {
+        phase: "interrupted",
+        reply_in_progress: false,
+        status_done_line: "Conversation interrupted",
+      },
+      normalizedReplyTo,
+    );
+    try {
+      await this.conductor.sendMessage(this.taskId, "Conversation interrupted", {
+        backend: this.backendName,
+        reply_to: normalizedReplyTo || undefined,
+        interrupted: true,
+        interruption_request_id: interruptInfo?.requestId || undefined,
+        reason: interruptInfo?.reason || undefined,
+        cli_args: this.cliArgs,
+      });
+    } catch (error) {
+      log(`Failed to send interrupt confirmation for ${this.taskId}: ${error?.message || error}`);
+    }
+    if (normalizedReplyTo) {
+      this.processedMessageIds.add(normalizedReplyTo);
+      this.remoteInterruptsByReplyTo.delete(normalizedReplyTo);
+    }
+    this.resetErrorLoop();
+  }
+
   async recoverAfterReconnect() {
     if (!this.needsReconnectRecovery) {
       return;
@@ -2493,6 +2758,7 @@ export class BridgeRunner {
     }
     this.lastRuntimeStatusSignature = null;
     this.runningTurn = true;
+    this.activeTurnReplyTo = this.normalizeReplyTarget(replyTo);
     const turnStartedAt = Date.now();
     let turnWatchdog = null;
     if (this.isCopilotBackend) {
@@ -2531,12 +2797,15 @@ export class BridgeRunner {
         );
       }
 
-      const result = await this.backendSession.runTurn(content, {
+      const turnPromise = this.backendSession.runTurn(content, {
         useInitialImages,
         onProgress: (payload) => {
           void this.reportRuntimeStatus(payload, replyTo);
         },
       });
+      await this.issueInterruptForReplyTarget(replyTo);
+      const result = await turnPromise;
+      this.activeTurnReplyTo = "";
       this.copilotLog(
         `runTurn completed replyTo=${replyTo || "latest"} elapsedMs=${Date.now() - turnStartedAt} answerLen=${String(
           result.text || "",
@@ -2573,6 +2842,10 @@ export class BridgeRunner {
         });
       }
       await this.syncBackendSessionBinding();
+      if (replyTo) {
+        this.clearInterruptRetryForReplyTarget(replyTo);
+        this.remoteInterruptsByReplyTo.delete(replyTo);
+      }
       if (replyTo) {
         this.processedMessageIds.add(replyTo);
       }
@@ -2591,6 +2864,7 @@ export class BridgeRunner {
         this.copilotLog(`sdk_message sent replyTo=${replyTo || "latest"} responseLen=${responseText.length}`);
       }
     } catch (error) {
+      this.activeTurnReplyTo = "";
       const errorMessage = error instanceof Error ? error.message : String(error);
       if (this.stopped && (this.remoteStopInfo || isSessionClosedError(error))) {
         this.copilotLog(
@@ -2598,6 +2872,11 @@ export class BridgeRunner {
         );
         return;
       }
+      const interruptInfo = replyTo ? this.remoteInterruptsByReplyTo.get(replyTo) : null;
+      if (interruptInfo && this.isTurnInterruptedError(error)) {
+        await this.handleInterruptedTurn(replyTo, interruptInfo);
+        return;
+      }
       if (await this.settleCodexCheckpointUnavailableAfterStream(replyTo, errorMessage)) {
         return;
       }
@@ -2654,7 +2933,9 @@ export class BridgeRunner {
       }
       if (replyTo) {
         this.inFlightMessageIds.delete(replyTo);
+        this.clearInterruptRetryForReplyTarget(replyTo);
       }
+      this.activeTurnReplyTo = "";
       this.copilotLog(
         `turn end replyTo=${replyTo || "latest"} elapsedMs=${Date.now() - turnStartedAt} processedIds=${this.processedMessageIds.size}`,
       );

package/bin/conductor-update.js

@@ -6,13 +6,14 @@
 
 import { fileURLToPath } from "node:url";
 import path from "node:path";
-import { createRequire } from "node:module";
 import fs from "node:fs";
 import { spawn } from "node:child_process";
 import process from "node:process";
 import readline from "node:readline/promises";
 import {
   PACKAGE_NAME,
+  buildUpgradeCommand,
+  resolveInstallMethod,
   fetchLatestVersion,
   isNewerVersion,
   detectPackageManager,
@@ -24,11 +25,14 @@ import {
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const require = createRequire(import.meta.url);
 const PKG_ROOT = path.join(__dirname, "..");
 
 const pkgJson = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, "package.json"), "utf-8"));
 const CURRENT_VERSION = pkgJson.version;
+const INSTALL_METHOD = resolveInstallMethod({
+  env: process.env,
+  packageRoot: PKG_ROOT,
+});
 
 // ANSI 颜色代码
 const COLORS = {
@@ -56,6 +60,13 @@ async function main() {
     process.exit(0);
   }
 
+  if (INSTALL_METHOD === "homebrew") {
+    console.log(colorize("🍺 Homebrew-managed install detected", "cyan"));
+    console.log("");
+    console.log(`   Use ${colorize(buildUpgradeCommand({ env: process.env }), "green")} to upgrade conductor.`);
+    process.exit(0);
+  }
+
   console.log(colorize(`📦 ${PACKAGE_NAME}`, "cyan"));
   console.log(`   Current version: ${CURRENT_VERSION}`);
   console.log("");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.2.37",
-  "gitCommitId": "c656a7d",
+  "version": "0.2.39",
+  "gitCommitId": "30204c8",
   "type": "module",
   "bin": {
     "conductor": "bin/conductor.js"
@@ -18,9 +18,9 @@
   },
   "dependencies": {
     "@love-moon/ai-bridge": "0.1.4",
-    "@love-moon/ai-manager": "0.2.37",
-    "@love-moon/ai-sdk": "0.2.37",
-    "@love-moon/conductor-sdk": "0.2.37",
+    "@love-moon/ai-manager": "0.2.39",
+    "@love-moon/ai-sdk": "0.2.39",
+    "@love-moon/conductor-sdk": "0.2.39",
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.33.0",
     "dotenv": "^16.4.5",

package/src/cli-update-notifier.js

@@ -2,7 +2,7 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
-import { fetchLatestVersion, isNewerVersion } from "./version-check.js";
+import { buildUpgradeCommand, fetchLatestVersion, isNewerVersion } from "./version-check.js";
 
 export const DEFAULT_VERSION_CHECK_INTERVAL_MS = 12 * 60 * 60 * 1000;
 export const DEFAULT_VERSION_NOTIFY_INTERVAL_MS = 24 * 60 * 60 * 1000;
@@ -115,8 +115,13 @@ export function shouldSkipVersionCheck(options = {}) {
   return { skip: false, reason: null };
 }
 
-export function buildUpdateNotice({ currentVersion, latestVersion }) {
-  return `New conductor version available: ${currentVersion} -> ${latestVersion}. Run: conductor update`;
+export function buildUpdateNotice({ currentVersion, latestVersion, installMethod, env }) {
+  const noticeEnv =
+    installMethod && !env?.CONDUCTOR_INSTALL_METHOD
+      ? { ...env, CONDUCTOR_INSTALL_METHOD: installMethod }
+      : env;
+  const upgradeCommand = buildUpgradeCommand({ env: noticeEnv });
+  return `New conductor version available: ${currentVersion} -> ${latestVersion}. Run: ${upgradeCommand}`;
 }
 
 function shouldNotifyVersion({ latestVersion, currentVersion, cache, nowMs, notifyIntervalMs }) {
@@ -147,6 +152,7 @@ export async function maybeCheckForUpdates(options = {}) {
   const env = options.env || process.env;
   const currentVersion = normalizeOptionalString(options.currentVersion);
   const subcommand = normalizeOptionalString(options.subcommand);
+  const installMethod = normalizeOptionalString(env.CONDUCTOR_INSTALL_METHOD);
   const nowMs = options.nowMs ?? Date.now();
   const checkIntervalMs = options.checkIntervalMs ?? DEFAULT_VERSION_CHECK_INTERVAL_MS;
   const notifyIntervalMs = options.notifyIntervalMs ?? DEFAULT_VERSION_NOTIFY_INTERVAL_MS;
@@ -182,7 +188,12 @@ export async function maybeCheckForUpdates(options = {}) {
       nowMs,
       notifyIntervalMs,
     })) {
-      writeNotice(buildUpdateNotice({ currentVersion, latestVersion: cache.latestVersion }));
+      writeNotice(buildUpdateNotice({
+        currentVersion,
+        latestVersion: cache.latestVersion,
+        installMethod,
+        env,
+      }));
       cache = createUpdatedCache(cache, {
         lastNotifiedVersion: cache.latestVersion,
         lastNotifiedAt: new Date(nowMs).toISOString(),
@@ -223,7 +234,12 @@ export async function maybeCheckForUpdates(options = {}) {
     nowMs,
     notifyIntervalMs,
   })) {
-    writeNotice(buildUpdateNotice({ currentVersion, latestVersion: versionToNotify }));
+      writeNotice(buildUpdateNotice({
+        currentVersion,
+        latestVersion: versionToNotify,
+        installMethod,
+        env,
+      }));
     cache = createUpdatedCache(cache, {
       lastNotifiedVersion: versionToNotify,
       lastNotifiedAt: new Date(nowMs).toISOString(),

package/src/daemon.js

@@ -29,12 +29,14 @@ import {
 } from "./runtime-backends.js";
 import {
   PACKAGE_NAME,
+  buildUpgradeCommand,
   fetchLatestVersion,
   isNewerVersion,
   detectPackageManager,
   parseUpdateWindow,
   isInUpdateWindow,
   isManagedInstallPath,
+  resolveInstallMethod,
 } from "./version-check.js";
 import {
   ensurePnpmOnlyBuiltDependencies,
@@ -662,12 +664,22 @@ export function startDaemon(config = {}, deps = {}) {
   const parseUpdateWindowFn = deps.parseUpdateWindow || parseUpdateWindow;
   const isInUpdateWindowFn = deps.isInUpdateWindow || isInUpdateWindow;
   const isManagedInstallPathFn = deps.isManagedInstallPath || isManagedInstallPath;
+  const resolveInstallMethodFn = deps.resolveInstallMethod || resolveInstallMethod;
   const installedPackageRoot = deps.packageRoot || PACKAGE_ROOT;
   const cliVersion = deps.cliVersion || CLI_VERSION;
   const isBackgroundProcess = deps.isBackgroundProcess ?? !process.stdout.isTTY;
   const autoUpdateForceLocal = parseBooleanEnv(process.env.CONDUCTOR_AUTO_UPDATE_FORCE_LOCAL);
+  const installMethod = resolveInstallMethodFn({
+    env: process.env,
+    packageRoot: installedPackageRoot,
+    readFileSync: deps.readFileSync || fs.readFileSync,
+  });
   const autoUpdateSupportedInstall =
-    autoUpdateForceLocal || isManagedInstallPathFn(installedPackageRoot);
+    (installMethod !== "homebrew") &&
+    (autoUpdateForceLocal || isManagedInstallPathFn(installedPackageRoot, {
+      env: process.env,
+      readFileSync: deps.readFileSync || fs.readFileSync,
+    }));
   const skipPidLockCheck = parseBooleanEnv(process.env.CONDUCTOR_TUI_DEBUG);
   const lockHandoffToken =
     normalizeOptionalString(config.LOCK_HANDOFF_TOKEN) ||
@@ -1570,18 +1582,34 @@ export function startDaemon(config = {}, deps = {}) {
     });
 
     if (!AUTO_UPDATE_ENABLED && autoUpdateSupportedInstall === false) {
-      log("[auto-update] Disabled for local/dev install; set CONDUCTOR_AUTO_UPDATE_FORCE_LOCAL=true to override");
+      if (installMethod === "homebrew") {
+        log(`[auto-update] Disabled for Homebrew install; use ${buildUpgradeCommand({ env: process.env })}`);
+      } else {
+        log("[auto-update] Disabled for local/dev install; set CONDUCTOR_AUTO_UPDATE_FORCE_LOCAL=true to override");
+      }
     }
 
-    watchdogTimer = setInterval(() => {
+    const runMaintenanceTick = async () => {
       void runDaemonWatchdog();
-      // Auto-update checks (internally throttled)
-      void checkForUpdate().catch(() => {});
-      void tryAutoUpdate().catch(() => {});
+      try {
+        await checkForUpdate();
+      } catch {
+        // ignore non-critical version check failures
+      }
+      try {
+        await tryAutoUpdate();
+      } catch {
+        // ignore non-critical auto-update failures
+      }
+    };
+
+    watchdogTimer = setInterval(() => {
+      void runMaintenanceTick();
     }, DAEMON_WATCHDOG_INTERVAL_MS);
     if (typeof watchdogTimer?.unref === "function") {
       watchdogTimer.unref();
     }
+    void runMaintenanceTick();
   })();
 
   function markBackendHttpSuccess(at = Date.now()) {
@@ -3808,6 +3836,10 @@ export function startDaemon(config = {}, deps = {}) {
     return true;
   }
 
+  function shouldDaemonReportFireChildTerminalStatus(record) {
+    return !Boolean(record?.managedByFireBridge);
+  }
+
   function handleStopTask(payload) {
     const taskId = payload?.task_id;
     if (!taskId) return;
@@ -4246,6 +4278,7 @@ export function startDaemon(config = {}, deps = {}) {
 
       const env = {
         ...process.env,
+        PWD: taskDir,
         CONDUCTOR_PROJECT_ID: projectId,
         CONDUCTOR_TASK_ID: taskId,
         CONDUCTOR_LAUNCHED_BY_DAEMON: "1",
@@ -4309,6 +4342,7 @@ export function startDaemon(config = {}, deps = {}) {
         projectId,
         logPath,
         stopForceKillTimer: null,
+        managedByFireBridge: true,
       });
 
       client
@@ -4378,7 +4412,7 @@ export function startDaemon(config = {}, deps = {}) {
             ? "completed"
             : `exited with code ${code}`;
 
-        if (!suppressExitStatusReport) {
+        if (!suppressExitStatusReport && shouldDaemonReportFireChildTerminalStatus(active)) {
           client
             .sendJson({
               type: "task_status_update",
@@ -4733,6 +4767,7 @@ export function startDaemon(config = {}, deps = {}) {
       projectId: normalizedProjectId,
       logPath,
       stopForceKillTimer: null,
+      managedByFireBridge: true,
     });
 
     client
@@ -4795,7 +4830,7 @@ export function startDaemon(config = {}, deps = {}) {
           ? "completed"
           : `exited with code ${code}`;
 
-      if (!suppressExitStatusReport) {
+      if (!suppressExitStatusReport && shouldDaemonReportFireChildTerminalStatus(active)) {
         client
           .sendJson({
             type: "task_status_update",
@@ -4835,6 +4870,9 @@ export function startDaemon(config = {}, deps = {}) {
       await Promise.allSettled(
         activeEntries.map(async ([taskId, record]) => {
           suppressedExitStatusReports.add(taskId);
+          if (!shouldDaemonReportFireChildTerminalStatus(record)) {
+            return;
+          }
           try {
             await withTimeout(
               client.sendJson({

package/src/runtime-backends.js

@@ -28,7 +28,7 @@ function appendProviderModulePaths(parts, value) {
   if (!raw) {
     return;
   }
-  for (const item of raw.split(process.platform === "win32" ? ";" : ":")) {
+  for (const item of splitProviderModulePathString(raw)) {
     const normalized = item.trim();
     if (normalized) {
       parts.push(normalized);
@@ -36,6 +36,49 @@ function appendProviderModulePaths(parts, value) {
   }
 }
 
+function looksLikeProviderModulePath(value) {
+  const normalized = String(value || "").trim();
+  if (!normalized) {
+    return false;
+  }
+  return (
+    normalized.startsWith("/") ||
+    normalized.startsWith("./") ||
+    normalized.startsWith("../") ||
+    normalized.startsWith("~/") ||
+    normalized.startsWith("file:") ||
+    normalized.includes("/") ||
+    normalized.includes("\\") ||
+    /\.[cm]?[jt]sx?$/i.test(normalized) ||
+    /^[A-Za-z]:[\\/]/.test(normalized)
+  );
+}
+
+function splitProviderModulePathString(raw) {
+  const normalized = String(raw || "").trim();
+  if (!normalized) {
+    return [];
+  }
+
+  const platformParts = normalized
+    .split(path.delimiter)
+    .map((item) => item.trim())
+    .filter(Boolean);
+  if (platformParts.length > 1 || !normalized.includes(",")) {
+    return platformParts;
+  }
+
+  const commaParts = normalized
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+  if (commaParts.length > 1 && commaParts.every(looksLikeProviderModulePath)) {
+    return commaParts;
+  }
+
+  return platformParts;
+}
+
 function listProviderModulePaths(providerPathEnv) {
   const parts = [];
   appendProviderModulePaths(parts, providerPathEnv);

package/src/version-check.js

@@ -2,14 +2,17 @@
  * Shared version-check utilities used by both `conductor update` and the daemon auto-update flow.
  */
 
+import fs from "node:fs";
 import http from "node:http";
 import https from "node:https";
 import path from "node:path";
 import { execFileSync, execSync } from "node:child_process";
 
 export const PACKAGE_NAME = "@love-moon/conductor-cli";
+export const DEFAULT_HOMEBREW_FORMULA = "lovemoon-ai/tap/conductor";
 const DEFAULT_UPDATE_WINDOW = { startMinutes: 120, endMinutes: 240 };
 const REQUEST_TIMEOUT_MS = 10_000;
+const INSTALL_METHOD_FILENAME = ".install-method";
 
 function resolveTimeoutMs(value) {
   const parsed = Number.parseInt(String(value ?? ""), 10);
@@ -100,6 +103,50 @@ function getRegistryBaseUrl(overrideRegistryUrl) {
   return candidate;
 }
 
+function normalizeInstallMethod(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const normalized = value.trim().toLowerCase();
+  return normalized || null;
+}
+
+export function resolveHomebrewFormula(env = process.env) {
+  const configured = typeof env?.CONDUCTOR_HOMEBREW_FORMULA === "string"
+    ? env.CONDUCTOR_HOMEBREW_FORMULA.trim()
+    : "";
+  return configured || DEFAULT_HOMEBREW_FORMULA;
+}
+
+export function resolveInstallMethod(options = {}) {
+  const env = options.env || process.env;
+  const envMethod = normalizeInstallMethod(env?.CONDUCTOR_INSTALL_METHOD);
+  if (envMethod) {
+    return envMethod;
+  }
+
+  const packageRoot = typeof options.packageRoot === "string" ? options.packageRoot.trim() : "";
+  if (!packageRoot) {
+    return null;
+  }
+
+  const readFileSyncFn = options.readFileSync || fs.readFileSync;
+  const installMethodPath = path.join(path.resolve(packageRoot), INSTALL_METHOD_FILENAME);
+  try {
+    return normalizeInstallMethod(readFileSyncFn(installMethodPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+export function buildUpgradeCommand(options = {}) {
+  const installMethod = resolveInstallMethod(options);
+  if (installMethod === "homebrew") {
+    return `brew upgrade ${resolveHomebrewFormula(options.env || process.env)}`;
+  }
+  return "conductor update";
+}
+
 /**
  * Compare two semver-like version strings.
  * Returns `true` when `latest` is strictly newer than `current`.
@@ -217,7 +264,10 @@ export function parseUpdateWindow(str) {
  * Auto-update should only mutate managed/global installs. Local repo runs and pnpm-linked
  * worktrees are treated as development installs and are skipped by default.
  */
-export function isManagedInstallPath(packageRoot) {
+export function isManagedInstallPath(packageRoot, options = {}) {
+  if (resolveInstallMethod({ ...options, packageRoot }) === "homebrew") {
+    return false;
+  }
   if (typeof packageRoot !== "string" || !packageRoot.trim()) {
     return false;
   }