@adhdev/daemon-core 0.9.82-rc.160 → 0.9.82-rc.162

package/dist/providers/spec/types.d.ts

@@ -0,0 +1,211 @@
+export type Size = number | string;
+export interface Section {
+    id: string;
+    from_top?: Size;
+    from_bottom?: Size;
+    until?: {
+        section: string;
+    };
+}
+export interface SectionRegex {
+    section?: string;
+    regex: string;
+    flags?: string;
+}
+export interface SectionPattern {
+    section?: string;
+    pattern: string;
+    flags?: string;
+}
+export interface ModalButtonsRule {
+    section?: string;
+    pattern: string;
+    flags?: string;
+    key_for_index: string;
+    min_count?: number;
+}
+export interface SpecState {
+    id: string;
+    label: string;
+    when: SectionRegex;
+    extract_title?: SectionRegex;
+    modal_buttons?: ModalButtonsRule;
+}
+export type ControlAction = {
+    type: 'send_keys';
+    keys: string;
+} | {
+    type: 'open_picker';
+    trigger_keys: string;
+    wait_for: SectionRegex;
+    extract_choices: SectionPattern;
+    submit_key: string;
+} | {
+    type: 'attach_image';
+    method: 'tempfile_then_keys';
+    keys_template: string;
+};
+export interface Control {
+    id: string;
+    label: string;
+    visible_when_state?: string[];
+    action: ControlAction;
+}
+export interface NotificationRule {
+    id: string;
+    when_state: string;
+    title: string;
+    body?: string;
+}
+export interface DelegateTrigger {
+    id: string;
+    when_state: string;
+    after_duration_ms?: number;
+    task_template: string;
+}
+/**
+ * Native history config — three modes, picked by which fields are present:
+ *
+ *   1. `reader`: built-in reader id (claude-cli / codex-cli / antigravity-cli / hermes-cli).
+ *      Backwards-compatible path used by the four shipped providers.
+ *
+ *   2. `source`: declarative source descriptor. The daemon's spec native-history
+ *      executor reads the on-disk store (jsonl file / sqlite db) directly using
+ *      paths + jsonpath maps from this block. New providers should prefer this
+ *      mode — no daemon changes required.
+ *
+ *   3. `override_path`: relative path to a provider-supplied reader module
+ *      (e.g. "./native_history/index.js"). Escape hatch for formats too
+ *      exotic for the declarative executor. The module must default-export
+ *      a function with the signature
+ *        (input: NativeHistoryInput) => NativeHistoryResult | null
+ *      and runs under provider-script-root sandboxing (same gate as
+ *      scripts.js).
+ *
+ * The three modes are mutually exclusive — set exactly one. Loader rejects
+ * specs that set zero or more than one.
+ */
+export interface NativeHistoryConfig {
+    reader?: 'claude-cli' | 'codex-cli' | 'antigravity-cli' | 'hermes-cli';
+    source?: NativeHistorySource;
+    override_path?: string;
+}
+export type NativeHistorySource = NativeHistoryJsonlSource | NativeHistorySqliteSource;
+/**
+ * JSONL source — each line in the resolved file is one record.
+ *
+ * `path` accepts ~/, environment variables (${HOME}), and a small set of
+ * runtime variables:
+ *   {cwd}              — the session's working directory, raw
+ *   {cwd_dashed}       — cwd with `/` replaced by `-` (claude's per-project key)
+ *   {session_id}       — providerSessionId, when known
+ *   {yyyy} {mm} {dd}   — UTC date components
+ *
+ * When `path` resolves to a directory, the daemon picks the newest file
+ * matching `file_pattern` whose mtime is inside `recent_window_ms` (default
+ * 5min) — prevents the wrong session's transcript from leaking through.
+ */
+export interface NativeHistoryJsonlSource {
+    kind: 'jsonl';
+    path: string;
+    file_pattern?: string;
+    recent_window_ms?: number;
+    session_id_from?: 'filename_uuid' | 'first_record';
+    session_id_path?: string;
+    message_filter?: {
+        where: string;
+    };
+    message_map: NativeHistoryMessageMap;
+}
+/**
+ * SQLite source — provider runs two queries on a read-only handle: one to
+ * pick the session row (`session_query` — first row's first column is the
+ * sessionId), then one to fetch messages (`message_query` — `?` is bound
+ * to the sessionId). Output rows are projected through `message_map`.
+ */
+export interface NativeHistorySqliteSource {
+    kind: 'sqlite';
+    path: string;
+    session_query: string;
+    message_query: string;
+    message_map: NativeHistoryMessageMap;
+}
+/**
+ * Maps a source record (jsonl line object / sqlite row) to a daemon
+ * native-history message. Values are jsonpath-lite strings: `$.foo.bar`
+ * or `$.items[0].text`. Literal strings (no leading `$`) pass through.
+ *
+ * `content_strip` lets a spec drop wrapper tags that the agent injects
+ * into its own transcript (claude's `<local-command-caveat>`, agy's
+ * `<USER_REQUEST>` / `<ADDITIONAL_METADATA>` / `<USER_SETTINGS_CHANGE>`).
+ * Each entry is a tag name; the executor removes `<tag>…</tag>` segments
+ * non-greedily before the value is handed to the dashboard. After all
+ * strips, leading/trailing whitespace is trimmed. If the result is empty
+ * the message is dropped.
+ */
+export interface NativeHistoryMessageMap {
+    role: string;
+    content: string;
+    /**
+     * Tags whose entire `<tag>…</tag>` segment is removed from content.
+     * Use for noise wrappers the agent ships alongside the real message
+     * (claude's `<local-command-caveat>`, agy's `<ADDITIONAL_METADATA>`).
+     */
+    content_strip?: string[];
+    /**
+     * Tags whose open/close markers are removed but inner content is kept.
+     * Use when the *real* user/assistant message is wrapped in a tag
+     * the agent uses for routing (agy wraps user input in `<USER_REQUEST>`).
+     */
+    content_unwrap?: string[];
+    timestamp_ms?: string;
+    kind?: string;
+}
+export interface CliSpec {
+    $schema: 'adhdev:cli/spec@1';
+    id: string;
+    name: string;
+    binary: string;
+    spawn_args?: string[];
+    env?: Record<string, string>;
+    /**
+     * Optional version constraint this spec is authored for, e.g. ">=2.1.0".
+     * Pure metadata used by tooling/UI — the actual version-to-spec match
+     * happens in provider-loader via the manifest's compatibility array.
+     * Spec authors include this so a misrouted spec is easy to spot.
+     */
+    cli_version_range?: string;
+    send_message: {
+        submit_key: string;
+        delay_ms_before_submit?: number;
+        delay_ms_per_char?: number;
+    };
+    layout: {
+        sections: Section[];
+    };
+    states: SpecState[];
+    default_state: string;
+    control_bar?: Control[];
+    notifications?: NotificationRule[];
+    delegate?: DelegateTrigger[];
+    native_history?: NativeHistoryConfig;
+    /**
+     * Per-spec debounce knobs. Defaults are conservative (busy_hold_ms
+     * 6000) and live in SpecDriver. Spec authors override here when a
+     * particular CLI flickers slower/faster than the default.
+     */
+    debounce?: {
+        /** Min time to stay in busy after the evaluator last reported it.
+         *  Absorbs per-frame flicker in TUIs that stream output through
+         *  the same region as the spinner. */
+        busy_hold_ms?: number;
+        /** Min time after start() before a send_message is allowed to
+         *  reach the PTY. Banner paints + auth flows + skill listings
+         *  can keep the agent unable to accept input for several seconds
+         *  even though the idle regex matches a transient empty prompt.
+         *  Send_messages issued before this window are queued and drained
+         *  once the window passes and an idle state has actually been
+         *  observed. */
+        startup_grace_ms?: number;
+    };
+}

