@love-moon/conductor-cli 0.2.17 → 0.2.18

package/bin/conductor-config.js

@@ -25,11 +25,11 @@ const DEFAULT_CLIs = {
     execArgs: "exec --dangerously-bypass-approvals-and-sandbox --skip-git-repo-check",
     description: "OpenAI Codex CLI"
   },
-  copilot: {
-    command: "copilot",
-    execArgs: "--allow-all-paths --allow-all-tools",
-    description: "GitHub Copilot CLI"
-  },
+  // copilot: {
+  //   command: "copilot",
+  //   execArgs: "--allow-all-paths --allow-all-tools",
+  //   description: "GitHub Copilot CLI"
+  // },
   // gemini: {
   //   command: "gemini",
   //   execArgs: "",
@@ -282,15 +282,15 @@ function checkAlternativeInstallations(command) {
     );
   }
   
-  // 特殊检查：Copilot CLI 可能是 gh copilot 扩展
-  if (command === "copilot" || command === "copilot-chat") {
-    try {
-      execSync("gh copilot --help", { stdio: "pipe", timeout: 5000 });
-      return true;
-    } catch {
-      // gh copilot 未安装
-    }
-  }
+  // // 特殊检查：Copilot CLI 可能是 gh copilot 扩展
+  // if (command === "copilot" || command === "copilot-chat") {
+  //   try {
+  //     execSync("gh copilot --help", { stdio: "pipe", timeout: 5000 });
+  //     return true;
+  //   } catch {
+  //     // gh copilot 未安装
+  //   }
+  // }
   
   // 检查文件是否存在
   for (const checkPath of commonPaths) {

package/bin/conductor-fire.js

@@ -32,6 +32,7 @@ const __dirname = path.dirname(__filename);
 const PKG_ROOT = path.join(__dirname, "..");
 const INITIAL_CLI_PROJECT_PATH = process.cwd();
 const FIRE_LOG_PATH = path.join(INITIAL_CLI_PROJECT_PATH, "conductor.log");
+const FIRE_TASK_MARKER_PREFIX = "active-fire";
 const ENABLE_FIRE_LOCAL_LOG = !process.env.CONDUCTOR_CLI_COMMAND;
 
 const pkgJson = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, "package.json"), "utf-8"));
@@ -303,6 +304,13 @@ async function main() {
       backend: cliArgs.backend,
       daemonName: configuredDaemonName,
     });
