@demigodmode/pi-web-agent 1.1.0 → 1.3.0

package/CHANGELOG.md

@@ -18,6 +18,36 @@ The format is intentionally simple and release-oriented.
 ### Breaking
 - None.
 
+## [1.3.0] - 2026-06-04
+### Added
+- Added direct URL handling in `web_explore` so linked pages are read before search results.
+- Added forum/thread source classification for Reddit-style discussions, forums, Stack Overflow, and GitHub issues/discussions.
+- Added Playwright-managed Chromium fallback when no local Chromium-family browser is detected.
+
+### Changed
+- Discussion-oriented queries now prefer forum/thread results over generic pages.
+- `/web-agent doctor` now reports the local-browser headless backend and managed Chromium fallback.
+
+### Fixed
+- Preserved direct/thread fetch gaps in bounded research results so unreadable thread sources get explicit caveats.
+
+### Breaking
+- None.
+
+## [1.2.0] - 2026-06-01
+### Added
+- Added backend provider and fallback editing to `/web-agent settings`.
+- Added interactive URL prompts for SearXNG and Firecrawl backend setup.
+
+### Changed
+- Nothing yet.
+
+### Fixed
+- Nothing yet.
+
+### Breaking
+- None.
+
 ## [1.1.0] - 2026-05-25
 ### Added
 - Added explicit opt-in fallback from SearXNG to DuckDuckGo and Firecrawl to HTTP.

package/README.md

@@ -8,7 +8,7 @@
 
 Most agent web tools blur search, fetch, browser rendering, and research into one vague thing. `pi-web-agent` exposes one public research tool, `web_explore`, and keeps search/fetch/headless work inside that bounded workflow.
 
-The point is keeping the model-facing boundary simple: ask `web_explore` to research a question, and it handles discovery, HTTP reads, targeted browser rendering, source ranking, and caveats internally.
+The point is keeping the model-facing boundary simple: ask `web_explore` to research a question, and it handles direct links, discovery, HTTP reads, targeted browser rendering, source ranking, and caveats internally.
 
 That sounds obvious, but a lot of agent tooling gets fuzzy right there. This package is meant to be stricter about what it actually did and more willing to say when a read was not good enough to trust.
 
@@ -20,9 +20,9 @@ Compatibility notice: current `pi-web-agent` requires Pi 0.74+ because Pi packag
 pi install npm:@demigodmode/pi-web-agent
 ```
 
-After installing, reload or restart Pi. Run `/web-agent` for the action menu, or `/web-agent doctor` to check whether the package loaded cleanly and whether headless rendering can find a browser.
+After installing, reload or restart Pi. Run `/web-agent` for the action menu, or `/web-agent doctor` to check whether the package loaded cleanly and which web backends are configured.
 
-Headless rendering currently requires a detectable Chromium-family browser: Chrome, Chromium, Edge, or Brave. Firefox/Safari-only systems can still use search and plain HTTP reads, but browser-rendered fallback pages need a supported Chromium-family browser for now.
+Headless rendering first tries a detectable Chromium-family browser: Chrome, Chromium, Edge, or Brave. If none is found, it falls back to Playwright-managed Chromium and still launches headless. Firefox/Safari-only systems can still use search and plain HTTP reads; browser-rendered fallback uses Chromium.
 
 Later on, update installed packages with:
 
@@ -109,7 +109,17 @@ Example:
 }
 ```
 
-Backend config is also supported. Defaults remain DuckDuckGo search, plain HTTP fetch, and local browser headless fallback. If you already run SearXNG or Firecrawl, see the self-hosted backend guide:
+Backend config is also supported. Defaults remain DuckDuckGo search, plain HTTP fetch, and local-browser headless fallback with managed Chromium fallback configured.
+
+Backend settings can be changed from:
+
+```text
+/web-agent settings
+```
+
+Choose **Backends** to edit search/fetch providers, fallback behavior, and SearXNG or Firecrawl base URLs interactively. Firecrawl API keys should stay in environment variables rather than being written into config files.
+
+If you already run SearXNG or Firecrawl, see the self-hosted backend guide:
 
 - https://demigodmode.github.io/pi-web-agent/self-hosted-backends
 

package/dist/backends/doctor.js

