@adhdev/daemon-core 0.7.46 → 0.8.0

package/src/daemon/dev-server.ts

@@ -29,7 +29,7 @@ import { generateTemplate as genScaffoldTemplate, generateFiles as genScaffoldFi
 import { VersionArchive, detectAllVersions } from '../providers/version-archive.js';
 import { LOG } from '../logging/logger.js';
 import { handleCdpEvaluate, handleCdpClick, handleCdpDomQuery, handleScreenshot, handleScriptsRun, handleTypeAndSend, handleTypeAndSendAt, handleScriptHints, handleCdpTargets, handleDomInspect, handleDomChildren, handleDomAnalyze, handleFindCommon, handleFindByText, handleDomContext } from './dev-cdp-handlers.js';
-import { handleCliStatus, handleCliLaunch, handleCliSend, handleCliStop, handleCliDebug, handleCliResolve, handleCliRaw, handleCliSSE } from './dev-cli-debug.js';
+import { handleCliStatus, handleCliLaunch, handleCliSend, handleCliStop, handleCliDebug, handleCliTrace, handleCliExercise, handleCliFixtureCapture, handleCliFixtureList, handleCliFixtureReplay, handleCliResolve, handleCliRaw, handleCliSSE } from './dev-cli-debug.js';
 import { handleAutoImplement, handleAutoImplCancel, handleAutoImplSSE } from './dev-auto-implement.js';
 
 export const DEV_SERVER_PORT = 19280;
@@ -102,11 +102,16 @@ export class DevServer implements DevServerContext {
     { method: 'GET',  pattern: '/api/cli/status',           handler: (q, s) => this.handleCliStatus(q, s) },
     { method: 'POST', pattern: '/api/cli/launch',           handler: (q, s) => this.handleCliLaunch(q, s) },
     { method: 'POST', pattern: '/api/cli/send',             handler: (q, s) => this.handleCliSend(q, s) },
+    { method: 'POST', pattern: '/api/cli/exercise',         handler: (q, s) => this.handleCliExercise(q, s) },
+    { method: 'POST', pattern: '/api/cli/fixture/capture',  handler: (q, s) => this.handleCliFixtureCapture(q, s) },
+    { method: 'POST', pattern: '/api/cli/fixture/replay',   handler: (q, s) => this.handleCliFixtureReplay(q, s) },
     { method: 'POST', pattern: '/api/cli/resolve',           handler: (q, s) => this.handleCliResolve(q, s) },
     { method: 'POST', pattern: '/api/cli/raw',               handler: (q, s) => this.handleCliRaw(q, s) },
     { method: 'POST', pattern: '/api/cli/stop',              handler: (q, s) => this.handleCliStop(q, s) },
     { method: 'GET',  pattern: '/api/cli/events',            handler: (q, s) => this.handleCliSSE(q, s) },
     { method: 'GET',  pattern: /^\/api\/cli\/debug\/([^/]+)$/, handler: (q, s, p) => this.handleCliDebug(p![0], q, s) },
+    { method: 'GET',  pattern: /^\/api\/cli\/trace\/([^/]+)$/, handler: (q, s, p) => this.handleCliTrace(p![0], q, s) },
+    { method: 'GET',  pattern: /^\/api\/cli\/fixtures\/([^/]+)$/, handler: (q, s, p) => this.handleCliFixtureList(p![0], q, s) },
     // Dynamic routes (provider :type param)
     { method: 'POST', pattern: /^\/api\/providers\/([^/]+)\/script$/,                handler: (q, s, p) => this.handleRunScript(p![0], q, s) },
     { method: 'GET',  pattern: /^\/api\/providers\/([^/]+)\/files$/,                 handler: (q, s, p) => this.handleListFiles(p![0], q, s) },
@@ -1472,6 +1477,7 @@ export class DevServer implements DevServerContext {
     lines.push('### 2. Inspect parsed + raw adapter state');
     lines.push('```bash');
     lines.push(`curl -sS http://127.0.0.1:${DEV_SERVER_PORT}/api/cli/debug/${type}`);
+    lines.push(`curl -sS http://127.0.0.1:${DEV_SERVER_PORT}/api/cli/trace/${type}`);
     lines.push(`curl -sS http://127.0.0.1:${DEV_SERVER_PORT}/api/cli/status`);
     lines.push('```');
     lines.push('');
@@ -1618,6 +1624,19 @@ export class DevServer implements DevServerContext {
     return handleCliSend(this, req, res);
   }
 
+  /** POST /api/cli/exercise — launch/send/approve/wait helper for provider-fix loops */
+  private async handleCliExercise(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+    return handleCliExercise(this, req, res);
+  }
+
+  private async handleCliFixtureCapture(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+    return handleCliFixtureCapture(this, req, res);
+  }
+
+  private async handleCliFixtureReplay(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+    return handleCliFixtureReplay(this, req, res);
+  }
+
   /** POST /api/cli/stop — stop a running CLI { type } */
   private async handleCliStop(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
     return handleCliStop(this, req, res);
@@ -1640,6 +1659,15 @@ export class DevServer implements DevServerContext {
     return handleCliDebug(this, type, _req, res);
   }
 
+  /** GET /api/cli/trace/:type — recent CLI trace timeline plus current debug snapshot */
+  private async handleCliTrace(type: string, _req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+    return handleCliTrace(this, type, _req, res);
+  }
+
+  private async handleCliFixtureList(type: string, _req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+    return handleCliFixtureList(this, type, _req, res);
+  }
+
   /** POST /api/cli/resolve — resolve an approval modal { type, buttonIndex } */
   private async handleCliResolve(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
     return handleCliResolve(this, req, res);

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

@@ -18,6 +18,7 @@ import type { PtyTransportFactory } from '../cli-adapters/pty-transport.js';
 import { StatusMonitor } from './status-monitor.js';
 import { ChatHistoryWriter } from '../config/chat-history.js';
 import { LOG } from '../logging/logger.js';
+import type { ChatMessage } from '../types.js';
 
 let CachedDatabaseSync: (new (path: string, options?: { readOnly?: boolean }) => {
     prepare(sql: string): { get(...params: Array<string | number>): unknown };
@@ -54,6 +55,7 @@ export class CliProviderInstance implements ProviderInstance {
     private generatingDebouncePending: { chatTitle: string; timestamp: number } | null = null;
     private lastApprovalEventAt = 0;
     private historyWriter: ChatHistoryWriter;
+    private runtimeMessages: Array<{ key: string; message: ChatMessage }> = [];
     readonly instanceId: string;
 
     private presentationMode: 'terminal' | 'chat';
@@ -170,6 +172,7 @@ export class CliProviderInstance implements ProviderInstance {
         }
         const runtime = this.adapter.getRuntimeMetadata();
         const parsedMessages = Array.isArray(parsedStatus?.messages) ? parsedStatus.messages : [];
+        const mergedMessages = this.mergeConversationMessages(parsedMessages);
 
         const dirName = this.workingDir.split('/').filter(Boolean).pop() || 'session';
 
@@ -202,7 +205,7 @@ export class CliProviderInstance implements ProviderInstance {
                 id: `${this.type}_${this.workingDir}`,
                 title: parsedStatus?.title || dirName,
                 status: parsedStatus?.status || adapterStatus.status,
-                messages: parsedMessages,
+                messages: mergedMessages,
                 activeModal: parsedStatus?.activeModal ?? adapterStatus.activeModal,
                 inputContent: '',
             },
@@ -308,6 +311,11 @@ export class CliProviderInstance implements ProviderInstance {
                 const approvalCooldown = 5000;
                 if (this.lastStatus !== 'waiting_approval' && (!this.lastApprovalEventAt || now - this.lastApprovalEventAt > approvalCooldown)) {
                     this.lastApprovalEventAt = now;
+                    this.appendRuntimeSystemMessage(
+                        this.formatApprovalRequestMessage(modal?.message, modal?.buttons),
+                        `approval_request:${now}`,
+                        now,
+                    );
                     this.pushEvent({
                         event: 'agent:waiting_approval', chatTitle, timestamp: now,
                         modalMessage: modal?.message,
@@ -376,12 +384,82 @@ export class CliProviderInstance implements ProviderInstance {
     get cliType(): string { return this.type; }
     get cliName(): string { return this.provider.name; }
 
+    recordApprovalSelection(buttonText: string): void {
+        const cleanButton = String(buttonText || '').trim();
+        if (!cleanButton) return;
+        const now = Date.now();
+        this.appendRuntimeSystemMessage(
+            `Approval selected: ${cleanButton}`,
+            `approval_selection:${now}:${cleanButton}`,
+            now,
+        );
+    }
+
     private formatMarkerTimestamp(timestamp: number): string {
         const date = new Date(timestamp);
         const pad = (value: number) => String(value).padStart(2, '0');
         return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
     }
 
+    private appendRuntimeSystemMessage(content: string, dedupKey: string, receivedAt = Date.now()): void {
+        const normalizedContent = String(content || '').trim();
+        if (!normalizedContent) return;
+        if (this.runtimeMessages.some((entry) => entry.key === dedupKey)) return;
+
+        this.runtimeMessages.push({
+            key: dedupKey,
+            message: {
+                role: 'system',
+                senderName: 'System',
+                content: normalizedContent,
+                receivedAt,
+                timestamp: receivedAt,
+            },
+        });
+        if (this.runtimeMessages.length > 50) {
+            this.runtimeMessages = this.runtimeMessages.slice(-50);
+        }
+
+        this.historyWriter.appendNewMessages(
+            this.type,
+            [{
+                role: 'system',
+                senderName: 'System',
+                content: normalizedContent,
+                receivedAt,
+                historyDedupKey: dedupKey,
+            }],
+            this.adapter.getScriptParsedStatus?.()?.title || this.workingDir.split('/').filter(Boolean).pop() || 'session',
+            this.instanceId,
+            this.providerSessionId,
+        );
+    }
+
+    private mergeConversationMessages(parsedMessages: any[]): ChatMessage[] {
+        if (this.runtimeMessages.length === 0) return parsedMessages;
+
+        return [...parsedMessages, ...this.runtimeMessages.map((entry) => entry.message)]
+            .map((message, index) => ({ message, index }))
+            .sort((a, b) => {
+                const aTime = a.message.receivedAt || a.message.timestamp || 0;
+                const bTime = b.message.receivedAt || b.message.timestamp || 0;
+                if (aTime !== bTime) return aTime - bTime;
+                return a.index - b.index;
+            })
+            .map((entry) => entry.message);
+    }
+
+    private formatApprovalRequestMessage(modalMessage?: string, buttons?: string[]): string {
+        const lines = ['Approval requested'];
+        const cleanMessage = String(modalMessage || '').trim();
+        if (cleanMessage) lines.push(cleanMessage);
+        const labels = (buttons || []).map((button) => String(button || '').trim()).filter(Boolean);
+        if (labels.length > 0) {
+            lines.push(labels.map((label) => `[${label}]`).join(' '));
+        }
+        return lines.join('\n');
+    }
+
     private promoteProviderSessionId(sessionId: string): void {
         const nextSessionId = String(sessionId || '').trim();
         if (!nextSessionId || nextSessionId === this.providerSessionId) return;

package/src/providers/contracts.ts

@@ -496,6 +496,14 @@ export interface ResolvedProvider extends ProviderModule {
   _resolvedVersion?: string;
  /** Warning when detected version is not in compatibility matrix */
   _versionWarning?: string;
+ /** On-disk provider directory selected by ProviderLoader */
+  _resolvedProviderDir?: string;
+ /** Script directory selected by compatibility/default resolution */
+  _resolvedScriptDir?: string;
+ /** scripts.js path or fallback script directory used to build runtime scripts */
+  _resolvedScriptsPath?: string;
+ /** Why this script selection was chosen */
+  _resolvedScriptsSource?: string;
 }
 
 // ─── Provider Settings ─────────────────────────────────

package/src/providers/provider-loader.ts

@@ -425,6 +425,7 @@ export class ProviderLoader {
   resolve(type: string, context?: { os?: string; version?: string }): ResolvedProvider | undefined {
     const base = this.providers.get(type);
     if (!base) return undefined;
+    const providerDir = this.findProviderDirInternal(type) || undefined;
 
     const currentOs = context?.os || process.platform;
     const currentVersion = context?.version ??
@@ -441,6 +442,9 @@ export class ProviderLoader {
     if (base.scripts) {
       resolved.scripts = { ...base.scripts };
     }
+    if (providerDir) {
+      resolved._resolvedProviderDir = providerDir;
+    }
 
  // 1. Apply OS override
     if (base.os?.[currentOs]) {
@@ -468,6 +472,14 @@ export class ProviderLoader {
             if (loaded) {
               resolved.scripts = loaded;
               this.log(`  [compatibility] ${type} v${currentVersion} → ${entry.scriptDir}`);
+              resolved._resolvedScriptDir = entry.scriptDir;
+              resolved._resolvedScriptsSource = `compatibility:${entry.ideVersion}`;
+              if (providerDir) {
+                const fullDir = path.join(providerDir, entry.scriptDir);
+                resolved._resolvedScriptsPath = fs.existsSync(path.join(fullDir, 'scripts.js'))
+                  ? path.join(fullDir, 'scripts.js')
+                  : fullDir;
+              }
               matched = true;
             }
             break; // first match wins
@@ -480,6 +492,14 @@ export class ProviderLoader {
           if (loaded) {
             resolved.scripts = loaded;
             this.log(`  [compatibility] ${type} v${currentVersion} → default: ${(base as any).defaultScriptDir}`);
+            resolved._resolvedScriptDir = (base as any).defaultScriptDir;
+            resolved._resolvedScriptsSource = 'defaultScriptDir:version_miss';
+            if (providerDir) {
+              const fullDir = path.join(providerDir, (base as any).defaultScriptDir);
+              resolved._resolvedScriptsPath = fs.existsSync(path.join(fullDir, 'scripts.js'))
+                ? path.join(fullDir, 'scripts.js')
+                : fullDir;
+            }
           }
           resolved._versionWarning = `Version ${currentVersion} not in compatibility matrix. Using default scripts.`;
         }
@@ -495,6 +515,14 @@ export class ProviderLoader {
             if (loaded) {
               resolved.scripts = loaded;
               this.log(`  [version override] ${type} ${range} → ${dirOverride}`);
+              resolved._resolvedScriptDir = dirOverride;
+              resolved._resolvedScriptsSource = `versions:${range}`;
+              if (providerDir) {
+                const fullDir = path.join(providerDir, dirOverride);
+                resolved._resolvedScriptsPath = fs.existsSync(path.join(fullDir, 'scripts.js'))
+                  ? path.join(fullDir, 'scripts.js')
+                  : fullDir;
+              }
             }
           } else if (override.scripts) {
             resolved.scripts = { ...resolved.scripts, ...override.scripts };
@@ -507,6 +535,14 @@ export class ProviderLoader {
       if (loaded) {
         resolved.scripts = loaded;
         this.log(`  [compatibility] ${type} no version detected → default: ${(base as any).defaultScriptDir}`);
+        resolved._resolvedScriptDir = (base as any).defaultScriptDir;
+        resolved._resolvedScriptsSource = 'defaultScriptDir:no_version';
+        if (providerDir) {
+          const fullDir = path.join(providerDir, (base as any).defaultScriptDir);
+          resolved._resolvedScriptsPath = fs.existsSync(path.join(fullDir, 'scripts.js'))
+            ? path.join(fullDir, 'scripts.js')
+            : fullDir;
+        }
       }
     }
 
@@ -583,6 +619,9 @@ export class ProviderLoader {
         });
 
         const handleChange = (filePath: string) => {
+          if (/[\/\\]fixtures[\/\\]/.test(filePath)) {
+            return;
+          }
           if (filePath.endsWith('.js') || filePath.endsWith('.json')) {
             this.log(`File changed: ${path.basename(filePath)}, reloading...`);
             this.reload();