@adhdev/daemon-core 0.9.76-rc.50 → 0.9.76-rc.52

package/dist/session-host/runtime-support.d.ts

@@ -1,8 +1,9 @@
-import { type SessionHostEndpoint } from '@adhdev/session-host-core';
+import { type SessionHostEndpoint, type SessionHostRequestType } from '@adhdev/session-host-core';
 import type { HostedCliRuntimeDescriptor } from '../commands/cli-manager.js';
 export declare function ensureSessionHostReady(options: {
     appName?: string;
     spawnHost: () => void;
     timeoutMs?: number;
+    requiredRequestTypes?: readonly SessionHostRequestType[];
 }): Promise<SessionHostEndpoint>;
 export declare function listHostedCliRuntimes(endpoint: SessionHostEndpoint): Promise<HostedCliRuntimeDescriptor[]>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.76-rc.50",
+  "version": "0.9.76-rc.52",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/commands/chat-commands.ts

@@ -22,6 +22,7 @@ import type { SessionTransport } from '../shared-types.js';
 
 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 recentSendByTarget = new Map<string, number>();
 
 interface ApprovalSelectableInstance extends ProviderInstance {
@@ -101,6 +102,19 @@ function getSendChatInputEnvelope(args: any): InputEnvelope {
     return normalizeInputEnvelope(args?.input ? { input: args.input } : args);
 }
 
+function sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function waitOnceForFreshHermesCliStart(adapter: CliAdapter, log: (msg: string) => void): Promise<void> {
+    if (adapter.cliType !== 'hermes-cli') return;
+    const status = typeof adapter.getStatus === 'function' ? adapter.getStatus()?.status : undefined;
+    if (status !== 'starting') return;
+
+    log(`Hermes CLI is still starting; waiting ${HERMES_CLI_STARTING_SEND_SETTLE_MS}ms before first send`);
+    await sleep(HERMES_CLI_STARTING_SEND_SETTLE_MS);
+}
+
 function getHistorySessionId(h: CommandHelpers, args: any): string | undefined {
     const explicit = typeof args?.historySessionId === 'string' ? args.historySessionId.trim() : '';
     if (explicit) return explicit;
@@ -1120,6 +1134,7 @@ export async function handleSendChat(h: CommandHelpers, args: any): Promise<Comm
             try {
                 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);
             } catch (e: any) {

package/src/providers/cli-provider-instance.ts

@@ -1032,8 +1032,11 @@ export class CliProviderInstance implements ProviderInstance {
                 const aTime = getTime(a.message);
                 const bTime = getTime(b.message);
                 if (aTime && bTime && aTime !== bTime) return aTime - bTime;
-                if (aTime && !bTime && a.source === 'runtime' && b.source === 'parsed') return -1;
-                if (!aTime && bTime && a.source === 'parsed' && b.source === 'runtime') return 1;
+                // Many provider-owned CLI transcripts (including Hermes CLI in debug bundles)
+                // do not carry timestamps on parsed messages. In that case there is no safe
+                // clock basis for interleaving timestamped runtime/system messages into the
+                // provider transcript, so preserve parsed order and append runtime entries by
+                // their insertion index instead of moving them ahead of the whole transcript.
                 return a.index - b.index;
             })
             .map((entry) => entry.message));

package/src/session-host/runtime-support.ts

@@ -1,8 +1,10 @@
 import {
     SessionHostClient,
     getDefaultSessionHostEndpoint,
+    type SessionHostDiagnostics,
     type SessionHostEndpoint,
     type SessionHostRecord,
+    type SessionHostRequestType,
 } from '@adhdev/session-host-core';
 import type { HostedCliRuntimeDescriptor } from '../commands/cli-manager.js';
 import { DEFAULT_SESSION_HOST_READY_TIMEOUT_MS } from '../runtime-defaults.js';
@@ -10,21 +12,65 @@ import { DEFAULT_SESSION_HOST_READY_TIMEOUT_MS } from '../runtime-defaults.js';
 const STARTUP_TIMEOUT_MS = DEFAULT_SESSION_HOST_READY_TIMEOUT_MS;
 const STARTUP_POLL_MS = 200;
 
-async function canConnect(endpoint: SessionHostEndpoint): Promise<boolean> {
+class SessionHostCompatibilityError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = 'SessionHostCompatibilityError';
+    }
+}
+
+function getMissingRequestTypes(
+    diagnostics: SessionHostDiagnostics | undefined,
+    requiredRequestTypes: readonly SessionHostRequestType[],
+): SessionHostRequestType[] {
+    const supported = new Set(diagnostics?.supportedRequestTypes || []);
+    return requiredRequestTypes.filter((requestType) => !supported.has(requestType));
+}
+
+async function assertRequiredRequestTypes(
+    client: SessionHostClient,
+    requiredRequestTypes: readonly SessionHostRequestType[],
+): Promise<void> {
+    if (requiredRequestTypes.length === 0) return;
+
+    const response = await client.request<SessionHostDiagnostics>({
+        type: 'get_host_diagnostics',
+        payload: { includeSessions: false },
+    });
+    const missing = getMissingRequestTypes(response.success ? response.result : undefined, requiredRequestTypes);
+    if (missing.length > 0) {
+        const detail = response.success ? '' : ` (${response.error || 'capability probe failed'})`;
+        throw new SessionHostCompatibilityError(
+            `Session host does not support required request types: ${missing.join(', ')}${detail}`,
+        );
+    }
+}
+
+async function canConnect(
+    endpoint: SessionHostEndpoint,
+    requiredRequestTypes: readonly SessionHostRequestType[] = [],
+): Promise<boolean> {
     const client = new SessionHostClient({ endpoint });
     try {
         await client.connect();
-        await client.close();
+        await assertRequiredRequestTypes(client, requiredRequestTypes);
         return true;
-    } catch {
+    } catch (error) {
+        if (error instanceof SessionHostCompatibilityError) throw error;
         return false;
+    } finally {
+        await client.close().catch(() => {});
     }
 }
 
-async function waitForReady(endpoint: SessionHostEndpoint, timeoutMs = STARTUP_TIMEOUT_MS): Promise<void> {
+async function waitForReady(
+    endpoint: SessionHostEndpoint,
+    timeoutMs = STARTUP_TIMEOUT_MS,
+    requiredRequestTypes: readonly SessionHostRequestType[] = [],
+): Promise<void> {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
-        if (await canConnect(endpoint)) return;
+        if (await canConnect(endpoint, requiredRequestTypes)) return;
         await new Promise((resolve) => setTimeout(resolve, STARTUP_POLL_MS));
     }
     throw new Error(`Session host did not become ready within ${timeoutMs}ms`);
@@ -34,11 +80,13 @@ export async function ensureSessionHostReady(options: {
     appName?: string;
     spawnHost: () => void;
     timeoutMs?: number;
+    requiredRequestTypes?: readonly SessionHostRequestType[];
 }): Promise<SessionHostEndpoint> {
     const endpoint = getDefaultSessionHostEndpoint(options.appName || 'adhdev');
-    if (await canConnect(endpoint)) return endpoint;
+    const requiredRequestTypes = options.requiredRequestTypes || [];
+    if (await canConnect(endpoint, requiredRequestTypes)) return endpoint;
     options.spawnHost();
-    await waitForReady(endpoint, options.timeoutMs);
+    await waitForReady(endpoint, options.timeoutMs, requiredRequestTypes);
     return endpoint;
 }