desktop-pet-app 0.3.24 → 0.4.1

package/out/main/index.js

@@ -29,13 +29,13 @@ const os = require("os");
 const node_crypto = require("node:crypto");
 const node_http = require("node:http");
 const node_os = require("node:os");
+const promises = require("node:fs/promises");
 const crypto = require("crypto");
 const WebSocket = require("ws");
+const node_child_process = require("node:child_process");
 const fs = require("fs");
-const promises = require("node:fs/promises");
 const node_stream = require("node:stream");
 const promises$1 = require("node:stream/promises");
-const node_child_process = require("node:child_process");
 const http = require("http");
 const ORDER = { debug: 10, info: 20, warn: 30, error: 40 };
 class Logger {
@@ -92,6 +92,7 @@ function resolvePortFile(env = process.env, homeDirectory = os.homedir()) {
 }
 const PORT_FILE = resolvePortFile();
 const LOCAL_PET_PROTOCOL_VERSION = "1.0";
+const MCP_BRIDGE_PROTOCOL_VERSION = "1.1";
 const LOCAL_PET_MAX_BODY_BYTES = 64 * 1024;
 const MAX_PETS = 4;
 const PET_WINDOW = { width: 200, height: 190 };
@@ -101,6 +102,75 @@ const PET_WINDOW_BY_SKIN = {
 const GREET_DISTANCE = 260;
 const GREET_COOLDOWN_MS = 15e3;
 const PROXIMITY_SCAN_MS = 500;
+const STATUS_LABELS = {
+  created: "正在安全打包工作区",
+  queued: "等待好友接单",
+  delivered: "已送达好友桌宠",
+  accepted: "好友已领取",
+  running: "好友正在执行",
+  needs_context: "等待补充资料",
+  cancelling: "正在取消",
+  completed: "任务已完成",
+  failed: "任务执行失败",
+  cancelled: "任务已取消",
+  expired: "任务已过期"
+};
+const PHASE_LABELS = {
+  receiving: "读取任务",
+  preparing: "准备工作区",
+  analyzing: "分析任务",
+  working: "实施处理",
+  testing: "运行验证",
+  packaging: "整理结果",
+  submitting: "回传结果"
+};
+const TERMINAL = /* @__PURE__ */ new Set(["completed", "failed", "cancelled", "expired"]);
+function taskPeer(task) {
+  return task.participantRole === "executor" ? task.envelope.from.userId : task.envelope.to.userId;
+}
+function taskTitle(task) {
+  return (task.envelope.title || task.envelope.objective).trim();
+}
+function isActiveTask(task) {
+  return !TERMINAL.has(task.status);
+}
+function taskActivity(task) {
+  const peer = taskPeer(task);
+  const rolePrefix = task.participantRole === "executor" ? `来自 @${peer}` : `交给 @${peer}`;
+  const progress = task.progress;
+  if (task.status === "completed") {
+    return { label: `${rolePrefix} · 已完成`, detail: task.result?.summary || taskTitle(task), tone: "success" };
+  }
+  if (task.status === "failed" || task.status === "cancelled" || task.status === "expired") {
+    return {
+      label: `${rolePrefix} · ${STATUS_LABELS[task.status]}`,
+      detail: task.result?.summary || taskTitle(task),
+      tone: "failed"
+    };
+  }
+  if (task.status === "needs_context" || task.status === "cancelling") {
+    return { label: `${rolePrefix} · ${STATUS_LABELS[task.status]}`, detail: taskTitle(task), tone: "blocked" };
+  }
+  if (progress && (task.status === "accepted" || task.status === "running")) {
+    return {
+      label: `${rolePrefix} · ${PHASE_LABELS[progress.phase]}`,
+      detail: progress.message,
+      tone: "working",
+      current: progress.current,
+      total: progress.total
+    };
+  }
+  return {
+    label: `${rolePrefix} · ${STATUS_LABELS[task.status]}`,
+    detail: taskTitle(task),
+    tone: task.status === "running" || task.status === "accepted" ? "working" : "waiting"
+  };
+}
+function taskMenuLabel(task) {
+  const view = taskActivity(task);
+  const compactTitle = taskTitle(task).replace(/\s+/g, " ").slice(0, 28);
+  return `${view.label}｜${compactTitle}${taskTitle(task).length > 28 ? "…" : ""}`;
+}
 const SKIN_IDS = [
   "codex",
   "claude",
@@ -292,6 +362,12 @@ class PetManager {
   lastGreetAt = /* @__PURE__ */ new Map();
   timer;
   petsVisible = true;
+  localDuty = false;
+  remoteDuty = /* @__PURE__ */ new Set();
+  remoteDutyKnown = false;
+  localAgentConnectionStatus = "disconnected";
+  remoteAgentConnectionStatuses = /* @__PURE__ */ new Map();
+  observableTasks = /* @__PURE__ */ new Map();
   register(id, win, skin, identity) {
     this.pets.set(id, { id, win, skin, identity });
     win.on("closed", () => this.pets.delete(id));
@@ -318,6 +394,58 @@ class PetManager {
       else pet.win.hide();
     }
   }
+  setLocalDuty(active) {
+    if (this.localDuty === active) return;
+    this.localDuty = active;
+    this.publishActivities();
+  }
+  isLocalOnDuty() {
+    return this.localDuty;
+  }
+  setLocalAgentConnectionStatus(status2) {
+    if (this.localAgentConnectionStatus === status2) return;
+    this.localAgentConnectionStatus = status2;
+    this.publishActivities();
+  }
+  getLocalAgentConnectionStatus() {
+    return this.localAgentConnectionStatus;
+  }
+  setRemoteDuty(usernames) {
+    this.remoteDutyKnown = true;
+    this.remoteDuty = new Set(usernames.map((username) => username.trim().toLowerCase()));
+    this.publishActivities();
+  }
+  /** undefined 表示尚未收到实时 presence，调用方可回退到后台快照。 */
+  getRemoteDuty(username) {
+    if (!this.remoteDutyKnown) return void 0;
+    return this.remoteDuty.has(username.trim().toLowerCase());
+  }
+  resetRemoteDuty() {
+    this.remoteDutyKnown = false;
+    this.remoteDuty.clear();
+    this.publishActivities();
+  }
+  setRemoteAgentConnectionStatuses(statuses) {
+    this.remoteAgentConnectionStatuses = new Map(
+      Object.entries(statuses).map(([username, status2]) => [username.trim().toLowerCase(), status2])
+    );
+    this.publishActivities();
+  }
+  syncObservableTasks(tasks) {
+    this.observableTasks = new Map(tasks.map((task) => [task.taskId, task]));
+    this.publishActivities();
+  }
+  updateObservableTask(task) {
+    this.observableTasks.set(task.taskId, task);
+    this.publishActivities();
+  }
+  observableTaskCount() {
+    return [...this.observableTasks.values()].filter(isActiveTask).length;
+  }
+  replayActivity(petId) {
+    const pet = this.pets.get(petId);
+    if (pet && !pet.win.isDestroyed()) this.publishPetActivity(pet);
+  }
   findRemoteFriend(username) {
     const normalized = username.trim().toLowerCase();
     return [...this.pets.values()].find(
@@ -331,6 +459,52 @@ class PetManager {
       dispatch({ type: "identity", label: presentation.badge, kind: pet.identity.kind }, pet.id);
     }
   }
+  publishActivities() {
+    for (const pet of this.pets.values()) {
+      if (!pet.win.isDestroyed()) this.publishPetActivity(pet);
+    }
+  }
+  publishPetActivity(pet) {
+    const agentStatus = pet.identity.kind === "primary" ? this.localAgentConnectionStatus : this.remoteAgentConnectionStatuses.get(pet.identity.username.toLowerCase());
+    if (agentStatus === "update-required") {
+      dispatch({
+        type: "activity",
+        label: pet.identity.kind === "primary" ? "需要重连 Agent" : `@${pet.identity.username} 需要重连 Agent`,
+        detail: "Desktop Pet 已更新，请重启或重新加载 MCP 连接",
+        tone: "blocked"
+      }, pet.id);
+      return;
+    }
+    const now = Date.now();
+    const tasks = [...this.observableTasks.values()].filter((task2) => pet.identity.kind === "primary" || taskPeer(task2).toLowerCase() === pet.identity.username.toLowerCase()).filter((task2) => isActiveTask(task2) || now - Date.parse(task2.updatedAt) < 5 * 6e4).sort((a, b) => {
+      const activeDelta = Number(isActiveTask(b)) - Number(isActiveTask(a));
+      return activeDelta || Date.parse(b.updatedAt) - Date.parse(a.updatedAt);
+    });
+    const task = tasks[0];
+    if (task) {
+      dispatch({ type: "activity", ...taskActivity(task) }, pet.id);
+      return;
+    }
+    if (pet.identity.kind === "primary" && this.localDuty) {
+      dispatch({
+        type: "activity",
+        label: "驻守中 · 等待好友任务",
+        detail: "Agent 已连接，收到任务会立即领取",
+        tone: "waiting"
+      }, pet.id);
+      return;
+    }
+    if (pet.identity.kind === "remote-friend" && this.remoteDuty.has(pet.identity.username.toLowerCase())) {
+      dispatch({
+        type: "activity",
+        label: `@${pet.identity.username} 正在驻守`,
+        detail: "可以向 TA 派发任务",
+        tone: "waiting"
+      }, pet.id);
+      return;
+    }
+    dispatch({ type: "activity" }, pet.id);
+  }
   checkProximity() {
     const arr = [...this.pets.values()].filter((p) => !p.win.isDestroyed());
     for (let i = 0; i < arr.length; i++) {
@@ -355,6 +529,54 @@ function center(bounds) {
   return { x: bounds.x + bounds.width / 2, y: bounds.y + bounds.height / 2 };
 }
 const petManager = new PetManager();
+const MAX_MENU_TASKS = 8;
+const MENU_REFRESH_INTERVAL_MS = 5e3;
+class BackgroundSnapshot {
+  constructor(now = Date.now) {
+    this.now = now;
+  }
+  entry;
+  pending;
+  read(key) {
+    return this.entry && Object.is(this.entry.key, key) ? this.entry.value : void 0;
+  }
+  refresh(key, loader, minIntervalMs = 0) {
+    if (this.entry && Object.is(this.entry.key, key) && this.now() - this.entry.refreshedAt < minIntervalMs) {
+      return Promise.resolve(this.entry.value);
+    }
+    if (this.pending && Object.is(this.pending.key, key)) return this.pending.promise;
+    const token = Symbol("menu-refresh");
+    const promise = Promise.resolve().then(loader).then((value) => {
+      if (this.pending?.token === token) {
+        this.entry = { key, value, refreshedAt: this.now() };
+      }
+      return value;
+    }).catch(() => this.read(key)).finally(() => {
+      if (this.pending?.token === token) this.pending = void 0;
+    });
+    this.pending = { key, token, promise };
+    return promise;
+  }
+  clear() {
+    this.entry = void 0;
+    this.pending = void 0;
+  }
+}
+function compactMenuText(value, maxLength) {
+  const compact = value.replace(/\s+/g, " ").trim();
+  if (compact.length <= maxLength) return compact;
+  if (maxLength <= 1) return compact.slice(0, maxLength);
+  return compact.slice(0, maxLength - 1).trimEnd() + "…";
+}
+function resolveFriendDuty(snapshotDuty, liveDuty) {
+  return liveDuty ?? snapshotDuty ?? false;
+}
+function menuTasks(tasks, limit = MAX_MENU_TASKS) {
+  return [...tasks].sort((a, b) => {
+    const activeDelta = Number(isActiveTask(b)) - Number(isActiveTask(a));
+    return activeDelta || Date.parse(b.updatedAt) - Date.parse(a.updatedAt);
+  }).slice(0, limit);
+}
 const OFFICIAL_SERVER_ROOT = "https://api.xinbit.top/desktop-pet";
 const OFFICIAL_PORTAL_ORIGIN = "https://deskpalai.com";
 const LEGACY_OFFICIAL_SERVER_HOSTS = "47.94.20.104".split(",").map((host) => host.trim()).filter(Boolean);
@@ -461,6 +683,38 @@ function relayURLFromHost(value) {
 function isLocalHost(value) {
   return /^(localhost|127\.0\.0\.1|\[::1\])(?::\d+)?(?:\/|$)/i.test(value.trim());
 }
+const INSTALLATION_ID_FILE = "update-installation-id";
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+let cachedInstallationID;
+async function installationID() {
+  if (cachedInstallationID) return cachedInstallationID;
+  const path2 = node_path.join(electron.app.getPath("userData"), INSTALLATION_ID_FILE);
+  let replaceInvalidFile = false;
+  try {
+    const stored = (await promises.readFile(path2, "utf8")).trim();
+    if (UUID_PATTERN.test(stored)) {
+      cachedInstallationID = stored;
+      return stored;
+    }
+    replaceInvalidFile = true;
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      logger.warn("could not read installation id", { error: String(error) });
+    }
+  }
+  const created = node_crypto.randomUUID();
+  await promises.mkdir(electron.app.getPath("userData"), { recursive: true });
+  try {
+    await promises.writeFile(path2, created, { flag: replaceInvalidFile ? "w" : "wx", mode: 384 });
+    cachedInstallationID = created;
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+    const stored = (await promises.readFile(path2, "utf8")).trim();
+    if (!UUID_PATTERN.test(stored)) throw new Error("设备安装标识无效");
+    cachedInstallationID = stored;
+  }
+  return cachedInstallationID;
+}
 const TASK_PROTOCOL_VERSION = "1.0";
 const WORKSPACE_SNAPSHOT_MIME = "application/vnd.desktop-pet.git-workspace-bundle";
 function taskParticipantRole(task, authenticatedUserId) {
@@ -541,9 +795,89 @@ const DEFAULT_EXECUTION_CAPABILITIES = [
   "browser",
   "document.create"
 ];
-function executionCapabilities(configured = process.env.DESKTOP_PET_EXECUTION_CAPABILITIES) {
-  const source = configured?.trim() || DEFAULT_EXECUTION_CAPABILITIES.join(",");
-  return [...new Set(source.split(",").map((value) => value.trim()).filter(Boolean))];
+const CAPABILITY_ALIASES = {
+  "fs.read": "filesystem.read",
+  "file.read": "filesystem.read",
+  "files.read": "filesystem.read",
+  read_file: "filesystem.read",
+  "workspace.read": "filesystem.read",
+  "fs.write": "filesystem.write",
+  "file.write": "filesystem.write",
+  "files.write": "filesystem.write",
+  write_file: "filesystem.write",
+  edit_file: "filesystem.write",
+  apply_patch: "filesystem.write",
+  "workspace.write": "filesystem.write",
+  "workspace.modify": "filesystem.write",
+  terminal: "shell",
+  exec: "shell",
+  "shell.exec": "shell",
+  "command.execute": "shell",
+  fetch: "network",
+  http: "network",
+  "web.request": "network",
+  "web.browser": "browser",
+  "document.write": "document.create",
+  "docs.create": "document.create",
+  node: "toolchain.node",
+  go: "toolchain.go",
+  golang: "toolchain.go",
+  git: "toolchain.git",
+  python: "toolchain.python",
+  python3: "toolchain.python",
+  npm: "toolchain.npm",
+  pnpm: "toolchain.pnpm",
+  yarn: "toolchain.yarn",
+  bun: "toolchain.bun",
+  rust: "toolchain.rust",
+  cargo: "toolchain.cargo",
+  java: "toolchain.java",
+  maven: "toolchain.maven",
+  mvn: "toolchain.maven",
+  gradle: "toolchain.gradle"
+};
+const TOOLCHAIN_PROBES = [
+  ["git", "toolchain.git"],
+  ["go", "toolchain.go"],
+  ["python3", "toolchain.python"],
+  ["npm", "toolchain.npm"],
+  ["pnpm", "toolchain.pnpm"],
+  ["yarn", "toolchain.yarn"],
+  ["bun", "toolchain.bun"],
+  ["rustc", "toolchain.rust"],
+  ["cargo", "toolchain.cargo"],
+  ["java", "toolchain.java"],
+  ["mvn", "toolchain.maven"],
+  ["gradle", "toolchain.gradle"]
+];
+let cachedDetectedCapabilities;
+function commandAvailable(command) {
+  const result = node_child_process.spawnSync(command, ["--version"], {
+    stdio: "ignore",
+    timeout: 1e3
+  });
+  return !result.error && result.status === 0;
+}
+function detectEnvironmentCapabilities(probe = commandAvailable) {
+  return [
+    "toolchain.node",
+    ...TOOLCHAIN_PROBES.filter(([command]) => probe(command)).map(([, capability]) => capability)
+  ];
+}
+function detectedEnvironmentCapabilities() {
+  if (!cachedDetectedCapabilities) cachedDetectedCapabilities = detectEnvironmentCapabilities();
+  return cachedDetectedCapabilities;
+}
+function normalizeCapabilities(values) {
+  return [
+    ...new Set(
+      values.map((value) => value.trim().toLowerCase()).filter(Boolean).map((value) => CAPABILITY_ALIASES[value] ?? value)
+    )
+  ];
+}
+function executionCapabilities(configured = process.env.DESKTOP_PET_EXECUTION_CAPABILITIES, detected = detectedEnvironmentCapabilities(), additional = process.env.DESKTOP_PET_ADDITIONAL_CAPABILITIES) {
+  const base = configured?.trim() ? configured.split(",") : [...DEFAULT_EXECUTION_CAPABILITIES, ...detected];
+  return normalizeCapabilities([...base, ...additional?.split(",") ?? []]);
 }
 function showDesktopNotification(title, body) {
   if (!electron.Notification.isSupported()) return;
@@ -622,9 +956,15 @@ const resultWaiters = /* @__PURE__ */ new Map();
 const p2pSignalListeners = /* @__PURE__ */ new Set();
 const leaseTimers = /* @__PURE__ */ new Map();
 const taskSequences = /* @__PURE__ */ new Map();
+const dutySessions = /* @__PURE__ */ new Set();
+const pendingDutyStops = /* @__PURE__ */ new Map();
+let dutyPublished = false;
+let mcpConnectionStatus = "disconnected";
+let observedMcpBridgeVersion;
 let ws = null;
 let connectPromise = null;
 let intentionalClose = false;
+let authenticationBlocked = !allowDevelopmentOverrides && !authToken;
 let protocolV1Available = false;
 let workspaceSnapshotStagingAvailable = false;
 let mcpRegistration;
@@ -663,12 +1003,7 @@ function isWorkspaceSnapshotStagingAvailable() {
 }
 function getRelayHTTPAuth() {
   if (!authToken) throw new Error("relay device access token is unavailable");
-  const url = new URL(serverURL);
-  url.protocol = url.protocol === "wss:" ? "https:" : "http:";
-  url.pathname = "";
-  url.search = "";
-  url.hash = "";
-  return { baseURL: url.toString().replace(/\/$/, ""), accessToken: authToken, deviceId: deviceID };
+  return { baseURL: relayHTTPRootURL(serverURL), accessToken: authToken, deviceId: deviceID };
 }
 function configureRelayIdentity(config) {
   if (ws || connectPromise) throw new Error("stop relay before changing identity");
@@ -677,6 +1012,7 @@ function configureRelayIdentity(config) {
   deviceID = config.deviceId;
   authToken = config.accessToken;
   signingPrivateKey = config.signingPrivateKey ?? "";
+  authenticationBlocked = false;
 }
 function clearRelayIdentity() {
   if (ws || connectPromise) throw new Error("stop relay before clearing identity");
@@ -685,9 +1021,22 @@ function clearRelayIdentity() {
   deviceID = allowDevelopmentOverrides ? process.env.DESKTOP_PET_DEVICE_ID?.trim() || "" : "";
   authToken = allowDevelopmentOverrides ? process.env.DESKTOP_PET_TOKEN?.trim() : void 0;
   signingPrivateKey = "";
-}
-async function registerMcpClient(agentHost, capabilities = {}) {
-  mcpRegistration = { agentHost, capabilities };
+  authenticationBlocked = !allowDevelopmentOverrides && !authToken;
+}
+function isRelayAuthenticationBlocked() {
+  return authenticationBlocked;
+}
+async function registerMcpClient(agentHost, capabilities = {}, hostExecutionCapabilities) {
+  const sanitizedExecutionCapabilities = hostExecutionCapabilities ? [
+    ...new Set(
+      hostExecutionCapabilities.map((value) => value.trim().toLowerCase()).filter((value) => /^[a-z0-9][a-z0-9._-]{0,63}$/.test(value))
+    )
+  ].slice(0, 100) : void 0;
+  mcpRegistration = {
+    agentHost,
+    capabilities,
+    executionCapabilities: sanitizedExecutionCapabilities
+  };
   await ensureConnected();
   ws?.send(
     JSON.stringify({
@@ -698,6 +1047,22 @@ async function registerMcpClient(agentHost, capabilities = {}) {
     })
   );
 }
+function recordMcpBridgeActivity(version) {
+  const nextStatus = version === MCP_BRIDGE_PROTOCOL_VERSION ? "ready" : "update-required";
+  const changed = mcpConnectionStatus !== nextStatus || observedMcpBridgeVersion !== version;
+  mcpConnectionStatus = nextStatus;
+  observedMcpBridgeVersion = version;
+  petManager.setLocalAgentConnectionStatus(nextStatus);
+  if (changed) {
+    logger.info("MCP bridge compatibility changed", {
+      status: nextStatus,
+      observedVersion: version ?? "missing",
+      requiredVersion: MCP_BRIDGE_PROTOCOL_VERSION
+    });
+    publishDeviceCapabilities();
+  }
+  return nextStatus === "ready";
+}
 function startRelay() {
   intentionalClose = false;
   retryAttempt = 0;
@@ -709,6 +1074,8 @@ function stopRelay() {
   intentionalClose = true;
   protocolV1Available = false;
   workspaceSnapshotStagingAvailable = false;
+  dutyPublished = false;
+  petManager.resetRemoteDuty();
   cancelRelayReconnect();
   retryAttempt = 0;
   connectPromise = null;
@@ -752,6 +1119,7 @@ function stopRelay() {
 function ensureConnected() {
   if (ws && ws.readyState === WebSocket.OPEN) return Promise.resolve();
   if (connectPromise) return connectPromise;
+  if (authenticationBlocked) return Promise.reject(relayAuthenticationError());
   connectPromise = new Promise((resolve, reject) => {
     let settled = false;
     let authRejected = false;
@@ -781,6 +1149,7 @@ function ensureConnected() {
       if (msg.task) msg.task = withParticipantRole(msg.task);
       if (msg.tasks) msg.tasks = msg.tasks.map(withParticipantRole);
       if (msg.type === "registered") {
+        authenticationBlocked = false;
         retryAttempt = 0;
         protocolV1Available = msg.protocolVersion === TASK_PROTOCOL_VERSION;
         workspaceSnapshotStagingAvailable = msg.capabilities?.workspaceSnapshotStaging === true;
@@ -789,6 +1158,11 @@ function ensureConnected() {
           settled = true;
           resolve();
         }
+        if (dutySessions.size > 0) void publishDutyState(true);
+        void refreshObservableTasks();
+      } else if (msg.type === "presence") {
+        petManager.setRemoteDuty(msg.duty ?? []);
+        petManager.setRemoteAgentConnectionStatuses(msg.agentStatuses ?? {});
       } else if (msg.type === "error" && msg.messageId) {
         const pending = pendingRPCs.get(msg.messageId);
         if (pending) {
@@ -804,6 +1178,7 @@ function ensureConnected() {
         clearTimeout(pending.timer);
         pending.resolve(msg);
       } else if (msg.type === "task.available") {
+        if (msg.task) petManager.updateObservableTask(msg.task);
         const sender = msg.from ?? msg.task?.envelope.from.userId;
         if (sender) showRemoteFriendVisitor(sender, msg.skin, "有新的远端任务");
         if (msg.taskId && sock.readyState === WebSocket.OPEN) {
@@ -827,9 +1202,10 @@ function ensureConnected() {
       } else if (msg.type === "task.capability.unavailable") {
         showCapabilityUnavailable(msg);
       } else if (msg.type === "task.updated" && msg.task) {
+        petManager.updateObservableTask(msg.task);
         if (isTerminalTaskStatus(msg.task.status) || msg.task.status === "cancelling") stopLease(msg.task.taskId);
         if (msg.task.status === "running" && msg.task.assignedDeviceId === deviceID) startLease(msg.task.taskId);
-        showCapabilityGapResult(msg.task);
+        showExecutionBlockerResult(msg.task);
         notifyResultWaiters(msg.task);
       } else if (msg.type.startsWith("p2p.") && msg.type !== "p2p.forwarded") {
         if (!verifyP2PSignal(msg)) {
@@ -877,13 +1253,13 @@ function ensureConnected() {
       }
     });
     sock.on("error", (err) => {
-      if (/Unexpected server response: 40\d/.test(String(err))) authRejected = true;
+      if (/Unexpected server response: (?:401|403)/.test(String(err))) {
+        authRejected = true;
+        if (ws === sock) authenticationBlocked = true;
+      }
       logger.warn("relay socket error", { error: String(err) });
       if (!settled) {
         settled = true;
-        if (ws === sock) {
-          connectPromise = null;
-        }
         reject(err);
       }
     });
@@ -905,6 +1281,7 @@ function ensureConnected() {
       }
       if (isCurrentSocket && !intentionalClose) {
         if (authRejected) {
+          authenticationBlocked = true;
           logger.warn("relay rejected by server authentication; auto reconnect paused until identity changes", {
             server: serverURL,
             authenticated: Boolean(authToken)
@@ -917,6 +1294,13 @@ function ensureConnected() {
   });
   return connectPromise;
 }
+function relayAuthenticationError() {
+  const error = new Error(
+    authToken ? "中转服务认证已失效，请重新登录桌宠账号" : "请先登录桌宠账号后再使用协作功能"
+  );
+  error.code = "RELAY_AUTH_REQUIRED";
+  return error;
+}
 async function askFriend(opts) {
   await ensureConnected();
   const questionId = crypto.randomUUID();
@@ -974,7 +1358,46 @@ async function askFriend(opts) {
 }
 async function getCollaborationState() {
   const response = await relayRPC({ type: "help.list" }, 1e4);
-  return { friends: response.friends ?? [], helpRequests: response.helpRequests ?? [] };
+  const friends = response.friends ?? [];
+  petManager.setRemoteDuty(
+    friends.filter((friend) => friend.duty).map((friend) => friend.username)
+  );
+  petManager.setRemoteAgentConnectionStatuses(
+    Object.fromEntries(
+      friends.flatMap((friend) => friend.agentStatus ? [[friend.username, friend.agentStatus]] : [])
+    )
+  );
+  const tasks = protocolV1Available ? await listRemoteTasks({ limit: 20 }).catch(() => []) : [];
+  return { friends, helpRequests: response.helpRequests ?? [], tasks };
+}
+async function updateDutySession(sessionId, active) {
+  const pendingStop = pendingDutyStops.get(sessionId);
+  if (pendingStop) {
+    clearTimeout(pendingStop);
+    pendingDutyStops.delete(sessionId);
+  }
+  if (!active) {
+    pendingDutyStops.set(sessionId, setTimeout(() => {
+      pendingDutyStops.delete(sessionId);
+      void updateDutySessionNow(sessionId, false);
+    }, 2500));
+    return;
+  }
+  await updateDutySessionNow(sessionId, true);
+}
+async function updateDutySessionNow(sessionId, active) {
+  const before = dutySessions.size > 0;
+  if (active) dutySessions.add(sessionId);
+  else dutySessions.delete(sessionId);
+  const after = dutySessions.size > 0;
+  petManager.setLocalDuty(after);
+  if (before !== after || dutyPublished !== after) {
+    try {
+      await publishDutyState(after);
+    } catch (error) {
+      logger.warn("relay does not accept duty presence yet", { error: String(error) });
+    }
+  }
 }
 async function requestFriendHelp(to) {
   const response = await relayRPC({ type: "help.request", to }, 1e4);
@@ -1032,6 +1455,7 @@ async function delegateTask(envelope) {
     15e3
   );
   if (!response.task) throw new Error("relay did not return the created task");
+  petManager.updateObservableTask(response.task);
   if (response.warning) {
     logger.warn("task created with delivery warning", { warning: response.warning });
     dispatch({ type: "state", state: "failed", ttl: 10 });
@@ -1046,6 +1470,7 @@ async function finalizeRemoteTaskWorkspace(taskId) {
     15e3
   );
   if (!response.task) throw new Error("relay did not return the finalized task");
+  petManager.updateObservableTask(response.task);
   return { task: response.task, warning: response.warning };
 }
 function relayCapabilities() {
@@ -1056,19 +1481,35 @@ function relayCapabilities() {
       sampling: false,
       roots: true,
       tasks: true,
-      ...mcpRegistration?.capabilities ?? {}
+      ...mcpRegistration?.capabilities ?? {},
+      connectionStatus: mcpConnectionStatus,
+      ...observedMcpBridgeVersion ? { bridgeProtocolVersion: observedMcpBridgeVersion } : {}
     },
-    execution: executionCapabilities(),
+    execution: currentExecutionCapabilities(),
     platform: `${process.platform}-${process.arch}`
   };
 }
+function currentExecutionCapabilities() {
+  return mcpRegistration?.executionCapabilities ?? executionCapabilities();
+}
+function publishDeviceCapabilities() {
+  if (!ws || ws.readyState !== WebSocket.OPEN) return;
+  ws.send(
+    JSON.stringify({
+      type: "device.capabilities",
+      protocolVersion: TASK_PROTOCOL_VERSION,
+      messageId: crypto.randomUUID(),
+      capabilities: relayCapabilities()
+    })
+  );
+}
 function showCapabilityUnavailable(msg) {
   const required = msg.requiredCapabilities ?? [];
-  const available = new Set(executionCapabilities());
+  const available = new Set(currentExecutionCapabilities());
   const missing = required.filter((capability) => !available.has(capability));
   const named = (missing.length > 0 ? missing : required).join("、") || "所需工具";
   const sender = msg.from ? `@${msg.from} 的` : "这项";
-  const text = `暂时无法帮忙：${sender}任务需要 ${named}。请在当前 Agent 中安装或启用对应工具后重新连接桌宠。`;
+  const text = `暂时无法匹配：${sender}任务强制要求 ${named}，但当前设备未通过对应能力声明。可让发起方改为 ignore，或补齐工具链/服务后重连。`;
   dispatch({ type: "state", state: "failed", ttl: 12 });
   dispatch({ type: "bubble", text, ttl: 18e3 });
   showDesktopNotification("桌宠暂时无法接单", text);
@@ -1079,6 +1520,7 @@ async function getRemoteTask(taskId) {
     1e4
   );
   if (!response.task) throw new Error("relay did not return task details");
+  petManager.updateObservableTask(response.task);
   return response.task;
 }
 async function listRemoteTasks(options) {
@@ -1092,12 +1534,21 @@ async function listRemoteTasks(options) {
     },
     1e4
   );
-  return response.tasks ?? [];
+  const tasks = response.tasks ?? [];
+  if (!options.direction && !options.status) petManager.syncObservableTasks(tasks);
+  return tasks;
 }
 async function claimRemoteTask(timeoutMs = 45e3) {
   const immediate = await claimOnce();
   if (immediate) {
+    petManager.updateObservableTask(immediate);
     startLease(immediate.taskId);
+    void reportRemoteTaskProgress(immediate.taskId, {
+      phase: "receiving",
+      message: "任务已领取，正在读取目标和交付约束",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }).catch(() => {
+    });
     dispatch({ type: "state", state: "working", ttl: 30 });
     return immediate;
   }
@@ -1122,7 +1573,14 @@ async function claimRemoteTask(timeoutMs = 45e3) {
   if (!available) return null;
   const claimed = await claimOnce();
   if (claimed) {
+    petManager.updateObservableTask(claimed);
     startLease(claimed.taskId);
+    void reportRemoteTaskProgress(claimed.taskId, {
+      phase: "receiving",
+      message: "任务已领取，正在读取目标和交付约束",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }).catch(() => {
+    });
     dispatch({ type: "state", state: "working", ttl: 30 });
   }
   return claimed;
@@ -1156,26 +1614,42 @@ async function submitRemoteTaskResult(result) {
     15e3
   );
   stopLease(result.taskId);
+  void getRemoteTask(result.taskId).then((task) => petManager.updateObservableTask(task)).catch(() => {
+  });
   dispatch({ type: "state", state: result.status === "completed" ? "success" : "failed", ttl: 12 });
-  const gap = result.diagnostics.find((diagnostic) => diagnostic.code === "CAPABILITY_UNAVAILABLE");
-  if (gap) {
-    dispatch({ type: "bubble", text: `暂时无法帮忙：${gap.message}`, ttl: 18e3 });
-    showDesktopNotification("桌宠暂时无法接单", gap.message);
+  const blocker = result.diagnostics.find(
+    (diagnostic) => diagnostic.code === "CAPABILITY_UNAVAILABLE" || diagnostic.code === "EXECUTION_BLOCKED"
+  );
+  if (blocker) {
+    dispatch({ type: "bubble", text: `任务执行受阻：${blocker.message}`, ttl: 18e3 });
+    showDesktopNotification("桌宠任务执行受阻", blocker.message);
   }
 }
-function showCapabilityGapResult(task) {
-  const gap = task.result?.diagnostics.find((diagnostic) => diagnostic.code === "CAPABILITY_UNAVAILABLE");
-  if (!gap) return;
-  const text = `@${task.envelope.to.userId} 暂时无法帮助：${gap.message}`;
+async function reportRemoteTaskProgress(taskId, progress) {
+  const response = await relayRPC(
+    { type: "task.progress", protocolVersion: TASK_PROTOCOL_VERSION, taskId, payload: progress },
+    1e4
+  );
+  if (!response.task) throw new Error("relay did not return updated task progress");
+  petManager.updateObservableTask(response.task);
+  return response.task;
+}
+function showExecutionBlockerResult(task) {
+  const blocker = task.result?.diagnostics.find(
+    (diagnostic) => diagnostic.code === "CAPABILITY_UNAVAILABLE" || diagnostic.code === "EXECUTION_BLOCKED"
+  );
+  if (!blocker) return;
+  const text = `@${task.envelope.to.userId} 执行受阻：${blocker.message}`;
   dispatch({ type: "state", state: "failed", ttl: 12 });
   dispatch({ type: "bubble", text, ttl: 18e3 });
-  showDesktopNotification("桌宠任务无法完成", text);
+  showDesktopNotification("桌宠任务执行受阻", text);
 }
 async function cancelRemoteTask(taskId) {
   const response = await relayRPC(
     { type: "task.cancel", protocolVersion: TASK_PROTOCOL_VERSION, taskId },
     1e4
   );
+  if (response.task) petManager.updateObservableTask(response.task);
   return response.task;
 }
 function onP2PSignal(listener) {
@@ -1193,6 +1667,7 @@ async function requestRemoteTaskContext(taskId, request) {
     { type: "task.context.request", protocolVersion: TASK_PROTOCOL_VERSION, taskId, payload: request },
     1e4
   );
+  if (response.task) petManager.updateObservableTask(response.task);
   return response.task;
 }
 async function supplyRemoteTaskContext(taskId, items) {
@@ -1200,6 +1675,7 @@ async function supplyRemoteTaskContext(taskId, items) {
     { type: "task.context.supply", protocolVersion: TASK_PROTOCOL_VERSION, taskId, payload: { items } },
     15e3
   );
+  if (response.task) petManager.updateObservableTask(response.task);
   return response.task;
 }
 async function claimOnce() {
@@ -1244,6 +1720,8 @@ function notifyResultWaiters(task) {
 }
 function startLease(taskId) {
   stopLease(taskId);
+  void relayRPC({ type: "task.lease", protocolVersion: TASK_PROTOCOL_VERSION, taskId }, 1e4).catch(() => {
+  });
   const timer = setInterval(() => {
     void relayRPC({ type: "task.lease", protocolVersion: TASK_PROTOCOL_VERSION, taskId }, 1e4).catch(() => {
       stopLease(taskId);
@@ -1251,6 +1729,16 @@ function startLease(taskId) {
   }, 3e4);
   leaseTimers.set(taskId, timer);
 }
+async function publishDutyState(active) {
+  await relayRPC({ type: "duty.update", status: active ? "active" : "inactive" }, 1e4);
+  dutyPublished = active;
+}
+async function refreshObservableTasks() {
+  try {
+    await listRemoteTasks({ limit: 20 });
+  } catch {
+  }
+}
 function stopLease(taskId) {
   const timer = leaseTimers.get(taskId);
   if (timer) clearInterval(timer);
@@ -1352,13 +1840,13 @@ async function activateStoredDevice() {
   return true;
 }
 async function configureAndActivateDevice(credentials) {
-  const signedCredentials = withSigningKeys(credentials);
+  const signedCredentials = { ...credentials, ...ensureDeviceKeyMaterial(credentials) };
   saveDeviceCredentials(signedCredentials);
   await activateDevice(signedCredentials, true);
 }
 async function activateDevice(credentials, restart) {
   if (!credentials.publicKey || !credentials.privateKey || !credentials.encryptionPublicKey || !credentials.encryptionPrivateKey) {
-    credentials = withSigningKeys(credentials);
+    credentials = { ...credentials, ...ensureDeviceKeyMaterial(credentials) };
     saveDeviceCredentials(credentials);
   }
   const base = credentials.serverUrl.replace(/\/$/, "");
@@ -1368,6 +1856,7 @@ async function activateDevice(credentials, restart) {
     body: JSON.stringify({
       deviceId: credentials.deviceId,
       refreshToken: credentials.refreshToken,
+      installationId: await installationID(),
       publicKey: credentials.publicKey,
       encryptionPublicKey: credentials.encryptionPublicKey
     })
@@ -1406,29 +1895,35 @@ async function activateDevice(credentials, restart) {
     );
   }, refreshAt);
 }
-function withSigningKeys(credentials) {
-  let next = credentials;
-  if (!next.publicKey || !next.privateKey) {
-    const { publicKey, privateKey } = node_crypto.generateKeyPairSync("ed25519", {
+function ensureDeviceKeyMaterial(credentials = {}) {
+  let publicKey = credentials.publicKey;
+  let privateKey = credentials.privateKey;
+  let encryptionPublicKey = credentials.encryptionPublicKey;
+  let encryptionPrivateKey = credentials.encryptionPrivateKey;
+  if (!publicKey || !privateKey) {
+    const generated = node_crypto.generateKeyPairSync("ed25519", {
       publicKeyEncoding: { type: "spki", format: "pem" },
       privateKeyEncoding: { type: "pkcs8", format: "pem" }
     });
-    next = { ...next, publicKey, privateKey };
+    publicKey = generated.publicKey;
+    privateKey = generated.privateKey;
   }
-  if (!next.encryptionPublicKey || !next.encryptionPrivateKey) {
-    const { publicKey, privateKey } = node_crypto.generateKeyPairSync("rsa", {
+  if (!encryptionPublicKey || !encryptionPrivateKey) {
+    const generated = node_crypto.generateKeyPairSync("rsa", {
       modulusLength: 2048,
       publicKeyEncoding: { type: "spki", format: "pem" },
       privateKeyEncoding: { type: "pkcs8", format: "pem" }
     });
-    next = { ...next, encryptionPublicKey: publicKey, encryptionPrivateKey: privateKey };
+    encryptionPublicKey = generated.publicKey;
+    encryptionPrivateKey = generated.privateKey;
   }
-  return next;
+  return { publicKey, privateKey, encryptionPublicKey, encryptionPrivateKey };
 }
 const deviceAuth = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   activateStoredDevice,
   configureAndActivateDevice,
+  ensureDeviceKeyMaterial,
   getDeviceIceServers
 }, Symbol.toStringTag, { value: "Module" }));
 function defaultAccountServerURL(relayURL = configuredRelayURL()) {
@@ -1454,11 +1949,16 @@ async function bindDesktopPetToWebSession(server, accessToken) {
   if (!accessToken) throw new Error("网页没有返回有效的登录会话");
   const session = await get(serverUrl, "/api/auth/me", accessToken);
   if (!session.user?.username) throw new Error("服务器没有返回有效的账号信息");
+  const previousCredentials = reusableCredentials(serverUrl, session.user.username);
+  const keyMaterial = ensureDeviceKeyMaterial(previousCredentials);
   const device = await post(
     serverUrl,
     "/api/devices",
     {
       name: `Desktop Pet · ${node_os.hostname()}`,
+      installationId: await installationID(),
+      publicKey: keyMaterial.publicKey,
+      encryptionPublicKey: keyMaterial.encryptionPublicKey,
       capabilities: {
         agentHost: process.env.DESKTOP_PET_AGENT_HOST || "unknown-mcp-host",
         mcp: { tools: true, sampling: false, roots: true, tasks: true },
@@ -1473,10 +1973,20 @@ async function bindDesktopPetToWebSession(server, accessToken) {
     serverUrl,
     userId: session.user.username,
     deviceId: device.device.id,
-    refreshToken: device.refreshToken
+    refreshToken: device.refreshToken,
+    ...keyMaterial
   });
   return { username: session.user.username };
 }
+function reusableCredentials(serverUrl, username) {
+  try {
+    const credentials = loadDeviceCredentials();
+    if (!credentials || credentials.userId.toLowerCase() !== username.toLowerCase()) return void 0;
+    return normalizeServerURL(credentials.serverUrl) === serverUrl ? credentials : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function normalizeServerURL(value) {
   let url;
   try {
@@ -1890,7 +2400,7 @@ async function checkForUpdates(currentVersion = electron.app.getVersion()) {
     endpoint.searchParams.set("arch", process.arch);
     endpoint.searchParams.set("currentVersion", currentVersion);
     endpoint.searchParams.set("channel", updateChannel());
-    endpoint.searchParams.set("installationId", await updateInstallationID());
+    endpoint.searchParams.set("installationId", await installationID());
     const response = await electron.net.fetch(endpoint.toString(), {
       headers: { accept: "application/json" },
       signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
@@ -2389,34 +2899,6 @@ function updateChannel() {
   const channel = process.env.DESKTOP_PET_UPDATE_CHANNEL?.trim() || "stable";
   return /^[a-z][a-z0-9-]{0,31}$/.test(channel) ? channel : "stable";
 }
-let cachedInstallationID;
-async function updateInstallationID() {
-  if (cachedInstallationID) return cachedInstallationID;
-  const path2 = node_path.join(electron.app.getPath("userData"), "update-installation-id");
-  let replaceInvalidFile = false;
-  try {
-    const stored = (await promises.readFile(path2, "utf8")).trim();
-    if (/^[0-9a-f-]{36}$/i.test(stored)) {
-      cachedInstallationID = stored;
-      return stored;
-    }
-    replaceInvalidFile = true;
-  } catch (error) {
-    if (error.code !== "ENOENT") {
-      logger.warn("could not read update installation id", { error: String(error) });
-    }
-  }
-  const created = node_crypto.randomUUID();
-  await promises.mkdir(electron.app.getPath("userData"), { recursive: true });
-  try {
-    await promises.writeFile(path2, created, { flag: replaceInvalidFile ? "w" : "wx", mode: 384 });
-    cachedInstallationID = created;
-  } catch (error) {
-    if (error.code !== "EEXIST") throw error;
-    cachedInstallationID = (await promises.readFile(path2, "utf8")).trim();
-  }
-  return cachedInstallationID;
-}
 function asString(value) {
   return typeof value === "string" ? value.trim() : "";
 }
@@ -2454,6 +2936,7 @@ function humanizeUpdateError(error) {
   return "暂时无法检查更新";
 }
 const SKINS = SKIN_IDS.map((id) => ({ id, label: SKIN_LABELS[id] }));
+const collaborationSnapshot = new BackgroundSnapshot();
 let nextId = 1;
 function createPetWindow(skin, options) {
   if (petManager.count() >= MAX_PETS) {
@@ -2467,6 +2950,7 @@ function createPetWindow(skin, options) {
   const initialSize = PET_WINDOW_BY_SKIN[skin] ?? PET_WINDOW;
   let W = initialSize.width;
   let H = initialSize.height;
+  let menuOpen = false;
   const x = options.near?.x ?? workArea.x + workArea.width - W - 120;
   const y = options.near?.y ?? workArea.y + workArea.height - H - 60;
   const win = new electron.BrowserWindow({
@@ -2501,6 +2985,8 @@ function createPetWindow(skin, options) {
     dispatch({ type: "skin", skin: currentSkin }, id);
     const presentation = publishIdentity();
     dispatch({ type: "bubble", text: presentation.greeting }, id);
+    petManager.replayActivity(id);
+    refreshCollaborationSnapshot();
   });
   const publishIdentity = () => {
     const presentation = presentPetIdentity(identity, currentAccountUsername());
@@ -2518,17 +3004,30 @@ function createPetWindow(skin, options) {
     }
   };
   const onMenu = (e) => {
-    if (win.isDestroyed() || e.sender !== win.webContents) return;
-    void showPetMenu();
+    if (win.isDestroyed() || e.sender !== win.webContents || menuOpen) return;
+    showPetMenu();
   };
   const onMousePassthrough = (e, enabled) => {
     if (win.isDestroyed() || e.sender !== win.webContents || typeof enabled !== "boolean") return;
     win.setIgnoreMouseEvents(enabled, { forward: enabled });
   };
-  const showPetMenu = async () => {
+  const refreshCollaborationSnapshot = () => {
+    const username = currentAccountUsername();
+    if (!username) {
+      collaborationSnapshot.clear();
+      return;
+    }
+    void collaborationSnapshot.refresh(
+      username,
+      getCollaborationState,
+      MENU_REFRESH_INTERVAL_MS
+    );
+  };
+  const showPetMenu = () => {
     const accountUsername = currentAccountUsername();
     const identityPresentation = publishIdentity();
-    const collaboration = accountUsername ? await loadCollaborationState() : void 0;
+    const collaboration = accountUsername ? collaborationSnapshot.read(accountUsername) : void 0;
+    refreshCollaborationSnapshot();
     if (win.isDestroyed()) return;
     const incoming = collaboration?.helpRequests.filter(
       (request) => request.toUsername === accountUsername && request.status === "pending"
@@ -2536,6 +3035,7 @@ function createPetWindow(skin, options) {
     const friendItems = collaboration?.friends.map(
       (friend) => friendMenuItem(friend, collaboration, accountUsername ?? "", id)
     ) ?? [];
+    const activeTasks = collaboration?.tasks.filter(isActiveTask) ?? [];
     const menu = electron.Menu.buildFromTemplate([
       {
         label: identityPresentation.menuHeader,
@@ -2574,10 +3074,23 @@ function createPetWindow(skin, options) {
         }))
       },
       { type: "separator" },
+      {
+        label: "协作动态（" + activeTasks.length + " 项进行中）",
+        enabled: Boolean(accountUsername),
+        submenu: collaboration ? collaborationMenuItems(collaboration.tasks) : [
+          {
+            label: petManager.getLocalAgentConnectionStatus() === "update-required" ? "本机 Agent 需要重连以加载新版 MCP" : isRelayAuthenticationBlocked() ? "账号连接已失效，请重新登录" : petManager.isLocalOnDuty() ? "本机正在驻守 · 服务器状态暂不可用" : "正在刷新协作状态，请稍后再打开菜单",
+            enabled: false
+          }
+        ]
+      },
       {
         label: `好友状态${collaboration ? `（${collaboration.friends.length}）` : ""}`,
         enabled: Boolean(accountUsername),
-        submenu: collaboration ? friendItems.length > 0 ? friendItems : [{ label: "还没有好友，请先到个人后台添加", enabled: false }] : [{ label: accountUsername ? "暂时无法连接服务器" : "请先登录账号", enabled: false }]
+        submenu: collaboration ? friendItems.length > 0 ? friendItems : [{ label: "还没有好友，请先到个人后台添加", enabled: false }] : [{
+          label: accountUsername ? isRelayAuthenticationBlocked() ? "账号认证已失效，请点击上方账号重新登录" : "正在刷新好友状态，请稍后再打开菜单" : "请先登录账号",
+          enabled: false
+        }]
       },
       {
         label: `要我帮忙${incoming.length ? `（${incoming.length}）` : ""}`,
@@ -2621,6 +3134,10 @@ function createPetWindow(skin, options) {
       ...canSendAwayPet(identity) ? [{ label: "送走这只宠物", click: () => win.close() }] : [],
       { label: "退出", click: () => electron.app.quit() }
     ]);
+    menuOpen = true;
+    menu.once("menu-will-close", () => {
+      menuOpen = false;
+    });
     menu.popup({ window: win });
   };
   electron.ipcMain.on(PET_MOVE, onMove);
@@ -2706,17 +3223,8 @@ function updateMenuItems(petId) {
   }
   return items;
 }
-async function loadCollaborationState() {
-  try {
-    return await Promise.race([
-      getCollaborationState(),
-      new Promise((resolve) => setTimeout(() => resolve(void 0), 1800))
-    ]);
-  } catch {
-    return void 0;
-  }
-}
 function friendMenuItem(friend, state, currentUsername, petId) {
+  const activeTask = state.tasks.filter((task) => isActiveTask(task) && taskPeer(task).toLowerCase() === friend.username.toLowerCase()).sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt))[0];
   const outboundHelp = state.helpRequests.find(
     (request) => request.fromUsername === currentUsername && request.toUsername === friend.username
   );
@@ -2724,10 +3232,17 @@ function friendMenuItem(friend, state, currentUsername, petId) {
     (request) => request.status === "accepted" && (request.fromUsername === currentUsername && request.toUsername === friend.username || request.fromUsername === friend.username && request.toUsername === currentUsername)
   );
   const helpLabel = outboundHelp?.status === "accepted" ? " · TA 已同意帮我" : outboundHelp?.status === "pending" ? " · 求助待 TA 接受" : activeHelp ? " · 我正在帮 TA" : "";
+  const friendOnDuty = resolveFriendDuty(friend.duty, petManager.getRemoteDuty(friend.username));
+  const availability = friend.agentStatus === "update-required" ? " · Agent 需重连" : activeTask ? " · " + taskActivity(activeTask).label.split(" · ").at(-1) : friendOnDuty ? " · 已驻守" : friend.online && friend.agentStatus === "disconnected" ? " · Agent 未连接" : friend.online ? " · 在线，未驻守" : " · 离线";
   const chatMessages = ["你好呀！", "现在方便聊聊吗？", "谢谢你的帮助！"];
   return {
-    label: `${friend.online ? "●" : "○"} ${friend.displayName} (@${friend.username})${helpLabel}`,
+    label: friend.displayName + " (@" + friend.username + ")" + availability + helpLabel,
     submenu: [
+      {
+        label: friend.agentStatus === "update-required" ? "Desktop Pet 已更新，请 TA 重启或重新加载 Agent 的 MCP 连接" : activeTask ? "当前任务：" + taskActivity(activeTask).detail : friendOnDuty ? "Agent 正在驻守，等待好友任务" : friend.online && friend.agentStatus === "disconnected" ? "桌宠在线，但 Agent 尚未连接 MCP" : friend.online ? "桌宠在线，但 Agent 尚未驻守" : "桌宠当前离线",
+        enabled: false
+      },
+      { type: "separator" },
       {
         label: outboundHelp?.status === "accepted" ? "TA 已同意帮我（可让 Agent 派任务）" : outboundHelp?.status === "pending" ? "求助已发出，等 TA 接受" : "请 TA 帮我",
         enabled: outboundHelp?.status !== "accepted" && outboundHelp?.status !== "pending",
@@ -2767,6 +3282,35 @@ function friendMenuItem(friend, state, currentUsername, petId) {
     ]
   };
 }
+function collaborationMenuItems(tasks) {
+  const duty = {
+    label: petManager.getLocalAgentConnectionStatus() === "update-required" ? "本机 Agent：需要重连以加载新版 MCP" : petManager.isLocalOnDuty() ? "本机 Agent：驻守中，正在等待任务" : petManager.getLocalAgentConnectionStatus() === "disconnected" ? "本机 Agent：尚未连接 MCP" : "本机 Agent：未驻守",
+    enabled: false
+  };
+  if (tasks.length === 0) {
+    return [duty, { type: "separator" }, { label: "还没有远程任务记录", enabled: false }];
+  }
+  return [
+    duty,
+    { type: "separator" },
+    ...menuTasks(tasks).map((task) => {
+      const view = taskActivity(task);
+      const measured = view.current != null && view.total != null ? " · " + view.current + "/" + view.total : "";
+      const summary = task.result?.summary ? compactMenuText(task.result.summary, 80) : void 0;
+      return {
+        label: taskMenuLabel(task),
+        submenu: [
+          { label: "状态：" + view.label + measured, enabled: false },
+          { label: "当前步骤：" + compactMenuText(view.detail, 120), enabled: false },
+          { label: "协作好友：@" + taskPeer(task), enabled: false },
+          { label: "任务：" + compactMenuText(taskTitle(task), 90), enabled: false },
+          { label: "最近更新：" + new Date(task.updatedAt).toLocaleString(), enabled: false },
+          ...summary ? [{ label: "结果：" + summary, enabled: false }] : []
+        ]
+      };
+    })
+  ];
+}
 function runMenuAction(action, successText, petId) {
   void action.then(() => {
     dispatch({ type: "state", state: "excited", ttl: 6 }, petId);
@@ -2806,6 +3350,7 @@ const ErrorCodes = {
   UNKNOWN_TYPE: "UNKNOWN_TYPE",
   INTERNAL: "INTERNAL",
   UNSUPPORTED_PROTOCOL: "UNSUPPORTED_PROTOCOL",
+  MCP_UPDATE_REQUIRED: "MCP_UPDATE_REQUIRED",
   TASK_NOT_FOUND: "TASK_NOT_FOUND"
 };
 const ERROR_CODE_VALUES = new Set(Object.values(ErrorCodes));
@@ -2888,7 +3433,7 @@ function optString(v, max) {
 function isRelayCommand(raw) {
   if (!raw || typeof raw !== "object") return false;
   const t = raw.type;
-  return t === "ask" || t === "list_tasks" || t === "wait_task" || t === "answer" || t === "delegate_task" || t === "get_task" || t === "wait_task_result" || t === "claim_task" || t === "submit_task_result" || t === "cancel_task" || t === "list_remote_tasks" || t === "request_task_context" || t === "supply_task_context" || t === "configure_device" || t === "register_mcp_client" || t === "upload_relay_artifact" || t === "download_relay_artifact";
+  return t === "ask" || t === "list_tasks" || t === "wait_task" || t === "answer" || t === "delegate_task" || t === "get_task" || t === "wait_task_result" || t === "claim_task" || t === "submit_task_result" || t === "cancel_task" || t === "list_remote_tasks" || t === "request_task_context" || t === "supply_task_context" || t === "report_task_progress" || t === "configure_device" || t === "register_mcp_client" || t === "upload_relay_artifact" || t === "download_relay_artifact";
 }
 const RELAY_BLOB_TRANSFER_TIMEOUT_MS = 10 * 6e4;
 async function uploadRelayBlob(input) {
@@ -2924,7 +3469,7 @@ async function uploadRelayBlob(input) {
       signal: AbortSignal.timeout(RELAY_BLOB_TRANSFER_TIMEOUT_MS)
     }
   );
-  if (!response.ok) throw new Error(`relay blob upload failed (${response.status})`);
+  if (!response.ok) throw await relayBlobHTTPError("upload", response);
   return {
     id: artifactId,
     kind: normalizedKind,
@@ -2949,7 +3494,7 @@ async function downloadRelayBlob(taskId, artifact) {
       signal: AbortSignal.timeout(RELAY_BLOB_TRANSFER_TIMEOUT_MS)
     }
   );
-  if (!response.ok) throw new Error(`relay blob download failed (${response.status})`);
+  if (!response.ok) throw await relayBlobHTTPError("download", response);
   const metadataEncoded = response.headers.get("x-artifact-metadata") ?? "";
   const metadata = JSON.parse(Buffer.from(metadataEncoded, "base64url").toString("utf8"));
   const bytes = decryptForDevice(new Uint8Array(await response.arrayBuffer()), metadata.keyWraps, auth.deviceId, credentials.encryptionPrivateKey);
@@ -2989,6 +3534,28 @@ function decryptForDevice(ciphertext, wraps, deviceId, privateKey) {
 function normalizeResultKind(kind) {
   return kind === "text" || kind === "markdown" || kind === "patch" ? kind : "file";
 }
+async function relayBlobHTTPError(operation, response) {
+  let detail = "";
+  try {
+    const body = await response.text();
+    if (body.trim()) {
+      try {
+        const decoded = JSON.parse(body);
+        detail = typeof decoded.message === "string" ? decoded.message : body;
+      } catch {
+        detail = body.replace(/<[^>]*>/g, " ");
+      }
+      detail = detail.replace(/\s+/g, " ").trim().slice(0, 300);
+    }
+  } catch {
+  }
+  const server = response.headers.get("server")?.trim();
+  const suffix = [server ? `server=${server}` : "", detail].filter(Boolean).join("; ");
+  return new AppError(
+    ErrorCodes.RELAY_UNREACHABLE,
+    `relay blob ${operation} failed (${response.status})${suffix ? `: ${suffix}` : ""}`
+  );
+}
 function writeJSON(res, status2, body) {
   res.writeHead(status2, { "content-type": "application/json" });
   res.end(JSON.stringify(body));
@@ -3005,6 +3572,7 @@ function fail(res, status2, message, errorCode) {
 }
 class BodyTooLargeError extends Error {
 }
+const MCP_UPDATE_REQUIRED_MESSAGE = `Desktop Pet 已更新，当前 Agent 的 MCP 连接版本过旧（需要 ${MCP_BRIDGE_PROTOCOL_VERSION}）。请重启或重新加载 Agent 的 MCP 连接，然后再次开始驻守。`;
 function hasJSONContentType(req) {
   const value = req.headers["content-type"];
   return typeof value === "string" && value.toLowerCase().startsWith("application/json");
@@ -3066,6 +3634,11 @@ function startEventServer(appVersion = "0.0.0") {
       try {
         const raw = JSON.parse(await readBody(req, LOCAL_PET_MAX_BODY_BYTES));
         if (isRelayCommand(raw)) {
+          const compatible = recordMcpBridgeActivity(raw.mcpBridgeProtocolVersion);
+          if (!compatible && (raw.type === "wait_task" || raw.type === "register_mcp_client")) {
+            fail(res, 409, MCP_UPDATE_REQUIRED_MESSAGE, ErrorCodes.MCP_UPDATE_REQUIRED);
+            return;
+          }
           await handleRelay(raw, res);
           return;
         }
@@ -3117,7 +3690,7 @@ function startEventServer(appVersion = "0.0.0") {
 }
 function relayErrorHTTPStatus(code) {
   if (code === ErrorCodes.TASK_NOT_FOUND || code === ErrorCodes.UNKNOWN_QUESTION) return 404;
-  if (code === ErrorCodes.HELP_NOT_ACCEPTED || code === ErrorCodes.NOT_FRIENDS || code === ErrorCodes.USER_NOT_ONLINE || code === ErrorCodes.QUESTION_NOT_ASSIGNED) {
+  if (code === ErrorCodes.HELP_NOT_ACCEPTED || code === ErrorCodes.NOT_FRIENDS || code === ErrorCodes.USER_NOT_ONLINE || code === ErrorCodes.QUESTION_NOT_ASSIGNED || code === ErrorCodes.MCP_UPDATE_REQUIRED) {
     return 409;
   }
   return 400;
@@ -3150,6 +3723,7 @@ async function handleRelay(cmd, res) {
           },
           executionPolicy: {
             capabilities: ["filesystem.read"],
+            capabilityMode: "ignore",
             writableScopes: [],
             networkPolicy: "ask",
             approvalMode: "manual",
@@ -3196,14 +3770,20 @@ async function handleRelay(cmd, res) {
       return;
     }
     case "wait_task": {
-      if (isProtocolV1Available()) {
-        const taskV1 = await claimRemoteTask(cmd.timeoutMs);
-        ok(res, { taskV1 });
+      if (cmd.dutySessionId) await updateDutySession(cmd.dutySessionId, true);
+      try {
+        if (isProtocolV1Available()) {
+          const taskV1 = await claimRemoteTask(cmd.timeoutMs);
+          ok(res, { taskV1 });
+          return;
+        }
+        const task = await waitForPendingTask(cmd.timeoutMs);
+        ok(res, { task });
         return;
+      } finally {
+        if (cmd.dutySessionId) await updateDutySession(cmd.dutySessionId, false).catch(() => {
+        });
       }
-      const task = await waitForPendingTask(cmd.timeoutMs);
-      ok(res, { task });
-      return;
     }
     case "answer": {
       if (!cmd.questionId?.trim() || !cmd.text?.trim()) {
@@ -3306,7 +3886,7 @@ async function handleRelay(cmd, res) {
         fail(res, 400, "register_mcp_client requires agentHost", ErrorCodes.BAD_EVENT);
         return;
       }
-      await registerMcpClient(agentHost, cmd.mcpCapabilities ?? {});
+      await registerMcpClient(agentHost, cmd.mcpCapabilities ?? {}, cmd.executionCapabilities);
       ok(res);
       return;
     }
@@ -3357,6 +3937,11 @@ async function handleRelay(cmd, res) {
       ok(res, { task });
       return;
     }
+    case "report_task_progress": {
+      const task = await reportRemoteTaskProgress(cmd.taskId, cmd.progress);
+      ok(res, { task });
+      return;
+    }
     case "configure_device": {
       const { configureAndActivateDevice: configureAndActivateDevice2 } = await Promise.resolve().then(() => deviceAuth);
       await configureAndActivateDevice2({
@@ -3607,6 +4192,12 @@ function showMenu() {
   tray?.popUpContextMenu(electron.Menu.buildFromTemplate([
     { label: `Desktop Pet v${electron.app.getVersion()}`, enabled: false },
     { type: "separator" },
+    {
+      label: petManager.getLocalAgentConnectionStatus() === "update-required" ? "协作状态：需要重连 Agent" : petManager.observableTaskCount() > 0 ? `协作状态：${petManager.observableTaskCount()} 项任务进行中` : petManager.isLocalOnDuty() ? "协作状态：驻守中，等待好友任务" : "协作状态：空闲",
+      enabled: false
+    },
+    { label: "任务明细：右键桌宠查看", enabled: false },
+    { type: "separator" },
     {
       label: petManager.arePetsVisible() ? "隐藏所有桌面宠物" : "显示所有桌面宠物",
       click: () => petManager.setPetsVisible(!petManager.arePetsVisible())
@@ -3722,8 +4313,8 @@ electron.app.whenReady().then(async () => {
     return false;
   });
   logger.info("device activation finished", { activated });
-  if (!activated) startRelay();
-  logger.info("relay start requested", { authenticated: activated });
+  if (activated) logger.info("relay start requested", { authenticated: true });
+  else logger.info("relay waiting for account authentication");
   if (process.env.DESKTOP_PET_P2P !== "0") startP2PWindow(getDeviceIceServers());
   logger.info("p2p start requested", { enabled: process.env.DESKTOP_PET_P2P !== "0" });
   void startRunnerManager();