server.js

import "dotenv/config";
import express from "express";
import { spawn } from "node:child_process";
import fs from "node:fs";
import https from "node:https";
import path from "node:path";
import { fileURLToPath } from "node:url";
import notifier from "node-notifier";
import { rememberConversationTurn } from "./lib/conversation-state.js";
import { runPersonaAgentTurn } from "./lib/agent/runner.js";
import { loadAgentNotes, loadAgentTraces, rememberAgentCorrection } from "./lib/agent/state.js";
import {
  confirmOutgoingDelivery,
  loadInnerState,
  needsAttentionPolicyMigration,
  repairLegacyAttentionRace,
  resolveIncomingAttention,
  updateLifeState,
} from "./lib/inner-state.js";
import { renderPrompt } from "./lib/prompt-loader.js";
import { synthesize } from "./lib/tts.js";
import { getPersonaId, getPersonaNames, personaKvKey, personaPrivatePath } from "./lib/persona-context.js";
import { createProactiveScheduler } from "./lib/proactive-scheduler.js";
import { indexPendingConversationEvents, vectorMemoryStatus } from "./lib/vector-memory-client.js";
import { configureSystemHttpProxy } from "./lib/system-http-proxy.js";
import {
  describeRuntimeError,
  isRequestAbortedError,
  isRetryableAgentDecisionError,
} from "./lib/runtime-errors.js";
import {
  appendSession,
  clearSession,
  findSessionMessage,
  loadSession,
  newId,
  normalizeMessage,
  updateSessionMessage,
} from "./lib/session.js";
import {
  appendFeedback,
  loadArchive,
  loadHabits,
  loadStickerBank,
} from "./lib/profile.js";
import {
  appendRuntimeEvent,
  cancelPendingProactiveDeliveries,
  cancelPendingRuntimeWork,
  completeReplyJob,
  compactExpiredAgentTraces,
  deleteKv,
  deletePushSubscription,
  deferReplyJobUntil,
  enqueueDeliveryOutbox,
  enqueueReplyJobMessage,
  failDeliveryOutbox,
  failReplyJob,
  getKv,
  loadDeliveryOutboxRow,
  loadNextPendingDeliveryOutbox,
  loadNextQueuedReplyJob,
  loadPushSubscriptions,
  loadReplyJob,
  markDeliveryOutboxDelivered,
  markDeliveryOutboxDelivering,
  markReplyJobRunning,
  pendingRuntimeWorkCounts,
  recoverRuntimeWork,
  releaseQueuedReplyJobs,
  retryReplyJobLater,
  setKv,
  upsertPushSubscription,
} from "./lib/runtime-db.js";
import {
  createPrivacyPushPayload,
  createTestPushPayload,
  describeWebPushError,
  requiresPushResubscription,
  sendWebPush,
  webPushPublicConfig,
} from "./lib/web-push-notifications.js";

const ROOT = path.dirname(fileURLToPath(import.meta.url));
const port = Number(process.env.PORT || 3000);
const host = String(process.env.HOST || "127.0.0.1").trim() || "127.0.0.1";
const httpsPort = Number(process.env.HTTPS_PORT || 3443);
const certDir = path.join(ROOT, "data", "certs");
const caCertificateFile = path.join(certDir, "clone-chat-ca.cer");
const httpsCertificateFile = path.join(certDir, "server-cert.pem");
const httpsKeyFile = path.join(certDir, "server-key.pem");
const lanIosMetadataFile = path.join(certDir, "lan-ios.json");
const proxyStatus = configureSystemHttpProxy();
const app = express();
app.use(express.json({ limit: "2mb" }));
app.use("/generated", express.static(path.join(ROOT, "data", "generated"), { maxAge: "7d" }));

const sseClients = new Map();
let sseSeq = 0;
let deliveryChain = Promise.resolve();
let replyPumpTimer = null;
let replyPumpActive = false;
let deliveryPumpTimer = null;
let deliveryPumpActive = false;
let currentPresence = { kind: "idle", updatedAt: new Date().toISOString() };
let currentAppStatus = { kind: "ready", message: "", updatedAt: new Date().toISOString() };
let memoryIndexTimer = null;
const clientPresence = new Map();
const proactiveScheduler = createProactiveScheduler({
  enabled: () => String(process.env.PROACTIVE_SCHEDULER_ENABLED ?? "1") !== "0",
  personaId: getPersonaId,
  loadSchedule: loadProactiveSchedule,
  saveSchedule: (schedule) => setKv(personaKvKey("proactive_schedule"), schedule),
  pendingWork: pendingRuntimeWorkCounts,
  decide: runProactiveAgentDecision,
  accept: (agent, { deliveries = [] } = {}) => persistAgentLifeState(agent, {
    attentionBaseAt: latestDeliveryDueAt(deliveries),
    evaluationKind: "system_reassessment",
  }),
  deliver: deliverProactiveAgentMessages,
  cancelPendingDeliveries: (reason) => {
    const rows = cancelPendingProactiveDeliveries(reason);
    for (const row of rows) {
      recordProactiveOutboxEvent("delivery_canceled", row, {
        reason,
        status: "canceled",
      }, "warn");
    }
    return rows;
  },
  onReady: () => broadcastAppStatus("ready", ""),
  onError: (error) => {
    console.error("主动消息决策失败:", describeRuntimeError(error));
    broadcastAppStatus("error", "主动消息暂时不可用，稍后自动重试");
  },
  onEvent: recordProactiveRuntimeEvent,
});

app.get("/api/events", (req, res) => {
  const clientId = newId("client");
  res.setHeader("Content-Type", "text/event-stream; charset=utf-8");
  res.setHeader("Cache-Control", "no-cache, no-transform");
  res.setHeader("Connection", "keep-alive");
  res.setHeader("X-Accel-Buffering", "no");
  res.flushHeaders?.();

  sseClients.set(clientId, res);
  sendSse(res, "sync:hello", {
    clientId,
    now: new Date().toISOString(),
    presence: currentPresence,
    appStatus: currentAppStatus,
  });

  const heartbeat = setInterval(() => {
    sendSse(res, "sync:ping", { now: new Date().toISOString() });
  }, 25_000);

  req.on("close", () => {
    clearInterval(heartbeat);
    sseClients.delete(clientId);
    clientPresence.delete(clientId);
  });
});

const personaMediaDir = personaPrivatePath("media");
if (fs.existsSync(personaMediaDir)) app.use("/persona-media", express.static(personaMediaDir, { maxAge: "7d" }));
app.use(express.static(path.join(ROOT, "public"), {
  setHeaders: (res, file) => {
    if (/manifest|^sw(?:-[a-z0-9]+)?\.js$|icon/i.test(path.basename(file))) {
      res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
      res.setHeader("Pragma", "no-cache");
      res.setHeader("Expires", "0");
    }
  },
}));

const HISTORY_CAP = 90;

