@adhdev/daemon-core 0.8.93 → 0.8.94

package/dist/providers/provider-loader.d.ts

@@ -33,6 +33,17 @@ export declare class ProviderLoader {
     setVersionArchive(archive: VersionArchive): void;
     private static readonly GITHUB_TARBALL_URL;
     private static readonly META_FILE;
+    private static readonly REPO_PROVIDER_DIRNAME;
+    private static readonly SIBLING_MARKER_FILE;
+    private static readonly SIBLING_ENV_VAR;
+    private probeStarts;
+    private siblingLogged;
+    private userDirSource;
+    /** Process-level dedup for stderr sibling-adoption notices (shared across all ProviderLoader instances). */
+    private static siblingStderrLogged;
+    private static looksLikeProviderRoot;
+    private static hasProviderRootMarker;
+    private detectDefaultUserDir;
     constructor(options?: {
         userDir?: string;
         logFn?: (msg: string) => void;
@@ -40,6 +51,12 @@ export declare class ProviderLoader {
         sourceMode?: ProviderSourceMode;
         /** Deprecated alias for sourceMode='no-upstream' */
         disableUpstream?: boolean;
+        /**
+         * Directories from which to walk up looking for a sibling `adhdev-providers`
+         * checkout. Defaults to [process.cwd(), __dirname]. Used by tests for hermetic
+         * probing; production code should leave this unset.
+         */
+        probeStarts?: string[];
     });
     private log;
     /**

package/node_modules/@adhdev/session-host-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.8.93",
+  "version": "0.8.94",
   "description": "ADHDev local session host core \u2014 session registry, protocol, buffers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/package.json

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

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

@@ -1492,7 +1492,7 @@ export class ProviderCliAdapter implements CliAdapter {
 
     private projectEffectiveStatus(startupModal: { message: string; buttons: string[] } | null = null): CliSessionStatus['status'] {
         if (this.parseErrorMessage) return 'error';
-        if (startupModal) return 'waiting_approval';
+        if (startupModal || this.activeModal) return 'waiting_approval';
         if (this.isWaitingForResponse && this.currentTurnScope && this.currentStatus === 'idle') return 'generating';
         return this.currentStatus;
     }
@@ -1502,12 +1502,28 @@ export class ProviderCliAdapter implements CliAdapter {
     getStatus(): CliSessionStatus {
         const screenText = this.terminalScreen.getText() || '';
         const startupModal = this.startupParseGate ? this.getStartupConfirmationModal(screenText) : null;
-        const effectiveStatus = this.projectEffectiveStatus(startupModal);
+        let effectiveStatus = this.projectEffectiveStatus(startupModal);
+        let effectiveModal = startupModal || this.activeModal;
+        if (!startupModal && !effectiveModal && typeof this.cliScripts?.parseOutput === 'function') {
+            try {
+                const parsed = this.getScriptParsedStatus();
+                const parsedModal = parsed?.activeModal && Array.isArray(parsed.activeModal.buttons)
+                    && parsed.activeModal.buttons.some((button: any) => typeof button === 'string' && button.trim())
+                    ? parsed.activeModal
+                    : null;
+                if (parsed?.status === 'waiting_approval' && parsedModal) {
+                    effectiveStatus = 'waiting_approval';
+                    effectiveModal = parsedModal;
+                }
+            } catch {
+                // Ignore parse errors here; getScriptParsedStatus surfaces them on richer callers.
+            }
+        }
         return {
             status: effectiveStatus,
             messages: [...this.committedMessages],
             workingDir: this.workingDir,
-            activeModal: startupModal || this.activeModal,
+            activeModal: effectiveModal,
             errorMessage: this.parseErrorMessage || undefined,
             errorReason: this.parseErrorMessage ? 'parse_error' : undefined,
         };
@@ -1565,6 +1581,18 @@ export class ProviderCliAdapter implements CliAdapter {
             this.currentTurnScope,
             screenText,
         );
+        const parsedModal = parsed?.activeModal && Array.isArray(parsed.activeModal.buttons)
+            && parsed.activeModal.buttons.some((button: any) => typeof button === 'string' && button.trim())
+            ? parsed.activeModal
+            : null;
+        if (parsedModal && parsed?.status === 'waiting_approval') {
+            this.activeModal = parsedModal;
+            this.isWaitingForResponse = true;
+            if (this.currentStatus !== 'waiting_approval') {
+                this.setStatus('waiting_approval', 'parsed_waiting_approval');
+                this.onStatusChange?.();
+            }
+        }
         if (this.maybeCommitVisibleIdleTranscript(parsed)) {
             return this.getScriptParsedStatus();
         }
@@ -2219,7 +2247,26 @@ export class ProviderCliAdapter implements CliAdapter {
 
     resolveModal(buttonIndex: number): void {
         const screenText = this.terminalScreen.getText() || '';
-        const modal = this.activeModal || this.getStartupConfirmationModal(screenText);
+        let modal = this.activeModal || this.getStartupConfirmationModal(screenText);
+        if (!modal && typeof this.cliScripts?.parseOutput === 'function') {
+            try {
+                const parsed = this.getScriptParsedStatus();
+                const parsedModal = parsed?.activeModal && Array.isArray(parsed.activeModal.buttons)
+                    && parsed.activeModal.buttons.some((button: any) => typeof button === 'string' && button.trim())
+                    ? parsed.activeModal
+                    : null;
+                if (parsed?.status === 'waiting_approval' && parsedModal) {
+                    modal = parsedModal;
+                    this.activeModal = parsedModal;
+                    if (this.currentStatus !== 'waiting_approval') {
+                        this.setStatus('waiting_approval', 'resolve_modal_parse');
+                        this.onStatusChange?.();
+                    }
+                }
+            } catch {
+                // Ignore parse failures here; resolveModal falls back to current state.
+            }
+        }
         if (!this.ptyProcess || ((this.currentStatus !== 'waiting_approval') && !modal)) return;
         this.clearIdleFinishCandidate('resolve_modal');
         this.recordTrace('resolve_modal', {

package/src/commands/chat-commands.ts

@@ -42,7 +42,9 @@ function getTargetInstance(h: CommandHelpers, args: any): ApprovalSelectableInst
     const targetSessionId = typeof args?.targetSessionId === 'string' ? args.targetSessionId.trim() : '';
     const sessionId = targetSessionId || h.currentSession?.sessionId || '';
     if (!sessionId) return null;
-    return (h.ctx.instanceManager?.getInstance(sessionId) as ApprovalSelectableInstance | undefined) || null;
+    const session = h.ctx.sessionRegistry?.get(sessionId);
+    const instanceKey = session?.adapterKey || session?.instanceKey || sessionId;
+    return (h.ctx.instanceManager?.getInstance(instanceKey) as ApprovalSelectableInstance | undefined) || null;
 }
 
 function getTargetTransport(h: CommandHelpers, provider?: ProviderModule): SessionTransport | null {
@@ -1238,10 +1240,25 @@ export async function handleResolveAction(h: CommandHelpers, args: any): Promise
         }
 
         const status = adapter.getStatus();
-        if (status?.status !== 'waiting_approval') {
+        const targetInstance = getTargetInstance(h, args);
+        const targetState = targetInstance?.getState?.() as { activeChat?: { status?: string; activeModal?: { message?: string; buttons?: string[] } | null } } | undefined;
+        const surfacedModal = targetState?.activeChat?.activeModal && Array.isArray(targetState.activeChat.activeModal.buttons)
+            && targetState.activeChat.activeModal.buttons.some((candidate) => typeof candidate === 'string' && candidate.trim())
+            ? targetState.activeChat.activeModal
+            : null;
+        const statusModal = status?.activeModal && Array.isArray(status.activeModal.buttons)
+            && status.activeModal.buttons.some((candidate) => typeof candidate === 'string' && candidate.trim())
+            ? status.activeModal
+            : null;
+        const effectiveModal = statusModal || surfacedModal;
+        const effectiveStatus = status?.status === 'waiting_approval' || targetState?.activeChat?.status === 'waiting_approval'
+            ? 'waiting_approval'
+            : status?.status;
+        LOG.info('Command', `[resolveAction] CLI PTY gate target=${String(args?.targetSessionId || '')} rawStatus=${String(status?.status || '')} effectiveStatus=${String(effectiveStatus || '')} statusModal=${statusModal ? 'yes' : 'no'} surfacedModal=${surfacedModal ? 'yes' : 'no'} instance=${targetInstance ? 'yes' : 'no'}`);
+        if (effectiveStatus !== 'waiting_approval' && !effectiveModal) {
             return { success: false, error: 'Not in approval state' };
         }
-        const buttons: string[] = status.activeModal?.buttons || ['Allow once', 'Always allow', 'Deny'];
+        const buttons: string[] = effectiveModal?.buttons || ['Allow once', 'Always allow', 'Deny'];
         // Resolve button index: explicit buttonIndex arg → button text match → action fallback
         let buttonIndex = typeof args?.buttonIndex === 'number' ? args.buttonIndex : -1;
         if (buttonIndex < 0) {

package/src/config/provider-source-config.ts

@@ -1,10 +1,20 @@
 import type { ProviderSourceMode } from './config.js'
 
+/**
+ * How the effective `userDir` was resolved:
+ *  - `explicit`        — the user set `config.providerDir` or passed `userDir`
+ *  - `sibling-env`     — auto-adopted a sibling `adhdev-providers/` via ADHDEV_USE_SIBLING_PROVIDERS=1
+ *  - `sibling-marker`  — auto-adopted a sibling `adhdev-providers/` via a `.adhdev-provider-root` marker file
+ *  - `home-default`    — fell back to `~/.adhdev/providers`
+ */
+export type ProviderUserDirSource = 'explicit' | 'sibling-env' | 'sibling-marker' | 'home-default'
+
 export interface ProviderSourceConfigSnapshot {
   sourceMode: ProviderSourceMode
   disableUpstream: boolean
   explicitProviderDir: string | null
   userDir: string
+  userDirSource: ProviderUserDirSource
   upstreamDir: string
   providerRoots: string[]
 }

package/src/providers/provider-loader.ts

@@ -31,7 +31,7 @@ import type {
 } from './contracts.js';
 import { validateProviderDefinition } from './provider-schema.js';
 import type { ProviderSourceMode } from '../config/config.js';
-import type { ProviderSourceConfigSnapshot } from '../config/provider-source-config.js';
+import type { ProviderSourceConfigSnapshot, ProviderUserDirSource } from '../config/provider-source-config.js';
 
 interface ProviderAvailabilityState {
   installed: boolean;
@@ -59,6 +59,75 @@ export class ProviderLoader {
 
   private static readonly GITHUB_TARBALL_URL = 'https://github.com/vilmire/adhdev-providers/archive/refs/heads/main.tar.gz';
   private static readonly META_FILE = '.meta.json';
+  private static readonly REPO_PROVIDER_DIRNAME = 'adhdev-providers';
+  private static readonly SIBLING_MARKER_FILE = '.adhdev-provider-root';
+  private static readonly SIBLING_ENV_VAR = 'ADHDEV_USE_SIBLING_PROVIDERS';
+
+  private probeStarts: string[] = [];
+  private siblingLogged = false;
+  private userDirSource: ProviderUserDirSource = 'home-default';
+
+  /** Process-level dedup for stderr sibling-adoption notices (shared across all ProviderLoader instances). */
+  private static siblingStderrLogged: Set<string> = new Set();
+
+  private static looksLikeProviderRoot(candidate: string): boolean {
+    try {
+      if (!fs.existsSync(candidate) || !fs.statSync(candidate).isDirectory()) return false;
+      return ['ide', 'extension', 'cli', 'acp'].some((category) =>
+        fs.existsSync(path.join(candidate, category))
+      );
+    } catch {
+      return false;
+    }
+  }
+
+  private static hasProviderRootMarker(candidate: string): boolean {
+    try {
+      return fs.existsSync(path.join(candidate, ProviderLoader.SIBLING_MARKER_FILE));
+    } catch {
+      return false;
+    }
+  }
+
+  private detectDefaultUserDir(): { path: string; source: 'sibling-env' | 'sibling-marker' | 'home-default' } {
+    const fallback = path.join(os.homedir(), '.adhdev', 'providers');
+    const envOptIn = process.env[ProviderLoader.SIBLING_ENV_VAR] === '1';
+    const visited = new Set<string>();
+
+    for (const start of this.probeStarts) {
+      let current = path.resolve(start);
+      while (!visited.has(current)) {
+        visited.add(current);
+        const siblingCandidate = path.join(path.dirname(current), ProviderLoader.REPO_PROVIDER_DIRNAME);
+        if (ProviderLoader.looksLikeProviderRoot(siblingCandidate)) {
+          const hasMarker = ProviderLoader.hasProviderRootMarker(siblingCandidate);
+          if (envOptIn || hasMarker) {
+            const source: 'sibling-env' | 'sibling-marker' = hasMarker ? 'sibling-marker' : 'sibling-env';
+            if (!this.siblingLogged) {
+              this.log(`Using sibling provider checkout (${source}): ${siblingCandidate}`);
+              this.siblingLogged = true;
+            }
+            // Force-surface adoption to stderr once per sibling path per process, so CLI
+            // entry points that suppress logFn still leave a visible trail.
+            if (!ProviderLoader.siblingStderrLogged.has(siblingCandidate)) {
+              ProviderLoader.siblingStderrLogged.add(siblingCandidate);
+              try {
+                process.stderr.write(
+                  `[adhdev] Using sibling adhdev-providers checkout (${source}): ${siblingCandidate}\n`,
+                );
+              } catch { /* ignore */ }
+            }
+            return { path: siblingCandidate, source };
+          }
+        }
+        const parent = path.dirname(current);
+        if (parent === current) break;
+        current = parent;
+      }
+    }
+
+    return { path: fallback, source: 'home-default' };
+  }
 
   constructor(options?: {
     userDir?: string;
@@ -67,12 +136,21 @@ export class ProviderLoader {
     sourceMode?: ProviderSourceMode;
     /** Deprecated alias for sourceMode='no-upstream' */
     disableUpstream?: boolean;
+    /**
+     * Directories from which to walk up looking for a sibling `adhdev-providers`
+     * checkout. Defaults to [process.cwd(), __dirname]. Used by tests for hermetic
+     * probing; production code should leave this unset.
+     */
+    probeStarts?: string[];
   }) {
     this.logFn = options?.logFn || LOG.forComponent('Provider').asLogFn();
+    this.probeStarts = options?.probeStarts ?? [process.cwd(), __dirname];
 
     // Default directory for auto-downloads
     this.defaultProvidersDir = path.join(os.homedir(), '.adhdev', 'providers');
-    this.userDir = this.defaultProvidersDir;
+    const detected = this.detectDefaultUserDir();
+    this.userDir = detected.path;
+    this.userDirSource = detected.source;
     this.upstreamDir = path.join(this.defaultProvidersDir, '.upstream');
     this.disableUpstream = false;
 
@@ -117,6 +195,7 @@ export class ProviderLoader {
       disableUpstream: this.disableUpstream,
       explicitProviderDir: this.explicitProviderDir,
       userDir: this.userDir,
+      userDirSource: this.userDirSource,
       upstreamDir: this.upstreamDir,
       providerRoots: this.getProviderRoots(),
     };
@@ -138,7 +217,14 @@ export class ProviderLoader {
     }
 
     this.sourceMode = nextSourceMode;
-    this.userDir = this.explicitProviderDir || this.defaultProvidersDir;
+    if (this.explicitProviderDir) {
+      this.userDir = this.explicitProviderDir;
+      this.userDirSource = 'explicit';
+    } else {
+      const detected = this.detectDefaultUserDir();
+      this.userDir = detected.path;
+      this.userDirSource = detected.source;
+    }
     this.upstreamDir = path.join(this.defaultProvidersDir, '.upstream');
     this.disableUpstream = this.sourceMode === 'no-upstream';