@adhdev/daemon-core 0.8.56 → 0.8.58

package/dist/providers/cli-provider-instance.d.ts

@@ -9,6 +9,15 @@ import type { ProviderInstance, ProviderState, InstanceContext } from './provide
 import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
 import type { PtyTransportFactory } from '../cli-adapters/pty-transport.js';
 export declare function getForcedNewSessionScriptName(provider: ProviderModule | undefined, launchMode: 'new' | 'resume' | 'manual'): string | null;
+export declare function waitForCliAdapterReady(adapter: {
+    isReady?: () => boolean;
+    getStatus?: () => {
+        status?: string;
+    };
+}, options?: {
+    timeoutMs?: number;
+    pollMs?: number;
+}): Promise<void>;
 export declare class CliProviderInstance implements ProviderInstance {
     private provider;
     private workingDir;

package/dist/providers/contracts.d.ts

@@ -328,6 +328,7 @@ export interface ProviderModule {
     /** How the CLI adapter decides when to submit typed input */
     submitStrategy?: 'wait_for_echo' | 'immediate';
     /** Keep this provider out of the upstream auto-updated bundle */
+    /** @deprecated Machine-level provider source policy now lives in config.providerSourceMode. Local overrides shadow upstream by root precedence and should not rely on provider-level disableUpstream. */
     disableUpstream?: boolean;
     approvalKeys?: Record<number, string>;
     patterns?: {

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

@@ -14,11 +14,16 @@
  */
 import { VersionArchive } from './version-archive.js';
 import type { ProviderModule, ProviderCategory, ProviderSettingSchema, ResolvedProvider } from './contracts.js';
+import type { ProviderSourceMode } from '../config/config.js';
+import type { ProviderSourceConfigSnapshot } from '../config/provider-source-config.js';
 export declare class ProviderLoader {
     private providers;
     private providerAvailability;
+    private defaultProvidersDir;
+    private explicitProviderDir;
     private userDir;
     private upstreamDir;
+    private sourceMode;
     private disableUpstream;
     private watchers;
     private logFn;
@@ -31,7 +36,9 @@ export declare class ProviderLoader {
     constructor(options?: {
         userDir?: string;
         logFn?: (msg: string) => void;
-        /** Disable upstream auto-download (for dev/testing/OSS) */
+        /** Explicit machine-level provider source policy */
+        sourceMode?: ProviderSourceMode;
+        /** Deprecated alias for sourceMode='no-upstream' */
         disableUpstream?: boolean;
     });
     private log;
@@ -48,6 +55,12 @@ export declare class ProviderLoader {
      * Highest-priority editable overrides come first.
      */
     getProviderRoots(): string[];
+    getSourceConfig(): ProviderSourceConfigSnapshot;
+    applySourceConfig(options?: {
+        userDir?: string;
+        sourceMode?: ProviderSourceMode;
+        disableUpstream?: boolean;
+    }): ProviderSourceConfigSnapshot;
     /**
     * Canonical provider directory shape for a given root.
     */

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

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.8.56",
+  "version": "0.8.58",
   "description": "ADHDev local session host core — 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.56",
+  "version": "0.8.58",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/boot/daemon-lifecycle.ts

@@ -90,6 +90,7 @@ export interface DaemonComponents {
     cdpManagers: Map<string, DaemonCdpManager>;
     sessionRegistry: SessionRegistry;
     detectedIdes: { value: IDEInfo[] };
+    refreshProviderAvailability: (providerType?: string) => Promise<void>;
 }
 
 export interface DaemonDevSupportOptions {
@@ -116,12 +117,13 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
     // 1. Global log interceptor
     installGlobalInterceptor();
 
-    // 2. ProviderLoader (disableUpstream from config.json)
+    // 2. ProviderLoader (provider source mode from config.json)
     const appConfig = loadConfig();
-    const disableUpstream = appConfig.disableUpstream ?? false;
+    const providerSourceMode = appConfig.providerSourceMode || 'normal';
+    const disableUpstream = providerSourceMode === 'no-upstream';
     const providerLoader = new ProviderLoader({
         logFn: config.providerLogFn,
-        disableUpstream,
+        sourceMode: providerSourceMode,
         userDir: appConfig.providerDir,
     });
 
@@ -253,6 +255,10 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
             await refreshProviderAvailability(providerType);
             config.onStatusChange?.();
         },
+        onProviderSourceConfigChanged: async () => {
+            await refreshProviderAvailability();
+            config.onStatusChange?.();
+        },
     });
 
     // 8. AgentStreamManager
@@ -312,6 +318,7 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         cdpManagers,
         sessionRegistry,
         detectedIdes: detectedIdesRef,
+        refreshProviderAvailability,
     };
 }
 
@@ -327,6 +334,9 @@ export async function startDaemonDevSupport(options: DaemonDevSupportOptions): P
         instanceManager: options.components.instanceManager,
         cliManager: options.components.cliManager,
         logFn: options.logFn,
+        onProviderSourceConfigChanged: async () => {
+            await options.components.refreshProviderAvailability();
+        },
     });
     await devServer.start();
     options.components.providerLoader.watch();

