@adhdev/daemon-core 0.9.4 → 0.9.6

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

@@ -161,6 +161,16 @@ export class CliProviderInstance implements ProviderInstance {
     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 cachedSqliteDb: {
+        prepare(sql: string): { get(...values: Array<string | number>): unknown };
+        close(): void;
+    } | null = null;
+    private cachedSqliteDbPath: string | null = null;
+    private cachedSqliteDbMissingUntil = 0;
     readonly instanceId: string;
     private suppressIdleHistoryReplay = false;
     private errorMessage: string | undefined = undefined;
@@ -260,37 +270,12 @@ export class CliProviderInstance implements ProviderInstance {
 
     async onTick(): Promise<void> {
         if (this.providerSessionId) return;
-        if (this.type === 'hermes-cli' && this.launchMode === 'new') return;
+        if (this.provider.resume?.skipProbeOnNewSession && this.launchMode === 'new') return;
 
-        let probedSessionId: string | null = null;
-
-        // Prefer declarative probe from provider.json schema
         const probeConfig = this.provider.sessionProbe;
-        if (probeConfig) {
-            probedSessionId = this.probeSessionIdFromConfig(probeConfig);
-        } else {
-            // Legacy hardcoded probes (backward compat until providers migrate)
-            if (this.type === 'opencode-cli') {
-                probedSessionId = this.probeSessionIdFromConfig({
-                    dbPath: '~/.local/share/opencode/opencode.db',
-                    query: 'select id from session where directory in ({dirs}) and time_created >= ? and time_archived is null order by time_updated desc limit 1',
-                    timestampFormat: 'unix_ms',
-                });
-            } else if (this.type === 'codex-cli') {
-                probedSessionId = this.probeSessionIdFromConfig({
-                    dbPath: '~/.codex/state_5.sqlite',
-                    query: 'select id from threads where cwd in ({dirs}) and updated_at >= ? and archived = 0 order by updated_at desc limit 1',
-                    timestampFormat: 'unix_s',
-                });
-            } else if (this.type === 'goose-cli') {
-                probedSessionId = this.probeSessionIdFromConfig({
-                    dbPath: '~/.local/share/goose/sessions/sessions.db',
-                    query: 'select id from sessions where working_dir in ({dirs}) and created_at >= ? order by updated_at desc limit 1',
-                    timestampFormat: 'iso',
-                });
-            }
-        }
+        if (!probeConfig) return;
 
+        const probedSessionId = this.probeSessionIdFromConfig(probeConfig);
         if (probedSessionId) {
             this.promoteProviderSessionId(probedSessionId);
         }
@@ -306,7 +291,13 @@ export class CliProviderInstance implements ProviderInstance {
         timestampFormat?: 'unix_ms' | 'unix_s' | 'iso';
     }): string | null {
         const resolvedDbPath = probe.dbPath.replace(/^~/, os.homedir());
-        if (!fs.existsSync(resolvedDbPath)) return null;
+        // Skip existsSync if we already confirmed DB is missing (cache for 10s)
+        const now = Date.now();
+        if (this.cachedSqliteDbMissingUntil > now) return null;
+        if (!fs.existsSync(resolvedDbPath)) {
+            this.cachedSqliteDbMissingUntil = now + 10_000;
+            return null;
+        }
 
         const directories = this.getProbeDirectories();
         const minCreatedAt = Math.max(0, this.startedAt - 60_000);
@@ -355,7 +346,7 @@ export class CliProviderInstance implements ProviderInstance {
             ? 'error'
             : (autoApproveActive ? 'generating' : adapterStatus.status);
         const parsedProviderSessionId = normalizeProviderSessionId(
-            this.type,
+            this.provider,
             typeof parsedStatus?.providerSessionId === 'string' ? parsedStatus.providerSessionId : '',
         );
         if (parsedProviderSessionId) {
@@ -511,6 +502,9 @@ export class CliProviderInstance implements ProviderInstance {
         this.adapter.shutdown();
         this.monitor.reset();
         this.appliedEffectKeys.clear();
+        try { this.cachedSqliteDb?.close(); } catch { /* noop */ }
+        this.cachedSqliteDb = null;
+        this.cachedSqliteDbPath = null;
     }
 
     private completedDebounceTimer: NodeJS.Timeout | null = null;
@@ -684,7 +678,7 @@ export class CliProviderInstance implements ProviderInstance {
         if (!data || typeof data !== 'object') return;
 
         const patchedProviderSessionId = normalizeProviderSessionId(
-            this.type,
+            this.provider,
             typeof data.providerSessionId === 'string' ? data.providerSessionId : '',
         );
         if (patchedProviderSessionId) {
@@ -960,53 +954,68 @@ export class CliProviderInstance implements ProviderInstance {
 
     private syncCanonicalSavedHistoryIfNeeded(): boolean {
         if (!this.providerSessionId) return false;
-        if (this.type === 'hermes-cli') {
-            try {
-                const canonicalPath = path.join(os.homedir(), '.hermes', 'sessions', `session_${this.providerSessionId}.json`);
-                if (!fs.existsSync(canonicalPath)) return false;
-                const stat = fs.statSync(canonicalPath);
+        const canonicalHistory = this.provider.canonicalHistory;
+        if (!canonicalHistory) return false;
+
+        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;
-                const rebuilt = rebuildHermesSavedHistoryFromCanonicalSession(this.providerSessionId);
-                if (!rebuilt) return false;
-                this.lastCanonicalHermesSyncMtimeMs = stat.mtimeMs;
-                const restoredHistory = readChatHistory(this.type, 0, Number.MAX_SAFE_INTEGER, this.providerSessionId);
-                this.lastPersistedHistoryMessages = restoredHistory.messages.map((message) => ({
-                    role: message.role,
-                    content: message.content,
-                    kind: message.kind,
-                    senderName: message.senderName,
-                    receivedAt: message.receivedAt,
-                }));
-                return true;
-            } catch {
-                return false;
-            }
-        }
-        if (this.type === 'claude-cli') {
-            try {
-                const rebuilt = rebuildClaudeSavedHistoryFromNativeProject(this.providerSessionId, this.workingDir);
-                if (!rebuilt) return false;
-                const restoredHistory = readChatHistory(this.type, 0, Number.MAX_SAFE_INTEGER, this.providerSessionId);
-                this.lastPersistedHistoryMessages = restoredHistory.messages.map((message) => ({
-                    role: message.role,
-                    content: message.content,
-                    kind: message.kind,
-                    senderName: message.senderName,
-                    receivedAt: message.receivedAt,
-                }));
-                return true;
-            } catch {
-                return false;
+                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();
             }
+            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,
+                content: message.content,
+                kind: message.kind,
+                senderName: message.senderName,
+                receivedAt: message.receivedAt,
+            }));
+            return true;
+        } catch {
+            return false;
         }
-        return false;
     }
 
     private restorePersistedHistoryFromCurrentSession(): void {
         if (!this.providerSessionId) return;
         this.syncCanonicalSavedHistoryIfNeeded();
-        this.historyWriter.compactHistorySession(this.type, this.providerSessionId);
-        const restoredHistory = readChatHistory(this.type, 0, Number.MAX_SAFE_INTEGER, this.providerSessionId);
+        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);
         this.historyWriter.seedSessionHistory(
             this.type,
             restoredHistory.messages,
@@ -1058,24 +1067,24 @@ export class CliProviderInstance implements ProviderInstance {
     }
 
     private querySqliteText(dbPath: string, query: string, params: Array<string | number>): string | null {
-        let db: {
-            prepare(sql: string): { get(...values: Array<string | number>): unknown };
-            close(): void;
-        } | null = null;
         try {
-            const DatabaseSync = getDatabaseSync();
-            db = new DatabaseSync(dbPath, { readOnly: true });
-            const row = db.prepare(query).get(...params) as { id?: unknown } | undefined;
+            if (this.cachedSqliteDb === null || this.cachedSqliteDbPath !== dbPath) {
+                try { this.cachedSqliteDb?.close(); } catch { /* noop */ }
+                this.cachedSqliteDb = null;
+                this.cachedSqliteDbPath = null;
+                const DatabaseSync = getDatabaseSync();
+                this.cachedSqliteDb = new DatabaseSync(dbPath, { readOnly: true });
+                this.cachedSqliteDbPath = dbPath;
+            }
+            const row = this.cachedSqliteDb!.prepare(query).get(...params) as { id?: unknown } | undefined;
             const sessionId = typeof row?.id === 'string' ? row.id.trim() : '';
             return sessionId || null;
         } catch {
+            // Close cached connection on error so we retry fresh next tick
+            try { this.cachedSqliteDb?.close(); } catch { /* noop */ }
+            this.cachedSqliteDb = null;
+            this.cachedSqliteDbPath = null;
             return null;
-        } finally {
-            try {
-                db?.close();
-            } catch {
-                // noop
-            }
         }
     }
 }

package/src/providers/contracts.ts

@@ -418,6 +418,13 @@ export interface ProviderModule {
   extensionIdPattern_flags?: string;
   compatibility?: ProviderCompatibilityEntry[];
   defaultScriptDir?: string;
+  /**
+   * Scripts that can run at the IDE main-page level (not just inside the extension webview session frame).
+   * Default: ['listModes', 'setMode', 'listModels', 'setModel'].
+   * Add extra scripts here if the provider supports them at the IDE level (e.g. 'setModelGui').
+   * Replaces hardcoded claude-code-vscode special-case in stream-commands.ts.
+   */
+  ideLevelScripts?: string[];
 
  // ─── CLI category only ───
   binary?: string;
@@ -426,6 +433,8 @@ export interface ProviderModule {
     args?: string[];
     shell?: boolean;
     env?: Record<string, string>;
+    /** Auto-implement spawn config — controls how this provider is invoked for autonomous script generation */
+    autoImpl?: ProviderAutoImplSpawnConfig;
   };
   /** Delay before submitting typed CLI input (provider-specific TUI tuning) */
   sendDelayMs?: number;
@@ -451,6 +460,24 @@ export interface ProviderModule {
   allowInputDuringGeneration?: boolean;
   /** Approval button priority hints used when auto-approve must pick a positive action */
   approvalPositiveHints?: string[];
+  /**
+   * Regex pattern (as string) that a valid provider session ID must match.
+   * If set and the ID doesn't match, it is rejected (treated as invalid).
+   * Replaces hardcoded HERMES_SESSION_ID_RE / CLAUDE_SESSION_ID_RE checks.
+   */
+  sessionIdPattern?: string;
+  /** History behavior config — controls message filtering and collapse during replay */
+  historyBehavior?: ProviderHistoryBehavior;
+  /**
+   * Canonical history sync config — for providers that maintain native history files.
+   * When set, daemon syncs from native format into ADHDev JSONL store on each tick.
+   */
+  canonicalHistory?: ProviderCanonicalHistoryConfig;
+  /**
+   * Auto-fix verification profile — provider-specific test expectations for `provider fix`.
+   * If not set, provider fix runs without pre/post verification.
+   */
+  autoFixProfile?: ProviderAutoFixProfile;
 
  // ─── CDP scripts (ide/extension category) ───
   scripts?: ProviderScripts;
@@ -538,6 +565,94 @@ export interface ProviderResumeCapability {
   resumeSessionArgs?: string[];
   newSessionArgs?: string[];
   sessionIdFormat?: 'uuid' | 'string';
+  /** Skip session ID probing when launchMode is 'new' — for providers that manage their own session IDs on new sessions */
+  skipProbeOnNewSession?: boolean;
+  /**
+   * Subcommands that carry a session ID as their next positional argument.
+   * e.g. ['resume', 'fork'] for codex-cli (codex resume <id> / codex fork <id>).
+   * Replaces the hardcoded readCodexResumeSessionId check in cli-manager.ts.
+   */
+  sessionIdFromSubcommand?: string[];
+  /**
+   * When --session-id is present without an explicit resume flag, treat as 'new' rather than 'resume'.
+   * e.g. goose-cli passes --session-id on new sessions but requires --resume/-r to actually resume.
+   * Replaces the hardcoded goose-cli check in cli-manager.ts.
+   */
+  sessionIdIsNewByDefault?: boolean;
+}
+
+/**
+ * History behavior config — controls how history messages are processed for this provider.
+ * Replaces hardcoded agentType checks in chat-history.ts.
+ */
+export interface ProviderHistoryBehavior {
+  /** Collapse consecutive assistant turns during history replay (e.g. codex-cli shows replayed intermediate turns) */
+  collapseConsecutiveAssistantTurns?: boolean;
+  /** Regex patterns (as strings) to filter out from assistant messages — e.g. CLI starter prompt suggestions */
+  filterAssistantPatterns?: string[];
+  /** If true, session ID must match sessionIdPattern exactly — reject and return '' if it doesn't match */
+  requireStrictSessionIdFormat?: boolean;
+}
+
+/**
+ * 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.
+ */
+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/
+   */
+  format: 'hermes-json' | 'claude-jsonl';
+  /**
+   * Path to the native history file. Supports ~ and {{sessionId}} placeholder.
+   * e.g. "~/.hermes/sessions/session_{{sessionId}}.json"
+   */
+  watchPath: string;
+}
+
+/**
+ * Auto-implement spawn config — controls how the provider is spawned for autonomous AI-driven
+ * provider script implementation (dev-auto-implement.ts).
+ * Replaces hardcoded per-command branching.
+ */
+export interface ProviderAutoImplSpawnConfig {
+  /**
+   * How the meta-prompt is passed to the agent.
+   * - 'flag': passed via a CLI flag (e.g. `claude -p "..."`)
+   * - 'stdin': piped via stdin (generic fallback)
+   * - 'subcommand': prepended as a subcommand (e.g. `codex exec "..."`)
+   */
+  promptMode: 'flag' | 'stdin' | 'subcommand';
+  /** CLI flag used to pass the prompt (promptMode: 'flag') — e.g. '-p' */
+  promptFlag?: string;
+  /** Subcommand prepended before the prompt (promptMode: 'subcommand') — e.g. 'exec' */
+  subcommand?: string;
+  /** Extra args appended in auto-impl mode — e.g. ['--dangerously-skip-permissions'] */
+  extraArgs?: string[];
+  /** Custom meta-prompt template; use {{promptFile}} placeholder. If omitted, generic prompt is used. */
+  metaPrompt?: string;
+  /**
+   * If true, schedule an auto-stop timer when the agent output goes quiet during verification.
+   * Replaces the hardcoded `command !== 'codex'` check in dev-auto-implement.ts.
+   */
+  autoStopOnQuiet?: boolean;
+}
+
+/**
+ * Auto-fix verification profile — provider-specific test expectations for `provider fix`.
+ * Replaces the hardcoded CLI_AUTO_FIX_VERIFICATION_PROFILES record in provider-commands.ts.
+ */
+export interface ProviderAutoFixProfile {
+  fixtureName: string;
+  description: string;
+  inspectFields?: string[];
+  focusAreas?: string[];
+  lastAssistantMustContainAny?: string[];
+  lastAssistantMustNotContainAny?: string[];
+  timeoutMs?: number;
 }
 
 /**

package/src/providers/provider-schema.ts

@@ -32,6 +32,12 @@ const KNOWN_PROVIDER_FIELDS = new Set<string>([
   'resume',
   'sessionProbe',
   'approvalPositiveHints',
+  'sessionIdPattern',
+  'historyBehavior',
+  'canonicalHistory',
+  'autoFixProfile',
+  'ideLevelScripts',
+  'allowInputDuringGeneration',
   'scripts',
   'vscodeCommands',
   'inputMethod',

package/src/providers/provider-session-id.ts

@@ -1,26 +1,28 @@
-const HERMES_SESSION_ID_RE = /^\d{8}_\d{6}_[a-z0-9]+$/i
-const CLAUDE_SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
+import type { ProviderModule } from './contracts.js'
 
-export function normalizeProviderSessionId(providerType: string | undefined, providerSessionId: string | null | undefined): string {
-  const normalizedProviderType = typeof providerType === 'string' ? providerType.trim() : ''
+/**
+ * Normalize and validate a provider session ID using the declarative `sessionIdPattern`
+ * from the provider's ProviderModule definition.
+ */
+export function normalizeProviderSessionId(
+  provider: ProviderModule | undefined,
+  providerSessionId: string | null | undefined,
+): string {
   const normalizedId = typeof providerSessionId === 'string' ? providerSessionId.trim() : ''
   if (!normalizedId) return ''
 
   const lowered = normalizedId.toLowerCase()
   if (lowered === 'undefined' || lowered === 'null') return ''
 
-  if (normalizedProviderType === 'hermes-cli' && !HERMES_SESSION_ID_RE.test(normalizedId)) {
-    return ''
-  }
-  if (normalizedProviderType === 'claude-cli' && !CLAUDE_SESSION_ID_RE.test(normalizedId)) {
-    return ''
+  const sessionIdPattern = provider?.sessionIdPattern
+  if (sessionIdPattern) {
+    try {
+      const re = new RegExp(sessionIdPattern, 'i')
+      if (!re.test(normalizedId)) return ''
+    } catch {
+      // Invalid regex in provider.json — skip validation
+    }
   }
 
   return normalizedId
 }
-
-export function isLegacyVolatileSessionReadKey(key: string | null | undefined): boolean {
-  const normalizedKey = typeof key === 'string' ? key.trim() : ''
-  if (!normalizedKey) return false
-  return normalizedKey.startsWith('provider:codex:vscode-webview://')
-}