app.get("/local-ca.cer", (_req, res) => {
  if (!fs.existsSync(caCertificateFile)) return res.status(404).send("请先运行 npm run setup:lan-ios");
  res.download(caCertificateFile, "clone-chat-ca.cer");
});

app.get("/api/lan-ios", (req, res) => {
  res.json(lanIosPublicStatus(req));
});

app.get("/api/push/config", (req, res) => {
  try {
    const deviceId = safeDeviceId(req.query.deviceId);
    const config = webPushPublicConfig();
    res.json({
      ...config,
      secure: req.secure,
      subscribed: deviceId ? loadPushSubscriptions({ deviceId }).length > 0 : false,
      ...lanIosPublicStatus(req),
    });
  } catch (error) {
    res.status(500).json({ error: String(error.message || error) });
  }
});

app.post("/api/push/subscribe", (req, res) => {
  if (!req.secure) return res.status(400).json({ error: "通知订阅必须从 HTTPS 页面开启" });
  try {
    const deviceId = safeDeviceId(req.body?.deviceId);
    if (!deviceId) return res.status(400).json({ error: "无效设备 ID" });
    const saved = upsertPushSubscription({
      ...(req.body?.subscription || {}),
      deviceId,
      userAgent: req.get("user-agent") || "",
    });
    res.json({ ok: true, subscribed: Boolean(saved) });
  } catch (error) {
    res.status(400).json({ error: String(error.message || error) });
  }
});

app.delete("/api/push/subscribe", (req, res) => {
  if (!req.secure) return res.status(400).json({ error: "请从 HTTPS 页面关闭通知" });
  const endpoint = String(req.body?.endpoint || "").trim();
  const deviceId = safeDeviceId(req.body?.deviceId);
  const deleted = deletePushSubscription({ endpoint, deviceId });
  res.json({ ok: true, deleted });
});

app.post("/api/push/test", async (req, res) => {
  if (!req.secure) return res.status(400).json({ error: "请从 HTTPS 页面测试通知" });
  const deviceId = safeDeviceId(req.body?.deviceId);
  const subscriptions = deviceId ? loadPushSubscriptions({ deviceId }) : [];
  if (!subscriptions.length) return res.status(404).json({ error: "这台设备还没有开启通知" });
  const payload = createTestPushPayload();
  let sent = 0;
  const failures = [];
  for (const subscription of subscriptions) {
    try {
      await sendWebPush(subscription, payload, { proxy: pushProxyUrl() });
      sent++;
    } catch (error) {
      const details = describeWebPushError(error);
      failures.push(details);
      if (requiresPushResubscription(error)) {
        deletePushSubscription({ endpoint: subscription.endpoint });
      }
      console.warn("测试 Web Push 失败:", details);
    }
  }
  if (!sent) {
    const failure = failures[0] || {};
    const resubscribe = failures.some((item) => (
      [404, 410].includes(item.statusCode) || item.reason === "VapidPkHashMismatch"
    ));
    return res.status(resubscribe ? 409 : 502).json({
      error: pushFailureMessage(failure),
      code: resubscribe ? "resubscribe_required" : "push_delivery_failed",
      pushStatus: failure.statusCode || 0,
      reason: failure.reason || "",
      apnsId: failure.apnsId || "",
    });
  }
  res.json({ ok: true, sent, failed: failures.length });
});

function readIfExists(p) {
  return fs.existsSync(p) ? fs.readFileSync(p, "utf8") : "";
}

function buildSystem(_userText, extra = "") {
  const persona = readIfExists(path.join(ROOT, "persona", "persona.md"));

  let system = persona;
  if (extra.trim()) system += "\n\n" + extra;
  return system;
}

app.get("/api/config", (_req, res) => {
  const habits = loadHabits();
  const stickers = loadStickerBank();
  const names = getPersonaNames();
  res.json({
    personaId: getPersonaId(),
    personaName: names.personaName,
    userName: names.userName,
    herName: names.personaDisplayName,
    meName: names.userDisplayName,
    hasPersonaMedia: fs.existsSync(personaMediaDir),
    stats: {
      importedAt: habits.importedAt || null,
      totalMessages: (habits.totals?.her || 0) + (habits.totals?.me || 0),
      herMessages: habits.totals?.her || 0,
      stickerCount: stickers.length,
      voiceRate: habits.her?.voiceRate ?? 0.01,
      stickerRate: habits.her?.stickerRate ?? 0.08,
    },
    memory: vectorMemoryStatus(),
  });
});

app.get("/api/history", (req, res) => {
  const limit = clampInt(req.query.limit, 20, 1000, 300);
  res.json({ messages: loadSession(limit) });
});

app.post("/api/persona/reset", (_req, res) => {
  cancelPendingRuntimeWork("reset_persona");
  clearRuntimeTimers();
  clearSession();
  deleteKv(personaKvKey("inner_state"));
  deleteKv(personaKvKey("conversation_state"));
  deleteKv(personaKvKey("agent_notes"));
  deleteKv(personaKvKey("proactive_schedule"));
  deleteKv("her_inner_state");
  deleteKv("conversation_state");
  deleteKv("agent_notes");
  broadcastSse("session:clear", { now: new Date().toISOString(), reset: true });
  broadcastPresence("idle");
  restoreProactiveSchedule();
  res.json({ ok: true });
});

app.get("/api/archive", (req, res) => {
  const limit = clampInt(req.query.limit, 20, 300, 80);
  const before = (req.query.before ?? "").toString();
  res.json({ messages: loadArchive(limit, before) });
});

app.get("/api/agent/state", (req, res) => {
  const limit = clampInt(req.query.limit, 5, 80, 20);
  res.json({
    framework: "persona-agent-v1",
    notes: loadAgentNotes(),
    traces: loadAgentTraces(limit),
    memory: vectorMemoryStatus(),
    proactive: loadProactiveSchedule(),
    life: loadInnerState(),
  });
});

app.post("/api/client-presence", (req, res) => {
  const clientId = safeClientMessageId(req.body?.clientId);
  if (!clientId || !sseClients.has(clientId)) return res.status(400).json({ error: "无效客户端" });
  clientPresence.set(clientId, {
    deviceId: safeDeviceId(req.body?.deviceId),
    focused: Boolean(req.body?.focused),
    visible: Boolean(req.body?.visible),
    updatedAt: Date.now(),
  });
  res.json({ ok: true });
});

// 连发合并现在落到 SQLite 的 reply_jobs:
// 服务重启前还没跑 Agent 的用户消息,启动后会按 dueAt 自动恢复,不再依赖内存队列。
let replyFlushChain = Promise.resolve();

function queueUserMessageForReply(message, { notBefore = "" } = {}) {
  const job = enqueueReplyJobMessage(message?.id, { notBefore });
  scheduleReplyJobPump(job?.dueAt);
  return job;
}