package/dist/repo-mesh-types.d.ts

@@ -202,7 +202,28 @@ export interface RepoMeshCoordinatorConfig {
     providerType?: string;
     /** Preferred node to run coordinator on (null = auto) */
     preferredNodeId?: string;
-    /** Additional system prompt context for coordinator */
+    /**
+     * Full mesh-level override for the coordinator system prompt. When set,
+     * replaces the daemon's rendered default and any user-file override
+     * (~/.adhdev/coordinator-prompts/<cli>.md). The per-launch
+     * extraSystemPrompt still composes on top — it always lands last as
+     * Additional Context. Supports the same {{placeholders}} the daemon's
+     * default template uses ({{meshName}}, {{repo}}, {{nodes}}, …).
+     */
+    systemPromptOverride?: string;
+    /**
+     * Mesh-level append. Composes after whichever base prompt won
+     * (override → user-file override → daemon default). Use this when you
+     * want extra rules for THIS mesh but otherwise the standard prompt is
+     * fine. Stacks with the user-file append (`<cli>.append.md`) — both
+     * apply if both are set.
+     */
+    systemPromptAppend?: string;
+    /**
+     * @deprecated Use systemPromptAppend. Kept as a fallback alias so
+     * existing meshes.json files keep working without a migration step;
+     * the daemon prefers systemPromptAppend when both are present.
+     */
     systemPromptSuffix?: string;
 }
 /**
@@ -234,6 +255,15 @@ export interface LocalMeshNodeEntry {
     machineId?: string;
     userOverrides: Partial<RepoMeshNodeCapabilities>;
     policy: RepoMeshNodePolicy;
+    /**
+     * Per-node instruction surfaced in the coordinator prompt so the LLM
+     * knows what each node is for (e.g. "this is the staging mirror — run
+     * only smoke tests here", or "use opus on this node, sonnet elsewhere").
+     * Empty/missing: omitted silently from the rendered prompt, no rule
+     * line about it gets added. The coordinator forwards/honors it when
+     * delegating; we don't enforce it at the daemon level.
+     */
+    systemPrompt?: string;
     /** For single-machine mesh: same daemon, different worktree */
     isLocalWorktree?: boolean;
     /** Branch this worktree tracks (set when created via clone_mesh_node) */
