@adhdev/daemon-core 0.8.35 → 0.8.36

package/dist/index.js

@@ -63,6 +63,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),
@@ -211,6 +212,7 @@ var init_config = __esm({
     import_crypto = require("crypto");
     DEFAULT_CONFIG = {
       serverUrl: "https://api.adhf.dev",
+      allowServerApiProxy: false,
       selectedIde: null,
       configuredIdes: [],
       installedExtensions: [],
@@ -3025,6 +3027,7 @@ __export(index_exports, {
   SessionHostPtyTransportFactory: () => SessionHostPtyTransportFactory,
   VersionArchive: () => VersionArchive,
   appendRecentActivity: () => appendRecentActivity,
+  buildMachineInfo: () => buildMachineInfo,
   buildSessionEntries: () => buildSessionEntries,
   buildStatusSnapshot: () => buildStatusSnapshot,
   connectCdpManager: () => connectCdpManager,
@@ -6984,11 +6987,24 @@ var WORKING_STATUSES = /* @__PURE__ */ new Set([
   "thinking",
   "active"
 ]);
-var STATUS_ACTIVE_CHAT_MESSAGE_LIMIT = 60;
-var STATUS_ACTIVE_CHAT_TOTAL_BYTES_LIMIT = 96 * 1024;
-var STATUS_ACTIVE_CHAT_STRING_LIMIT = 4 * 1024;
-var STATUS_ACTIVE_CHAT_FALLBACK_STRING_LIMIT = 1024;
-var STATUS_INPUT_CONTENT_LIMIT = 2 * 1024;
+var FULL_STATUS_ACTIVE_CHAT_OPTIONS = {
+  includeMessages: true,
+  includeInputContent: true,
+  includeActiveModal: true,
+  messageLimit: 60,
+  totalBytesLimit: 96 * 1024,
+  stringLimit: 4 * 1024,
+  fallbackStringLimit: 1024
+};
+var LIVE_STATUS_ACTIVE_CHAT_OPTIONS = {
+  includeMessages: false,
+  includeInputContent: false,
+  includeActiveModal: false,
+  messageLimit: 0,
+  totalBytesLimit: 0,
+  stringLimit: 512,
+  fallbackStringLimit: 256
+};
 var STATUS_MODAL_MESSAGE_LIMIT = 2 * 1024;
 var STATUS_MODAL_BUTTON_LIMIT = 120;
 function truncateString(value, maxChars) {
@@ -7027,19 +7043,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);
@@ -7069,23 +7086,40 @@ 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
   };
 }
 
 // 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;
@@ -7193,74 +7227,88 @@ var ACP_SESSION_CAPABILITIES = [
   "set_mode",
   "set_thought_level"
 ];
-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",
@@ -7268,74 +7316,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)
@@ -7396,10 +7455,29 @@ function reconcileIdeRuntimeSessions(instanceManager, sessionRegistry) {
 // src/commands/handler.ts
 init_logger();
 
+// 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");
+}
+
 // src/commands/chat-commands.ts
 init_logger();
 var RECENT_SEND_WINDOW_MS = 1200;
 var recentSendByTarget = /* @__PURE__ */ new Map();
+function hashSignatureParts(parts) {
+  let hash = 2166136261;
+  for (const part of parts) {
+    const text = String(part || "");
+    for (let i = 0; i < text.length; i += 1) {
+      hash ^= text.charCodeAt(i);
+      hash = Math.imul(hash, 16777619) >>> 0;
+    }
+    hash ^= 255;
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
 function getCurrentProviderType(h, fallback = "") {
   return h.currentSession?.providerType || h.currentProviderType || fallback;
 }
@@ -7473,6 +7551,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;
@@ -7546,12 +7752,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` };
@@ -7571,12 +7776,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) {
@@ -7588,21 +7793,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" };
@@ -7624,18 +7833,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) {
@@ -7652,18 +7861,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;
@@ -8784,21 +8993,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}'` };
     }
@@ -8823,7 +9032,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"}` };
@@ -8831,7 +9040,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);
@@ -8860,7 +9069,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);
       }