function routeIncomingMessage(message, {
  pauseReason = "awaiting_reply_decision",
  cancelReason = "superseded_by_new_user_message",
} = {}) {
  const receivedAt = Date.now();
  const attention = resolveIncomingAttention(loadInnerState(), receivedAt, {
    notificationAt: receivedAt,
    currentlyNoticing: pendingRuntimeWorkCounts().replyRunning > 0,
  });
  if (!attention.defer) {
    proactiveScheduler.supersede({ pauseReason, cancelReason });
  }
  const releasedJobs = !attention.defer
    ? releaseQueuedReplyJobs("incoming_message_admitted").released
    : 0;
  const job = queueUserMessageForReply(message, {
    notBefore: attention.defer ? attention.dueAt : "",
  });
  recordAttentionRuntimeEvent(attention.defer ? "message_deferred" : "message_admitted", {
    messageId: message?.id || "",
    jobId: job?.id || "",
    dueAt: job?.dueAt || "",
    attentionMode: attention.attentionMode,
    notificationMode: attention.notificationMode,
    attentionUntil: attention.passiveDueAt || "",
    notificationDueAt: attention.notificationDueAt || "",
    notificationRecheck: attention.notificationRecheck,
    incomingRecheckAfterMs: attention.incomingRecheckAfterMs,
    remainingMs: attention.remainingMs,
    reason: attention.reason,
    releasedJobs,
  });
  return { attention, job };
}

function scheduleReplyJobPump() {
  if (replyPumpTimer) clearTimeout(replyPumpTimer);
  const next = loadNextQueuedReplyJob();
  if (!next) return;
  replyPumpTimer = setTimeout(() => {
    replyPumpTimer = null;
    replyFlushChain = replyFlushChain.then(() => pumpReplyJobs()).catch((err) => {
      console.error("回复批处理失败:", err);
      broadcastPresence("idle", { error: String(err?.message ?? err), reason: "burst_error" });
    });
  }, timerDelayUntil(next.dueAt));
}

async function pumpReplyJobs() {
  if (replyPumpActive) return;
  replyPumpActive = true;
  try {
    while (true) {
      const next = loadNextQueuedReplyJob();
      if (!next) return;
      const waitMs = msUntil(next.dueAt);
      if (waitMs > 25) return scheduleReplyJobPump();
      await processReplyJob(next.id);
    }
  } finally {
    replyPumpActive = false;
    scheduleReplyJobPump();
  }
}

async function processReplyJob(jobId) {
  const queuedJob = loadReplyJob(jobId);
  if (!queuedJob || queuedJob.status !== "queued") return;
  const attention = resolveIncomingAttention(loadInnerState(), Date.now(), {
    notificationAt: queuedJob.firstAt || queuedJob.createdAt,
  });
  if (attention.defer) {
    const deferred = deferReplyJobUntil(jobId, attention.dueAt);
    recordAttentionRuntimeEvent("message_still_deferred", {
      jobId,
      dueAt: deferred?.dueAt || attention.dueAt,
      attentionMode: attention.attentionMode,
      notificationMode: attention.notificationMode,
      attentionTransitionAt: attention.transitionAt,
      attentionUntil: attention.passiveDueAt,
      notificationDueAt: attention.notificationDueAt,
      notificationRecheck: attention.notificationRecheck,
      incomingRecheckAfterMs: attention.incomingRecheckAfterMs,
      reason: attention.reason,
    });
    scheduleReplyJobPump();
    return;
  }
  if (["attention_notification_recheck", "attention_window_elapsed"].includes(attention.reason)) {
    proactiveScheduler.supersede({
      pauseReason: "awaiting_reply_decision",
      cancelReason: "superseded_when_saved_message_was_noticed",
    });
  }
  const job = markReplyJobRunning(jobId);
  if (!job) return;
  try {
    const batch = (job.messageIds || [])
      .map((id) => findSessionMessage(id))
      .filter((m) => m && m.sender === "me");
    if (!batch.length) {
      completeReplyJob(job.id, { emptyBatch: true });
      return;
    }
    // 先完成上一轮尚未发送的内容，再处理本批消息。
    await deliveryChain.catch(() => {});
    // 投递期间如果新消息使当前 job 失效，消息已并入新 job，无需重复调用模型。
    if (loadReplyJob(job.id)?.status !== "running") return;
    const text = batch
      .map((m) => (m.type === "voice" ? `[语音] ${m.transcript || m.text}` : m.text))
      .filter(Boolean)
      .join("\n");
    if (!text.trim()) {
      completeReplyJob(job.id, { emptyText: true });
      return;
    }
    const inputType = batch.length === 1 && batch[0].type === "voice" ? "voice" : "text";
    recordAttentionRuntimeEvent("message_processing_started", {
      jobId: job.id,
      messageIds: batch.map((item) => item.id),
      messageCount: batch.length,
      firstAt: job.firstAt,
      firstMessageSentAt: batch[0]?.createdAt || batch[0]?.time || "",
      lastMessageSentAt: batch.at(-1)?.createdAt || batch.at(-1)?.time || "",
      noticedAt: new Date().toISOString(),
      dueAt: job.dueAt,
      waitedMs: Math.max(0, Date.now() - new Date(job.firstAt || job.createdAt).getTime()),
      attentionReason: attention.reason,
      notificationMode: attention.notificationMode,
    });
    const agent = await runPersonaAgentTurn({
      text,
      inputMessages: batch,
      inputType,
      mode: "reply",
      attentionContext: {
        reason: attention.reason,
        notificationAt: job.firstAt || job.createdAt,
        notificationMode: attention.notificationMode,
      },
      buildSystem,
      historyCap: HISTORY_CAP,
      onEvent: makeAgentLogEmitter({ route: "chat", batchSize: batch.length, jobId: job.id }),
    });
    const stillRunning = loadReplyJob(job.id);
    if (stillRunning?.status !== "running") {
      broadcastPresence("idle", { traceId: agent.traceId || "", reason: "reply_job_cancelled" });
      return;
    }
    rememberConversationTurn({
      userText: text,
      userMessages: batch,
      inputType,
      mode: "reply",
      herMessages: agent.messages,
      noReply: Boolean(agent.noReply),
      traceId: agent.traceId,
    });
    broadcastAppStatus("ready", "");
    if (agent.noReply || !agent.messages.length) {
      const life = persistAgentLifeState(agent);
      scheduleProactiveAt(life.attentionUntil, "reply_decision");
      // 本轮决定不回复时不创建投递记录，也不向前端显示状态。
      completeReplyJob(job.id, { traceId: agent.traceId, plan: agent.plan, noReply: true });
      broadcastPresence("idle", { traceId: agent.traceId || "", reason: "no_reply" });
      return;
    }
    const outboxRows = scheduleHerMessages(agent.messages, {
      jobId: job.id,
      traceId: agent.traceId,
      plan: agent.plan,
      reason: "reply",
    });
    const life = persistAgentLifeState(agent, {
      attentionBaseAt: latestDeliveryDueAt(outboxRows),
    });
    scheduleProactiveAt(life.attentionUntil, "reply_decision");
    completeReplyJob(job.id, {
      traceId: agent.traceId,
      plan: agent.plan,
      noReply: false,
      outboxRows: outboxRows.length,
    });
  } catch (err) {
    if (shouldRetryReplyJob(err, job)) {
      const delayMs = computeReplyJobRetryDelayMs(job.attempts);
      const retried = retryReplyJobLater(job.id, String(err?.message ?? err), delayMs, {
        attempts: job.attempts,
        maxAttempts: replyJobMaxAttempts(),
        transient: true,
      });
      recordAttentionRuntimeEvent("message_retry_scheduled", {
        jobId: job.id,
        dueAt: retried?.dueAt || "",
        attempts: job.attempts,
        maxAttempts: replyJobMaxAttempts(),
        error: String(err?.message ?? err),
      }, "warn");
      console.warn(`回复批处理请求异常，${Math.round(delayMs / 1000)} 秒后重试:`, err);
      broadcastAppStatus("error", "消息处理暂时失败，正在自动重试");
      broadcastPresence("idle", {
        error: String(err?.message ?? err),
        reason: "reply_job_retry_scheduled",
        retryAt: retried?.dueAt || "",
        attempts: job.attempts,
        maxAttempts: replyJobMaxAttempts(),
      });
      return;
    }
    failReplyJob(job.id, String(err?.message ?? err));
    recordAttentionRuntimeEvent("message_processing_failed", {
      jobId: job.id,
      attempts: job.attempts,
      maxAttempts: replyJobMaxAttempts(),
      error: String(err?.message ?? err),
    }, "error");
    broadcastAppStatus("error", "消息暂时无法处理，请稍后重试");
    scheduleNextProactive(10 * 60_000, "technical_retry");
    broadcastPresence("idle", { error: String(err?.message ?? err), reason: "reply_job_error" });
    throw err;
  }
}

