@adhdev/daemon-core 0.8.24 → 0.8.27

package/dist/agent-stream/provider-adapter.d.ts

@@ -16,6 +16,7 @@ export declare class ProviderStreamAdapter implements IAgentStreamAdapter {
     constructor(provider: ProviderModule);
     private callScript;
     private hasScript;
+    private parseMaybeJson;
     private summarizeRaw;
     private isTransportError;
     readChat(evaluate: AgentEvaluateFn): Promise<AgentStreamState>;

package/dist/boot/daemon-lifecycle.d.ts

@@ -10,6 +10,7 @@ import { DaemonCdpManager } from '../cdp/manager.js';
 import { DaemonCdpInitializer } from '../cdp/initializer.js';
 import { DaemonCommandHandler } from '../commands/handler.js';
 import { DaemonCommandRouter } from '../commands/router.js';
+import type { SessionHostControlPlane } from '../commands/router.js';
 import { DaemonCliManager, type CliTransportFactoryParams, type HostedCliRuntimeDescriptor } from '../commands/cli-manager.js';
 import { DaemonAgentStreamManager } from '../agent-stream/manager.js';
 import { AgentStreamPoller } from '../agent-stream/poller.js';
@@ -35,6 +36,7 @@ export interface DaemonInitConfig {
     /** Router transport-specific callbacks */
     onStatusChange?: () => void;
     onPostChatCommand?: () => void;
+    sessionHostControl?: SessionHostControlPlane | null;
     getCdpLogFn?: (ideType: string) => (msg: string) => void;
     /** Additional callback after CDP manager created (transport-specific extras) */
     onCdpManagerSetup?: (ideType: string, manager: DaemonCdpManager, managerKey: string) => void | Promise<void>;

package/dist/cli-adapters/pty-transport.d.ts

@@ -20,6 +20,9 @@ export interface PtyRuntimeMetadata {
     workspaceLabel?: string;
     writeOwner?: PtyRuntimeWriteOwner | null;
     attachedClients?: PtyRuntimeClientInfo[];
+    restoredFromStorage?: boolean;
+    recoveryState?: string | null;
+    recoveryError?: string | null;
 }
 export interface PtyRuntimeTransport {
     readonly pid: number;

package/dist/commands/router.d.ts

@@ -14,6 +14,28 @@ import { DaemonCliManager } from './cli-manager.js';
 import type { ProviderLoader } from '../providers/provider-loader.js';
 import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
 import { SessionRegistry } from '../sessions/registry.js';
+export interface SessionHostControlPlane {
+    getDiagnostics(payload?: {
+        includeSessions?: boolean;
+        limit?: number;
+    }): Promise<any>;
+    listSessions(): Promise<any[]>;
+    stopSession(sessionId: string): Promise<any>;
+    resumeSession(sessionId: string): Promise<any>;
+    restartSession(sessionId: string): Promise<any>;
+    sendSignal(sessionId: string, signal: string): Promise<any>;
+    forceDetachClient(sessionId: string, clientId: string): Promise<any>;
+    acquireWrite(payload: {
+        sessionId: string;
+        clientId: string;
+        ownerType: 'agent' | 'user';
+        force?: boolean;
+    }): Promise<any>;
+    releaseWrite(payload: {
+        sessionId: string;
+        clientId: string;
+    }): Promise<any>;
+}
 export interface CommandRouterDeps {
     commandHandler: DaemonCommandHandler;
     cliManager: DaemonCliManager;
@@ -37,6 +59,8 @@ export interface CommandRouterDeps {
     getCdpLogFn?: (ideType: string) => (msg: string) => void;
     /** Package name for upgrade detection ('adhdev' or '@adhdev/daemon-standalone') */
     packageName?: string;
+    /** Session host control plane */
+    sessionHostControl?: SessionHostControlPlane | null;
 }
 export interface CommandRouterResult {
     success: boolean;

package/dist/index.js

@@ -5201,6 +5201,7 @@ var ExtensionProviderInstance = class {
   currentStatus = "idle";
   agentStreams = [];
   messages = [];
+  prevMessageHashes = /* @__PURE__ */ new Map();
   activeModal = null;
   currentModel = "";
   currentMode = "";
@@ -5266,7 +5267,7 @@ var ExtensionProviderInstance = class {
   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;
@@ -5292,6 +5293,7 @@ var ExtensionProviderInstance = class {
   dispose() {
     this.agentStreams = [];
     this.messages = [];
+    this.prevMessageHashes.clear();
     this.monitor.reset();
     this.appliedEffectKeys.clear();
     this.runtimeMessages = [];
@@ -5447,6 +5449,23 @@ var ExtensionProviderInstance = class {
       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 hash = `${msg.role}:${(msg.content || "").slice(0, 100)}`;
+      const prevTime = this.prevMessageHashes.get(hash);
+      msg.receivedAt = prevTime || now;
+      nextHashes.set(hash, 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) => {
@@ -5503,6 +5522,7 @@ ${effect.notification.body || ""}`.trim();
     }
     this.agentStreams = [];
     this.messages = [];
+    this.prevMessageHashes.clear();
     this.activeModal = null;
     this.currentModel = "";
     this.currentMode = "";
@@ -6488,16 +6508,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) {
@@ -6809,6 +6841,51 @@ function buildSessionEntries(allStates, cdpManagers) {
   return sessions;
 }
 
+// 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
+      });
+    }
+  }
+}
+
 // src/commands/handler.ts
 init_logger();
 
@@ -7075,7 +7152,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)) {
@@ -7106,7 +7183,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);
@@ -8508,9 +8585,26 @@ var DaemonCommandHandler = class {
     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;
@@ -8566,17 +8660,27 @@ var DaemonCommandHandler = class {
     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);
@@ -8623,6 +8727,33 @@ var DaemonCommandHandler = class {
     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"];
@@ -8934,6 +9065,7 @@ var CliProviderInstance = class {
       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) {
@@ -9028,6 +9160,7 @@ var CliProviderInstance = class {
       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) {
@@ -9354,6 +9487,28 @@ ${effect.notification.body || ""}`.trim();
     const pad = (value) => String(value).padStart(2, "0");
     return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.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;
@@ -12642,17 +12797,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) {
@@ -12669,7 +12824,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) {
@@ -12954,6 +13109,25 @@ var CHAT_COMMANDS = [
   "change_model"
 ];
 var READ_DEBUG_ENABLED2 = process.argv.includes("--dev") || process.env.ADHDEV_READ_DEBUG === "1";
+function toHostedCliRuntimeDescriptor(record) {
+  if (!record || typeof record !== "object") return null;
+  const runtimeId = typeof record.sessionId === "string" ? record.sessionId : "";
+  const cliType = typeof record.providerType === "string" ? record.providerType : "";
+  const workspace = typeof record.workspace === "string" ? record.workspace : "";
+  if (!runtimeId || !cliType || !workspace) return null;
+  return {
+    runtimeId,
+    runtimeKey: typeof record.runtimeKey === "string" ? record.runtimeKey : void 0,
+    displayName: typeof record.displayName === "string" ? record.displayName : void 0,
+    workspaceLabel: typeof record.workspaceLabel === "string" ? record.workspaceLabel : void 0,
+    lifecycle: typeof record.lifecycle === "string" ? record.lifecycle : void 0,
+    recoveryState: typeof record.meta?.runtimeRecoveryState === "string" ? String(record.meta.runtimeRecoveryState) : null,
+    cliType,
+    workspace,
+    cliArgs: Array.isArray(record.meta?.cliArgs) ? record.meta.cliArgs : [],
+    providerSessionId: typeof record.meta?.providerSessionId === "string" ? String(record.meta.providerSessionId) : void 0
+  };
+}
 var DaemonCommandRouter = class {
   deps;
   constructor(deps) {
@@ -13027,6 +13201,90 @@ var DaemonCommandRouter = class {
           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 record = await this.deps.sessionHostControl.stopSession(sessionId);
+        return { success: true, record };
+      }
+      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 record = await this.deps.sessionHostControl.resumeSession(sessionId);
+        const hosted = toHostedCliRuntimeDescriptor(record);
+        if (hosted) {
+          await this.deps.cliManager.restoreHostedSessions([hosted]);
+        }
+        return { success: true, record };
+      }
+      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 record = await this.deps.sessionHostControl.restartSession(sessionId);
+        const hosted = toHostedCliRuntimeDescriptor(record);
+        if (hosted) {
+          await this.deps.cliManager.restoreHostedSessions([hosted]);
+        }
+        return { success: true, record };
+      }
+      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 record = await this.deps.sessionHostControl.sendSignal(sessionId, signal);
+        return { success: true, record };
+      }
+      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 record = await this.deps.sessionHostControl.forceDetachClient(sessionId, clientId);
+        return { success: true, record };
+      }
+      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 record = await this.deps.sessionHostControl.acquireWrite({
+          sessionId,
+          clientId,
+          ownerType,
+          force: args?.force !== false
+        });
+        return { success: true, record };
+      }
+      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 record = await this.deps.sessionHostControl.releaseWrite({ sessionId, clientId });
+        return { success: true, record };
+      }
       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";
@@ -13555,6 +13813,14 @@ var ProviderStreamAdapter = class {
   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);
@@ -13615,12 +13881,30 @@ var ProviderStreamAdapter = class {
     }
   }
   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 });
@@ -14005,6 +14289,7 @@ var AgentStreamPoller = class {
       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}`);
@@ -19870,6 +20155,7 @@ var SessionHostRuntimeTransport = class {
     }
   }
   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;
@@ -19945,7 +20231,10 @@ var SessionHostRuntimeTransport = class {
         clientId: client.clientId,
         type: client.type,
         readOnly: client.readOnly
-      }))
+      })),
+      restoredFromStorage: record.meta?.restoredFromStorage === true,
+      recoveryState: typeof record.meta?.runtimeRecoveryState === "string" ? String(record.meta.runtimeRecoveryState) : null,
+      recoveryError: typeof record.meta?.runtimeRecoveryError === "string" ? String(record.meta.runtimeRecoveryError) : null
     };
   }
   enqueue(action) {
@@ -20389,6 +20678,7 @@ async function initDaemonComponents(config) {
     onIdeConnected: () => poller?.start(),
     onStatusChange: config.onStatusChange,
     onPostChatCommand: config.onPostChatCommand,
+    sessionHostControl: config.sessionHostControl,
     getCdpLogFn: config.getCdpLogFn || ((ideType) => LOG.forComponent(`CDP:${ideType}`).asLogFn())
   });
   poller = new AgentStreamPoller({