@@ -83,5 +83,8 @@ export async function checkBackendHealth(config, { fetchImpl = fetch, timeoutMs
     if (config.fetch.fallback) {
         lines.push(`fetch fallback: ${config.fetch.fallback}`);
     }
+    if (config.headless.provider === 'local-browser') {
+        lines.push('headless backend: local-browser (managed Chromium fallback configured)');
+    }
     return lines;
 }

package/dist/commands/web-agent-config.d.ts

@@ -1,4 +1,4 @@
-import { type BackendConfig } from '../backends/config.js';
+import { type BackendConfig, type BackendConfigOverride } from '../backends/config.js';
 import { type ExtensionAPI } from '@earendil-works/pi-coding-agent';
 import { loadPresentationConfigLayers, type LoadedPresentationConfig } from '../presentation/config-store.js';
 import { type BrowserResolutionResult } from '../fetch/browser-resolution.js';
@@ -6,6 +6,7 @@ import type { PresentationConfig, PresentationConfigOverride, PresentationScope
 type CommandDeps = {
     load?: () => ReturnType<typeof loadPresentationConfigLayers>;
     save?: (scope: PresentationScope, config: PresentationConfigOverride) => Promise<void>;
+    saveBackends?: (scope: PresentationScope, config: BackendConfigOverride) => Promise<void>;
     reset?: (scope: PresentationScope) => Promise<void>;
     resolveBrowser?: () => Promise<BrowserResolutionResult>;
     runtime?: {
@@ -20,13 +21,25 @@ type CommandDeps = {
 export type SettingsDraftState = {
     scope: PresentationScope;
     drafts: Record<PresentationScope, PresentationConfig>;
+    backendDrafts: Record<PresentationScope, BackendConfig>;
     config: PresentationConfig;
+    backends: BackendConfig;
+};
+export declare function validateBackendUrl(value: string): {
+    ok: true;
+    value: string;
+} | {
+    ok: false;
+    message: string;
 };
 export declare function getInheritedConfigForScope(loaded: Awaited<LoadedPresentationConfig>, scope: PresentationScope): PresentationConfig;
 export declare function getScopeDisplayConfig(loaded: Awaited<LoadedPresentationConfig>, scope: PresentationScope): PresentationConfig;
+export declare function getInheritedBackendsForScope(loaded: Awaited<LoadedPresentationConfig>, scope: PresentationScope): BackendConfig;
+export declare function getScopeDisplayBackends(loaded: Awaited<LoadedPresentationConfig>, scope: PresentationScope): BackendConfig;
 export declare function createSettingsDraftState(loaded: Awaited<LoadedPresentationConfig>, initialScope: PresentationScope): SettingsDraftState;
 export declare function applySettingsValue(state: SettingsDraftState, id: string, newValue: string): SettingsDraftState;
 export declare function collapsePresentationConfigToOverride(config: PresentationConfig, inheritedConfig: PresentationConfig): PresentationConfigOverride;
+export declare function collapseBackendConfigToOverride(config: BackendConfig, inheritedConfig: BackendConfig): BackendConfigOverride;
 export declare function handleSettingsShortcut(data: string): {
     action: 'cancel' | 'reset' | 'save';
 } | undefined;

package/dist/commands/web-agent-config.js

@@ -1,9 +1,9 @@
-import { DEFAULT_BACKEND_CONFIG, validateBackendConfig } from '../backends/config.js';
+import { DEFAULT_BACKEND_CONFIG, mergeBackendConfigLayers, validateBackendConfig } from '../backends/config.js';
 import { checkBackendHealth } from '../backends/doctor.js';
 import { DynamicBorder, getSettingsListTheme } from '@earendil-works/pi-coding-agent';
 import { Container, SelectList, SettingsList, Text } from '@earendil-works/pi-tui';
 import { DEFAULT_PRESENTATION_CONFIG, mergePresentationConfigLayers, resolvePresentationMode } from '../presentation/config.js';
-import { loadPresentationConfigLayers, resetPresentationConfigScope, savePresentationConfigScope } from '../presentation/config-store.js';
+import { loadPresentationConfigLayers, resetPresentationConfigScope, saveBackendConfigScope, savePresentationConfigScope } from '../presentation/config-store.js';
 import { resolveBrowserExecutable } from '../fetch/browser-resolution.js';
 import { getLatestChangelogEntry } from '../changelog-notice.js';
 const PRESENTATION_TOOL_NAMES = ['web_explore'];
@@ -16,6 +16,34 @@ function clonePresentationConfig(config) {
         tools: { ...config.tools }
     };
 }
+function cloneBackendConfig(config) {
+    return {
+        search: {
+            ...config.search,
+            options: config.search.options ? { ...config.search.options } : undefined
+        },
+        fetch: {
+            ...config.fetch,
+            options: config.fetch.options ? { ...config.fetch.options } : undefined
+        },
+        headless: { ...config.headless }
+    };
+}
+function sameJson(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+export function validateBackendUrl(value) {
+    try {
+        const url = new URL(value.trim());
+        if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+            return { ok: false, message: 'Invalid URL. Include http:// or https://.' };
+        }
+        return { ok: true, value: url.toString().replace(/\/$/, '') };
+    }
+    catch {
+        return { ok: false, message: 'Invalid URL. Include http:// or https://.' };
+    }
+}
 async function defaultCheckTypebox() {
     try {
         await import('typebox');
@@ -62,7 +90,7 @@ function formatConfigSummary(config) {
     }
     return lines.join('\n');
 }
-function buildSettingsItems(scope, config) {
+function buildPresentationSettingsItems(scope, config) {
     return [
         {
             id: 'scope',
@@ -84,6 +112,58 @@ function buildSettingsItems(scope, config) {
         }))
     ];
 }
+function buildBackendSettingsItems(scope, backends) {
+    return [
+        {
+            id: 'scope',
+            label: 'Write scope',
+            currentValue: scope,
+            values: ['project', 'global']
+        },
+        {
+            id: 'backend:search:provider',
+            label: 'Search backend',
+            currentValue: backends.search.provider,
+            values: ['duckduckgo', 'searxng']
+        },
+        {
+            id: 'backend:search:baseUrl',
+            label: 'SearXNG URL',
+            currentValue: backends.search.baseUrl ?? 'not set',
+            values: ['edit']
+        },
+        {
+            id: 'backend:search:fallback',
+            label: 'SearXNG fallback',
+            currentValue: backends.search.provider === 'searxng' ? backends.search.fallback ?? 'off' : 'off',
+            values: backends.search.provider === 'searxng' ? ['off', 'duckduckgo'] : ['off']
+        },
+        {
+            id: 'backend:fetch:provider',
+            label: 'Fetch backend',
+            currentValue: backends.fetch.provider,
+            values: ['http', 'firecrawl']
+        },
+        {
+            id: 'backend:fetch:baseUrl',
+            label: 'Firecrawl URL',
+            currentValue: backends.fetch.baseUrl ?? 'not set',
+            values: ['edit']
+        },
+        {
+            id: 'backend:fetch:fallback',
+            label: 'Firecrawl fallback',
+            currentValue: backends.fetch.provider === 'firecrawl' ? backends.fetch.fallback ?? 'off' : 'off',
+            values: backends.fetch.provider === 'firecrawl' ? ['off', 'http'] : ['off']
+        },
+        {
+            id: 'backend:secret:firecrawl',
+            label: 'Firecrawl API key',
+            currentValue: 'env var',
+            values: ['env var']
+        }
+    ];
+}
 function isToolName(value) {
     return PRESENTATION_TOOL_NAMES.includes(value);
 }
@@ -102,15 +182,33 @@ export function getScopeDisplayConfig(loaded, scope) {
     }
     return mergePresentationConfigLayers(DEFAULT_PRESENTATION_CONFIG, loaded.global.rawConfig, loaded.project.rawConfig);
 }
+export function getInheritedBackendsForScope(loaded, scope) {
+    if (scope === 'global') {
+        return DEFAULT_BACKEND_CONFIG;
+    }
+    return mergeBackendConfigLayers(DEFAULT_BACKEND_CONFIG, loaded.global.rawBackends);
+}
+export function getScopeDisplayBackends(loaded, scope) {
+    if (scope === 'global') {
+        return mergeBackendConfigLayers(DEFAULT_BACKEND_CONFIG, loaded.global.rawBackends);
+    }
+    return mergeBackendConfigLayers(DEFAULT_BACKEND_CONFIG, loaded.global.rawBackends, loaded.project.rawBackends);
+}
 export function createSettingsDraftState(loaded, initialScope) {
     const drafts = {
         global: getScopeDisplayConfig(loaded, 'global'),
         project: getScopeDisplayConfig(loaded, 'project')
     };
+    const backendDrafts = {
+        global: getScopeDisplayBackends(loaded, 'global'),
+        project: getScopeDisplayBackends(loaded, 'project')
+    };
     return {
         scope: initialScope,
         drafts,
-        config: clonePresentationConfig(drafts[initialScope])
+        backendDrafts,
+        config: clonePresentationConfig(drafts[initialScope]),
+        backends: cloneBackendConfig(backendDrafts[initialScope])
     };
 }
 export function applySettingsValue(state, id, newValue) {
@@ -118,16 +216,23 @@ export function applySettingsValue(state, id, newValue) {
         global: clonePresentationConfig(state.drafts.global),
         project: clonePresentationConfig(state.drafts.project)
     };
+    const nextBackendDrafts = {
+        global: cloneBackendConfig(state.backendDrafts.global),
+        project: cloneBackendConfig(state.backendDrafts.project)
+    };
     let nextScope = state.scope;
     if (id === 'scope' && (newValue === 'project' || newValue === 'global')) {
         nextScope = newValue;
         return {
             scope: nextScope,
             drafts: nextDrafts,
-            config: clonePresentationConfig(nextDrafts[nextScope])
+            backendDrafts: nextBackendDrafts,
+            config: clonePresentationConfig(nextDrafts[nextScope]),
+            backends: cloneBackendConfig(nextBackendDrafts[nextScope])
         };
     }
     const currentDraft = clonePresentationConfig(nextDrafts[nextScope]);
+    const currentBackends = cloneBackendConfig(nextBackendDrafts[nextScope]);
     if (id === 'defaultMode' && (newValue === 'compact' || newValue === 'preview' || newValue === 'verbose')) {
         currentDraft.defaultMode = newValue;
     }
@@ -144,11 +249,58 @@ export function applySettingsValue(state, id, newValue) {
         }
         currentDraft.tools = nextTools;
     }
+    if (id === 'backend:search:provider' && (newValue === 'duckduckgo' || newValue === 'searxng')) {
+        currentBackends.search.provider = newValue;
+        if (newValue === 'duckduckgo') {
+            delete currentBackends.search.fallback;
+        }
+    }
+    if (id === 'backend:search:fallback') {
+        if (newValue === 'duckduckgo' && currentBackends.search.provider === 'searxng') {
+            currentBackends.search.fallback = 'duckduckgo';
+        }
+        else if (newValue === 'off' || currentBackends.search.provider !== 'searxng') {
+            delete currentBackends.search.fallback;
+        }
+    }
+    if (id === 'backend:search:baseUrl') {
+        if (newValue.trim()) {
+            currentBackends.search.baseUrl = newValue.trim();
+        }
+        else {
+            delete currentBackends.search.baseUrl;
+        }
+    }
+    if (id === 'backend:fetch:provider' && (newValue === 'http' || newValue === 'firecrawl')) {
+        currentBackends.fetch.provider = newValue;
+        if (newValue === 'http') {
+            delete currentBackends.fetch.fallback;
+        }
+    }
+    if (id === 'backend:fetch:fallback') {
+        if (newValue === 'http' && currentBackends.fetch.provider === 'firecrawl') {
+            currentBackends.fetch.fallback = 'http';
+        }
+        else if (newValue === 'off' || currentBackends.fetch.provider !== 'firecrawl') {
+            delete currentBackends.fetch.fallback;
+        }
+    }
+    if (id === 'backend:fetch:baseUrl') {
+        if (newValue.trim()) {
+            currentBackends.fetch.baseUrl = newValue.trim();
+        }
+        else {
+            delete currentBackends.fetch.baseUrl;
+        }
+    }
     nextDrafts[nextScope] = currentDraft;
+    nextBackendDrafts[nextScope] = currentBackends;
     return {
         scope: nextScope,
         drafts: nextDrafts,
-        config: clonePresentationConfig(nextDrafts[nextScope])
+        backendDrafts: nextBackendDrafts,
+        config: clonePresentationConfig(nextDrafts[nextScope]),
+        backends: cloneBackendConfig(nextBackendDrafts[nextScope])
     };
 }
 export function collapsePresentationConfigToOverride(config, inheritedConfig) {
@@ -168,6 +320,44 @@ export function collapsePresentationConfigToOverride(config, inheritedConfig) {
         tools
     };
 }
+export function collapseBackendConfigToOverride(config, inheritedConfig) {
+    const override = {};
+    if (!sameJson(config.search, inheritedConfig.search)) {
+        override.search = config.search.provider !== inheritedConfig.search.provider
+            ? { ...config.search }
+            : {
+                ...(config.search.baseUrl !== inheritedConfig.search.baseUrl ? { baseUrl: config.search.baseUrl } : {}),
+                ...(config.search.fallback !== inheritedConfig.search.fallback ? { fallback: config.search.fallback } : {}),
+                ...(!sameJson(config.search.options, inheritedConfig.search.options) ? { options: config.search.options } : {})
+            };
+        if (config.search.provider !== inheritedConfig.search.provider) {
+            override.search.provider = config.search.provider;
+        }
+        else if (Object.keys(override.search).length === 0) {
+            delete override.search;
+        }
+    }
+    if (!sameJson(config.fetch, inheritedConfig.fetch)) {
+        override.fetch = config.fetch.provider !== inheritedConfig.fetch.provider
+            ? { ...config.fetch, apiKey: undefined }
+            : {
+                ...(config.fetch.baseUrl !== inheritedConfig.fetch.baseUrl ? { baseUrl: config.fetch.baseUrl } : {}),
+                ...(config.fetch.fallback !== inheritedConfig.fetch.fallback ? { fallback: config.fetch.fallback } : {}),
+                ...(!sameJson(config.fetch.options, inheritedConfig.fetch.options) ? { options: config.fetch.options } : {})
+            };
+        delete override.fetch.apiKey;
+        if (config.fetch.provider !== inheritedConfig.fetch.provider) {
+            override.fetch.provider = config.fetch.provider;
+        }
+        else if (Object.keys(override.fetch).length === 0) {
+            delete override.fetch;
+        }
+    }
+    if (!sameJson(config.headless, inheritedConfig.headless)) {
+        override.headless = { ...config.headless };
+    }
+    return override;
+}
 export function handleSettingsShortcut(data) {
     if (data === '\u001b') {
         return { action: 'cancel' };
@@ -184,9 +374,10 @@ async function openActionMenu(ctx) {
     return ctx.ui.custom((tui, theme, _kb, done) => {
         const container = new Container();
         const items = [
-            { value: 'settings', label: 'Settings', description: 'Edit presentation modes' },
+            { value: 'settings', label: 'Settings', description: 'Edit presentation modes and backends' },
             { value: 'show', label: 'Show config', description: 'Print effective config paths and modes' },
             { value: 'doctor', label: 'Doctor', description: 'Check runtime dependencies and browser detection' },
+            { value: 'changelog', label: 'Changelog', description: 'Show latest package changelog' },
             { value: 'reset-project', label: 'Reset project config', description: 'Delete project-level overrides' },
             { value: 'reset-global', label: 'Reset global config', description: 'Delete global overrides' }
         ];
@@ -214,22 +405,120 @@ async function openActionMenu(ctx) {
         };
     });
 }
-async function openSettingsUi(ctx, loaded, initialScope) {
+async function openSettingsSectionMenu(ctx) {
+    return ctx.ui.custom((tui, theme, _kb, done) => {
+        const container = new Container();
+        const items = [
+            { value: 'presentation', label: 'Presentation', description: 'Compact, preview, and verbose output modes' },
+            { value: 'backends', label: 'Backends', description: 'Search/fetch providers, URLs, and fallbacks' }
+        ];
+        container.addChild(new DynamicBorder((text) => theme.fg('accent', text)));
+        container.addChild(new Text(theme.fg('accent', theme.bold('pi-web-agent settings')), 1, 0));
+        const list = new SelectList(items, items.length, {
+            selectedPrefix: (text) => theme.fg('accent', text),
+            selectedText: (text) => theme.fg('accent', text),
+            description: (text) => theme.fg('muted', text),
+            scrollInfo: (text) => theme.fg('dim', text),
+            noMatch: (text) => theme.fg('warning', text)
+        });
+        list.onSelect = (item) => done(item.value);
+        list.onCancel = () => done(undefined);
+        container.addChild(list);
+        container.addChild(new Text(theme.fg('dim', '↑↓ navigate • enter select • esc cancel'), 1, 0));
+        container.addChild(new DynamicBorder((text) => theme.fg('accent', text)));
+        return {
+            render: (width) => container.render(width),
+            invalidate: () => container.invalidate(),
+            handleInput: (data) => {
+                list.handleInput?.(data);
+                tui.requestRender?.();
+            }
+        };
+    });
+}
+async function openPresentationSettingsUi(ctx, loaded, initialScope) {
     return ctx.ui.custom((_tui, theme, _kb, done) => {
         let state = createSettingsDraftState(loaded, initialScope);
         let settingsList;
         const container = new Container();
-        container.addChild(new Text(theme.fg('accent', theme.bold('pi-web-agent settings')), 1, 1));
+        container.addChild(new Text(theme.fg('accent', theme.bold('pi-web-agent · presentation')), 1, 1));
         container.addChild(new Text(theme.fg('muted', 'Ctrl+S save · Ctrl+R reset scope · Esc cancel'), 1, 2));
         const rebuildSettingsList = () => {
             if (settingsList) {
                 container.removeChild(settingsList);
             }
-            settingsList = new SettingsList(buildSettingsItems(state.scope, state.config), Math.min(PRESENTATION_TOOL_NAMES.length + 8, 18), getSettingsListTheme(), (id, newValue) => {
+            settingsList = new SettingsList(buildPresentationSettingsItems(state.scope, state.config), Math.min(PRESENTATION_TOOL_NAMES.length + 8, 18), getSettingsListTheme(), (id, newValue) => {
+                state = applySettingsValue(state, id, newValue);
+                rebuildSettingsList();
+                container.invalidate();
+            }, () => done({ action: 'save', scope: state.scope, config: state.config, backends: state.backends }), { enableSearch: true });
+            container.addChild(settingsList);
+        };
+        rebuildSettingsList();
+        return {
+            render: (width) => container.render(width),
+            invalidate: () => container.invalidate(),
+            handleInput: (data) => {
+                const shortcut = handleSettingsShortcut(JSON.stringify(data).slice(1, -1));
+                if (shortcut?.action === 'cancel') {
+                    done({ action: 'cancel' });
+                    return;
+                }
+                if (shortcut?.action === 'reset') {
+                    done({ action: 'reset', scope: state.scope });
+                    return;
+                }
+                if (shortcut?.action === 'save') {
+                    done({ action: 'save', scope: state.scope, config: state.config, backends: state.backends });
+                    return;
+                }
+                settingsList.handleInput?.(data);
+            }
+        };
+    });
+}
+async function openBackendSettingsUi(ctx, loaded, initialScope) {
+    return ctx.ui.custom((tui, theme, _kb, done) => {
+        let state = createSettingsDraftState(loaded, initialScope);
+        let settingsList;
+        const container = new Container();
+        container.addChild(new Text(theme.fg('accent', theme.bold('pi-web-agent · backends')), 1, 1));
+        container.addChild(new Text(theme.fg('muted', 'Ctrl+S save · Ctrl+R reset scope · Esc cancel · API keys stay in env vars'), 1, 2));
+        const editUrl = async (id) => {
+            const isSearchUrl = id === 'backend:search:baseUrl';
+            const label = isSearchUrl ? 'SearXNG base URL' : 'Firecrawl base URL';
+            const currentValue = isSearchUrl ? state.backends.search.baseUrl : state.backends.fetch.baseUrl;
+            const entered = await ctx.ui.input(label, currentValue ?? (isSearchUrl ? 'http://localhost:8080' : 'http://localhost:3002'));
+            if (entered === undefined)
+                return;
+            if (!entered.trim()) {
+                state = applySettingsValue(state, id, '');
+                rebuildSettingsList();
+                tui.requestRender?.();
+                return;
+            }
+            const validated = validateBackendUrl(entered);
+            if (!validated.ok) {
+                ctx.ui.notify(validated.message, 'warning');
+                return;
+            }
+            state = applySettingsValue(state, id, validated.value);
+            rebuildSettingsList();
+            tui.requestRender?.();
+        };
+        const rebuildSettingsList = () => {
+            if (settingsList) {
+                container.removeChild(settingsList);
+            }
+            settingsList = new SettingsList(buildBackendSettingsItems(state.scope, state.backends), 12, getSettingsListTheme(), (id, newValue) => {
+                if (id === 'backend:search:baseUrl' || id === 'backend:fetch:baseUrl') {
+                    void editUrl(id);
+                    return;
+                }
                 state = applySettingsValue(state, id, newValue);
                 rebuildSettingsList();
                 container.invalidate();
-            }, () => done({ action: 'save', scope: state.scope, config: state.config }), { enableSearch: true });
+            }, () => done({ action: 'save', scope: state.scope, config: state.config, backends: state.backends }), { enableSearch: true });
             container.addChild(settingsList);
         };
         rebuildSettingsList();
@@ -247,7 +536,7 @@ async function openSettingsUi(ctx, loaded, initialScope) {
                     return;
                 }
                 if (shortcut?.action === 'save') {
-                    done({ action: 'save', scope: state.scope, config: state.config });
+                    done({ action: 'save', scope: state.scope, config: state.config, backends: state.backends });
                     return;
                 }
                 settingsList.handleInput?.(data);
@@ -258,6 +547,7 @@ async function openSettingsUi(ctx, loaded, initialScope) {
 export function registerWebAgentConfigCommands(pi, deps = {}) {
     const load = deps.load ?? (() => loadPresentationConfigLayers());
     const save = deps.save ?? ((scope, config) => savePresentationConfigScope({}, scope, config));
+    const saveBackends = deps.saveBackends ?? ((scope, config) => saveBackendConfigScope({}, scope, config));
     const reset = deps.reset ?? ((scope) => resetPresentationConfigScope({}, scope));
     const resolveBrowser = deps.resolveBrowser ?? (() => resolveBrowserExecutable({}));
     const runtime = deps.runtime ?? {
@@ -362,7 +652,12 @@ export function registerWebAgentConfigCommands(pi, deps = {}) {
             if (!action || action === 'settings') {
                 const loaded = await load();
                 const initialScope = 'project';
-                const result = await openSettingsUi(ctx, loaded, initialScope);
+                const section = await openSettingsSectionMenu(ctx);
+                if (!section)
+                    return;
+                const result = section === 'presentation'
+                    ? await openPresentationSettingsUi(ctx, loaded, initialScope)
+                    : await openBackendSettingsUi(ctx, loaded, initialScope);
                 if (!result || result.action === 'cancel') {
                     return;
                 }
@@ -371,8 +666,13 @@ export function registerWebAgentConfigCommands(pi, deps = {}) {
                     ctx.ui.notify(`Reset ${result.scope} config`, 'info');
                     return;
                 }
-                await save(result.scope, collapsePresentationConfigToOverride(result.config, getInheritedConfigForScope(loaded, result.scope)));
-                ctx.ui.notify(`Saved ${result.scope} config`, 'info');
+                if (section === 'presentation') {
+                    await save(result.scope, collapsePresentationConfigToOverride(result.config, getInheritedConfigForScope(loaded, result.scope)));
+                    ctx.ui.notify(`Saved ${result.scope} presentation config`, 'info');
+                    return;
+                }
+                await saveBackends(result.scope, collapseBackendConfigToOverride(result.backends, getInheritedBackendsForScope(loaded, result.scope)));
+                ctx.ui.notify(`Saved ${result.scope} backend config`, 'info');
                 return;
             }
             ctx.ui.notify('Use /web-agent, /web-agent show, /web-agent doctor, /web-agent changelog, /web-agent reset project, or /web-agent settings', 'info');

package/dist/fetch/headless-fetch.d.ts

@@ -6,7 +6,8 @@ export declare function headlessFetch(url: string, { configuredPath, resolveBrow
         configuredPath?: string;
     }) => Promise<BrowserResolutionResult>;
     launchBrowser?: (options: {
-        executablePath: string;
+        executablePath?: string;
+        headless: true;
     }) => Promise<{
         newContext: () => Promise<{
             newPage: () => Promise<any>;

package/dist/fetch/headless-fetch.js

@@ -1,4 +1,4 @@
-import { chromium } from 'playwright-core';
+import { chromium } from 'playwright';
 import { extractReadableContentSafely } from '../extract/readability.js';
 import { resolveBrowserExecutable } from './browser-resolution.js';
 function cleanupRenderedText(text) {
@@ -7,9 +7,9 @@ function cleanupRenderedText(text) {
     cleaned = cleaned.replace(/\s+/g, ' ').trim();
     return cleaned;
 }
-export async function headlessFetch(url, { configuredPath, resolveBrowser = (options) => resolveBrowserExecutable({ configuredPath: options?.configuredPath }), launchBrowser = ({ executablePath }) => chromium.launch({ executablePath, headless: true }), now = () => Date.now() } = {}) {
+export async function headlessFetch(url, { configuredPath, resolveBrowser = (options) => resolveBrowserExecutable({ configuredPath: options?.configuredPath }), launchBrowser = ({ executablePath, headless }) => chromium.launch(executablePath ? { executablePath, headless } : { headless }), now = () => Date.now() } = {}) {
     const resolved = await resolveBrowser({ configuredPath });
-    if (!resolved.ok) {
+    if (!resolved.ok && resolved.error.code === 'CONFIGURED_BROWSER_NOT_FOUND') {
         return {
             status: 'error',
             url,
@@ -17,11 +17,15 @@ export async function headlessFetch(url, { configuredPath, resolveBrowser = (opt
             error: resolved.error
         };
     }
+    const browserName = resolved.ok ? resolved.browser : 'chromium';
+    const launchOptions = resolved.ok
+        ? { executablePath: resolved.executablePath, headless: true }
+        : { headless: true };
     let browser;
     let context;
     let page;
     try {
-        browser = await launchBrowser({ executablePath: resolved.executablePath });
+        browser = await launchBrowser(launchOptions);
         context = await browser.newContext();
         page = await context.newPage();
         const startedAt = now();
@@ -42,7 +46,7 @@ export async function headlessFetch(url, { configuredPath, resolveBrowser = (opt
                 metadata: {
                     method: 'headless',
                     cacheHit: false,
-                    browser: resolved.browser,
+                    browser: browserName,
                     navigationMs: finishedAt - startedAt
                 },
                 error: {
@@ -58,7 +62,7 @@ export async function headlessFetch(url, { configuredPath, resolveBrowser = (opt
             metadata: {
                 method: 'headless',
                 cacheHit: false,
-                browser: resolved.browser,
+                browser: browserName,
                 navigationMs: finishedAt - startedAt,
                 truncated: cleanedContent.text.length >= 4000
             }
@@ -71,7 +75,7 @@ export async function headlessFetch(url, { configuredPath, resolveBrowser = (opt
             metadata: {
                 method: 'headless',
                 cacheHit: false,
-                browser: resolved.browser
+                browser: browserName
             },
             error: {
                 code: 'HEADLESS_NAVIGATION_FAILED',

package/dist/orchestration/candidate-selector.d.ts

@@ -1,5 +1,6 @@
 import type { SearchResult } from '../types.js';
-export declare function selectCandidates({ results, seenUrls, maxCandidates }: {
+export declare function selectCandidates({ query, results, seenUrls, maxCandidates }: {
+    query?: string;
     results: SearchResult[];
     seenUrls: Set<string>;
     maxCandidates: number;

package/dist/orchestration/candidate-selector.js

@@ -1,16 +1,35 @@
-function candidateScore(result) {
+import { classifySourceProfile } from './source-profile.js';
+function wantsDiscussionSources(query = '') {
+    return /reddit|forum|forums|discussion|thread|comments|community|user experience|people recommend/i.test(query);
+}
+function candidateScore(result, query) {
     const url = result.url.toLowerCase();
-    if (url.includes('playwright.dev/docs') || url.includes('vitest.dev/guide') || url.includes('learn.microsoft.com'))
+    const profile = classifySourceProfile(result.url);
+    const wantsThreads = wantsDiscussionSources(query);
+    if (profile.kind === 'official-docs')
         return 0;
-    if (url.includes('github.com/') && (url.includes('/issues/') || url.includes('/discussions/')))
+    if (profile.kind === 'official-api')
         return 1;
-    if (url.includes('github.com/'))
+    if (wantsThreads) {
+        if (profile.kind === 'forum-thread')
+            return 2;
+        if (profile.kind === 'issue-thread')
+            return 3;
+        if (url.includes('github.com/'))
+            return 4;
+        if (profile.kind === 'package-page')
+            return 6;
+        return 5;
+    }
+    if (profile.kind === 'issue-thread')
         return 2;
-    if (url.includes('npmjs.com/package/'))
-        return 4;
-    return 3;
+    if (url.includes('github.com/'))
+        return 3;
+    if (profile.kind === 'package-page')
+        return 5;
+    return 4;
 }
-export function selectCandidates({ results, seenUrls, maxCandidates }) {
+export function selectCandidates({ query, results, seenUrls, maxCandidates }) {
     const deduped = new Map();
     for (const result of results) {
         if (seenUrls.has(result.url))
@@ -19,6 +38,6 @@ export function selectCandidates({ results, seenUrls, maxCandidates }) {
             deduped.set(result.url, result);
     }
     return [...deduped.values()]
-        .sort((left, right) => candidateScore(left) - candidateScore(right))
+        .sort((left, right) => candidateScore(left, query) - candidateScore(right, query))
         .slice(0, maxCandidates);
 }

package/dist/orchestration/direct-url.d.ts

@@ -0,0 +1 @@
+export declare function extractDirectUrls(query: string): string[];

package/dist/orchestration/direct-url.js

@@ -0,0 +1,47 @@
+const TRACKING_PARAMS = new Set([
+    'utm_source',
+    'utm_medium',
+    'utm_campaign',
+    'utm_term',
+    'utm_content',
+    'utm_name',
+    'fbclid',
+    'gclid'
+]);
+function stripTrailingPunctuation(raw) {
+    let next = raw.trim();
+    while (/[),.;!?\]]$/.test(next)) {
+        const last = next.at(-1);
+        if (last === ')' && next.includes('(') && next.lastIndexOf('(') > next.lastIndexOf(')'))
+            break;
+        next = next.slice(0, -1);
+    }
+    return next;
+}
+function normalizeDirectUrl(raw) {
+    try {
+        const url = new URL(stripTrailingPunctuation(raw));
+        if (url.protocol !== 'http:' && url.protocol !== 'https:')
+            return undefined;
+        for (const key of [...url.searchParams.keys()]) {
+            if (TRACKING_PARAMS.has(key.toLowerCase())) {
+                url.searchParams.delete(key);
+            }
+        }
+        url.hash = '';
+        return url.toString().replace(/\/$/, '');
+    }
+    catch {
+        return undefined;
+    }
+}
+export function extractDirectUrls(query) {
+    const matches = query.match(/https?:\/\/\S+/gi) ?? [];
+    const urls = new Set();
+    for (const match of matches) {
+        const normalized = normalizeDirectUrl(match);
+        if (normalized)
+            urls.add(normalized);
+    }
+    return [...urls];
+}

package/dist/orchestration/index.js

@@ -7,5 +7,9 @@ export function createResearchWorkflow({ backendConfig, search, fetchPage, headl
     const resolvedFetchPage = fetchPage ?? backends.fetchPage;
     const resolvedHeadlessFetch = headlessFetch ?? backends.headlessFetch;
     const worker = createResearchWorker({ search: resolvedSearch, fetchPage: resolvedFetchPage });
-    return createResearchOrchestrator({ worker, headlessFetch: resolvedHeadlessFetch });
+    return createResearchOrchestrator({
+        worker,
+        fetchDirect: resolvedFetchPage,
+        headlessFetch: resolvedHeadlessFetch
+    });
 }

package/dist/orchestration/research-orchestrator.d.ts

@@ -1,6 +1,6 @@
-import type { WebFetchHeadlessResponse } from '../types.js';
+import type { WebFetchHeadlessResponse, WebFetchResponse } from '../types.js';
 import type { ResearchEvidence, ResearchOrchestratorDecision, ResearchWorkerResult } from './research-types.js';
-export declare function createResearchOrchestrator({ worker, headlessFetch }: {
+export declare function createResearchOrchestrator({ worker, fetchDirect, headlessFetch }: {
     worker: {
         run: (input: {
             query: string;
@@ -8,6 +8,9 @@ export declare function createResearchOrchestrator({ worker, headlessFetch }: {
             maxFetches: number;
         }) => Promise<ResearchWorkerResult>;
     };
+    fetchDirect?: (input: {
+        url: string;
+    }) => Promise<WebFetchResponse>;
     headlessFetch: (input: {
         url: string;
     }) => Promise<WebFetchHeadlessResponse>;

package/dist/orchestration/research-orchestrator.js

@@ -1,23 +1,13 @@
 import { rankEvidence } from './evidence-ranker.js';
 import { planSearchQueries } from './query-planner.js';
+import { classifySourceProfile } from './source-profile.js';
+import { extractDirectUrls } from './direct-url.js';
 import { decideNextResearchStep } from './stop-decider.js';
 const DEFAULT_MAX_PASSES = 3;
 const DEFAULT_MAX_FETCHES_PER_PASS = 4;
 const DEFAULT_MAX_HEADLESS_ATTEMPTS = 2;
 function classifyEvidenceUrl(url) {
-    if (url.includes('/docs/api/') || url.includes('/config/'))
-        return 'official-api';
-    if (url.includes('playwright.dev/docs') || url.includes('vitest.dev/guide/'))
-        return 'official-docs';
-    if (url.includes('github.com/vitest-dev/vitest') && url.includes('/docs/'))
-        return 'official-docs';
-    if (url.includes('learn.microsoft.com'))
-        return 'official-docs';
-    if (url.includes('github.com/') && url.includes('/issues/'))
-        return 'issue-thread';
-    if (url.includes('npmjs.com/package/'))
-        return 'package-page';
-    return 'community';
+    return classifySourceProfile(url).sourceKind;
 }
 function summarizeText(text, maxLength = 180) {
     return text.replace(/\s+/g, ' ').trim().slice(0, maxLength);
@@ -25,6 +15,20 @@ function summarizeText(text, maxLength = 180) {
 function isBotCheckContent({ title = '', text }) {
     return /performing security verification|security service|verify you are not a bot|just a moment|checking your browser/i.test(`${title}\n${text}`);
 }
+function evidenceFromFetch(result) {
+    if (result.status !== 'ok' || !result.content?.text.trim())
+        return null;
+    if (isBotCheckContent({ title: result.content.title, text: result.content.text }))
+        return null;
+    return {
+        title: result.content.title ?? result.url,
+        url: result.url,
+        sourceKind: classifyEvidenceUrl(result.url),
+        method: result.metadata.method,
+        summary: summarizeText(result.content.text),
+        supports: [summarizeText(result.content.text, 120)]
+    };
+}
 function evidenceFromHeadless(result) {
     if (result.status !== 'ok' || !result.content?.text.trim())
         return null;
@@ -39,15 +43,28 @@ function evidenceFromHeadless(result) {
         supports: [summarizeText(result.content.text, 120)]
     };
 }
-function fallbackWorkerPass({ previousQueries, allGaps, allLowValueOutcomes, exhaustedBudget }) {
+function combinedWorkerPass({ lastPass, previousQueries, allGaps, allLowValueOutcomes, exhaustedBudget }) {
     return {
-        searchQueries: previousQueries,
-        evidence: [],
+        searchQueries: lastPass?.searchQueries ?? previousQueries,
+        evidence: lastPass?.evidence ?? [],
         gaps: allGaps,
         lowValueOutcomes: allLowValueOutcomes,
+        suggestedHeadlessUrl: lastPass?.suggestedHeadlessUrl,
         exhaustedBudget
     };
 }
+function directUnreadableMessage(url) {
+    return classifySourceProfile(url).kind === 'forum-thread'
+        ? `Thread source could not be read reliably: ${url}`
+        : `Direct URL could not be read reliably: ${url}`;
+}
+function shouldRetryDirectWithHeadless(result, evidence) {
+    if (result.status === 'needs_headless')
+        return true;
+    if (result.status !== 'ok' || evidence)
+        return false;
+    return classifySourceProfile(result.url).shouldPreferHeadlessWhenWeak;
+}
 function buildMetadata({ previousQueries, allEvidence, allGaps, allLowValueOutcomes, headlessAttempts, exhaustedBudget }) {
     return {
         searchPasses: previousQueries.length,
@@ -70,7 +87,7 @@ function decisionForAnswer(action, query, ranked) {
         followupQuery: query
     };
 }
-export function createResearchOrchestrator({ worker, headlessFetch }) {
+export function createResearchOrchestrator({ worker, fetchDirect, headlessFetch }) {
     return {
         async run({ query }) {
             const allEvidence = [];
@@ -80,6 +97,41 @@ export function createResearchOrchestrator({ worker, headlessFetch }) {
             const suggestedHeadlessUrls = [];
             let headlessAttempts = 0;
             let lastPass;
+            if (fetchDirect) {
+                for (const url of extractDirectUrls(query).slice(0, 3)) {
+                    const directResult = await fetchDirect({ url });
+                    const directEvidence = evidenceFromFetch(directResult);
+                    if (directEvidence) {
+                        allEvidence.push(directEvidence);
+                        continue;
+                    }
+                    if (shouldRetryDirectWithHeadless(directResult, directEvidence)) {
+                        if (headlessAttempts < DEFAULT_MAX_HEADLESS_ATTEMPTS) {
+                            headlessAttempts++;
+                            const headlessResult = await headlessFetch({ url: directResult.url });
+                            const headlessEvidence = evidenceFromHeadless(headlessResult);
+                            if (headlessEvidence) {
+                                allEvidence.push(headlessEvidence);
+                            }
+                            else {
+                                allGaps.push({ kind: 'fetch-failed', message: directUnreadableMessage(directResult.url) });
+                            }
+                        }
+                        else {
+                            allGaps.push({ kind: 'fetch-failed', message: directUnreadableMessage(directResult.url) });
+                        }
+                    }
+                    else if (directResult.status !== 'ok') {
+                        allGaps.push({
+                            kind: 'fetch-failed',
+                            message: directResult.error?.message ?? `Direct URL fetch failed for ${directResult.url}`
+                        });
+                    }
+                    else {
+                        allGaps.push({ kind: 'fetch-failed', message: directUnreadableMessage(directResult.url) });
+                    }
+                }
+            }
             for (let passIndex = 0; passIndex < DEFAULT_MAX_PASSES; passIndex++) {
                 const queries = planSearchQueries({
                     originalQuery: query,
@@ -127,7 +179,13 @@ export function createResearchOrchestrator({ worker, headlessFetch }) {
                             return {
                                 decision: decisionForAnswer(updatedDecision.action === 'answer' ? 'answer' : 'answer-with-caveat', query, updatedRanked),
                                 evidence: updatedRanked,
-                                workerPass: lastPass,
+                                workerPass: combinedWorkerPass({
+                                    lastPass,
+                                    previousQueries,
+                                    allGaps,
+                                    allLowValueOutcomes,
+                                    exhaustedBudget: updatedDecision.action !== 'answer'
+                                }),
                                 metadata: buildMetadata({
                                     previousQueries,
                                     allEvidence,
@@ -146,7 +204,13 @@ export function createResearchOrchestrator({ worker, headlessFetch }) {
                                 approvedEvidence: ranked
                             },
                             evidence: ranked,
-                            workerPass: lastPass,
+                            workerPass: combinedWorkerPass({
+                                lastPass,
+                                previousQueries,
+                                allGaps,
+                                allLowValueOutcomes,
+                                exhaustedBudget: false
+                            }),
                             metadata: buildMetadata({
                                 previousQueries,
                                 allEvidence,
@@ -161,7 +225,13 @@ export function createResearchOrchestrator({ worker, headlessFetch }) {
                         return {
                             decision: decisionForAnswer(decision.action, query, ranked),
                             evidence: ranked,
-                            workerPass: lastPass,
+                            workerPass: combinedWorkerPass({
+                                lastPass,
+                                previousQueries,
+                                allGaps,
+                                allLowValueOutcomes,
+                                exhaustedBudget: decision.action === 'answer-with-caveat'
+                            }),
                             metadata: buildMetadata({
                                 previousQueries,
                                 allEvidence,
@@ -178,13 +248,13 @@ export function createResearchOrchestrator({ worker, headlessFetch }) {
             return {
                 decision: decisionForAnswer('answer-with-caveat', query, ranked),
                 evidence: ranked,
-                workerPass: lastPass ??
-                    fallbackWorkerPass({
-                        previousQueries,
-                        allGaps,
-                        allLowValueOutcomes,
-                        exhaustedBudget: true
-                    }),
+                workerPass: combinedWorkerPass({
+                    lastPass,
+                    previousQueries,
+                    allGaps,
+                    allLowValueOutcomes,
+                    exhaustedBudget: true
+                }),
                 metadata: buildMetadata({
                     previousQueries,
                     allEvidence,

package/dist/orchestration/research-worker.js

@@ -1,18 +1,7 @@
 import { selectCandidates } from './candidate-selector.js';
+import { classifySourceProfile } from './source-profile.js';
 function classifySource(url) {
-    if (url.includes('/docs/api/') || url.includes('/config/'))
-        return 'official-api';
-    if (url.includes('playwright.dev/docs') || url.includes('vitest.dev/guide/'))
-        return 'official-docs';
-    if (url.includes('github.com/vitest-dev/vitest') && url.includes('/docs/'))
-        return 'official-docs';
-    if (url.includes('learn.microsoft.com'))
-        return 'official-docs';
-    if (url.includes('github.com/') && url.includes('/issues/'))
-        return 'issue-thread';
-    if (url.includes('npmjs.com/package/'))
-        return 'package-page';
-    return 'community';
+    return classifySourceProfile(url).sourceKind;
 }
 function summarizeText(text, maxLength = 180) {
     return text.replace(/\s+/g, ' ').trim().slice(0, maxLength);
@@ -95,6 +84,7 @@ export function createResearchWorker({ search, fetchPage }) {
                 };
             }
             const candidates = selectCandidates({
+                query,
                 results: searchResult.results,
                 seenUrls: new Set(evidence.map((item) => item.url)),
                 maxCandidates: maxFetches

package/dist/orchestration/source-profile.d.ts

@@ -0,0 +1,8 @@
+import type { ResearchSourceKind } from './research-types.js';
+export type SourceProfileKind = 'official-docs' | 'official-api' | 'issue-thread' | 'forum-thread' | 'package-page' | 'community';
+export type SourceProfile = {
+    kind: SourceProfileKind;
+    sourceKind: ResearchSourceKind;
+    shouldPreferHeadlessWhenWeak: boolean;
+};
+export declare function classifySourceProfile(rawUrl: string): SourceProfile;

package/dist/orchestration/source-profile.js

@@ -0,0 +1,60 @@
+const COMMUNITY_FORUM_HOST_RE = /(^|\.)(community|forum|forums|discuss|discourse)\./;
+function profile(kind, sourceKind, shouldPreferHeadlessWhenWeak) {
+    return { kind, sourceKind, shouldPreferHeadlessWhenWeak };
+}
+function parseUrl(rawUrl) {
+    try {
+        return new URL(rawUrl);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isOfficialApi(host, path) {
+    return ((host === 'playwright.dev' && path.startsWith('/docs/api/')) ||
+        (host === 'vitest.dev' && path.startsWith('/config/')));
+}
+function isOfficialDocs(host, path) {
+    return ((host === 'playwright.dev' && path.startsWith('/docs/')) ||
+        (host === 'vitest.dev' && path.startsWith('/guide/')) ||
+        (host === 'github.com' && path.startsWith('/vitest-dev/vitest/') && path.includes('/docs/')) ||
+        host === 'learn.microsoft.com');
+}
+function isIssueThread(host, path) {
+    return host === 'github.com' && (path.includes('/issues/') || path.includes('/discussions/'));
+}
+function hasForumThreadPath(path) {
+    return (path.includes('/forum/') ||
+        path.includes('/forums/') ||
+        path.includes('/t/') ||
+        path.includes('/topic/') ||
+        path.includes('/threads/'));
+}
+function isForumThread(host, path) {
+    return ((host === 'reddit.com' && path.includes('/comments/')) ||
+        (host === 'stackoverflow.com' && path.startsWith('/questions/')) ||
+        (COMMUNITY_FORUM_HOST_RE.test(`${host}.`) && hasForumThreadPath(path)));
+}
+export function classifySourceProfile(rawUrl) {
+    const parsed = parseUrl(rawUrl);
+    if (!parsed)
+        return profile('community', 'community', false);
+    const host = parsed.hostname.toLowerCase().replace(/^www\./, '');
+    const path = parsed.pathname.toLowerCase();
+    if (isOfficialApi(host, path)) {
+        return profile('official-api', 'official-api', false);
+    }
+    if (isOfficialDocs(host, path)) {
+        return profile('official-docs', 'official-docs', false);
+    }
+    if (isIssueThread(host, path)) {
+        return profile('issue-thread', 'issue-thread', true);
+    }
+    if (isForumThread(host, path)) {
+        return profile('forum-thread', 'community', true);
+    }
+    if (host === 'npmjs.com' && path.startsWith('/package/')) {
+        return profile('package-page', 'package-page', false);
+    }
+    return profile('community', 'community', false);
+}

package/dist/presentation/config-store.d.ts

@@ -23,4 +23,5 @@ export declare function getPresentationConfigPaths(options?: PresentationConfigS
 };
 export declare function loadPresentationConfigLayers(options?: PresentationConfigStoreOptions): Promise<LoadedPresentationConfig>;
 export declare function savePresentationConfigScope(options: PresentationConfigStoreOptions, scope: PresentationScope, config: PresentationConfigOverride): Promise<void>;
+export declare function saveBackendConfigScope(options: PresentationConfigStoreOptions, scope: PresentationScope, config: BackendConfigOverride): Promise<void>;
 export declare function resetPresentationConfigScope(options: PresentationConfigStoreOptions, scope: PresentationScope): Promise<void>;

package/dist/presentation/config-store.js

@@ -49,6 +49,35 @@ function serializePresentationConfigOverride(config) {
     }
     return { presentation };
 }
+function serializeBackendConfigOverride(config) {
+    const backends = {};
+    if (config.search && Object.keys(config.search).length > 0) {
+        backends.search = { ...config.search };
+    }
+    if (config.fetch && Object.keys(config.fetch).length > 0) {
+        const { apiKey: _apiKey, ...fetch } = config.fetch;
+        backends.fetch = { ...fetch };
+    }
+    if (config.headless && Object.keys(config.headless).length > 0) {
+        backends.headless = { ...config.headless };
+    }
+    return { backends };
+}
+async function readConfigFileForWrite(filePath) {
+    try {
+        return JSON.parse(await readFile(filePath, 'utf8'));
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT') {
+            return {};
+        }
+        throw error;
+    }
+}
+async function writeConfigFile(filePath, config) {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+}
 export async function loadPresentationConfigLayers(options = {}) {
     const { globalPath, projectPath } = getPresentationConfigPaths(options);
     const global = await readPresentationConfigFile(globalPath);
@@ -63,8 +92,20 @@ export async function loadPresentationConfigLayers(options = {}) {
 export async function savePresentationConfigScope(options, scope, config) {
     const { globalPath, projectPath } = getPresentationConfigPaths(options);
     const filePath = scope === 'global' ? globalPath : projectPath;
-    await mkdir(path.dirname(filePath), { recursive: true });
-    await writeFile(filePath, JSON.stringify(serializePresentationConfigOverride(config), null, 2) + '\n', 'utf8');
+    const existing = await readConfigFileForWrite(filePath);
+    await writeConfigFile(filePath, {
+        ...existing,
+        ...serializePresentationConfigOverride(config)
+    });
+}
+export async function saveBackendConfigScope(options, scope, config) {
+    const { globalPath, projectPath } = getPresentationConfigPaths(options);
+    const filePath = scope === 'global' ? globalPath : projectPath;
+    const existing = await readConfigFileForWrite(filePath);
+    await writeConfigFile(filePath, {
+        ...existing,
+        ...serializeBackendConfigOverride(config)
+    });
 }
 export async function resetPresentationConfigScope(options, scope) {
     const { globalPath, projectPath } = getPresentationConfigPaths(options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@demigodmode/pi-web-agent",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Pi package for reliable web access with explicit search, fetch, and headless boundaries.",
   "type": "module",
   "main": "./dist/extension.js",
@@ -57,7 +57,7 @@
     "@mozilla/readability": "^0.6.0",
     "cheerio": "^1.1.0",
     "jsdom": "^26.0.0",
-    "playwright-core": "^1.54.0",
+    "playwright": "^1.60.0",
     "typebox": "^1.1.37"
   },
   "devDependencies": {