app.post("/api/chat", async (req, res) => {
  const text = (req.body?.text ?? "").toString().trim();
  const inputType = (req.body?.inputType ?? "text").toString();
  if (!text) return res.status(400).json({ error: "空消息" });
  try {
    const clientMessageId = safeClientMessageId(req.body?.clientMessageId);
    const userMsg = normalizeMessage({
      id: clientMessageId || newId("u"),
      role: "user",
      type: inputType === "voice" ? "voice" : "text",
      text,
      transcript: inputType === "voice" ? text : "",
      source: "user",
      status: "sent",
    });
    const [savedUserMsg] = appendAndBroadcastSession(userMsg, { reason: "user_send" });
    const routed = routeIncomingMessage(savedUserMsg);
    res.json({
      user: savedUserMsg,
      queued: true,
      deferred: routed.attention.defer,
      deferredUntil: routed.attention.dueAt || null,
    });
  } catch (err) {
    console.error(err);
    broadcastAppStatus("error", "消息暂时无法处理，请稍后重试");
    scheduleNextProactive(10 * 60_000, "technical_retry");
    broadcastPresence("idle", { error: String(err.message ?? err), reason: "chat_error" });
    res.status(500).json({ error: String(err.message ?? err) });
  }
});

app.post("/api/retry-message", async (req, res) => {
  const messageId = safeClientMessageId(req.body?.messageId);
  if (!messageId) return res.status(400).json({ error: "缺少 messageId" });
  const original = findSessionMessage(messageId);
  if (!original || original.sender !== "me") return res.status(404).json({ error: "没找到可重发的消息" });
  const text = String(original.transcript || original.text || "").trim();
  if (!text) return res.status(400).json({ error: "这条消息没有可重发的文字" });
  let savedUserMsg = null;
  try {
    const receivedAt = Date.now();
    const attention = resolveIncomingAttention(loadInnerState(), receivedAt, {
      notificationAt: receivedAt,
      currentlyNoticing: pendingRuntimeWorkCounts().replyRunning > 0,
    });
    if (attention.defer) {
      savedUserMsg = updateAndBroadcastSessionMessage(messageId, {
        status: "sent",
        meta: {
          ...(original.meta || {}),
          retryAt: new Date().toISOString(),
          error: "",
        },
      }, { reason: "user_retry_deferred" }) || original;
      const job = queueUserMessageForReply(savedUserMsg, { notBefore: attention.dueAt });
      recordAttentionRuntimeEvent("message_deferred", {
        messageId,
        jobId: job?.id || "",
        dueAt: job?.dueAt || "",
        attentionMode: attention.attentionMode,
        notificationMode: attention.notificationMode,
        attentionUntil: attention.passiveDueAt,
        notificationDueAt: attention.notificationDueAt,
        notificationRecheck: attention.notificationRecheck,
        incomingRecheckAfterMs: attention.incomingRecheckAfterMs,
        remainingMs: attention.remainingMs,
        reason: attention.reason,
      });
      return res.json({
        user: savedUserMsg,
        messages: [],
        queued: true,
        deferred: true,
        deferredUntil: attention.dueAt,
        agent: { scheduled: false, retry: true, deferred: true },
      });
    }
    proactiveScheduler.supersede({
      pauseReason: "awaiting_retry_reply_decision",
      cancelReason: "superseded_by_user_retry",
    });
    savedUserMsg = updateAndBroadcastSessionMessage(messageId, {
      status: "sending",
      meta: {
        ...(original.meta || {}),
        retryAt: new Date().toISOString(),
        error: "",
      },
    }, { reason: "user_retry" }) || original;

    // 生成回复期间不显示输入状态；输入状态只由投递层在实际发送窗口内广播。
    const agent = await runPersonaAgentTurn({
      text,
      inputMessages: [original],
      inputType: original.type === "voice" ? "voice" : "text",
      mode: "reply",
      attentionContext: {
        reason: attention.reason,
        notificationAt: receivedAt,
        notificationMode: attention.notificationMode,
      },
      buildSystem,
      historyCap: HISTORY_CAP,
      onEvent: makeAgentLogEmitter({ route: "retry", messageId }),
    });
    const herMessages = agent.messages;
    rememberConversationTurn({
      userText: text,
      userMessages: [original],
      inputType: original.type === "voice" ? "voice" : "text",
      mode: "reply",
      herMessages,
      noReply: Boolean(agent.noReply),
      traceId: agent.traceId,
    });
    broadcastAppStatus("ready", "");
    savedUserMsg = updateAndBroadcastSessionMessage(messageId, { status: "sent" }, { reason: "user_retry_sent" }) || savedUserMsg;
    if (agent.noReply || !herMessages.length) {
      const life = persistAgentLifeState(agent);
      scheduleProactiveAt(life.attentionUntil, "retry_reply_decision");
      broadcastPresence("idle", { traceId: agent.traceId || "", reason: "no_reply" });
      return res.json({
        user: savedUserMsg,
        messages: [],
        agent: { traceId: agent.traceId, plan: agent.plan, scheduled: false, noReply: true, retry: true },
      });
    }
    const outboxRows = scheduleHerMessages(herMessages, {
      traceId: agent.traceId,
      plan: agent.plan,
      reason: "retry_reply",
    });
    const life = persistAgentLifeState(agent, {
      attentionBaseAt: latestDeliveryDueAt(outboxRows),
    });
    scheduleProactiveAt(life.attentionUntil, "retry_reply_decision");
    res.json({
      user: savedUserMsg,
      messages: herMessages,
      agent: { traceId: agent.traceId, plan: agent.plan, scheduled: true, retry: true },
    });
  } catch (err) {
    console.error(err);
    updateAndBroadcastSessionMessage(messageId, {
      status: "failed",
      meta: {
        ...(savedUserMsg?.meta || original.meta || {}),
        failedAt: new Date().toISOString(),
        error: String(err.message ?? err),
      },
    }, { reason: "user_retry_failed" });
    broadcastAppStatus("error", "消息暂时无法处理，请稍后重试");
    scheduleNextProactive(10 * 60_000, "technical_retry");
    broadcastPresence("idle", { error: String(err.message ?? err), reason: "retry_error" });
    res.status(500).json({ error: String(err.message ?? err) });
  }
});

