@adhdev/daemon-core 0.9.44 → 0.9.46

package/src/launch/macos-app-process.ts

@@ -0,0 +1,37 @@
+function normalizeMacAppPath(appPath: string): string | null {
+  const trimmed = String(appPath || '').trim()
+  if (!trimmed) return null
+  return trimmed.replace(/\/+$/, '')
+}
+
+function parsePsLine(line: string): { pid: number; args: string } | null {
+  const match = line.match(/^\s*(\d+)\s+(.+)$/)
+  if (!match) return null
+  const pid = Number.parseInt(match[1], 10)
+  if (!Number.isFinite(pid)) return null
+  return { pid, args: match[2] }
+}
+
+export function isMacAppProcessArgs(args: string, appPath: string): boolean {
+  const normalized = normalizeMacAppPath(appPath)
+  if (!normalized) return false
+  return String(args || '').startsWith(`${normalized}/`)
+}
+
+export function findMacAppProcessPids(psOutput: string, appPaths: readonly string[]): number[] {
+  const normalizedPaths = appPaths
+    .map(normalizeMacAppPath)
+    .filter((value): value is string => !!value)
+
+  if (normalizedPaths.length === 0) return []
+
+  const pids: number[] = []
+  for (const line of String(psOutput || '').split(/\r?\n/)) {
+    const parsed = parsePsLine(line)
+    if (!parsed) continue
+    if (normalizedPaths.some(appPath => isMacAppProcessArgs(parsed.args, appPath))) {
+      pids.push(parsed.pid)
+    }
+  }
+  return pids
+}

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, materializeProviderNativeHistory, readChatHistory, readProviderChatHistory } from '../config/chat-history.js';
 import { LOG } from '../logging/logger.js';
 import type { ChatMessage } from '../types.js';
 import { buildPersistedProviderEffectMessage, normalizeProviderEffects } from './control-effects.js';
