@adhdev/daemon-core 0.9.45 → 0.9.47

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, isNativeSourceCanonicalHistory, readChatHistory, readProviderChatHistory, rebuildClaudeSavedHistoryFromNativeProject, rebuildCodexSavedHistoryFromNativeSession, rebuildHermesSavedHistoryFromCanonicalSession, resolveCodexSessionTranscriptPath } 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,13 +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 lastCanonicalCodexRebuildMtimeMs = 0;
-    private lastCanonicalCodexCheckAt = 0;
+    private lastNativeSourceCanonicalCheckAt = 0;
+    private lastNativeSourceCanonicalCacheKey: string | undefined = undefined;
     private cachedSqliteDb: {
         prepare(sql: string): { get(...values: Array<string | number>): unknown };
         close(): void;
@@ -1050,6 +1045,14 @@ export class CliProviderInstance implements ProviderInstance {
         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,
@@ -1057,74 +1060,32 @@ export class CliProviderInstance implements ProviderInstance {
                 offset: 0,
                 limit: Number.MAX_SAFE_INTEGER,
                 historyBehavior: this.provider.historyBehavior,
+                scripts: this.provider.scripts as any,
             });
-            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,
-            }));
+            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();
-            } 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();
+            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,
@@ -1150,6 +1111,7 @@ export class CliProviderInstance implements ProviderInstance {
                 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);

package/src/providers/contracts.ts

@@ -602,24 +602,34 @@ 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 {
-  /**
-   * 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' | 'codex-jsonl';
-  /**
-   * Path to the native history file. Supports ~ and {{sessionId}} placeholder.
-   * e.g. "~/.hermes/sessions/session_{{sessionId}}.json"
-   */
-  watchPath: string;
+  /** 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;
   /**
    * How ADHDev should use native history.
    * - 'native-source': provider-native files are canonical; ADHDev reads them directly and keeps only in-memory/thin projections.

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')