app.post("/api/feedback", (req, res) => {
  const body = req.body || {};
  const entry = {
    messageId: body.messageId || "",
    kind: body.kind || "不像",
    detail: body.detail || "",
    correctedText: body.correctedText || "",
    message: body.message || null,
  };
  appendFeedback(entry);
  rememberAgentCorrection(entry);
  res.json({ ok: true });
});

app.get("/api/tts", async (req, res) => {
  const text = (req.query.text ?? "").toString().trim();
  if (!text) return res.status(400).json({ error: "空文本" });
  try {
    const result = await synthesize(text);
    res.setHeader("Content-Type", "audio/mpeg");
    res.send(Buffer.isBuffer(result) ? result : result.audio);
  } catch (err) {
    console.error(err);
    res.status(500).json({ error: String(err.message ?? err) });
  }
});

function loadProactiveSchedule() {
  return getKv(personaKvKey("proactive_schedule"), null);
}

function scheduleNextProactive(delayMs, reason = "agent_decision") {
  return proactiveScheduler.schedule(delayMs, reason);
}

function scheduleProactiveAt(nextAt, reason = "agent_decision") {
  const delayMs = msUntil(nextAt);
  return scheduleNextProactive(delayMs, reason);
}

function restoreProactiveSchedule() {
  return proactiveScheduler.restore();
}

async function runProactiveAgentDecision() {
  const proactiveTask = renderPrompt("agent/proactive-task.md");
  return runPersonaAgentTurn({
    text: "现在重新判断是否主动联系。",
    inputType: "text",
    mode: "proactive",
    buildSystem: (userText, extra = "") => buildSystem(userText, `${proactiveTask}\n\n${extra}`),
    historyCap: HISTORY_CAP,
    extraUserPrompt: "没有新用户消息；根据自己的当前状态决定是否主动联系。",
    onEvent: makeAgentLogEmitter({ route: "proactive_scheduler" }),
  });
}

async function deliverProactiveAgentMessages(agent) {
  rememberConversationTurn({
    userText: "",
    inputType: "text",
    mode: "proactive",
    herMessages: agent.messages,
    traceId: agent.traceId,
  });
  return scheduleHerMessages(agent.messages, {
    traceId: agent.traceId,
    plan: agent.plan,
    reason: "proactive",
  });
}

function persistAgentLifeState(agent = {}, {
  attentionBaseAt = "",
  evaluationKind = "conversation_decision",
} = {}) {
  const result = updateLifeState({
    lifeState: agent.plan?.lifeState,
    lifeTransition: agent.plan?.lifeTransition,
    elapsedLifeEpisodes: agent.plan?.elapsedLifeEpisodes,
    attentionMode: agent.plan?.attentionMode,
    notificationMode: agent.plan?.notificationMode,
    attentionStartsAfterMs: agent.plan?.attentionStartsAfterMs,
    incomingRecheckAfterMs: agent.plan?.incomingRecheckAfterMs,
    nextCheckAfterMs: agent.plan?.nextCheckAfterMs,
    attentionBaseAt,
    traceId: agent.traceId,
    evaluationKind,
  });
  if (!result.ok) {
    throw new Error(`生活状态持久化失败: ${result.error || "unknown"}`);
  }
  recordAttentionRuntimeEvent("attention_updated", {
    traceId: agent.traceId || "",
    attentionMode: result.attentionMode,
    attentionTargetMode: result.attentionTargetMode,
    notificationMode: result.notificationMode,
    attentionTransitionAt: result.attentionTransitionAt,
    attentionUntil: result.attentionUntil,
    incomingRecheckAfterMs: result.incomingRecheckAfterMs,
    lifeTransition: result.lifeTransition,
    lifeEpisodeId: result.lifeEpisode?.id || "",
    elapsedLifeEpisodes: result.elapsedLifeEpisodes || [],
    nextCheckAfterMs: agent.plan?.nextCheckAfterMs,
    lifeState: result.lifeState,
    evaluationKind,
  });
  return result;
}

function clampInt(value, min, max, fallback) {
  const n = Number.parseInt(value, 10);
  if (!Number.isFinite(n)) return fallback;
  return Math.max(min, Math.min(max, n));
}

function sendSse(res, event, payload) {
  try {
    res.write(`id: ${++sseSeq}\n`);
    res.write(`event: ${event}\n`);
    res.write(`data: ${JSON.stringify(payload)}\n\n`);
  } catch {
    // 连接断开时 Express 会触发 close,这里不让单个页面影响服务端
  }
}

function broadcastSse(event, payload) {
  for (const [clientId, res] of sseClients.entries()) {
    try {
      sendSse(res, event, payload);
    } catch {
      sseClients.delete(clientId);
    }
  }
}

function recordProactiveRuntimeEvent(event = {}) {
  const {
    type = "event",
    level = "info",
    createdAt = new Date().toISOString(),
    traceId = "",
    outboxId = "",
    ...payload
  } = event;
  try {
    const saved = appendRuntimeEvent({
      scope: "proactive",
      type,
      level,
      createdAt,
      traceId,
      outboxId,
      payload,
    });
    broadcastSse("runtime:event", saved);
    return saved;
  } catch (error) {
    console.warn("主动消息监控事件写入失败:", error?.message || error);
    return null;
  }
}

function recordAttentionRuntimeEvent(type, payload = {}, level = "info") {
  try {
    const saved = appendRuntimeEvent({
      scope: "attention",
      type,
      level,
      createdAt: new Date().toISOString(),
      payload,
    });
    broadcastSse("runtime:event", saved);
    return saved;
  } catch (error) {
    console.warn("消息注意力监控事件写入失败:", error?.message || error);
    return null;
  }
}