+    injectResolvedTaskId(taskContext.taskId);
+    injectResolvedTaskId(taskContext.taskId, env);
+    try {
+      writeFireTaskMarker(taskContext.taskId, runtimeProjectPath);
+    } catch (error) {
+      log(`Note: Could not persist local task marker: ${error.message}`);
+    }
 
     log(
       `Attached to Conductor task ${taskContext.taskId}${
@@ -711,6 +719,73 @@ export function resolveRequestedTaskTitle({
   return resolveTaskTitle(explicit, runtimeProjectPath);
 }
 
+function normalizeTaskId(value) {
+  if (typeof value !== "string") {
+    return "";
+  }
+  return value.trim();
+}
+
+function resolveFireStateDir(workingDirectory = process.cwd()) {
+  const baseDir =
+    typeof workingDirectory === "string" && workingDirectory.trim()
+      ? path.resolve(workingDirectory.trim())
+      : process.cwd();
+  return path.join(baseDir, ".conductor", "state");
+}
+
+export function injectResolvedTaskId(taskId, env = process.env) {
+  const normalizedTaskId = normalizeTaskId(taskId);
+  if (!normalizedTaskId) {
+    return "";
+  }
+  env.CONDUCTOR_TASK_ID = normalizedTaskId;
+  return normalizedTaskId;
+}
+
+export function writeFireTaskMarker(taskId, workingDirectory = process.cwd()) {
+  const normalizedTaskId = normalizeTaskId(taskId);
+  if (!normalizedTaskId) {
+    return "";
+  }
+
+  const stateDir = resolveFireStateDir(workingDirectory);
+  const markerFileName = `${FIRE_TASK_MARKER_PREFIX}.task_${normalizedTaskId}.json`;
+  const markerPath = path.join(stateDir, markerFileName);
+
+  fs.mkdirSync(stateDir, { recursive: true });
+  fs.writeFileSync(
+    markerPath,
+    `${JSON.stringify(
+      {
+        source: "conductor-fire",
+        taskId: normalizedTaskId,
+        cwd: path.resolve(workingDirectory),
+        updatedAt: new Date().toISOString(),
+      },
+      null,
+      2,
+    )}\n`,
+    "utf8",
+  );
+
+  for (const entry of fs.readdirSync(stateDir)) {
+    if (entry === markerFileName) {
+      continue;
+    }
+    if (!entry.startsWith(`${FIRE_TASK_MARKER_PREFIX}.task_`) || !entry.endsWith(".json")) {
+      continue;
+    }
+    try {
+      fs.unlinkSync(path.join(stateDir, entry));
+    } catch {
+      // ignore stale marker cleanup failures
+    }
+  }
+
+  return markerPath;
+}
+
 function normalizeArray(value) {
   if (!value) {
     return [];
@@ -992,6 +1067,7 @@ export class BridgeRunner {
     this.needsReconnectRecovery = false;
     this.remoteStopInfo = null;
     this.sessionAnnouncementSent = false;
+    this.boundSessionId = "";
     this.errorLoop = null;
     this.errorLoopWindowMs = getBoundedEnvInt(
       "CONDUCTOR_ERROR_LOOP_WINDOW_MS",
@@ -1058,16 +1134,11 @@ export class BridgeRunner {
     const message = hasRealSessionId
       ? `${this.backendName} session started: ${sessionId}`
       : `${this.backendName} session started`;
-    if (hasRealSessionId && typeof this.conductor?.bindTaskSession === "function") {
-      try {
-        await this.conductor.bindTaskSession(this.taskId, {
-          session_id: sessionId,
-          session_file_path: sessionFilePath || undefined,
-          backend_type: this.backendName,
-        });
-      } catch (error) {
-        log(`Failed to persist task session binding for ${this.taskId}: ${error?.message || error}`);
-      }
+    if (hasRealSessionId) {
+      await this.persistTaskSessionBinding({
+        sessionId,
+        sessionFilePath,
+      });
     }
     try {
       await this.conductor.sendMessage(this.taskId, message, {
@@ -1101,6 +1172,51 @@ export class BridgeRunner {
     }
   }
 
+  async persistTaskSessionBinding({ sessionId, sessionFilePath } = {}) {
+    const normalizedSessionId = typeof sessionId === "string" ? sessionId.trim() : "";
+    if (!normalizedSessionId || normalizedSessionId === this.boundSessionId) {
+      return false;
+    }
+    if (typeof this.conductor?.bindTaskSession !== "function") {
+      return false;
+    }
+    try {
+      await this.conductor.bindTaskSession(this.taskId, {
+        session_id: normalizedSessionId,
+        session_file_path:
+          typeof sessionFilePath === "string" && sessionFilePath.trim() ? sessionFilePath.trim() : undefined,
+        backend_type: this.backendName,
+      });
+      this.boundSessionId = normalizedSessionId;
+      return true;
+    } catch (error) {
+      log(`Failed to persist task session binding for ${this.taskId}: ${error?.message || error}`);
+      return false;
+    }
+  }
+
+  async syncBackendSessionBinding() {
+    if (!this.backendSession) {
+      return false;
+    }
+    let sessionInfo = null;
+    try {
+      if (typeof this.backendSession.getSessionInfo === "function") {
+        sessionInfo = this.backendSession.getSessionInfo();
+      }
+      if (!sessionInfo && typeof this.backendSession.ensureSessionInfo === "function") {
+        sessionInfo = await this.backendSession.ensureSessionInfo();
+      }
+    } catch (error) {
+      this.copilotLog(`session binding sync skipped: ${sanitizeForLog(error?.message || error, 160)}`);
+      return false;
+    }
+    return this.persistTaskSessionBinding({
+      sessionId: sessionInfo?.sessionId,
+      sessionFilePath: sessionInfo?.sessionFilePath,
+    });
+  }
+
   async start(abortSignal) {
     abortSignal?.addEventListener("abort", () => {
       this.stopped = true;
@@ -1505,6 +1621,11 @@ export class BridgeRunner {
       return;
     }
 
+    await this.persistTaskSessionBinding({
+      sessionId,
+      sessionFilePath,
+    });
+
     logBackendReply(this.backendName, normalizedText, {
       usage: null,
       replyTo: replyTo || "latest",
@@ -1748,6 +1869,7 @@ export class BridgeRunner {
           cli_args: this.cliArgs,
         });
       }
+      await this.syncBackendSessionBinding();
       if (replyTo) {
         this.processedMessageIds.add(replyTo);
       }
@@ -1877,6 +1999,7 @@ export class BridgeRunner {
       } else {
         this.copilotLog("synthetic session_file turn settled");
       }
+      await this.syncBackendSessionBinding();
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       if (this.stopped && (this.remoteStopInfo || isSessionClosedError(error))) {

package/bin/conductor-send-file.js

@@ -0,0 +1,290 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+import yargs from "yargs/yargs";
+import { hideBin } from "yargs/helpers";
+import { ConductorConfig, loadConfig } from "@love-moon/conductor-sdk";
+
+const DEFAULT_MIME_TYPE = "application/octet-stream";
+const DEFAULT_CONFIG_PATH = path.join(os.homedir(), ".conductor", "config.yaml");
+const FIRE_TASK_MARKER_PREFIX = "active-fire";
+
+const EXTENSION_TO_MIME = {
+  ".gif": "image/gif",
+  ".heic": "image/heic",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".json": "application/json",
+  ".mov": "video/quicktime",
+  ".mp3": "audio/mpeg",
+  ".mp4": "video/mp4",
+  ".pdf": "application/pdf",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".txt": "text/plain",
+  ".wav": "audio/wav",
+  ".webm": "video/webm",
+  ".webp": "image/webp",
+};
+
+const isMainModule = (() => {
+  const currentFile = fileURLToPath(import.meta.url);
+  const entryFile = process.argv[1] ? path.resolve(process.argv[1]) : "";
+  return entryFile === currentFile;
+})();
+
+function walkUpDirectories(startDir) {
+  const visited = [];
+  let currentDir = path.resolve(startDir);
+  while (true) {
+    visited.push(currentDir);
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return visited;
+}
+
+function normalizeTaskId(value) {
+  if (typeof value !== "string") {
+    return "";
+  }
+  return value.trim();
+}
+
+function pickLatestTaskIdFromStateDir(stateDir) {
+  if (!fs.existsSync(stateDir)) {
+    return "";
+  }
+
+  const matches = [];
+  for (const entry of fs.readdirSync(stateDir)) {
+    const match = entry.match(new RegExp(`^${FIRE_TASK_MARKER_PREFIX}\\.task_([0-9a-f-]+)\\.json$`, "i"));
+    if (!match) {
+      continue;
+    }
+    const filePath = path.join(stateDir, entry);
+    let mtimeMs = 0;
+    try {
+      mtimeMs = fs.statSync(filePath).mtimeMs;
+    } catch {
+      continue;
+    }
+    matches.push({ taskId: match[1], mtimeMs });
+  }
+
+  if (matches.length === 0) {
+    return "";
+  }
+
+  matches.sort((left, right) => right.mtimeMs - left.mtimeMs);
+  return matches[0].taskId;
+}
+
+export function detectTaskId(options = {}) {
+  const env = options.env || process.env;
+  const cwd = options.cwd || process.cwd();
+
+  const envTaskId = normalizeTaskId(env.CONDUCTOR_TASK_ID);
+  if (envTaskId) {
+    return envTaskId;
+  }
+
+  for (const directory of walkUpDirectories(cwd)) {
+    const stateTaskId = pickLatestTaskIdFromStateDir(path.join(directory, ".conductor", "state"));
+    if (stateTaskId) {
+      return stateTaskId;
+    }
+  }
+
+  return "";
+}
+
+function loadCliConfig(configFile, env = process.env) {
+  const configPath = configFile ? path.resolve(configFile) : DEFAULT_CONFIG_PATH;
+  if (fs.existsSync(configPath)) {
+    return loadConfig(configPath, { env });
+  }
+
+  const agentToken = typeof env.CONDUCTOR_AGENT_TOKEN === "string" ? env.CONDUCTOR_AGENT_TOKEN.trim() : "";
+  const backendUrl = typeof env.CONDUCTOR_BACKEND_URL === "string" ? env.CONDUCTOR_BACKEND_URL.trim() : "";
+  if (agentToken && backendUrl) {
+    return new ConductorConfig({
+      agentToken,
+      backendUrl,
+    });
+  }
+
+  return loadConfig(configPath, { env });
+}
+
+export function guessMimeType(fileName, preferredMimeType = "") {
+  const preferred = typeof preferredMimeType === "string" ? preferredMimeType.trim() : "";
+  if (preferred) {
+    return preferred;
+  }
+  const extension = path.extname(fileName).toLowerCase();
+  return EXTENSION_TO_MIME[extension] || DEFAULT_MIME_TYPE;
+}
+
+function formatErrorBody(text) {
+  const normalized = text.trim();
+  if (!normalized) {
+    return "";
+  }
+  try {
+    const parsed = JSON.parse(normalized);
+    if (parsed && typeof parsed === "object" && typeof parsed.error === "string") {
+      return parsed.error;
+    }
+  } catch {
+    // ignore parse failures
+  }
+  return normalized;
+}
+
+export async function sendFileToTask(options) {
+  const env = options.env || process.env;
+  const cwd = options.cwd || process.cwd();
+  const fetchImpl = options.fetchImpl || global.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new Error("fetch is not available");
+  }
+
+  const taskId = normalizeTaskId(options.taskId) || detectTaskId({ env, cwd });
+  if (!taskId) {
+    throw new Error("Unable to resolve task ID. Pass --task-id or run inside an active Conductor fire workspace.");
+  }
+
+  const config = loadCliConfig(options.configFile, env);
+  const filePath = path.resolve(cwd, String(options.filePath || ""));
+  const stats = await fsp.stat(filePath).catch(() => null);
+  if (!stats || !stats.isFile()) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+
+  const fileBuffer = await fsp.readFile(filePath);
+  const fileName =
+    typeof options.name === "string" && options.name.trim()
+      ? path.basename(options.name.trim())
+      : path.basename(filePath);
+  const mimeType = guessMimeType(fileName, options.mimeType);
+  const body = new FormData();
+  body.set("file", new Blob([fileBuffer], { type: mimeType }), fileName);
+
+  const content = typeof options.content === "string" ? options.content.trim() : "";
+  if (content) {
+    body.set("content", content);
+  }
+
+  const role = typeof options.role === "string" && options.role.trim()
+    ? options.role.trim().toLowerCase()
+    : "sdk";
+  body.set("role", role);
+
+  const url = new URL(`/api/tasks/${encodeURIComponent(taskId)}/attachments`, config.backendUrl);
+  const response = await fetchImpl(String(url), {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${config.agentToken}`,
+      Accept: "application/json",
+    },
+    body,
+  });
+
+  const rawText = await response.text();
+  if (!response.ok) {
+    const details = formatErrorBody(rawText);
+    throw new Error(`Upload failed (${response.status})${details ? `: ${details}` : ""}`);
+  }
+
+  return {
+    taskId,
+    response: rawText ? JSON.parse(rawText) : {},
+  };
+}
+
+export async function main(argvInput = hideBin(process.argv)) {
+  await yargs(argvInput)
+    .scriptName("conductor send-file")
+    .command(
+      "$0 <file>",
+      "Upload a local file into the task session",
+      (command) => command
+        .positional("file", {
+          describe: "Path to the local file to upload into the task session",
+          type: "string",
+          demandOption: true,
+        })
+        .option("task-id", {
+          type: "string",
+          describe: "Explicit Conductor task ID. Defaults to auto-detecting the current task.",
+        })
+        .option("config-file", {
+          type: "string",
+          describe: "Path to Conductor config file",
+        })
+        .option("content", {
+          alias: "m",
+          type: "string",
+          describe: "Optional message text to accompany the uploaded file",
+        })
+        .option("role", {
+          choices: ["sdk", "assistant", "user"],
+          default: "sdk",
+          describe: "Message role to write into the task session",
+        })
+        .option("mime-type", {
+          type: "string",
+          describe: "Override MIME type detection",
+        })
+        .option("name", {
+          type: "string",
+          describe: "Override the filename shown in Conductor",
+        })
+        .option("json", {
+          type: "boolean",
+          default: false,
+          describe: "Print the raw JSON response",
+        }),
+      async (argv) => {
+        const result = await sendFileToTask({
+          filePath: argv.file,
+          taskId: argv.taskId,
+          configFile: argv.configFile,
+          content: argv.content,
+          role: argv.role,
+          mimeType: argv.mimeType,
+          name: argv.name,
+        });
+
+        if (argv.json) {
+          process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+          return;
+        }
+
+        const attachments = Array.isArray(result.response?.attachments) ? result.response.attachments : [];
+        const attachmentNames = attachments.map((attachment) => attachment?.name).filter(Boolean);
+        const summary = attachmentNames.length > 0 ? attachmentNames.join(", ") : path.basename(String(argv.file));
+        process.stdout.write(`Uploaded ${summary} to task ${result.taskId}\n`);
+      },
+    )
+    .help()
+    .strict()
+    .parse();
+}
+
+if (isMainModule) {
+  main().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exit(1);
+  });
+}