package/src/commands/handler.ts

@@ -46,6 +46,7 @@ export interface CommandContext {
     instanceManager?: ProviderInstanceManager;
     sessionRegistry?: SessionRegistry;
     onProviderSettingChanged?: (providerType: string, key: string, value: any) => Promise<void> | void;
+    onProviderSourceConfigChanged?: () => Promise<void> | void;
 }
 
 /**
@@ -502,6 +503,8 @@ export class DaemonCommandHandler implements CommandHelpers {
             // ─── Provider Settings (stream-commands.ts) ──────────
             case 'get_provider_settings': return Stream.handleGetProviderSettings(this, args);
             case 'set_provider_setting': return Stream.handleSetProviderSetting(this, args);
+            case 'get_provider_source_config': return Stream.handleGetProviderSourceConfig(this, args);
+            case 'set_provider_source_config': return Stream.handleSetProviderSourceConfig(this, args);
 
             // ─── IDE Extension Settings (stream-commands.ts) ──────────
             case 'get_ide_extensions': return Stream.handleGetIdeExtensions(this, args);

package/src/commands/router.ts

@@ -382,8 +382,9 @@ export class DaemonCommandRouter {
                     return { success: false, error: 'providerType required' };
                 }
 
-                const offset = Math.max(0, Number(args?.offset) || 0);
-                const limit = Math.max(1, Math.min(100, Number(args?.limit) || 30));
+                const wantsAll = args?.all === true;
+                const offset = wantsAll ? 0 : Math.max(0, Number(args?.offset) || 0);
+                const limit = wantsAll ? Number.MAX_SAFE_INTEGER : Math.max(1, Math.min(100, Number(args?.limit) || 30));
                 const { sessions: historySessions, hasMore } = listSavedHistorySessions(providerType, { offset, limit });
                 const state = loadState();
                 const savedSessions = getSavedProviderSessions(state, { providerType, kind });
@@ -406,13 +407,13 @@ export class DaemonCommandRouter {
                             providerName: saved?.providerName || recent?.providerName || providerType,
                             kind: saved?.kind || recent?.kind || kind,
                             title: saved?.title || recent?.title || session.sessionTitle || session.preview || providerType,
-                            workspace: saved?.workspace || recent?.workspace,
+                            workspace: saved?.workspace || recent?.workspace || session.workspace,
                             currentModel: saved?.currentModel || recent?.currentModel,
                             preview: session.preview,
                             messageCount: session.messageCount,
                             firstMessageAt: session.firstMessageAt,
                             lastMessageAt: session.lastMessageAt,
-                            canResume: !!(saved?.workspace || recent?.workspace) && canResumeById,
+                            canResume: !!(saved?.workspace || recent?.workspace || session.workspace) && canResumeById,
                         };
                     }),
                     hasMore,

package/src/commands/stream-commands.ts

@@ -6,6 +6,8 @@
 import type { CommandResult, CommandHelpers } from './handler.js';
 import type { ProviderLoader } from '../providers/provider-loader.js';
 import type { ProviderInstance } from '../providers/provider-instance.js';
+import { loadConfig, saveConfig } from '../config/config.js';
+import { parseProviderSourceConfigUpdate } from '../config/provider-source-config.js';
 import { getCliScriptCommand, parseCliScriptResult } from '../providers/cli-script-results.js';
 import {
     normalizeControlInvokeResult,
@@ -107,6 +109,45 @@ export async function handleSetProviderSetting(h: CommandHelpers, args: any): Pr
     return { success: false, error: `Failed to set ${providerType}.${key} — invalid key, value, or not a public setting` };
 }
 
+export function handleGetProviderSourceConfig(h: CommandHelpers, _args: any): CommandResult {
+    const loader = h.ctx.providerLoader as ProviderLoader | undefined;
+    if (!loader) return { success: false, error: 'providerLoader not available' };
+    return { success: true, ...loader.getSourceConfig() };
+}
+
+export async function handleSetProviderSourceConfig(h: CommandHelpers, args: any): Promise<CommandResult> {
+    const loader = h.ctx.providerLoader as ProviderLoader | undefined;
+    if (!loader) return { success: false, error: 'providerLoader not available' };
+
+    const parsed = parseProviderSourceConfigUpdate(args || {});
+    if ('error' in parsed) {
+        return { success: false, error: parsed.error };
+    }
+
+    const currentConfig = loadConfig();
+    const nextConfig = {
+        ...currentConfig,
+        ...(parsed.updates.providerSourceMode ? { providerSourceMode: parsed.updates.providerSourceMode } : {}),
+        ...(Object.prototype.hasOwnProperty.call(parsed.updates, 'providerDir') ? { providerDir: parsed.updates.providerDir } : {}),
+    };
+    saveConfig(nextConfig);
+
+    const sourceConfig = loader.applySourceConfig({
+        sourceMode: nextConfig.providerSourceMode,
+        userDir: Object.prototype.hasOwnProperty.call(parsed.updates, 'providerDir') ? parsed.updates.providerDir : loader.getSourceConfig().explicitProviderDir || undefined,
+    });
+    loader.reload();
+    loader.registerToDetector();
+    await h.ctx.onProviderSourceConfigChanged?.();
+
+    LOG.info(
+        'Command',
+        `[set_provider_source_config] mode=${sourceConfig.sourceMode} explicitProviderDir=${sourceConfig.explicitProviderDir || '-'} userDir=${sourceConfig.userDir}`,
+    );
+
+    return { success: true, reloaded: true, ...sourceConfig };
+}
+
 // ─── Extension Script Execution (Model/Mode) ─────
 
 function normalizeProviderScriptArgs(args: any): Record<string, any> {

package/src/config/chat-history.ts

@@ -27,6 +27,7 @@ interface HistoryMessage {
     instanceId?: string;  // IDE instance UUID (distinguishes windows of the same agent type)
     historySessionId?: string; // Persistent provider-side conversation/session key
     sessionTitle?: string;
+    workspace?: string;   // Working directory at session start (kind: 'session_start' only)
 }
 
 const CODEX_STARTER_PROMPT_RE = /^(?:[›❯]\s*)?(?:Find and fix a bug in @filename|Improve documentation in @filename|Write tests for @filename|Explain this codebase|Summarize recent commits|Implement \{feature\}|Use \/skills(?: to list available skills)?|Run \/review on my current changes)$/i;
@@ -123,6 +124,7 @@ export interface SavedHistorySessionSummary {
     firstMessageAt: number;
     lastMessageAt: number;
     preview?: string;
+    workspace?: string;
 }
 
 export class ChatHistoryWriter {
@@ -325,6 +327,37 @@ export class ChatHistoryWriter {
         );
     }
 
+    writeSessionStart(
+        agentType: string,
+        historySessionId: string,
+        workspace: string,
+        instanceId?: string,
+    ): void {
+        const id = String(historySessionId || '').trim();
+        const ws = String(workspace || '').trim();
+        if (!id || !ws) return;
+        try {
+            const dir = path.join(HISTORY_DIR, this.sanitize(agentType));
+            fs.mkdirSync(dir, { recursive: true });
+            const date = new Date().toISOString().slice(0, 10);
+            const filePath = path.join(dir, `${this.sanitize(id)}_${date}.jsonl`);
+            const record: HistoryMessage = {
+                ts: new Date().toISOString(),
+                receivedAt: Date.now(),
+                role: 'system',
+                kind: 'session_start',
+                content: ws,
+                agent: agentType,
+                instanceId,
+                historySessionId: id,
+                workspace: ws,
+            };
+            fs.appendFileSync(filePath, JSON.stringify(record) + '\n', 'utf-8');
+        } catch {
+            // Ignore — must not affect main functionality
+        }
+    }
+
     promoteHistorySession(
         agentType: string,
         previousHistorySessionId: string,
@@ -606,6 +639,7 @@ export function listSavedHistorySessions(
             let lastMessageAt = 0;
             let sessionTitle = '';
             let preview = '';
+            let workspace = '';
 
             for (const file of files.sort()) {
                 const filePath = path.join(dir, file);
@@ -619,6 +653,10 @@ export function listSavedHistorySessions(
                         parsed = null;
                     }
                     if (!parsed || parsed.historySessionId !== historySessionId) continue;
+                    if (parsed.kind === 'session_start') {
+                        if (!workspace && parsed.workspace) workspace = parsed.workspace;
+                        continue;
+                    }
                     messageCount += 1;
                     if (!firstMessageAt || parsed.receivedAt < firstMessageAt) firstMessageAt = parsed.receivedAt;
                     if (!lastMessageAt || parsed.receivedAt > lastMessageAt) lastMessageAt = parsed.receivedAt;
@@ -635,6 +673,7 @@ export function listSavedHistorySessions(
                 firstMessageAt,
                 lastMessageAt,
                 preview: preview || undefined,
+                workspace: workspace || undefined,
             });
         }
 

package/src/config/config.d.ts

@@ -8,6 +8,8 @@ export type { WorkspaceEntry } from './workspaces.js';
 export type { RecentActivityEntry } from './recent-activity.js';
 export type { SavedProviderSessionEntry } from './saved-sessions.js';
 export type { DaemonState } from './state-store.js';
+export type ProviderSourceMode = 'normal' | 'no-upstream';
+export declare function resolveProviderSourceMode(providerSourceMode: unknown, legacyDisableUpstream: unknown): ProviderSourceMode;
 export interface ADHDevConfig {
     serverUrl: string;
     selectedIde: string | null;
@@ -45,6 +47,7 @@ export interface ADHDevConfig {
         }>;
     }>;
     disableUpstream?: boolean;
+    providerSourceMode?: ProviderSourceMode;
     providerDir?: string;
     /**
      * Browser terminal sizing behavior for dashboard CLI panes.

package/src/config/config.ts

@@ -14,6 +14,18 @@ export type { RecentActivityEntry } from './recent-activity.js';
 export type { SavedProviderSessionEntry } from './saved-sessions.js';
 export type { DaemonState } from './state-store.js';
 
+export type ProviderSourceMode = 'normal' | 'no-upstream';
+
+export function resolveProviderSourceMode(
+    providerSourceMode: unknown,
+    legacyDisableUpstream: unknown,
+): ProviderSourceMode {
+    if (providerSourceMode === 'normal' || providerSourceMode === 'no-upstream') {
+        return providerSourceMode;
+    }
+    return legacyDisableUpstream === true ? 'no-upstream' : 'normal';
+}
+
 export interface ADHDevConfig {
  // Server connection
     serverUrl: string;
@@ -81,9 +93,13 @@ export interface ADHDevConfig {
 
  // Disable upstream provider auto-download (use builtin only)
  // Controllable from CLI (--no-upstream) and dashboard (machine page)
+ // Deprecated legacy boolean; prefer providerSourceMode.
     disableUpstream?: boolean;
 
- // Optional custom provider directory for local development
+ // Explicit machine-level provider source policy.
+    providerSourceMode?: ProviderSourceMode;
+
+ // Optional explicit provider override root (for example a local adhdev-providers checkout)
     providerDir?: string;
 
     /**
@@ -113,7 +129,7 @@ const DEFAULT_CONFIG: ADHDevConfig = {
     registeredMachineId: undefined,
     providerSettings: {},
     ideSettings: {},
-    disableUpstream: false,
+    providerSourceMode: 'normal',
     terminalSizingMode: 'measured',
 };
 
@@ -164,7 +180,7 @@ function normalizeConfig(raw: unknown): ADHDevConfig & { activeWorkspaceId?: str
         registeredMachineId: asOptionalString(parsed.registeredMachineId),
         providerSettings: isPlainObject(parsed.providerSettings) ? parsed.providerSettings : {},
         ideSettings: isPlainObject(parsed.ideSettings) ? parsed.ideSettings : {},
-        disableUpstream: asBoolean(parsed.disableUpstream, DEFAULT_CONFIG.disableUpstream ?? false),
+        providerSourceMode: resolveProviderSourceMode(parsed.providerSourceMode, parsed.disableUpstream),
         providerDir: asOptionalString(parsed.providerDir),
         terminalSizingMode: parsed.terminalSizingMode === 'fit' ? 'fit' : 'measured',
     };

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

@@ -0,0 +1,42 @@
+import type { ProviderSourceMode } from './config.js'
+
+export interface ProviderSourceConfigSnapshot {
+  sourceMode: ProviderSourceMode
+  disableUpstream: boolean
+  explicitProviderDir: string | null
+  userDir: string
+  upstreamDir: string
+  providerRoots: string[]
+}
+
+export interface ProviderSourceConfigUpdate {
+  providerSourceMode?: ProviderSourceMode
+  providerDir?: string | undefined
+}
+
+function normalizeProviderDir(value: unknown): string | undefined {
+  if (typeof value !== 'string') return undefined
+  const trimmed = value.trim()
+  return trimmed ? trimmed : undefined
+}
+
+export function parseProviderSourceConfigUpdate(input: {
+  providerSourceMode?: unknown
+  providerDir?: unknown
+}): { ok: true; updates: ProviderSourceConfigUpdate } | { ok: false; error: string } {
+  const updates: ProviderSourceConfigUpdate = {}
+
+  if (Object.prototype.hasOwnProperty.call(input, 'providerSourceMode')) {
+    const { providerSourceMode } = input
+    if (providerSourceMode !== 'normal' && providerSourceMode !== 'no-upstream') {
+      return { ok: false, error: "providerSourceMode must be 'normal' or 'no-upstream'" }
+    }
+    updates.providerSourceMode = providerSourceMode
+  }
+
+  if (Object.prototype.hasOwnProperty.call(input, 'providerDir')) {
+    updates.providerDir = normalizeProviderDir(input.providerDir)
+  }
+
+  return { ok: true, updates }
+}

package/src/daemon/dev-auto-implement.ts

@@ -141,19 +141,6 @@ export function resolveAutoImplWritableProviderDir(ctx: DevServerContext,
     return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
   }
 
-  try {
-    const providerData = JSON.parse(fs.readFileSync(providerJson, 'utf-8'));
-    if (providerData.disableUpstream !== true) {
-      providerData.disableUpstream = true;
-      fs.writeFileSync(providerJson, JSON.stringify(providerData, null, 2));
-    }
-  } catch (error) {
-    return {
-      dir: null,
-      reason: `Failed to update provider.json in writable provider directory: ${(error as Error).message}`,
-    };
-  }
-
   return { dir: desiredDir };
 }
 

package/src/daemon/dev-server-types.ts

@@ -20,6 +20,7 @@ export interface DevServerContext {
   readonly cdpManagers: Map<string, DaemonCdpManager>;
   readonly instanceManager: ProviderInstanceManager | null;
   readonly cliManager: DaemonCliManager | null;
+  readonly onProviderSourceConfigChanged?: (() => Promise<void> | void) | null;
 
   // Utilities
   getCdp(ideType?: string): DaemonCdpManager | null;

package/src/daemon/dev-server.ts

@@ -22,6 +22,8 @@ import * as os from 'os';
 import type { ProviderLoader } from '../providers/provider-loader.js';
 import type { ProviderCategory, ProviderModule, ProviderScripts, ProviderSettingDef } from '../providers/contracts.js';
 import { validateProviderDefinition } from '../providers/provider-schema.js';
+import { loadConfig, saveConfig } from '../config/config.js';
+import { parseProviderSourceConfigUpdate } from '../config/provider-source-config.js';
 import type { ChildProcess } from 'child_process';
 import type { DaemonCdpManager } from '../cdp/manager.js';
 import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
@@ -100,6 +102,7 @@ export class DevServer implements DevServerContext {
   public cdpManagers: Map<string, DaemonCdpManager>;
   public instanceManager: ProviderInstanceManager | null;
   public cliManager: DaemonCliManager | null;
+  public onProviderSourceConfigChanged: (() => Promise<void> | void) | null;
   private logFn: (msg: string) => void;
   private sseClients: http.ServerResponse[] = [];
   private watchScriptPath: string | null = null;
@@ -120,11 +123,13 @@ export class DevServer implements DevServerContext {
     instanceManager?: ProviderInstanceManager;
     cliManager?: DaemonCliManager;
     logFn?: (msg: string) => void;
+    onProviderSourceConfigChanged?: () => Promise<void> | void;
   }) {
     this.providerLoader = options.providerLoader;
     this.cdpManagers = options.cdpManagers;
     this.instanceManager = options.instanceManager || null;
     this.cliManager = options.cliManager || null;
+    this.onProviderSourceConfigChanged = options.onProviderSourceConfigChanged || null;
     this.logFn = options.logFn || LOG.forComponent('DevServer').asLogFn();
   }
 
@@ -140,6 +145,8 @@ export class DevServer implements DevServerContext {
   }[] = [
     // Static routes
     { method: 'GET',  pattern: '/api/providers',          handler: (q, s) => this.handleListProviders(q, s) },
+    { method: 'GET',  pattern: '/api/providers/source-config', handler: (q, s) => this.handleGetProviderSourceConfig(q, s) },
+    { method: 'POST', pattern: '/api/providers/source-config', handler: (q, s) => this.handleSetProviderSourceConfig(q, s) },
     { method: 'GET',  pattern: '/api/providers/versions',  handler: (q, s) => this.handleDetectVersions(q, s) },
     { method: 'POST', pattern: '/api/providers/reload',    handler: (q, s) => this.handleReload(q, s) },
     { method: 'POST', pattern: '/api/cdp/evaluate',        handler: (q, s) => this.handleCdpEvaluate(q, s) },
@@ -273,7 +280,38 @@ export class DevServer implements DevServerContext {
 
   private async handleListProviders(_req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
     const providers = this.providerLoader.getAll().map(toProviderListEntry);
-    this.json(res, 200, { providers, count: providers.length });
+    this.json(res, 200, { providers, count: providers.length, sourceConfig: this.providerLoader.getSourceConfig() });
+  }
+
+  private async handleGetProviderSourceConfig(_req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+    this.json(res, 200, { success: true, sourceConfig: this.providerLoader.getSourceConfig() });
+  }
+
+  private async handleSetProviderSourceConfig(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+    const body = await this.readBody(req);
+    const parsed = parseProviderSourceConfigUpdate(body || {});
+    if (!parsed.ok) {
+      this.json(res, 400, { success: false, error: parsed.error });
+      return;
+    }
+
+    const currentConfig = loadConfig();
+    const nextConfig = {
+      ...currentConfig,
+      ...(parsed.updates.providerSourceMode ? { providerSourceMode: parsed.updates.providerSourceMode } : {}),
+      ...(Object.prototype.hasOwnProperty.call(parsed.updates, 'providerDir') ? { providerDir: parsed.updates.providerDir } : {}),
+    };
+    saveConfig(nextConfig);
+
+    const sourceConfig = this.providerLoader.applySourceConfig({
+      sourceMode: nextConfig.providerSourceMode,
+      userDir: Object.prototype.hasOwnProperty.call(parsed.updates, 'providerDir') ? parsed.updates.providerDir : this.providerLoader.getSourceConfig().explicitProviderDir || undefined,
+    });
+    this.providerLoader.reload();
+    this.providerLoader.registerToDetector();
+    await this.onProviderSourceConfigChanged?.();
+
+    this.json(res, 200, { success: true, reloaded: true, sourceConfig });
   }
 
   private async handleProviderConfig(type: string, _req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
@@ -994,27 +1032,14 @@ export class DevServer implements DevServerContext {
       this.log(`Auto-implement writable copy created: ${desiredDir}`);
     }
 
-    const providerJson = path.join(desiredDir, 'provider.json');
-    if (!fs.existsSync(providerJson)) {
-      return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
-    }
-
-    try {
-      const providerData = JSON.parse(fs.readFileSync(providerJson, 'utf-8'));
-      if (providerData.disableUpstream !== true) {
-        providerData.disableUpstream = true;
-        fs.writeFileSync(providerJson, JSON.stringify(providerData, null, 2));
-      }
-    } catch (error) {
-      return {
-        dir: null,
-        reason: `Failed to update provider.json in writable provider directory: ${(error as Error).message}`,
-      };
-    }
-
-    return { dir: desiredDir };
+  const providerJson = path.join(desiredDir, 'provider.json');
+  if (!fs.existsSync(providerJson)) {
+    return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
   }
 
+  return { dir: desiredDir };
+}
+
 
   private async handleAutoImplement(type: string, req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
     return handleAutoImplement(this, type, req, res);

package/src/index.ts

@@ -195,6 +195,8 @@ export { IdeProviderInstance } from './providers/ide-provider-instance.js';
 export { CliProviderInstance } from './providers/cli-provider-instance.js';
 export { AcpProviderInstance } from './providers/acp-provider-instance.js';
 export type { ProviderModule, CdpTargetFilter, ProviderResumeCapability, InputEnvelope, InputPart, MessagePart, ControlListResult, ControlSetResult, ControlInvokeResult } from './providers/contracts.js';
+export type { ProviderSourceConfigSnapshot, ProviderSourceConfigUpdate } from './config/provider-source-config.js';
+export { parseProviderSourceConfigUpdate } from './config/provider-source-config.js';
 export { normalizeInputEnvelope, normalizeMessageParts, flattenMessageParts } from './providers/io-contracts.js';
 export { VersionArchive, detectAllVersions } from './providers/version-archive.js';
 export type { ProviderVersionInfo, VersionHistory } from './providers/version-archive.js';

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

@@ -55,6 +55,9 @@ export function getForcedNewSessionScriptName(
     const controls = Array.isArray((provider as any).controls) ? (provider as any).controls : [];
     for (const control of controls) {
         if (control?.type !== 'action') continue;
+        if (typeof control?.confirmTitle === 'string' && control.confirmTitle.trim()) continue;
+        if (typeof control?.confirmMessage === 'string' && control.confirmMessage.trim()) continue;
+        if (typeof control?.confirmLabel === 'string' && control.confirmLabel.trim()) continue;
         const invokeScript = typeof control?.invokeScript === 'string' ? control.invokeScript.trim() : '';
         if (!invokeScript) continue;
         const controlId = typeof control?.id === 'string' ? control.id.trim() : '';
@@ -66,6 +69,26 @@ export function getForcedNewSessionScriptName(
     return null;
 }
 
+export async function waitForCliAdapterReady(
+    adapter: { isReady?: () => boolean; getStatus?: () => { status?: string } },
+    options?: { timeoutMs?: number; pollMs?: number },
+): Promise<void> {
+    const timeoutMs = Math.max(100, options?.timeoutMs ?? 15_000);
+    const pollMs = Math.max(10, options?.pollMs ?? 50);
+    const deadline = Date.now() + timeoutMs;
+
+    while (Date.now() < deadline) {
+        if (adapter?.isReady?.()) return;
+        const status = adapter?.getStatus?.()?.status;
+        if (status === 'stopped') {
+            throw new Error('CLI runtime stopped before it became ready');
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollMs));
+    }
+
+    throw new Error(`CLI runtime did not become ready within ${timeoutMs}ms`);
+}
+
 export class CliProviderInstance implements ProviderInstance {
     readonly type: string;
     readonly category = 'cli' as const;
@@ -427,6 +450,7 @@ export class CliProviderInstance implements ProviderInstance {
         if (!scriptName) return;
 
         LOG.info('CLI', `[${this.type}] forcing fresh session launch via script: ${scriptName}`);
+        await waitForCliAdapterReady(this.adapter);
         const raw = await this.adapter.invokeScript(scriptName, {});
         const parsed = parseCliScriptResult(raw);
         if (!parsed.success) {
@@ -819,6 +843,7 @@ export class CliProviderInstance implements ProviderInstance {
         const previousProviderSessionId = this.providerSessionId;
         this.providerSessionId = nextSessionId;
         this.historyWriter.promoteHistorySession(this.type, previousHistorySessionId, nextSessionId);
+        this.historyWriter.writeSessionStart(this.type, nextSessionId, this.workingDir, this.instanceId);
         this.adapter.updateRuntimeMeta({ providerSessionId: nextSessionId });
         this.onProviderSessionResolved?.({
             instanceId: this.instanceId,

package/src/providers/contracts.ts

@@ -414,6 +414,7 @@ export interface ProviderModule {
   /** How the CLI adapter decides when to submit typed input */
   submitStrategy?: 'wait_for_echo' | 'immediate';
   /** Keep this provider out of the upstream auto-updated bundle */
+  /** @deprecated Machine-level provider source policy now lives in config.providerSourceMode. Local overrides shadow upstream by root precedence and should not rely on provider-level disableUpstream. */
   disableUpstream?: boolean;
   approvalKeys?: Record<number, string>;
   patterns?: {