@adhdev/daemon-core 0.8.69 → 0.8.70

package/dist/providers/contracts.d.ts

@@ -199,6 +199,16 @@ export interface SwitchSessionResult {
     clickY?: number;
     error?: string;
 }
+export interface FocusEditorResult {
+    focused: boolean;
+    error?: string;
+}
+export interface OpenPanelResult {
+    opened: boolean;
+    visible: boolean;
+    focused?: boolean;
+    error?: string;
+}
 /**
  * Method 1: Script-Click — script calls el.click() directly
  * Cursor Suitable for IDEs using div.cursor-pointer elements.

package/dist/providers/extension-provider-instance.d.ts

@@ -29,6 +29,7 @@ export declare class ExtensionProviderInstance implements ProviderInstance {
     private instanceId;
     private ideType;
     private chatId;
+    private providerSessionId;
     private chatTitle;
     private agentName;
     private extensionId;

package/dist/providers/open-panel-support.d.ts

@@ -0,0 +1,6 @@
+import type { ProviderModule } from './contracts.js';
+import type { SessionCapability } from '../shared-types.js';
+export declare const IDE_PROVIDER_SESSION_CAPABILITIES_BASE: SessionCapability[];
+export declare const EXTENSION_PROVIDER_SESSION_CAPABILITIES_BASE: SessionCapability[];
+export declare function providerHasOpenPanelSupport(provider: Pick<ProviderModule, 'category' | 'scripts'>): boolean;
+export declare function getProviderSessionCapabilities(provider: Pick<ProviderModule, 'category' | 'scripts'>, baseCapabilities: SessionCapability[]): SessionCapability[];

package/dist/providers/provider-instance.d.ts

@@ -8,7 +8,7 @@
  * Each Instance manages its own status.
  */
 import type { ProviderResumeCapability } from './contracts.js';