function recordProactiveOutboxEvent(type, row = {}, extra = {}, level = "info") {
  if (row?.meta?.reason !== "proactive") return null;
  const message = row.message || {};
  return recordProactiveRuntimeEvent({
    type,
    level,
    traceId: row.meta?.traceId || message.meta?.traceId || "",
    outboxId: row.id || "",
    messageId: row.messageId || message.id || "",
    dueAt: row.dueAt || "",
    deliveredAt: row.deliveredAt || "",
    status: row.status || "",
    attempts: row.attempts || 0,
    messageType: message.type || "text",
    messageText: message.text || message.transcript || "",
    ...extra,
  });
}

function broadcastPresence(kind, extra = {}) {
  currentPresence = {
    kind: kind || "idle",
    updatedAt: new Date().toISOString(),
    ...extra,
  };
  broadcastSse("presence", currentPresence);
  if (extra.error) {
    const message = extra.reason === "reply_job_retry_scheduled"
      ? "模型连接暂时不可用，正在自动重试"
      : "消息处理暂时不可用";
    broadcastAppStatus("error", message);
  }
}

function broadcastAppStatus(kind, message = "") {
  currentAppStatus = {
    kind: kind || "ready",
    message: String(message || ""),
    updatedAt: new Date().toISOString(),
  };
  broadcastSse("app:status", currentAppStatus);
}

function makeAgentLogEmitter(scope = {}) {
  return (event = {}) => {
    broadcastSse("agent:log", {
      ...event,
      scope,
      now: new Date().toISOString(),
    });
  };
}

function replyJobMaxAttempts() {
  return clampInt(process.env.REPLY_JOB_MAX_ATTEMPTS, 1, 10, 3);
}

function computeReplyJobRetryDelayMs(attempts = 1) {
  const baseMs = clampInt(process.env.REPLY_JOB_RETRY_BASE_MS, 500, 120_000, 5000);
  const maxMs = clampInt(process.env.REPLY_JOB_RETRY_MAX_MS, baseMs, 10 * 60_000, 60_000);
  const n = Math.max(1, Number(attempts) || 1);
  const jitter = Math.floor(Math.random() * Math.min(1000, baseMs));
  return Math.min(maxMs, baseMs * (2 ** (n - 1)) + jitter);
}

function shouldRetryReplyJob(err, job = {}) {
  if (Number(job.attempts || 0) >= replyJobMaxAttempts()) return false;
  if (isRetryableAgentDecisionError(err)) return true;
  return isTransientRequestError(err);
}

function isTransientRequestError(err) {
  const status = Number(err?.status ?? err?.statusCode ?? 0);
  if (status === 408 || status === 409 || status === 425 || status === 429 || status >= 500) return true;
  const haystack = [
    err?.name,
    err?.constructor?.name,
    err?.code,
    err?.type,
    err?.message,
    err?.cause?.code,
    err?.cause?.message,
    err?.stack,
  ].filter(Boolean).join(" ");
  return /APIConnectionTimeoutError|APIConnectionError|Request timed out|timed?\s*out|timeout|fetch failed|network|socket hang up|ECONNRESET|ECONNREFUSED|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|UND_ERR/i.test(haystack);
}

function appendAndBroadcastSession(messages, extra = {}) {
  const saved = appendSession(messages);
  broadcastSse("session:append", {
    messages: saved,
    now: new Date().toISOString(),
    ...extra,
  });
  return saved;
}

function updateAndBroadcastSessionMessage(id, patch = {}, extra = {}) {
  let saved = null;
  try {
    saved = updateSessionMessage(id, patch);
  } catch (err) {
    console.error("会话消息更新失败:", err);
    return null;
  }
  if (!saved) return null;
  broadcastSse("session:append", {
    messages: [saved],
    now: new Date().toISOString(),
    ...extra,
  });
  return saved;
}

function scheduleHerMessages(messages, meta = {}) {
  const list = Array.isArray(messages) ? messages : [messages];
  const rows = enqueueDeliveryOutbox(list, meta);
  scheduleDeliveryOutboxPump();
  return rows;
}

function latestDeliveryDueAt(rows = []) {
  let latestMs = 0;
  let latest = "";
  for (const row of rows || []) {
    const dueMs = new Date(row?.dueAt || "").getTime();
    if (Number.isFinite(dueMs) && dueMs >= latestMs) {
      latestMs = dueMs;
      latest = row.dueAt;
    }
  }
  return latest;
}

function scheduleDeliveryOutboxPump() {
  if (deliveryPumpTimer) clearTimeout(deliveryPumpTimer);
  const next = loadNextPendingDeliveryOutbox();
  if (!next) return;
  deliveryPumpTimer = setTimeout(() => {
    deliveryPumpTimer = null;
    deliveryChain = deliveryChain
      .then(() => pumpDeliveryOutbox())
      .catch((err) => {
        console.error("模型消息投递队列失败:", err);
        broadcastPresence("idle", { error: String(err.message ?? err) });
      });
  }, deliveryWakeDelay(next));
}

async function pumpDeliveryOutbox() {
  if (deliveryPumpActive) return;
  deliveryPumpActive = true;
  try {
    while (true) {
      const next = loadNextPendingDeliveryOutbox();
      if (!next) return;
      const waitMs = deliveryWakeDelay(next);
      if (waitMs > 25) return scheduleDeliveryOutboxPump();
      await deliverOutboxRow(next.id);
    }
  } finally {
    deliveryPumpActive = false;
    scheduleDeliveryOutboxPump();
  }
}

