@adhdev/daemon-core 0.9.44 → 0.9.45

package/src/launch.ts

@@ -24,6 +24,7 @@ import { detectIDEs } from './detection/ide-detector.js';
 import { IDEInfo } from './detection/ide-detector.js';
 import { ProviderLoader } from './providers/provider-loader.js';
 import type { ProviderModule } from './providers/contracts.js';
+import { findMacAppProcessPids } from './launch/macos-app-process.js';
 
 // ─── Provider-based dynamic IDE infrastructure ────────────────
 // Reads cdpPorts, processNames from provider.js — only create provider.js to add new IDE
@@ -71,6 +72,37 @@ function escapeForAppleScript(value: string): string {
     return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
 }
 
+function getIdePathCandidates(ideId: string): string[] {
+    return getProviderLoader().getIdePathCandidates(ideId);
+}
+
+function getMacAppProcessPids(ideId: string): number[] {
+    const appPaths = getIdePathCandidates(ideId);
+    if (appPaths.length === 0) return [];
+    try {
+        const output = execSync('ps axww -o pid=,args=', {
+            encoding: 'utf-8',
+            timeout: 3000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return findMacAppProcessPids(output, appPaths);
+    } catch {
+        return [];
+    }
+}
+
+function killMacAppPathProcesses(ideId: string, signal: NodeJS.Signals): boolean {
+    const pids = getMacAppProcessPids(ideId);
+    let signalled = false;
+    for (const pid of pids) {
+        try {
+            process.kill(pid, signal);
+            signalled = true;
+        } catch { }
+    }
+    return signalled;
+}
+
 // ─── Helpers ────────────────────────────────────
 
 /** Find available port (primary → secondary → sequential after) */
@@ -137,6 +169,7 @@ export async function killIdeProcess(ideId: string): Promise<boolean> {
             } catch {
                 try { execSync(`pkill -x "${appName}" 2>/dev/null`, { timeout: 5000 }); } catch { }
             }
+            killMacAppPathProcesses(ideId, 'SIGTERM');
         } else if (plat === 'win32' && winProcesses) {
  // Windows: taskkill for each process name
             for (const proc of winProcesses) {
@@ -164,6 +197,7 @@ export async function killIdeProcess(ideId: string): Promise<boolean> {
  // Force terminate retry
         if (plat === 'darwin' && appName) {
             try { execSync(`pkill -9 -x "${appName}" 2>/dev/null`, { timeout: 5000 }); } catch { }
+            killMacAppPathProcesses(ideId, 'SIGKILL');
         } else if (plat === 'win32' && winProcesses) {
             for (const proc of winProcesses) {
                 try { execSync(`taskkill /IM "${proc}" /F 2>nul`); } catch { }
@@ -185,14 +219,16 @@ export function isIdeRunning(ideId: string): boolean {
     try {
         if (plat === 'darwin') {
             const appName = getMacAppIdentifiers()[ideId];
-            if (!appName) return false;
+            if (!appName) return getMacAppProcessPids(ideId).length > 0;
             try {
                 const result = execSync(`pgrep -x "${appName}" 2>/dev/null`, {
                     encoding: 'utf-8',
                     timeout: 3000,
                 });
-                return result.trim().length > 0;
-            } catch {
+                if (result.trim().length > 0) return true;
+            } catch { }
+
+            try {
                 const result = execSync(
                     `osascript -e 'tell application "System Events" to count (every process whose name is "${escapeForAppleScript(appName)}")'`,
                     {
@@ -201,8 +237,10 @@ export function isIdeRunning(ideId: string): boolean {
                         stdio: ['pipe', 'pipe', 'pipe'],
                     },
                 );
-                return Number.parseInt(result.trim() || '0', 10) > 0;
-            }
+                if (Number.parseInt(result.trim() || '0', 10) > 0) return true;
+            } catch { }
+
+            return getMacAppProcessPids(ideId).length > 0;
         } else if (plat === 'win32') {
             const winProcesses = getWinProcessNames()[ideId];
             if (!winProcesses) return false;

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

@@ -17,7 +17,7 @@ import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
 import type { CliProviderModule } from '../cli-adapters/provider-cli-adapter.js';
 import type { PtyRuntimeMetadata, PtyTransportFactory } from '../cli-adapters/pty-transport.js';
 import { StatusMonitor } from './status-monitor.js';
-import { ChatHistoryWriter, readChatHistory, rebuildClaudeSavedHistoryFromNativeProject, rebuildHermesSavedHistoryFromCanonicalSession } from '../config/chat-history.js';
+import { ChatHistoryWriter, isNativeSourceCanonicalHistory, readChatHistory, readProviderChatHistory, rebuildClaudeSavedHistoryFromNativeProject, rebuildCodexSavedHistoryFromNativeSession, rebuildHermesSavedHistoryFromCanonicalSession, resolveCodexSessionTranscriptPath } from '../config/chat-history.js';
 import { LOG } from '../logging/logger.js';
 import type { ChatMessage } from '../types.js';
 import { buildPersistedProviderEffectMessage, normalizeProviderEffects } from './control-effects.js';
@@ -184,6 +184,8 @@ export class CliProviderInstance implements ProviderInstance {
     private lastCanonicalHermesWatchPath: string | undefined = undefined;
     private lastCanonicalClaudeRebuildMtimeMs = 0;
     private lastCanonicalClaudeCheckAt = 0;
+    private lastCanonicalCodexRebuildMtimeMs = 0;
+    private lastCanonicalCodexCheckAt = 0;
     private cachedSqliteDb: {
         prepare(sql: string): { get(...values: Array<string | number>): unknown };
         close(): void;
@@ -1047,6 +1049,26 @@ export class CliProviderInstance implements ProviderInstance {
         const canonicalHistory = this.provider.canonicalHistory;
         if (!canonicalHistory) return false;
 
+        if (isNativeSourceCanonicalHistory(canonicalHistory)) {
+            const restoredHistory = readProviderChatHistory(this.type, {
+                canonicalHistory,
+                historySessionId: this.providerSessionId,
+                workspace: this.workingDir,
+                offset: 0,
+                limit: Number.MAX_SAFE_INTEGER,
+                historyBehavior: this.provider.historyBehavior,
+            });
+            if (restoredHistory.source !== 'provider-native') return false;
+            this.lastPersistedHistoryMessages = restoredHistory.messages.map((message) => ({
+                role: message.role,
+                content: message.content,
+                kind: message.kind,
+                senderName: message.senderName,
+                receivedAt: message.receivedAt,
+            }));
+            return true;
+        }
+
         try {
             let rebuilt = false;
             if (canonicalHistory.format === 'hermes-json') {
@@ -1085,6 +1107,22 @@ export class CliProviderInstance implements ProviderInstance {
                 if (transcriptMtime > 0 && transcriptMtime <= this.lastCanonicalClaudeRebuildMtimeMs) return true;
                 rebuilt = rebuildClaudeSavedHistoryFromNativeProject(this.providerSessionId, this.workingDir);
                 if (rebuilt) this.lastCanonicalClaudeRebuildMtimeMs = transcriptMtime || Date.now();
+            } else if (canonicalHistory.format === 'codex-jsonl') {
+                // Codex stores rollout transcripts under ~/.codex/sessions/YYYY/MM/DD/.
+                // Resolving requires a recursive lookup, so throttle the probe like Claude.
+                const now = Date.now();
+                if (now - this.lastCanonicalCodexCheckAt < 2_000 && this.lastCanonicalCodexRebuildMtimeMs !== 0) {
+                    return true;
+                }
+                this.lastCanonicalCodexCheckAt = now;
+                const transcriptFile = resolveCodexSessionTranscriptPath(this.providerSessionId, this.workingDir);
+                let transcriptMtime = 0;
+                if (transcriptFile) {
+                    try { transcriptMtime = fs.statSync(transcriptFile).mtimeMs; } catch { /* not found yet */ }
+                }
+                if (transcriptMtime > 0 && transcriptMtime <= this.lastCanonicalCodexRebuildMtimeMs) return true;
+                rebuilt = rebuildCodexSavedHistoryFromNativeSession(this.providerSessionId, this.workingDir);
+                if (rebuilt) this.lastCanonicalCodexRebuildMtimeMs = transcriptMtime || Date.now();
             }
             if (!rebuilt) return false;
             const restoredHistory = readChatHistory(this.type, 0, Number.MAX_SAFE_INTEGER, this.providerSessionId, 0, this.provider.historyBehavior);
@@ -1104,8 +1142,19 @@ export class CliProviderInstance implements ProviderInstance {
     private restorePersistedHistoryFromCurrentSession(): void {
         if (!this.providerSessionId) return;
         this.syncCanonicalSavedHistoryIfNeeded();
-        this.historyWriter.compactHistorySession(this.type, this.providerSessionId, this.provider.historyBehavior);
-        const restoredHistory = readChatHistory(this.type, 0, Number.MAX_SAFE_INTEGER, this.providerSessionId, 0, this.provider.historyBehavior);
+        const restoredHistory = isNativeSourceCanonicalHistory(this.provider.canonicalHistory)
+            ? readProviderChatHistory(this.type, {
+                canonicalHistory: this.provider.canonicalHistory,
+                historySessionId: this.providerSessionId,
+                workspace: this.workingDir,
+                offset: 0,
+                limit: Number.MAX_SAFE_INTEGER,
+                historyBehavior: this.provider.historyBehavior,
+            })
+            : (() => {
+                this.historyWriter.compactHistorySession(this.type, this.providerSessionId!, this.provider.historyBehavior);
+                return readChatHistory(this.type, 0, Number.MAX_SAFE_INTEGER, this.providerSessionId, 0, this.provider.historyBehavior);
+            })();
         this.historyWriter.seedSessionHistory(
             this.type,
             restoredHistory.messages,

package/src/providers/contracts.ts

@@ -36,7 +36,10 @@ export interface ReadChatResult {
   controlValues?: Record<string, string | number | boolean>;
   /** Flexible always-visible metadata for compact/live surfaces. */
   summaryMetadata?: ProviderSummaryMetadata;
-/** Provider-driven UI effects derived from chat state */
+  /** Provider-owned transcript authority/coverage hints for daemon/dashboard sync. */
+  transcriptAuthority?: 'provider' | 'daemon';
+  coverage?: 'full' | 'tail' | 'current-turn';
+  /** Provider-driven UI effects derived from chat state */
   effects?: ProviderEffect[];
 }
 
@@ -609,13 +612,23 @@ export interface ProviderCanonicalHistoryConfig {
    * Native history format.
    * - 'hermes-json': single JSON file per session (~/.hermes/sessions/session_{{sessionId}}.json)
    * - 'claude-jsonl': JSONL transcript under ~/.claude/projects/
+   * - 'codex-jsonl': rollout JSONL transcript under ~/.codex/sessions/YYYY/MM/DD/
    */
-  format: 'hermes-json' | 'claude-jsonl';
+  format: 'hermes-json' | 'claude-jsonl' | 'codex-jsonl';
   /**
    * Path to the native history file. Supports ~ and {{sessionId}} placeholder.
    * e.g. "~/.hermes/sessions/session_{{sessionId}}.json"
    */
   watchPath: string;
+  /**
+   * How ADHDev should use native history.
+   * - 'native-source': provider-native files are canonical; ADHDev reads them directly and keeps only in-memory/thin projections.
+   * - 'materialized-mirror': transitional compatibility mode; native files are rewritten into ~/.adhdev/history before read/list.
+   * - 'disabled': ignore native history and use ADHDev mirror only.
+   *
+   * Omitted mode defaults to 'native-source'.
+   */
+  mode?: 'native-source' | 'materialized-mirror' | 'disabled';
 }
 
 /**

package/src/providers/read-chat-contract.ts

@@ -154,6 +154,8 @@ export function validateReadChatResultPayload(raw: unknown, source = 'read_chat'
   if (raw.summaryMetadata !== undefined) normalized.summaryMetadata = raw.summaryMetadata as any
   if (Array.isArray(raw.effects)) normalized.effects = raw.effects as any
   if (typeof raw.providerSessionId === 'string') normalized.providerSessionId = raw.providerSessionId
+  if (raw.transcriptAuthority === 'provider' || raw.transcriptAuthority === 'daemon') normalized.transcriptAuthority = raw.transcriptAuthority
+  if (raw.coverage === 'full' || raw.coverage === 'tail' || raw.coverage === 'current-turn') normalized.coverage = raw.coverage
 
   return normalized
 }