@love-moon/conductor-cli 0.2.12 → 0.2.13

package/bin/conductor-diagnose.js

@@ -0,0 +1,366 @@
+#!/usr/bin/env node
+
+import process from "node:process";
+import yargs from "yargs/yargs";
+import { hideBin } from "yargs/helpers";
+
+import { loadConfig } from "@love-moon/conductor-sdk";
+
+const CLI_NAME = process.env.CONDUCTOR_CLI_NAME || "conductor diagnose";
+const DEFAULT_TIMEOUT_MS = 8000;
+
+const args = yargs(hideBin(process.argv))
+  .scriptName(CLI_NAME)
+  .usage("Usage: $0 <task-id> [options]")
+  .option("config-file", {
+    type: "string",
+    describe: "Path to Conductor config file",
+  })
+  .option("json", {
+    type: "boolean",
+    default: false,
+    describe: "Print raw JSON output",
+  })
+  .option("timeout-ms", {
+    type: "number",
+    default: DEFAULT_TIMEOUT_MS,
+    describe: "HTTP timeout in milliseconds",
+  })
+  .example("$0 3b3e09b8-6d6f-4f3b-9f2f-3fca86b9e3cb", "Diagnose a task")
+  .example("$0 3b3e09b8-6d6f-4f3b-9f2f-3fca86b9e3cb --json", "Diagnose and print JSON")
+  .demandCommand(1, "task-id is required")
+  .help()
+  .strictOptions()
+  .parse();
+
+const taskId = String(args._[0] || "").trim();
+if (!taskId) {
+  process.stderr.write("task-id is required\n");
+  process.exit(1);
+}
+
+main().catch((error) => {
+  process.stderr.write(`diagnose failed: ${error?.message || error}\n`);
+  process.exit(1);
+});
+
+async function main() {
+  const config = loadConfig(args.configFile);
+  const timeoutMs = normalizePositiveInt(args.timeoutMs, DEFAULT_TIMEOUT_MS);
+  const baseUrl = String(config.backendUrl || "").replace(/\/+$/, "");
+  const endpoint = `${baseUrl}/api/diagnostics/tasks/${encodeURIComponent(taskId)}`;
+
+  const full = await fetchJson(endpoint, config.agentToken, timeoutMs);
+  let report;
+  if (full.ok) {
+    report = {
+      mode: "full",
+      endpoint,
+      payload: full.body,
+    };
+  } else if (full.status === 404) {
+    const fallback = await runFallbackDiagnosis(baseUrl, config.agentToken, taskId, timeoutMs);
+    report = {
+      mode: "fallback",
+      endpoint,
+      payload: fallback,
+      note: "backend does not expose /api/diagnostics/tasks/:taskId yet",
+    };
+  } else {
+    const body = full.body && typeof full.body === "object" ? full.body : null;
+    const msg = body?.error || body?.message || `HTTP ${full.status}`;
+    throw new Error(`diagnostics request failed: ${msg}`);
+  }
+
+  if (args.json) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+    return;
+  }
+
+  printReport(taskId, report);
+}
+
+async function runFallbackDiagnosis(baseUrl, token, taskId, timeoutMs) {
+  const taskResp = await fetchJson(`${baseUrl}/api/tasks/${encodeURIComponent(taskId)}`, token, timeoutMs);
+  if (!taskResp.ok) {
+    throw new Error(`fallback: failed to fetch task (${taskResp.status})`);
+  }
+
+  const msgResp = await fetchJson(
+    `${baseUrl}/api/tasks/${encodeURIComponent(taskId)}/messages`,
+    token,
+    timeoutMs,
+  );
+  if (!msgResp.ok) {
+    throw new Error(`fallback: failed to fetch messages (${msgResp.status})`);
+  }
+
+  const agentsResp = await fetchJson(`${baseUrl}/api/agents`, token, timeoutMs);
+  if (!agentsResp.ok) {
+    throw new Error(`fallback: failed to fetch agents (${agentsResp.status})`);
+  }
+
+  const task = taskResp.body || {};
+  const messages = Array.isArray(msgResp.body) ? msgResp.body : [];
+  const agents = Array.isArray(agentsResp.body) ? agentsResp.body : [];
+
+  const latestUser = messages
+    .filter((m) => normalizeRole(m?.role) === "user")
+    .sort((a, b) => toMs(b?.created_at || b?.createdAt) - toMs(a?.created_at || a?.createdAt))[0] || null;
+  const latestSdk = messages
+    .filter((m) => {
+      const role = normalizeRole(m?.role);
+      return role === "sdk" || role === "assistant";
+    })
+    .sort((a, b) => toMs(b?.created_at || b?.createdAt) - toMs(a?.created_at || a?.createdAt))[0] || null;
+
+  const latestUserMs = toMs(latestUser?.created_at || latestUser?.createdAt);
+  const latestSdkMs = toMs(latestSdk?.created_at || latestSdk?.createdAt);
+  const hasPendingUser = Boolean(latestUser && (!latestSdk || latestUserMs > latestSdkMs));
+  const pendingAgeMs = hasPendingUser && Number.isFinite(latestUserMs) ? Date.now() - latestUserMs : null;
+  const latestSdkFailureKey = detectExecutionFailureLoopKey(latestSdk?.content);
+
+  const assignedHost = cleanText(task?.agent_host || task?.agentHost);
+  const assignedConnected = Boolean(
+    assignedHost && agents.some((agent) => cleanText(agent?.host) === assignedHost),
+  );
+
+  const diagnosis = classifyFallback({
+    taskStatus: normalizeTaskStatus(task?.status),
+    hasPendingUser,
+    pendingAgeMs,
+    latestSdkFailureKey,
+    assignedHost,
+    assignedConnected,
+  });
+
+  return {
+    task: {
+      id: task?.id || taskId,
+      status: normalizeTaskStatus(task?.status),
+      agent_host: assignedHost || null,
+    },
+    messages: {
+      total: messages.length,
+      latest_user: latestUser,
+      latest_sdk: latestSdk,
+      latest_sdk_failure_key: latestSdkFailureKey,
+      has_pending_user: hasPendingUser,
+      pending_age_ms: pendingAgeMs,
+    },
+    realtime: {
+      connected_agents: agents,
+      assigned_host_connected: assignedConnected,
+    },
+    diagnosis,
+  };
+}
+
+function classifyFallback(input) {
+  if (input.taskStatus === "completed" || input.taskStatus === "killed") {
+    return {
+      code: "task_terminal",
+      confidence: "high",
+      summary: `task is already ${input.taskStatus}`,
+      reasons: [`task.status=${input.taskStatus}`],
+      next_actions: [],
+    };
+  }
+
+  if (!input.hasPendingUser) {
+    if (input.latestSdkFailureKey) {
+      return {
+        code: "execution_failure_loop",
+        confidence: "high",
+        summary: "latest sdk message indicates execution-layer failure loop",
+        reasons: [
+          "latest user message is not newer than latest sdk message",
+          `latest sdk failure key=${input.latestSdkFailureKey}`,
+        ],
+        next_actions: [
+          "restart task-scoped fire process and verify PTY child cleanup",
+          "if repeated, create a new task and terminate old stuck task",
+        ],
+      };
+    }
+    return {
+      code: "no_pending_user",
+      confidence: "high",
+      summary: "no pending user message newer than last sdk reply",
+      reasons: ["latest user message is not newer than latest sdk message"],
+      next_actions: [],
+    };
+  }
+
+  if (!input.assignedConnected) {
+    return {
+      code: "likely_ws_or_routing_issue",
+      confidence: "high",
+      summary: "pending user message and assigned agent is offline",
+      reasons: [
+        "latest user message is pending",
+        input.assignedHost ? `assigned host ${input.assignedHost} is not connected` : "task has no assigned host",
+      ],
+      next_actions: [
+        "check fire/daemon websocket reconnect logs",
+        "verify task binding and outbox delivery on backend",
+      ],
+    };
+  }
+
+  if (typeof input.pendingAgeMs === "number" && input.pendingAgeMs > 120000) {
+    return {
+      code: "likely_runturn_stuck",
+      confidence: "medium",
+      summary: "agent is online but pending user message has waited >120s",
+      reasons: [
+        "assigned host is still connected",
+        `pending age ${Math.round(input.pendingAgeMs / 1000)}s`,
+      ],
+      next_actions: [
+        "inspect fire log for repeated turn waiting on same replyTo",
+        "enable CONDUCTOR_TUI_TRACE=1 to confirm driver state progression",
+      ],
+    };
+  }
+
+  return {
+    code: "pending_but_processing",
+    confidence: "low",
+    summary: "pending user message exists but may still be processing",
+    reasons: [
+      "assigned host is connected",
+      typeof input.pendingAgeMs === "number" ? `pending age ${Math.round(input.pendingAgeMs / 1000)}s` : "pending age unknown",
+    ],
+    next_actions: [],
+  };
+}
+
+function printReport(taskId, report) {
+  const payload = report?.payload || {};
+  const diagnosis = payload?.diagnosis || {};
+  const task = payload?.task || {};
+  const realtime = payload?.realtime || {};
+  const messages = payload?.messages || {};
+
+  process.stdout.write(`Task: ${task?.id || taskId}\n`);
+  process.stdout.write(`Mode: ${report.mode}${report.note ? ` (${report.note})` : ""}\n`);
+  process.stdout.write(`Verdict: ${String(diagnosis.code || "unknown")} (${String(diagnosis.confidence || "unknown")})\n`);
+  process.stdout.write(`Summary: ${String(diagnosis.summary || "n/a")}\n`);
+  process.stdout.write("\n");
+  process.stdout.write("Signals:\n");
+  process.stdout.write(`- task.status: ${String(task?.status || "unknown")}\n`);
+  process.stdout.write(`- task.agent_host: ${String(task?.agent_host || task?.agentHost || "n/a")}\n`);
+  process.stdout.write(`- bound_agent_host: ${String(realtime?.bound_agent_host || realtime?.boundAgentHost || "n/a")}\n`);
+  process.stdout.write(
+    `- pending user: ${Boolean(messages?.has_pending_user ?? messages?.hasPendingUser)}${
+      typeof (messages?.pending_age_ms ?? messages?.pendingAgeMs) === "number"
+        ? ` (${Math.round((messages?.pending_age_ms ?? messages?.pendingAgeMs) / 1000)}s)`
+        : ""
+    }\n`,
+  );
+  if (payload?.outbox) {
+    process.stdout.write(`- outbox.available: ${Boolean(payload.outbox.available)}\n`);
+    if (payload.outbox.latest_for_pending_user) {
+      process.stdout.write(
+        `- outbox.latest_for_pending_user: ${String(payload.outbox.latest_for_pending_user.status || "unknown")} (${String(
+          payload.outbox.latest_for_pending_user.last_error || "no_error",
+        )})\n`,
+      );
+    }
+  }
+
+  const reasons = Array.isArray(diagnosis.reasons) ? diagnosis.reasons : [];
+  if (reasons.length > 0) {
+    process.stdout.write("\nReasons:\n");
+    for (const reason of reasons) {
+      process.stdout.write(`- ${reason}\n`);
+    }
+  }
+
+  const nextActions = Array.isArray(diagnosis.next_actions) ? diagnosis.next_actions : [];
+  if (nextActions.length > 0) {
+    process.stdout.write("\nNext Actions:\n");
+    for (const action of nextActions) {
+      process.stdout.write(`- ${action}\n`);
+    }
+  }
+}
+
+async function fetchJson(url, token, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  if (typeof timer.unref === "function") {
+    timer.unref();
+  }
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/json",
+      },
+      signal: controller.signal,
+    });
+    const body = await parseJsonSafe(response);
+    return {
+      ok: response.ok,
+      status: response.status,
+      body,
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function parseJsonSafe(response) {
+  const text = await response.text();
+  if (!text) {
+    return null;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { raw: text };
+  }
+}
+
+function normalizeRole(role) {
+  return cleanText(role).toLowerCase();
+}
+
+function normalizeTaskStatus(status) {
+  const normalized = cleanText(status).toLowerCase();
+  if (normalized === "completed") return "completed";
+  if (normalized === "running") return "running";
+  if (normalized === "killed" || normalized === "failed" || normalized === "cancelled") return "killed";
+  return normalized || "unknown";
+}
+
+function cleanText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function toMs(value) {
+  const ms = Date.parse(String(value || ""));
+  return Number.isFinite(ms) ? ms : NaN;
+}
+
+function detectExecutionFailureLoopKey(value) {
+  const normalized = cleanText(value).toLowerCase();
+  if (!normalized) return null;
+  if (normalized.includes("pty session already spawned")) return "pty_session_already_spawned";
+  if (
+    normalized.includes("tui process has exited") ||
+    normalized.includes("cannot proceed: tui process has exited")
+  ) {
+    return "tui_process_exited";
+  }
+  if (normalized.includes("execution_failure_loop")) return "execution_failure_loop";
+  return null;
+}
+
+function normalizePositiveInt(value, fallback) {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}

package/bin/conductor-fire.js

@@ -103,6 +103,12 @@ const DEFAULT_POLL_INTERVAL_MS = parseInt(
   process.env.CONDUCTOR_CLI_POLL_INTERVAL_MS || process.env.CCODEX_POLL_INTERVAL_MS || "2000",
   10,
 );
+const DEFAULT_TURN_DEADLINE_MS = 12 * 60 * 1000;
+const MIN_TURN_DEADLINE_MS = 30 * 1000;
+const MAX_TURN_DEADLINE_MS = 30 * 60 * 1000;
+const DEFAULT_ERROR_LOOP_WINDOW_MS = 2 * 60 * 1000;
+const DEFAULT_ERROR_LOOP_BACKOFF_MS = 3 * 60 * 1000;
+const DEFAULT_ERROR_LOOP_THRESHOLD = 3;
 
 function appendFireLocalLog(line) {
   if (!ENABLE_FIRE_LOCAL_LOG) {
@@ -1027,6 +1033,39 @@ function sanitizeForLog(value, maxLen = 180) {
   return truncateText(String(value).replace(/\s+/g, " ").trim(), maxLen);
 }
 
+function getBoundedEnvInt(envName, fallback, min, max) {
+  const fallbackNumber = Number(fallback);
+  const normalizedFallback = Number.isFinite(fallbackNumber)
+    ? Math.min(Math.max(Math.round(fallbackNumber), min), max)
+    : min;
+  const raw = process.env[envName];
+  const parsed = Number.parseInt(String(raw ?? ""), 10);
+  if (!Number.isFinite(parsed)) {
+    return normalizedFallback;
+  }
+  return Math.min(Math.max(parsed, min), max);
+}
+
+function normalizeExecutionErrorKey(errorMessage) {
+  const normalized = sanitizeForLog(errorMessage, 280).toLowerCase();
+  if (!normalized) {
+    return "unknown_error";
+  }
+  if (normalized.includes("pty session already spawned")) {
+    return "pty_session_already_spawned";
+  }
+  if (normalized.includes("tui process has exited")) {
+    return "tui_process_exited";
+  }
+  if (normalized.includes("cannot proceed: tui process has exited")) {
+    return "cannot_proceed_tui_exited";
+  }
+  if (normalized.includes("turn exceeded hard deadline")) {
+    return "turn_timeout";
+  }
+  return normalized;
+}
+
 function tailLines(value, count = 6) {
   if (!value) return "";
   const lines = String(value).split(/\r?\n/);
@@ -1045,6 +1084,7 @@ class TuiDriverSession {
     this.sessionId = resumeSessionId || `${backend}-${Date.now()}`;
     this.history = Array.isArray(options.initialHistory) ? [...options.initialHistory] : [];
     this.pendingHistorySeed = this.history.length > 0;
+    this.sessionInfo = null;
 
     const allowCliList = options.configFile ? loadAllowCliList(options.configFile) : DEFAULT_ALLOW_CLI_LIST;
     const cliCommand = CUSTOM_CLI_COMMAND || allowCliList[backend] || backend;
@@ -1066,6 +1106,12 @@ class TuiDriverSession {
     this.closeRequested = false;
     this.closed = false;
     this.closeWaiters = new Set();
+    this.turnDeadlineMs = getBoundedEnvInt(
+      "CONDUCTOR_TURN_DEADLINE_MS",
+      DEFAULT_TURN_DEADLINE_MS,
+      MIN_TURN_DEADLINE_MS,
+      MAX_TURN_DEADLINE_MS,
+    );
 
     const profileName = profileNameForBackend(backend);
     if (!profileName) {
@@ -1129,6 +1175,10 @@ class TuiDriverSession {
       }
       log(`[${this.backend}] [WARN] Please run "${this.command} login" or authenticate manually.`);
     });
+
+    this.driver.on("session", (session) => {
+      this.applySessionInfo(session);
+    });
   }
 
   get threadId() {
@@ -1139,12 +1189,86 @@ class TuiDriverSession {
     return { model: this.backend };
   }
 
+  applySessionInfo(session) {
+    if (!session || typeof session !== "object") {
+      return;
+    }
+    const sessionId = typeof session.sessionId === "string" ? session.sessionId.trim() : "";
+    const sessionFilePath =
+      typeof session.sessionFilePath === "string" ? session.sessionFilePath.trim() : "";
+    if (!sessionId) {
+      return;
+    }
+    this.sessionId = sessionId;
+    this.sessionInfo = {
+      backend: this.backend,
+      sessionId,
+      sessionFilePath: sessionFilePath || undefined,
+    };
+    this.trace(
+      `session id=${sessionId} file="${sanitizeForLog(sessionFilePath, 180)}"`,
+    );
+  }
+
+  getSessionInfo() {
+    if (this.sessionInfo) {
+      return { ...this.sessionInfo };
+    }
+    return null;
+  }
+
+  async ensureSessionInfo() {
+    if (!this.driver) {
+      return null;
+    }
+    try {
+      await this.driver.boot();
+    } catch (error) {
+      this.trace(`session boot failed: ${sanitizeForLog(error?.message || error, 180)}`);
+      return this.getSessionInfo();
+    }
+
+    try {
+      if (typeof this.driver.ensureSessionInfo === "function") {
+        const detected = await this.driver.ensureSessionInfo();
+        this.applySessionInfo(detected);
+      } else if (typeof this.driver.getSessionInfo === "function") {
+        this.applySessionInfo(this.driver.getSessionInfo());
+      }
+    } catch (error) {
+      this.trace(`session detect failed: ${sanitizeForLog(error?.message || error, 180)}`);
+    }
+
+    return this.getSessionInfo();
+  }
+
+  async getSessionUsageSummary() {
+    if (!this.driver || typeof this.driver.getSessionUsageSummary !== "function") {
+      return null;
+    }
+    try {
+      const summary = await this.driver.getSessionUsageSummary();
+      return summary && typeof summary === "object" ? summary : null;
+    } catch (error) {
+      this.trace(`session usage detect failed: ${sanitizeForLog(error?.message || error, 180)}`);
+      return null;
+    }
+  }
+
   createSessionClosedError() {
     const error = new Error("TUI session closed");
     error.reason = "session_closed";
     return error;
   }
 
+  createTurnTimeoutError(timeoutMs) {
+    const seconds = Math.max(1, Math.round(timeoutMs / 1000));
+    const error = new Error(`Turn exceeded hard deadline (${seconds}s)`);
+    error.reason = "turn_timeout";
+    error.timeoutMs = timeoutMs;
+    return error;
+  }
+
   createCloseGuard() {
     if (this.closeRequested) {
       return {
@@ -1169,6 +1293,32 @@ class TuiDriverSession {
     };
   }
 
+  createTurnTimeoutGuard() {
+    if (!Number.isFinite(this.turnDeadlineMs) || this.turnDeadlineMs <= 0) {
+      return {
+        promise: new Promise(() => {}),
+        cleanup: () => {},
+      };
+    }
+    let timer = null;
+    const promise = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        reject(this.createTurnTimeoutError(this.turnDeadlineMs));
+      }, this.turnDeadlineMs);
+      if (typeof timer.unref === "function") {
+        timer.unref();
+      }
+    });
+    return {
+      promise,
+      cleanup: () => {
+        if (timer) {
+          clearTimeout(timer);
+        }
+      },
+    };
+  }
+
   flushCloseWaiters() {
     if (!this.closeWaiters || this.closeWaiters.size === 0) {
       return;
@@ -1364,9 +1514,10 @@ class TuiDriverSession {
       }
     }
     const closeGuard = this.createCloseGuard();
+    const turnTimeoutGuard = this.createTurnTimeoutGuard();
 
     try {
-      const result = await Promise.race([this.driver.ask(effectivePrompt), closeGuard.promise]);
+      const result = await Promise.race([this.driver.ask(effectivePrompt), closeGuard.promise, turnTimeoutGuard.promise]);
       const answer = String(result.answer || result.replyText || "").trim();
       this.trace(
         `runTurn finished success=${Boolean(result.success)} elapsedMs=${result.elapsedMs} answerLen=${answer.length} state=${this.driver.state}`,
@@ -1415,8 +1566,23 @@ class TuiDriverSession {
         throw error instanceof Error ? error : new Error(errorMessage);
       }
 
-      // 特殊处理登录和权限错误
-      if (errorReason === "login_required") {
+      if (errorReason === "turn_timeout") {
+        this.emitProgress(onProgress, {
+          state: "ERROR",
+          phase: "timeout_recovered",
+          source: "tui-driver",
+          error: errorMessage,
+          reason: errorReason,
+          timeout_ms: error?.timeoutMs,
+        });
+        log(`[${this.backend}] Turn timed out (${error?.timeoutMs || this.turnDeadlineMs}ms), restarting TUI session`);
+        try {
+          await this.driver.forceRestart();
+        } catch (restartError) {
+          log(`[${this.backend}] Failed to restart TUI after timeout: ${restartError?.message || restartError}`);
+        }
+        log(`[${this.backend}] Error: ${errorMessage}`);
+      } else if (errorReason === "login_required") {
         this.emitProgress(onProgress, {
           state: "ERROR",
           phase: "login_required",
@@ -1469,6 +1635,7 @@ class TuiDriverSession {
       }
       clearInterval(signalTimer);
       this.driver.off("stateChange", handleStateChange);
+      turnTimeoutGuard.cleanup();
       closeGuard.cleanup();
       this.trace(`runTurn cleanup state=${this.driver.state}`);
     }
@@ -1503,10 +1670,45 @@ export class BridgeRunner {
     this.stopped = false;
     this.runningTurn = false;
     this.processedMessageIds = new Set();
+    this.inFlightMessageIds = new Set();
     this.lastRuntimeStatusSignature = null;
     this.lastRuntimeStatusPayload = null;
+    this.runtimeContextSnapshot = null;
+    this.runtimeContextSnapshotAt = 0;
+    this.runtimeContextInFlight = null;
+    this.runtimeContextRefreshMs = getBoundedEnvInt(
+      "CONDUCTOR_RUNTIME_CONTEXT_REFRESH_MS",
+      2000,
+      500,
+      60 * 1000,
+    );
+    this.daemonName =
+      (typeof process.env.CONDUCTOR_AGENT_NAME === "string" && process.env.CONDUCTOR_AGENT_NAME.trim()) ||
+      (typeof process.env.CONDUCTOR_DAEMON_NAME === "string" && process.env.CONDUCTOR_DAEMON_NAME.trim()) ||
+      (typeof process.env.HOSTNAME === "string" && process.env.HOSTNAME.trim()) ||
+      os.hostname();
     this.needsReconnectRecovery = false;
     this.remoteStopInfo = null;
+    this.sessionAnnouncementSent = false;
+    this.errorLoop = null;
+    this.errorLoopWindowMs = getBoundedEnvInt(
+      "CONDUCTOR_ERROR_LOOP_WINDOW_MS",
+      DEFAULT_ERROR_LOOP_WINDOW_MS,
+      15 * 1000,
+      30 * 60 * 1000,
+    );
+    this.errorLoopBackoffMs = getBoundedEnvInt(
+      "CONDUCTOR_ERROR_LOOP_BACKOFF_MS",
+      DEFAULT_ERROR_LOOP_BACKOFF_MS,
+      15 * 1000,
+      60 * 60 * 1000,
+    );
+    this.errorLoopThreshold = getBoundedEnvInt(
+      "CONDUCTOR_ERROR_LOOP_THRESHOLD",
+      DEFAULT_ERROR_LOOP_THRESHOLD,
+      2,
+      20,
+    );
   }
 
   copilotLog(message) {
@@ -1516,6 +1718,54 @@ export class BridgeRunner {
     log(`[copilot-debug] task=${this.taskId} ${message}`);
   }
 
+  async announceBackendSession() {
+    if (this.sessionAnnouncementSent) {
+      return;
+    }
+    if (!this.backendSession || typeof this.backendSession.ensureSessionInfo !== "function") {
+      return;
+    }
+    let sessionInfo = null;
+    try {
+      sessionInfo = await this.backendSession.ensureSessionInfo();
+    } catch (error) {
+      this.copilotLog(`session announce skipped: ${sanitizeForLog(error?.message || error, 160)}`);
+      return;
+    }
+    const sessionId = String(sessionInfo?.sessionId || "").trim();
+    const sessionFilePath = sessionInfo?.sessionFilePath ? String(sessionInfo.sessionFilePath).trim() : "";
+    const hasRealSessionId = Boolean(sessionId);
+    const message = hasRealSessionId
+      ? `${this.backendName} session started: ${sessionId}`
+      : `${this.backendName} session started`;
+    try {
+      await this.conductor.sendMessage(this.taskId, message, {
+        backend: this.backendName,
+        thread_id: hasRealSessionId ? sessionId : undefined,
+        session_id: hasRealSessionId ? sessionId : undefined,
+        session_file_path: sessionFilePath || undefined,
+        cli_args: this.cliArgs,
+        synthetic: true,
+      });
+      this.sessionAnnouncementSent = true;
+      this.copilotLog(hasRealSessionId ? `session announced id=${sessionId}` : "session announced without id");
+      await this.reportRuntimeStatus(
+        {
+          state: "WAIT_READY",
+          phase: "session_started",
+          source: "tui-driver",
+          reply_in_progress: false,
+          status_done_line: `${this.backendName} session started`,
+          backend: this.backendName,
+          thread_id: hasRealSessionId ? sessionId : undefined,
+        },
+        undefined,
+      );
+    } catch (error) {
+      log(`Failed to send session announcement: ${error?.message || error}`);
+    }
+  }
+
   async start(abortSignal) {
     abortSignal?.addEventListener("abort", () => {
       this.stopped = true;
@@ -1524,6 +1774,11 @@ export class BridgeRunner {
       return;
     }
 
+    await this.announceBackendSession();
+    if (this.stopped) {
+      return;
+    }
+
     if (this.initialPrompt) {
       this.copilotLog("processing initial prompt");
       await this.handleSyntheticMessage(this.initialPrompt, {
@@ -1779,7 +2034,80 @@ export class BridgeRunner {
     }
   }
 
-  createRuntimeStatus(payload, replyTo) {
+  normalizePercent(value) {
+    if (!Number.isFinite(value)) {
+      return undefined;
+    }
+    if (value < 0) {
+      return 0;
+    }
+    if (value > 100) {
+      return 100;
+    }
+    return value;
+  }
+
+  async resolveRuntimeContext() {
+    const now = Date.now();
+    if (
+      this.runtimeContextSnapshot &&
+      now - this.runtimeContextSnapshotAt < this.runtimeContextRefreshMs
+    ) {
+      return this.runtimeContextSnapshot;
+    }
+    if (this.runtimeContextInFlight) {
+      return this.runtimeContextInFlight;
+    }
+
+    this.runtimeContextInFlight = (async () => {
+      let sessionInfo = null;
+      try {
+        if (typeof this.backendSession?.getSessionInfo === "function") {
+          sessionInfo = this.backendSession.getSessionInfo();
+        }
+      } catch {
+        sessionInfo = null;
+      }
+
+      let usage = null;
+      try {
+        if (typeof this.backendSession?.getSessionUsageSummary === "function") {
+          usage = await this.backendSession.getSessionUsageSummary();
+        }
+      } catch {
+        usage = null;
+      }
+
+      const resolvedSessionId = String(
+        usage?.sessionId || sessionInfo?.sessionId || "",
+      ).trim();
+      const resolvedSessionFilePath = String(
+        usage?.sessionFilePath || sessionInfo?.sessionFilePath || "",
+      ).trim();
+      const tokenUsagePercent = this.normalizePercent(Number(usage?.tokenUsagePercent));
+      const contextUsagePercent = this.normalizePercent(Number(usage?.contextUsagePercent));
+
+      const snapshot = {
+        daemon: this.daemonName || undefined,
+        pid: process.pid,
+        session_id: resolvedSessionId || undefined,
+        session_file_path: resolvedSessionFilePath || undefined,
+        token_usage_percent: tokenUsagePercent,
+        context_usage_percent: contextUsagePercent,
+      };
+      this.runtimeContextSnapshot = snapshot;
+      this.runtimeContextSnapshotAt = Date.now();
+      return snapshot;
+    })();
+
+    try {
+      return await this.runtimeContextInFlight;
+    } finally {
+      this.runtimeContextInFlight = null;
+    }
+  }
+
+  createRuntimeStatus(payload, replyTo, runtimeContext = null) {
     if (!payload || typeof payload !== "object") {
       return null;
     }
@@ -1804,12 +2132,22 @@ export class BridgeRunner {
       reply_preview: truncateText(replyPreview, 240) || undefined,
       reply_to: replyTo,
       backend: this.backendName,
-      thread_id: this.backendSession.threadId,
+      thread_id:
+        String(
+          payload.thread_id || runtimeContext?.session_id || "",
+        ).trim() || undefined,
+      daemon: runtimeContext?.daemon,
+      pid: runtimeContext?.pid,
+      session_id: runtimeContext?.session_id,
+      session_file_path: runtimeContext?.session_file_path,
+      token_usage_percent: runtimeContext?.token_usage_percent,
+      context_usage_percent: runtimeContext?.context_usage_percent,
     };
   }
 
   async reportRuntimeStatus(payload, replyTo) {
-    const runtime = this.createRuntimeStatus(payload, replyTo);
+    const runtimeContext = await this.resolveRuntimeContext();
+    const runtime = this.createRuntimeStatus(payload, replyTo, runtimeContext);
     if (!runtime) {
       return;
     }
@@ -1852,6 +2190,67 @@ export class BridgeRunner {
     }
   }
 
+  resetErrorLoop() {
+    this.errorLoop = null;
+  }
+
+  evaluateErrorLoop(errorMessage) {
+    const normalizedKey = normalizeExecutionErrorKey(errorMessage);
+    const now = Date.now();
+    const current = this.errorLoop;
+
+    if (
+      !current ||
+      current.key !== normalizedKey ||
+      now - current.lastAt > this.errorLoopWindowMs
+    ) {
+      this.errorLoop = {
+        key: normalizedKey,
+        count: 1,
+        lastAt: now,
+        cooldownUntil: 0,
+      };
+      return {
+        key: normalizedKey,
+        count: 1,
+        open: false,
+        suppressReport: false,
+        cooldownMs: 0,
+      };
+    }
+
+    current.count += 1;
+    current.lastAt = now;
+    const open = current.count >= this.errorLoopThreshold;
+    let suppressReport = false;
+
+    if (open) {
+      if (current.cooldownUntil > now) {
+        suppressReport = true;
+      } else {
+        current.cooldownUntil = now + this.errorLoopBackoffMs;
+      }
+    }
+
+    this.errorLoop = current;
+    return {
+      key: normalizedKey,
+      count: current.count,
+      open,
+      suppressReport,
+      cooldownMs: suppressReport ? current.cooldownUntil - now : 0,
+    };
+  }
+
+  isExecutionFailureLoopError(errorMessage) {
+    const normalized = String(errorMessage || "").toLowerCase();
+    return (
+      normalized.includes("pty session already spawned") ||
+      normalized.includes("tui process has exited") ||
+      normalized.includes("cannot proceed: tui process has exited")
+    );
+  }
+
   async respondToMessage(message) {
     const content = String(message.content || "").trim();
     if (!content) {
@@ -1863,6 +2262,13 @@ export class BridgeRunner {
       this.copilotLog(`skip duplicated message replyTo=${replyTo}`);
       return;
     }
+    if (replyTo && this.inFlightMessageIds.has(replyTo)) {
+      this.copilotLog(`skip in-flight duplicated message replyTo=${replyTo}`);
+      return;
+    }
+    if (replyTo) {
+      this.inFlightMessageIds.add(replyTo);
+    }
     this.lastRuntimeStatusSignature = null;
     this.runningTurn = true;
     const turnStartedAt = Date.now();
@@ -1932,6 +2338,7 @@ export class BridgeRunner {
       if (replyTo) {
         this.processedMessageIds.add(replyTo);
       }
+      this.resetErrorLoop();
       this.copilotLog(`sdk_message sent replyTo=${replyTo || "latest"} responseLen=${responseText.length}`);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -1953,11 +2360,48 @@ export class BridgeRunner {
         },
         replyTo,
       );
-      await this.reportError(`${this.backendName} 处理失败: ${errorMessage}`, replyTo);
+      const isExecutionFailure = this.isExecutionFailureLoopError(errorMessage);
+      const loopState = isExecutionFailure
+        ? this.evaluateErrorLoop(errorMessage)
+        : {
+            key: "non_execution_error",
+            count: 1,
+            open: false,
+            suppressReport: false,
+            cooldownMs: 0,
+          };
+      if (!isExecutionFailure) {
+        this.resetErrorLoop();
+      }
+      const executionFailureLoop = isExecutionFailure && loopState.open;
+      if (executionFailureLoop) {
+        await this.reportRuntimeStatus(
+          {
+            state: "ERROR",
+            phase: "execution_failure_loop",
+            reply_in_progress: false,
+            status_done_line: `${this.backendName} execution_failure_loop`,
+          },
+          replyTo,
+        );
+      }
+      if (isExecutionFailure && loopState.suppressReport) {
+        this.copilotLog(
+          `suppress repeated error report key=${loopState.key} count=${loopState.count} cooldownMs=${loopState.cooldownMs}`,
+        );
+        return;
+      }
+      const reportMessage = executionFailureLoop
+        ? `${this.backendName} 执行层失败循环(${loopState.key}, 连续${loopState.count}次): ${errorMessage}`
+        : `${this.backendName} 处理失败: ${errorMessage}`;
+      await this.reportError(reportMessage, replyTo);
     } finally {
       if (turnWatchdog) {
         clearInterval(turnWatchdog);
       }
+      if (replyTo) {
+        this.inFlightMessageIds.delete(replyTo);
+      }
       this.copilotLog(
         `turn end replyTo=${replyTo || "latest"} elapsedMs=${Date.now() - turnStartedAt} processedIds=${this.processedMessageIds.size}`,
       );

package/bin/conductor.js

@@ -8,6 +8,7 @@
  *   daemon   - Start long-running daemon for task orchestration
  *   config   - Interactive configuration setup
  *   update   - Update the CLI to the latest version
+ *   diagnose - Diagnose a task in production/backend
  */
 
 import { fileURLToPath } from "node:url";
@@ -43,7 +44,7 @@ if (argv[0] === "--version" || argv[0] === "-v") {
 const subcommand = argv[0];
 
 // Valid subcommands
-const validSubcommands = ["fire", "daemon", "config", "update"];
+const validSubcommands = ["fire", "daemon", "config", "update", "diagnose"];
 
 if (!validSubcommands.includes(subcommand)) {
   console.error(`Error: Unknown subcommand '${subcommand}'`);
@@ -85,6 +86,7 @@ Subcommands:
   daemon    Start long-running daemon for task orchestration
   config    Interactive configuration setup
   update    Update the CLI to the latest version
+  diagnose  Diagnose a task and print likely root cause
 
 Options:
   -h, --help     Show this help message
@@ -94,6 +96,7 @@ Examples:
   conductor fire -- "fix the bug"
   conductor fire --backend claude -- "add feature"
   conductor daemon --config-file ~/.conductor/config.yaml
+  conductor diagnose <task-id>
   conductor config
   conductor update
 
@@ -102,6 +105,7 @@ For subcommand-specific help:
   conductor daemon --help
   conductor config --help
   conductor update --help
+  conductor diagnose --help
 
 Version: ${pkgJson.version}
 `);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.2.12",
+  "version": "0.2.13",
   "type": "module",
   "bin": {
     "conductor": "bin/conductor.js"
@@ -16,8 +16,8 @@
     "test": "node --test"
   },
   "dependencies": {
-    "@love-moon/tui-driver": "0.2.12",
-    "@love-moon/conductor-sdk": "0.2.12",
+    "@love-moon/tui-driver": "0.2.13",
+    "@love-moon/conductor-sdk": "0.2.13",
     "dotenv": "^16.4.5",
     "enquirer": "^2.4.1",
     "js-yaml": "^4.1.1",