async function deliverOutboxRow(outboxId) {
  const row = markDeliveryOutboxDelivering(outboxId);
  if (!row) return;
  recordProactiveOutboxEvent("delivery_started", row);
  try {
    const planned = normalizeMessage({
      ...row.message,
      id: row.messageId || row.message?.id,
    });
    const delayMs = clampInt(planned.meta?.delayMs, 0, 10 * 60_000, 1200);
    const sendStatus = planned.meta?.sendStatus || statusForMessageType(planned.type);
    const composeMs = composeWindowMs(planned);
    const idleMs = Math.max(0, msUntil(row.dueAt) - composeMs);
    if (idleMs > 800) {
      broadcastPresence("idle", {
        messageId: planned.id,
        traceId: row.meta?.traceId || planned.meta?.traceId || "",
        reason: row.meta?.reason || planned.meta?.deliveryReason || "",
      });
      await sleep(idleMs);
    }
    if (loadDeliveryOutboxRow(row.id)?.status !== "delivering") return;
    broadcastPresence(sendStatus, {
      messageId: planned.id,
      traceId: row.meta?.traceId || planned.meta?.traceId || "",
      delayMs,
      reason: row.meta?.reason || planned.meta?.deliveryReason || "",
    });
    await sleep(Math.max(0, msUntil(row.dueAt)));
    if (loadDeliveryOutboxRow(row.id)?.status !== "delivering") return;

    const deliveredAt = new Date().toISOString();
    const delivered = normalizeMessage({
      ...planned,
      id: row.messageId || planned.id,
      createdAt: deliveredAt,
      time: deliveredAt,
      meta: {
        ...(planned.meta || {}),
        deliveredAt,
        outboxId: row.id,
        traceId: row.meta?.traceId || planned.meta?.traceId || "",
      },
    });
    appendAndBroadcastSession(delivered, {
      reason: row.meta?.reason || planned.meta?.deliveryReason || "ai_reply",
      traceId: row.meta?.traceId || planned.meta?.traceId || "",
    });
    notifyDeliveredMessage(delivered);
    const deliveredRow = markDeliveryOutboxDelivered(row.id, deliveredAt);
    const attentionShift = confirmOutgoingDelivery({
      traceId: row.meta?.traceId || planned.meta?.traceId || "",
      deliveredAt,
    });
    if (attentionShift.shifted) {
      scheduleProactiveAt(attentionShift.attentionUntil, "delivery_timing_adjusted");
      recordAttentionRuntimeEvent("attention_timing_shifted", {
        traceId: row.meta?.traceId || planned.meta?.traceId || "",
        shiftMs: attentionShift.shiftMs,
        attentionTransitionAt: attentionShift.attentionTransitionAt,
        attentionUntil: attentionShift.attentionUntil,
      });
    }
    recordProactiveOutboxEvent("delivery_delivered", deliveredRow || row, {
      deliveredAt,
    }, "ok");
    broadcastAppStatus("ready", "");
    broadcastPresence("idle", {
      messageId: delivered.id,
      traceId: row.meta?.traceId || planned.meta?.traceId || "",
      reason: row.meta?.reason || planned.meta?.deliveryReason || "",
    });
    await sleep(180 + Math.random() * 420);
  } catch (err) {
    const failedRow = failDeliveryOutbox(row.id, String(err?.message ?? err));
    recordProactiveOutboxEvent("delivery_failed", failedRow || row, {
      error: String(err?.message ?? err),
    }, "error");
    throw err;
  }
}

function notifyDeliveredMessage(message) {
  if (message?.sender !== "her") return;
  if (!hasFocusedVisibleClient()) {
    const url = `http://127.0.0.1:${port}/#message=${encodeURIComponent(message.id)}`;
    notifier.notify({
      title: "clone-chat",
      message: "收到一条新消息",
      wait: true,
      sound: true,
    }, (error, response) => {
      if (error) console.warn("Windows 通知失败:", error.message || error);
      if (response === "activate") openNotificationUrl(url);
    });
  }
  void notifySubscribedDevices(message);
}

async function notifySubscribedDevices(message) {
  const subscriptions = loadPushSubscriptions();
  if (!subscriptions.length) return;
  const payload = createPrivacyPushPayload(message);
  let sent = 0;
  let removed = 0;
  for (const subscription of subscriptions) {
    if (subscription.deviceId && hasFocusedVisibleClient(subscription.deviceId)) continue;
    try {
      await sendWebPush(subscription, payload, { proxy: pushProxyUrl() });
      sent++;
    } catch (error) {
      if (requiresPushResubscription(error)) {
        removed += deletePushSubscription({ endpoint: subscription.endpoint });
      }
      console.warn("Web Push 投递失败:", describeWebPushError(error));
    }
  }
  if (sent || removed) console.log("Web Push 投递:", { sent, removed });
}

function openNotificationUrl(url) {
  if (process.platform !== "win32") return;
  try {
    const child = spawn("explorer.exe", [url], {
      detached: true,
      stdio: "ignore",
      windowsHide: true,
    });
    child.unref();
  } catch (error) {
    console.warn("打开通知目标失败:", error.message || error);
  }
}

function hasFocusedVisibleClient(deviceId = "") {
  const now = Date.now();
  for (const [clientId, state] of clientPresence.entries()) {
    if (!sseClients.has(clientId) || now - Number(state.updatedAt || 0) > 20_000) {
      clientPresence.delete(clientId);
      continue;
    }
    if (deviceId && state.deviceId !== deviceId) continue;
    if (state.focused && state.visible) return true;
  }
  return false;
}

function scheduleBackgroundMemoryIndex(delayMs = 5000) {
  if (String(process.env.LOCAL_MEMORY_BACKGROUND_INDEX ?? "1") === "0") return;
  if (memoryIndexTimer) clearTimeout(memoryIndexTimer);
  memoryIndexTimer = setTimeout(async () => {
    memoryIndexTimer = null;
    try {
      const result = await indexPendingConversationEvents({
        limit: clampInt(process.env.MEMORY_INDEX_BATCH_SIZE, 1, 32, 8),
      });
      console.log("本地记忆索引后台批次:", result);
      if (result.remaining) scheduleBackgroundMemoryIndex(30_000);
    } catch (error) {
      console.warn("本地向量索引暂不可用，FTS5 继续工作:", error.message || error);
      scheduleBackgroundMemoryIndex(10 * 60_000);
    }
  }, Math.max(1000, Number(delayMs) || 5000));
}

function deliveryWakeDelay(row) {
  try {
    const planned = normalizeMessage(row.message || {});
    const composeMs = composeWindowMs(planned);
    return Math.max(0, msUntil(row.dueAt) - composeMs);
  } catch {
    return timerDelayUntil(row?.dueAt);
  }
}

function clearRuntimeTimers() {
  if (replyPumpTimer) clearTimeout(replyPumpTimer);
  if (deliveryPumpTimer) clearTimeout(deliveryPumpTimer);
  proactiveScheduler.clear();
  replyPumpTimer = null;
  deliveryPumpTimer = null;
}

function msUntil(isoText) {
  const t = new Date(isoText || 0).getTime();
  if (!Number.isFinite(t)) return 0;
  return Math.max(0, t - Date.now());
}

function timerDelayUntil(isoText) {
  return Math.min(msUntil(isoText), 2_147_483_000);
}

async function deliverHerMessages(messages, meta = {}) {
  // 兼容旧调用方:任何直接调用也先进入持久化 outbox,不再只靠内存等待。
  scheduleHerMessages(messages, meta);
  try {
    await deliveryChain;
  } catch (err) {
      console.error("模型消息投递队列失败:", err);
      broadcastPresence("idle", { error: String(err.message ?? err) });
  }
}

function statusForMessageType(type) {
  if (type === "voice") return "recording";
  if (type === "sticker" || type === "image") return "sending";
  return "typing";
}

function composeWindowMs(message) {
  if (message.type === "voice") return Math.min(60_000, Number(message.duration || 0) * 1000 + 1500);
  if (message.type === "sticker" || message.type === "image") return 900;
  const len = [...String(message.text || "")].length;
  return Math.max(1500, Math.min(10_000, 1200 + len * 280));
}