-import type { AcpConfigOption, AcpMode, ProviderControlSchema, ProviderSummaryMetadata } from '../shared-types.js';
+import type { AcpConfigOption, AcpMode, ProviderControlSchema, ProviderSummaryMetadata, SessionCapability } from '../shared-types.js';
 import type { ChatMessage } from '../types.js';
 export type ProviderStatus = 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting';
 export interface ProviderRuntimeWriteOwner {
@@ -66,6 +66,7 @@ interface ProviderStateBase {
     pendingEvents: ProviderEvent[];
     runtime?: ProviderRuntimeInfo;
     resume?: ProviderResumeCapability;
+    sessionCapabilities?: SessionCapability[];
     /** Dynamic control current values */
     controlValues?: Record<string, string | number | boolean>;
     /** Provider-declared controls schema (from provider.controls) */

package/dist/shared-types.d.ts

@@ -225,7 +225,7 @@ export type UnsubscribeRequest = {
 export type StandaloneWsStatusPayload = StatusReportPayload;
 export type SessionTransport = 'cdp-page' | 'cdp-webview' | 'pty' | 'acp';
 export type SessionKind = 'workspace' | 'agent';
-export type SessionCapability = 'read_chat' | 'send_message' | 'new_session' | 'list_sessions' | 'switch_session' | 'resolve_action' | 'terminal_io' | 'resize_terminal' | 'change_model' | 'set_mode' | 'set_thought_level';
+export type SessionCapability = 'read_chat' | 'send_message' | 'new_session' | 'list_sessions' | 'switch_session' | 'resolve_action' | 'open_panel' | 'terminal_io' | 'resize_terminal' | 'change_model' | 'set_mode' | 'set_thought_level';
 import type { RuntimeWriteOwner, RuntimeAttachedClient, SessionStatus } from './shared-types-extra.js';
 export type { RuntimeWriteOwner, RuntimeAttachedClient, SessionStatus } from './shared-types-extra.js';
 export interface SessionEntry {

package/dist/types.d.ts

@@ -29,6 +29,7 @@ export interface ChatMessage {
     index?: number;
     timestamp?: number;
     receivedAt?: number;
+    _turnKey?: string;
     /** Tool calls associated with this message */
     toolCalls?: ToolCallInfo[];
     /** Optional: fiber metadata */

package/node_modules/@adhdev/session-host-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.8.69",
+  "version": "0.8.70",
   "description": "ADHDev local session host core \u2014 session registry, protocol, buffers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.8.69",
+  "version": "0.8.70",
   "description": "ADHDev daemon core \u2014 CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/agent-stream/forward.ts

@@ -34,6 +34,7 @@ export function forwardAgentStreamsToIdeInstance(
             summaryMetadata: stream.summaryMetadata || undefined,
             effects: stream.effects || undefined,
             sessionId: stream.sessionId || stream.instanceId || undefined,
+            providerSessionId: stream.providerSessionId || stream.sessionId || undefined,
             title: stream.title || stream.agentName || undefined,
             agentType: stream.agentType || undefined,
             agentName: stream.agentName || undefined,

package/src/agent-stream/manager.d.ts

@@ -52,7 +52,8 @@ export declare class DaemonAgentStreamManager {
     newSession(cdp: DaemonCdpManager, sessionId: string): Promise<boolean>;
     listSessionChats(cdp: DaemonCdpManager, sessionId: string): Promise<AgentChatListItem[]>;
     switchConversation(cdp: DaemonCdpManager, sessionId: string, conversationId: string): Promise<boolean>;
-    focusSession(cdp: DaemonCdpManager, sessionId: string): Promise<boolean>;
+    selectSession(cdp: DaemonCdpManager, sessionId: string): Promise<boolean>;
+    openSessionPanel(cdp: DaemonCdpManager, sessionId: string): Promise<boolean>;
     getConnectedSessions(parentSessionId?: string): string[];
     getManagedSession(sessionId: string): ManagedAgent | undefined;
     dispose(cdpManagers: Map<string, DaemonCdpManager>): Promise<void>;

package/src/agent-stream/manager.ts

@@ -322,20 +322,35 @@ export class DaemonAgentStreamManager {
         }
     }
 
-    async focusSession(cdp: DaemonCdpManager, sessionId: string): Promise<boolean> {
+    async selectSession(cdp: DaemonCdpManager, sessionId: string): Promise<boolean> {
         const target = this.getSessionTarget(sessionId);
         if (!target?.parentSessionId) return false;
         await this.setActiveSession(cdp, target.parentSessionId, sessionId);
         await this.syncActiveSession(cdp, target.parentSessionId);
+        return this.managedBySessionId.has(sessionId);
+    }
+
+    async openSessionPanel(cdp: DaemonCdpManager, sessionId: string): Promise<boolean> {
+        const selected = await this.selectSession(cdp, sessionId);
+        if (!selected) return false;
         const agent = this.managedBySessionId.get(sessionId);
-        if (!agent || typeof agent.adapter.focusEditor !== 'function') return false;
+        if (!agent) return false;
+        let panelVisible = false;
+        let editorFocused = false;
         try {
             const evaluate: AgentEvaluateFn = (expr, timeout) =>
                 cdp.evaluateInSessionFrame(agent.cdpSessionId, expr, timeout);
-            await agent.adapter.focusEditor(evaluate);
-            return true;
+            if (typeof agent.adapter.openPanel === 'function') {
+                const result = await agent.adapter.openPanel(evaluate);
+                panelVisible = result.visible;
+            }
+            if (typeof agent.adapter.focusEditor === 'function') {
+                const result = await agent.adapter.focusEditor(evaluate);
+                editorFocused = result.focused;
+            }
+            return panelVisible || editorFocused;
         } catch (e) {
-            this.logFn(`[AgentStream] focusEditor(${sessionId}) error: ${(e as Error).message}`);
+            this.logFn(`[AgentStream] openPanel(${sessionId}) error: ${(e as Error).message}`);
             return false;
         }
     }

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

@@ -5,7 +5,7 @@
  * Auto-configured using provider.js scripts + metadata.
  */
 import type { IAgentStreamAdapter, AgentStreamState, AgentChatListItem, AgentEvaluateFn } from './types.js';
-import type { ProviderModule } from '../providers/contracts.js';
+import type { ProviderModule, FocusEditorResult, OpenPanelResult } from '../providers/contracts.js';
 export declare class ProviderStreamAdapter implements IAgentStreamAdapter {
     readonly agentType: string;
     readonly agentName: string;
@@ -31,6 +31,7 @@ export declare class ProviderStreamAdapter implements IAgentStreamAdapter {
     newSession(evaluate: AgentEvaluateFn): Promise<void>;
     listChats(evaluate: AgentEvaluateFn): Promise<AgentChatListItem[]>;
     switchSession(evaluate: AgentEvaluateFn, sessionId: string): Promise<boolean>;
-    focusEditor(evaluate: AgentEvaluateFn): Promise<void>;
+    focusEditor(evaluate: AgentEvaluateFn): Promise<FocusEditorResult>;
+    openPanel(evaluate: AgentEvaluateFn): Promise<OpenPanelResult>;
     private errorState;
 }

package/src/agent-stream/provider-adapter.ts

@@ -11,7 +11,7 @@ import type {
     AgentChatListItem,
     AgentEvaluateFn,
 } from './types.js';
-import type { ProviderModule, ProviderScripts } from '../providers/contracts.js';
+import type { ProviderModule, ProviderScripts, FocusEditorResult, OpenPanelResult } from '../providers/contracts.js';
 import { extractProviderControlValues, normalizeProviderEffects } from '../providers/control-effects.js';
 import { validateReadChatResultPayload } from '../providers/read-chat-contract.js';
 import { resolveProviderStateSurface } from '../providers/provider-patch-state.js';
@@ -57,6 +57,110 @@ export class ProviderStreamAdapter implements IAgentStreamAdapter {
         }
     }
 
+    private getOptionalError(raw: unknown): string | undefined {
+        return typeof raw === 'string' && raw.trim() ? raw.trim() : undefined;
+    }
+
+    private normalizeFocusEditorResult(raw: unknown): FocusEditorResult {
+        const data = this.parseMaybeJson(raw);
+        if (data === true) return { focused: true };
+        if (data === false || data == null) return { focused: false };
+        if (typeof data === 'string') {
+            const trimmed = data.trim();
+            const normalized = trimmed.toLowerCase();
+            if (
+                normalized === 'true'
+                || normalized === 'ok'
+                || normalized === 'success'
+                || normalized === 'focused'
+                || normalized === 'visible'
+            ) {
+                return { focused: true };
+            }
+            if (
+                normalized === 'false'
+                || normalized === 'not_found'
+                || normalized === 'not found'
+                || normalized === 'missing'
+                || normalized === 'panel_hidden'
+                || normalized === 'hidden'
+            ) {
+                return { focused: false };
+            }
+            return { focused: false, ...(trimmed ? { error: trimmed } : {}) };
+        }
+        if (data && typeof data === 'object') {
+            const error = this.getOptionalError(data.error);
+            if (data.focused === true || data.success === true || data.ok === true || data.visible === true) {
+                return { focused: true };
+            }
+            if (data.focused === false || data.success === false || data.ok === false || error) {
+                return { focused: false, ...(error ? { error } : {}) };
+            }
+        }
+        return { focused: false };
+    }
+
+    private normalizeOpenPanelResult(raw: unknown): OpenPanelResult {
+        const data = this.parseMaybeJson(raw);
+        if (data === true) return { opened: true, visible: true };
+        if (data === false || data == null) return { opened: false, visible: false };
+        if (typeof data === 'string') {
+            const trimmed = data.trim();
+            const normalized = trimmed.toLowerCase();
+            if (
+                normalized === 'true'
+                || normalized === 'ok'
+                || normalized === 'opened'
+                || normalized === 'open'
+                || normalized === 'success'
+            ) {
+                return { opened: true, visible: true };
+            }
+            if (normalized === 'visible') {
+                return { opened: false, visible: true };
+            }
+            if (normalized === 'focused') {
+                return { opened: false, visible: true, focused: true };
+            }
+            if (
+                normalized === 'false'
+                || normalized === 'panel_hidden'
+                || normalized === 'hidden'
+                || normalized === 'not_found'
+                || normalized === 'not found'
+                || normalized === 'missing'
+            ) {
+                return { opened: false, visible: false };
+            }
+            return { opened: false, visible: false, ...(trimmed ? { error: trimmed } : {}) };
+        }
+        if (data && typeof data === 'object') {
+            const error = this.getOptionalError(data.error);
+            const focused = data.focused === true;
+            const visible = data.visible === true
+                || data.opened === true
+                || focused
+                || data.success === true
+                || data.ok === true;
+            if (visible) {
+                return {
+                    opened: data.opened === true,
+                    visible: true,
+                    ...(focused ? { focused: true } : {}),
+                };
+            }
+            if (data.opened === false || data.visible === false || data.success === false || data.ok === false || error) {
+                return {
+                    opened: false,
+                    visible: false,
+                    ...(error ? { error } : {}),
+                };
+            }
+        }
+        return { opened: false, visible: false };
+    }
+
     private summarizeRaw(raw: unknown): string {
         try {
             if (typeof raw === 'string') return raw.replace(/\s+/g, ' ').trim().slice(0, 240);
@@ -167,6 +271,13 @@ export class ProviderStreamAdapter implements IAgentStreamAdapter {
             if (typeof validated.title === 'string' && validated.title.trim()) {
                 state.title = validated.title.trim();
             }
+            const providerSessionId = typeof validated.providerSessionId === 'string' && validated.providerSessionId.trim()
+                ? validated.providerSessionId.trim()
+                : '';
+            if (providerSessionId) {
+                state.sessionId = providerSessionId;
+                state.providerSessionId = providerSessionId;
+            }
             const controlValues = extractProviderControlValues(this.provider.controls, validated);
             const surface = resolveProviderStateSurface({
                 controlValues,
@@ -303,10 +414,18 @@ export class ProviderStreamAdapter implements IAgentStreamAdapter {
         return false;
     }
 
-    async focusEditor(evaluate: AgentEvaluateFn): Promise<void> {
+    async focusEditor(evaluate: AgentEvaluateFn): Promise<FocusEditorResult> {
         const script = this.callScript('focusEditor');
-        if (!script) return;
-        await evaluate(script);
+        if (!script) return { focused: false };
+        const raw = await evaluate(script);
+        return this.normalizeFocusEditorResult(raw);
+    }
+
+    async openPanel(evaluate: AgentEvaluateFn): Promise<OpenPanelResult> {
+        const script = this.callScript('openPanel');
+        if (!script) return { opened: false, visible: false };
+        const raw = await evaluate(script);
+        return this.normalizeOpenPanelResult(raw);
     }
 
     private errorState(message: string): AgentStreamState {

package/src/agent-stream/types.d.ts

@@ -4,7 +4,7 @@
  * Agent stream types.
  * No vscode dependency — can be used as-is.
  */
-import type { ProviderEffect } from '../providers/contracts.js';
+import type { ProviderEffect, FocusEditorResult, OpenPanelResult } from '../providers/contracts.js';
 import type { ProviderSummaryMetadata } from '../shared-types.js';
 /** Agent chat message */
 export interface AgentChatMessage {
@@ -61,7 +61,8 @@ export interface IAgentStreamAdapter {
     newSession(evaluate: AgentEvaluateFn): Promise<void>;
     listChats?(evaluate: AgentEvaluateFn): Promise<AgentChatListItem[]>;
     switchSession?(evaluate: AgentEvaluateFn, sessionId: string): Promise<boolean>;
-    focusEditor?(evaluate: AgentEvaluateFn): Promise<void>;
+    focusEditor?(evaluate: AgentEvaluateFn): Promise<FocusEditorResult>;
+    openPanel?(evaluate: AgentEvaluateFn): Promise<OpenPanelResult>;
     setProvider?(provider: any): void;
 }
 export type AgentEvaluateFn = (expression: string, timeoutMs?: number) => Promise<unknown>;

package/src/agent-stream/types.ts

@@ -5,7 +5,7 @@
  * No vscode dependency — can be used as-is.
  */
 
-import type { ProviderEffect } from '../providers/contracts.js';
+import type { ProviderEffect, FocusEditorResult, OpenPanelResult } from '../providers/contracts.js';
 import type { ProviderSummaryMetadata } from '../shared-types.js';
 import type { ChatMessageKind } from '../providers/chat-message-normalization.js';
 
@@ -38,6 +38,8 @@ export interface AgentStreamState {
     agentType: string;
     agentName: string;
     extensionId: string;
+    sessionId?: string;
+    providerSessionId?: string;
     status: 'idle' | 'streaming' | 'waiting_approval' | 'error' | 'disconnected' | 'panel_hidden' | 'not_monitored';
     messages: AgentChatMessage[];
     inputContent: string;
@@ -74,7 +76,8 @@ export interface IAgentStreamAdapter {
     newSession(evaluate: AgentEvaluateFn): Promise<void>;
     listChats?(evaluate: AgentEvaluateFn): Promise<AgentChatListItem[]>;
     switchSession?(evaluate: AgentEvaluateFn, sessionId: string): Promise<boolean>;
-    focusEditor?(evaluate: AgentEvaluateFn): Promise<void>;
+    focusEditor?(evaluate: AgentEvaluateFn): Promise<FocusEditorResult>;
+    openPanel?(evaluate: AgentEvaluateFn): Promise<OpenPanelResult>;
     setProvider?(provider: any): void;
 }
 

package/src/cli-adapters/provider-cli-adapter.ts

@@ -1458,7 +1458,9 @@ export class ProviderCliAdapter implements CliAdapter {
             }
         }
         if (!this.ready) throw new Error(`${this.cliName} not ready (status: ${this.currentStatus})`);
-        if (this.isWaitingForResponse) return;
+        if (this.isWaitingForResponse) {
+            throw new Error(`${this.cliName} is still processing the previous prompt`);
+        }
         const blockingModal = this.activeModal || this.getStartupConfirmationModal(this.terminalScreen.getText() || '');
         if (blockingModal || this.currentStatus === 'waiting_approval') {
             throw new Error(`${this.cliName} is awaiting confirmation before it can accept a prompt`);

package/src/commands/cli-manager.ts

@@ -883,6 +883,18 @@ export class DaemonCliManager {
  // UUID session target based search priority
                 const found = this.findAdapter(cliType, { instanceKey: args?.targetSessionId, dir });
                 if (found) {
+ // If we got here via fuzzy match (no targetSessionId, no dir), check for ambiguity.
+ // If multiple sessions of the same type exist, refuse to stop without a targetSessionId.
+                    if (!args?.targetSessionId && !dir) {
+                        const matchCount = [...this.adapters.values()].filter((a) => a.cliType === cliType).length;
+                        if (matchCount > 1) {
+                            return {
+                                success: false,
+                                error: `Multiple ${cliType} sessions running — provide targetSessionId to stop a specific session`,
+                                code: 'AMBIGUOUS_SESSION',
+                            };
+                        }
+                    }
                     await this.stopSessionWithMode(found.key, mode);
                 } else {
                     console.log(colorize('yellow', `  ⚠ No adapter found for ${cliType}`));

package/src/commands/handler.ts

@@ -413,7 +413,8 @@ export class DaemonCommandHandler implements CommandHelpers {
             'change_model',
             'set_thought_level',
             'resolve_action',
-            'focus_session',
+            'select_session',
+            'open_panel',
             'pty_input',
             'pty_resize',
             'invoke_provider_script',
@@ -494,7 +495,8 @@ export class DaemonCommandHandler implements CommandHelpers {
             case 'refresh_scripts': return this.handleRefreshScripts(args);
 
             // ─── Stream commands (stream-commands.ts) ───────────
-            case 'focus_session': return Stream.handleFocusSession(this, args);
+            case 'select_session': return Stream.handleSelectSession(this, args);
+            case 'open_panel': return Stream.handleOpenPanel(this, args);
 
             // ─── PTY Raw I/O (stream-commands.ts) ─────────
             case 'pty_input': return Stream.handlePtyInput(this, args);

package/src/commands/router.ts

@@ -718,6 +718,7 @@ export class DaemonCommandRouter {
                     sessionId,
                     typeof args?.seenAt === 'number' ? args.seenAt : Date.now(),
                     completionMarker,
+                    targetSession?.providerSessionId,
                 );
                 if (READ_DEBUG_ENABLED) {
                     LOG.info('RecentRead', `mark_session_seen sessionId=${sessionId} seenAt=${String(args?.seenAt || '')} prevSeenAt=${String(prevSeenAt)} nextSeenAt=${String(next.sessionReads?.[sessionId] || 0)} marker=${completionMarker || '-'}`);

package/src/commands/stream-commands.d.ts

@@ -3,7 +3,8 @@
  *                   IDE Extension Settings, Extension Script Execution
  */
 import type { CommandResult, CommandHelpers } from './handler.js';
-export declare function handleFocusSession(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleSelectSession(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleOpenPanel(h: CommandHelpers, args: any): Promise<CommandResult>;
 export declare function handlePtyInput(h: CommandHelpers, args: any): CommandResult;
 export declare function handlePtyResize(h: CommandHelpers, args: any): CommandResult;
 export declare function handleGetProviderSettings(h: CommandHelpers, args: any): CommandResult;

package/src/commands/stream-commands.ts

@@ -28,14 +28,86 @@ function getCliPresentationMode(h: CommandHelpers, targetSessionId?: string): 't
     return mode === 'chat' || mode === 'terminal' ? mode : null;
 }
 
-export async function handleFocusSession(h: CommandHelpers, args: any): Promise<CommandResult> {
+function normalizeOpenPanelCommandResult(result: CommandResult): { opened: boolean; visible: boolean; focused: boolean } {
+    const payload = Object.prototype.hasOwnProperty.call(result, 'result') ? result.result : result;
+    if (payload === true) return { opened: true, visible: true, focused: false };
+    if (!payload) return { opened: false, visible: false, focused: false };
+    if (typeof payload === 'string') {
+        const normalized = payload.trim().toLowerCase();
+        if (normalized === 'visible') return { opened: false, visible: true, focused: false };
+        if (normalized === 'focused') return { opened: false, visible: true, focused: true };
+        if (normalized === 'opened' || normalized === 'open' || normalized === 'true' || normalized === 'ok' || normalized === 'success') {
+            return { opened: true, visible: true, focused: false };
+        }
+        return { opened: false, visible: false, focused: false };
+    }
+    if (typeof payload === 'object') {
+        const record = payload as Record<string, unknown>;
+        return {
+            opened: record.opened === true,
+            visible: record.visible === true || record.opened === true || record.focused === true,
+            focused: record.focused === true,
+        };
+    }
+    return { opened: false, visible: false, focused: false };
+}
+
+function normalizeFocusEditorCommandResult(result: CommandResult): { focused: boolean } {
+    const payload = Object.prototype.hasOwnProperty.call(result, 'result') ? result.result : result;
+    if (payload === true) return { focused: true };
+    if (!payload) return { focused: false };
+    if (typeof payload === 'string') {
+        const normalized = payload.trim().toLowerCase();
+        return { focused: normalized === 'focused' || normalized === 'visible' || normalized === 'true' || normalized === 'ok' || normalized === 'success' };
+    }
+    if (typeof payload === 'object') {
+        const record = payload as Record<string, unknown>;
+        return { focused: record.focused === true || record.visible === true || record.success === true || record.ok === true };
+    }
+    return { focused: false };
+}
+
+export async function handleSelectSession(h: CommandHelpers, args: any): Promise<CommandResult> {
     if (!h.agentStream || !h.getCdp()) return { success: false, error: 'AgentStream or CDP not available' };
     const sessionId = args?.targetSessionId || h.currentSession?.sessionId;
     if (!sessionId) return { success: false, error: 'targetSessionId required' };
-    const ok = await h.agentStream.focusSession(h.getCdp()!, sessionId);
+    const ok = await h.agentStream.selectSession(h.getCdp()!, sessionId);
     return { success: ok };
 }
 
+export async function handleOpenPanel(h: CommandHelpers, args: any): Promise<CommandResult> {
+    const cdp = h.getCdp();
+    if (!cdp) return { success: false, error: 'AgentStream or CDP not available' };
+    const sessionId = args?.targetSessionId || h.currentSession?.sessionId;
+    if (!sessionId) return { success: false, error: 'targetSessionId required' };
+
+    const currentTransport = h.currentSession?.transport;
+    const shouldUseAgentStream = !!h.agentStream
+        && currentTransport !== 'cdp-page'
+        && currentTransport !== 'pty'
+        && currentTransport !== 'acp';
+    if (shouldUseAgentStream) {
+        const ok = await h.agentStream.openSessionPanel(cdp, sessionId);
+        return { success: ok };
+    }
+
+    const openResult = await executeProviderScript(h, args, 'openPanel');
+    if (!openResult.success) return openResult;
+    const revealState = normalizeOpenPanelCommandResult(openResult);
+
+    let focusState = { focused: false };
+    const focusResult = await executeProviderScript(h, args, 'focusEditor');
+    if (focusResult.success) {
+        focusState = normalizeFocusEditorCommandResult(focusResult);
+    }
+
+    return {
+        ...openResult,
+        ...(focusState.focused ? { focused: true } : {}),
+        success: revealState.visible || focusState.focused,
+    };
+}
+
 // ─── PTY Raw I/O ──────────────────────────────────
 
 export function handlePtyInput(h: CommandHelpers, args: any): CommandResult {

package/src/config/recent-activity.ts

@@ -83,12 +83,20 @@ export function getRecentActivity(state: DaemonState, limit = 20): RecentActivit
         .slice(0, limit);
 }
 
-export function getSessionSeenAt(state: DaemonState, sessionId: string): number {
-    return state.sessionReads?.[sessionId] || 0;
+export function buildSessionReadStateKey(sessionId: string, providerSessionId?: string | null): string {
+    const normalizedProviderSessionId = typeof providerSessionId === 'string' ? providerSessionId.trim() : '';
+    if (normalizedProviderSessionId) return `provider:${normalizedProviderSessionId}`;
+    return sessionId;
 }
 
-export function getSessionSeenMarker(state: DaemonState, sessionId: string): string {
-    return state.sessionReadMarkers?.[sessionId] || '';
+export function getSessionSeenAt(state: DaemonState, sessionId: string, providerSessionId?: string | null): number {
+    const providerKey = buildSessionReadStateKey(sessionId, providerSessionId);
+    return state.sessionReads?.[providerKey] || state.sessionReads?.[sessionId] || 0;
+}
+
+export function getSessionSeenMarker(state: DaemonState, sessionId: string, providerSessionId?: string | null): string {
+    const providerKey = buildSessionReadStateKey(sessionId, providerSessionId);
+    return state.sessionReadMarkers?.[providerKey] || state.sessionReadMarkers?.[sessionId] || '';
 }
 
 export function markSessionSeen(
@@ -96,22 +104,24 @@ export function markSessionSeen(
     sessionId: string,
     seenAt = Date.now(),
     completionMarker?: string | null,
+    providerSessionId?: string | null,
 ): DaemonState {
     const prev = state.sessionReads || {};
-    const nextSeenAt = Math.max(prev[sessionId] || 0, seenAt);
     const prevMarkers = state.sessionReadMarkers || {};
     const nextMarker = typeof completionMarker === 'string' ? completionMarker : '';
+    const readKeys = Array.from(new Set([
+        sessionId,
+        buildSessionReadStateKey(sessionId, providerSessionId),
+    ].filter(Boolean)));
+    const nextSessionReads = { ...prev };
+    const nextSessionReadMarkers = { ...prevMarkers };
+    for (const key of readKeys) {
+        nextSessionReads[key] = Math.max(prev[key] || 0, seenAt);
+        if (nextMarker) nextSessionReadMarkers[key] = nextMarker;
+    }
     return {
         ...state,
-        sessionReads: {
-            ...prev,
-            [sessionId]: nextSeenAt,
-        },
-        sessionReadMarkers: nextMarker
-            ? {
-                ...prevMarkers,
-                [sessionId]: nextMarker,
-            }
-            : prevMarkers,
+        sessionReads: nextSessionReads,
+        sessionReadMarkers: nextMarker ? nextSessionReadMarkers : prevMarkers,
     };
 }

package/src/daemon/dev-auto-implement.ts

@@ -898,8 +898,8 @@ export function buildAutoImplPrompt(ctx: DevServerContext,
   lines.push('| setModel | `{ success: true/false }` |');
   lines.push('| listModes | `{ modes: [{ name, id }], current }` |');
   lines.push('| setMode | `{ success: true/false }` |');
-  lines.push('| focusEditor | `{ focused: true/false }` |');
-  lines.push('| openPanel | `{ opened: true/false }` |');
+  lines.push('| focusEditor | `{ focused: true/false, error? }` |');
+  lines.push('| openPanel | `{ opened: true/false, visible: true/false, focused?: true, error? }` |');
   lines.push('');
 
   // ── readChat.status lifecycle spec ──

package/src/daemon/dev-server.ts

@@ -1221,8 +1221,8 @@ export class DevServer implements DevServerContext {
     lines.push('| setModel | `{ success: true/false }` |');
     lines.push('| listModes | `{ modes: [{ name, id }], current }` |');
     lines.push('| setMode | `{ success: true/false }` |');
-    lines.push('| focusEditor | `{ focused: true/false }` |');
-    lines.push('| openPanel | `{ opened: true/false }` |');
+    lines.push('| focusEditor | `{ focused: true/false, error? }` |');
+    lines.push('| openPanel | `{ opened: true/false, visible: true/false, focused?: true, error? }` |');
     lines.push('');
 
     // ── readChat.status lifecycle spec ──