@adhdev/daemon-core 0.9.82-rc.164 → 0.9.82-rc.166

package/dist/providers/external-sources.d.ts

@@ -0,0 +1,71 @@
+export interface ExternalSource {
+    /** Unique short identifier, e.g. "@vendor-x". User-supplied or derived from the URL. */
+    name: string;
+    /** Full git URL (https://, git@, …). */
+    url: string;
+    /** Branch / tag / commit-ish to track. Defaults to `main`. */
+    ref: string;
+    /** ISO timestamp when first registered. */
+    addedAt: string;
+}
+export interface ExternalSourcesFile {
+    /** Schema version — bump if shape changes. */
+    schema: 1;
+    sources: ExternalSource[];
+}
+/**
+ * Per-type active source selection. Only types reachable from more than
+ * one source need an entry — single-source types have no ambiguity.
+ *
+ * Shape: { active: { "<type>": "<source-name>" } }
+ */
+export interface ProvidersActiveFile {
+    schema: 1;
+    active: Record<string, string>;
+}
+export declare function externalRoot(): string;
+export declare function sourcesFilePath(): string;
+export declare function activeFilePath(): string;
+export declare function loadExternalSources(): ExternalSourcesFile;
+export declare function saveExternalSources(file: ExternalSourcesFile): void;
+export declare function loadProvidersActive(): ProvidersActiveFile;
+export declare function saveProvidersActive(file: ProvidersActiveFile): void;
+/**
+ * Derive a short identifier from a git URL when the user didn't supply one.
+ *   https://github.com/vendor/extra-providers.git → "@vendor-extra-providers"
+ *   git@github.com:vendor/extra-providers       → "@vendor-extra-providers"
+ *
+ * Idempotent; safe to call before validation since it produces a string
+ * regardless of input shape.
+ */
+export declare function deriveSourceName(url: string): string;
+/**
+ * Return the per-source category/type tree currently on disk under
+ * ~/.adhdev/external/<source>/. Used by the conflict detector and by
+ * list_provider_sources.
+ */
+export interface SourceInventoryEntry {
+    sourceName: string;
+    /** Map: category → list of provider types. */
+    providers: Record<string, string[]>;
+}
+export declare function inventoryExternalSources(): SourceInventoryEntry[];
+/**
+ * For a given category+type, list every source that currently exposes it.
+ * Returns source names in disk-walk order; callers can use the first one
+ * when no explicit active selection exists.
+ */
+export declare function sourcesProviding(category: string, type: string): string[];
+/**
+ * Resolve which source should be active for a given category+type.
+ *   - If exactly one source provides it → that source.
+ *   - If multiple sources provide it → the one named in providers-active.json
+ *     (when present) or null (ambiguous; loader should warn and pick
+ *     the first deterministically so daemon doesn't refuse to boot).
+ *   - If none → null.
+ */
+export declare function resolveActiveSource(category: string, type: string, activeFile?: ProvidersActiveFile): {
+    source: string | null;
+    ambiguous: boolean;
+    candidates: string[];
+};

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

@@ -86,6 +86,7 @@ export declare class ProviderLoader {
          */
         probeStarts?: string[];
     });
+    private migrateMarketplaceDirToExternal;
     private log;
     private debugLog;
     /**
@@ -130,9 +131,12 @@ export declare class ProviderLoader {
     resolveProviderFile(type: string, ...segments: string[]): string | null;
     /**
     * Load all providers (3-tier priority)
-    * 1. .upstream/ (GitHub auto-download — primary source)
-    * 2. User custom (~/.adhdev/providers/ excluding .upstream)
-    * User custom always wins (highest priority).
+    * 1. ~/.adhdev/providers/.upstream/ — official git, auto-synced
+    * 2. ~/.adhdev/external/ — 3rd-party git sources, user-added,
+    *    bundled providers may include arbitrary JS (untrusted by default)
+    * 3. ~/.adhdev/providers/ (excluding .upstream) — user-authored customs,
+    *    always wins
+    * Highest priority listed last (overwrites earlier loads).
     * If .upstream/ is empty, call fetchLatest() before loadAll().
     */
     loadAll(): void;

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