@@ -305,6 +335,8 @@ export interface RepoMeshNodeStatus {
     machineStatus?: string;
     isLocalWorktree?: boolean;
     worktreeBranch?: string;
+    /** Mirrored from LocalMeshNodeEntry.systemPrompt for coordinator-prompt rendering. */
+    systemPrompt?: string;
     health: RepoMeshNodeHealth;
     git?: GitRepoStatus;
     /**

package/dist/sessions/registry.d.ts

@@ -7,6 +7,9 @@ export interface SessionRuntimeTarget {
     cdpManagerKey?: string;
     adapterKey?: string;
     instanceKey?: string;
+    /** Wall clock at register time. native-history readers use it as a
+     *  cutoff so a fresh session can't show records from a prior one. */
+    spawnedAtMs?: number;
 }
 export declare class SessionRegistry {
     private readonly bySessionId;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.160",
+  "version": "0.9.82-rc.162",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -48,6 +48,7 @@
   "dependencies": {
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
+    "@xterm/headless": "^6.0.0",
     "@xterm/xterm": "^6.0.0",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/cli-adapter-types.ts

@@ -13,6 +13,9 @@ export interface CliAdapterStatus {
         message: string;
         buttons: string[];
     } | null;
+    providerSessionId?: string;
+    errorMessage?: string;
+    errorReason?: string;
 }
 
 export interface AcpAdapterHandle {
@@ -40,7 +43,7 @@ export interface CliAdapter {
     spawn(): Promise<void>;
     sendMessage(text: string, options?: { force?: boolean }): Promise<void>;
     forceSendMessage?(text: string): Promise<void>;
-    getStatus(): CliAdapterStatus;
+    getStatus(options?: { allowParse?: boolean }): CliAdapterStatus;
     getScriptParsedStatus?(): unknown;
     getDebugSnapshot?(): unknown;
     invokeScript?(scriptName: string, args?: Record<string, unknown>): Promise<unknown>;
@@ -63,4 +66,15 @@ export interface CliAdapter {
     setOnPtyData?(callback: (data: string) => void): void;
     writeRaw?(data: string): void;
     resize?(cols: number, rows: number): void;
+    // ── Runtime metadata used by CliProviderInstance for session tracking ──
+    getRuntimeMetadata?(): unknown;
+    updateRuntimeMeta?(meta: Record<string, unknown>): void;
+    refreshProviderDefinition?(provider: unknown): void;
+    // ── Optional auxiliary fields some daemon paths read off the status ──
+}
+
+export interface CliAdapterStatusOptional {
+    providerSessionId?: string;
+    errorMessage?: string;
+    errorReason?: string;
 }

package/src/commands/chat-commands.ts

@@ -15,6 +15,7 @@ import { validateReadChatResultPayload } from '../providers/read-chat-contract.j
 import { pickApprovalButton } from '../providers/approval-utils.js';
 import type { ProviderInstance } from '../providers/provider-instance.js';
 import { isNativeSourceCanonicalHistory, readChatHistory, readProviderChatHistory } from '../config/chat-history.js';
+import { getCoordinatorForSession } from '../mesh/coordinator-registry.js';
 import { LOG, getRecentLogs } from '../logging/logger.js';
 import { getRecentDebugTrace, recordDebugTrace } from '../logging/debug-trace.js';
 import { buildChatMessageSignature, hashSignatureParts } from '../chat/chat-signatures.js';
@@ -324,6 +325,82 @@ function shouldPreserveNativeIdentity(providerType: string, sessionId: string, m
     return true;
 }
 
+/**
+ * Drop the synthetic "user" message some CLIs surface in their native
+ * transcript when the daemon injects a coordinator system prompt
+ * (codex puts the AGENTS.md / developer_instructions block in as
+ * role=user; agy/claude/hermes have similar artifacts). The user can
+ * opt back into seeing it via the provider setting
+ * `showCoordinatorSystemPrompt`. Default is off — the prompt is still
+ * fully visible from the chat-header ⓘ "Session info" dialog.
+ *
+ * Matching rules:
+ *   1. Setting must be off (default).
+ *   2. There must be a registered coordinator entry for the session.
+ *   3. The candidate message is filtered when its role is user OR
+ *      system and its content either contains the prompt body verbatim,
+ *      OR contains the well-known coordinator marker
+ *      `adhdev-mesh-coordinator-prompt`. The marker covers context-file
+ *      cases (agy AGENTS.md / gemini GEMINI.md) where the CLI may wrap
+ *      its own preamble around our block. Verbatim-content covers
+ *      codex's developer_instructions echo.
+ *
+ * Returns the messages array unchanged when none of the rules match,
+ * so this is safe to apply unconditionally to every read_chat result.
+ */
+function maybeHideCoordinatorPromptMessage(
+    h: CommandHelpers,
+    providerType: string,
+    sessionId: string | undefined,
+    messages: ChatMessage[],
+): ChatMessage[] {
+    if (!Array.isArray(messages) || messages.length === 0) return messages;
+    if (!sessionId) return messages;
+    const loader = h.ctx?.providerLoader;
+    if (!loader) return messages;
+    let showSetting: unknown = undefined;
+    try {
+        showSetting = (loader as any).getSettingValue?.(providerType, 'showCoordinatorSystemPrompt');
+    } catch { /* unknown setting key for this provider — fall through */ }
+    if (showSetting === true) return messages;
+    const coord = getCoordinatorForSession(sessionId);
+    if (!coord) return messages;
+    const promptBody = typeof coord.systemPrompt === 'string' ? coord.systemPrompt : '';
+    const MARKER = 'adhdev-mesh-coordinator-prompt';
+    const filtered = messages.filter(m => {
+        const role = String((m as any)?.role || '').toLowerCase();
+        if (role !== 'user' && role !== 'system') return true;
+        const content = flattenContent((m as any)?.content);
+        if (!content) return true;
+        if (content.includes(MARKER)) return false;
+        if (promptBody && content.includes(promptBody.slice(0, Math.min(400, promptBody.length)))) return false;
+        return true;
+    });
+    if (filtered.length !== messages.length) {
+        LOG.debug('ChatFilter', `[${providerType}] hid ${messages.length - filtered.length} coordinator-prompt message(s) from ${sessionId}`);
+    }
+    return filtered;
+}
+
+/**
+ * Convenience wrapper used at every native-history call site: normalize +
+ * conditionally drop the coordinator system-prompt message. Avoids
+ * duplicating the filter at four read_chat code paths.
+ */
+function normalizeAndFilterNativeHistory(
+    h: CommandHelpers,
+    providerType: string,
+    args: any,
+    messages: ChatMessage[],
+    nativeSessionId?: string,
+): ChatMessage[] {
+    const normalized = normalizeNativeHistoryMessages(providerType, messages, nativeSessionId);
+    const sessionId = typeof args?.targetSessionId === 'string' ? args.targetSessionId
+        : typeof args?.sessionId === 'string' ? args.sessionId
+        : undefined;
+    return maybeHideCoordinatorPromptMessage(h, providerType, sessionId, normalized);
+}
+
 function normalizeNativeHistoryMessages(providerType: string, messages: ChatMessage[], nativeSessionId?: string): ChatMessage[] {
     let turnIndex = 0;
     return normalizeChatMessages(messages).map((message, index) => {
@@ -1003,6 +1080,41 @@ function hasSafeNativeHistoryMapping(args: {
 // 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.
+/**
+ * Pull the session's spawnedAtMs out of the registry. Native-history
+ * file pickers use it as a "files older than this can't be from this
+ * session" floor; without it a fresh dashboard view would inherit the
+ * previous session's transcript whenever its file happened to be the
+ * newest match. Returns undefined when the session isn't registered
+ * (e.g. read_chat before the live session was wired up) — the executor
+ * treats undefined as "no floor".
+ */
+function sessionStartedAtMsFromRegistry(h: CommandHelpers, targetSessionId: string | undefined): number | undefined {
+    const sid = typeof targetSessionId === 'string' ? targetSessionId.trim() : '';
+    if (!sid) return undefined;
+    const target = h.ctx?.sessionRegistry?.get?.(sid);
+    return typeof target?.spawnedAtMs === 'number' ? target.spawnedAtMs : undefined;
+}
+
+/**
+ * Pull the env vars the daemon set when it spawned this session's CLI.
+ * Mesh coordinator points hermes at a per-coordinator HERMES_HOME so
+ * the native-history reader needs that override to find the right
+ * state.db; without it the reader sees ~/.hermes/state.db and misses
+ * every coordinator-session transcript.
+ *
+ * Returns undefined when no SpecCliAdapter is in play (legacy
+ * providers / CDP) or when the adapter exposes no spawn env.
+ */
+function sessionSpawnEnvFromAdapter(h: CommandHelpers, targetSessionId: string | undefined): Record<string, string> | undefined {
+    const adapter = getTargetedCliAdapter(h, { targetSessionId }, undefined);
+    if (!adapter || typeof adapter.getRuntimeMetadata !== 'function') return undefined;
+    const meta = adapter.getRuntimeMetadata() as Record<string, unknown> | undefined;
+    const env = meta && typeof meta === 'object' ? (meta as Record<string, unknown>).spawnedEnv : undefined;
+    return env && typeof env === 'object' ? env as Record<string, string> : undefined;
+}
+
+
 function readCliProviderNativeHistory(agentStr: string, args: {
     canonicalHistory?: ProviderModule['canonicalHistory'];
     historySessionId?: string;
@@ -1013,6 +1125,8 @@ function readCliProviderNativeHistory(agentStr: string, args: {
     historyBehavior?: ProviderModule['historyBehavior'];
     scripts?: ProviderScripts;
     excludeInProgressTurn?: boolean;
+    sessionStartedAtMs?: number;
+    envOverrides?: Record<string, string>;
 }): ReturnType<typeof readProviderChatHistory> & { lookup: 'session' | 'workspace' } {
     if (!args.historySessionId) {
         return {
@@ -1033,6 +1147,8 @@ function readCliProviderNativeHistory(agentStr: string, args: {
         historyBehavior: args.historyBehavior,
         scripts: args.scripts as any,
         excludeInProgressTurn: args.excludeInProgressTurn,
+        sessionStartedAtMs: args.sessionStartedAtMs,
+        envOverrides: args.envOverrides,
     });
     // Native transcripts are keyed by provider/runtime session identity. Falling
     // back to workspace makes concurrent local Codex/Hermes sessions alias each
@@ -1290,7 +1406,7 @@ function collapseAdjacentDuplicateChatMessages(messages: ChatMessage[]): ChatMes
     return result;
 }
 
-function buildReadChatCommandResult(payload: Record<string, any>, args: any): CommandResult {
+function buildReadChatCommandResult(payload: Record<string, any>, args: any, h?: CommandHelpers): CommandResult {
     let validatedPayload: Record<string, any>;
     const debugReadChat = payload?.debugReadChat && typeof payload.debugReadChat === 'object'
         ? payload.debugReadChat
@@ -1304,7 +1420,23 @@ function buildReadChatCommandResult(payload: Record<string, any>, args: any): Co
         return { success: false, error: error?.message || String(error) };
     }
     const messages = normalizeReadChatMessages(validatedPayload);
-    const visibleMessages = filterUserFacingChatMessages(messages);
+    // Last-mile coordinator-prompt filter. Different read_chat code paths
+    // produce the final messages array (native-history main path, codex
+    // exact-runtime-mirror fallback, daemon-side pty-parser, etc), so
+    // applying it here means we don't have to thread the filter through
+    // every one. Driven by the provider setting `showCoordinatorSystemPrompt`
+    // + the coordinator-registry entry for the target session.
+    const sessionIdHint = typeof args?.targetSessionId === 'string' ? args.targetSessionId
+        : typeof args?.sessionId === 'string' ? args.sessionId
+        : '';
+    const providerHint = typeof args?.cliType === 'string' ? args.cliType
+        : typeof args?.providerType === 'string' ? args.providerType
+        : typeof args?.agentType === 'string' ? args.agentType
+        : '';
+    const filteredMessages = h
+        ? maybeHideCoordinatorPromptMessage(h, providerHint, sessionIdHint, messages)
+        : messages;
+    const visibleMessages = filterUserFacingChatMessages(filteredMessages);
     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)));
@@ -1819,6 +1951,8 @@ export async function handleChatHistory(h: CommandHelpers, args: any): Promise<C
                 excludeRecentCount,
                 historyBehavior: provider?.historyBehavior,
                 scripts: provider?.scripts as any,
+                sessionStartedAtMs: sessionStartedAtMsFromRegistry(h, args?.targetSessionId),
+                envOverrides: sessionSpawnEnvFromAdapter(h, args?.targetSessionId),
             })
             : readProviderChatHistory(agentStr, {
                 canonicalHistory: provider?.nativeHistory,
@@ -1833,7 +1967,7 @@ export async function handleChatHistory(h: CommandHelpers, args: any): Promise<C
         if (supportsCliNativeTranscript(agentStr, provider) && isNativeSourceCanonicalHistory(provider?.nativeHistory)) {
             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)
+                ? normalizeAndFilterNativeHistory(h, agentStr, args, (result as any).messages as ChatMessage[], (result as any)?.providerSessionId)
                 : [];
             const historyProviderSessionId = typeof (result as any)?.providerSessionId === 'string'
                 ? (result as any).providerSessionId
@@ -2004,6 +2138,8 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                         historyBehavior: provider?.historyBehavior,
                         scripts: provider?.scripts as any,
                         excludeInProgressTurn: returnedStatus === 'waiting_approval',
+                        sessionStartedAtMs: sessionStartedAtMsFromRegistry(h, args?.targetSessionId),
+                envOverrides: sessionSpawnEnvFromAdapter(h, args?.targetSessionId),
                     });
                 } catch (error: any) {
                     nativeHistoryError = error;
@@ -2014,7 +2150,7 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
             // 2. Compute safeMapping with the same rules the v1 code used so the
             //    machine sees the same observation it always would have.
             const nativeMessages: ChatMessage[] = nativeHistory && Array.isArray(nativeHistory.messages)
-                ? normalizeNativeHistoryMessages(agentStr, nativeHistory.messages as ChatMessage[], nativeHistory.providerSessionId)
+                ? normalizeAndFilterNativeHistory(h, agentStr, args, nativeHistory.messages as ChatMessage[], nativeHistory.providerSessionId)
                 : [];
             const historyProviderSessionId = typeof nativeHistory?.providerSessionId === 'string'
                 ? nativeHistory.providerSessionId
@@ -2099,7 +2235,7 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                     })
                     : null;
                 const liveWorkspaceNativeMessages = Array.isArray((liveWorkspaceNativeHistory as any)?.messages)
-                    ? normalizeNativeHistoryMessages(agentStr, (liveWorkspaceNativeHistory as any).messages as ChatMessage[], (liveWorkspaceNativeHistory as any)?.providerSessionId)
+                    ? normalizeAndFilterNativeHistory(h, agentStr, args, (liveWorkspaceNativeHistory as any).messages as ChatMessage[], (liveWorkspaceNativeHistory as any)?.providerSessionId)
                     : [];
                 const liveWorkspaceNativeProviderSessionId = typeof (liveWorkspaceNativeHistory as any)?.providerSessionId === 'string'
                     ? (liveWorkspaceNativeHistory as any).providerSessionId
@@ -2214,7 +2350,7 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                 ...(selectedProviderSessionId ? { providerSessionId: selectedProviderSessionId } : {}),
                 ...(selectedTranscriptAuthority ? { transcriptAuthority: selectedTranscriptAuthority } : {}),
                 ...(selectedCoverage ? { coverage: selectedCoverage } : {}),
-            }, args);
+            }, args, h);
         }
         // History-only path (no adapter). Same source-decision contract as
         // the adapter path above, but with no PTY messages — the machine
@@ -2240,6 +2376,8 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                     excludeRecentCount: 0,
                     historyBehavior: provider?.historyBehavior,
                     scripts: provider?.scripts as any,
+                    sessionStartedAtMs: sessionStartedAtMsFromRegistry(h, args?.targetSessionId),
+                envOverrides: sessionSpawnEnvFromAdapter(h, args?.targetSessionId),
                 })
                 : readProviderChatHistory(agentStr, {
                     canonicalHistory: provider?.nativeHistory,
@@ -2253,7 +2391,7 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                 });
             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)
