adhdev 0.8.35 → 0.8.36

package/dist/cli/index.js

@@ -67,6 +67,7 @@ function normalizeConfig(raw) {
   const parsed = isPlainObject(raw) ? raw : {};
   return {
     serverUrl: typeof parsed.serverUrl === "string" && parsed.serverUrl.trim() ? parsed.serverUrl : DEFAULT_CONFIG.serverUrl,
+    allowServerApiProxy: asBoolean(parsed.allowServerApiProxy, DEFAULT_CONFIG.allowServerApiProxy ?? false),
     selectedIde: asNullableString(parsed.selectedIde),
     configuredIdes: asStringArray(parsed.configuredIdes),
     installedExtensions: asStringArray(parsed.installedExtensions),
@@ -215,6 +216,7 @@ var init_config = __esm({
     import_crypto = require("crypto");
     DEFAULT_CONFIG = {
       serverUrl: "https://api.adhf.dev",
+      allowServerApiProxy: false,
       selectedIde: null,
       configuredIdes: [],
       installedExtensions: [],
@@ -4500,19 +4502,20 @@ function normalizeMessageTime(message) {
   }
   return msg;
 }
-function trimMessagesForStatus(messages) {
+function trimMessagesForStatus(messages, options) {
+  if (!options.includeMessages || options.messageLimit <= 0 || options.totalBytesLimit <= 0) return [];
   if (!Array.isArray(messages) || messages.length === 0) return [];
-  const recent = messages.slice(-STATUS_ACTIVE_CHAT_MESSAGE_LIMIT);
+  const recent = messages.slice(-options.messageLimit);
   const kept = [];
   let totalBytes = 0;
   for (let i = recent.length - 1; i >= 0; i -= 1) {
-    let normalized = normalizeMessageTime(trimMessageForStatus(recent[i], STATUS_ACTIVE_CHAT_STRING_LIMIT));
+    let normalized = normalizeMessageTime(trimMessageForStatus(recent[i], options.stringLimit));
     let size = estimateBytes(normalized);
-    if (size > STATUS_ACTIVE_CHAT_TOTAL_BYTES_LIMIT) {
-      normalized = normalizeMessageTime(trimMessageForStatus(recent[i], STATUS_ACTIVE_CHAT_FALLBACK_STRING_LIMIT));
+    if (size > options.totalBytesLimit) {
+      normalized = normalizeMessageTime(trimMessageForStatus(recent[i], options.fallbackStringLimit));
       size = estimateBytes(normalized);
     }
-    if (kept.length > 0 && totalBytes + size > STATUS_ACTIVE_CHAT_TOTAL_BYTES_LIMIT) {
+    if (kept.length > 0 && totalBytes + size > options.totalBytesLimit) {
       continue;
     }
     kept.push(normalized);
@@ -4542,22 +4545,26 @@ function isManagedStatusWorking(status) {
 function isManagedStatusWaiting(status, opts) {
   return normalizeManagedStatus(status, opts) === "waiting_approval";
 }
-function normalizeActiveChatData(activeChat) {
+function normalizeActiveChatData(activeChat, options = FULL_STATUS_ACTIVE_CHAT_OPTIONS) {
   if (!activeChat) return activeChat;
+  const resolvedOptions = {
+    ...FULL_STATUS_ACTIVE_CHAT_OPTIONS,
+    ...options
+  };
   return {
     ...activeChat,
     status: normalizeManagedStatus(activeChat.status, { activeModal: activeChat.activeModal }),
-    messages: trimMessagesForStatus(activeChat.messages),
-    activeModal: activeChat.activeModal ? {
+    messages: trimMessagesForStatus(activeChat.messages, resolvedOptions),
+    activeModal: resolvedOptions.includeActiveModal && activeChat.activeModal ? {
       message: truncateString(activeChat.activeModal.message || "", STATUS_MODAL_MESSAGE_LIMIT),
       buttons: (activeChat.activeModal.buttons || []).map(
         (button) => truncateString(String(button || ""), STATUS_MODAL_BUTTON_LIMIT)
       )
-    } : activeChat.activeModal,
-    inputContent: activeChat.inputContent ? truncateString(activeChat.inputContent, STATUS_INPUT_CONTENT_LIMIT) : activeChat.inputContent
+    } : null,
+    inputContent: resolvedOptions.includeInputContent && activeChat.inputContent ? truncateString(activeChat.inputContent, 2 * 1024) : void 0
   };
 }
-var WORKING_STATUSES, STATUS_ACTIVE_CHAT_MESSAGE_LIMIT, STATUS_ACTIVE_CHAT_TOTAL_BYTES_LIMIT, STATUS_ACTIVE_CHAT_STRING_LIMIT, STATUS_ACTIVE_CHAT_FALLBACK_STRING_LIMIT, STATUS_INPUT_CONTENT_LIMIT, STATUS_MODAL_MESSAGE_LIMIT, STATUS_MODAL_BUTTON_LIMIT;
+var WORKING_STATUSES, FULL_STATUS_ACTIVE_CHAT_OPTIONS, LIVE_STATUS_ACTIVE_CHAT_OPTIONS, STATUS_MODAL_MESSAGE_LIMIT, STATUS_MODAL_BUTTON_LIMIT;
 var init_normalize = __esm({
   "../../oss/packages/daemon-core/src/status/normalize.ts"() {
     "use strict";
@@ -4569,17 +4576,43 @@ var init_normalize = __esm({
       "thinking",
       "active"
     ]);
-    STATUS_ACTIVE_CHAT_MESSAGE_LIMIT = 60;
-    STATUS_ACTIVE_CHAT_TOTAL_BYTES_LIMIT = 96 * 1024;
-    STATUS_ACTIVE_CHAT_STRING_LIMIT = 4 * 1024;
-    STATUS_ACTIVE_CHAT_FALLBACK_STRING_LIMIT = 1024;
-    STATUS_INPUT_CONTENT_LIMIT = 2 * 1024;
+    FULL_STATUS_ACTIVE_CHAT_OPTIONS = {
+      includeMessages: true,
+      includeInputContent: true,
+      includeActiveModal: true,
+      messageLimit: 60,
+      totalBytesLimit: 96 * 1024,
+      stringLimit: 4 * 1024,
+      fallbackStringLimit: 1024
+    };
+    LIVE_STATUS_ACTIVE_CHAT_OPTIONS = {
+      includeMessages: false,
+      includeInputContent: false,
+      includeActiveModal: false,
+      messageLimit: 0,
+      totalBytesLimit: 0,
+      stringLimit: 512,
+      fallbackStringLimit: 256
+    };
     STATUS_MODAL_MESSAGE_LIMIT = 2 * 1024;
     STATUS_MODAL_BUTTON_LIMIT = 120;
   }
 });
 
 // ../../oss/packages/daemon-core/src/status/builders.ts
+function getActiveChatOptions(profile) {
+  if (profile === "full") return {};
+  return LIVE_STATUS_ACTIVE_CHAT_OPTIONS;
+}
+function shouldIncludeSessionControls(profile) {
+  return profile !== "live";
+}
+function shouldIncludeSessionMetadata(profile) {
+  return profile !== "live";
+}
+function shouldIncludeRuntimeMetadata(profile) {
+  return profile !== "live";
+}
 function findCdpManager(cdpManagers, key) {
   const exact = cdpManagers.get(key);
   if (exact) return exact;
@@ -4645,74 +4678,88 @@ function buildFallbackControls(providerControls, serverModel, serverMode, acpCon
   }
   return controls;
 }
-function buildIdeWorkspaceSession(state, cdpManagers) {
-  const activeChat = normalizeActiveChatData(state.activeChat);
+function buildIdeWorkspaceSession(state, cdpManagers, options) {
+  const profile = options.profile || "full";
+  const activeChat = normalizeActiveChatData(state.activeChat, getActiveChatOptions(profile));
+  const includeSessionMetadata = shouldIncludeSessionMetadata(profile);
+  const includeSessionControls = shouldIncludeSessionControls(profile);
   const title = activeChat?.title || state.name;
   return {
     id: state.instanceId || state.type,
     parentId: null,
     providerType: state.type,
-    providerName: state.name,
+    ...includeSessionMetadata && { providerName: state.name },
     kind: "workspace",
     transport: "cdp-page",
     status: normalizeManagedStatus(activeChat?.status || state.status, {
       activeModal: activeChat?.activeModal || null
     }),
     title,
-    workspace: state.workspace || null,
+    ...includeSessionMetadata && { workspace: state.workspace || null },
     activeChat,
-    capabilities: IDE_SESSION_CAPABILITIES,
+    ...includeSessionMetadata && { capabilities: IDE_SESSION_CAPABILITIES },
     cdpConnected: state.cdpConnected ?? isCdpConnected(cdpManagers, state.type),
     currentModel: state.currentModel,
     currentPlan: state.currentPlan,
     currentAutoApprove: state.currentAutoApprove,
-    controlValues: state.controlValues,
-    providerControls: buildFallbackControls(
-      state.providerControls,
-      state.currentModel,
-      state.currentPlan
-    ),
+    ...includeSessionControls && {
+      controlValues: state.controlValues,
+      providerControls: buildFallbackControls(
+        state.providerControls,
+        state.currentModel,
+        state.currentPlan
+      )
+    },
     errorMessage: state.errorMessage,
     errorReason: state.errorReason,
     lastUpdated: state.lastUpdated
   };
 }
-function buildExtensionAgentSession(parent, ext) {
-  const activeChat = normalizeActiveChatData(ext.activeChat);
+function buildExtensionAgentSession(parent, ext, options) {
+  const profile = options.profile || "full";
+  const activeChat = normalizeActiveChatData(ext.activeChat, getActiveChatOptions(profile));
+  const includeSessionMetadata = shouldIncludeSessionMetadata(profile);
+  const includeSessionControls = shouldIncludeSessionControls(profile);
   return {
     id: ext.instanceId || `${parent.instanceId}:${ext.type}`,
     parentId: parent.instanceId || parent.type,
     providerType: ext.type,
-    providerName: ext.name,
+    ...includeSessionMetadata && { providerName: ext.name },
     kind: "agent",
     transport: "cdp-webview",
     status: normalizeManagedStatus(activeChat?.status || ext.status, {
       activeModal: activeChat?.activeModal || null
     }),
     title: activeChat?.title || ext.name,
-    workspace: parent.workspace || null,
+    ...includeSessionMetadata && { workspace: parent.workspace || null },
     activeChat,
-    capabilities: EXTENSION_SESSION_CAPABILITIES,
+    ...includeSessionMetadata && { capabilities: EXTENSION_SESSION_CAPABILITIES },
     currentModel: ext.currentModel,
     currentPlan: ext.currentPlan,
-    controlValues: ext.controlValues,
-    providerControls: buildFallbackControls(
-      ext.providerControls,
-      ext.currentModel,
-      ext.currentPlan
-    ),
+    ...includeSessionControls && {
+      controlValues: ext.controlValues,
+      providerControls: buildFallbackControls(
+        ext.providerControls,
+        ext.currentModel,
+        ext.currentPlan
+      )
+    },
     errorMessage: ext.errorMessage,
     errorReason: ext.errorReason,
     lastUpdated: ext.lastUpdated
   };
 }
-function buildCliSession(state) {
-  const activeChat = normalizeActiveChatData(state.activeChat);
+function buildCliSession(state, options) {
+  const profile = options.profile || "full";
+  const activeChat = normalizeActiveChatData(state.activeChat, getActiveChatOptions(profile));
+  const includeSessionMetadata = shouldIncludeSessionMetadata(profile);
+  const includeRuntimeMetadata = shouldIncludeRuntimeMetadata(profile);
+  const includeSessionControls = shouldIncludeSessionControls(profile);
   return {
     id: state.instanceId,
     parentId: null,
     providerType: state.type,
-    providerName: state.name,
+    ...includeSessionMetadata && { providerName: state.name },
     providerSessionId: state.providerSessionId,
     kind: "agent",
     transport: "pty",
@@ -4720,74 +4767,85 @@ function buildCliSession(state) {
       activeModal: activeChat?.activeModal || null
     }),
     title: activeChat?.title || state.name,
-    workspace: state.workspace || null,
-    runtimeKey: state.runtime?.runtimeKey,
-    runtimeDisplayName: state.runtime?.displayName,
-    runtimeWorkspaceLabel: state.runtime?.workspaceLabel,
-    runtimeWriteOwner: state.runtime?.writeOwner || null,
-    runtimeAttachedClients: state.runtime?.attachedClients || [],
+    ...includeSessionMetadata && { workspace: state.workspace || null },
+    ...includeRuntimeMetadata && {
+      runtimeKey: state.runtime?.runtimeKey,
+      runtimeDisplayName: state.runtime?.displayName,
+      runtimeWorkspaceLabel: state.runtime?.workspaceLabel,
+      runtimeWriteOwner: state.runtime?.writeOwner || null,
+      runtimeAttachedClients: state.runtime?.attachedClients || []
+    },
     mode: state.mode,
     resume: state.resume,
     activeChat,
-    capabilities: state.mode === "terminal" ? PTY_SESSION_CAPABILITIES : CLI_CHAT_SESSION_CAPABILITIES,
-    controlValues: state.controlValues,
-    providerControls: buildFallbackControls(
-      state.providerControls
-    ),
+    ...includeSessionMetadata && {
+      capabilities: state.mode === "terminal" ? PTY_SESSION_CAPABILITIES : CLI_CHAT_SESSION_CAPABILITIES
+    },
+    ...includeSessionControls && {
+      controlValues: state.controlValues,
+      providerControls: buildFallbackControls(
+        state.providerControls
+      )
+    },
     errorMessage: state.errorMessage,
     errorReason: state.errorReason,
     lastUpdated: state.lastUpdated
   };
 }
-function buildAcpSession(state) {
-  const activeChat = normalizeActiveChatData(state.activeChat);
+function buildAcpSession(state, options) {
+  const profile = options.profile || "full";
+  const activeChat = normalizeActiveChatData(state.activeChat, getActiveChatOptions(profile));
+  const includeSessionMetadata = shouldIncludeSessionMetadata(profile);
+  const includeSessionControls = shouldIncludeSessionControls(profile);
   return {
     id: state.instanceId,
     parentId: null,
     providerType: state.type,
-    providerName: state.name,
+    ...includeSessionMetadata && { providerName: state.name },
     kind: "agent",
     transport: "acp",
     status: normalizeManagedStatus(activeChat?.status || state.status, {
       activeModal: activeChat?.activeModal || null
     }),
     title: activeChat?.title || state.name,
-    workspace: state.workspace || null,
+    ...includeSessionMetadata && { workspace: state.workspace || null },
     activeChat,
-    capabilities: ACP_SESSION_CAPABILITIES,
+    ...includeSessionMetadata && { capabilities: ACP_SESSION_CAPABILITIES },
     currentModel: state.currentModel,
     currentPlan: state.currentPlan,
-    acpConfigOptions: state.acpConfigOptions,
-    acpModes: state.acpModes,
-    controlValues: state.controlValues,
-    providerControls: buildFallbackControls(
-      state.providerControls,
-      state.currentModel,
-      state.currentPlan,
-      state.acpConfigOptions,
-      state.acpModes
-    ),
+    ...includeSessionControls && {
+      acpConfigOptions: state.acpConfigOptions,
+      acpModes: state.acpModes,
+      controlValues: state.controlValues,
+      providerControls: buildFallbackControls(
+        state.providerControls,
+        state.currentModel,
+        state.currentPlan,
+        state.acpConfigOptions,
+        state.acpModes
+      )
+    },
     errorMessage: state.errorMessage,
     errorReason: state.errorReason,
     lastUpdated: state.lastUpdated
   };
 }
-function buildSessionEntries(allStates, cdpManagers) {
+function buildSessionEntries(allStates, cdpManagers, options = {}) {
   const sessions = [];
   const ideStates = allStates.filter((s) => s.category === "ide");
   const cliStates = allStates.filter((s) => s.category === "cli");
   const acpStates = allStates.filter((s) => s.category === "acp");
   for (const state of ideStates) {
-    sessions.push(buildIdeWorkspaceSession(state, cdpManagers));
+    sessions.push(buildIdeWorkspaceSession(state, cdpManagers, options));
     for (const ext of state.extensions) {
-      sessions.push(buildExtensionAgentSession(state, ext));
+      sessions.push(buildExtensionAgentSession(state, ext, options));
     }
   }
   for (const state of cliStates) {
-    sessions.push(buildCliSession(state));
+    sessions.push(buildCliSession(state, options));
   }
   for (const state of acpStates) {
-    sessions.push(buildAcpSession(state));
+    sessions.push(buildAcpSession(state, options));
   }
   const extensionParentIds = new Set(
     sessions.filter((session) => session.transport === "cdp-webview" && !!session.parentId).map((session) => session.parentId)
@@ -4899,7 +4957,31 @@ var init_reconcile = __esm({
   }
 });
 
+// ../../oss/packages/daemon-core/src/providers/contracts.ts
+function flattenContent(content) {
+  if (typeof content === "string") return content;
+  return content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+}
+var init_contracts = __esm({
+  "../../oss/packages/daemon-core/src/providers/contracts.ts"() {
+    "use strict";
+  }
+});
+
 // ../../oss/packages/daemon-core/src/commands/chat-commands.ts
+function hashSignatureParts(parts) {
+  let hash2 = 2166136261;
+  for (const part of parts) {
+    const text = String(part || "");
+    for (let i = 0; i < text.length; i += 1) {
+      hash2 ^= text.charCodeAt(i);
+      hash2 = Math.imul(hash2, 16777619) >>> 0;
+    }
+    hash2 ^= 255;
+    hash2 = Math.imul(hash2, 16777619) >>> 0;
+  }
+  return hash2.toString(16).padStart(8, "0");
+}
 function getCurrentProviderType(h, fallback = "") {
   return h.currentSession?.providerType || h.currentProviderType || fallback;
 }
@@ -4973,6 +5055,134 @@ function parseMaybeJson(value) {
     return value;
   }
 }
+function getChatMessageSignature(message) {
+  if (!message) return "";
+  let content = "";
+  try {
+    content = JSON.stringify(message.content ?? "");
+  } catch {
+    content = String(message.content ?? "");
+  }
+  return hashSignatureParts([
+    String(message.id || ""),
+    String(message.index ?? ""),
+    String(message.role || ""),
+    String(message.receivedAt ?? message.timestamp ?? ""),
+    content
+  ]);
+}
+function normalizeReadChatCursor(args) {
+  const knownMessageCount = Math.max(0, Number(args?.knownMessageCount || 0));
+  const lastMessageSignature = typeof args?.lastMessageSignature === "string" ? args.lastMessageSignature : "";
+  const tailLimit = Math.max(0, Number(args?.tailLimit || 0));
+  return { knownMessageCount, lastMessageSignature, tailLimit };
+}
+function normalizeReadChatMessages(payload) {
+  const messages = Array.isArray(payload.messages) ? payload.messages : [];
+  return messages;
+}
+function deriveHistoryDedupKey(message) {
+  const unitKey = typeof message._unitKey === "string" ? message._unitKey.trim() : "";
+  if (unitKey) return `read_chat:${unitKey}`;
+  const turnKey = typeof message._turnKey === "string" ? message._turnKey.trim() : "";
+  if (!turnKey) return void 0;
+  let content = "";
+  try {
+    content = JSON.stringify(message.content ?? "");
+  } catch {
+    content = String(message.content ?? "");
+  }
+  return `read_chat:${turnKey}:${String(message.role || "").toLowerCase()}:${content}`;
+}
+function toHistoryPersistedMessages(messages) {
+  return messages.map((message) => ({
+    role: message.role,
+    content: flattenContent(message.content),
+    receivedAt: typeof message.receivedAt === "number" ? message.receivedAt : void 0,
+    kind: typeof message.kind === "string" ? message.kind : void 0,
+    senderName: typeof message.senderName === "string" ? message.senderName : void 0,
+    historyDedupKey: deriveHistoryDedupKey(message)
+  }));
+}
+function computeReadChatSync(messages, cursor) {
+  const totalMessages = messages.length;
+  const lastMessageSignature = getChatMessageSignature(messages[totalMessages - 1]);
+  const { knownMessageCount, lastMessageSignature: knownSignature } = cursor;
+  if (!knownMessageCount || !knownSignature) {
+    return {
+      syncMode: "full",
+      replaceFrom: 0,
+      messages,
+      totalMessages,
+      lastMessageSignature
+    };
+  }
+  if (knownMessageCount > totalMessages) {
+    return {
+      syncMode: "full",
+      replaceFrom: 0,
+      messages,
+      totalMessages,
+      lastMessageSignature
+    };
+  }
+  if (knownMessageCount === totalMessages && knownSignature === lastMessageSignature) {
+    return {
+      syncMode: "noop",
+      replaceFrom: totalMessages,
+      messages: [],
+      totalMessages,
+      lastMessageSignature
+    };
+  }
+  if (knownMessageCount < totalMessages) {
+    const anchorSignature = getChatMessageSignature(messages[knownMessageCount - 1]);
+    if (anchorSignature === knownSignature) {
+      return {
+        syncMode: "append",
+        replaceFrom: knownMessageCount,
+        messages: messages.slice(knownMessageCount),
+        totalMessages,
+        lastMessageSignature
+      };
+    }
+  }
+  const replaceFrom = Math.max(0, Math.min(knownMessageCount - 1, totalMessages));
+  return {
+    syncMode: replaceFrom === 0 ? "full" : "replace_tail",
+    replaceFrom,
+    messages: replaceFrom === 0 ? messages : messages.slice(replaceFrom),
+    totalMessages,
+    lastMessageSignature
+  };
+}
+function buildReadChatCommandResult(payload, args) {
+  const messages = normalizeReadChatMessages(payload);
+  const cursor = normalizeReadChatCursor(args);
+  if (!cursor.knownMessageCount && !cursor.lastMessageSignature && cursor.tailLimit > 0 && messages.length > cursor.tailLimit) {
+    const tailMessages = messages.slice(-cursor.tailLimit);
+    const lastMessageSignature = getChatMessageSignature(tailMessages[tailMessages.length - 1]);
+    return {
+      success: true,
+      ...payload,
+      messages: tailMessages,
+      syncMode: "full",
+      replaceFrom: 0,
+      totalMessages: messages.length,
+      lastMessageSignature
+    };
+  }
+  const sync = computeReadChatSync(messages, cursor);
+  return {
+    success: true,
+    ...payload,
+    messages: sync.messages,
+    syncMode: sync.syncMode,
+    replaceFrom: sync.replaceFrom,
+    totalMessages: sync.totalMessages,
+    lastMessageSignature: sync.lastMessageSignature
+  };
+}
 function didProviderConfirmSend(result) {
   const parsed = parseMaybeJson(result);
   if (parsed === true) return true;
@@ -5046,12 +5256,11 @@ async function handleReadChat(h, args) {
       _log(`${transport} adapter: ${adapter.cliType}`);
       const status = adapter.getStatus();
       if (status) {
-        return {
-          success: true,
+        return buildReadChatCommandResult({
           messages: status.messages || [],
           status: status.status,
           activeModal: status.activeModal
-        };
+        }, args);
       }
     }
     return { success: false, error: `${transport} adapter not found` };
@@ -5071,12 +5280,12 @@ async function handleReadChat(h, args) {
           _log(`Extension OK: ${parsed.messages?.length || 0} msgs`);
           h.historyWriter.appendNewMessages(
             provider?.type || "unknown_extension",
-            parsed.messages || [],
+            toHistoryPersistedMessages(normalizeReadChatMessages(parsed)),
             parsed.title,
             args?.targetSessionId,
             historySessionId
           );
-          return { success: true, ...parsed };
+          return buildReadChatCommandResult(parsed, args);
         }
       }
     } catch (e) {
@@ -5088,21 +5297,25 @@ async function handleReadChat(h, args) {
       if (cdp2 && parentSessionId) {
         const stream = await h.agentStream.collectActiveSession(cdp2, parentSessionId);
         if (stream?.agentType !== provider?.type) {
-          return { success: true, messages: [], status: "idle" };
+          return buildReadChatCommandResult({ messages: [], status: "idle" }, args);
         }
         if (stream) {
           h.historyWriter.appendNewMessages(
             stream.agentType,
-            stream.messages || [],
+            toHistoryPersistedMessages(stream.messages || []),
             void 0,
             args?.targetSessionId,
             historySessionId
           );
-          return { success: true, messages: stream.messages || [], status: stream.status, agentType: stream.agentType };
+          return buildReadChatCommandResult({
+            messages: stream.messages || [],
+            status: stream.status,
+            agentType: stream.agentType
+          }, args);
         }
       }
     }
-    return { success: true, messages: [], status: "idle" };
+    return buildReadChatCommandResult({ messages: [], status: "idle" }, args);
   }
   const cdp = h.getCdp();
   if (!cdp?.isConnected) return { success: false, error: "CDP not connected" };
@@ -5124,18 +5337,18 @@ async function handleReadChat(h, args) {
           _log(`Webview OK: ${parsed.messages?.length || 0} msgs`);
           h.historyWriter.appendNewMessages(
             provider?.type || getCurrentProviderType(h, "unknown_webview"),
-            parsed.messages || [],
+            toHistoryPersistedMessages(normalizeReadChatMessages(parsed)),
             parsed.title,
             args?.targetSessionId,
             historySessionId
           );
-          return { success: true, ...parsed };
+          return buildReadChatCommandResult(parsed, args);
         }
       }
     } catch (e) {
       _log(`Webview readChat error: ${e.message}`);
     }
-    return { success: true, messages: [], status: "idle" };
+    return buildReadChatCommandResult({ messages: [], status: "idle" }, args);
   }
   const script = h.getProviderScript("readChat") || h.getProviderScript("read_chat");
   if (script) {
@@ -5152,18 +5365,18 @@ async function handleReadChat(h, args) {
         _log(`OK: ${parsed.messages?.length} msgs`);
         h.historyWriter.appendNewMessages(
           provider?.type || getCurrentProviderType(h, "unknown_ide"),
-          parsed.messages || [],
+          toHistoryPersistedMessages(normalizeReadChatMessages(parsed)),
           parsed.title,
           args?.targetSessionId,
           historySessionId
         );
-        return { success: true, ...parsed };
+        return buildReadChatCommandResult(parsed, args);
       }
     } catch (e) {
       LOG.info("Command", `[read_chat] Script error: ${e.message}`);
     }
   }
-  return { success: true, messages: [], status: "idle" };
+  return buildReadChatCommandResult({ messages: [], status: "idle" }, args);
 }
 async function handleSendChat(h, args) {
   const text = args?.text || args?.message;
@@ -5814,6 +6027,7 @@ var RECENT_SEND_WINDOW_MS, recentSendByTarget;
 var init_chat_commands = __esm({
   "../../oss/packages/daemon-core/src/commands/chat-commands.ts"() {
     "use strict";
+    init_contracts();
     init_chat_history();
     init_logger();
     RECENT_SEND_WINDOW_MS = 1200;
@@ -6299,21 +6513,21 @@ function applyProviderPatch(h, args, payload) {
   });
 }
 async function executeProviderScript(h, args, scriptName) {
-  const { agentType, ideType } = args || {};
-  if (!agentType) return { success: false, error: "agentType is required" };
+  const resolvedProviderType = h.currentSession?.providerType || h.currentProviderType || args?.agentType || args?.providerType;
+  if (!resolvedProviderType) return { success: false, error: "targetSessionId or providerType is required" };
   const loader = h.ctx.providerLoader;
   if (!loader) return { success: false, error: "ProviderLoader not initialized" };
-  const provider = loader.resolve(agentType);
-  if (!provider) return { success: false, error: `Provider not found: ${agentType}` };
+  const provider = loader.resolve(resolvedProviderType);
+  if (!provider) return { success: false, error: `Provider not found: ${resolvedProviderType}` };
   const webviewScriptName = `webview${scriptName.charAt(0).toUpperCase() + scriptName.slice(1)}`;
   const hasWebviewScript = provider.category === "ide" && !!provider.scripts?.[webviewScriptName];
   const actualScriptName = hasWebviewScript ? webviewScriptName : scriptName;
   if (!provider.scripts?.[actualScriptName]) {
-    return { success: false, error: `Script '${actualScriptName}' not available for ${agentType}` };
+    return { success: false, error: `Script '${actualScriptName}' not available for ${resolvedProviderType}` };
   }
   const normalizedArgs = normalizeProviderScriptArgs(args);
   if (provider.category === "cli") {
-    const adapter = h.getCliAdapter(args?.targetSessionId || agentType);
+    const adapter = h.getCliAdapter(args?.targetSessionId || resolvedProviderType);
     if (!adapter?.invokeScript) {
       return { success: false, error: `CLI adapter does not support script '${actualScriptName}'` };
     }
@@ -6338,7 +6552,7 @@ async function executeProviderScript(h, args, scriptName) {
   const scriptFn = provider.scripts[actualScriptName];
   const scriptCode = scriptFn(normalizedArgs);
   if (!scriptCode) return { success: false, error: `Script '${actualScriptName}' returned null` };
-  const cdpKey = provider.category === "ide" ? h.currentSession?.cdpManagerKey || h.currentManagerKey || agentType : h.currentSession?.cdpManagerKey || h.currentManagerKey || ideType;
+  const cdpKey = provider.category === "ide" ? h.currentSession?.cdpManagerKey || h.currentManagerKey || resolvedProviderType : h.currentSession?.cdpManagerKey || h.currentManagerKey;
   LOG.info("Command", `[ExtScript] provider=${provider.type} category=${provider.category} cdpKey=${cdpKey}`);
   const cdp = h.getCdp(cdpKey);
   if (!cdp?.isConnected) return { success: false, error: `No CDP connection for ${cdpKey || "any"}` };
@@ -6346,7 +6560,7 @@ async function executeProviderScript(h, args, scriptName) {
     let result;
     if (provider.category === "extension") {
       const runtimeSessionId = h.currentSession?.sessionId || args?.targetSessionId;
-      if (!runtimeSessionId) return { success: false, error: `No target session found for ${agentType}` };
+      if (!runtimeSessionId) return { success: false, error: `No target session found for ${resolvedProviderType}` };
       const parentSessionId = h.currentSession?.parentSessionId;
       if (parentSessionId) {
         await h.agentStream?.setActiveSession(cdp, parentSessionId, runtimeSessionId);
@@ -6375,7 +6589,7 @@ async function executeProviderScript(h, args, scriptName) {
         }
       } else {
         if (!targetSessionId) {
-          return { success: false, error: `No active session found for ${agentType}` };
+          return { success: false, error: `No active session found for ${resolvedProviderType}` };
         }
         result = await cdp.evaluateInSessionFrame(targetSessionId, scriptCode);
       }
@@ -27201,17 +27415,6 @@ var init_acp = __esm({
   }
 });
 
-// ../../oss/packages/daemon-core/src/providers/contracts.ts
-function flattenContent(content) {
-  if (typeof content === "string") return content;
-  return content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
-}
-var init_contracts = __esm({
-  "../../oss/packages/daemon-core/src/providers/contracts.ts"() {
-    "use strict";
-  }
-});
-
 // ../../oss/packages/daemon-core/src/providers/acp-provider-instance.ts
 var import_stream, import_child_process5, AcpProviderInstance;
 var init_acp_provider_instance = __esm({
@@ -32364,6 +32567,37 @@ function buildAvailableProviders(providerLoader) {
     ...provider.detectedPath !== void 0 ? { detectedPath: provider.detectedPath } : {}
   }));
 }
+function buildMachineInfo(profile = "full") {
+  const base = {
+    hostname: os17.hostname(),
+    platform: os17.platform()
+  };
+  if (profile === "live") {
+    return base;
+  }
+  if (profile === "metadata") {
+    const memSnap2 = getHostMemorySnapshot();
+    return {
+      ...base,
+      arch: os17.arch(),
+      cpus: os17.cpus().length,
+      totalMem: memSnap2.totalMem,
+      release: os17.release()
+    };
+  }
+  const memSnap = getHostMemorySnapshot();
+  return {
+    ...base,
+    arch: os17.arch(),
+    cpus: os17.cpus().length,
+    totalMem: memSnap.totalMem,
+    freeMem: memSnap.freeMem,
+    availableMem: memSnap.availableMem,
+    loadavg: os17.loadavg(),
+    uptime: os17.uptime(),
+    release: os17.release()
+  };
+}
 function parseMessageTime(value) {
   if (typeof value === "number" && Number.isFinite(value)) return value;
   if (typeof value === "string") {
@@ -32419,26 +32653,35 @@ function buildRecentLaunches(recentActivity) {
   })).sort((a, b) => b.lastLaunchedAt - a.lastLaunchedAt).slice(0, 12);
 }
 function buildStatusSnapshot(options) {
+  const profile = options.profile || "full";
   const cfg = loadConfig();
   const state = loadState();
   const wsState = getWorkspaceState(cfg);
-  const memSnap = getHostMemorySnapshot();
   const recentActivity = getRecentActivity(state, 20);
-  const sessions = buildSessionEntries(
+  const unreadSourceSessions = buildSessionEntries(
     options.allStates,
-    options.cdpManagers
+    options.cdpManagers,
+    { profile: "full" }
   );
-  for (const session of sessions) {
-    const lastSeenAt = getSessionSeenAt(state, session.id);
-    const seenCompletionMarker = getSessionSeenMarker(state, session.id);
-    const lastUsedAt = getSessionLastUsedAt(session);
-    const completionMarker = getSessionCompletionMarker(session);
-    const { unread, inboxBucket } = session.surfaceHidden ? { unread: false, inboxBucket: "idle" } : getUnreadState(
-      getSessionMessageUpdatedAt(session) > 0,
-      session.status,
+  const sessions = profile === "full" ? unreadSourceSessions : buildSessionEntries(
+    options.allStates,
+    options.cdpManagers,
+    { profile }
+  );
+  const sessionsById = new Map(sessions.map((session) => [session.id, session]));
+  for (const sourceSession of unreadSourceSessions) {
+    const session = sessionsById.get(sourceSession.id);
+    if (!session) continue;
+    const lastSeenAt = getSessionSeenAt(state, sourceSession.id);
+    const seenCompletionMarker = getSessionSeenMarker(state, sourceSession.id);
+    const lastUsedAt = getSessionLastUsedAt(sourceSession);
+    const completionMarker = getSessionCompletionMarker(sourceSession);
+    const { unread, inboxBucket } = sourceSession.surfaceHidden ? { unread: false, inboxBucket: "idle" } : getUnreadState(
+      getSessionMessageUpdatedAt(sourceSession) > 0,
+      sourceSession.status,
       lastUsedAt,
       lastSeenAt,
-      getLastMessageRole(session),
+      getLastMessageRole(sourceSession),
       completionMarker,
       seenCompletionMarker
     );
@@ -32448,39 +32691,30 @@ function buildStatusSnapshot(options) {
     if (READ_DEBUG_ENABLED && (session.unread || session.inboxBucket !== "idle" || session.providerType.includes("codex"))) {
       LOG.info(
         "RecentRead",
-        `snapshot session id=${session.id} provider=${session.providerType} status=${String(session.status || "")} bucket=${inboxBucket} unread=${String(unread)} lastSeenAt=${lastSeenAt} completionMarker=${completionMarker || "-"} seenMarker=${seenCompletionMarker || "-"} lastUpdated=${String(session.lastUpdated || 0)} lastUsedAt=${lastUsedAt} lastRole=${getLastMessageRole(session)} msgUpdatedAt=${getSessionMessageUpdatedAt(session)}`
+        `snapshot session id=${session.id} provider=${session.providerType} status=${String(session.status || "")} bucket=${inboxBucket} unread=${String(unread)} lastSeenAt=${lastSeenAt} completionMarker=${completionMarker || "-"} seenMarker=${seenCompletionMarker || "-"} lastUpdated=${String(session.lastUpdated || 0)} lastUsedAt=${lastUsedAt} lastRole=${getLastMessageRole(sourceSession)} msgUpdatedAt=${getSessionMessageUpdatedAt(sourceSession)}`
       );
     }
   }
-  const terminalBackend = getTerminalBackendRuntimeStatus();
+  const includeMachineMetadata = profile !== "live";
+  const terminalBackend = includeMachineMetadata ? getTerminalBackendRuntimeStatus() : void 0;
   return {
     instanceId: options.instanceId,
-    version: options.version,
-    daemonMode: options.daemonMode,
-    machine: {
-      hostname: os17.hostname(),
-      platform: os17.platform(),
-      arch: os17.arch(),
-      cpus: os17.cpus().length,
-      totalMem: memSnap.totalMem,
-      freeMem: memSnap.freeMem,
-      availableMem: memSnap.availableMem,
-      loadavg: os17.loadavg(),
-      uptime: os17.uptime(),
-      release: os17.release()
-    },
-    machineNickname: options.machineNickname ?? cfg.machineNickname ?? null,
+    ...includeMachineMetadata ? { version: options.version } : {},
+    machine: buildMachineInfo(profile),
+    ...includeMachineMetadata ? { machineNickname: options.machineNickname ?? cfg.machineNickname ?? null } : {},
     timestamp: options.timestamp ?? Date.now(),
-    detectedIdes: buildDetectedIdeInfos(options.detectedIdes, options.cdpManagers),
     ...options.p2p ? { p2p: options.p2p } : {},
     sessions,
-    workspaces: wsState.workspaces,
-    defaultWorkspaceId: wsState.defaultWorkspaceId,
-    defaultWorkspacePath: wsState.defaultWorkspacePath,
-    terminalSizingMode: cfg.terminalSizingMode || "measured",
-    recentLaunches: buildRecentLaunches(recentActivity),
-    terminalBackend,
-    availableProviders: buildAvailableProviders(options.providerLoader)
+    ...terminalBackend ? { terminalBackend } : {},
+    ...includeMachineMetadata && {
+      detectedIdes: buildDetectedIdeInfos(options.detectedIdes, options.cdpManagers),
+      workspaces: wsState.workspaces,
+      defaultWorkspaceId: wsState.defaultWorkspaceId,
+      defaultWorkspacePath: wsState.defaultWorkspacePath,
+      terminalSizingMode: cfg.terminalSizingMode || "measured",
+      recentLaunches: buildRecentLaunches(recentActivity),
+      availableProviders: buildAvailableProviders(options.providerLoader)
+    }
   };
 }
 var os17, READ_DEBUG_ENABLED;
@@ -32751,6 +32985,7 @@ var init_router = __esm({
     init_logger();
     init_builders();
     init_snapshot();
+    init_snapshot();
     init_upgrade_helper();
     fs9 = __toESM(require("fs"));
     CHAT_COMMANDS = [
@@ -33079,6 +33314,25 @@ var init_router = __esm({
             updateConfig({ userName: name });
             return { success: true, userName: name };
           }
+          case "get_status_metadata": {
+            const snapshot = buildStatusSnapshot({
+              allStates: this.deps.instanceManager.collectAllStates(),
+              cdpManagers: this.deps.cdpManagers,
+              providerLoader: this.deps.providerLoader,
+              detectedIdes: this.deps.detectedIdes.value,
+              instanceId: this.deps.statusInstanceId || loadConfig().machineId || "daemon",
+              version: this.deps.statusVersion || "unknown",
+              profile: "metadata"
+            });
+            return { success: true, status: snapshot };
+          }
+          case "get_machine_runtime_stats": {
+            return {
+              success: true,
+              machine: buildMachineInfo("full"),
+              timestamp: Date.now()
+            };
+          }
           case "mark_session_seen": {
             const sessionId = args?.sessionId;
             if (!sessionId || typeof sessionId !== "string") {
@@ -33292,9 +33546,58 @@ var init_reporter = __esm({
           }, 5e3 - elapsed);
         }
       }
+      toDaemonStatusEventName(value) {
+        switch (value) {
+          case "agent:generating_started":
+          case "agent:waiting_approval":
+          case "agent:generating_completed":
+          case "agent:stopped":
+          case "monitor:long_generating":
+            return value;
+          default:
+            return null;
+        }
+      }
+      buildServerStatusEvent(event) {
+        const eventName = this.toDaemonStatusEventName(event.event);
+        if (!eventName) return null;
+        if (eventName.startsWith("provider:")) {
+          return null;
+        }
+        const payload = {
+          event: eventName,
+          timestamp: typeof event.timestamp === "number" && Number.isFinite(event.timestamp) ? event.timestamp : Date.now()
+        };
+        if (typeof event.targetSessionId === "string" && event.targetSessionId.trim()) {
+          payload.targetSessionId = event.targetSessionId.trim();
+        }
+        const providerType = typeof event.providerType === "string" && event.providerType.trim() ? event.providerType.trim() : typeof event.ideType === "string" && event.ideType.trim() ? event.ideType.trim() : "";
+        if (providerType) {
+          payload.providerType = providerType;
+        }
+        if (typeof event.duration === "number" && Number.isFinite(event.duration)) {
+          payload.duration = event.duration;
+        }
+        if (typeof event.elapsedSec === "number" && Number.isFinite(event.elapsedSec)) {
+          payload.elapsedSec = event.elapsedSec;
+        }
+        if (typeof event.modalMessage === "string" && event.modalMessage.trim()) {
+          payload.modalMessage = event.modalMessage;
+        }
+        if (Array.isArray(event.modalButtons)) {
+          const modalButtons = event.modalButtons.filter((button) => typeof button === "string" && button.trim().length > 0);
+          if (modalButtons.length > 0) {
+            payload.modalButtons = modalButtons;
+          }
+        }
+        return payload;
+      }
       emitStatusEvent(event) {
         LOG.info("StatusEvent", `${event.event} (${event.providerType || event.ideType || ""})`);
-        this.deps.serverConn?.sendMessage("status_event", event);
+        const serverEvent = this.buildServerStatusEvent(event);
+        if (!serverEvent) return;
+        this.deps.p2p?.sendStatusEvent(serverEvent);
+        this.deps.serverConn?.sendMessage("status_event", serverEvent);
       }
       removeAgentTracking(_key) {
       }
@@ -33363,17 +33666,16 @@ var init_reporter = __esm({
             detectedIdes: this.deps.detectedIdes || [],
             instanceId: this.deps.instanceId,
             version: this.deps.daemonVersion || "unknown",
-            daemonMode: true,
             timestamp: now,
             p2p: {
               available: p2p?.isAvailable || false,
               state: p2p?.connectionState || "unavailable",
               peers: p2p?.connectedPeerCount || 0,
               screenshotActive: p2p?.screenshotActive || false
-            }
+            },
+            profile: "live"
           }),
-          screenshotUsage: this.deps.getScreenshotUsage?.() || null,
-          connectedExtensions: []
+          screenshotUsage: this.deps.getScreenshotUsage?.() || null
         };
         const payloadBytes = JSON.stringify(payload).length;
         const p2pSent = this.sendP2PPayload(payload);
@@ -33388,16 +33690,15 @@ var init_reporter = __esm({
         }
         if (opts?.p2pOnly) return;
         const wsPayload = {
-          daemonMode: true,
           sessions: sessions.map((session) => ({
             id: session.id,
             parentId: session.parentId,
             providerType: session.providerType,
-            providerName: session.providerName,
+            providerName: session.providerName || session.providerType,
             kind: session.kind,
             transport: session.transport,
             status: session.status,
-            workspace: session.workspace,
+            workspace: session.workspace ?? null,
             title: session.title,
             cdpConnected: session.cdpConnected,
             currentModel: session.currentModel,
@@ -33405,9 +33706,7 @@ var init_reporter = __esm({
             currentAutoApprove: session.currentAutoApprove
           })),
           p2p: payload.p2p,
-          timestamp: now,
-          detectedIdes: payload.detectedIdes,
-          availableProviders: payload.availableProviders
+          timestamp: now
         };
         const wsHash = this.simpleHash(JSON.stringify({
           ...wsPayload,
@@ -33424,10 +33723,15 @@ var init_reporter = __esm({
       // ─── P2P ─────────────────────────────────────────
       sendP2PPayload(payload) {
         const { timestamp: _ts, system: _sys, ...hashTarget } = payload;
+        const sessions = Array.isArray(hashTarget.sessions) ? hashTarget.sessions.map((session) => {
+          if (!session || typeof session !== "object") return session;
+          const { lastUpdated: _lu, ...stableSession } = session;
+          return stableSession;
+        }) : hashTarget.sessions;
         const hashPayload = hashTarget.machine ? (() => {
           const { freeMem: _f, availableMem: _a2, loadavg: _l, uptime: _u, ...stableMachine } = hashTarget.machine;
-          return { ...hashTarget, machine: stableMachine };
-        })() : hashTarget;
+          return { ...hashTarget, sessions, machine: stableMachine };
+        })() : { ...hashTarget, sessions };
         const h = this.simpleHash(JSON.stringify(hashPayload));
         if (h !== this.lastP2PStatusHash) {
           this.lastP2PStatusHash = h;
@@ -40638,6 +40942,8 @@ async function initDaemonComponents(config2) {
     onStatusChange: config2.onStatusChange,
     onPostChatCommand: config2.onPostChatCommand,
     sessionHostControl: config2.sessionHostControl,
+    statusInstanceId: config2.statusInstanceId,
+    statusVersion: config2.statusVersion,
     getCdpLogFn: config2.getCdpLogFn || ((ideType) => LOG.forComponent(`CDP:${ideType}`).asLogFn())
   });
   poller = new AgentStreamPoller({
@@ -40763,6 +41069,7 @@ __export(src_exports, {
   SessionHostPtyTransportFactory: () => SessionHostPtyTransportFactory,
   VersionArchive: () => VersionArchive,
   appendRecentActivity: () => appendRecentActivity,
+  buildMachineInfo: () => buildMachineInfo,
   buildSessionEntries: () => buildSessionEntries,
   buildStatusSnapshot: () => buildStatusSnapshot,
   connectCdpManager: () => connectCdpManager,
@@ -41036,6 +41343,7 @@ var init_server_connection = __esm({
           this.ws = new import_ws2.default(fullUrl, {
             headers: {
               "X-ADHDev-Token": this.options.token,
+              "X-ADHDev-Daemon": JSON.stringify(this.options.cliInfo),
               "X-ADHDev-IDE": JSON.stringify(this.options.cliInfo),
               "X-ADHDev-Version": this.options.daemonVersion || "unknown"
             }
@@ -41120,7 +41428,7 @@ var init_server_connection = __esm({
           type: "auth",
           payload: {
             token: this.options.token,
-            ide: this.options.cliInfo
+            daemon: this.options.cliInfo
           },
           timestamp: Date.now()
         });
@@ -41360,11 +41668,19 @@ function routeDataChannelMessage(peerId, msg, peers, handlers) {
       if (peer) peer.lastPongAt = Date.now();
       return;
     }
+    if (parsed.type === "subscribe") {
+      handleSubscribe(peerId, parsed, peers, handlers);
+      return;
+    }
+    if (parsed.type === "unsubscribe") {
+      handleUnsubscribe(peerId, parsed, peers);
+      return;
+    }
     if (parsed.type === "screenshot_start") {
       const peer = peers.get(peerId);
       const permission = peer?.sharePermission;
-      if (!parsed.ideType) {
-        log(`screenshot_start: REJECTED \u2014 no ideType from peer ${peerId}`);
+      if (!parsed.targetSessionId) {
+        log(`screenshot_start: REJECTED \u2014 no targetSessionId from peer ${peerId}`);
         return;
       }
       if (!canPeerStartScreenshots(permission)) {
@@ -41373,9 +41689,9 @@ function routeDataChannelMessage(peerId, msg, peers, handlers) {
       }
       if (peer) {
         peer.screenshotActive = true;
-        peer.screenshotIdeType = parsed.ideType;
+        peer.screenshotTargetSessionId = parsed.targetSessionId;
         peer.needsFirstFrame = true;
-        log(`screenshot_start: peer=${peerId}, ideType=${parsed.ideType}, channelOpen=${!!peer.dataChannel}, state=${peer.state}`);
+        log(`screenshot_start: peer=${peerId}, targetSessionId=${parsed.targetSessionId}, channelOpen=${!!peer.dataChannel}, state=${peer.state}`);
         handlers.screenshotStartHandler?.();
       } else {
         log(`screenshot_start: peer ${peerId} NOT FOUND in peers map!`);
@@ -41427,6 +41743,87 @@ function routeDataChannelMessage(peerId, msg, peers, handlers) {
     log(`Parse error from peer ${peerId}: ${e?.message}`);
   }
 }
+function handleSubscribe(peerId, msg, peers, handlers) {
+  const peer = peers.get(peerId);
+  if (!peer) return;
+  if (msg.topic === "session.chat_tail") {
+    const targetSessionId = typeof msg.params?.targetSessionId === "string" ? msg.params.targetSessionId.trim() : "";
+    if (!targetSessionId) return;
+    if (!peer.chatSubscriptions) peer.chatSubscriptions = /* @__PURE__ */ new Map();
+    peer.chatSubscriptions.set(msg.key, {
+      key: msg.key,
+      params: msg.params,
+      seq: 0,
+      cursor: {
+        knownMessageCount: Math.max(0, Number(msg.params.knownMessageCount || 0)),
+        lastMessageSignature: typeof msg.params.lastMessageSignature === "string" ? msg.params.lastMessageSignature : "",
+        tailLimit: Math.max(0, Number(msg.params.tailLimit || 0))
+      },
+      lastDeliveredSignature: ""
+    });
+  } else if (msg.topic === "machine.runtime") {
+    if (!peer.machineRuntimeSubscriptions) peer.machineRuntimeSubscriptions = /* @__PURE__ */ new Map();
+    peer.machineRuntimeSubscriptions.set(msg.key, {
+      key: msg.key,
+      params: msg.params,
+      seq: 0,
+      lastSentAt: 0
+    });
+  } else if (msg.topic === "session_host.diagnostics") {
+    if (!peer.sessionHostDiagnosticsSubscriptions) peer.sessionHostDiagnosticsSubscriptions = /* @__PURE__ */ new Map();
+    peer.sessionHostDiagnosticsSubscriptions.set(msg.key, {
+      key: msg.key,
+      params: msg.params,
+      seq: 0,
+      lastSentAt: 0
+    });
+  } else if (msg.topic === "session.modal") {
+    const targetSessionId = typeof msg.params?.targetSessionId === "string" ? msg.params.targetSessionId.trim() : "";
+    if (!targetSessionId) return;
+    if (!peer.sessionModalSubscriptions) peer.sessionModalSubscriptions = /* @__PURE__ */ new Map();
+    peer.sessionModalSubscriptions.set(msg.key, {
+      key: msg.key,
+      params: msg.params,
+      seq: 0,
+      lastSentAt: 0,
+      lastDeliveredSignature: ""
+    });
+  } else if (msg.topic === "daemon.metadata") {
+    if (!peer.daemonMetadataSubscriptions) peer.daemonMetadataSubscriptions = /* @__PURE__ */ new Map();
+    peer.daemonMetadataSubscriptions.set(msg.key, {
+      key: msg.key,
+      params: msg.params,
+      seq: 0,
+      lastSentAt: 0
+    });
+  } else {
+    return;
+  }
+  handlers.subscriptionChangeHandler?.();
+}
+function handleUnsubscribe(peerId, msg, peers) {
+  const peer = peers.get(peerId);
+  if (!peer) return;
+  if (msg.topic === "session.chat_tail") {
+    peer.chatSubscriptions?.delete(msg.key);
+    return;
+  }
+  if (msg.topic === "machine.runtime") {
+    peer.machineRuntimeSubscriptions?.delete(msg.key);
+    return;
+  }
+  if (msg.topic === "session_host.diagnostics") {
+    peer.sessionHostDiagnosticsSubscriptions?.delete(msg.key);
+    return;
+  }
+  if (msg.topic === "session.modal") {
+    peer.sessionModalSubscriptions?.delete(msg.key);
+    return;
+  }
+  if (msg.topic === "daemon.metadata") {
+    peer.daemonMetadataSubscriptions?.delete(msg.key);
+  }
+}
 async function handleP2PCommand(peerId, msg, peers, handlers) {
   const { id, commandType, data } = msg;
   const peer = peers.get(peerId);
@@ -41447,7 +41844,7 @@ async function handleP2PCommand(peerId, msg, peers, handlers) {
   }
 }
 async function handleInputEvent(peerId, msg, peers, handlers) {
-  const { id, action, params, instanceId } = msg;
+  const { id, action, params, targetSessionId: explicitTargetSessionId } = msg;
   const peer = peers.get(peerId);
   const permission = peer?.sharePermission;
   if (!canPeerUseRemoteInput(permission)) {
@@ -41459,11 +41856,11 @@ async function handleInputEvent(peerId, msg, peers, handlers) {
     return;
   }
   try {
-    const ideType = instanceId || peer?.screenshotIdeType;
-    if (!ideType) {
-      log(`[Input] WARNING: No instanceId or screenshotIdeType for peer ${peerId}`);
+    const targetSessionId = explicitTargetSessionId || peer?.screenshotTargetSessionId;
+    if (!targetSessionId) {
+      log(`[Input] WARNING: No targetSessionId for peer ${peerId}`);
     }
-    const result = await handlers.inputHandler({ action, params, ideType });
+    const result = await handlers.inputHandler({ action, params, targetSessionId });
     sendToPeer(peer, { id, type: "response", success: true, result });
   } catch (e) {
     sendToPeer(peer, { id, type: "response", success: false, error: e?.message });
@@ -41522,6 +41919,35 @@ var init_screenshot_sender = __esm({
         }
         return sentAny;
       }
+      sendStatusEvent(peers, event) {
+        const payload = JSON.stringify({
+          type: "status_event",
+          payload: event,
+          timestamp: Date.now()
+        });
+        let sentAny = false;
+        for (const peer of peers.values()) {
+          if (peer.state !== "connected" || !peer.dataChannel) continue;
+          try {
+            peer.dataChannel.sendMessage(payload);
+            sentAny = true;
+          } catch {
+          }
+        }
+        return sentAny;
+      }
+      sendTopicUpdateToPeer(peer, update) {
+        if (!peer?.dataChannel || peer.state !== "connected") return false;
+        try {
+          peer.dataChannel.sendMessage(JSON.stringify({
+            type: "topic_update",
+            update
+          }));
+          return true;
+        } catch {
+          return false;
+        }
+      }
       /** Broadcast runtime session output to all connected peers */
       broadcastSessionOutput(peers, sessionId, data) {
         const msg = JSON.stringify({ type: "session_output", sessionId, data });
@@ -41683,7 +42109,12 @@ async function initiateConnection(deps, peerId, sharePermission) {
     pendingCandidates: [],
     remoteDescriptionSet: false,
     isRelay: false,
-    lastPongAt: Date.now()
+    lastPongAt: Date.now(),
+    chatSubscriptions: /* @__PURE__ */ new Map(),
+    machineRuntimeSubscriptions: /* @__PURE__ */ new Map(),
+    sessionHostDiagnosticsSubscriptions: /* @__PURE__ */ new Map(),
+    sessionModalSubscriptions: /* @__PURE__ */ new Map(),
+    daemonMetadataSubscriptions: /* @__PURE__ */ new Map()
   };
   deps.peers.set(pid, entry);
   deps.notifyStateChange();
@@ -41930,7 +42361,8 @@ var init_daemon_p2p = __esm({
         commandHandler: null,
         ptyInputHandler: null,
         ptyResizeHandler: null,
-        screenshotStartHandler: null
+        screenshotStartHandler: null,
+        subscriptionChangeHandler: null
       };
       get screenshotActive() {
         for (const peer of this.peers.values()) {
@@ -41938,11 +42370,11 @@ var init_daemon_p2p = __esm({
         }
         return false;
       }
-      /** Get the ideType for the currently active screenshot request */
-      get screenshotIdeType() {
+      /** Get the target session for the currently active screenshot request */
+      get screenshotTargetSessionId() {
         for (const peer of this.peers.values()) {
-          if (peer.screenshotActive && peer.state === "connected" && peer.screenshotIdeType) {
-            return peer.screenshotIdeType;
+          if (peer.screenshotActive && peer.state === "connected" && peer.screenshotTargetSessionId) {
+            return peer.screenshotTargetSessionId;
           }
         }
         return void 0;
@@ -42094,6 +42526,9 @@ ${e?.stack || ""}`);
       sendStatus(status) {
         return this.screenshotSender.sendStatus(this.peers, status);
       }
+      sendStatusEvent(event) {
+        return this.screenshotSender.sendStatusEvent(this.peers, event);
+      }
       broadcastSessionOutput(sessionId, data) {
         return this.screenshotSender.broadcastSessionOutput(this.peers, sessionId, data);
       }
@@ -42122,6 +42557,89 @@ ${e?.stack || ""}`);
       onScreenshotStart(handler) {
         this.handlers.screenshotStartHandler = handler;
       }
+      onSubscriptionChange(handler) {
+        this.handlers.subscriptionChangeHandler = handler;
+      }
+      hasChatSubscriptions() {
+        for (const peer of this.peers.values()) {
+          if (peer.chatSubscriptions && peer.chatSubscriptions.size > 0) return true;
+        }
+        return false;
+      }
+      hasMachineRuntimeSubscriptions() {
+        for (const peer of this.peers.values()) {
+          if (peer.machineRuntimeSubscriptions && peer.machineRuntimeSubscriptions.size > 0) return true;
+        }
+        return false;
+      }
+      hasSessionHostDiagnosticsSubscriptions() {
+        for (const peer of this.peers.values()) {
+          if (peer.sessionHostDiagnosticsSubscriptions && peer.sessionHostDiagnosticsSubscriptions.size > 0) return true;
+        }
+        return false;
+      }
+      hasSessionModalSubscriptions() {
+        for (const peer of this.peers.values()) {
+          if (peer.sessionModalSubscriptions && peer.sessionModalSubscriptions.size > 0) return true;
+        }
+        return false;
+      }
+      hasDaemonMetadataSubscriptions() {
+        for (const peer of this.peers.values()) {
+          if (peer.daemonMetadataSubscriptions && peer.daemonMetadataSubscriptions.size > 0) return true;
+        }
+        return false;
+      }
+      async flushChatSubscriptions(builder) {
+        for (const peer of this.peers.values()) {
+          if (peer.state !== "connected" || !peer.chatSubscriptions || peer.chatSubscriptions.size === 0) continue;
+          for (const subscription of peer.chatSubscriptions.values()) {
+            const update = await builder(subscription);
+            if (!update) continue;
+            this.screenshotSender.sendTopicUpdateToPeer(peer, update);
+          }
+        }
+      }
+      async flushMachineRuntimeSubscriptions(builder) {
+        for (const peer of this.peers.values()) {
+          if (peer.state !== "connected" || !peer.machineRuntimeSubscriptions || peer.machineRuntimeSubscriptions.size === 0) continue;
+          for (const subscription of peer.machineRuntimeSubscriptions.values()) {
+            const update = await builder(subscription);
+            if (!update) continue;
+            this.screenshotSender.sendTopicUpdateToPeer(peer, update);
+          }
+        }
+      }
+      async flushSessionHostDiagnosticsSubscriptions(builder) {
+        for (const peer of this.peers.values()) {
+          if (peer.state !== "connected" || !peer.sessionHostDiagnosticsSubscriptions || peer.sessionHostDiagnosticsSubscriptions.size === 0) continue;
+          for (const subscription of peer.sessionHostDiagnosticsSubscriptions.values()) {
+            const update = await builder(subscription);
+            if (!update) continue;
+            this.screenshotSender.sendTopicUpdateToPeer(peer, update);
+          }
+        }
+      }
+      async flushSessionModalSubscriptions(builder) {
+        for (const peer of this.peers.values()) {
+          if (peer.state !== "connected" || !peer.sessionModalSubscriptions || peer.sessionModalSubscriptions.size === 0) continue;
+          for (const subscription of peer.sessionModalSubscriptions.values()) {
+            const update = await builder(subscription);
+            if (!update) continue;
+            this.screenshotSender.sendTopicUpdateToPeer(peer, update);
+          }
+        }
+      }
+      async flushDaemonMetadataSubscriptions(builder) {
+        for (const peer of this.peers.values()) {
+          if (peer.state !== "connected" || !peer.daemonMetadataSubscriptions || peer.daemonMetadataSubscriptions.size === 0) continue;
+          for (const subscription of peer.daemonMetadataSubscriptions.values()) {
+            const update = await builder(subscription);
+            if (!update) continue;
+            this.screenshotSender.sendTopicUpdateToPeer(peer, update);
+          }
+        }
+      }
     };
   }
 });
@@ -48782,12 +49300,12 @@ var init_screenshot_controller = __esm({
       async tick() {
         if (!this.deps.isRunning()) return;
         const active = this.deps.isScreenshotActive();
-        const ssIdeType = this.deps.getScreenshotIdeType();
-        if (active && !ssIdeType) {
+        const targetSessionId = this.deps.getScreenshotTargetSessionId();
+        if (active && !targetSessionId) {
           this.timer = setTimeout(() => this.tick(), 500);
           return;
         }
-        const cdp = ssIdeType ? this.deps.getCdp(ssIdeType) : null;
+        const cdp = targetSessionId ? this.deps.getCdp(targetSessionId) : null;
         const isRelay = this.deps.isUsingRelay();
         const profile = isRelay ? this.profileRelay : this.profileDirect;
         this.checkBudgetReset();
@@ -49318,6 +49836,48 @@ __export(adhdev_daemon_exports, {
   isDaemonRunning: () => isDaemonRunning,
   stopDaemon: () => stopDaemon
 });
+function hashSignatureParts2(parts) {
+  let hash2 = 2166136261;
+  for (const part of parts) {
+    const text = String(part || "");
+    for (let i = 0; i < text.length; i += 1) {
+      hash2 ^= text.charCodeAt(i);
+      hash2 = Math.imul(hash2, 16777619) >>> 0;
+    }
+    hash2 ^= 255;
+    hash2 = Math.imul(hash2, 16777619) >>> 0;
+  }
+  return hash2.toString(16).padStart(8, "0");
+}
+function buildChatTailDeliverySignature(payload) {
+  let messages = "";
+  try {
+    messages = JSON.stringify(payload.messages);
+  } catch {
+    messages = String(payload.messages.length);
+  }
+  return hashSignatureParts2([
+    payload.sessionId,
+    payload.historySessionId || "",
+    payload.status,
+    payload.title || "",
+    payload.syncMode,
+    String(payload.replaceFrom),
+    String(payload.totalMessages),
+    payload.lastMessageSignature,
+    payload.activeModal ? `${payload.activeModal.message}|${payload.activeModal.buttons.join("")}` : "",
+    messages
+  ]);
+}
+function buildSessionModalDeliverySignature(payload) {
+  return hashSignatureParts2([
+    payload.sessionId,
+    payload.status,
+    payload.title || "",
+    payload.modalMessage || "",
+    Array.isArray(payload.modalButtons) ? payload.modalButtons.join("") : ""
+  ]);
+}
 function getDaemonPidFile() {
   const dir = path26.join(os23.homedir(), ".adhdev");
   if (!fs17.existsSync(dir)) fs17.mkdirSync(dir, { recursive: true });
@@ -49381,7 +49941,7 @@ function stopDaemon() {
     return false;
   }
 }
-var os23, fs17, path26, import_http, import_ws3, import_chalk2, pkgVersion, AdhdevDaemon;
+var os23, fs17, path26, import_http, import_ws3, import_chalk2, pkgVersion, ACTIVE_CHAT_POLL_STATUSES, AdhdevDaemon;
 var init_adhdev_daemon = __esm({
   "src/adhdev-daemon.ts"() {
     "use strict";
@@ -49399,7 +49959,12 @@ var init_adhdev_daemon = __esm({
     import_ws3 = require("ws");
     import_chalk2 = __toESM(require("chalk"));
     init_version();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.8.35" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.8.36" });
+    ACTIVE_CHAT_POLL_STATUSES = /* @__PURE__ */ new Set([
+      "generating",
+      "waiting_approval",
+      "starting"
+    ]);
     AdhdevDaemon = class {
       localHttpServer = null;
       localWss = null;
@@ -49408,6 +49973,11 @@ var init_adhdev_daemon = __esm({
       p2p = null;
       screenshotController = null;
       statusReporter = null;
+      topicSubscriptionTimer = null;
+      p2pChatFlushInFlight = false;
+      pendingP2PChatFlush = false;
+      pendingP2PChatFlushOnlyActive = true;
+      hotP2PChatSessionIds = /* @__PURE__ */ new Set();
       components = null;
       sessionHostEndpoint = null;
       sessionHostController = null;
@@ -49431,6 +50001,252 @@ var init_adhdev_daemon = __esm({
         const mode = this.getCliPresentationMode(sessionId);
         return mode === "chat" || mode === "terminal";
       }
+      async buildChatTailUpdateForSubscription(subscription) {
+        const result = await this.components.router.execute("read_chat", {
+          targetSessionId: subscription.params.targetSessionId,
+          ...subscription.params.historySessionId ? { historySessionId: subscription.params.historySessionId } : {},
+          knownMessageCount: subscription.cursor.knownMessageCount,
+          lastMessageSignature: subscription.cursor.lastMessageSignature,
+          ...subscription.cursor.tailLimit > 0 ? { tailLimit: subscription.cursor.tailLimit } : {}
+        }, "p2p");
+        if (!result?.success || result.syncMode === "noop") {
+          if (result?.success) {
+            subscription.cursor = {
+              knownMessageCount: Math.max(0, Number(result.totalMessages || subscription.cursor.knownMessageCount)),
+              lastMessageSignature: typeof result.lastMessageSignature === "string" ? result.lastMessageSignature : subscription.cursor.lastMessageSignature,
+              tailLimit: subscription.cursor.tailLimit
+            };
+          }
+          return null;
+        }
+        subscription.seq += 1;
+        const syncMode = result.syncMode === "append" || result.syncMode === "replace_tail" || result.syncMode === "noop" || result.syncMode === "full" ? result.syncMode : "full";
+        subscription.cursor = {
+          knownMessageCount: Math.max(0, Number(result.totalMessages || 0)),
+          lastMessageSignature: typeof result.lastMessageSignature === "string" ? result.lastMessageSignature : "",
+          tailLimit: subscription.cursor.tailLimit
+        };
+        const activeModal = result.activeModal && typeof result.activeModal === "object" && typeof result.activeModal.message === "string" && Array.isArray(result.activeModal.buttons) ? {
+          message: result.activeModal.message,
+          buttons: result.activeModal.buttons.filter((button) => typeof button === "string")
+        } : null;
+        const deliverySignature = buildChatTailDeliverySignature({
+          sessionId: subscription.params.targetSessionId,
+          ...subscription.params.historySessionId ? { historySessionId: subscription.params.historySessionId } : {},
+          messages: Array.isArray(result.messages) ? result.messages : [],
+          status: typeof result.status === "string" ? result.status : "idle",
+          ...typeof result.title === "string" ? { title: result.title } : {},
+          ...activeModal ? { activeModal } : {},
+          syncMode,
+          replaceFrom: Number(result.replaceFrom || 0),
+          totalMessages: Number(result.totalMessages || 0),
+          lastMessageSignature: typeof result.lastMessageSignature === "string" ? result.lastMessageSignature : ""
+        });
+        if (deliverySignature === subscription.lastDeliveredSignature) {
+          return null;
+        }
+        subscription.lastDeliveredSignature = deliverySignature;
+        return {
+          topic: "session.chat_tail",
+          key: subscription.key,
+          sessionId: subscription.params.targetSessionId,
+          ...subscription.params.historySessionId ? { historySessionId: subscription.params.historySessionId } : {},
+          seq: subscription.seq,
+          timestamp: Date.now(),
+          messages: Array.isArray(result.messages) ? result.messages : [],
+          status: typeof result.status === "string" ? result.status : "idle",
+          ...typeof result.title === "string" ? { title: result.title } : {},
+          ...activeModal ? { activeModal } : {},
+          syncMode,
+          replaceFrom: Number(result.replaceFrom || 0),
+          totalMessages: Number(result.totalMessages || 0),
+          lastMessageSignature: typeof result.lastMessageSignature === "string" ? result.lastMessageSignature : ""
+        };
+      }
+      buildLiveStatusSnapshot() {
+        return buildStatusSnapshot({
+          allStates: this.components.instanceManager.collectAllStates(),
+          cdpManagers: this.components.cdpManagers,
+          providerLoader: this.components.providerLoader,
+          detectedIdes: this.components.detectedIdes.value.map((ide) => ({
+            ...ide,
+            path: ide.path ?? void 0
+          })),
+          instanceId: `daemon_${loadConfig().machineId || "daemon"}`,
+          version: pkgVersion,
+          profile: "live"
+        });
+      }
+      getHotChatSessionIdsForP2PFlush() {
+        const snapshot = this.buildLiveStatusSnapshot();
+        const active = new Set(
+          snapshot.sessions.filter((session) => ACTIVE_CHAT_POLL_STATUSES.has(String(session.status || "").toLowerCase())).map((session) => session.id)
+        );
+        const finalizing = new Set(
+          Array.from(this.hotP2PChatSessionIds).filter((sessionId) => !active.has(sessionId))
+        );
+        this.hotP2PChatSessionIds = active;
+        return { active, finalizing };
+      }
+      async flushP2PChatSubscriptions(options = {}) {
+        if (!this.p2p?.isConnected || !this.p2p.hasChatSubscriptions()) return;
+        const onlyActive = options.onlyActive === true;
+        if (this.p2pChatFlushInFlight) {
+          this.pendingP2PChatFlush = true;
+          this.pendingP2PChatFlushOnlyActive = this.pendingP2PChatFlushOnlyActive && onlyActive;
+          return;
+        }
+        this.p2pChatFlushInFlight = true;
+        try {
+          const hotSessionIds = onlyActive ? this.getHotChatSessionIdsForP2PFlush() : null;
+          await this.p2p.flushChatSubscriptions(async (subscription) => {
+            if (hotSessionIds && !hotSessionIds.active.has(subscription.params.targetSessionId) && !hotSessionIds.finalizing.has(subscription.params.targetSessionId)) {
+              return null;
+            }
+            return this.buildChatTailUpdateForSubscription(subscription);
+          });
+        } finally {
+          this.p2pChatFlushInFlight = false;
+          if (this.pendingP2PChatFlush) {
+            const pendingOnlyActive = this.pendingP2PChatFlushOnlyActive;
+            this.pendingP2PChatFlush = false;
+            this.pendingP2PChatFlushOnlyActive = true;
+            void this.flushP2PChatSubscriptions({ onlyActive: pendingOnlyActive });
+          }
+        }
+      }
+      buildMachineRuntimeUpdateForSubscription(subscription) {
+        const intervalMs = Math.max(5e3, Number(subscription.params.intervalMs || 15e3));
+        const now = Date.now();
+        if (subscription.lastSentAt > 0 && now - subscription.lastSentAt < intervalMs) {
+          return null;
+        }
+        subscription.seq += 1;
+        subscription.lastSentAt = now;
+        return {
+          topic: "machine.runtime",
+          key: subscription.key,
+          machine: buildMachineInfo("full"),
+          seq: subscription.seq,
+          timestamp: now
+        };
+      }
+      async flushP2PMachineRuntimeSubscriptions() {
+        if (!this.p2p?.isConnected || !this.p2p.hasMachineRuntimeSubscriptions()) return;
+        await this.p2p.flushMachineRuntimeSubscriptions(async (subscription) => this.buildMachineRuntimeUpdateForSubscription(subscription));
+      }
+      async buildSessionHostDiagnosticsUpdateForSubscription(subscription) {
+        if (!this.sessionHostController) return null;
+        const intervalMs = Math.max(5e3, Number(subscription.params.intervalMs || 1e4));
+        const now = Date.now();
+        if (subscription.lastSentAt > 0 && now - subscription.lastSentAt < intervalMs) {
+          return null;
+        }
+        const diagnostics = await this.sessionHostController.getDiagnostics({
+          includeSessions: subscription.params.includeSessions !== false,
+          limit: Number(subscription.params.limit) || void 0
+        });
+        subscription.seq += 1;
+        subscription.lastSentAt = now;
+        return {
+          topic: "session_host.diagnostics",
+          key: subscription.key,
+          diagnostics,
+          seq: subscription.seq,
+          timestamp: now
+        };
+      }
+      async flushP2PSessionHostDiagnosticsSubscriptions() {
+        if (!this.p2p?.isConnected || !this.p2p.hasSessionHostDiagnosticsSubscriptions()) return;
+        await this.p2p.flushSessionHostDiagnosticsSubscriptions(
+          async (subscription) => this.buildSessionHostDiagnosticsUpdateForSubscription(subscription)
+        );
+      }
+      findProviderStateBySessionId(sessionId) {
+        if (!this.components || !sessionId) return null;
+        const states = this.components.instanceManager.collectAllStates();
+        for (const state of states) {
+          if (state.instanceId === sessionId) return state;
+          if (state.category === "ide") {
+            const child = state.extensions.find((entry) => entry.instanceId === sessionId);
+            if (child) return child;
+          }
+        }
+        return null;
+      }
+      buildSessionModalUpdateForSubscription(subscription) {
+        const state = this.findProviderStateBySessionId(subscription.params.targetSessionId);
+        if (!state) return null;
+        const now = Date.now();
+        const activeModal = state.activeChat?.activeModal;
+        const modalButtons = Array.isArray(activeModal?.buttons) ? activeModal.buttons.filter((button) => typeof button === "string") : [];
+        const status = String(state.activeChat?.status || state.status || "idle");
+        const title = typeof state.activeChat?.title === "string" ? state.activeChat.title : void 0;
+        const modalMessage = typeof activeModal?.message === "string" ? activeModal.message : void 0;
+        const deliverySignature = buildSessionModalDeliverySignature({
+          sessionId: subscription.params.targetSessionId,
+          status,
+          ...title ? { title } : {},
+          ...modalMessage ? { modalMessage } : {},
+          ...modalButtons.length > 0 ? { modalButtons } : {}
+        });
+        if (deliverySignature === subscription.lastDeliveredSignature) {
+          return null;
+        }
+        subscription.lastDeliveredSignature = deliverySignature;
+        subscription.seq += 1;
+        subscription.lastSentAt = now;
+        return {
+          topic: "session.modal",
+          key: subscription.key,
+          sessionId: subscription.params.targetSessionId,
+          status,
+          ...title ? { title } : {},
+          ...modalMessage ? { modalMessage } : {},
+          ...modalButtons.length > 0 ? { modalButtons } : {},
+          seq: subscription.seq,
+          timestamp: now
+        };
+      }
+      async flushP2PSessionModalSubscriptions() {
+        if (!this.p2p?.isConnected || !this.p2p.hasSessionModalSubscriptions()) return;
+        await this.p2p.flushSessionModalSubscriptions(
+          async (subscription) => this.buildSessionModalUpdateForSubscription(subscription)
+        );
+      }
+      buildDaemonMetadataSnapshot() {
+        return buildStatusSnapshot({
+          allStates: this.components.instanceManager.collectAllStates(),
+          cdpManagers: this.components.cdpManagers,
+          providerLoader: this.components.providerLoader,
+          detectedIdes: this.components.detectedIdes.value.map((ide) => ({
+            ...ide,
+            path: ide.path ?? void 0
+          })),
+          instanceId: `daemon_${loadConfig().machineId || "daemon"}`,
+          version: pkgVersion,
+          profile: "metadata"
+        });
+      }
+      buildDaemonMetadataUpdateForSubscription(subscription) {
+        const now = Date.now();
+        subscription.seq += 1;
+        subscription.lastSentAt = now;
+        return {
+          topic: "daemon.metadata",
+          key: subscription.key,
+          daemonId: `daemon_${loadConfig().machineId || "daemon"}`,
+          status: this.buildDaemonMetadataSnapshot(),
+          seq: subscription.seq,
+          timestamp: now
+        };
+      }
+      async flushP2PDaemonMetadataSubscriptions() {
+        if (!this.p2p?.isConnected || !this.p2p.hasDaemonMetadataSubscriptions()) return;
+        await this.p2p.flushDaemonMetadataSubscriptions(
+          async (subscription) => this.buildDaemonMetadataUpdateForSubscription(subscription)
+        );
+      }
       async start(options = {}) {
         installGlobalInterceptor();
         process.on("uncaughtException", (err) => {
@@ -49463,9 +50279,14 @@ ${err?.stack || ""}`);
           this.sessionHostEndpoint = sessionHostEndpoint;
           this.sessionHostController = new SessionHostController(
             sessionHostEndpoint,
-            (event) => this.broadcastLocalIpcMessage("daemon:session_host_event", event)
+            (event) => {
+              this.broadcastLocalIpcMessage("daemon:session_host_event", event);
+              void this.flushP2PSessionHostDiagnosticsSubscriptions();
+              void this.flushP2PSessionModalSubscriptions();
+            }
           );
           await this.sessionHostController.start();
+          const instanceId = `daemon_${config2.machineId}`;
           this.components = await initDaemonComponents({
             providerLogFn: LOG.forComponent("Provider").asLogFn(),
             cliManagerDeps: {
@@ -49498,6 +50319,8 @@ ${err?.stack || ""}`);
               listHostedCliRuntimes: async () => listHostedCliRuntimes2(sessionHostEndpoint)
             },
             enabledIdes: config2.enabledIdes,
+            statusInstanceId: instanceId,
+            statusVersion: pkgVersion,
             onStatusChange: () => this.statusReporter?.onStatusChange(),
             onPostChatCommand: () => {
               setTimeout(() => this.statusReporter?.throttledReport(), 1e3);
@@ -49523,7 +50346,6 @@ ${err?.stack || ""}`);
             }
           }).catch(() => {
           });
-          const instanceId = `daemon_${config2.machineId}`;
           this.serverConn = new ServerConnection({
             serverUrl: options.serverUrl || config2.serverUrl,
             token: authToken,
@@ -49573,6 +50395,13 @@ ${err?.stack || ""}`);
                 found.adapter.resize(cols, rows);
               }
             });
+            this.p2p.onSubscriptionChange(() => {
+              void this.flushP2PChatSubscriptions();
+              void this.flushP2PMachineRuntimeSubscriptions();
+              void this.flushP2PSessionHostDiagnosticsSubscriptions();
+              void this.flushP2PSessionModalSubscriptions();
+              void this.flushP2PDaemonMetadataSubscriptions();
+            });
             this.p2p.onStateChange((state) => {
               if (state === "connected") {
                 LOG.info("P2P", "Peer connected \u2192 sending immediate full status report");
@@ -49589,18 +50418,24 @@ ${err?.stack || ""}`);
             this.screenshotController = new ScreenshotController({
               isRunning: () => this.running,
               isScreenshotActive: () => this.p2p?.screenshotActive ?? false,
-              getScreenshotIdeType: () => this.p2p?.screenshotIdeType,
+              getScreenshotTargetSessionId: () => this.p2p?.screenshotTargetSessionId,
               isUsingRelay: () => this.p2p?.isUsingRelay ?? false,
               hasAnyNeedingFirstFrame: () => this.p2p?.hasAnyNeedingFirstFrame() ?? false,
-              getCdp: (ideType) => {
-                if (ideType) return this.getCdpFor(ideType);
-                LOG.warn("P2P", "Screenshot requested without ideType \u2014 cannot determine target IDE. Skipping frame.");
+              getCdp: (targetSessionId) => {
+                if (targetSessionId) return this.getCdpFor(targetSessionId);
+                LOG.warn("P2P", "Screenshot requested without targetSessionId \u2014 cannot determine target session. Skipping frame.");
                 return null;
               },
               sendScreenshotBuffer: (buf) => this.p2p.sendScreenshotBuffer(buf)
             }, planLimits ?? void 0);
             this.screenshotController.start();
             this.p2p.onScreenshotStart(() => this.screenshotController?.triggerImmediate());
+            this.topicSubscriptionTimer = setInterval(() => {
+              void this.flushP2PChatSubscriptions({ onlyActive: true });
+              void this.flushP2PMachineRuntimeSubscriptions();
+              void this.flushP2PSessionHostDiagnosticsSubscriptions();
+              void this.flushP2PSessionModalSubscriptions();
+            }, 2500);
           } else {
             console.log(import_chalk2.default.gray("  \u26A0 P2P unavailable \u2014 using server relay"));
           }
@@ -49705,10 +50540,26 @@ ${err?.stack || ""}`);
       async handleCommand(msg, cmd, args) {
         LOG.info("Command", `${cmd}${args?.targetSessionId ? ` \u2192 session:${String(args.targetSessionId).split("_")[0]}` : ""}`);
         const cmdStart = Date.now();
-        const source = msg.ipcWs ? "ext" : "ws";
+        const source = msg.ipcWs ? "ext" : typeof msg.source === "string" && msg.source.trim() ? msg.source : "ws";
         try {
+          if (source === "api" && !loadConfig().allowServerApiProxy) {
+            this.sendResult(msg, false, {
+              error: "Server API relay is disabled on this daemon. Enable it explicitly with `adhdev daemon:api enable`.",
+              code: "SERVER_API_DISABLED"
+            });
+            return;
+          }
           const result = await this.components.router.execute(cmd, args, source);
           if (cmd.startsWith("workspace_")) this.statusReporter?.throttledReport();
+          if (cmd === "get_status_metadata" || cmd.startsWith("workspace_") || cmd.startsWith("session_host_")) {
+            void this.flushP2PDaemonMetadataSubscriptions();
+          }
+          if (cmd.startsWith("session_host_")) {
+            void this.flushP2PSessionHostDiagnosticsSubscriptions();
+          }
+          if (cmd === "resolve_action" || cmd === "send_chat" || cmd === "read_chat") {
+            void this.flushP2PSessionModalSubscriptions();
+          }
           this.sendResult(msg, result.success, result);
         } catch (e) {
           console.error(import_chalk2.default.red(`  \u2717 Command failed: ${e.message}`));
@@ -49748,6 +50599,7 @@ ${err?.stack || ""}`);
               const config2 = loadConfig();
               config2.machineNickname = nickname;
               saveConfig(config2);
+              void this.flushP2PDaemonMetadataSubscriptions();
               logCommand({ ts: (/* @__PURE__ */ new Date()).toISOString(), cmd: cmdType, source: "p2p", args: { nickname }, success: true, durationMs: Date.now() - cmdStart });
               return { success: true, nickname };
             }
@@ -49760,6 +50612,15 @@ ${err?.stack || ""}`);
           }
           const routed = await this.components.router.execute(cmdType, data, "p2p");
           if (cmdType.startsWith("workspace_")) this.statusReporter?.throttledReport();
+          if (cmdType === "get_status_metadata" || cmdType.startsWith("workspace_") || cmdType.startsWith("session_host_")) {
+            void this.flushP2PDaemonMetadataSubscriptions();
+          }
+          if (cmdType.startsWith("session_host_")) {
+            void this.flushP2PSessionHostDiagnosticsSubscriptions();
+          }
+          if (cmdType === "resolve_action" || cmdType === "send_chat" || cmdType === "read_chat") {
+            void this.flushP2PSessionModalSubscriptions();
+          }
           return routed;
         } catch (e) {
           logCommand({ ts: (/* @__PURE__ */ new Date()).toISOString(), cmd: cmdType, source: "p2p", success: false, error: e.message, durationMs: Date.now() - cmdStart });
@@ -49932,6 +50793,10 @@ ${err?.stack || ""}`);
           this.statusReporter.stopReporting();
           this.statusReporter = null;
         }
+        if (this.topicSubscriptionTimer) {
+          clearInterval(this.topicSubscriptionTimer);
+          this.topicSubscriptionTimer = null;
+        }
         if (this.components) {
           await shutdownDaemonComponents(this.components);
         }
@@ -51794,17 +52659,50 @@ function registerDaemonCommands(program2, pkgVersion3) {
   \u2717 Failed to start standalone server: ${err.message}`));
     });
   });
+  hideCommand(program2.command("daemon:api [mode]").description("Manage server API relay access (disabled by default)").action(async (modeArg) => {
+    const mode = typeof modeArg === "string" && modeArg.trim() ? modeArg.trim().toLowerCase() : "status";
+    const { loadConfig: loadConfig2, saveConfig: saveConfig3 } = await Promise.resolve().then(() => (init_src(), src_exports));
+    const config2 = loadConfig2();
+    if (mode === "status") {
+      const enabled2 = config2.allowServerApiProxy === true;
+      console.log();
+      console.log(import_chalk5.default.bold("  Server API Relay\n"));
+      console.log(`  ${import_chalk5.default.bold("Status:")} ${enabled2 ? import_chalk5.default.green("enabled") : import_chalk5.default.yellow("disabled")}`);
+      console.log(import_chalk5.default.gray("  Applies only to server REST/API proxy routes."));
+      console.log(import_chalk5.default.gray("  Dashboard traffic remains P2P/local IPC based.\n"));
+      return;
+    }
+    if (mode !== "enable" && mode !== "disable") {
+      console.log(import_chalk5.default.red(`
+  \u2717 Unknown mode: ${mode}
+`));
+      console.log(import_chalk5.default.gray("  Use: adhdev daemon:api [status|enable|disable]\n"));
+      process.exitCode = 1;
+      return;
+    }
+    const enabled = mode === "enable";
+    config2.allowServerApiProxy = enabled;
+    saveConfig3(config2);
+    console.log();
+    console.log(import_chalk5.default.bold("  Server API Relay\n"));
+    console.log(`  ${import_chalk5.default.bold("Status:")} ${enabled ? import_chalk5.default.green("enabled") : import_chalk5.default.yellow("disabled")}`);
+    console.log(import_chalk5.default.gray(`  Set with: adhdev daemon:api ${enabled ? "disable" : "enable"}
+`));
+  }));
   hideCommand(program2.command("daemon:status").description("Check ADHDev Daemon status").option("-p, --port <port>", "Local WS server port", "19222").action(async (options) => {
     const { isDaemonRunning: isDaemonRunning2, getDaemonPid: getDaemonPid2 } = await Promise.resolve().then(() => (init_adhdev_daemon(), adhdev_daemon_exports));
     const { getCurrentDaemonLogPath: getCurrentDaemonLogPath2 } = await Promise.resolve().then(() => (init_src(), src_exports));
     const { probeSessionHostStatus: probeSessionHostStatus2 } = await Promise.resolve().then(() => (init_session_host(), session_host_exports));
     const port = parseInt(options.port, 10) || 19222;
+    const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+    const config2 = loadConfig2();
     if (isDaemonRunning2()) {
       console.log(import_chalk5.default.green(`
   \u2713 ADHDev Daemon is running.
 `));
       console.log(import_chalk5.default.gray(`  PID:       ${getDaemonPid2() ?? "unknown"}`));
       console.log(import_chalk5.default.gray(`  Logs:      ${getCurrentDaemonLogPath2()}`));
+      console.log(import_chalk5.default.gray(`  API Relay: ${config2.allowServerApiProxy ? "enabled" : "disabled"}`));
       const health = await fetchLocalDaemonHealth(port);
       if (health) {
         console.log(import_chalk5.default.gray(`  Local IPC: reachable (ws://127.0.0.1:${health.port}${health.wsPath})`));