function sleep(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

function safeClientMessageId(value) {
  const text = String(value || "").trim();
  if (!text) return "";
  return /^[a-zA-Z0-9_-]{3,80}$/.test(text) ? text : "";
}

function safeDeviceId(value) {
  return safeClientMessageId(value);
}

function pushProxyUrl() {
  return proxyStatus.enabled ? String(proxyStatus.httpsProxy || proxyStatus.httpProxy || "") : "";
}

function pushFailureMessage(details = {}) {
  if (details.reason === "VapidPkHashMismatch") return "推送密钥已变化，需要重新订阅";
  if ([404, 410].includes(Number(details.statusCode))) return "iPhone 推送订阅已失效，需要重新订阅";
  if (details.reason === "BadJwtToken") return "Apple 拒绝了推送服务身份，请重新测试";
  if (details.reason) return `Apple 推送服务拒绝请求：${details.reason}`;
  if (details.statusCode) return `推送服务返回 HTTP ${details.statusCode}`;
  return details.message || "测试通知发送失败，请检查系统代理和网络";
}

function lanIosPublicStatus(req) {
  const metadata = readJsonFile(lanIosMetadataFile);
  const requestHost = String(req?.hostname || "").trim();
  const primaryIp = String(metadata?.primaryIp || (/^\d+\.\d+\.\d+\.\d+$/.test(requestHost) ? requestHost : ""));
  return {
    httpsReady: httpsFilesReady(),
    httpsPort,
    httpsUrl: primaryIp ? `https://${primaryIp}:${httpsPort}` : "",
    caDownloadUrl: primaryIp ? `http://${primaryIp}:${port}/local-ca.cer` : "/local-ca.cer",
  };
}

function readJsonFile(file) {
  try {
    return JSON.parse(fs.readFileSync(file, "utf8"));
  } catch {
    return null;
  }
}

function httpsFilesReady() {
  return fs.existsSync(httpsCertificateFile) && fs.existsSync(httpsKeyFile);
}

function startHttpsServer() {
  if (String(process.env.WEB_PUSH_HTTPS_ENABLED ?? "1") === "0" || !httpsFilesReady()) {
    console.warn("⚠ iOS 通知 HTTPS 未启动；运行 npm run setup:lan-ios 后重启服务");
    return null;
  }
  const server = https.createServer({
    cert: fs.readFileSync(httpsCertificateFile),
    key: fs.readFileSync(httpsKeyFile),
  }, app);
  server.on("error", (error) => {
    console.error(`局域网 HTTPS ${httpsPort} 启动失败:`, error.message || error);
  });
  server.listen(httpsPort, host, () => {
    const metadata = readJsonFile(lanIosMetadataFile);
    const address = metadata?.primaryIp || host;
    console.log(`iOS 局域网通知入口: https://${address}:${httpsPort}`);
  });
  return server;
}

app.use((error, req, res, next) => {
  if (req.aborted || isRequestAbortedError(error)) {
    if (String(process.env.HTTP_ABORT_LOG ?? "0") === "1") {
      console.warn("HTTP 请求被客户端中止:", {
        method: req.method,
        path: req.path,
      });
    }
    if (!res.headersSent && !res.writableEnded) res.status(400).end();
    return;
  }
  if (res.headersSent) {
    next(error);
    return;
  }
  console.error("HTTP 请求失败:", describeRuntimeError(error));
  const status = Math.max(400, Math.min(599, Number(error?.status || error?.statusCode) || 500));
  res.status(status).json({ error: status >= 500 ? "服务器暂时不可用" : String(error?.message || "请求失败") });
});

app.listen(port, host, () => {
  console.log(`clone-chat 已启动: http://${host}:${port}`);
  startHttpsServer();
  if (proxyStatus.enabled) console.log("系统 HTTP 代理已接入:", proxyStatus);
  const recovery = recoverRuntimeWork();
  const attentionRepair = repairAttentionAfterOutgoingRace();
  const attentionPolicyMigration = prepareIncomingRecheckMigration();
  const pending = pendingRuntimeWorkCounts();
  if (
    recovery.replyJobsRecovered ||
    recovery.replyJobsCompletedFromOutbox ||
    recovery.deliveriesRecovered ||
    pending.replyQueued ||
    pending.deliveryPending
  ) {
    console.log("运行时队列恢复:", { recovery, attentionRepair, attentionPolicyMigration, pending });
  }
  scheduleReplyJobPump();
  scheduleDeliveryOutboxPump();
  restoreProactiveSchedule();
  compactExpiredAgentTraces(7);
  scheduleBackgroundMemoryIndex(5000);
  warnMissingLlmKey();
  if (!fs.existsSync(path.join(ROOT, "data", "history.jsonl"))) {
    console.warn("⚠ 还没有 data/history.jsonl(聊天记录记忆库),记忆检索会跳过");
  }
  if (!fs.existsSync(personaMediaDir)) {
    console.warn("⚠ 当前人物还没有私有媒体目录，历史媒体和人物表情可能无法显示");
  }
});

function repairAttentionAfterOutgoingRace() {
  const latestPersonaMessage = [...loadSession(80)]
    .reverse()
    .find((message) => message.sender === "her");
  const lastDeliveredAt = String(
    latestPersonaMessage?.meta?.deliveredAt
    || latestPersonaMessage?.createdAt
    || latestPersonaMessage?.time
    || "",
  );
  const repair = repairLegacyAttentionRace({ lastDeliveredAt });
  if (!repair.repaired) return repair;
  const released = releaseQueuedReplyJobs("legacy_attention_delivery_race");
  recordAttentionRuntimeEvent("attention_legacy_repaired", {
    lastDeliveredAt,
    releasedJobs: released.released,
    reason: "away_started_before_last_outgoing_delivery",
  }, "warn");
  return { ...repair, releasedJobs: released.released };
}

function prepareIncomingRecheckMigration() {
  const state = loadInnerState();
  if (!needsAttentionPolicyMigration(state)) return { needed: false, releasedJobs: 0 };
  const released = releaseQueuedReplyJobs("incoming_recheck_policy_migration");
  if (released.released) {
    recordAttentionRuntimeEvent("attention_policy_migration", {
      releasedJobs: released.released,
      reason: "waiting_messages_need_persona_reassessment",
    });
  }
  return { needed: true, releasedJobs: released.released };
}

function warnMissingLlmKey() {
  const provider = String(process.env.LLM_PROVIDER || "deepseek").trim().toLowerCase();
  if (provider === "openai" && !process.env.OPENAI_API_KEY) {
    console.warn("⚠ LLM_PROVIDER=openai 但还没配置 OPENAI_API_KEY");
  } else if (provider === "mimo" && !process.env.MIMO_API_KEY) {
    console.warn("⚠ LLM_PROVIDER=mimo 但还没配置 MIMO_API_KEY");
  } else if (provider === "deepseek" && !process.env.DEEPSEEK_API_KEY) {
    console.warn("⚠ LLM_PROVIDER=deepseek 但还没配置 DEEPSEEK_API_KEY");
  }
}