@adhdev/daemon-core 0.9.82-rc.49 → 0.9.82-rc.490

package/src/runtime-defaults.ts

@@ -14,3 +14,42 @@ export const DEFAULT_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS = 10_000;
 export const DEFAULT_SESSION_HOST_READY_TIMEOUT_MS = 15_000;
 
 export const STANDALONE_CDP_SCAN_INTERVAL_MS = 15_000;
+
+// ---------------------------------------------------------------------------
+// Mesh P2P timeout windows (env-overridable)
+// ---------------------------------------------------------------------------
+
+// Reads a mesh timeout (ms) from the first non-empty env var in `names`, clamped
+// to [1_000, 120_000]; falls back to `defaultMs` when none is set or the value is
+// out of range. The clamp lets a slow real link be tuned up (TURN-relayed peers
+// whose RTT is many seconds) and lets the test harness shrink the window to its
+// 1s minimum, without ever degenerating to 0 or an absurd value. Multiple names
+// are accepted so a renamed constant can keep honoring a legacy alias.
+export function readMeshTimeoutEnvMs(names: string | string[], defaultMs: number): number {
+    const candidates = Array.isArray(names) ? names : [names];
+    for (const name of candidates) {
+        const raw = process.env[name]?.trim();
+        if (!raw) continue;
+        const parsed = Number.parseInt(raw, 10);
+        if (Number.isFinite(parsed) && parsed >= 1_000 && parsed <= 120_000) return parsed;
+        return defaultMs;
+    }
+    return defaultMs;
+}
+
+// SINGLE source of truth for the mesh cold-open *connect* budget — the time a
+// caller grants a peer whose mesh DataChannel is not open yet to drive the
+// cross-machine (often TURN-relayed) ICE/DTLS handshake before the response
+// deadline takes over. Two call sites share this so an env override tunes BOTH:
+//   - commands/router.ts direct-peer git_status probe (requireDirectPeerTruth)
+//   - mesh/mesh-events-coordinator.ts remote task-dispatch (deliverTaskToSession)
+// Before unification the coordinator hard-coded 45_000 while the router was
+// env-overridable, so setting the env tuned the probe path but silently left the
+// dispatch path at 45s — the same nominal 45s, but divergent the moment the env
+// was set. Matches the daemon-cloud DaemonMeshManager CONNECT_TIMEOUT_MS (45s).
+// `MESH_DIRECT_PROBE_CONNECT_TIMEOUT_MS` is honored as a backward-compat alias so
+// environments already tuned under the old name keep working.
+export const MESH_CONNECT_TIMEOUT_MS = readMeshTimeoutEnvMs(
+    ['MESH_CONNECT_TIMEOUT_MS', 'MESH_DIRECT_PROBE_CONNECT_TIMEOUT_MS'],
+    45_000,
+);

package/src/session-host/managed-host.ts