@@ -179,11 +179,8 @@ export class CliProviderInstance implements ProviderInstance {
     private historyWriter: ChatHistoryWriter;
     private runtimeMessages: Array<{ key: string; message: ChatMessage }> = [];
     private lastPersistedHistoryMessages: PersistableCliHistoryMessage[] = [];
-    private lastCanonicalHermesSyncMtimeMs = 0;
-    private lastCanonicalHermesExistCheckAt = 0;
-    private lastCanonicalHermesWatchPath: string | undefined = undefined;
-    private lastCanonicalClaudeRebuildMtimeMs = 0;
-    private lastCanonicalClaudeCheckAt = 0;
+    private lastNativeSourceCanonicalCheckAt = 0;
+    private lastNativeSourceCanonicalCacheKey: string | undefined = undefined;
     private cachedSqliteDb: {
         prepare(sql: string): { get(...values: Array<string | number>): unknown };
         close(): void;
@@ -1047,46 +1044,48 @@ export class CliProviderInstance implements ProviderInstance {
         const canonicalHistory = this.provider.canonicalHistory;
         if (!canonicalHistory) return false;
 
+        if (isNativeSourceCanonicalHistory(canonicalHistory)) {
+            const cacheKey = [this.type, this.providerSessionId, this.workingDir].join('\0');
+            const now = Date.now();
+            if (cacheKey === this.lastNativeSourceCanonicalCacheKey && now - this.lastNativeSourceCanonicalCheckAt < 2_000) {
+                return true;
+            }
+            this.lastNativeSourceCanonicalCacheKey = cacheKey;
+            this.lastNativeSourceCanonicalCheckAt = now;
+
+            const restoredHistory = readProviderChatHistory(this.type, {
+                canonicalHistory,
+                historySessionId: this.providerSessionId,
+                workspace: this.workingDir,
+                offset: 0,
+                limit: Number.MAX_SAFE_INTEGER,
+                historyBehavior: this.provider.historyBehavior,
+                scripts: this.provider.scripts as any,
+            });
+            if (restoredHistory.source === 'provider-native') {
+                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') {
-                const watchPath = canonicalHistory.watchPath
-                    .replace(/^~/, os.homedir())
-                    .replace('{{sessionId}}', this.providerSessionId);
-                // Throttle existsSync: check file existence at most once per 2s
-                const now = Date.now();
-                if (watchPath !== this.lastCanonicalHermesWatchPath || now - this.lastCanonicalHermesExistCheckAt >= 2_000) {
-                    this.lastCanonicalHermesWatchPath = watchPath;
-                    this.lastCanonicalHermesExistCheckAt = now;
-                    if (!fs.existsSync(watchPath)) return false;
-                } else if (this.lastCanonicalHermesSyncMtimeMs === 0) {
-                    // First check: file existence not yet confirmed, must verify
-                    if (!fs.existsSync(watchPath)) return false;
-                }
-                const stat = fs.statSync(watchPath);
-                if (stat.mtimeMs <= this.lastCanonicalHermesSyncMtimeMs) return true;
-                rebuilt = rebuildHermesSavedHistoryFromCanonicalSession(this.providerSessionId);
-                if (rebuilt) this.lastCanonicalHermesSyncMtimeMs = stat.mtimeMs;
-            } else if (canonicalHistory.format === 'claude-jsonl') {
-                // Throttle: only check for changes at most once per 2s
-                const now = Date.now();
-                if (now - this.lastCanonicalClaudeCheckAt < 2_000 && this.lastCanonicalClaudeRebuildMtimeMs !== 0) {
-                    return true;
-                }
-                this.lastCanonicalClaudeCheckAt = now;
-                // Only rebuild if the transcript file has changed since last rebuild
-                const claudeProjectsDir = path.join(os.homedir(), '.claude', 'projects');
-                const workspaceSegment = typeof this.workingDir === 'string'
-                    ? this.workingDir.replace(/[\\/]/g, '-').replace(/^-+/, '')
-                    : '';
-                const transcriptFile = path.join(claudeProjectsDir, workspaceSegment, `${this.providerSessionId}.jsonl`);
-                let transcriptMtime = 0;
-                try { transcriptMtime = fs.statSync(transcriptFile).mtimeMs; } catch { /* not found yet */ }
-                if (transcriptMtime > 0 && transcriptMtime <= this.lastCanonicalClaudeRebuildMtimeMs) return true;
-                rebuilt = rebuildClaudeSavedHistoryFromNativeProject(this.providerSessionId, this.workingDir);
-                if (rebuilt) this.lastCanonicalClaudeRebuildMtimeMs = transcriptMtime || Date.now();
+            const cacheKey = [this.type, this.providerSessionId, this.workingDir, canonicalHistory.mode || 'materialized-mirror'].join('\0');
+            const now = Date.now();
+            if (cacheKey === this.lastNativeSourceCanonicalCacheKey && now - this.lastNativeSourceCanonicalCheckAt < 2_000) {
+                return true;
+            }
+            this.lastNativeSourceCanonicalCacheKey = cacheKey;
+            this.lastNativeSourceCanonicalCheckAt = now;
+
+            if (!materializeProviderNativeHistory(this.type, canonicalHistory, this.providerSessionId, this.workingDir, this.provider.scripts as any)) {
+                return false;
             }
-            if (!rebuilt) return false;
             const restoredHistory = readChatHistory(this.type, 0, Number.MAX_SAFE_INTEGER, this.providerSessionId, 0, this.provider.historyBehavior);
             this.lastPersistedHistoryMessages = restoredHistory.messages.map((message) => ({
                 role: message.role,
@@ -1104,8 +1103,20 @@ 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,
+                scripts: this.provider.scripts as any,
+            })
+            : (() => {
+                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[];
 }
 
@@ -599,23 +602,43 @@ export interface ProviderHistoryBehavior {
   requireStrictSessionIdFormat?: boolean;
 }
 
+/**
+ * Provider-owned native history script names.
+ *
+ * These functions live in the provider's versioned CLI script bundle, not in
+ * daemon-core. They let each provider own native transcript file discovery and
+ * parsing while daemon-core only validates/pages the normalized result.
+ */
+export interface ProviderCanonicalHistoryScriptsConfig {
+  /** Reads one native session. Default: 'readNativeHistory'. */
+  readSession?: string;
+  /** Lists native sessions with summary metadata. Default: 'listNativeHistory'. */
+  listSessions?: string;
+}
+
 /**
  * Canonical history sync config — for providers that maintain their own native history files.
- * When set, daemon syncs from the provider's native format into the ADHDev JSONL store.
- * Replaces hardcoded hermes-cli / claude-cli checks in cli-provider-instance.ts.
+ *
+ * Preferred mode is provider-owned scripts via `scripts`. `format` is now an
+ * opaque provider label retained for diagnostics/backward compatibility; daemon
+ * live paths must not branch on provider-specific format values.
  */
 export interface ProviderCanonicalHistoryConfig {
+  /** Opaque provider-owned history format label. */
+  format?: string;
+  /** Optional native history glob/template for diagnostics only. */
+  watchPath?: string;
+  /** Provider-owned script entry points for native transcript list/read. */
+  scripts?: ProviderCanonicalHistoryScriptsConfig;
   /**
-   * Native history format.
-   * - 'hermes-json': single JSON file per session (~/.hermes/sessions/session_{{sessionId}}.json)
-   * - 'claude-jsonl': JSONL transcript under ~/.claude/projects/
-   */
-  format: 'hermes-json' | 'claude-jsonl';
-  /**
-   * Path to the native history file. Supports ~ and {{sessionId}} placeholder.
-   * e.g. "~/.hermes/sessions/session_{{sessionId}}.json"
+   * 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'.
    */
-  watchPath: string;
+  mode?: 'native-source' | 'materialized-mirror' | 'disabled';
 }
 
 /**

package/src/providers/provider-schema.ts

@@ -123,6 +123,7 @@ export function validateProviderDefinition(raw: unknown): ProviderValidationResu
   }
 
   validateCapabilities(provider as unknown as ProviderModule, controls, errors)
+  validateCanonicalHistory(provider.canonicalHistory, errors)
 
   for (const control of controls) {
     validateControl(control as ProviderControlDef, errors)
@@ -192,6 +193,45 @@ function validateCapabilities(provider: ProviderModule, controls: ProviderContro
   }
 }
 
+function validateCanonicalHistory(raw: unknown, errors: string[]): void {
+  if (raw === undefined) return
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+    errors.push('canonicalHistory must be an object')
+    return
+  }
+
+  const canonicalHistory = raw as Record<string, unknown>
+  const format = canonicalHistory.format
+  if (format !== undefined && (typeof format !== 'string' || !format.trim())) {
+    errors.push('canonicalHistory.format must be a non-empty string when provided')
+  }
+
+  const watchPath = canonicalHistory.watchPath
+  if (watchPath !== undefined && (typeof watchPath !== 'string' || !watchPath.trim())) {
+    errors.push('canonicalHistory.watchPath must be a non-empty string when provided')
+  }
+
+  const mode = canonicalHistory.mode
+  if (mode !== undefined && !['native-source', 'materialized-mirror', 'disabled'].includes(String(mode))) {
+    errors.push('canonicalHistory.mode must be one of: native-source, materialized-mirror, disabled')
+  }
+
+  const scripts = canonicalHistory.scripts
+  if (scripts === undefined) return
+  if (!scripts || typeof scripts !== 'object' || Array.isArray(scripts)) {
+    errors.push('canonicalHistory.scripts must be an object')
+    return
+  }
+
+  const scriptConfig = scripts as Record<string, unknown>
+  for (const key of ['readSession', 'listSessions']) {
+    const value = scriptConfig[key]
+    if (typeof value !== 'string' || !value.trim()) {
+      errors.push(`canonicalHistory.scripts.${key} must be a non-empty string`)
+    }
+  }
+}
+
 function validateControl(control: ProviderControlDef, errors: string[]): void {
   if (!control || typeof control !== 'object') {
     errors.push('controls: each control must be an object')

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
 }