+                ? normalizeAndFilterNativeHistory(h, agentStr, args, (history as any).messages as ChatMessage[], (history as any)?.providerSessionId)
                 : [];
             const historyProviderSessionId = typeof (history as any)?.providerSessionId === 'string'
                 ? (history as any).providerSessionId
@@ -2307,7 +2445,7 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                     ? { transcriptAuthority: (provider?.historyBehavior as any).transcriptAuthority }
                     : {}),
                 coverage: 'tail',
-            }, args);
+            }, args, h);
         } catch (error: any) {
             return { success: false, error: error?.message || `${transport} adapter not found` };
         }
@@ -2347,7 +2485,7 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                         args?.targetSessionId,
                         historySessionId,
                     );
-                    return buildReadChatCommandResult(validated as Record<string, any>, args);
+                    return buildReadChatCommandResult(validated as Record<string, any>, args, h);
                 }
                 if (!extensionReadChatError) {
                     extensionReadChatError = 'extension read_chat returned a non-object payload';
@@ -2386,7 +2524,7 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                         messages: stream.messages || [],
                         status: stream.status,
                         agentType: stream.agentType,
-                    }, args);
+                    }, args, h);
                 }
             }
         }
@@ -2426,7 +2564,7 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                         args?.targetSessionId,
                         historySessionId,
                     );