@@ -0,0 +1,218 @@
+import { execFileSync, spawn, type StdioOptions } from 'child_process';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import {
+    getDefaultSessionHostEndpoint,
+    sanitizeSpawnEnv,
+    type SessionHostEndpoint,
+    type SessionHostRequestType,
+} from '@adhdev/session-host-core';
+import { ensureSessionHostReady as ensureSharedSessionHostReady } from './runtime-support.js';
+import { DEFAULT_SESSION_HOST_READY_TIMEOUT_MS } from '../runtime-defaults.js';
+
+/**
+ * Shared managed-session-host process helpers.
+ *
+ * The cloud (`packages/daemon-cloud`) and standalone (`oss/packages/daemon-standalone`)
+ * daemons carried byte-for-byte copies of `buildSessionHostEnv`, `resolveSessionHostEntry`,
+ * `getSessionHostPidFile`, `killPid`, a base `stopManagedSessionHostProcess`, and the
+ * `ensureSessionHostReady` retry-wrapper. Those live here now. The pieces that genuinely
+ * differ between the two daemons (kill windowsHide, quarantine preamble, spawn stdio,
+ * required request types, cloud's socket-owner sweep) are injected via options so the
+ * observable behavior of each daemon is preserved exactly.
+ */
+export interface ManagedSessionHostOptions {
+    /** Session-host namespace (app name). Drives the socket endpoint and pidfile path. */
+    appName: string;
+    /** Capability probe: request types the host must advertise before it's considered ready. */
+    requiredRequestTypes: readonly SessionHostRequestType[];
+    /** Ready timeout for the spawn/poll loop. Defaults to the shared runtime default. */
+    timeoutMs?: number;
+    /**
+     * `killPid` on win32 uses `taskkill /T /F`. Cloud passes `windowsHide: true`; standalone
+     * historically did not. Kept as a flag to preserve each daemon's exact spawn options.
+     */
+    killWindowsHide?: boolean;
+    /**
+     * How the detached host child's stdio is wired. 'ignore' matches standalone; 'logfile'
+     * matches cloud (append to `~/.adhdev/logs/session-host.log`).
+     */
+    spawnStdio?: 'ignore' | 'logfile';
+    /**
+     * Optional preamble run at the start of `ensureReady` (before the first connect probe).
+     * Cloud uses this to quarantine legacy standalone runtime files.
+     */
+    beforeEnsureReady?: () => void;
+    /**
+     * Optional extra stop pass appended to `stopManagedSessionHostProcess`. Cloud sweeps
+     * managed session-host processes that own the default socket but predate pidfile tracking.
+     * Returns true if it stopped anything.
+     */
+    extraStop?: (endpoint: SessionHostEndpoint) => boolean;
+    /**
+     * Optional guard applied to a pidfile-tracked pid before killing it in
+     * `stopManagedSessionHostProcess`. Cloud verifies the command line is an ADHDev
+     * session-host daemon; standalone kills unconditionally (returns true here).
+     */
+    isManagedPid?: (pid: number) => boolean;
+}
+
+export interface ManagedSessionHost {
+    readonly appName: string;
+    readonly endpoint: SessionHostEndpoint;
+    getPidFile(): string;
+    getPid(): number | null;
+    buildEnv(baseEnv: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+    resolveEntry(): string;
+    killPid(pid: number): boolean;
+    spawnHost(): void;
+    stopManagedSessionHostProcess(): boolean;
+    ensureReady(): Promise<SessionHostEndpoint>;
+    getStatusPaths(): { pidFile: string; endpoint: SessionHostEndpoint };
+}
+
+export function createManagedSessionHost(options: ManagedSessionHostOptions): ManagedSessionHost {
+    const appName = options.appName;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_SESSION_HOST_READY_TIMEOUT_MS;
+    const endpoint = getDefaultSessionHostEndpoint(appName);
+    const isManagedPid = options.isManagedPid ?? (() => true);
+
+    function buildEnv(baseEnv: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
+        const env = sanitizeSpawnEnv(baseEnv) as NodeJS.ProcessEnv;
+        env.ADHDEV_SESSION_HOST_NAME = appName;
+        return env;
+    }
+
+    function resolveEntry(): string {
+        const packagedCandidates = [
+            path.resolve(__dirname, '../vendor/session-host-daemon/index.js'),
+            path.resolve(__dirname, '../../vendor/session-host-daemon/index.js'),
+        ];
+        for (const candidate of packagedCandidates) {
+            if (fs.existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        return require.resolve('@adhdev/session-host-daemon');
+    }
+
+    function getPidFile(): string {
+        return path.join(os.homedir(), '.adhdev', `${appName}-session-host.pid`);
+    }
+
+    function getPid(): number | null {
+        try {
+            const pidFile = getPidFile();
+            if (!fs.existsSync(pidFile)) return null;
+            const pid = Number.parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
+            return Number.isFinite(pid) ? pid : null;
+        } catch {
+            return null;
+        }
+    }
+
+    function killPid(pid: number): boolean {
+        try {
+            if (process.platform === 'win32') {
+                const spawnOpts: { stdio: 'ignore'; windowsHide?: boolean } = { stdio: 'ignore' };
+                if (options.killWindowsHide) spawnOpts.windowsHide = true;
+                execFileSync('taskkill', ['/PID', String(pid), '/T', '/F'], spawnOpts);
+            } else {
+                process.kill(pid, 'SIGTERM');
+            }
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    function spawnHost(): void {
+        const entry = resolveEntry();
+        let stdio: StdioOptions = 'ignore';
+        let logFd: number | null = null;
+        if (options.spawnStdio === 'logfile') {
+            const logDir = path.join(os.homedir(), '.adhdev', 'logs');
+            fs.mkdirSync(logDir, { recursive: true });
+            logFd = fs.openSync(path.join(logDir, 'session-host.log'), 'a');
+            stdio = ['ignore', logFd, logFd];
+        }
+        const child = spawn(process.execPath, [entry], {
+            detached: true,
+            stdio,
+            windowsHide: true,
+            env: buildEnv(process.env),
+        });
+        child.unref();
+        if (logFd !== null) {
+            try { fs.closeSync(logFd); } catch { /* noop */ }
+        }
+    }
+
+    function stopManagedSessionHostProcess(): boolean {
+        let stopped = false;
+        const pidFile = getPidFile();
+        try {
+            if (fs.existsSync(pidFile)) {
+                const pid = Number.parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
+                if (Number.isFinite(pid) && pid !== process.pid && isManagedPid(pid)) {
+                    stopped = killPid(pid) || stopped;
+                }
+            }
+        } catch {
+            // noop
+        } finally {
+            try {
+                fs.unlinkSync(pidFile);
+            } catch {
+                // noop
+            }
+        }
+
+        if (options.extraStop) {
+            stopped = options.extraStop(endpoint) || stopped;
+        }
+
+        return stopped;
+    }
+
+    async function ensureReady(): Promise<SessionHostEndpoint> {
+        options.beforeEnsureReady?.();
+        try {
+            return await ensureSharedSessionHostReady({
+                appName,
+                spawnHost,
+                timeoutMs,
+                requiredRequestTypes: options.requiredRequestTypes,
+            });
+        } catch (error) {
+            stopManagedSessionHostProcess();
+            return ensureSharedSessionHostReady({
+                appName,
+                spawnHost,
+                timeoutMs,
+                requiredRequestTypes: options.requiredRequestTypes,
+            }).catch((retryError) => {
+                const initialMessage = error instanceof Error ? error.message : String(error);
+                const retryMessage = retryError instanceof Error ? retryError.message : String(retryError);
+                throw new Error(`Session host failed to start after retry (${initialMessage}; retry: ${retryMessage})`);
+            });
+        }
+    }
+
+    return {
+        appName,
+        endpoint,
+        getPidFile,
+        getPid,
+        buildEnv,
+        resolveEntry,
+        killPid,
+        spawnHost,
+        stopManagedSessionHostProcess,
+        ensureReady,
+        getStatusPaths() {
+            return { pidFile: getPidFile(), endpoint };
+        },
+    };
+}

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

@@ -1,80 +1,20 @@
-import type { SessionHostRecord } from '../shared-types.js';
-
-export type SessionHostSurfaceKind = 'live_runtime' | 'recovery_snapshot' | 'inactive_record';
-
-export interface SessionHostSurfaceRecordLike {
-    lifecycle?: string | null;
-    meta?: Record<string, unknown> | null;
-}
-
-const LIVE_LIFECYCLES = new Set(['starting', 'running', 'stopping', 'interrupted']);
-
-export function isSessionHostLiveRuntime(record: SessionHostSurfaceRecordLike | null | undefined): boolean {
-    const lifecycle = String(record?.lifecycle || '').trim();
-    return LIVE_LIFECYCLES.has(lifecycle);
-}
-
-export function getSessionHostRecoveryLabel(meta: Record<string, unknown> | null | undefined): string | null {
-    const recoveryState = typeof meta?.runtimeRecoveryState === 'string'
-        ? String(meta.runtimeRecoveryState).trim()
-        : '';
-    if (!recoveryState) return null;
-    if (recoveryState === 'auto_resumed') return 'restored after restart';
-    if (recoveryState === 'resume_failed') return 'restore failed';
-    if (recoveryState === 'host_restart_interrupted') return 'host restart interrupted';
-    if (recoveryState === 'orphan_snapshot') return 'snapshot recovered';
-    return recoveryState.replace(/_/g, ' ');
-}
-
-export function isSessionHostRecoverySnapshot(record: SessionHostSurfaceRecordLike | null | undefined): boolean {
-    if (!record) return false;
-    if (isSessionHostLiveRuntime(record)) return false;
-
-    const lifecycle = String(record.lifecycle || '').trim();
-    if (lifecycle && lifecycle !== 'stopped' && lifecycle !== 'failed') {
-        return false;
-    }
-
-    const meta = record.meta || undefined;
-    if (meta?.restoredFromStorage === true) return true;
-    return getSessionHostRecoveryLabel(meta) !== null;
-}
-
-export function getSessionHostSurfaceKind(record: SessionHostSurfaceRecordLike | null | undefined): SessionHostSurfaceKind {
-    if (isSessionHostLiveRuntime(record)) return 'live_runtime';
-    if (isSessionHostRecoverySnapshot(record)) return 'recovery_snapshot';
-    return 'inactive_record';
-}
-
-export function partitionSessionHostRecords<T extends SessionHostSurfaceRecordLike>(records: T[]): {
-    liveRuntimes: T[];
-    recoverySnapshots: T[];
-    inactiveRecords: T[];
-} {
-    const liveRuntimes: T[] = [];
-    const recoverySnapshots: T[] = [];
-    const inactiveRecords: T[] = [];
-
-    for (const record of records) {
-        const kind = getSessionHostSurfaceKind(record);
-        if (kind === 'live_runtime') {
-            liveRuntimes.push(record);
-        } else if (kind === 'recovery_snapshot') {
-            recoverySnapshots.push(record);
-        } else {
-            inactiveRecords.push(record);
-        }
-    }
-
-    return {
-        liveRuntimes,
-        recoverySnapshots,
-        inactiveRecords,
-    };
-}
-
-export function partitionSessionHostDiagnosticsSessions(
-    records: SessionHostRecord[] | null | undefined,
-): ReturnType<typeof partitionSessionHostRecords<SessionHostRecord>> {
-    return partitionSessionHostRecords(records || []);
-}
+/**
+ * Session-host runtime-surface helpers.
+ *
+ * These classification helpers (live_runtime / recovery_snapshot / inactive_record)
+ * are owned by @adhdev/session-host-core as the single source of truth. daemon-core
+ * re-exports them so consumers can keep importing from this path while the behavior
+ * (including the `record.surfaceKind` short-circuit) stays identical across packages.
+ */
+export {
+    getSessionHostRecoveryLabel,
+    getSessionHostSurfaceKind,
+    isSessionHostLiveRuntime,
+    isSessionHostRecoverySnapshot,
+    partitionSessionHostDiagnosticsSessions,
+    partitionSessionHostRecords,
+} from '@adhdev/session-host-core';
+export type {
+    SessionHostSurfaceKind,
+    SessionHostSurfaceRecordLike,
+} from '@adhdev/session-host-core';

package/src/sessions/registry.ts

@@ -8,6 +8,25 @@ export interface SessionRuntimeTarget {
     cdpManagerKey?: string;
     adapterKey?: string;
     instanceKey?: string;
+    /** Working directory for CLI/ACP sessions. Used by read_chat to resolve
+     *  native history when there is no live adapter (e.g. subscription path). */
+    workspace?: 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;
+    /**
+     * Authoritative provider-native conversation id for this session (SSOT).
+     * For providers that expose a session id on the CLI (codex/claude/hermes)
+     * this equals that id. For antigravity — which takes no --session-id — this
+     * is the on-disk conversations/<uuid>.db basename, discovered by the
+     * native-history dispatcher and written back here via setProviderSessionId
+     * the first time it resolves. Every downstream reader (read_chat, the
+     * completion probe, the dashboard) should prefer this over re-deriving the
+     * conversation by spawn-floor/mtime heuristics — that re-derivation is the
+     * source of the antigravity conversation crosswire/theft class. Empty until
+     * the first successful native read binds it.
+     */
+    providerSessionId?: string;
 }
 
 export class SessionRegistry {
@@ -17,7 +36,15 @@ export class SessionRegistry {
     private readonly byParentSessionId = new Map<string, Set<string>>();
 
     register(target: SessionRuntimeTarget): void {
+        // Preserve an already-resolved conversation binding across a
+        // re-register (attach-restore, meta refresh): the caller rarely knows
+        // the antigravity conv uuid at register time, so a plain replace would
+        // drop the SSOT binding and force a fresh (crosswire-prone) re-resolve.
+        const priorProviderSessionId = this.bySessionId.get(target.sessionId)?.providerSessionId;
         this.unregister(target.sessionId);
+        if (priorProviderSessionId && !target.providerSessionId) {
+            target = { ...target, providerSessionId: priorProviderSessionId };
+        }
         this.bySessionId.set(target.sessionId, target);
         if (target.cdpManagerKey) this.addIndex(this.byManagerKey, target.cdpManagerKey, target.sessionId);
         if (target.instanceKey) this.addIndex(this.byInstanceKey, target.instanceKey, target.sessionId);
@@ -29,6 +56,23 @@ export class SessionRegistry {
         return this.bySessionId.get(sessionId);
     }
 
+    /**
+     * Record the authoritative provider-native conversation id for a session
+     * (SSOT). Idempotent; a no-op when the session is unknown or the value is
+     * empty or unchanged. Never overwrites a known binding with an empty one.
+     * Returns whether the stored value changed.
+     */
+    setProviderSessionId(sessionId: string | undefined | null, providerSessionId: string | undefined | null): boolean {
+        const sid = typeof sessionId === 'string' ? sessionId.trim() : '';
+        const value = typeof providerSessionId === 'string' ? providerSessionId.trim() : '';
+        if (!sid || !value) return false;
+        const target = this.bySessionId.get(sid);
+        if (!target) return false;
+        if (target.providerSessionId === value) return false;
+        target.providerSessionId = value;
+        return true;
+    }
+
     unregister(sessionId: string | undefined | null): void {
         if (!sessionId) return;
         const target = this.bySessionId.get(sessionId);

package/src/shared-types-extra.ts

@@ -21,14 +21,12 @@ export interface RuntimeAttachedClient {
 }
 
 /** Session status union (used by SessionEntry.status, legacy recent-launch metadata, etc.) */
-export type SessionStatus = 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting' | 'panel_hidden' | 'not_monitored' | 'disconnected';
+export type SessionStatus = 'idle' | 'generating' | 'waiting_approval' | 'waiting_choice' | 'error' | 'stopped' | 'starting' | 'panel_hidden' | 'not_monitored' | 'disconnected';
 
 /** Inbox bucket categories for recent sessions */
 export type RecentSessionBucket = 'needs_attention' | 'working' | 'task_complete' | 'idle';
 
 /** Terminal backend status */
 export interface TerminalBackendStatus {
-    backend: 'xterm' | 'ghostty-vt';
-    preference: 'auto' | 'xterm' | 'ghostty-vt';
-    ghosttyAvailable: boolean;
+    backend: 'ghostty-vt';
 }

package/src/shared-types.d.ts

@@ -206,6 +206,14 @@ export interface SessionEntry {
     completionMarker?: string;
     seenCompletionMarker?: string;
     surfaceHidden?: boolean;
+    /**
+     * True owning-daemon id for a session a coordinator synthesises into its own
+     * status snapshot (mesh delegated sessions), so the dashboard attributes it to the
+     * worker node instead of the coordinator daemon hosting the snapshot.
+     */
+    ownerDaemonId?: string;
+    /** True owning-machine display name fallback when the owning daemon is not aggregated. */
+    ownerMachineName?: string;
 }
 /**
  * Compact session metadata stored in UserSessionDO and reused by server-side