@adhdev/daemon-core 0.6.74 → 0.6.76

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.6.74",
+  "version": "0.6.76",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/cli-adapters/provider-cli-adapter.ts

@@ -146,6 +146,25 @@ function stripAnsi(str: string): string {
         .replace(/  +/g, ' ');
 }
 
+function stripTerminalNoise(str: string): string {
+    return String(str || '')
+        // Remove remaining C0/C1 control chars except newlines/tabs.
+        // eslint-disable-next-line no-control-regex
+        .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x9F]/g, '')
+        // Drop common terminal negotiation/report fragments that can remain after ANSI stripping.
+        .replace(/(^|[\s([])(?:\??\d{1,4}(?:;\d{1,4})*[A-Za-z])(?=$|[\s)\]])/g, '$1')
+        .replace(/(^|[\s([])(?:\[\??\d{1,4}(?:;\d{1,4})*[A-Za-z])(?=$|[\s)\]])/g, '$1')
+        .replace(/(^|[\s([])(?:\d{1,4};\?)(?=$|[\s)\]])/g, '$1')
+        .replace(/\r+/g, '\n')
+        .replace(/[ \t]+\n/g, '\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .replace(/ {2,}/g, ' ');
+}
+
+function sanitizeTerminalText(str: string): string {
+    return stripTerminalNoise(stripAnsi(str));
+}
+
 function findBinary(name: string): string {
     const isWin = os.platform() === 'win32';
     try {
@@ -370,6 +389,9 @@ export class ProviderCliAdapter implements CliAdapter {
  // Approval state machine
     private approvalTransitionBuffer: string = '';
     private approvalExitTimeout: NodeJS.Timeout | null = null;
+    private pendingScriptStatus: 'generating' | 'waiting_approval' | null = null;
+    private pendingScriptStatusSince = 0;
+    private pendingScriptStatusTimer: NodeJS.Timeout | null = null;
 
  // Output settle debounce — fires after PTY output goes quiet
     private settleTimer: NodeJS.Timeout | null = null;
@@ -454,6 +476,7 @@ export class ProviderCliAdapter implements CliAdapter {
     private readonly sendDelayMs: number;
     private readonly sendKey: string;
     private readonly submitStrategy: 'wait_for_echo' | 'immediate';
+    private static readonly SCRIPT_STATUS_DEBOUNCE_MS = 1000;
 
     constructor(provider: CliProviderModule, workingDir: string, private extraArgs: string[] = []) {
         this.provider = provider;
@@ -645,7 +668,7 @@ export class ProviderCliAdapter implements CliAdapter {
     private handleOutput(rawData: string): void {
         this.terminalScreen.write(rawData);
         this.terminalHistory = mergeTerminalHistory(this.terminalHistory, this.terminalScreen.getText());
-        const cleanData = stripAnsi(rawData);
+        const cleanData = sanitizeTerminalText(rawData);
 
         if (this.isWaitingForResponse && cleanData) {
             this.responseBuffer = (this.responseBuffer + cleanData).slice(-8000);
@@ -764,26 +787,45 @@ export class ProviderCliAdapter implements CliAdapter {
 
         const prevStatus = this.currentStatus;
 
-        if (scriptStatus === 'waiting_approval') {
-            // Auto-accept startup safety dialogs (e.g., "Claude Code'll be able to read, edit, and execute")
-            const modalMessage = modal?.message || '';
-            const screenText = this.terminalScreen.getText() || this.accumulatedBuffer;
-            const autoAcceptPatterns = [
-                /be able to read, edit, and execute/i,
-                /Security guide/i,
-                /Enter to confirm/i,
-                /Quick safety check/i,
-                /Do you trust the files/i,
-                /Is this a project/i,
-            ];
-            if (autoAcceptPatterns.some(p => p.test(modalMessage) || p.test(screenText))) {
-                LOG.info('CLI', `[${this.cliType}] Auto-accepting startup dialog: ${modalMessage.slice(0, 80)}`);
-                setTimeout(() => this.ptyProcess?.write('\r'), 200);
-                this.lastApprovalResolvedAt = Date.now();
-                this.activeModal = null;
+        const clearPendingScriptStatus = () => {
+            this.pendingScriptStatus = null;
+            this.pendingScriptStatusSince = 0;
+            if (this.pendingScriptStatusTimer) {
+                clearTimeout(this.pendingScriptStatusTimer);
+                this.pendingScriptStatusTimer = null;
+            }
+        };
+        const armPendingScriptStatus = (delayMs: number) => {
+            if (this.pendingScriptStatusTimer) clearTimeout(this.pendingScriptStatusTimer);
+            this.pendingScriptStatusTimer = setTimeout(() => {
+                this.pendingScriptStatusTimer = null;
+                this.settledBuffer = this.recentOutputBuffer;
+                this.evaluateSettled();
+            }, delayMs);
+        };
+        const shouldDebouncePromotion = (status: string) =>
+            prevStatus === 'idle'
+            && !this.isWaitingForResponse
+            && !this.currentTurnScope
+            && (status === 'generating' || status === 'waiting_approval');
+
+        if (shouldDebouncePromotion(scriptStatus)) {
+            if (this.pendingScriptStatus !== scriptStatus) {
+                this.pendingScriptStatus = scriptStatus as 'generating' | 'waiting_approval';
+                this.pendingScriptStatusSince = now;
+                armPendingScriptStatus(ProviderCliAdapter.SCRIPT_STATUS_DEBOUNCE_MS);
+                return;
+            }
+            const elapsed = now - this.pendingScriptStatusSince;
+            if (elapsed < ProviderCliAdapter.SCRIPT_STATUS_DEBOUNCE_MS) {
+                armPendingScriptStatus(ProviderCliAdapter.SCRIPT_STATUS_DEBOUNCE_MS - elapsed);
                 return;
             }
+        } else {
+            clearPendingScriptStatus();
+        }
 
+        if (scriptStatus === 'waiting_approval') {
             const inCooldown = this.lastApprovalResolvedAt && (Date.now() - this.lastApprovalResolvedAt) < this.timeouts.approvalCooldown;
             if (!inCooldown) {
                 this.isWaitingForResponse = true;
@@ -800,6 +842,16 @@ export class ProviderCliAdapter implements CliAdapter {
         }
 
         if (scriptStatus === 'generating') {
+            const screenText = this.terminalScreen.getText() || this.accumulatedBuffer;
+            const noActiveTurn = !this.currentTurnScope;
+            const looksIdleChrome = /(^|\n)\s*[❯›>]\s*(?:\n|$)/m.test(screenText)
+                || (/accept edits on/i.test(screenText)
+                    && (/Update available!/i.test(screenText)
+                        || /\/effort/i.test(screenText)
+                        || /^.*➜\s+\S+/m.test(screenText)));
+            if (prevStatus === 'idle' && !this.isWaitingForResponse && noActiveTurn && !modal && looksIdleChrome) {
+                return;
+            }
             if (prevStatus === 'waiting_approval') {
                 // Transitioned out of approval → generating
                 if (this.approvalExitTimeout) { clearTimeout(this.approvalExitTimeout); this.approvalExitTimeout = null; }
@@ -1242,7 +1294,7 @@ export class ProviderCliAdapter implements CliAdapter {
             committedMessages: this.committedMessages.slice(-20),
             structuredMessages: this.structuredMessages.slice(-20),
             messageCount: this.committedMessages.length,
-            screenText: this.terminalScreen.getText().slice(-4000),
+            screenText: sanitizeTerminalText(this.terminalScreen.getText()).slice(-4000),
             terminalHistory: this.terminalHistory.slice(-8000),
             currentTurnScope: this.currentTurnScope,
             startupBuffer: this.startupBuffer.slice(-4000),
@@ -1251,6 +1303,7 @@ export class ProviderCliAdapter implements CliAdapter {
             accumulatedBufferLength: this.accumulatedBuffer.length,
             accumulatedRawBufferLength: this.accumulatedRawBuffer.length,
             rawBufferPreview: this.accumulatedRawBuffer.slice(-1000),
+            sanitizedRawPreview: sanitizeTerminalText(this.accumulatedRawBuffer).slice(-1000),
             responseBuffer: this.responseBuffer.slice(-1000),
             isWaitingForResponse: this.isWaitingForResponse,
             activeModal: this.activeModal,

package/src/commands/handler.ts

@@ -168,8 +168,24 @@ export class DaemonCommandHandler implements CommandHelpers {
     getCliAdapter(type?: string): any | null {
         const target = type || this._currentIdeType;
         if (!target || !this._ctx.adapters) return null;
+        // Normalize composite transport IDs:
+        //   standalone_xxx:cli:<uuid> -> <uuid>
+        //   daemon:acp:<uuid>         -> <uuid>
+        let normalizedTarget = target;
+        const colonIdx = normalizedTarget.lastIndexOf(':');
+        if (colonIdx >= 0) normalizedTarget = normalizedTarget.substring(colonIdx + 1);
+
+        const direct = this._ctx.adapters.get(normalizedTarget);
+        if (direct) return direct;
+
         for (const [key, adapter] of this._ctx.adapters.entries()) {
-            if ((adapter as any).cliType === target || key.startsWith(target)) {
+            if (
+                (adapter as any).cliType === target
+                || (adapter as any).cliType === normalizedTarget
+                || key === normalizedTarget
+                || key.startsWith(target)
+                || key.startsWith(normalizedTarget)
+            ) {
                 return adapter;
             }
         }

package/src/daemon/dev-server.ts

@@ -1895,22 +1895,25 @@ export class DevServer {
     return path.join(scriptsDir, versions[0]);
   }
 
-  private resolveAutoImplWritableProviderDir(category: ProviderCategory, type: string, requestedDir?: string): string | null {
+  private resolveAutoImplWritableProviderDir(
+    category: ProviderCategory,
+    type: string,
+    requestedDir?: string,
+  ): { dir: string | null; reason?: string } {
     const canonicalUserDir = path.resolve(this.providerLoader.getUserProviderDir(category, type));
     const desiredDir = requestedDir ? path.resolve(requestedDir) : canonicalUserDir;
-
-    if (desiredDir !== canonicalUserDir) {
-      return null;
+    const upstreamRoot = path.resolve(this.providerLoader.getUpstreamDir());
+    if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path.sep}`)) {
+      return { dir: null, reason: `Refusing to write into upstream provider directory: ${desiredDir}` };
     }
 
-    const userRoot = path.resolve(this.providerLoader.getUserDir());
-    if (desiredDir !== userRoot && !desiredDir.startsWith(`${userRoot}${path.sep}`)) {
-      return null;
+    if (path.basename(desiredDir) !== type) {
+      return { dir: null, reason: `Requested writable provider directory must end with '${type}': ${desiredDir}` };
     }
 
     const sourceDir = this.findProviderDir(type);
     if (!sourceDir) {
-      return null;
+      return { dir: null, reason: `Provider source directory not found for '${type}'` };
     }
 
     if (!fs.existsSync(desiredDir)) {
@@ -1921,7 +1924,7 @@ export class DevServer {
 
     const providerJson = path.join(desiredDir, 'provider.json');
     if (!fs.existsSync(providerJson)) {
-      return null;
+      return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
     }
 
     try {
@@ -1930,11 +1933,14 @@ export class DevServer {
         providerData.disableUpstream = true;
         fs.writeFileSync(providerJson, JSON.stringify(providerData, null, 2));
       }
-    } catch {
-      return null;
+    } catch (error) {
+      return {
+        dir: null,
+        reason: `Failed to update provider.json in writable provider directory: ${(error as Error).message}`,
+      };
     }
 
-    return desiredDir;
+    return { dir: desiredDir };
   }
 
   private loadAutoImplReferenceScripts(referenceType: string | null): Record<string, string> {
@@ -1975,13 +1981,14 @@ export class DevServer {
     const provider = this.providerLoader.resolve(type);
     if (!provider) { this.json(res, 404, { error: `Provider not found: ${type}` }); return; }
 
-    const providerDir = this.resolveAutoImplWritableProviderDir(provider.category, type, requestedProviderDir);
-    if (!providerDir) {
+    const writableProvider = this.resolveAutoImplWritableProviderDir(provider.category, type, requestedProviderDir);
+    if (!writableProvider.dir) {
       this.json(res, 409, {
-        error: `Auto-implement only writes to the canonical user provider directory for '${type}'.`,
+        error: writableProvider.reason || `Auto-implement only writes to the canonical user provider directory for '${type}'.`,
       });
       return;
     }
+    const providerDir = writableProvider.dir;
 
     try {
       // 1. Collect DOM context
@@ -2749,6 +2756,9 @@ export class DevServer {
     lines.push('8. Keep exports compatible with the existing `scripts.js` router (`module.exports = function ...`).');
     lines.push('9. Do not rewrite unrelated provider config. Only touch the scripts needed for this task unless a tiny supporting change is required.');
     lines.push('10. When the verification API returns `instanceId`, keep using that exact instance for follow-up `send`, `resolve`, `raw`, and `stop` calls. Do not assume type-only routing is safe if multiple sessions exist.');
+    lines.push('11. Do NOT repeatedly dump the same target files. Read the target scripts once, reproduce the bug, then move directly to patching.');
+    lines.push('12. If the user instructions include concrete screen text, raw PTY snippets, or a specific repro, treat that as the primary acceptance criteria.');
+    lines.push('13. After the first successful live repro, stop broad diagnosis. Edit the scripts, reload, and verify. Do not burn tokens on repeated re-inspection without code changes.');
     lines.push('');
 
     lines.push('## Task');
@@ -2792,6 +2802,9 @@ export class DevServer {
     lines.push('');
     lines.push('Use `resolve` when the parsed modal buttons are correct. Use `raw` when the CLI expects a literal keystroke like `1`, `y`, or Enter. Repeat until idle.');
     lines.push('');
+    lines.push('### Patch Discipline');
+    lines.push('Once the repro is confirmed, immediately edit the target files. Avoid loops where you keep re-reading long files or re-running the same debug commands without changing code.');
+    lines.push('');
     lines.push('### 5. Verify the side effects outside the CLI');
     lines.push('```bash');
     lines.push('test -f tmp/adhdev_provider_fix_test.py');

package/src/detection/cli-detector.ts

@@ -16,12 +16,18 @@ export interface CLIInfo {
     displayName: string;
     icon: string;
     command: string;
+    versionCommand?: string;
     installed: boolean;
     version?: string;
     path?: string;
     category?: string;
 }
 
+function parseVersion(raw: string): string {
+    const match = raw.match(/v?(\d+\.\d+(?:\.\d+)?(?:-[a-zA-Z0-9.]+)?)/);
+    return match ? match[1] : raw.split('\n')[0].slice(0, 100);
+}
+
 /** Run a shell command with timeout, returning stdout or null on failure */
 function execAsync(cmd: string, timeoutMs = 5000): Promise<string | null> {
     return new Promise((resolve) => {
@@ -62,11 +68,18 @@ export async function detectCLIs(providerLoader?: ProviderLoader): Promise<CLIIn
                 // Get version (parallel with other checks)
                 let version: string | undefined;
                 try {
-                    const versionResult = await execAsync(`${cli.command} --version 2>/dev/null`, 3000);
-                    if (versionResult) {
-                        // Extract version number (e.g. "gemini v1.2.3" → "1.2.3")
-                        const match = versionResult.match(/(\d+\.\d+[\.\d]*)/);
-                        version = match ? match[1] : versionResult.split('\n')[0].slice(0, 30);
+                    const versionCommands = [
+                        cli.versionCommand,
+                        `${cli.command} --version 2>/dev/null`,
+                        `${cli.command} -V 2>/dev/null`,
+                        `${cli.command} -v 2>/dev/null`,
+                    ].filter((v): v is string => !!v);
+                    for (const versionCommand of versionCommands) {
+                        const versionResult = await execAsync(versionCommand, 3000);
+                        if (versionResult) {
+                            version = parseVersion(versionResult);
+                            break;
+                        }
                     }
                 } catch { }
 

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

@@ -85,25 +85,6 @@ export class CliProviderInstance implements ProviderInstance {
 
         const dirName = this.workingDir.split('/').filter(Boolean).pop() || 'session';
 
- // Preserve rich message objects, just truncate extremely long text strings
-        const recentMessages = adapterStatus.messages.slice(-50).map((m: any) => {
-            const content = typeof m.content === 'string' && m.content.length > 8000
-                ? m.content.slice(0, 8000) + '\n... (truncated)'
-                : m.content;
-            return { ...m, content };
-        });
-
- // generating during partial response add
- // Save history
-        if (recentMessages.length > 0) {
-            const dirName = this.workingDir.split('/').filter(Boolean).pop() || 'session';
-            this.historyWriter.appendNewMessages(
-                this.type,
-                recentMessages,
-                `${this.provider.name} · ${dirName}`,
-                this.instanceId,
-            );
-        }
         if (adapterStatus.terminalHistory?.trim()) {
             this.historyWriter.appendTerminalHistory(
                 this.type,
@@ -118,12 +99,12 @@ export class CliProviderInstance implements ProviderInstance {
             name: this.provider.name,
             category: 'cli',
             status: adapterStatus.status,
-            mode: (this.settings.mode as 'terminal' | 'chat') || 'terminal',
+            mode: 'terminal',
             activeChat: {
                 id: `${this.type}_${this.workingDir}`,
                 title: `${this.provider.name} · ${dirName}`,
                 status: adapterStatus.status,
-                messages: recentMessages,
+                messages: [],
                 activeModal: adapterStatus.activeModal,
                 terminalHistory: adapterStatus.terminalHistory,
                 inputContent: '',
@@ -138,11 +119,15 @@ export class CliProviderInstance implements ProviderInstance {
 
     onEvent(event: string, data?: any): void {
         if (event === 'send_message' && data?.text) {
-            this.adapter.sendMessage(data.text);
+            void this.adapter.sendMessage(data.text).catch((e: any) => {
+                LOG.warn('CLI', `[${this.type}] send_message failed: ${e?.message || e}`);
+            });
         } else if (event === 'server_connected' && data?.serverConn) {
             this.adapter.setServerConn(data.serverConn);
         } else if (event === 'resolve_action' && data) {
-            this.adapter.resolveAction(data);
+            void this.adapter.resolveAction(data).catch((e: any) => {
+                LOG.warn('CLI', `[${this.type}] resolve_action failed: ${e?.message || e}`);
+            });
         }
     }
 

package/src/providers/provider-loader.ts

@@ -237,16 +237,23 @@ export class ProviderLoader {
  * Build CLI/ACP detection list (replaces cli-detector)
  * Dynamically generated from provider.js spawn.command.
  */
-  getCliDetectionList(): { id: string; displayName: string; icon: string; command: string; category: string }[] {
-    const result: { id: string; displayName: string; icon: string; command: string; category: string }[] = [];
+  getCliDetectionList(): { id: string; displayName: string; icon: string; command: string; category: string; versionCommand?: string }[] {
+    const result: { id: string; displayName: string; icon: string; command: string; category: string; versionCommand?: string }[] = [];
     for (const p of this.providers.values()) {
       if ((p.category === 'cli' || p.category === 'acp') && p.spawn?.command) {
+        const verCmdConfig = (p as any).versionCommand;
+        const versionCommand = typeof verCmdConfig === 'object' && verCmdConfig !== null
+          ? verCmdConfig[process.platform]
+          : verCmdConfig;
         result.push({
           id: p.type,
           displayName: p.displayName || p.name,
           icon: p.icon || '🔧',
           command: p.spawn.command,
           category: p.category,
+          ...(typeof versionCommand === 'string' && versionCommand.trim()
+            ? { versionCommand: versionCommand.trim() }
+            : {}),
         });
       }
     }

package/src/shared-types.ts

@@ -75,7 +75,7 @@ export interface ManagedCliEntry {
     cliType: string;
     cliName: string;
     status: string;
-    mode: 'terminal' | 'chat';
+    mode: 'terminal';
     workspace: string;
     activeChat: _ActiveChatData | null;
 }

package/src/status/builders.ts

@@ -156,7 +156,7 @@ export function buildManagedClis(
         cliType: s.type,
         cliName: s.name,
         status: s.status,
-        mode: s.mode as 'terminal' | 'chat',
+        mode: 'terminal' as const,
         workspace: s.workspace || '',
         activeChat: s.activeChat,
     }));