-                    return buildReadChatCommandResult(validated as Record<string, any>, args);
+                    return buildReadChatCommandResult(validated as Record<string, any>, args, h);
                 }
                 if (!webviewReadChatError) {
                     webviewReadChatError = 'webview read_chat returned a non-object payload';
@@ -2476,7 +2614,7 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                         args?.targetSessionId,
                         historySessionId,
                     );
-                    return buildReadChatCommandResult(validated as Record<string, any>, args);
+                    return buildReadChatCommandResult(validated as Record<string, any>, args, h);
                 }
                 if (!ideReadChatError) {
                     ideReadChatError = 'ide read_chat returned a non-object payload';

package/src/commands/cli-manager.ts

@@ -638,6 +638,17 @@ export class DaemonCliManager {
                 transport: 'pty',
                 adapterKey: key,
                 instanceKey: key,
+                // attachExisting === true means we're restoring an already-spawned
+                // hosted runtime after a daemon restart, not starting a fresh PTY.
+                // The real spawn time is in the past and we don't have it on the
+                // restored descriptor; pinning spawnedAtMs to Date.now() in that
+                // case would push the native-history session-floor cutoff past
+                // every existing transcript file, so the agy/hermes/claude reader
+                // would return null even though the transcript on disk is fresh.
+                // 0 disables the floor for this session — recent_window_ms in the
+                // spec still bounds how far back we look. Fresh launches still
+                // get a proper floor so prior-session leak protection holds.
+                spawnedAtMs: attachExisting ? 0 : Date.now(),
             });
         } catch (spawnErr: any) {
             LOG.error('CLI', `[${cliType}] Spawn failed: ${spawnErr?.message}`);