@@ -0,0 +1,31 @@
+export type ProviderTrust = 'user-custom' | 'trusted' | 'trusted-with-scripts' | 'external-safe' | 'external-untrusted';
+export type ProviderLayer = 'user' | 'upstream' | 'external';
+export interface ProviderManifestShape {
+    /** Has a `tui` block — SDK builders consume it as code paths. */
+    hasTui: boolean;
+    /** Has a non-empty `overrides` object — JS override paths. */
+    hasOverrides: boolean;
+    /** compatibility[].scriptDir or defaultScriptDir is set — JS scripts dir. */
+    hasScriptDir: boolean;
+}
+/**
+ * Inspect a manifest to decide whether it ships JavaScript hooks.
+ * Cheap; pure; safe to call on every provider load.
+ */
+export declare function inspectManifestShape(manifest: Record<string, unknown>): ProviderManifestShape;
+/**
+ * Classify trust given the layer the provider was loaded from + the
+ * manifest's JS-hook footprint.
+ */
+export declare function classifyTrust(layer: ProviderLayer, shape: ProviderManifestShape): ProviderTrust;
+/**
+ * Returns true when activation should require an explicit user confirm.
+ * Today only `external-untrusted` qualifies; future trust levels may
+ * fold in here.
+ */
+export declare function requiresConfirmation(trust: ProviderTrust): boolean;
+/**
+ * Render a short human-readable rationale for the trust tag. Used by
+ * the dashboard's confirmation modal and the provider catalog tooltip.
+ */
+export declare function describeTrust(trust: ProviderTrust): string;

package/dist/providers/sdk/v1/index.d.ts

@@ -24,7 +24,7 @@ export declare const V1_PRIMITIVE_CATALOG: Readonly<{
     readonly common: readonly ["adhdev:common/setting-boolean@1", "adhdev:common/setting-number@1", "adhdev:common/setting-string@1", "adhdev:common/setting-select@1", "adhdev:common/capability-input@1", "adhdev:common/capability-output@1", "adhdev:common/capability-controls@1", "adhdev:common/auth-env-var@1", "adhdev:common/auth-cli-command@1", "adhdev:common/spawn@1", "adhdev:common/timeouts@1", "adhdev:common/resume@1", "adhdev:common/mesh-coordinator@1"];
     readonly override: readonly ["adhdev:override/cli-parse-session@1", "adhdev:override/cli-detect-status@1", "adhdev:override/cli-parse-approval@1", "adhdev:override/cli-parse-output@1", "adhdev:override/cli-read-native-history@1", "adhdev:override/cli-list-native-history@1", "adhdev:override/cli-capability-handler@1"];
 }>;
-/** Aggregate flat list — for marketplace catalog endpoint. */
+/** Aggregate flat list — for provider catalog endpoints. */
 export declare const V1_ALL_PRIMITIVES: ReadonlyArray<string>;
 /** Catalog version label exposed at `registry.adhf.dev/primitives`. */
 export declare const V1_CONTRACT_VERSION: "1.0.0";

package/dist/providers/sdk/v1/validators/manifest.d.ts

@@ -9,7 +9,7 @@
  * offending field without guessing.
  *
  * Validation lives in the SDK layer (not in provider-loader) so dashboards,