@@ -10243,14 +10452,6 @@ ${effect.notification.body || ""}`.trim();
 var import_stream = require("stream");
 var import_child_process5 = require("child_process");
 var import_sdk = require("@agentclientprotocol/sdk");
-
-// 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");
-}
-
-// src/providers/acp-provider-instance.ts
 init_logger();
 var AcpProviderInstance = class {
   constructor(provider, workingDir, cliArgs = []) {
@@ -13616,6 +13817,37 @@ function buildAvailableProviders(providerLoader) {
     ...provider.detectedPath !== void 0 ? { detectedPath: provider.detectedPath } : {}
   }));
 }
+function buildMachineInfo(profile = "full") {
+  const base = {
+    hostname: os16.hostname(),
+    platform: os16.platform()
+  };
+  if (profile === "live") {
+    return base;
+  }
+  if (profile === "metadata") {
+    const memSnap2 = getHostMemorySnapshot();
+    return {
+      ...base,
+      arch: os16.arch(),
+      cpus: os16.cpus().length,
+      totalMem: memSnap2.totalMem,
+      release: os16.release()
+    };
+  }
+  const memSnap = getHostMemorySnapshot();
+  return {
+    ...base,
+    arch: os16.arch(),
+    cpus: os16.cpus().length,
+    totalMem: memSnap.totalMem,
+    freeMem: memSnap.freeMem,
+    availableMem: memSnap.availableMem,
+    loadavg: os16.loadavg(),
+    uptime: os16.uptime(),
+    release: os16.release()
+  };
+}
 function parseMessageTime(value) {
   if (typeof value === "number" && Number.isFinite(value)) return value;
   if (typeof value === "string") {
@@ -13671,26 +13903,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
     );
@@ -13700,39 +13941,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: os16.hostname(),
-      platform: os16.platform(),
-      arch: os16.arch(),
-      cpus: os16.cpus().length,
-      totalMem: memSnap.totalMem,
-      freeMem: memSnap.freeMem,
-      availableMem: memSnap.availableMem,
-      loadavg: os16.loadavg(),
-      uptime: os16.uptime(),
-      release: os16.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)
+    }
   };
 }
 
@@ -14288,6 +14520,25 @@ var DaemonCommandRouter = class {
         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") {
@@ -14493,9 +14744,58 @@ var DaemonStatusReporter = class {
       }, 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) {
   }
@@ -14564,17 +14864,16 @@ var DaemonStatusReporter = class {
         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);
@@ -14589,16 +14888,15 @@ var DaemonStatusReporter = class {
     }
     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,
@@ -14606,9 +14904,7 @@ var DaemonStatusReporter = class {
         currentAutoApprove: session.currentAutoApprove
       })),
       p2p: payload.p2p,
-      timestamp: now,
-      detectedIdes: payload.detectedIdes,
-      availableProviders: payload.availableProviders
+      timestamp: now
     };
     const wsHash = this.simpleHash(JSON.stringify({
       ...wsPayload,
@@ -14625,10 +14921,15 @@ var DaemonStatusReporter = class {
   // ─── 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: _a, 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;
@@ -21726,6 +22027,8 @@ async function initDaemonComponents(config) {
     onStatusChange: config.onStatusChange,
     onPostChatCommand: config.onPostChatCommand,
     sessionHostControl: config.sessionHostControl,
+    statusInstanceId: config.statusInstanceId,
+    statusVersion: config.statusVersion,
     getCdpLogFn: config.getCdpLogFn || ((ideType) => LOG.forComponent(`CDP:${ideType}`).asLogFn())
   });
   poller = new AgentStreamPoller({
@@ -21828,6 +22131,7 @@ async function shutdownDaemonComponents(components) {
   SessionHostPtyTransportFactory,
   VersionArchive,
   appendRecentActivity,
+  buildMachineInfo,
   buildSessionEntries,
   buildStatusSnapshot,
   connectCdpManager,