@adhdev/daemon-core 0.9.82-rc.13 → 0.9.82-rc.130

package/src/commands/chat-commands.ts

@@ -12,8 +12,9 @@ import type { CliAdapter } from '../cli-adapter-types.js';
 import { flattenContent, normalizeInputEnvelope, type InputEnvelope, type ProviderModule, type ProviderScripts } from '../providers/contracts.js';
 import { assertProviderSupportsDeclaredInput, assertTextOnlyInput } from '../providers/provider-input-support.js';
 import { validateReadChatResultPayload } from '../providers/read-chat-contract.js';
+import { pickApprovalButton } from '../providers/approval-utils.js';
 import type { ProviderInstance } from '../providers/provider-instance.js';
-import { readProviderChatHistory } from '../config/chat-history.js';
+import { isNativeSourceCanonicalHistory, readChatHistory, readProviderChatHistory } from '../config/chat-history.js';
 import { LOG, getRecentLogs } from '../logging/logger.js';
 import { getRecentDebugTrace, recordDebugTrace } from '../logging/debug-trace.js';
 import { buildChatMessageSignature, hashSignatureParts } from '../chat/chat-signatures.js';
@@ -24,6 +25,13 @@ import { filterUserFacingChatMessages, normalizeChatMessages } from '../provider
 const RECENT_SEND_WINDOW_MS = 1200;
 export const READ_CHAT_PROVIDER_EVAL_TIMEOUT_MS = 25_000;
 const HERMES_CLI_STARTING_SEND_SETTLE_MS = 2_000;