- * registry workers, and the marketplace publish flow can all reuse the
+ * registry workers, and the provider publish flow can all reuse the
  * same code path and produce identical error messages.
  */
 export interface ManifestValidationIssue {

package/dist/providers/sdk/v1/validators/taint.d.ts

@@ -2,7 +2,7 @@
  * Static taint analyzer for extended-tier override JS.
  *
  * Goal: classify the override JS shipped with an extended-tier provider into
- * one of three risk tiers, so the marketplace + daemon trust prompt can
+ * one of three risk tiers, so the dashboard + daemon trust prompt can
  * surface accurate language to the operator instead of a single generic
  * "this provider contains JS" warning.
  *

package/dist/providers/spec/cli-adapter.d.ts

@@ -4,6 +4,15 @@ export declare class SpecCliAdapter implements CliAdapter {
     readonly cliType: string;
     readonly cliName: string;
     readonly workingDir: string;
+    /**
+     * Marker the daemon's finalization gate checks: `getStatus()` returns
+     * `messages: []` by design here (chat history lives in the daemon's
+     * native-history pipeline, not the adapter). Without this flag,
+     * cli-provider-instance's `missing_final_assistant` gate would stall
+     * every turn until the 30s safety timeout because it expects the
+     * adapter to surface the final assistant message.
+     */
+    readonly chatMessagesOwnedExternally: true;
     private driver;
     private spec;
     private lastEvent;

package/dist/shared-types.d.ts

@@ -422,7 +422,33 @@ export interface AvailableProviderInfo {
     lastVerification?: MachineProviderCheckResult;
     /** Provider-declared Repo Mesh coordinator/MCP behavior. */
     meshCoordinator?: ProviderMeshCoordinatorConfig;
-}
+    /**
+     * Provider trust classification — derived from the on-disk layer the
+     * manifest came from and the shape of the manifest. Dashboards use
+     * this to render a trust badge and gate activation of
+     * `external-untrusted` providers behind a confirm modal.
+     */
+    trust?: ProviderTrust;
+    /** Daemon-side human-readable description of the trust value. */
+    trustDescription?: string;
+    /** True when activation needs a user-side confirmation step. */
+    requiresConfirmation?: boolean;
+    /** Which on-disk layer the manifest lives in. */
+    sourceLayer?: 'user' | 'upstream' | 'external';
+    /** For external providers, the source-name namespace it came from. */
+    sourceName?: string | null;
+    /** Manifest-declared version, e.g. "1.2.1". */
+    providerVersion?: string;
+    /** Underlying executable name (CLI/binary providers). */
+    binary?: string;
+    /** Lifecycle label from the manifest: "Stable", "Beta", … */
+    status?: string;
+    /** One-line provider description from the manifest. */
+    details?: string;
+    /** Manifest-declared links: homepage, docs, repo, … */
+    links?: Record<string, string>;
+}
+export type ProviderTrust = 'user-custom' | 'trusted' | 'trusted-with-scripts' | 'external-safe' | 'external-untrusted';
 export interface MachineProviderCheckResult {
     ok: boolean;
     stage?: 'detection' | 'runnable' | 'verification';

package/package.json

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

package/src/commands/cli-manager.ts

@@ -1099,6 +1099,25 @@ export class DaemonCliManager {
                         env: args?.env,
                     })
                     : null;
+                // Untrusted-provider gate: an external source that ships JS
+                // hooks needs explicit user confirmation before its first
+                // launch. Dashboards add `confirmExternalUntrusted: true` to
+                // the launch args after showing the trust modal. Without
+                // that ack we refuse to spawn and tell the caller why.
+                const provLookup = this.providerLoader.getMeta(this.providerLoader.resolveAlias(cliType)) as any;
+                const provTrust = provLookup?._sourceTrust;
+                if (provTrust === 'external-untrusted' && args?.confirmExternalUntrusted !== true) {
+                    return {
+                        success: false,
+                        error: 'untrusted_external_provider',
+                        provider: {
+                            type: provLookup?.type ?? cliType,
+                            sourceName: provLookup?._sourceName ?? null,
+                            trust: provTrust,
+                        },
+                        hint: 'Resend launch_cli with confirmExternalUntrusted=true after the user explicitly approves running JavaScript from this 3rd-party source.',
+                    };
+                }
                 const started = await this.startSession(
                     cliType,
                     dir,

package/src/commands/handler.ts

@@ -515,6 +515,10 @@ export class DaemonCommandHandler implements CommandHelpers {
             case 'uninstall_provider_manifest': return this.handleUninstallProviderManifest(args);
             case 'check_provider_updates': return this.handleCheckProviderUpdates(args);
             case 'list_installed_providers': return this.handleListInstalledProviders(args);
+            case 'add_provider_source': return this.handleAddProviderSource(args);
+            case 'remove_provider_source': return this.handleRemoveProviderSource(args);
+            case 'list_provider_sources': return this.handleListProviderSources(args);
+            case 'set_active_provider_source': return this.handleSetActiveProviderSource(args);
 
             // ─── Stream commands (stream-commands.ts) ───────────
             case 'select_session': return Stream.handleSelectSession(this, args);
@@ -575,18 +579,23 @@ export class DaemonCommandHandler implements CommandHelpers {
     }
 
     /**
-     * Return per-provider availability so a Marketplace UI can show
-     * "Installed" badges. Reuses the existing detection state from
+     * Return per-provider availability so the dashboard's provider catalog
+     * can show "Installed" badges. Reuses the existing detection state from
      * ProviderLoader.getMachineProviderStatus() — no probing is triggered.
      */
     private handleListProviderAvailability(_args: any): CommandResult {
         if (!this._ctx.providerLoader) {
             return { success: false, error: 'ProviderLoader not initialized' };
         }
+        const { describeTrust, requiresConfirmation } =
+            require('../providers/provider-trust.js') as typeof import('../providers/provider-trust.js');
         const loader = this._ctx.providerLoader;
         const items = loader.getAll().map((provider) => {
             const machineConfig = loader.getMachineProviderConfig(provider.type);
             const lastDetection = machineConfig.lastDetection;
+            const trust = (provider as any)._sourceTrust ?? 'trusted';
+            const layer = (provider as any)._sourceLayer ?? 'upstream';
+            const sourceName = (provider as any)._sourceName ?? null;
             return {
                 type: provider.type,
                 category: provider.category,
@@ -594,32 +603,41 @@ export class DaemonCommandHandler implements CommandHelpers {
                 installed: lastDetection?.ok === true,
                 detectedPath: lastDetection?.path ?? null,
                 checkedAt: lastDetection?.checkedAt ?? null,
+                trust,
+                trustDescription: describeTrust(trust),
+                requiresConfirmation: requiresConfirmation(trust),
+                sourceLayer: layer,
+                sourceName,
             };
         });
         return { success: true, providers: items };
     }
 
     /**
-     * Compute the *Marketplace install root*. This is always
-     * `~/.adhdev/marketplace/` regardless of how ProviderLoader resolved its
-     * userDir (which can point to a sibling adhdev-providers git checkout in
-     * dev). Marketplace-installed manifests must never overwrite files in a
-     * developer checkout, and they should be isolated from upstream/registry
-     * sync so they survive `refresh_scripts`.
+     * Compute the *upstream cache root*. install_provider_manifest writes
+     * official-registry manifests here so the daemon's standard upstream
+     * layer picks them up — no special handling needed at load time, and
+     * the manifests inherit the official-trust badge instead of the
+     * untrusted-external one.
+     *
+     * Path matches ProviderLoader.upstreamDir but we recompute it from
+     * homedir() so this method stays usable in dev where userDir can
+     * point at a sibling git checkout.
      */
-    private getMarketplaceInstallRoot(): string {
+    private getUpstreamInstallRoot(): string {
         const os = require('os') as typeof import('os');
         const path = require('path') as typeof import('path');
-        return path.join(os.homedir(), '.adhdev', 'marketplace');
+        return path.join(os.homedir(), '.adhdev', 'providers', '.upstream');
     }
 
     /**
      * Download a single provider manifest from the registry and write it to
-     * ~/.adhdev/marketplace/{category}/{type}/provider.json.
+     * ~/.adhdev/providers/.upstream/{category}/{type}/provider.json.
      *
-     * Used by the Marketplace UI's Install button. Verifies SHA-256 checksum
-     * against the registry meta before persisting. Refuses to write outside
-     * the marketplace root.
+     * Used by standalone onboarding to seed the upstream cache with the
+     * default provider set on first launch. Verifies SHA-256 checksum
+     * against the registry meta before persisting. Refuses to write
+     * outside the upstream root.
      *
      * Args: { type: string, category?: string, version?: string }
      * If category/version are omitted, looks up the latest from the registry.
@@ -678,13 +696,13 @@ export class DaemonCommandHandler implements CommandHelpers {
                 return { success: false, error: `checksum mismatch: expected ${meta.checksum}, got ${actualChecksum}` };
             }
 
-            // 4. Write to the marketplace install root, NOT to ProviderLoader.getUserDir():
+            // 4. Write to the upstream cache root, NOT to ProviderLoader.getUserDir():
             //    in dev, userDir points at the sibling adhdev-providers git checkout.
-            const installRoot = this.getMarketplaceInstallRoot();
+            const installRoot = this.getUpstreamInstallRoot();
             const installRootResolved = path.resolve(installRoot);
             const targetDir = path.resolve(path.join(installRoot, category, type));
             if (!targetDir.startsWith(installRootResolved + path.sep)) {
-                return { success: false, error: 'install path escaped marketplace root' };
+                return { success: false, error: 'install path escaped upstream root' };
             }
             fs.mkdirSync(targetDir, { recursive: true });
             // v1 vs v0 manifest selection — v1 manifests carry an SDK
@@ -792,6 +810,17 @@ export class DaemonCommandHandler implements CommandHelpers {
         if (Array.isArray(manifest.compatibility)) {
             for (const c of manifest.compatibility) {
                 if (typeof c?.scriptDir === 'string') scriptDirs.add(c.scriptDir);
+                // Spec-driven providers (claude/codex/agy/…) point at a
+                // single specs/<version>.json instead of a scriptDir.
+                // The whole specs/ directory needs to come down so the
+                // spec adapter can resolve the file at runtime — without
+                // this, install_provider_manifest leaves the marketplace
+                // copy spec-less and provider-loader falls back to the
+                // legacy tui-based ProviderCliAdapter.
+                if (typeof c?.spec === 'string' && c.spec.includes('/')) {
+                    const dir = c.spec.substring(0, c.spec.lastIndexOf('/'));
+                    if (dir) scriptDirs.add(dir);
+                }
             }
         }
         if (manifest.overrides && typeof manifest.overrides === 'object' && !Array.isArray(manifest.overrides)) {
@@ -956,9 +985,12 @@ export class DaemonCommandHandler implements CommandHelpers {
     }
 
     /**
-     * Remove a provider manifest from the marketplace install root
-     * (~/.adhdev/marketplace/{category}/{type}/). Refuses to touch anything
-     * outside that root.
+     * Remove a provider manifest from the upstream cache root
+     * (~/.adhdev/providers/.upstream/{category}/{type}/). Refuses to touch
+     * anything outside that root. Used by onboarding to opt out of a
+     * provider the user doesn't want; the dashboard no longer exposes a
+     * per-provider uninstall button (external sources are removed as a
+     * whole via remove_provider_source).
      */
     private async handleUninstallProviderManifest(args: any): Promise<CommandResult> {
         const type = typeof args?.type === 'string' ? args.type : '';
@@ -975,12 +1007,12 @@ export class DaemonCommandHandler implements CommandHelpers {
         const path = require('path') as typeof import('path');
 
         try {
-            const installRoot = this.getMarketplaceInstallRoot();
+            const installRoot = this.getUpstreamInstallRoot();
             const installRootResolved = path.resolve(installRoot);
             const targetDir = path.resolve(path.join(installRoot, category, type));
 
             if (!targetDir.startsWith(installRootResolved + path.sep)) {
-                return { success: false, error: 'refusing to delete outside marketplace root' };
+                return { success: false, error: 'refusing to delete outside upstream root' };
             }
             if (!fs.existsSync(targetDir)) {
                 return { success: false, error: 'not installed' };
@@ -1000,7 +1032,7 @@ export class DaemonCommandHandler implements CommandHelpers {
     }
 
     /**
-     * Return everything currently installed in ~/.adhdev/marketplace/ with its
+     * Return everything currently installed in the upstream cache with its
      * version. This is the "what does this daemon have" answer used both by
      * the UI and by the update checker.
      */
@@ -1008,7 +1040,7 @@ export class DaemonCommandHandler implements CommandHelpers {
         const fs = require('fs') as typeof import('fs');
         const path = require('path') as typeof import('path');
 
-        const installRoot = this.getMarketplaceInstallRoot();
+        const installRoot = this.getUpstreamInstallRoot();
         if (!fs.existsSync(installRoot)) return { success: true, providers: [] };
 
         const CATEGORIES = ['cli', 'ide', 'extension', 'acp'] as const;
@@ -1101,6 +1133,236 @@ export class DaemonCommandHandler implements CommandHelpers {
         return { success: true, providers: checks };
     }
 
+    // ─── External provider sources (3rd-party git URLs) ──────────────
+
+    /**
+     * Register a new external provider source. The daemon clones the repo
+     * to ~/.adhdev/external/<name>/, walks it once to detect provided
+     * types, and surfaces any conflicts with already-installed types so
+     * the dashboard can ask the user how to resolve them.
+     *
+     * Args: { url: string, ref?: string, name?: string }
+     *   - url: https://, git@, or any git-cloneable URL
+     *   - ref: branch/tag/commit (default "main")
+     *   - name: short identifier (default derived from URL)
+     *
+     * Returns: { source, providers, conflicts }
+     *   - conflicts: list of types this new source provides that another
+     *     source already exposes. UI uses this to prompt for active-source
+     *     selection before the load takes effect.
+     */
+    private async handleAddProviderSource(args: any): Promise<CommandResult> {
+        const url = typeof args?.url === 'string' ? args.url.trim() : '';
+        if (!url) return { success: false, error: 'url is required' };
+        const ref = typeof args?.ref === 'string' && args.ref.trim() ? args.ref.trim() : 'main';
+
+        // Defense in depth against argv flag-smuggling: reject anything that
+        // looks like a git option in either positional. The `--` end-of-options
+        // sentinel below catches accidental cases, but rejecting early gives
+        // a clear error message and stops obviously malicious inputs from
+        // even touching git.
+        if (url.startsWith('-')) return { success: false, error: 'url must not start with "-"' };
+        if (ref.startsWith('-')) return { success: false, error: 'ref must not start with "-"' };
+        // Whitelist the protocols we'll forward to git. Anything else
+        // (file://, ext-protocol-handlers, …) is refused outright.
+        if (!/^(https?:\/\/|git@[a-z0-9._-]+:)[a-z0-9._@:/~\-]+$/i.test(url)) {
+            return { success: false, error: 'url must be https://… or git@host:… and contain only URL-safe characters' };
+        }
+        // Refs are git refnames — letters, digits, slashes, dots, underscores,
+        // dashes. Rejects e.g. spaces, semicolons, backticks, shell metas.
+        if (!/^[A-Za-z0-9._/-]+$/.test(ref)) {
+            return { success: false, error: 'ref must contain only [A-Za-z0-9._/-]' };
+        }
+
+        const ext = require('../providers/external-sources.js') as typeof import('../providers/external-sources.js');
+        const requestedName = typeof args?.name === 'string' && args.name.trim() ? args.name.trim() : ext.deriveSourceName(url);
+        if (!/^@[a-z0-9_-]+$/i.test(requestedName)) {
+            return { success: false, error: 'name must match @[a-z0-9_-]+' };
+        }
+
+        const fs = require('node:fs') as typeof import('node:fs');
+        const path = require('node:path') as typeof import('node:path');
+        const { spawnSync } = require('node:child_process') as typeof import('node:child_process');
+
+        const file = ext.loadExternalSources();
+        if (file.sources.some(s => s.name === requestedName)) {
+            return { success: false, error: `source name "${requestedName}" is already registered` };
+        }
+        if (file.sources.some(s => s.url === url && s.ref === ref)) {
+            return { success: false, error: `source url+ref already registered (use a different name to track another ref)` };
+        }
+
+        const sourceDir = path.join(ext.externalRoot(), requestedName);
+        if (!fs.existsSync(ext.externalRoot())) fs.mkdirSync(ext.externalRoot(), { recursive: true });
+        if (fs.existsSync(sourceDir)) {
+            return { success: false, error: `directory already exists: ${sourceDir} (rename or remove first)` };
+        }
+
+        // `--` sentinel after the option list so any future regex-bypassing
+        // url that *did* start with `-` would still be treated as a path
+        // by git rather than an option.
+        const clone = spawnSync('git', ['clone', '--depth=1', '--branch', ref, '--', url, sourceDir], {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+            timeout: 60_000,
+        });
+        if (clone.status !== 0) {
+            try { fs.rmSync(sourceDir, { recursive: true, force: true }); } catch { /* best-effort */ }
+            return { success: false, error: `git clone failed: ${(clone.stderr || clone.stdout || '').trim() || 'unknown error'}` };
+        }
+
+        const source: import('../providers/external-sources.js').ExternalSource = {
+            name: requestedName,
+            url,
+            ref,
+            addedAt: new Date().toISOString(),
+        };
+        ext.saveExternalSources({ schema: 1, sources: [...file.sources, source] });
+
+        // Detect type-level conflicts with what's already on disk after this clone.
+        const inventory = ext.inventoryExternalSources();
+        const conflicts: { category: string; type: string; sources: string[] }[] = [];
+        const newEntry = inventory.find(e => e.sourceName === requestedName);
+        if (newEntry) {
+            for (const [category, types] of Object.entries(newEntry.providers)) {
+                for (const type of types) {
+                    const sources = ext.sourcesProviding(category, type);
+                    if (sources.length > 1) conflicts.push({ category, type, sources });
+                }
+            }
+        }
+
+        // Hot-reload so the daemon picks up the new providers immediately.
+        if (this._ctx.providerLoader) {
+            this._ctx.providerLoader.reload();
+            this._ctx.providerLoader.registerToDetector();
+        }
+
+        return {
+            success: true,
+            source,
+            providers: newEntry?.providers ?? {},
+            conflicts,
+        };
+    }
+
+    /**
+     * Remove a registered external source. Deletes the clone directory and
+     * any active-source entry pointing to it.
+     *
+     * Args: { name: string }
+     */
+    private async handleRemoveProviderSource(args: any): Promise<CommandResult> {
+        const name = typeof args?.name === 'string' ? args.name.trim() : '';
+        if (!name) return { success: false, error: 'name is required' };
+        const ext = require('../providers/external-sources.js') as typeof import('../providers/external-sources.js');
+
+        const fs = require('node:fs') as typeof import('node:fs');
+        const path = require('node:path') as typeof import('node:path');
+        const file = ext.loadExternalSources();
+        const match = file.sources.find(s => s.name === name);
+        if (!match) return { success: false, error: `source "${name}" not registered` };
+
+        const sourceDir = path.join(ext.externalRoot(), name);
+        if (fs.existsSync(sourceDir)) {
+            try { fs.rmSync(sourceDir, { recursive: true, force: true }); }
+            catch (e: any) { return { success: false, error: `failed to delete ${sourceDir}: ${e?.message || e}` }; }
+        }
+
+        ext.saveExternalSources({
+            schema: 1,
+            sources: file.sources.filter(s => s.name !== name),
+        });
+
+        // Drop any active-source entries that pointed at this source.
+        const active = ext.loadProvidersActive();
+        const filteredActive: Record<string, string> = {};
+        for (const [type, src] of Object.entries(active.active)) {
+            if (src !== name) filteredActive[type] = src;
+        }
+        ext.saveProvidersActive({ schema: 1, active: filteredActive });
+
+        if (this._ctx.providerLoader) {
+            this._ctx.providerLoader.reload();
+            this._ctx.providerLoader.registerToDetector();
+        }
+
+        return { success: true, removed: { name } };
+    }
+
+    /**
+     * List registered external sources + each source's currently installed
+     * providers + the active selection for any conflicting types. Used by
+     * the dashboard's "Sources" tab.
+     */
+    private handleListProviderSources(_args: any): CommandResult {
+        const ext = require('../providers/external-sources.js') as typeof import('../providers/external-sources.js');
+        const file = ext.loadExternalSources();
+        const inventory = ext.inventoryExternalSources();
+        const active = ext.loadProvidersActive();
+
+        // Build a per-source view + flag types that have ambiguity.
+        const sources = file.sources.map(s => {
+            const inv = inventory.find(e => e.sourceName === s.name);
+            return {
+                ...s,
+                providers: inv?.providers ?? {},
+            };
+        });
+
+        // Compute conflicts globally — any type provided by ≥ 2 sources.
+        const conflictMap = new Map<string, { category: string; sources: string[] }>();
+        for (const inv of inventory) {
+            for (const [category, types] of Object.entries(inv.providers)) {
+                for (const type of types) {
+                    const candidates = ext.sourcesProviding(category, type);
+                    if (candidates.length > 1 && !conflictMap.has(type)) {
+                        conflictMap.set(type, { category, sources: candidates });
+                    }
+                }
+            }
+        }
+        const conflicts = [...conflictMap.entries()].map(([type, info]) => ({
+            type,
+            category: info.category,
+            candidates: info.sources,
+            active: active.active[type] ?? null,
+        }));
+
+        return { success: true, sources, conflicts };
+    }
+
+    /**
+     * Pick which source's copy of a conflicting provider type is active.
+     * Other sources' copies stay on disk but the loader ignores them.
+     *
+     * Args: { type: string, sourceName: string }
+     */
+    private handleSetActiveProviderSource(args: any): CommandResult {
+        const type = typeof args?.type === 'string' ? args.type.trim() : '';
+        const sourceName = typeof args?.sourceName === 'string' ? args.sourceName.trim() : '';
+        if (!type || !sourceName) return { success: false, error: 'type and sourceName are required' };
+        const ext = require('../providers/external-sources.js') as typeof import('../providers/external-sources.js');
+
+        // Validate: the source must actually provide that type.
+        const inventory = ext.inventoryExternalSources();
+        const entry = inventory.find(e => e.sourceName === sourceName);
+        if (!entry) return { success: false, error: `source "${sourceName}" not found` };
+        const provided = Object.values(entry.providers).some(types => types.includes(type));
+        if (!provided) return { success: false, error: `source "${sourceName}" does not provide type "${type}"` };
+
+        const active = ext.loadProvidersActive();
+        active.active[type] = sourceName;
+        ext.saveProvidersActive(active);
+
+        if (this._ctx.providerLoader) {
+            this._ctx.providerLoader.reload();
+            this._ctx.providerLoader.registerToDetector();
+        }
+
+        return { success: true, type, sourceName };
+    }
+
     // ─── DevServer HTTP proxy helpers ─────────────────
     // These bridge WS commands to the DevServer REST API (localhost:19280)