package/bin/conductor.js

@@ -9,6 +9,7 @@
  *   config   - Interactive configuration setup
  *   update   - Update the CLI to the latest version
  *   diagnose - Diagnose a task in production/backend
+ *   send-file - Upload a local file into a task session
  */
 
 import { fileURLToPath } from "node:url";
@@ -45,7 +46,7 @@ if (argv[0] === "--version" || argv[0] === "-v") {
 const subcommand = argv[0];
 
 // Valid subcommands
-const validSubcommands = ["fire", "daemon", "config", "update", "diagnose"];
+const validSubcommands = ["fire", "daemon", "config", "update", "diagnose", "send-file"];
 
 if (!validSubcommands.includes(subcommand)) {
   console.error(`Error: Unknown subcommand '${subcommand}'`);
@@ -88,6 +89,7 @@ Subcommands:
   config    Interactive configuration setup
   update    Update the CLI to the latest version
   diagnose  Diagnose a task and print likely root cause
+  send-file Upload a local file into a task session
 
 Options:
   -h, --help     Show this help message
@@ -98,6 +100,7 @@ Examples:
   conductor fire --backend claude -- "add feature"
   conductor daemon --config-file ~/.conductor/config.yaml
   conductor diagnose <task-id>
+  conductor send-file ./screenshot.png
   conductor config
   conductor update
 
@@ -107,6 +110,7 @@ For subcommand-specific help:
   conductor config --help
   conductor update --help
   conductor diagnose --help
+  conductor send-file --help
 
 Version: ${pkgJson.version}
 `);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.2.17",
-  "gitCommitId": "c2654e1",
+  "version": "0.2.18",
+  "gitCommitId": "942418b",
   "type": "module",
   "bin": {
     "conductor": "bin/conductor.js"
@@ -14,11 +14,11 @@
     "access": "public"
   },
   "scripts": {
-    "test": "node --test"
+    "test": "node --test test/*.test.js"
   },
   "dependencies": {
-    "@love-moon/ai-sdk": "0.2.17",
-    "@love-moon/conductor-sdk": "0.2.17",
+    "@love-moon/ai-sdk": "0.2.18",
+    "@love-moon/conductor-sdk": "0.2.18",
     "dotenv": "^16.4.5",
     "enquirer": "^2.4.1",
     "js-yaml": "^4.1.1",

package/src/daemon.js

@@ -230,6 +230,30 @@ export function startDaemon(config = {}, deps = {}) {
     process.env.CONDUCTOR_SHUTDOWN_DISCONNECT_TIMEOUT_MS,
     1000,
   );
+  const DAEMON_WATCHDOG_INTERVAL_MS = parsePositiveInt(
+    process.env.CONDUCTOR_DAEMON_WATCHDOG_INTERVAL_MS,
+    30_000,
+  );
+  const DAEMON_WATCHDOG_STALE_WS_MS = parsePositiveInt(
+    process.env.CONDUCTOR_DAEMON_WATCHDOG_STALE_WS_MS,
+    75_000,
+  );
+  const DAEMON_WATCHDOG_CONNECT_GRACE_MS = parsePositiveInt(
+    process.env.CONDUCTOR_DAEMON_WATCHDOG_CONNECT_GRACE_MS,
+    35_000,
+  );
+  const DAEMON_WATCHDOG_RECONNECT_COOLDOWN_MS = parsePositiveInt(
+    process.env.CONDUCTOR_DAEMON_WATCHDOG_RECONNECT_COOLDOWN_MS,
+    45_000,
+  );
+  const DAEMON_WATCHDOG_HTTP_TIMEOUT_MS = parsePositiveInt(
+    process.env.CONDUCTOR_DAEMON_WATCHDOG_HTTP_TIMEOUT_MS,
+    5_000,
+  );
+  const DAEMON_WATCHDOG_MAX_SELF_HEALS = parsePositiveInt(
+    process.env.CONDUCTOR_DAEMON_WATCHDOG_MAX_SELF_HEALS,
+    3,
+  );
 
   try {
     mkdirSyncFn(WORKSPACE_ROOT, { recursive: true });
@@ -363,19 +387,42 @@ export function startDaemon(config = {}, deps = {}) {
 
   let disconnectedSinceLastConnectedLog = false;
   let didRecoverStaleTasks = false;
+  let daemonShuttingDown = false;
   const activeTaskProcesses = new Map();
   const suppressedExitStatusReports = new Set();
   const seenCommandRequestIds = new Set();
+  let lastConnectedAt = null;
+  let lastPongAt = null;
+  let lastInboundAt = null;
+  let lastSuccessfulHttpAt = null;
+  let lastPresenceCheckAt = null;
+  let lastPresenceConfirmedAt = null;
+  let wsConnected = false;
+  let watchdogLastHealAt = 0;
+  let watchdogHealAttempts = 0;
+  let watchdogProbeInFlight = false;
+  let watchdogLastProbeErrorAt = 0;
+  let watchdogLastPresenceMismatchAt = 0;
+  let watchdogAwaitingHealthySignalAt = null;
+  let watchdogTimer = null;
   const logCollector = createLogCollector(BACKEND_HTTP);
   const client = createWebSocketClient(sdkConfig, {
     extraHeaders: {
       "x-conductor-host": AGENT_NAME,
       "x-conductor-backends": SUPPORTED_BACKENDS.join(","),
     },
-    onConnected: ({ isReconnect } = { isReconnect: false }) => {
+    onConnected: ({ isReconnect, connectedAt } = { isReconnect: false, connectedAt: Date.now() }) => {
+      wsConnected = true;
+      lastConnectedAt = connectedAt || Date.now();
+      lastPongAt = lastPongAt && lastPongAt > lastConnectedAt ? lastPongAt : lastConnectedAt;
       if (!isReconnect || disconnectedSinceLastConnectedLog) {
         log("Connected to backend");
       }
+      if (watchdogHealAttempts > 0) {
+        watchdogAwaitingHealthySignalAt = lastConnectedAt;
+      } else {
+        watchdogAwaitingHealthySignalAt = null;
+      }
       disconnectedSinceLastConnectedLog = false;
       sendAgentResume(isReconnect).catch((error) => {
         logError(`sendAgentResume failed: ${error?.message || error}`);
@@ -391,8 +438,24 @@ export function startDaemon(config = {}, deps = {}) {
         });
       }
     },
-    onDisconnected: () => {
+    onDisconnected: (event = {}) => {
+      wsConnected = false;
       disconnectedSinceLastConnectedLog = true;
+      if (!daemonShuttingDown) {
+        logError(
+          `[daemon-ws] Disconnected from backend: ${formatDisconnectDiagnostics(event)} (${formatDaemonHealthState({
+            connectedAt: lastConnectedAt,
+            lastPongAt,
+            lastInboundAt,
+            lastSuccessfulHttpAt,
+            lastPresenceConfirmedAt,
+          })})`,
+        );
+      }
+    },
+    onPong: ({ at }) => {
+      lastPongAt = at;
+      markWatchdogHealthy("pong", at);
     },
   });
 
@@ -404,6 +467,165 @@ export function startDaemon(config = {}, deps = {}) {
     logError(`Failed to connect: ${err}`);
   });
 
+  watchdogTimer = setInterval(() => {
+    void runDaemonWatchdog();
+  }, DAEMON_WATCHDOG_INTERVAL_MS);
+  if (typeof watchdogTimer?.unref === "function") {
+    watchdogTimer.unref();
+  }
+
+  function markBackendHttpSuccess(at = Date.now()) {
+    lastSuccessfulHttpAt = at;
+  }
+
+  async function probeAgentPresence() {
+    lastPresenceCheckAt = Date.now();
+    try {
+      const response = await withTimeout(
+        fetchFn(`${BACKEND_HTTP}/api/agents`, {
+          method: "GET",
+          headers: {
+            Authorization: `Bearer ${AGENT_TOKEN}`,
+            Accept: "application/json",
+          },
+        }),
+        DAEMON_WATCHDOG_HTTP_TIMEOUT_MS,
+        "daemon agent presence probe",
+      );
+      if (!response.ok) {
+        return {
+          ok: false,
+          status: response.status,
+          error: `HTTP ${response.status}`,
+        };
+      }
+      const at = Date.now();
+      markBackendHttpSuccess(at);
+      const payload = await response.json();
+      const agents = Array.isArray(payload) ? payload : [];
+      const selfOnline = agents.some((entry) => String(entry?.host || "").trim() === AGENT_NAME);
+      if (selfOnline) {
+        lastPresenceConfirmedAt = at;
+      }
+      return {
+        ok: true,
+        selfOnline,
+        agentCount: agents.length,
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        status: null,
+        error: error?.message || String(error),
+      };
+    }
+  }
+
+  function requestWatchdogSelfHeal(reason, extra = {}) {
+    if (daemonShuttingDown || !wsConnected) {
+      return;
+    }
+    const now = Date.now();
+    if (watchdogLastHealAt && now - watchdogLastHealAt < DAEMON_WATCHDOG_RECONNECT_COOLDOWN_MS) {
+      return;
+    }
+    watchdogLastHealAt = now;
+    watchdogHealAttempts += 1;
+    logError(
+      `[watchdog] ${reason}; restarting daemon websocket (${watchdogHealAttempts}/${DAEMON_WATCHDOG_MAX_SELF_HEALS}) ${formatWatchdogExtra(extra)} (${formatDaemonHealthState({
+        connectedAt: lastConnectedAt,
+        lastPongAt,
+        lastInboundAt,
+        lastSuccessfulHttpAt,
+        lastPresenceConfirmedAt,
+      })})`,
+    );
+    if (watchdogHealAttempts > DAEMON_WATCHDOG_MAX_SELF_HEALS) {
+      daemonShuttingDown = true;
+      logError("[watchdog] Self-heal budget exceeded; exiting daemon for supervisor restart");
+      void requestShutdown("watchdog self-heal budget exceeded")
+        .catch((error) => {
+          logError(`watchdog shutdown failed: ${error?.message || error}`);
+        })
+        .finally(() => {
+          cleanupLock();
+          exitFn(1);
+        });
+      return;
+    }
+    watchdogAwaitingHealthySignalAt = null;
+    wsConnected = false;
+    disconnectedSinceLastConnectedLog = true;
+    if (typeof client.forceReconnect === "function") {
+      Promise.resolve(client.forceReconnect(`watchdog:${reason}`)).catch((error) => {
+        logError(`watchdog forceReconnect failed: ${error?.message || error}`);
+      });
+      return;
+    }
+    Promise.resolve(client.disconnect())
+      .catch((error) => {
+        logError(`watchdog disconnect failed: ${error?.message || error}`);
+      })
+      .finally(() => {
+        client.connect().catch((error) => {
+          logError(`watchdog reconnect failed: ${error?.message || error}`);
+        });
+      });
+  }
+
+  async function runDaemonWatchdog() {
+    if (daemonShuttingDown || !wsConnected || watchdogProbeInFlight) {
+      return;
+    }
+    const startedAt = Date.now();
+    if (!lastConnectedAt || startedAt - lastConnectedAt < DAEMON_WATCHDOG_CONNECT_GRACE_MS) {
+      return;
+    }
+    watchdogProbeInFlight = true;
+    try {
+      const probe = await probeAgentPresence();
+      const now = Date.now();
+      const lastWsHealthAt = Math.max(lastPongAt || 0, lastInboundAt || 0, lastConnectedAt || 0);
+      const staleWs = !lastWsHealthAt || now - lastWsHealthAt > DAEMON_WATCHDOG_STALE_WS_MS;
+
+      if (!probe.ok) {
+        if (now - watchdogLastProbeErrorAt >= DAEMON_WATCHDOG_RECONNECT_COOLDOWN_MS) {
+          watchdogLastProbeErrorAt = now;
+          logError(`[watchdog] agent presence probe failed: ${probe.error}`);
+        }
+        if (staleWs) {
+          requestWatchdogSelfHeal("stale_ws_health", {
+            probeAt: lastPresenceCheckAt,
+            probeStatus: probe.status,
+            probeError: probe.error,
+            lastWsHealthAt,
+            staleForMs: now - lastWsHealthAt,
+          });
+        }
+        return;
+      }
+
+      if (!probe.selfOnline && now - watchdogLastPresenceMismatchAt >= DAEMON_WATCHDOG_RECONNECT_COOLDOWN_MS) {
+        watchdogLastPresenceMismatchAt = now;
+        logError(`[watchdog] agent presence probe did not include current host; skipping self-heal to avoid false positives on non-sticky HTTP/WS deployments (${formatWatchdogExtra({
+          agentCount: probe.agentCount,
+          probeAt: lastPresenceCheckAt,
+        })})`);
+      }
+
+      if (staleWs) {
+        requestWatchdogSelfHeal("stale_ws_health", {
+          agentCount: probe.agentCount,
+          lastWsHealthAt,
+          staleForMs: now - lastWsHealthAt,
+          probeAt: lastPresenceCheckAt,
+        });
+      }
+    } finally {
+      watchdogProbeInFlight = false;
+    }
+  }
+
   async function recoverStaleTasks() {
     try {
       const response = await fetchFn(`${BACKEND_HTTP}/api/tasks`, {
@@ -417,6 +639,7 @@ export function startDaemon(config = {}, deps = {}) {
         logError(`Failed to recover stale tasks: HTTP ${response.status}`);
         return;
       }
+      markBackendHttpSuccess();
 
       const tasks = await response.json();
       if (!Array.isArray(tasks) || tasks.length === 0) {
@@ -448,6 +671,8 @@ export function startDaemon(config = {}, deps = {}) {
           });
           if (!patchResp.ok) {
             logError(`Failed to mark stale task ${taskId} as killed: HTTP ${patchResp.status}`);
+          } else {
+            markBackendHttpSuccess();
           }
         }),
       );
@@ -471,6 +696,7 @@ export function startDaemon(config = {}, deps = {}) {
         logError(`Failed to reconcile tasks: HTTP ${response.status}`);
         return;
       }
+      markBackendHttpSuccess();
       const tasks = await response.json();
       if (!Array.isArray(tasks)) {
         return;
@@ -500,6 +726,7 @@ export function startDaemon(config = {}, deps = {}) {
         });
         if (patchResp.ok) {
           killedCount += 1;
+          markBackendHttpSuccess();
         } else {
           logError(`Failed to reconcile stale task ${taskId}: HTTP ${patchResp.status}`);
         }
@@ -555,6 +782,9 @@ export function startDaemon(config = {}, deps = {}) {
   }
 
   function handleEvent(event) {
+    const receivedAt = Date.now();
+    lastInboundAt = receivedAt;
+    markWatchdogHealthy("inbound", receivedAt);
     if (event.type === "error") {
       const payload = event?.payload && typeof event.payload === "object" ? event.payload : {};
       const planLimitMessage = getPlanLimitMessage(payload);
@@ -584,6 +814,26 @@ export function startDaemon(config = {}, deps = {}) {
     }
   }
 
+  function markWatchdogHealthy(signal, at = Date.now()) {
+    if (!watchdogAwaitingHealthySignalAt || watchdogHealAttempts === 0) {
+      return;
+    }
+    if (at < watchdogAwaitingHealthySignalAt) {
+      return;
+    }
+    log(
+      `[watchdog] Backend websocket healthy again after self-heal via ${signal} (${formatDaemonHealthState({
+        connectedAt: lastConnectedAt,
+        lastPongAt,
+        lastInboundAt,
+        lastSuccessfulHttpAt,
+        lastPresenceConfirmedAt,
+      })})`,
+    );
+    watchdogAwaitingHealthySignalAt = null;
+    watchdogHealAttempts = 0;
+  }
+
   async function handleCollectLogs(payload) {
     const requestId = payload?.request_id ? String(payload.request_id).trim() : "";
     const taskId = payload?.task_id ? String(payload.task_id).trim() : "";
@@ -1060,6 +1310,11 @@ export function startDaemon(config = {}, deps = {}) {
     }
 
     closePromise = (async () => {
+      daemonShuttingDown = true;
+      if (watchdogTimer) {
+        clearInterval(watchdogTimer);
+        watchdogTimer = null;
+      }
       const activeEntries = [...activeTaskProcesses.entries()];
       if (activeEntries.length > 0) {
         log(`Shutdown requested (${reason}); stopping ${activeEntries.length} active task(s)`);
@@ -1174,6 +1429,82 @@ function parsePositiveInt(value, fallback) {
   return fallback;
 }
 
+function formatDisconnectDiagnostics(event) {
+  const parts = [];
+  const reason = typeof event?.reason === "string" && event.reason.trim()
+    ? event.reason.trim()
+    : "unknown";
+  parts.push(`reason=${reason}`);
+  if (Number.isFinite(event?.closeCode)) {
+    parts.push(`close_code=${event.closeCode}`);
+  }
+  if (typeof event?.closeReason === "string" && event.closeReason.trim()) {
+    parts.push(`close_reason=${event.closeReason.trim()}`);
+  }
+  if (typeof event?.socketError === "string" && event.socketError.trim()) {
+    parts.push(`socket_error=${event.socketError.trim()}`);
+  }
+  if (Number.isFinite(event?.missedPongs) && event.missedPongs > 0) {
+    parts.push(`missed_pongs=${event.missedPongs}`);
+  }
+  if (Number.isFinite(event?.lastPingAt)) {
+    parts.push(`last_ping_at=${formatIsoTimestamp(event.lastPingAt)}`);
+  }
+  if (Number.isFinite(event?.lastPongAt)) {
+    parts.push(`last_pong_at=${formatIsoTimestamp(event.lastPongAt)}`);
+  }
+  if (Number.isFinite(event?.lastMessageAt)) {
+    parts.push(`last_message_at=${formatIsoTimestamp(event.lastMessageAt)}`);
+  }
+  return parts.join(" ");
+}
+
+function formatDaemonHealthState({
+  connectedAt,
+  lastPongAt,
+  lastInboundAt,
+  lastSuccessfulHttpAt,
+  lastPresenceConfirmedAt,
+}) {
+  return [
+    `connected_at=${formatIsoTimestamp(connectedAt)}`,
+    `last_pong_at=${formatIsoTimestamp(lastPongAt)}`,
+    `last_inbound_at=${formatIsoTimestamp(lastInboundAt)}`,
+    `last_http_ok_at=${formatIsoTimestamp(lastSuccessfulHttpAt)}`,
+    `last_presence_at=${formatIsoTimestamp(lastPresenceConfirmedAt)}`,
+  ].join(" ");
+}
+
+function formatWatchdogExtra(extra) {
+  const parts = [];
+  if (Number.isFinite(extra?.agentCount)) {
+    parts.push(`agent_count=${extra.agentCount}`);
+  }
+  if (Number.isFinite(extra?.probeStatus)) {
+    parts.push(`probe_status=${extra.probeStatus}`);
+  }
+  if (Number.isFinite(extra?.probeAt)) {
+    parts.push(`probe_at=${formatIsoTimestamp(extra.probeAt)}`);
+  }
+  if (typeof extra?.probeError === "string" && extra.probeError.trim()) {
+    parts.push(`probe_error=${extra.probeError.trim()}`);
+  }
+  if (Number.isFinite(extra?.lastWsHealthAt)) {
+    parts.push(`last_ws_health_at=${formatIsoTimestamp(extra.lastWsHealthAt)}`);
+  }
+  if (Number.isFinite(extra?.staleForMs)) {
+    parts.push(`stale_for_ms=${extra.staleForMs}`);
+  }
+  return parts.length ? parts.join(" ") : "no-extra-diagnostics";
+}
+
+function formatIsoTimestamp(value) {
+  if (!Number.isFinite(value)) {
+    return "never";
+  }
+  return new Date(value).toISOString();
+}
+
 async function withTimeout(promise, timeoutMs, label) {
   let timer = null;
   const timeoutPromise = new Promise((_, reject) => {