+const CLI_NATIVE_HISTORY_FRESH_MS = 5 * 60_000;
+// Fallback list for supportsCliNativeTranscript() when the ProviderModule is
+// unavailable (e.g. provider config not yet loaded). The authoritative check is
+// provider.canonicalHistory via isNativeSourceCanonicalHistory(). New providers
+// with native transcripts should set canonicalHistory in their provider.json
+// rather than adding entries here.
+const CLI_NATIVE_TRANSCRIPT_PROVIDERS = new Set(['codex-cli', 'claude-cli', 'hermes-cli', 'antigravity-cli']);
 const recentSendByTarget = new Map<string, number>();
 
 interface ApprovalSelectableInstance extends ProviderInstance {
@@ -32,6 +40,7 @@ interface ApprovalSelectableInstance extends ProviderInstance {
 
 interface RuntimeChatMessageMerger extends ProviderInstance {
     mergeRuntimeChatMessages?(messages: ChatMessage[]): ChatMessage[];
+    recordAcknowledgedUserInput?(input: InputEnvelope | string): void;
 }
 
 type LegacyStringScript = (params?: Record<string, unknown> | string) => string;
@@ -48,6 +57,16 @@ function getTargetedCliAdapter(h: CommandHelpers, args: any, providerType?: stri
     return h.getCliAdapter(args?.targetSessionId || providerType || h.currentSession?.providerType || h.currentManagerKey);
 }
 
+function getExplicitHistorySessionId(args: any): string | undefined {
+    const explicit = typeof args?.historySessionId === 'string' ? args.historySessionId.trim() : '';
+    if (explicit) return explicit;
+
+    const explicitProviderSessionId = typeof args?.providerSessionId === 'string' ? args.providerSessionId.trim() : '';
+    if (explicitProviderSessionId) return explicitProviderSessionId;
+
+    return undefined;
+}
+
 function getTargetInstance(h: CommandHelpers, args: any): ApprovalSelectableInstance | null {
     const targetSessionId = typeof args?.targetSessionId === 'string' ? args.targetSessionId.trim() : '';
     const sessionId = targetSessionId || h.currentSession?.sessionId || '';
@@ -139,19 +158,47 @@ async function waitOnceForFreshHermesCliStart(adapter: CliAdapter, log: (msg: st
 }
 
 function getHistorySessionId(h: CommandHelpers, args: any): string | undefined {
-    const explicit = typeof args?.historySessionId === 'string' ? args.historySessionId.trim() : '';
+    const explicit = getExplicitHistorySessionId(args);
     if (explicit) return explicit;
 
-    const explicitProviderSessionId = typeof args?.providerSessionId === 'string' ? args.providerSessionId.trim() : '';
-    if (explicitProviderSessionId) return explicitProviderSessionId;
-
     const targetSessionId = typeof args?.targetSessionId === 'string' ? args.targetSessionId.trim() : '';
     if (!targetSessionId) return undefined;
 
-    const instance = h.ctx.instanceManager?.getInstance(targetSessionId);
+    const session = h.ctx.sessionRegistry?.get(targetSessionId) as any;
+    const registeredProviderSessionId = typeof session?.providerSessionId === 'string' ? session.providerSessionId.trim() : '';
+    if (registeredProviderSessionId) return registeredProviderSessionId;
+
+    const instance = getTargetInstance(h, args);
     const state = instance?.getState?.();
     const providerSessionId = typeof state?.providerSessionId === 'string' ? state.providerSessionId.trim() : '';
-    return providerSessionId || targetSessionId;
+    if (providerSessionId) return providerSessionId;
+
+    const currentSession = h.currentSession as any;
+    if (currentSession?.sessionId === targetSessionId) {
+        const currentProviderSessionId = typeof currentSession.providerSessionId === 'string'
+            ? currentSession.providerSessionId.trim()
+            : '';
+        if (currentProviderSessionId) return currentProviderSessionId;
+    }
+
+    return targetSessionId;
+}
+
+function resolveCliNativeHistorySessionId(args: any, currentHistorySessionId: string | undefined, parsedProviderSessionId: string | undefined): string | undefined {
+    const explicit = getExplicitHistorySessionId(args);
+    if (explicit) return explicit;
+
+    const parsed = typeof parsedProviderSessionId === 'string' ? parsedProviderSessionId.trim() : '';
+    const current = typeof currentHistorySessionId === 'string' ? currentHistorySessionId.trim() : '';
+    const targetSessionId = typeof args?.targetSessionId === 'string' ? args.targetSessionId.trim() : '';
+
+    // getHistorySessionId falls back to the runtime session id when no native
+    // handle has been registered yet. For live CLI adapters the parser may
+    // already know the provider-native handle; prefer it over the runtime id so
+    // exact native reads do not miss the worker transcript and fall back to PTY
+    // or same-workspace history.
+    if (parsed && (!current || current === targetSessionId)) return parsed;
+    return current || parsed || undefined;
 }
 
 function getInteractionId(args: any): string | undefined {
@@ -221,6 +268,446 @@ function normalizeReadChatMessages(payload: Record<string, any>): ChatMessage[]
     return normalizeChatMessages(messages);
 }
 
+function getMessageNewestReceivedAt(messages: Array<{ receivedAt?: unknown; timestamp?: unknown }>): number {
+    let newest = 0;
+    for (const message of messages) {
+        const receivedAt = Number(message?.receivedAt ?? message?.timestamp ?? 0);
+        if (Number.isFinite(receivedAt) && receivedAt > newest) newest = receivedAt;
+    }
+    return newest;
+}
+
+function readHistorySessionIdFromMessages(messages: ChatMessage[]): string | undefined {
+    for (const message of messages as Array<ChatMessage & { historySessionId?: unknown }>) {
+        const historySessionId = typeof message?.historySessionId === 'string' ? message.historySessionId.trim() : '';
+        if (historySessionId) return historySessionId;
+    }
+    return undefined;
+}
+
+function shouldPreserveNativeIdentity(providerType: string, sessionId: string, message: ChatMessage): boolean {
+    const providerUnitKey = typeof message.providerUnitKey === 'string' ? message.providerUnitKey.trim() : '';
+    const turnKey = typeof message._turnKey === 'string' ? message._turnKey.trim() : '';
+    if (!providerUnitKey || !turnKey) return false;
+    if (providerType === 'hermes-cli' && sessionId) {
+        return providerUnitKey.startsWith(`${providerType}:native:${sessionId}:`)
+            && turnKey.startsWith(`${providerType}:native-turn:${sessionId}:`);
+    }
+    return true;
+}
+
+function normalizeNativeHistoryMessages(providerType: string, messages: ChatMessage[], nativeSessionId?: string): ChatMessage[] {
+    let turnIndex = 0;
+    return normalizeChatMessages(messages).map((message, index) => {
+        const role = typeof message.role === 'string' ? message.role.trim().toLowerCase() : '';
+        const kind = typeof message.kind === 'string' && message.kind.trim() ? message.kind.trim() : (role === 'system' ? 'system' : 'standard');
+        if ((role === 'user' || role === 'human') && index > 0) turnIndex += 1;
+        const historySessionId = typeof (message as any).historySessionId === 'string'
+            ? (message as any).historySessionId.trim()
+            : '';
+        const contentHash = hashSignatureParts([
+            providerType,
+            historySessionId,
+            String(message.receivedAt || message.timestamp || index),
+            role,
+            kind,
+            flattenContent(message.content),
+        ]).slice(0, 12);
+        const nativeIdentitySessionId = historySessionId || (typeof nativeSessionId === 'string' ? nativeSessionId.trim() : '');
+        const preserveNativeIdentity = shouldPreserveNativeIdentity(providerType, nativeIdentitySessionId, message);
+        const existingProviderUnitKey = typeof message.providerUnitKey === 'string' ? message.providerUnitKey.trim() : '';
+        const existingTurnKey = typeof message._turnKey === 'string' ? message._turnKey.trim() : '';
+        const providerUnitKey = preserveNativeIdentity
+            ? existingProviderUnitKey
+            : `${providerType}:native:${nativeIdentitySessionId || 'workspace'}:${index}:${role || 'message'}:${kind}:${contentHash}`;
+        const meta = message.meta && typeof message.meta === 'object' ? message.meta as Record<string, unknown> : undefined;
+        const isSystemSessionStart = role === 'system' || kind === 'system' || kind === 'session_start';
+        const isActivity = role === 'assistant' && (kind === 'tool' || kind === 'terminal' || kind === 'thought');
+        return {
+            ...message,
+            role: role === 'human' ? 'user' : (role || 'assistant'),
+            kind: isSystemSessionStart ? 'system' : kind,
+            providerUnitKey,
+            bubbleId: typeof message.bubbleId === 'string' && message.bubbleId.trim()
+                && preserveNativeIdentity
+                ? message.bubbleId.trim()
+                : `bubble:${providerUnitKey}`,
+            _turnKey: preserveNativeIdentity
+                ? existingTurnKey
+                : `${providerType}:native-turn:${nativeIdentitySessionId || 'workspace'}:${turnIndex}`,
+            bubbleState: message.bubbleState || 'final',
+            ...(isSystemSessionStart ? {
+                visibility: message.visibility || 'hidden',
+                transcriptVisibility: message.transcriptVisibility || 'hidden',
+                audience: message.audience || 'internal',
+                source: message.source || 'runtime_status',
+            } : isActivity ? {
+                source: message.source || (kind === 'terminal' ? 'terminal_command' : 'tool_call'),
+                meta: { ...meta, label: message.senderName || meta?.label || (kind === 'terminal' ? 'Terminal' : 'Tool') },
+            } : {
+                source: message.source || (role === 'assistant' ? 'assistant_text' : undefined),
+            }),
+        } as ChatMessage;
+    });
+}
+
+function buildCliMessageSourceProvenance(args: {
+    selected: 'native-history' | 'pty-parser';
+    provider: string;
+    nativeHandle?: string;
+    sessionWorkspace?: string;
+    intendedWorkspace?: string;
+    transcriptWorkspace?: string;
+    fallbackReason?: string;
+    nativeSource?: string;
+    sourcePath?: string;
+    sourceMtimeMs?: number;
+    nativeHistoryCoverage?: string;
+    partialReason?: string;
+    unavailableReason?: string;
+    nativeMessages?: ChatMessage[];
+    ptyMessages?: ChatMessage[];
+    returnedMessages?: ChatMessage[];
+    safeMapping?: boolean;
+    freshEnough?: boolean;
+    ptyStatusApprovalOnly?: boolean;
+}): Record<string, unknown> {
+    const sourceMtimeMs = Number(args.sourceMtimeMs || 0);
+    const sourceMtimeAgeMs = sourceMtimeMs > 0 ? Math.max(0, Date.now() - sourceMtimeMs) : undefined;
+    const nativeMessages = args.nativeMessages || [];
+    const ptyMessages = args.ptyMessages || [];
+    const returnedMessages = args.returnedMessages || [];
+    const identityStatus = args.selected === 'native-history'
+        ? 'safe'
+        : args.fallbackReason === 'native_history_not_safely_mapped'
+            ? 'ambiguous_session_identity'
+            : args.fallbackReason?.startsWith('native_history_unavailable')
+                ? 'transcript_unmapped'
+                : undefined;
+    return {
+        selected: args.selected,
+        provider: args.provider,
+        providerType: args.provider,
+        ...(identityStatus ? { identityStatus } : {}),
+        ...(args.nativeHandle ? { nativeHandle: args.nativeHandle } : {}),
+        ...(args.nativeHandle ? { nativeSessionId: args.nativeHandle } : {}),
+        ...(args.sessionWorkspace ? { sessionWorkspace: args.sessionWorkspace } : {}),
+        ...(args.intendedWorkspace ? { intendedWorkspace: args.intendedWorkspace } : {}),
+        ...(args.transcriptWorkspace ? { transcriptWorkspace: args.transcriptWorkspace } : {}),
+        ...(args.fallbackReason ? { fallbackReason: args.fallbackReason } : {}),
+        ...(args.nativeSource ? { nativeSource: args.nativeSource } : {}),
+        ...(args.sourcePath ? { sourcePath: args.sourcePath } : {}),
+        ...(args.nativeHistoryCoverage ? { nativeHistoryCoverage: args.nativeHistoryCoverage } : {}),
+        ...(args.partialReason ? { partialReason: args.partialReason } : {}),
+        ...(args.unavailableReason ? { unavailableReason: args.unavailableReason } : {}),
+        ptyStatusApprovalOnly: args.ptyStatusApprovalOnly === true,
+        staleness: {
+            sourceMtimeMs: sourceMtimeMs || undefined,
+            sourceMtimeAgeMs,
+            nativeNewestMessageAt: getMessageNewestReceivedAt(nativeMessages),
+            ptyNewestMessageAt: getMessageNewestReceivedAt(ptyMessages),
+            freshEnough: args.freshEnough === true,
+        },
+        coverage: {
+            nativeMessageCount: nativeMessages.length,
+            ptyMessageCount: ptyMessages.length,
+            returnedMessageCount: returnedMessages.length,
+            safeMapping: args.safeMapping === true,
+            // true when PTY message bodies are suppressed and must not be treated as
+            // chat content. PTY may still contribute status/approval/screen evidence.
+            ptyMessagesSuppressed: args.selected === 'native-history' || args.ptyStatusApprovalOnly === true,
+        },
+    };
+}
+
+function buildNativeHistoryFallbackReason(args: {
+    providerType: string;
+    provider?: ProviderModule;
+    nativeSource?: string;
+    nativeHistoryCoverage?: string;
+    unavailableReason?: string;
+    nativeMessageCount: number;
+    safeMapping: boolean;
+    freshEnough: boolean;
+}): string {
+    if (!supportsCliNativeTranscript(args.providerType, args.provider)) return 'provider_native_transcript_not_supported';
+    if (args.unavailableReason) return `native_history_unavailable:${args.unavailableReason}`;
+    if (args.nativeSource === 'native-unavailable') return 'native_history_unavailable';
+    if (args.nativeHistoryCoverage === 'partial') return 'native_history_partial';
+    if (args.nativeHistoryCoverage === 'unavailable') return 'native_history_unavailable';
+    if (args.nativeSource && args.nativeSource !== 'provider-native') return `native_history_source_${args.nativeSource}`;
+    if (args.nativeMessageCount <= 0) return 'native_history_empty';
+    if (!args.safeMapping) return 'native_history_not_safely_mapped';
+    if (!args.freshEnough) return 'native_history_stale';
+    return 'native_history_not_selected';
+}
+
+function isUnsafeNativeTranscriptFallback(reason?: string): boolean {
+    const value = String(reason || '').trim();
+    return value.startsWith('native_history_unavailable')
+        || value === 'native_history_not_safely_mapped'
+        || value === 'native_history_stale'
+        || value === 'native_history_partial';
+}
+
+function coerceUnsafeNativeFallbackStatus(status: string, activeModal: unknown): string {
+    if (status === 'waiting_approval' && activeModal) return status;
+    return 'idle';
+}
+
+function isRuntimeInputAckMessage(message: ChatMessage | undefined): boolean {
+    if (!message || typeof message !== 'object') return false;
+    const role = String((message as any).role || '').trim().toLowerCase();
+    if (role !== 'user' && role !== 'human') return false;
+    const meta = (message as any).meta;
+    return !!meta && typeof meta === 'object' && !Array.isArray(meta) && meta.runtimeInputAck === true;
+}
+
+function selectRuntimeInputAckMessages(messages: ChatMessage[]): ChatMessage[] {
+    return messages.filter((message) => isRuntimeInputAckMessage(message));
+}
+
+function readExactRuntimeMirrorMessages(args: {
+    providerType: string;
+    targetSessionId?: string;
+    currentSessionId?: string;
+    tailLimit: number;
+    historyBehavior?: ProviderModule['historyBehavior'];
+}): ChatMessage[] {
+    const targetSessionId = String(args.targetSessionId || '').trim();
+    const currentSessionId = String(args.currentSessionId || '').trim();
+    if (!targetSessionId || targetSessionId !== currentSessionId) return [];
+
+    const history = readChatHistory(
+        args.providerType,
+        0,
+        Math.max(args.tailLimit || 0, 200),
+        targetSessionId,
+        0,
+        args.historyBehavior,
+    );
+    return normalizeChatMessages((history.messages || []) as ChatMessage[])
+        .filter((message) => {
+            const historySessionId = String((message as any).historySessionId || '').trim();
+            const instanceId = String((message as any).instanceId || '').trim();
+            return historySessionId === targetSessionId || instanceId === targetSessionId;
+        });
+}
+
+function normalizeComparableWorkspace(value: unknown): string {
+    const text = typeof value === 'string' ? value.trim() : '';
+    if (!text) return '';
+    return path.resolve(text);
+}
+
+function isCurrentRuntimePtySafelyAttributed(args: {
+    adapter: CliAdapter;
+    helpers: CommandHelpers;
+    readChatArgs: any;
+    sessionWorkspace?: string;
+    intendedWorkspace?: string;
+    ptyMessages: ChatMessage[];
+}): boolean {
+    if (args.adapter.cliType !== 'codex-cli') return false;
+    if (!Array.isArray(args.ptyMessages) || args.ptyMessages.length === 0) return false;
+    const targetSessionId = typeof args.readChatArgs?.targetSessionId === 'string'
+        ? args.readChatArgs.targetSessionId.trim()
+        : '';
+    const currentSession = args.helpers.currentSession as any;
+    const currentSessionId = typeof currentSession?.sessionId === 'string'
+        ? currentSession.sessionId.trim()
+        : '';
+    if (!targetSessionId || !currentSessionId || targetSessionId !== currentSessionId) return false;
+
+    const runtimeMeta = typeof (args.adapter as any).getRuntimeMetadata === 'function'
+        ? (args.adapter as any).getRuntimeMetadata()
+        : null;
+    const runtimeId = typeof runtimeMeta?.runtimeId === 'string' ? runtimeMeta.runtimeId.trim() : '';
+    if (!runtimeId || runtimeId !== targetSessionId) return false;
+    const surfaceKind = typeof runtimeMeta?.surfaceKind === 'string' ? runtimeMeta.surfaceKind : '';
+    if (surfaceKind === 'inactive_record' || surfaceKind === 'recovery_snapshot') return false;
+
+    const sessionWorkspace = normalizeComparableWorkspace(args.sessionWorkspace);
+    const adapterWorkspace = normalizeComparableWorkspace(args.adapter.workingDir);
+    if (!sessionWorkspace || !adapterWorkspace || sessionWorkspace !== adapterWorkspace) return false;
+    const intendedWorkspace = normalizeComparableWorkspace(args.intendedWorkspace);
+    if (intendedWorkspace && intendedWorkspace !== sessionWorkspace) return false;
+
+    const registryEntry = args.helpers.ctx?.sessionRegistry?.get?.(targetSessionId) as any;
+    const registryInstanceKey = typeof registryEntry?.adapterKey === 'string' && registryEntry.adapterKey.trim()
+        ? registryEntry.adapterKey.trim()
+        : typeof registryEntry?.instanceKey === 'string' && registryEntry.instanceKey.trim()
+            ? registryEntry.instanceKey.trim()
+            : '';
+    if (registryInstanceKey) {
+        const targetInstance = args.helpers.ctx?.instanceManager?.getInstance?.(registryInstanceKey);
+        if (targetInstance) {
+            const instanceType = typeof (targetInstance as any).type === 'string' ? (targetInstance as any).type : '';
+            if (instanceType && instanceType !== args.adapter.cliType) return false;
+        }
+    }
+
+    return true;
+}
+
+function supportsCliNativeTranscript(providerType: string, provider?: ProviderModule): boolean {
+    if (CLI_NATIVE_TRANSCRIPT_PROVIDERS.has(providerType)) return true;
+    return provider?.category === 'cli' && isNativeSourceCanonicalHistory(provider?.canonicalHistory);
+}
+
+function getComparableVisibleText(message: ChatMessage | undefined): string {
+    if (!message) return '';
+    const role = String((message as any).role || '').trim().toLowerCase();
+    if (role !== 'user' && role !== 'assistant') return '';
+    const kind = String((message as any).kind || 'standard').trim().toLowerCase();
+    if (kind && kind !== 'standard') return '';
+    const content = flattenContent((message as any).content).replace(/\s+/g, ' ').trim();
+    return content;
+}
+
+function hasOverlappingVisibleConversationText(nativeMessages: ChatMessage[], ptyMessages: ChatMessage[]): boolean {
+    const nativeTexts = nativeMessages.map(getComparableVisibleText).filter(Boolean);
+    const ptyTexts = ptyMessages.map(getComparableVisibleText).filter(Boolean);
+    if (nativeTexts.length === 0 || ptyTexts.length === 0) return false;
+    for (const nativeText of nativeTexts) {
+        for (const ptyText of ptyTexts) {
+            if (nativeText === ptyText) return true;
+            const shorter = nativeText.length <= ptyText.length ? nativeText : ptyText;
+            const longer = nativeText.length <= ptyText.length ? ptyText : nativeText;
+            if (shorter.length >= 32 && longer.includes(shorter)) return true;
+        }
+    }
+    return false;
+}
+
+function hasSafeNativeHistoryMapping(args: {
+    historySessionId?: string;
+    providerSessionId?: string;
+    workspace?: string;
+    nativeMessages: ChatMessage[];
+    ptyMessages?: ChatMessage[];
+    requireWorkspaceContentOverlap?: boolean;
+}): boolean {
+    const isCoordinatorTranscript = args.nativeMessages.some((m: any) => {
+        const text = typeof m?.content === 'string' ? m.content : JSON.stringify(m?.content || '');
+        return text.includes('mesh_send_task') || text.includes('mesh_status') || text.includes('mesh_read_chat') || text.includes('mesh_launch_session');
+    });
+
+    const explicitSessionId = String(args.historySessionId || args.providerSessionId || '').trim();
+    if (explicitSessionId) {
+        const messageSessionIds = args.nativeMessages
+            .map((message: any) => typeof message?.historySessionId === 'string' ? message.historySessionId.trim() : '')
+            .filter(Boolean);
+        if (messageSessionIds.length > 0) {
+            return messageSessionIds.some((id) => id === explicitSessionId);
+        }
+
+        // Messages carry no historySessionId — cannot confirm they belong to the requested session.
+        // Only allow a coordinator transcript that is also confirmed by the PTY side; otherwise
+        // fail closed so a same-workspace session's history is never silently accepted.
+        if (isCoordinatorTranscript && args.ptyMessages && args.ptyMessages.length > 0) {
+            const ptyHasCoordinator = args.ptyMessages.some((m: any) => {
+                const text = typeof m?.content === 'string' ? m.content : JSON.stringify(m?.content || '');
+                return text.includes('mesh_send_task') || text.includes('mesh_status') || text.includes('mesh_read_chat');
+            });
+            return ptyHasCoordinator;
+        }
+
+        // No historySessionId in messages and no coordinator cross-check: fail closed.
+        // Workspace-only matching must not override an explicit session identity.
+        return false;
+    }
+    const workspace = String(args.workspace || '').trim();
+    if (!workspace) return false;
+    const workspaceMatches = args.nativeMessages.some((message: any) => String(message?.workspace || '').trim() === workspace);
+    if (!workspaceMatches) return false;
+
+    if (isCoordinatorTranscript && args.ptyMessages && args.ptyMessages.length > 0) {
+        const ptyHasCoordinator = args.ptyMessages.some((m: any) => {
+            const text = typeof m?.content === 'string' ? m.content : JSON.stringify(m?.content || '');
+            return text.includes('mesh_send_task') || text.includes('mesh_status') || text.includes('mesh_read_chat');
+        });
+        if (!ptyHasCoordinator) {
+            return false;
+        }
+    }
+
+    if (!args.requireWorkspaceContentOverlap) return true;
+    return hasOverlappingVisibleConversationText(args.nativeMessages, args.ptyMessages || []);
+}
+
+// Provenance boundary: workspace-only native history lookup is never safe
+// because multiple concurrent sessions sharing the same cwd would alias each
+// other. historySessionId (the provider-native session key) is required to
+// establish ownership. hasSafeNativeHistoryMapping() enforces the same
+// invariant after the read; both guards must hold for native history to be used.
+function readCliProviderNativeHistory(agentStr: string, args: {
+    canonicalHistory?: ProviderModule['canonicalHistory'];
+    historySessionId?: string;
+    workspace?: string;
+    offset: number;
+    limit: number;
+    excludeRecentCount: number;
+    historyBehavior?: ProviderModule['historyBehavior'];
+    scripts?: ProviderScripts;
+}): ReturnType<typeof readProviderChatHistory> & { lookup: 'session' | 'workspace' } {
+    if (!args.historySessionId) {
+        return {
+            messages: [],
+            hasMore: false,
+            source: 'native-unavailable',
+            unavailableReason: 'native_history_workspace_only_lookup_unsafe',
+            lookup: 'session',
+        } as ReturnType<typeof readProviderChatHistory> & { lookup: 'session' | 'workspace' };
+    }
+    const sessionHistory = readProviderChatHistory(agentStr, {
+        canonicalHistory: args.canonicalHistory,
+        historySessionId: args.historySessionId,
+        workspace: args.workspace,
+        offset: args.offset,
+        limit: args.limit,
+        excludeRecentCount: args.excludeRecentCount,
+        historyBehavior: args.historyBehavior,
+        scripts: args.scripts as any,
+    });
+    // Native transcripts are keyed by provider/runtime session identity. Falling
+    // back to workspace makes concurrent local Codex/Hermes sessions alias each
+    // other when they share the same cwd.
+    return { ...(sessionHistory as any), lookup: 'session' };
+}
+
+function isNativeHistoryFreshEnough(args: {
+    sourceMtimeMs?: number;
+    nativeMessages: ChatMessage[];
+    ptyMessages: ChatMessage[];
+}): boolean {
+    const nativeNewest = getMessageNewestReceivedAt(args.nativeMessages);
+    const ptyNewest = getMessageNewestReceivedAt(args.ptyMessages);
+    if (nativeNewest > 0 && nativeNewest >= ptyNewest) return true;
+    const sourceMtimeMs = Number(args.sourceMtimeMs || 0);
+    if (sourceMtimeMs > 0 && Date.now() - sourceMtimeMs <= CLI_NATIVE_HISTORY_FRESH_MS) return true;
+    return ptyNewest === 0 && nativeNewest > 0;
+}
+
+function shouldPreserveReadChatPayloadField(key: string): boolean {
+    return key === 'messageSource' || key === 'transcriptProvenance';
+}
+
+function updateMessageSourceReturnedCount(value: unknown, returnedMessageCount: number): unknown {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return value;
+    const record = value as Record<string, unknown>;
+    const coverage = record.coverage && typeof record.coverage === 'object' && !Array.isArray(record.coverage)
+        ? record.coverage as Record<string, unknown>
+        : undefined;
+    if (!coverage) return value;
+    return {
+        ...record,
+        coverage: {
+            ...coverage,
+            returnedMessageCount,
+        },
+    };
+}
 
 function deriveHistoryDedupKey(message: ChatMessage & { _unitKey?: string; _turnKey?: string }): string | undefined {
     const unitKey = typeof message._unitKey === 'string' ? message._unitKey.trim() : '';
@@ -281,7 +768,7 @@ function normalizeReadChatCommandStatus(status: unknown, activeModal: unknown):
     }
     switch (raw) {
         case 'starting':
-            return hasNonEmptyModalButtons(activeModal) ? 'waiting_approval' : 'generating';
+            return hasNonEmptyModalButtons(activeModal) ? 'waiting_approval' : 'starting';
         case 'stopped':
         case 'disconnected':
         case 'not_monitored':
@@ -295,6 +782,16 @@ function isGeneratingLikeStatus(status: unknown): boolean {
     return status === 'generating' || status === 'streaming' || status === 'long_generating' || status === 'starting';
 }
 
+function hasVisibleAssistantMessage(messages: unknown[] | undefined): boolean {
+    if (!Array.isArray(messages)) return false;
+    return messages.some((message: any) => {
+        if (!message || message.role !== 'assistant') return false;
+        const kind = typeof message.kind === 'string' ? message.kind : 'standard';
+        if (kind !== 'standard') return false;
+        return String(message.content || '').trim().length > 0;
+    });
+}
+
 function shouldTrustCliAdapterTerminalStatus(parsedStatus: unknown, activeModal: unknown, adapter: CliAdapter, adapterStatus: any): boolean {
     if (!isGeneratingLikeStatus(parsedStatus)) return false;
     if (hasNonEmptyModalButtons(activeModal)) return false;
@@ -304,7 +801,26 @@ function shouldTrustCliAdapterTerminalStatus(parsedStatus: unknown, activeModal:
     return true;
 }
 
-function normalizeCliReadChatStatus(parsedStatus: unknown, activeModal: unknown, adapter: CliAdapter, adapterStatus: any): string {
+function normalizeCliReadChatStatus(parsedStatus: unknown, activeModal: unknown, adapter: CliAdapter, adapterStatus: any, parsedMessages?: unknown[]): string {
+    const adapterRawStatus = typeof adapterStatus?.status === 'string' ? adapterStatus.status.trim() : '';
+    if (adapterRawStatus === 'starting'
+        && isGeneratingLikeStatus(parsedStatus)
+        && !hasNonEmptyModalButtons(activeModal)
+        && Array.isArray(parsedMessages)
+        && parsedMessages.length === 0
+        && Array.isArray(adapterStatus?.messages)
+        && adapterStatus.messages.length === 0
+        && !(typeof adapter.isProcessing === 'function' && adapter.isProcessing())) {
+        return 'starting';
+    }
+    if (
+        isGeneratingLikeStatus(adapterRawStatus)
+        && parsedStatus === 'idle'
+        && !hasNonEmptyModalButtons(activeModal)
+        && !hasVisibleAssistantMessage(parsedMessages)
+    ) {
+        return adapterRawStatus;
+    }
     if (shouldTrustCliAdapterTerminalStatus(parsedStatus, activeModal, adapter, adapterStatus)) return 'idle';
     return typeof parsedStatus === 'string' && parsedStatus.trim() ? parsedStatus : 'idle';
 }
@@ -342,6 +858,13 @@ function buildReadChatCommandResult(payload: Record<string, any>, args: any): Co
     const visibleMessages = filterUserFacingChatMessages(messages);
     const sync = buildFullTail(visibleMessages, normalizeReadChatTailLimit(args));
     const hiddenMsgCount = Math.max(0, messages.length - visibleMessages.length);
+    const preservedPayloadFields = Object.fromEntries(Object.entries(payload).filter(([key]) => shouldPreserveReadChatPayloadField(key)));
+    if (preservedPayloadFields.messageSource) {
+        preservedPayloadFields.messageSource = updateMessageSourceReturnedCount(preservedPayloadFields.messageSource, sync.messages.length);
+    }
+    if (preservedPayloadFields.transcriptProvenance) {
+        preservedPayloadFields.transcriptProvenance = updateMessageSourceReturnedCount(preservedPayloadFields.transcriptProvenance, sync.messages.length);
+    }
     const returnedDebugReadChat = debugReadChat
         ? {
             ...debugReadChat,
@@ -356,6 +879,7 @@ function buildReadChatCommandResult(payload: Record<string, any>, args: any): Co
     return {
         success: true,
         ...validatedPayload,
+        ...preservedPayloadFields,
         messages: sync.messages,
         totalMessages: sync.totalMessages,
         ...(returnedDebugReadChat ? { debugReadChat: returnedDebugReadChat } : {}),
@@ -584,6 +1108,8 @@ function buildChatDebugBundleSummary(bundle: Record<string, unknown>): Record<st
             adapterStatus: debugReadChat.adapterStatus,
             parsedStatus: debugReadChat.parsedStatus,
             returnedStatus: debugReadChat.returnedStatus,
+            selectedMessageSource: debugReadChat.selectedMessageSource,
+            messageSource: debugReadChat.messageSource,
             parsedMsgCount: debugReadChat.parsedMsgCount,
             returnedMsgCount: debugReadChat.returnedMsgCount,
             shouldPreferAdapterMessages: debugReadChat.shouldPreferAdapterMessages,
@@ -646,11 +1172,20 @@ export async function handleGetChatDebugBundle(h: CommandHelpers, args: any): Pr
                 providerSessionId: readResult.providerSessionId,
                 transcriptAuthority: readResult.transcriptAuthority,
                 coverage: readResult.coverage,
+                messageSource: readResult.messageSource,
+                transcriptProvenance: readResult.transcriptProvenance,
                 activeModal: readResult.activeModal,
                 messagesTail: Array.isArray(readResult.messages) ? readResult.messages.slice(-20) : [],
                 debugReadChat: readResult.debugReadChat,
             }
-            : { success: false, error: readResult.error };
+            : {
+                success: false,
+                error: readResult.error,
+                code: readResult.code,
+                messageSource: readResult.messageSource,
+                transcriptProvenance: readResult.transcriptProvenance,
+                debugReadChat: readResult.debugReadChat,
+            };
     } catch (error: any) {
         readChat = { success: false, error: error?.message || String(error) };
     }
@@ -817,16 +1352,56 @@ export async function handleChatHistory(h: CommandHelpers, args: any): Promise<C
             : typeof (h.currentSession as any)?.workspace === 'string'
                 ? (h.currentSession as any).workspace
                 : undefined;
-        const result = readProviderChatHistory(agentStr, {
-            canonicalHistory: provider?.canonicalHistory,
-            historySessionId,
-            workspace,
-            offset: offset || 0,
-            limit: limit || 30,
-            excludeRecentCount,
-            historyBehavior: provider?.historyBehavior,
-            scripts: provider?.scripts as any,
-        });
+        const exactNativeHistoryScope = Boolean(
+            (typeof args?.targetSessionId === 'string' && args.targetSessionId.trim())
+            || (typeof args?.historySessionId === 'string' && args.historySessionId.trim())
+            || (typeof args?.providerSessionId === 'string' && args.providerSessionId.trim())
+        );
+        const result = supportsCliNativeTranscript(agentStr, provider) && isNativeSourceCanonicalHistory(provider?.canonicalHistory)
+            ? readCliProviderNativeHistory(agentStr, {
+                canonicalHistory: provider?.canonicalHistory,
+                historySessionId,
+                workspace,
+                offset: offset || 0,
+                limit: limit || 30,
+                excludeRecentCount,
+                historyBehavior: provider?.historyBehavior,
+                scripts: provider?.scripts as any,
+            })
+            : readProviderChatHistory(agentStr, {
+                canonicalHistory: provider?.canonicalHistory,
+                historySessionId,
+                workspace,
+                offset: offset || 0,
+                limit: limit || 30,
+                excludeRecentCount,
+                historyBehavior: provider?.historyBehavior,
+                scripts: provider?.scripts as any,
+            });
+        if (supportsCliNativeTranscript(agentStr, provider) && isNativeSourceCanonicalHistory(provider?.canonicalHistory)) {
+            const lookup = (result as any).lookup === 'workspace' ? 'workspace' : 'session';
+            const messages = Array.isArray((result as any).messages)
+                ? normalizeNativeHistoryMessages(agentStr, (result as any).messages as ChatMessage[], (result as any)?.providerSessionId)
+                : [];
+            const historyProviderSessionId = typeof (result as any)?.providerSessionId === 'string'
+                ? (result as any).providerSessionId
+                : readHistorySessionIdFromMessages(messages) || historySessionId;
+            const safeMapping = hasSafeNativeHistoryMapping({
+                historySessionId: lookup === 'workspace' ? undefined : historySessionId,
+                providerSessionId: lookup === 'workspace' ? undefined : historyProviderSessionId,
+                workspace,
+                nativeMessages: messages,
+            });
+            if ((result as any).source === 'provider-native' && messages.length > 0 && !safeMapping) {
+                return {
+                    success: true,
+                    messages: [],
+                    hasMore: false,
+                    source: 'native-unavailable',
+                    agent: agentStr,
+                };
+            }
+        }
         return { success: true, ...result, agent: agentStr };
     } catch (e: any) {
         return { success: false, error: e.message };
@@ -874,7 +1449,7 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                 ? parsedRecord.coverage
                 : undefined;
             const activeModal = parsedRecord.activeModal ?? parsedRecord.modal ?? null;
-            const returnedStatus = normalizeCliReadChatStatus(parsedRecord.status, activeModal, adapter, adapterStatus);
+            const returnedStatus = normalizeCliReadChatStatus(parsedRecord.status, activeModal, adapter, adapterStatus, parsedRecord.messages);
             const runtimeMessageMerger = getTargetInstance(h, args) as RuntimeChatMessageMerger | null;
             const parsedMessages = finalizeStreamingMessagesWhenIdle(parsedRecord.messages as ChatMessage[], returnedStatus);
             const returnedMessages = runtimeMessageMerger?.category === 'cli'
@@ -882,36 +1457,287 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                 && typeof runtimeMessageMerger.mergeRuntimeChatMessages === 'function'
                 ? runtimeMessageMerger.mergeRuntimeChatMessages(parsedMessages)
                 : parsedMessages;
+            const providerType = provider?.type || adapter.cliType;
+            let selectedMessages = returnedMessages;
+            let selectedTitle = title;
+            let selectedProviderSessionId = providerSessionId;
+            let selectedTranscriptAuthority = transcriptAuthority;
+            let selectedCoverage = coverage;
+            let selectedStatus = returnedStatus;
+            const sessionWorkspace = typeof (h.currentSession as any)?.workspace === 'string'
+                ? (h.currentSession as any).workspace
+                : typeof adapter.workingDir === 'string'
+                    ? adapter.workingDir
+                    : undefined;
+            const intendedWorkspace = typeof args?.workspace === 'string' ? args.workspace : undefined;
+            let messageSource = buildCliMessageSourceProvenance({
+                selected: 'pty-parser',
+                provider: adapter.cliType,
+                fallbackReason: supportsCliNativeTranscript(providerType, provider) ? 'native_history_not_checked' : 'provider_native_transcript_not_supported',
+                sessionWorkspace,
+                intendedWorkspace,
+                ptyMessages: returnedMessages,
+                returnedMessages,
+                ptyStatusApprovalOnly: false,
+            });
+
+            if (supportsCliNativeTranscript(providerType, provider) && isNativeSourceCanonicalHistory(provider?.canonicalHistory)) {
+                const agentStr = provider?.type || args?.agentType || getCurrentProviderType(h, adapter.cliType);
+                const workspace = sessionWorkspace;
+                const nativeHistoryLimit = Math.max(
+                    normalizeReadChatTailLimit(args) || 0,
+                    returnedMessages.length,
+                    200,
+                );
+                const nativeHistorySessionId = resolveCliNativeHistorySessionId(args, historySessionId, providerSessionId);
+                const targetSessionId = typeof args?.targetSessionId === 'string' ? args.targetSessionId.trim() : '';
+                const exactNativeHistoryScope = Boolean(
+                    (typeof args?.historySessionId === 'string' && args.historySessionId.trim())
+                    || (typeof args?.providerSessionId === 'string' && args.providerSessionId.trim())
+                    || providerSessionId
+                    || (nativeHistorySessionId && nativeHistorySessionId !== targetSessionId)
+                    || ((h.currentSession as any)?.sessionId === args?.targetSessionId && typeof (h.currentSession as any)?.providerSessionId === 'string' && (h.currentSession as any).providerSessionId.trim())
+                );
+                let nativeHistory: (ReturnType<typeof readProviderChatHistory> & { lookup?: 'session' | 'workspace' }) | null = null;
+                try {
+                    nativeHistory = readCliProviderNativeHistory(agentStr, {
+                        canonicalHistory: provider?.canonicalHistory,
+                        historySessionId: nativeHistorySessionId,
+                        workspace,
+                        offset: 0,
+                        limit: nativeHistoryLimit,
+                        excludeRecentCount: 0,
+                        historyBehavior: provider?.historyBehavior,
+                        scripts: provider?.scripts as any,
+                    });
+                } catch (error: any) {
+                    const fallbackReason = `native_history_error:${error?.message || String(error)}`;
+                    messageSource = buildCliMessageSourceProvenance({
+                        selected: 'pty-parser',
+                        provider: adapter.cliType,
+                        fallbackReason,
+                        sessionWorkspace,
+                        intendedWorkspace,
+                        ptyMessages: returnedMessages,
+                        returnedMessages,
+                        ptyStatusApprovalOnly: false,
+                    });
+                    nativeHistory = null;
+                }
+
+                if (nativeHistory) {
+                    const nativeMessages = Array.isArray((nativeHistory as any).messages)
+                        ? normalizeNativeHistoryMessages(agentStr, (nativeHistory as any).messages as ChatMessage[], (nativeHistory as any)?.providerSessionId)
+                        : [];
+                    const historyProviderSessionId = typeof (nativeHistory as any)?.providerSessionId === 'string'
+                        ? (nativeHistory as any).providerSessionId
+                        : readHistorySessionIdFromMessages(nativeMessages) || nativeHistorySessionId || historySessionId;
+                    const nativeHistoryCoverage = typeof (nativeHistory as any)?.nativeHistoryCoverage === 'string'
+                        ? (nativeHistory as any).nativeHistoryCoverage
+                        : undefined;
+                    const partialReason = typeof (nativeHistory as any)?.partialReason === 'string'
+                        ? (nativeHistory as any).partialReason
+                        : undefined;
+                    const unavailableReason = typeof (nativeHistory as any)?.unavailableReason === 'string'
+                        ? (nativeHistory as any).unavailableReason
+                        : undefined;
+                    const lookup = (nativeHistory as any).lookup === 'workspace' ? 'workspace' : 'session';
+                    const transcriptWorkspace = typeof (nativeHistory as any)?.workspace === 'string'
+                        ? (nativeHistory as any).workspace
+                        : nativeMessages.map((message: any) => typeof message?.workspace === 'string' ? message.workspace.trim() : '').find(Boolean);
+                    const nativeHistorySessionForMapping = adapter.cliType === 'antigravity-cli'
+                        && historyProviderSessionId
+                        && nativeHistorySessionId
+                        && historyProviderSessionId !== nativeHistorySessionId
+                        ? undefined
+                        : nativeHistorySessionId;
+                    const safeMapping = hasSafeNativeHistoryMapping({
+                        historySessionId: lookup === 'workspace' ? undefined : nativeHistorySessionForMapping,
+                        providerSessionId: lookup === 'workspace' ? undefined : historyProviderSessionId || providerSessionId,
+                        workspace,
+                        nativeMessages,
+                        ptyMessages: returnedMessages,
+                        requireWorkspaceContentOverlap: lookup === 'workspace' && !exactNativeHistoryScope,
+                    });
+                    const freshEnough = isNativeHistoryFreshEnough({
+                        sourceMtimeMs: (nativeHistory as any).sourceMtimeMs,
+                        nativeMessages,
+                        ptyMessages: returnedMessages,
+                    });
+                    const nativeUsableForChatMessages = (nativeHistory as any).source === 'provider-native'
+                        && nativeMessages.length > 0
+                        && nativeHistoryCoverage !== 'partial'
+                        && nativeHistoryCoverage !== 'unavailable'
+                        && safeMapping;
+                    const allowStaleNativeChatMessages = adapter.cliType === 'antigravity-cli' && nativeUsableForChatMessages;
+                    if (nativeUsableForChatMessages && (freshEnough || allowStaleNativeChatMessages)) {
+                        selectedMessages = finalizeStreamingMessagesWhenIdle(nativeMessages, returnedStatus);
+                        selectedProviderSessionId = historyProviderSessionId || providerSessionId;
+                        selectedTranscriptAuthority = 'provider';
+                        selectedCoverage = (nativeHistory as any).hasMore ? 'tail' : 'full';
+                        messageSource = buildCliMessageSourceProvenance({
+                            selected: 'native-history',
+                            provider: adapter.cliType,
+                            nativeHandle: selectedProviderSessionId || nativeHistorySessionId || historySessionId,
+                            sessionWorkspace,
+                            intendedWorkspace,
+                            transcriptWorkspace,
+                            nativeSource: (nativeHistory as any).source,
+                            sourcePath: (nativeHistory as any).sourcePath,
+                            sourceMtimeMs: (nativeHistory as any).sourceMtimeMs,
+                            nativeHistoryCoverage,
+                            partialReason,
+                            unavailableReason,
+                            nativeMessages,
+                            ptyMessages: returnedMessages,
+                            returnedMessages: selectedMessages,
+                            safeMapping,
+                            freshEnough,
+                            ptyStatusApprovalOnly: true,
+                        });
+                    } else {
+                        const fallbackReason = buildNativeHistoryFallbackReason({
+                            providerType,
+                            provider,
+                        nativeSource: (nativeHistory as any).source,
+                        nativeHistoryCoverage,
+                        unavailableReason,
+                        nativeMessageCount: nativeMessages.length,
+                        safeMapping,
+                        freshEnough,
+                        });
+                        const unsafeNativeFallback = adapter.cliType === 'codex-cli'
+                            && isUnsafeNativeTranscriptFallback(fallbackReason);
+                        const safeCurrentRuntimePtyMessages = unsafeNativeFallback
+                            && isCurrentRuntimePtySafelyAttributed({
+                                adapter,
+                                helpers: h,
+                                readChatArgs: args,
+                                sessionWorkspace,
+                                intendedWorkspace,
+                                ptyMessages: returnedMessages,
+                            });
+                        const safeRuntimeAckMessages = unsafeNativeFallback
+                            && !safeCurrentRuntimePtyMessages
+                            ? selectRuntimeInputAckMessages(returnedMessages)
+                            : [];
+                        const exactRuntimeMirrorMessages = unsafeNativeFallback
+                            && !safeCurrentRuntimePtyMessages
+                            && safeRuntimeAckMessages.length === 0
+                            ? readExactRuntimeMirrorMessages({
+                                providerType,
+                                targetSessionId: typeof args?.targetSessionId === 'string' ? args.targetSessionId : undefined,
+                                currentSessionId: typeof (h.currentSession as any)?.sessionId === 'string' ? (h.currentSession as any).sessionId : undefined,
+                                tailLimit: nativeHistoryLimit,
+                                historyBehavior: provider?.historyBehavior,
+                            })
+                            : [];
+                        const safeDaemonMessages = safeRuntimeAckMessages.length > 0
+                            ? safeRuntimeAckMessages
+                            : exactRuntimeMirrorMessages;
+                        if (unsafeNativeFallback) {
+                            if (safeCurrentRuntimePtyMessages) {
+                                selectedMessages = returnedMessages;
+                                selectedTranscriptAuthority = 'daemon';
+                                selectedCoverage = coverage || 'current-turn';
+                                selectedStatus = returnedStatus;
+                            } else {
+                                selectedMessages = safeDaemonMessages;
+                                selectedTranscriptAuthority = safeDaemonMessages.length > 0 ? 'daemon' : undefined;
+                                selectedCoverage = safeDaemonMessages.length > 0 ? 'tail' : undefined;
+                                selectedStatus = coerceUnsafeNativeFallbackStatus(returnedStatus, activeModal);
+                            }
+                        }
+                        messageSource = buildCliMessageSourceProvenance({
+                            selected: 'pty-parser',
+                            provider: adapter.cliType,
+                            nativeHandle: historyProviderSessionId || nativeHistorySessionId || historySessionId,
+                            sessionWorkspace,
+                            intendedWorkspace,
+                            transcriptWorkspace,
+                            fallbackReason,
+                            nativeSource: (nativeHistory as any).source,
+                            sourcePath: (nativeHistory as any).sourcePath,
+                            sourceMtimeMs: (nativeHistory as any).sourceMtimeMs,
+                            nativeHistoryCoverage,
+                            partialReason,
+                            unavailableReason,
+                            nativeMessages,
+                            ptyMessages: returnedMessages,
+                            returnedMessages: unsafeNativeFallback && !safeCurrentRuntimePtyMessages ? safeDaemonMessages : returnedMessages,
+                            safeMapping,
+                            freshEnough,
+                            ptyStatusApprovalOnly: unsafeNativeFallback && !safeCurrentRuntimePtyMessages,
+                        });
+                        if (safeCurrentRuntimePtyMessages) {
+                            (messageSource as any).selectedDaemonSource = 'current-runtime-pty';
+                            (messageSource as any).transcriptAuthority = 'daemon';
+                            (messageSource as any).runtimeMappingSafe = true;
+                        }
+                        if (unsafeNativeFallback && exactRuntimeMirrorMessages.length > 0) {
+                            (messageSource as any).selectedDaemonSource = 'exact-runtime-mirror';
+                            (messageSource as any).transcriptAuthority = 'daemon';
+                        }
+                    }
+                }
+            }
             LOG.debug('Command', `[read_chat] cli-like parsed provider=${adapter.cliType} target=${String(args?.targetSessionId || '')} adapterStatus=${String(adapterStatus.status || '')} parsedStatus=${String(parsedRecord.status || '')} parsedMsgCount=${parsedRecord.messages.length} returnedMsgCount=${returnedMessages.length}`);
             return buildReadChatCommandResult({
-                messages: returnedMessages,
-                status: returnedStatus,
+                messages: selectedMessages,
+                status: selectedStatus,
                 activeModal,
+                messageSource,
+                transcriptProvenance: messageSource,
                 debugReadChat: {
                     provider: adapter.cliType,
                     targetSessionId: String(args?.targetSessionId || ''),
                     adapterStatus: String(adapterStatus.status || ''),
                     parsedStatus: String(parsedRecord.status || ''),
-                    returnedStatus: String(returnedStatus || ''),
-                    shouldPreferAdapterMessages: false,
+                    returnedStatus: String(selectedStatus || ''),
+                    selectedMessageSource: (messageSource as any).selected,
+                    messageSource,
+                    shouldPreferAdapterMessages: supportsCliNativeTranscript(providerType, provider)
+                        && isNativeSourceCanonicalHistory(provider?.canonicalHistory)
+                        && (messageSource as any).selected !== 'native-history'
+                        && typeof (messageSource as any).fallbackReason === 'string'
+                        && (messageSource as any).fallbackReason.startsWith('native_history_')
+                        && (messageSource as any).fallbackReason !== 'native_history_not_checked'
+                        && !isUnsafeNativeTranscriptFallback((messageSource as any).fallbackReason)
+                        && !(selectedTranscriptAuthority === 'provider' && selectedCoverage === 'full'),
                     parsedMsgCount: parsedRecord.messages.length,
-                    returnedMsgCount: returnedMessages.length,
+                    returnedMsgCount: selectedMessages.length,
                 },
-                ...(title ? { title } : {}),
-                ...(providerSessionId ? { providerSessionId } : {}),
-                ...(transcriptAuthority ? { transcriptAuthority } : {}),
-                ...(coverage ? { coverage } : {}),
+                ...(selectedTitle ? { title: selectedTitle } : {}),
+                ...(selectedProviderSessionId ? { providerSessionId: selectedProviderSessionId } : {}),
+                ...(selectedTranscriptAuthority ? { transcriptAuthority: selectedTranscriptAuthority } : {}),
+                ...(selectedCoverage ? { coverage: selectedCoverage } : {}),
             }, args);
         }
         const historyLimit = normalizeReadChatTailLimit(args);
         try {
             const agentStr = provider?.type || args?.agentType || getCurrentProviderType(h);
-            const workspace = typeof args?.workspace === 'string'
-                ? args.workspace
-                : typeof (h.currentSession as any)?.workspace === 'string'
-                    ? (h.currentSession as any).workspace
-                    : undefined;
-            const history = readProviderChatHistory(agentStr, {
+            const workspace = typeof (h.currentSession as any)?.workspace === 'string'
+                ? (h.currentSession as any).workspace
+                : undefined;
+            const intendedWorkspace = typeof args?.workspace === 'string' ? args.workspace : undefined;
+            const exactNativeHistoryScope = Boolean(
+                (typeof args?.targetSessionId === 'string' && args.targetSessionId.trim())
+                || (typeof args?.historySessionId === 'string' && args.historySessionId.trim())
+                || (typeof args?.providerSessionId === 'string' && args.providerSessionId.trim())
+                || ((h.currentSession as any)?.sessionId === args?.targetSessionId && typeof (h.currentSession as any)?.providerSessionId === 'string' && (h.currentSession as any).providerSessionId.trim())
+            );
+            const history = supportsCliNativeTranscript(agentStr, provider) && isNativeSourceCanonicalHistory(provider?.canonicalHistory)
+                ? readCliProviderNativeHistory(agentStr, {
+                    canonicalHistory: provider?.canonicalHistory,
+                    historySessionId,
+                    workspace,
+                    offset: 0,
+                    limit: historyLimit,
+                    excludeRecentCount: 0,
+                    historyBehavior: provider?.historyBehavior,
+                    scripts: provider?.scripts as any,
+                })
+                : readProviderChatHistory(agentStr, {
                 canonicalHistory: provider?.canonicalHistory,
                 historySessionId,
                 workspace,
@@ -921,12 +1747,87 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                 historyBehavior: provider?.historyBehavior,
                 scripts: provider?.scripts as any,
             });
+            const lookup = (history as any).lookup === 'workspace' ? 'workspace' : 'session';
+            const historyMessages = Array.isArray((history as any)?.messages)
+                ? normalizeNativeHistoryMessages(agentStr, (history as any).messages as ChatMessage[], (history as any)?.providerSessionId)
+                : [];
             const historyProviderSessionId = typeof (history as any)?.providerSessionId === 'string'
                 ? (history as any).providerSessionId
-                : historySessionId;
+                : readHistorySessionIdFromMessages(historyMessages) || historySessionId;
+            const nativeHistoryCoverage = typeof (history as any)?.nativeHistoryCoverage === 'string'
+                ? (history as any).nativeHistoryCoverage
+                : undefined;
+            const partialReason = typeof (history as any)?.partialReason === 'string'
+                ? (history as any).partialReason
+                : undefined;
+            const unavailableReason = typeof (history as any)?.unavailableReason === 'string'
+                ? (history as any).unavailableReason
+                : undefined;
+            const transcriptWorkspace = typeof (history as any)?.workspace === 'string'
+                ? (history as any).workspace
+                : historyMessages.map((message: any) => typeof message?.workspace === 'string' ? message.workspace.trim() : '').find(Boolean);
+            const safeMapping = supportsCliNativeTranscript(agentStr, provider)
+                ? hasSafeNativeHistoryMapping({
+                    historySessionId: lookup === 'workspace' ? undefined : historySessionId,
+                    providerSessionId: lookup === 'workspace' ? undefined : historyProviderSessionId,
+                    workspace,
+                    nativeMessages: historyMessages,
+                })
+                : false;
+            const nativeSelected = supportsCliNativeTranscript(agentStr, provider)
+                && (history as any).source === 'provider-native'
+                && historyMessages.length > 0
+                && nativeHistoryCoverage !== 'partial'
+                && nativeHistoryCoverage !== 'unavailable'
+                && safeMapping;
+            const messageSource = buildCliMessageSourceProvenance({
+                selected: nativeSelected ? 'native-history' : 'pty-parser',
+                provider: agentStr,
+                nativeHandle: historyProviderSessionId || historySessionId,
+                sessionWorkspace: workspace,
+                intendedWorkspace,
+                transcriptWorkspace,
+                fallbackReason: nativeSelected
+                    ? undefined
+                    : buildNativeHistoryFallbackReason({
+                        providerType: agentStr,
+                        provider,
+                        nativeSource: (history as any).source,
+                        nativeHistoryCoverage,
+                        unavailableReason,
+                        nativeMessageCount: historyMessages.length,
+                        safeMapping,
+                        freshEnough: true,
+                    }),
+                nativeSource: (history as any).source,
+                sourcePath: (history as any).sourcePath,
+                sourceMtimeMs: (history as any).sourceMtimeMs,
+                nativeHistoryCoverage,
+                partialReason,
+                unavailableReason,
+                nativeMessages: historyMessages,
+                returnedMessages: historyMessages,
+                safeMapping,
+                freshEnough: true,
+                ptyStatusApprovalOnly: false,
+            });
+            const requiresNativeSource = supportsCliNativeTranscript(agentStr, provider)
+                && isNativeSourceCanonicalHistory(provider?.canonicalHistory);
+            if (requiresNativeSource && !nativeSelected) {
+                return {
+                    success: false,
+                    code: 'native_history_not_safely_available',
+                    error: 'Provider-native history was not safely available for the requested CLI session.',
+                    providerSessionId: historyProviderSessionId,
+                    messageSource,
+                    transcriptProvenance: messageSource,
+                };
+            }
             return buildReadChatCommandResult({
-                messages: Array.isArray((history as any)?.messages) ? (history as any).messages : [],
+                messages: historyMessages,
                 status: 'idle',
+                messageSource,
+                transcriptProvenance: messageSource,
                 ...(typeof (history as any)?.title === 'string' ? { title: (history as any).title } : {}),
                 ...(historyProviderSessionId ? { providerSessionId: historyProviderSessionId } : {}),
                 ...(((provider?.historyBehavior as any)?.transcriptAuthority === 'provider' || (provider?.historyBehavior as any)?.transcriptAuthority === 'daemon')
@@ -1184,8 +2085,24 @@ export async function handleSendChat(h: CommandHelpers, args: any): Promise<Comm
                 assertTextOnlyInput(provider, input);
                 if (!text) return { success: false, error: 'text required for PTY send' };
                 await waitOnceForFreshHermesCliStart(adapter, _log);
-                await adapter.sendMessage(text);
-                return _logSendSuccess(`${transport}-adapter`, adapter.cliType);
+                const forceSend = args?.force === true || args?.forceSend === true;
+                if (forceSend && typeof adapter.forceSendMessage === 'function') {
+                    await adapter.forceSendMessage(text);
+                } else if (forceSend) {
+                    await adapter.sendMessage(text, { force: true });
+                } else {
+                    await adapter.sendMessage(text);
+                }
+                const target = getTargetInstance(h, args) as RuntimeChatMessageMerger | null;
+                if (target?.category === 'cli'
+                    && target.type === adapter.cliType
+                    && typeof target.recordAcknowledgedUserInput === 'function') {
+                    target.recordAcknowledgedUserInput(input);
+                }
+                return {
+                    ..._logSendSuccess(`${transport}-adapter`, adapter.cliType),
+                    ...(forceSend ? { forceSent: true } : {}),
+                };
             } catch (e: any) {
                 return { success: false, error: `${transport} send failed: ${e.message}` };
             }
@@ -1742,6 +2659,9 @@ export async function handleResolveAction(h: CommandHelpers, args: any): Promise
         if (buttonIndex < 0 && (action === 'always' || /always/i.test(button))) {
             buttonIndex = buttons.findIndex(b => /always/i.test(b));
         }
+        if (buttonIndex < 0 && (action === 'approve' || action === 'accept')) {
+            buttonIndex = pickApprovalButton(buttons, provider).index;
+        }
         if (buttonIndex < 0) {
             return { success: false, error: 'Approval action did not match any visible button' };
         }