adhdev 0.8.24 → 0.8.27

package/dist/index.js

@@ -2852,6 +2852,7 @@ var init_extension_provider_instance = __esm({
       currentStatus = "idle";
       agentStreams = [];
       messages = [];
+      prevMessageHashes = /* @__PURE__ */ new Map();
       activeModal = null;
       currentModel = "";
       currentMode = "";
@@ -2917,7 +2918,7 @@ var init_extension_provider_instance = __esm({
       onEvent(event, data) {
         if (event === "stream_update") {
           if (data?.streams) this.agentStreams = data.streams;
-          if (data?.messages) this.messages = data.messages;
+          if (data?.messages) this.messages = this.assignReceivedAt(data.messages);
           if (data?.activeModal !== void 0) this.activeModal = data.activeModal;
           if (data?.model) this.currentModel = data.model;
           if (data?.mode) this.currentMode = data.mode;
@@ -2943,6 +2944,7 @@ var init_extension_provider_instance = __esm({
       dispose() {
         this.agentStreams = [];
         this.messages = [];
+        this.prevMessageHashes.clear();
         this.monitor.reset();
         this.appliedEffectKeys.clear();
         this.runtimeMessages = [];
@@ -3098,6 +3100,23 @@ var init_extension_provider_instance = __esm({
           this.chatId || this.instanceId
         );
       }
+      /**
+       * Assign stable receivedAt to extension messages.
+       * Same pattern as IdeProviderInstance.readChat() prevByHash —
+       * preserves first-seen timestamp across polling cycles.
+       */
+      assignReceivedAt(messages) {
+        const now = Date.now();
+        const nextHashes = /* @__PURE__ */ new Map();
+        for (const msg of messages) {
+          const hash2 = `${msg.role}:${(msg.content || "").slice(0, 100)}`;
+          const prevTime = this.prevMessageHashes.get(hash2);
+          msg.receivedAt = prevTime || now;
+          nextHashes.set(hash2, msg.receivedAt);
+        }
+        this.prevMessageHashes = nextHashes;
+        return messages;
+      }
       mergeConversationMessages(messages) {
         if (this.runtimeMessages.length === 0) return messages;
         return [...messages, ...this.runtimeMessages.map((entry) => entry.message)].map((message, index) => ({ message, index })).sort((a, b) => {
@@ -3154,6 +3173,7 @@ ${effect.notification.body || ""}`.trim();
         }
         this.agentStreams = [];
         this.messages = [];
+        this.prevMessageHashes.clear();
         this.activeModal = null;
         this.currentModel = "";
         this.currentMode = "";
@@ -4161,16 +4181,28 @@ function trimMessageForStatus(message, stringLimit) {
   if (!message || typeof message !== "object") return message;
   return trimStructuredStrings(message, stringLimit);
 }
+function normalizeMessageTime(message) {
+  if (!message || typeof message !== "object") return message;
+  const msg = message;
+  if (msg.receivedAt == null) {
+    const fallback = msg.timestamp ?? msg.createdAt;
+    if (fallback != null) {
+      const ts2 = typeof fallback === "string" ? Date.parse(fallback) : Number(fallback);
+      if (Number.isFinite(ts2) && ts2 > 0) msg.receivedAt = ts2;
+    }
+  }
+  return msg;
+}
 function trimMessagesForStatus(messages) {
   if (!Array.isArray(messages) || messages.length === 0) return [];
   const recent = messages.slice(-STATUS_ACTIVE_CHAT_MESSAGE_LIMIT);
   const kept = [];
   let totalBytes = 0;
   for (let i = recent.length - 1; i >= 0; i -= 1) {
-    let normalized = trimMessageForStatus(recent[i], STATUS_ACTIVE_CHAT_STRING_LIMIT);
+    let normalized = normalizeMessageTime(trimMessageForStatus(recent[i], STATUS_ACTIVE_CHAT_STRING_LIMIT));
     let size = estimateBytes(normalized);
     if (size > STATUS_ACTIVE_CHAT_TOTAL_BYTES_LIMIT) {
-      normalized = trimMessageForStatus(recent[i], STATUS_ACTIVE_CHAT_FALLBACK_STRING_LIMIT);
+      normalized = normalizeMessageTime(trimMessageForStatus(recent[i], STATUS_ACTIVE_CHAT_FALLBACK_STRING_LIMIT));
       size = estimateBytes(normalized);
     }
     if (kept.length > 0 && totalBytes + size > STATUS_ACTIVE_CHAT_TOTAL_BYTES_LIMIT) {
@@ -4510,6 +4542,56 @@ var init_builders = __esm({
   }
 });
 
+// ../../oss/packages/daemon-core/src/sessions/reconcile.ts
+function upsertSessionTarget(sessionRegistry, target) {
+  const existing = sessionRegistry.get(target.sessionId);
+  if (existing && existing.parentSessionId === target.parentSessionId && existing.providerType === target.providerType && existing.transport === target.transport && existing.cdpManagerKey === target.cdpManagerKey && existing.instanceKey === target.instanceKey) {
+    return;
+  }
+  sessionRegistry.register(target);
+}
+function reconcileIdeRuntimeSessions(instanceManager, sessionRegistry) {
+  if (!instanceManager || !sessionRegistry) return;
+  for (const instanceKey of instanceManager.listInstanceIds()) {
+    if (!instanceKey.startsWith("ide:")) continue;
+    const ideInstance = instanceManager.getInstance(instanceKey);
+    if (!ideInstance || ideInstance.category !== "ide" || typeof ideInstance.getInstanceId !== "function") {
+      continue;
+    }
+    const managerKey = instanceKey.slice(4);
+    const ideType = typeof ideInstance.type === "string" && ideInstance.type.trim() ? ideInstance.type.trim() : managerKey.split("_")[0];
+    const parentSessionId = ideInstance.getInstanceId();
+    if (!parentSessionId) continue;
+    upsertSessionTarget(sessionRegistry, {
+      sessionId: parentSessionId,
+      parentSessionId: null,
+      providerType: ideType,
+      transport: "cdp-page",
+      cdpManagerKey: managerKey,
+      instanceKey
+    });
+    const extensions = ideInstance.getExtensionInstances?.() || [];
+    for (const ext of extensions) {
+      const extType = typeof ext?.type === "string" ? ext.type.trim() : "";
+      const extSessionId = ext?.getInstanceId?.();
+      if (!extType || !extSessionId) continue;
+      upsertSessionTarget(sessionRegistry, {
+        sessionId: extSessionId,
+        parentSessionId,
+        providerType: extType,
+        transport: "cdp-webview",
+        cdpManagerKey: managerKey,
+        instanceKey
+      });
+    }
+  }
+}
+var init_reconcile = __esm({
+  "../../oss/packages/daemon-core/src/sessions/reconcile.ts"() {
+    "use strict";
+  }
+});
+
 // ../../oss/packages/daemon-core/src/commands/chat-commands.ts
 function getCurrentProviderType(h, fallback = "") {
   return h.currentSession?.providerType || h.currentProviderType || fallback;
@@ -4770,7 +4852,7 @@ async function handleSendChat(h, args) {
   if (isExtensionTransport(transport)) {
     _log(`Extension: ${provider?.type || "unknown_extension"}`);
     try {
-      const evalResult = await h.evaluateProviderScript("sendMessage", { MESSAGE: text }, 3e4);
+      const evalResult = await h.evaluateProviderScript("sendMessage", { message: text }, 3e4);
       if (evalResult?.result) {
         const parsed = parseMaybeJson(evalResult.result);
         if (didProviderConfirmSend(parsed)) {
@@ -4801,7 +4883,7 @@ async function handleSendChat(h, args) {
     return { success: false, error: `CDP for ${managerKey || "unknown"} not connected` };
   }
   _log(`Targeting IDE: ${getCurrentManagerKey(h)}`);
-  const sendScript = h.getProviderScript("sendMessage", { MESSAGE: text });
+  const sendScript = h.getProviderScript("sendMessage", { message: text });
   if (sendScript) {
     try {
       const result = await targetCdp.evaluate(sendScript, 3e4);
@@ -5809,10 +5891,10 @@ function getCliScriptCommand(payload) {
   }
   const command = payload.command;
   if (!command || typeof command !== "object") return null;
-  if (command.type !== "send_message") return null;
+  if (command.type !== "send_message" && command.type !== "pty_write") return null;
   const text = typeof command.text === "string" ? command.text.trim() : typeof command.message === "string" ? command.message.trim() : "";
   if (!text) return null;
-  return { type: "send_message", text };
+  return { type: command.type, text };
 }
 function applyProviderPatch(h, args, payload) {
   if (!payload || typeof payload !== "object") return;
@@ -5853,6 +5935,8 @@ async function executeProviderScript(h, args, scriptName) {
       const cliCommand = getCliScriptCommand(parsed.payload);
       if (cliCommand?.type === "send_message" && cliCommand.text) {
         await adapter.sendMessage(cliCommand.text);
+      } else if (cliCommand?.type === "pty_write" && cliCommand.text && adapter.writeRaw) {
+        adapter.writeRaw(cliCommand.text + "\r");
       }
       applyProviderPatch(h, args, parsed.payload);
       return { success: true, ...parsed.payload && typeof parsed.payload === "object" ? parsed.payload : { result: parsed.payload } };
@@ -6166,6 +6250,7 @@ var init_handler = __esm({
     init_devtools();
     init_builders();
     init_chat_history();
+    init_reconcile();
     init_logger();
     init_chat_commands();
     init_cdp_commands();
@@ -6242,9 +6327,26 @@ var init_handler = __esm({
         if (provider?.scripts) {
           const fn = provider.scripts[scriptName];
           if (typeof fn === "function") {
-            const firstVal = params ? Object.values(params)[0] : void 0;
-            const script = firstVal ? fn(firstVal) : fn();
-            if (script) return script;
+            if (params && Object.keys(params).length > 0) {
+              const firstVal = Object.values(params)[0];
+              if (scriptName === "sendMessage" && typeof firstVal === "string") {
+                const legacyScript = fn(firstVal);
+                if (legacyScript) return legacyScript;
+              }
+              const script = fn(params);
+              if (script) {
+                const likelyLegacyObjectLeak = typeof script === "string" && script.includes("[object Object]") && typeof firstVal === "string";
+                if (!likelyLegacyObjectLeak) return script;
+              }
+              if (firstVal !== void 0) {
+                const legacyScript = fn(firstVal);
+                if (legacyScript) return legacyScript;
+              }
+              if (script) return script;
+            } else {
+              const script = fn();
+              if (script) return script;
+            }
           }
         }
         return null;
@@ -6300,17 +6402,27 @@ var init_handler = __esm({
         return key.split("_")[0];
       }
       resolveRoute(args) {
-        const session = this._ctx.sessionRegistry?.get(args?.targetSessionId);
-        const managerKey = this.extractIdeType(args);
-        const providerType = args?.agentType || args?.providerType || session?.providerType || this.inferProviderType(managerKey);
-        return { session, managerKey, providerType };
+        const targetSessionId = typeof args?.targetSessionId === "string" ? args.targetSessionId.trim() : "";
+        let session = targetSessionId ? this._ctx.sessionRegistry?.get(targetSessionId) : void 0;
+        if (targetSessionId && !session) {
+          reconcileIdeRuntimeSessions(this._ctx.instanceManager, this._ctx.sessionRegistry);
+          session = this._ctx.sessionRegistry?.get(targetSessionId);
+        }
+        const sessionLookupFailed = !!targetSessionId && !session;
+        const managerKey = this.extractIdeType(args, sessionLookupFailed);
+        let providerType;
+        if (!sessionLookupFailed) {
+          providerType = session?.providerType || args?.agentType || args?.providerType || this.inferProviderType(managerKey);
+        }
+        return { session, managerKey, providerType, sessionLookupFailed };
       }
       /** Extract CDP scope key from target session or explicit ideType */
-      extractIdeType(args) {
+      extractIdeType(args, sessionLookupFailed = false) {
         if (args?.targetSessionId) {
           const target = this._ctx.sessionRegistry?.get(args.targetSessionId);
           if (target?.cdpManagerKey) return target.cdpManagerKey;
           if (this._ctx.cdpManagers.has(args.targetSessionId)) return args.targetSessionId;
+          if (sessionLookupFailed) return void 0;
         }
         if (args?.ideType) {
           const target = this._ctx.sessionRegistry?.get(args.ideType);
@@ -6357,6 +6469,33 @@ var init_handler = __esm({
         this._currentRoute = this.resolveRoute(args);
         const startedAt = Date.now();
         this.logCommandStart(cmd, args);
+        const sessionScopedCommands = /* @__PURE__ */ new Set([
+          "read_chat",
+          "send_chat",
+          "list_chats",
+          "new_chat",
+          "switch_chat",
+          "set_mode",
+          "change_model",
+          "set_thought_level",
+          "resolve_action",
+          "focus_session",
+          "pty_input",
+          "pty_resize",
+          "invoke_provider_script",
+          "list_extension_models",
+          "set_extension_model",
+          "list_extension_modes",
+          "set_extension_mode"
+        ]);
+        if (this._currentRoute.sessionLookupFailed && sessionScopedCommands.has(cmd)) {
+          const result2 = {
+            success: false,
+            error: `Live session not found for targetSessionId: ${String(args?.targetSessionId || "").trim() || "unknown"}`
+          };
+          this.logCommandEnd(cmd, result2, startedAt);
+          return result2;
+        }
         let result;
         if (!this._currentRoute.session && !this._currentRoute.managerKey && !this._currentRoute.providerType) {
           const cdpCommands = ["send_chat", "read_chat", "list_chats", "new_chat", "switch_chat", "set_mode", "change_model", "set_thought_level", "resolve_action"];
@@ -9212,6 +9351,7 @@ var init_cli_provider_instance = __esm({
           this.detectStatusTransition();
         });
         await this.adapter.spawn();
+        this.maybeAppendRuntimeRecoveryMessage(this.adapter.getRuntimeMetadata());
         if (this.providerSessionId) {
           const restoredHistory = readChatHistory(this.type, 0, 200, this.providerSessionId);
           if (restoredHistory.messages.length > 0) {
@@ -9306,6 +9446,7 @@ var init_cli_provider_instance = __esm({
           this.promoteProviderSessionId(parsedProviderSessionId);
         }
         const runtime = this.adapter.getRuntimeMetadata();
+        this.maybeAppendRuntimeRecoveryMessage(runtime);
         const parsedMessages = Array.isArray(parsedStatus?.messages) ? parsedStatus.messages : [];
         const controlValues = extractProviderControlValues(this.provider.controls, parsedStatus);
         if (controlValues) {
@@ -9632,6 +9773,28 @@ ${effect.notification.body || ""}`.trim();
         const pad = (value) => String(value).padStart(2, "0");
         return `${date5.getFullYear()}-${pad(date5.getMonth() + 1)}-${pad(date5.getDate())} ${pad(date5.getHours())}:${pad(date5.getMinutes())}:${pad(date5.getSeconds())}`;
       }
+      maybeAppendRuntimeRecoveryMessage(runtime) {
+        if (!runtime?.restoredFromStorage || !runtime.runtimeId) return;
+        const recoveryState = String(runtime.recoveryState || "").trim();
+        if (!recoveryState) return;
+        let content = "";
+        if (recoveryState === "auto_resumed") {
+          content = "Session host restored this CLI after restart and reattached it from a saved snapshot.";
+        } else if (recoveryState === "resume_failed") {
+          const errorSuffix = runtime.recoveryError ? ` Resume failed: ${runtime.recoveryError}` : "";
+          content = `Session host found this CLI after restart, but automatic resume failed.${errorSuffix}`;
+        } else if (recoveryState === "host_restart_interrupted") {
+          content = "Session host found this CLI in interrupted state after restart and is attempting to resume it.";
+        } else if (recoveryState === "orphan_snapshot") {
+          content = "Session host restored the last snapshot for this CLI, but the original runtime was not resumed automatically.";
+        } else {
+          content = `Session host restored this CLI after restart (${recoveryState}).`;
+        }
+        this.appendRuntimeSystemMessage(
+          content,
+          `runtime_recovery:${runtime.runtimeId}:${recoveryState}`
+        );
+      }
       appendRuntimeSystemMessage(content, dedupKey, receivedAt = Date.now()) {
         const normalizedContent = String(content || "").trim();
         if (!normalizedContent) return;
@@ -31009,17 +31172,17 @@ function parseMessageTime(value) {
 function getSessionMessageUpdatedAt(session) {
   const lastMessage = session.activeChat?.messages?.at?.(-1);
   if (!lastMessage) return 0;
-  return parseMessageTime(lastMessage.timestamp) || parseMessageTime(lastMessage.receivedAt) || parseMessageTime(lastMessage.createdAt) || 0;
+  return parseMessageTime(lastMessage.receivedAt) || 0;
 }
 function getSessionCompletionMarker(session) {
   const lastMessage = session.activeChat?.messages?.at?.(-1);
   if (!lastMessage) return "";
   const role = typeof lastMessage.role === "string" ? lastMessage.role : "";
-  if (role === "user" || role === "human") return "";
+  if (role === "user" || role === "human" || role === "system") return "";
   if (typeof lastMessage._turnKey === "string" && lastMessage._turnKey) return `turn:${lastMessage._turnKey}`;
   if (typeof lastMessage.id === "string" && lastMessage.id) return `id:${lastMessage.id}`;
   if (typeof lastMessage.index === "number" && Number.isFinite(lastMessage.index)) return `idx:${lastMessage.index}`;
-  const timestamp = parseMessageTime(lastMessage.timestamp) || parseMessageTime(lastMessage.receivedAt) || parseMessageTime(lastMessage.createdAt);
+  const timestamp = parseMessageTime(lastMessage.receivedAt);
   return timestamp > 0 ? `ts:${timestamp}` : "";
 }
 function getSessionLastUsedAt(session) {
@@ -31036,7 +31199,7 @@ function getUnreadState(hasContentChange, status, lastUsedAt, lastSeenAt, lastRo
   if (status === "generating" || status === "starting") {
     return { unread: false, inboxBucket: "working" };
   }
-  const unread = completionMarker ? completionMarker !== seenCompletionMarker : hasContentChange && lastUsedAt > lastSeenAt && lastRole !== "user" && lastRole !== "human";
+  const unread = completionMarker ? completionMarker !== seenCompletionMarker : hasContentChange && lastUsedAt > lastSeenAt && lastRole !== "user" && lastRole !== "human" && lastRole !== "system";
   return { unread, inboxBucket: unread ? "task_complete" : "idle" };
 }
 function buildRecentLaunches(recentActivity) {
@@ -31334,6 +31497,25 @@ var init_upgrade_helper = __esm({
 });
 
 // ../../oss/packages/daemon-core/src/commands/router.ts
+function toHostedCliRuntimeDescriptor(record2) {
+  if (!record2 || typeof record2 !== "object") return null;
+  const runtimeId = typeof record2.sessionId === "string" ? record2.sessionId : "";
+  const cliType = typeof record2.providerType === "string" ? record2.providerType : "";
+  const workspace = typeof record2.workspace === "string" ? record2.workspace : "";
+  if (!runtimeId || !cliType || !workspace) return null;
+  return {
+    runtimeId,
+    runtimeKey: typeof record2.runtimeKey === "string" ? record2.runtimeKey : void 0,
+    displayName: typeof record2.displayName === "string" ? record2.displayName : void 0,
+    workspaceLabel: typeof record2.workspaceLabel === "string" ? record2.workspaceLabel : void 0,
+    lifecycle: typeof record2.lifecycle === "string" ? record2.lifecycle : void 0,
+    recoveryState: typeof record2.meta?.runtimeRecoveryState === "string" ? String(record2.meta.runtimeRecoveryState) : null,
+    cliType,
+    workspace,
+    cliArgs: Array.isArray(record2.meta?.cliArgs) ? record2.meta.cliArgs : [],
+    providerSessionId: typeof record2.meta?.providerSessionId === "string" ? String(record2.meta.providerSessionId) : void 0
+  };
+}
 var fs9, CHAT_COMMANDS, READ_DEBUG_ENABLED2, DaemonCommandRouter;
 var init_router = __esm({
   "../../oss/packages/daemon-core/src/commands/router.ts"() {
@@ -31437,6 +31619,90 @@ var init_router = __esm({
               return { success: false, error: e.message };
             }
           }
+          case "session_host_get_diagnostics": {
+            if (!this.deps.sessionHostControl) return { success: false, error: "Session host control unavailable" };
+            const diagnostics = await this.deps.sessionHostControl.getDiagnostics({
+              includeSessions: args?.includeSessions !== false,
+              limit: Number(args?.limit) || void 0
+            });
+            return { success: true, diagnostics };
+          }
+          case "session_host_list_sessions": {
+            if (!this.deps.sessionHostControl) return { success: false, error: "Session host control unavailable" };
+            const sessions = await this.deps.sessionHostControl.listSessions();
+            return { success: true, sessions };
+          }
+          case "session_host_stop_session": {
+            if (!this.deps.sessionHostControl) return { success: false, error: "Session host control unavailable" };
+            const sessionId = typeof args?.sessionId === "string" ? args.sessionId : "";
+            if (!sessionId) return { success: false, error: "sessionId required" };
+            const record2 = await this.deps.sessionHostControl.stopSession(sessionId);
+            return { success: true, record: record2 };
+          }
+          case "session_host_resume_session": {
+            if (!this.deps.sessionHostControl) return { success: false, error: "Session host control unavailable" };
+            const sessionId = typeof args?.sessionId === "string" ? args.sessionId : "";
+            if (!sessionId) return { success: false, error: "sessionId required" };
+            const record2 = await this.deps.sessionHostControl.resumeSession(sessionId);
+            const hosted = toHostedCliRuntimeDescriptor(record2);
+            if (hosted) {
+              await this.deps.cliManager.restoreHostedSessions([hosted]);
+            }
+            return { success: true, record: record2 };
+          }
+          case "session_host_restart_session": {
+            if (!this.deps.sessionHostControl) return { success: false, error: "Session host control unavailable" };
+            const sessionId = typeof args?.sessionId === "string" ? args.sessionId : "";
+            if (!sessionId) return { success: false, error: "sessionId required" };
+            const record2 = await this.deps.sessionHostControl.restartSession(sessionId);
+            const hosted = toHostedCliRuntimeDescriptor(record2);
+            if (hosted) {
+              await this.deps.cliManager.restoreHostedSessions([hosted]);
+            }
+            return { success: true, record: record2 };
+          }
+          case "session_host_send_signal": {
+            if (!this.deps.sessionHostControl) return { success: false, error: "Session host control unavailable" };
+            const sessionId = typeof args?.sessionId === "string" ? args.sessionId : "";
+            const signal = typeof args?.signal === "string" ? args.signal : "";
+            if (!sessionId) return { success: false, error: "sessionId required" };
+            if (!signal) return { success: false, error: "signal required" };
+            const record2 = await this.deps.sessionHostControl.sendSignal(sessionId, signal);
+            return { success: true, record: record2 };
+          }
+          case "session_host_force_detach_client": {
+            if (!this.deps.sessionHostControl) return { success: false, error: "Session host control unavailable" };
+            const sessionId = typeof args?.sessionId === "string" ? args.sessionId : "";
+            const clientId = typeof args?.clientId === "string" ? args.clientId : "";
+            if (!sessionId) return { success: false, error: "sessionId required" };
+            if (!clientId) return { success: false, error: "clientId required" };
+            const record2 = await this.deps.sessionHostControl.forceDetachClient(sessionId, clientId);
+            return { success: true, record: record2 };
+          }
+          case "session_host_acquire_write": {
+            if (!this.deps.sessionHostControl) return { success: false, error: "Session host control unavailable" };
+            const sessionId = typeof args?.sessionId === "string" ? args.sessionId : "";
+            const clientId = typeof args?.clientId === "string" ? args.clientId : "";
+            const ownerType = args?.ownerType === "agent" ? "agent" : "user";
+            if (!sessionId) return { success: false, error: "sessionId required" };
+            if (!clientId) return { success: false, error: "clientId required" };
+            const record2 = await this.deps.sessionHostControl.acquireWrite({
+              sessionId,
+              clientId,
+              ownerType,
+              force: args?.force !== false
+            });
+            return { success: true, record: record2 };
+          }
+          case "session_host_release_write": {
+            if (!this.deps.sessionHostControl) return { success: false, error: "Session host control unavailable" };
+            const sessionId = typeof args?.sessionId === "string" ? args.sessionId : "";
+            const clientId = typeof args?.clientId === "string" ? args.clientId : "";
+            if (!sessionId) return { success: false, error: "sessionId required" };
+            if (!clientId) return { success: false, error: "clientId required" };
+            const record2 = await this.deps.sessionHostControl.releaseWrite({ sessionId, clientId });
+            return { success: true, record: record2 };
+          }
           case "list_saved_sessions": {
             const providerType = typeof args?.providerType === "string" ? args.providerType.trim() : typeof args?.agentType === "string" ? args.agentType.trim() : "";
             const kind = args?.kind === "acp" ? "acp" : "cli";
@@ -31983,6 +32249,14 @@ var init_provider_adapter = __esm({
       hasScript(name) {
         return typeof this.provider.scripts?.[name] === "function";
       }
+      parseMaybeJson(raw) {
+        if (typeof raw !== "string") return raw;
+        try {
+          return JSON.parse(raw);
+        } catch {
+          return raw;
+        }
+      }
       summarizeRaw(raw) {
         try {
           if (typeof raw === "string") return raw.replace(/\s+/g, " ").trim().slice(0, 240);
@@ -32043,12 +32317,30 @@ var init_provider_adapter = __esm({
         }
       }
       async sendMessage(evaluate, text) {
-        const script = this.callScript("sendMessage", text);
+        const params = { message: text };
+        const script = this.callScript("sendMessage", params) || this.callScript("sendMessage", text);
         if (!script) throw new Error(`[${this.agentName}] sendMessage script not available`);
         const result = await evaluate(script);
         if (result && typeof result === "string" && result.startsWith("error:")) {
           throw new Error(`[${this.agentName}] sendMessage failed: ${result}`);
         }
+        const parsed = this.parseMaybeJson(result);
+        if (parsed === true) return;
+        if (typeof parsed === "string") {
+          const normalized = parsed.trim().toLowerCase();
+          if (normalized === "ok" || normalized === "sent" || normalized === "success" || normalized === "true") {
+            return;
+          }
+        }
+        if (parsed && typeof parsed === "object") {
+          if (parsed.sent === true || parsed.success === true || parsed.ok === true || parsed.submitted === true || parsed.dispatched === true) {
+            return;
+          }
+          if (typeof parsed.error === "string" && parsed.error.trim()) {
+            throw new Error(`[${this.agentName}] sendMessage failed: ${parsed.error}`);
+          }
+        }
+        throw new Error(`[${this.agentName}] sendMessage was not confirmed`);
       }
       async resolveAction(evaluate, action, button) {
         const script = this.callScript("resolveAction", { action, button });
@@ -32415,6 +32707,7 @@ var init_poller = __esm({
   "../../oss/packages/daemon-core/src/agent-stream/poller.ts"() {
     "use strict";
     init_setup();
+    init_reconcile();
     init_logger();
     AgentStreamPoller = class {
       deps;
@@ -32454,6 +32747,7 @@ var init_poller = __esm({
           sessionRegistry
         } = this.deps;
         if (!agentStreamManager || cdpManagers.size === 0) return;
+        reconcileIdeRuntimeSessions(instanceManager, sessionRegistry);
         for (const [ideType, cdp] of cdpManagers) {
           registerExtensionProviders(providerLoader, cdp, ideType);
           const ideInstance = instanceManager.getInstance(`ide:${ideType}`);
@@ -38381,6 +38675,7 @@ var init_session_host_transport = __esm({
         }
       }
       handleEvent(event) {
+        if (!("sessionId" in event)) return;
         if (event.sessionId !== this.options.runtimeId) return;
         if ((event.type === "session_started" || event.type === "session_resumed") && typeof event.pid === "number") {
           this.currentPid = event.pid;
@@ -38456,7 +38751,10 @@ var init_session_host_transport = __esm({
             clientId: client.clientId,
             type: client.type,
             readOnly: client.readOnly
-          }))
+          })),
+          restoredFromStorage: record2.meta?.restoredFromStorage === true,
+          recoveryState: typeof record2.meta?.runtimeRecoveryState === "string" ? String(record2.meta.runtimeRecoveryState) : null,
+          recoveryError: typeof record2.meta?.runtimeRecoveryError === "string" ? String(record2.meta.runtimeRecoveryError) : null
         };
       }
       enqueue(action) {
@@ -38918,6 +39216,7 @@ async function initDaemonComponents(config2) {
     onIdeConnected: () => poller?.start(),
     onStatusChange: config2.onStatusChange,
     onPostChatCommand: config2.onPostChatCommand,
+    sessionHostControl: config2.sessionHostControl,
     getCdpLogFn: config2.getCdpLogFn || ((ideType) => LOG.forComponent(`CDP:${ideType}`).asLogFn())
   });
   poller = new AgentStreamPoller({
@@ -47167,6 +47466,151 @@ var init_session_host = __esm({
   }
 });
 
+// src/session-host-controller.ts
+var SessionHostController;
+var init_session_host_controller = __esm({
+  "src/session-host-controller.ts"() {
+    "use strict";
+    init_src();
+    init_dist();
+    SessionHostController = class {
+      constructor(endpoint, onEvent) {
+        this.onEvent = onEvent;
+        this.client = new SessionHostClient({ endpoint });
+      }
+      client;
+      reconnectTimer = null;
+      unsubscribe = null;
+      started = false;
+      async start() {
+        if (this.started) return;
+        this.started = true;
+        this.unsubscribe = this.client.onEvent((event) => this.handleEvent(event));
+        await this.ensureConnected();
+        this.reconnectTimer = setInterval(() => {
+          void this.ensureConnected();
+        }, 2e3);
+      }
+      async stop() {
+        this.started = false;
+        if (this.reconnectTimer) {
+          clearInterval(this.reconnectTimer);
+          this.reconnectTimer = null;
+        }
+        try {
+          this.unsubscribe?.();
+          this.unsubscribe = null;
+        } catch {
+        }
+        await this.client.close().catch(() => {
+        });
+      }
+      async getDiagnostics(payload = {}) {
+        return this.request({
+          type: "get_host_diagnostics",
+          payload
+        });
+      }
+      async listSessions() {
+        return this.request({
+          type: "list_sessions",
+          payload: {}
+        });
+      }
+      async stopSession(sessionId) {
+        return this.request({
+          type: "stop_session",
+          payload: { sessionId }
+        });
+      }
+      async resumeSession(sessionId) {
+        return this.request({
+          type: "resume_session",
+          payload: { sessionId }
+        });
+      }
+      async restartSession(sessionId) {
+        return this.request({
+          type: "restart_session",
+          payload: { sessionId }
+        });
+      }
+      async sendSignal(sessionId, signal) {
+        return this.request({
+          type: "send_signal",
+          payload: { sessionId, signal }
+        });
+      }
+      async forceDetachClient(sessionId, clientId) {
+        return this.request({
+          type: "force_detach_client",
+          payload: { sessionId, clientId }
+        });
+      }
+      async acquireWrite(payload) {
+        return this.request({
+          type: "acquire_write",
+          payload
+        });
+      }
+      async releaseWrite(payload) {
+        return this.request({
+          type: "release_write",
+          payload
+        });
+      }
+      async request(request) {
+        await this.ensureConnected();
+        const response = await this.client.request(request);
+        if (!response.success) {
+          throw new Error(response.error || `Session host request failed: ${request.type}`);
+        }
+        return response.result ?? null;
+      }
+      async ensureConnected() {
+        try {
+          await this.client.connect();
+        } catch (error48) {
+          if (!this.started) return;
+          LOG.debug("SessionHost", `connect failed: ${error48?.message || error48}`);
+        }
+      }
+      handleEvent(event) {
+        if (event.type === "host_log") {
+          const line = event.entry.sessionId ? `${event.entry.message} (session=${event.entry.sessionId})` : event.entry.message;
+          switch (event.entry.level) {
+            case "debug":
+              LOG.debug("SessionHost", line);
+              break;
+            case "warn":
+              LOG.warn("SessionHost", line);
+              break;
+            case "error":
+              LOG.error("SessionHost", line);
+              break;
+            default:
+              LOG.info("SessionHost", line);
+              break;
+          }
+        } else if (event.type === "request_trace") {
+          const line = `${event.trace.type} ${event.trace.success ? "ok" : "failed"} ${event.trace.durationMs}ms` + (event.trace.sessionId ? ` session=${event.trace.sessionId}` : "") + (event.trace.error ? ` error=${event.trace.error}` : "");
+          if (event.trace.success) LOG.debug("SessionHost", line);
+          else LOG.warn("SessionHost", line);
+        } else if (event.type === "runtime_transition") {
+          const line = `${event.transition.action} ${event.transition.success === false ? "failed" : "ok"}` + (event.transition.lifecycle ? ` lifecycle=${event.transition.lifecycle}` : "") + (event.transition.detail ? ` detail=${event.transition.detail}` : "") + (event.transition.error ? ` error=${event.transition.error}` : "");
+          if (event.transition.success === false) LOG.warn("SessionHost", `[${event.transition.sessionId}] ${line}`);
+          else LOG.info("SessionHost", `[${event.transition.sessionId}] ${line}`);
+        }
+        try {
+          this.onEvent?.(event);
+        } catch (error48) {
+          LOG.warn("SessionHost", `event callback failed: ${error48?.message || error48}`);
+        }
+      }
+    };
+  }
+});
+
 // src/version.ts
 function resolvePackageVersion(options) {
   const injectedVersion = options?.injectedVersion || "unknown";
@@ -47261,6 +47705,7 @@ var init_adhdev_daemon = __esm({
     init_screenshot_controller();
     init_session_host();
     init_dist();
+    init_session_host_controller();
     os21 = __toESM(require("os"));
     fs17 = __toESM(require("fs"));
     path21 = __toESM(require("path"));
@@ -47268,7 +47713,7 @@ var init_adhdev_daemon = __esm({
     import_ws3 = require("ws");
     import_chalk2 = __toESM(require("chalk"));
     init_version();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.8.24" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.8.27" });
     DANGEROUS_PATTERNS = [
       /\brm\s+(-[a-z]*f|-[a-z]*r|--force|--recursive)/i,
       /\bsudo\b/i,
@@ -47291,6 +47736,7 @@ var init_adhdev_daemon = __esm({
       statusReporter = null;
       components = null;
       sessionHostEndpoint = null;
+      sessionHostController = null;
       running = false;
       localPort;
       ideType = "unknown";
@@ -47341,6 +47787,11 @@ ${err?.stack || ""}`);
           }
           const sessionHostEndpoint = await ensureSessionHostReady2();
           this.sessionHostEndpoint = sessionHostEndpoint;
+          this.sessionHostController = new SessionHostController(
+            sessionHostEndpoint,
+            (event) => this.broadcastLocalIpcMessage("daemon:session_host_event", event)
+          );
+          await this.sessionHostController.start();
           this.components = await initDaemonComponents({
             providerLogFn: LOG.forComponent("Provider").asLogFn(),
             cliManagerDeps: {
@@ -47378,6 +47829,7 @@ ${err?.stack || ""}`);
               setTimeout(() => this.statusReporter?.throttledReport(), 1e3);
               setTimeout(() => this.statusReporter?.throttledReport(), 3e3);
             },
+            sessionHostControl: this.sessionHostController,
             getCdpLogFn: (ideType) => LOG.forComponent(`CDP:${ideType}`).asLogFn(),
             onCdpManagerSetup: (ideType) => {
               if (this.ideType === "unknown") this.ideType = ideType;
@@ -47734,13 +48186,24 @@ ${err?.stack || ""}`);
               serverConnected: this.serverConn?.isConnected() ?? false,
               cdpConnected: (this.components?.cdpManagers.size || 0) > 0,
               localPort: this.localPort,
-              cliAgents
+              cliAgents,
+              sessionHostConnected: !!this.sessionHostController
             }
           }));
         } catch (error48) {
           LOG.warn("IPC", `Failed to send welcome: ${error48?.message || error48}`);
         }
       }
+      broadcastLocalIpcMessage(type, payload) {
+        const message = JSON.stringify({ type, payload });
+        for (const client of this.localClients) {
+          if (client.readyState !== import_ws3.WebSocket.OPEN) continue;
+          try {
+            client.send(message);
+          } catch {
+          }
+        }
+      }
       async handleLocalIpcMessage(ws, raw) {
         let msg;
         try {
@@ -47831,6 +48294,11 @@ ${err?.stack || ""}`);
           this.serverConn?.disconnect();
         } catch {
         }
+        try {
+          await this.sessionHostController?.stop();
+          this.sessionHostController = null;
+        } catch {
+        }
         try {
           for (const client of this.localClients) {
             client.close();