@demigodmode/pi-web-agent 0.3.1 → 0.5.1

package/dist/fetch/browser-resolution.js

@@ -1,14 +1,82 @@
-const WINDOWS_CANDIDATES = {
-    chrome: [
-        'C:/Program Files/Google/Chrome/Application/chrome.exe',
-        'C:/Program Files (x86)/Google/Chrome/Application/chrome.exe'
-    ],
-    edge: [
-        'C:/Program Files/Microsoft/Edge/Application/msedge.exe',
-        'C:/Program Files (x86)/Microsoft/Edge/Application/msedge.exe'
-    ]
-};
-export async function resolveBrowserExecutable({ configuredPath, fileExists = defaultFileExists }) {
+const WINDOWS_CANDIDATES = [
+    {
+        browser: 'chrome',
+        paths: [
+            'C:/Program Files/Google/Chrome/Application/chrome.exe',
+            'C:/Program Files (x86)/Google/Chrome/Application/chrome.exe'
+        ],
+        commands: ['chrome.exe', 'chrome', 'google-chrome']
+    },
+    {
+        browser: 'edge',
+        paths: [
+            'C:/Program Files/Microsoft/Edge/Application/msedge.exe',
+            'C:/Program Files (x86)/Microsoft/Edge/Application/msedge.exe'
+        ],
+        commands: ['msedge.exe', 'msedge', 'microsoft-edge']
+    },
+    {
+        browser: 'brave',
+        paths: [
+            'C:/Program Files/BraveSoftware/Brave-Browser/Application/brave.exe',
+            'C:/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe'
+        ],
+        commands: ['brave.exe', 'brave']
+    },
+    {
+        browser: 'chromium',
+        paths: [
+            'C:/Program Files/Chromium/Application/chrome.exe',
+            'C:/Program Files (x86)/Chromium/Application/chrome.exe'
+        ],
+        commands: ['chromium.exe', 'chromium']
+    }
+];
+const MACOS_CANDIDATES = [
+    {
+        browser: 'chrome',
+        paths: ['/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'],
+        commands: ['google-chrome', 'chrome']
+    },
+    {
+        browser: 'edge',
+        paths: ['/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge'],
+        commands: ['microsoft-edge', 'msedge']
+    },
+    {
+        browser: 'brave',
+        paths: ['/Applications/Brave Browser.app/Contents/MacOS/Brave Browser'],
+        commands: ['brave-browser', 'brave']
+    },
+    {
+        browser: 'chromium',
+        paths: ['/Applications/Chromium.app/Contents/MacOS/Chromium'],
+        commands: ['chromium', 'chromium-browser']
+    }
+];
+const LINUX_CANDIDATES = [
+    {
+        browser: 'chrome',
+        paths: ['/usr/bin/google-chrome', '/usr/local/bin/google-chrome', '/opt/google/chrome/chrome'],
+        commands: ['google-chrome', 'google-chrome-stable', 'chrome']
+    },
+    {
+        browser: 'edge',
+        paths: ['/usr/bin/microsoft-edge', '/opt/microsoft/msedge/msedge'],
+        commands: ['microsoft-edge', 'microsoft-edge-stable', 'msedge']
+    },
+    {
+        browser: 'brave',
+        paths: ['/usr/bin/brave-browser', '/usr/local/bin/brave-browser', '/opt/brave.com/brave/brave'],
+        commands: ['brave-browser', 'brave']
+    },
+    {
+        browser: 'chromium',
+        paths: ['/usr/bin/chromium', '/usr/bin/chromium-browser', '/snap/bin/chromium'],
+        commands: ['chromium', 'chromium-browser']
+    }
+];
+export async function resolveBrowserExecutable({ configuredPath, platform = process.platform, env = process.env, fileExists = defaultFileExists }) {
     if (configuredPath) {
         if (await fileExists(configuredPath)) {
             return {
@@ -25,14 +93,19 @@ export async function resolveBrowserExecutable({ configuredPath, fileExists = de
             }
         };
     }
-    for (const path of WINDOWS_CANDIDATES.chrome) {
-        if (await fileExists(path)) {
-            return { ok: true, executablePath: path, browser: 'chrome' };
+    const candidates = getCandidatesForPlatform(platform);
+    for (const candidate of candidates) {
+        for (const path of candidate.paths) {
+            if (await fileExists(path)) {
+                return { ok: true, executablePath: path, browser: candidate.browser };
+            }
         }
     }
-    for (const path of WINDOWS_CANDIDATES.edge) {
-        if (await fileExists(path)) {
-            return { ok: true, executablePath: path, browser: 'edge' };
+    for (const candidate of candidates) {
+        for (const path of getPathCommandCandidates(candidate.commands, platform, env)) {
+            if (await fileExists(path)) {
+                return { ok: true, executablePath: path, browser: candidate.browser };
+            }
         }
     }
     return {
@@ -43,6 +116,27 @@ export async function resolveBrowserExecutable({ configuredPath, fileExists = de
         }
     };
 }
+function getCandidatesForPlatform(platform) {
+    if (platform === 'win32')
+        return WINDOWS_CANDIDATES;
+    if (platform === 'darwin')
+        return MACOS_CANDIDATES;
+    if (platform === 'linux')
+        return LINUX_CANDIDATES;
+    return [...WINDOWS_CANDIDATES, ...MACOS_CANDIDATES, ...LINUX_CANDIDATES];
+}
+function getPathCommandCandidates(commands, platform, env) {
+    const pathValue = env.PATH ?? env.Path ?? env.path;
+    if (!pathValue)
+        return [];
+    const delimiter = platform === 'win32' ? ';' : ':';
+    const dirs = pathValue.split(delimiter).filter(Boolean);
+    const extensions = platform === 'win32' ? ['', '.exe'] : [''];
+    return dirs.flatMap((dir) => commands.flatMap((command) => extensions.map((extension) => {
+        const normalizedCommand = command.toLowerCase().endsWith(extension) ? command : `${command}${extension}`;
+        return `${dir.replace(/[\\/]$/, '')}/${normalizedCommand}`;
+    })));
+}
 async function defaultFileExists(path) {
     try {
         const { access } = await import('node:fs/promises');

package/dist/orchestration/answer-synthesizer.d.ts

@@ -0,0 +1,8 @@
+import type { ResearchEvidence } from './research-types.js';
+export declare function synthesizeAnswer({ evidence, partial }: {
+    evidence: ResearchEvidence[];
+    partial: boolean;
+}): {
+    findings: string[];
+    caveat: string | undefined;
+};

package/dist/orchestration/answer-synthesizer.js

@@ -0,0 +1,17 @@
+function normalizeSummary(summary) {
+    return summary.replace(/\s+/g, ' ').trim();
+}
+export function synthesizeAnswer({ evidence, partial }) {
+    const findings = evidence.slice(0, 5).map((item) => {
+        const summary = normalizeSummary(item.summary);
+        return item.sourceKind === 'community' || item.sourceKind === 'issue-thread'
+            ? `Community/practical context: ${summary}`
+            : summary;
+    });
+    return {
+        findings,
+        caveat: partial
+            ? 'Evidence is partial, so this answer is based on the strongest source found within the bounded research budget.'
+            : undefined
+    };
+}

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

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

package/dist/orchestration/candidate-selector.js

@@ -0,0 +1,24 @@
+function candidateScore(result) {
+    const url = result.url.toLowerCase();
+    if (url.includes('playwright.dev/docs') || url.includes('vitest.dev/guide') || url.includes('learn.microsoft.com'))
+        return 0;
+    if (url.includes('github.com/') && (url.includes('/issues/') || url.includes('/discussions/')))
+        return 1;
+    if (url.includes('github.com/'))
+        return 2;
+    if (url.includes('npmjs.com/package/'))
+        return 4;
+    return 3;
+}
+export function selectCandidates({ results, seenUrls, maxCandidates }) {
+    const deduped = new Map();
+    for (const result of results) {
+        if (seenUrls.has(result.url))
+            continue;
+        if (!deduped.has(result.url))
+            deduped.set(result.url, result);
+    }
+    return [...deduped.values()]
+        .sort((left, right) => candidateScore(left) - candidateScore(right))
+        .slice(0, maxCandidates);
+}

package/dist/orchestration/evidence-ranker.d.ts

@@ -0,0 +1,4 @@
+import type { ResearchEvidence } from './research-types.js';
+export declare function rankEvidence(evidence: ResearchEvidence[]): ResearchEvidence[];
+export declare function hasOfficialEvidence(evidence: ResearchEvidence[]): boolean;
+export declare function strongEvidenceCount(evidence: ResearchEvidence[]): number;

package/dist/orchestration/evidence-ranker.js

@@ -0,0 +1,36 @@
+function sourceRank(sourceKind) {
+    switch (sourceKind) {
+        case 'official-docs':
+            return 0;
+        case 'official-api':
+            return 1;
+        case 'official-discussion':
+            return 2;
+        case 'issue-thread':
+            return 3;
+        case 'community':
+            return 4;
+        case 'package-page':
+            return 5;
+        default:
+            return 6;
+    }
+}
+export function rankEvidence(evidence) {
+    const bestByUrl = new Map();
+    for (const item of evidence) {
+        const current = bestByUrl.get(item.url);
+        if (!current || sourceRank(item.sourceKind) < sourceRank(current.sourceKind)) {
+            bestByUrl.set(item.url, item);
+        }
+    }
+    return [...bestByUrl.values()].sort((left, right) => sourceRank(left.sourceKind) - sourceRank(right.sourceKind));
+}
+export function hasOfficialEvidence(evidence) {
+    return evidence.some((item) => item.sourceKind === 'official-docs' || item.sourceKind === 'official-api');
+}
+export function strongEvidenceCount(evidence) {
+    return evidence.filter((item) => item.sourceKind === 'official-docs' ||
+        item.sourceKind === 'official-api' ||
+        item.sourceKind === 'official-discussion').length;
+}

package/dist/orchestration/index.d.ts

@@ -13,29 +13,14 @@ export declare function createResearchWorkflow({ search, fetchPage, headlessFetc
     run({ query }: {
         query: string;
     }): Promise<{
-        decision: {
-            action: "answer";
-            rationale: string;
-            approvedEvidence: import("./research-types.js").ResearchEvidence[];
-        };
-        evidence: import("./research-types.js").ResearchEvidence[];
-        workerPass: import("./research-types.js").ResearchWorkerResult;
-    } | {
-        decision: {
-            action: "escalate-headless";
-            rationale: string;
-            url: string;
-            approvedEvidence: import("./research-types.js").ResearchEvidence[];
-        };
+        decision: import("./research-types.js").ResearchOrchestratorDecision;
         evidence: import("./research-types.js").ResearchEvidence[];
         workerPass: import("./research-types.js").ResearchWorkerResult;
-    } | {
-        decision: {
-            action: "research-again";
-            rationale: string;
-            followupQuery: string;
+        metadata: {
+            searchPasses: number;
+            fetchedPages: number;
+            headlessAttempts: number;
+            exhaustedBudget: boolean;
         };
-        evidence: import("./research-types.js").ResearchEvidence[];
-        workerPass: import("./research-types.js").ResearchWorkerResult;
     }>;
 };

package/dist/orchestration/query-planner.d.ts

@@ -0,0 +1,7 @@
+export type QueryPlanInput = {
+    originalQuery: string;
+    passIndex: number;
+    previousQueries: string[];
+    gaps: string[];
+};
+export declare function planSearchQueries(input: QueryPlanInput): string[];

package/dist/orchestration/query-planner.js

@@ -0,0 +1,37 @@
+function normalizeWhitespace(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+function extractImportantWords(query) {
+    return normalizeWhitespace(query)
+        .replace(/\b(find|current|tell|me|how|to|the|and|with|for|in|a|an)\b/gi, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function officialSiteQuery(query) {
+    const lower = query.toLowerCase();
+    const terms = extractImportantWords(query);
+    if (lower.includes('vitest'))
+        return `site:vitest.dev ${terms}`;
+    if (lower.includes('playwright'))
+        return `site:playwright.dev ${terms}`;
+    if (lower.includes('microsoft edge') || lower.includes('edge'))
+        return `site:learn.microsoft.com ${terms}`;
+    return `${terms} official docs`;
+}
+function implementationQuery(query) {
+    return `site:github.com ${extractImportantWords(query)}`;
+}
+export function planSearchQueries(input) {
+    const planned = input.passIndex === 0
+        ? [input.originalQuery]
+        : [
+            officialSiteQuery(input.originalQuery),
+            implementationQuery(input.originalQuery),
+            `${extractImportantWords(input.originalQuery)} discussion`
+        ];
+    const previous = new Set(input.previousQueries.map(normalizeWhitespace));
+    return planned
+        .map(normalizeWhitespace)
+        .filter((query) => query && !previous.has(query))
+        .slice(0, 3);
+}

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

@@ -1,5 +1,5 @@
 import type { WebFetchHeadlessResponse } from '../types.js';
-import type { ResearchEvidence, ResearchWorkerResult } from './research-types.js';
+import type { ResearchEvidence, ResearchOrchestratorDecision, ResearchWorkerResult } from './research-types.js';
 export declare function createResearchOrchestrator({ worker, headlessFetch }: {
     worker: {
         run: (input: {
@@ -15,29 +15,14 @@ export declare function createResearchOrchestrator({ worker, headlessFetch }: {
     run({ query }: {
         query: string;
     }): Promise<{
-        decision: {
-            action: "answer";
-            rationale: string;
-            approvedEvidence: ResearchEvidence[];
-        };
-        evidence: ResearchEvidence[];
-        workerPass: ResearchWorkerResult;
-    } | {
-        decision: {
-            action: "escalate-headless";
-            rationale: string;
-            url: string;
-            approvedEvidence: ResearchEvidence[];
-        };
+        decision: ResearchOrchestratorDecision;
         evidence: ResearchEvidence[];
         workerPass: ResearchWorkerResult;
-    } | {
-        decision: {
-            action: "research-again";
-            rationale: string;
-            followupQuery: string;
+        metadata: {
+            searchPasses: number;
+            fetchedPages: number;
+            headlessAttempts: number;
+            exhaustedBudget: boolean;
         };
-        evidence: ResearchEvidence[];
-        workerPass: ResearchWorkerResult;
     }>;
 };

package/dist/orchestration/research-orchestrator.js

@@ -1,87 +1,199 @@
-function sourceRank(sourceKind) {
-    switch (sourceKind) {
-        case 'official-docs':
-            return 0;
-        case 'official-api':
-            return 1;
-        case 'official-discussion':
-            return 2;
-        case 'issue-thread':
-            return 3;
-        case 'community':
-            return 4;
-        case 'package-page':
-            return 5;
-        default:
-            return 6;
-    }
+import { rankEvidence } from './evidence-ranker.js';
+import { planSearchQueries } from './query-planner.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';
 }
-function sortEvidence(evidence) {
-    return [...evidence].sort((left, right) => sourceRank(left.sourceKind) - sourceRank(right.sourceKind));
+function summarizeText(text, maxLength = 180) {
+    return text.replace(/\s+/g, ' ').trim().slice(0, maxLength);
 }
-function strongEvidence(evidence) {
-    return evidence.filter((item) => item.sourceKind === 'official-docs' ||
-        item.sourceKind === 'official-api' ||
-        item.sourceKind === 'official-discussion');
+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 hasOfficialDocsOrApi(evidence) {
-    return evidence.some((item) => item.sourceKind === 'official-docs' || item.sourceKind === 'official-api');
+function evidenceFromHeadless(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: 'headless',
+        summary: summarizeText(result.content.text),
+        supports: [summarizeText(result.content.text, 120)]
+    };
 }
-function hasBotCheck(outcomes) {
-    return outcomes.some((outcome) => outcome.kind === 'bot-check');
+function fallbackWorkerPass({ previousQueries, allGaps, allLowValueOutcomes, exhaustedBudget }) {
+    return {
+        searchQueries: previousQueries,
+        evidence: [],
+        gaps: allGaps,
+        lowValueOutcomes: allLowValueOutcomes,
+        exhaustedBudget
+    };
 }
-function isHeadlessWorthTrying(pass, approvedEvidence) {
-    if (!pass.suggestedHeadlessUrl)
-        return false;
-    if (hasBotCheck(pass.lowValueOutcomes))
-        return false;
-    if (approvedEvidence.length >= 2 && hasOfficialDocsOrApi(approvedEvidence))
-        return false;
-    const candidate = pass.suggestedHeadlessUrl;
-    return !candidate.includes('npmjs.com/package/');
+function buildMetadata({ previousQueries, allEvidence, allGaps, allLowValueOutcomes, headlessAttempts, exhaustedBudget }) {
+    return {
+        searchPasses: previousQueries.length,
+        fetchedPages: allEvidence.length + allGaps.length + allLowValueOutcomes.length,
+        headlessAttempts,
+        exhaustedBudget
+    };
+}
+function decisionForAnswer(action, query, ranked) {
+    if (action === 'answer') {
+        return {
+            action: 'answer',
+            rationale: 'Adaptive research gathered enough strong evidence.',
+            approvedEvidence: ranked
+        };
+    }
+    return {
+        action: 'research-again',
+        rationale: 'Research budget exhausted; answer with caveat.',
+        followupQuery: query
+    };
 }
 export function createResearchOrchestrator({ worker, headlessFetch }) {
     return {
         async run({ query }) {
-            const pass = await worker.run({ query, maxSearchRounds: 1, maxFetches: 3 });
-            const approvedEvidence = sortEvidence(pass.evidence.filter((item) => item.sourceKind !== 'package-page'));
-            const strong = strongEvidence(approvedEvidence);
-            const enoughEvidence = strong.length >= 2 && hasOfficialDocsOrApi(approvedEvidence);
-            if (enoughEvidence) {
-                const decision = {
-                    action: 'answer',
-                    rationale: 'Two strong sources with official support are enough to answer safely.',
-                    approvedEvidence
-                };
-                return { decision, evidence: approvedEvidence, workerPass: pass };
-            }
-            if (isHeadlessWorthTrying(pass, approvedEvidence)) {
-                const url = pass.suggestedHeadlessUrl;
-                await headlessFetch({ url });
-                const decision = {
-                    action: 'escalate-headless',
-                    rationale: 'One high-value page is worth a single orchestrator-approved headless retry.',
-                    url,
-                    approvedEvidence
-                };
-                return { decision, evidence: approvedEvidence, workerPass: pass };
-            }
-            const hasConcreteGap = pass.gaps.length > 0;
-            const onlyLowValueOutcomes = pass.lowValueOutcomes.length > 0 && pass.evidence.length === 0;
-            if (!hasConcreteGap || onlyLowValueOutcomes) {
-                const decision = {
-                    action: 'research-again',
-                    rationale: 'Current results did not justify more escalation; continue only with a more targeted pass.',
-                    followupQuery: query
-                };
-                return { decision, evidence: approvedEvidence, workerPass: pass };
+            const allEvidence = [];
+            const allGaps = [];
+            const allLowValueOutcomes = [];
+            const previousQueries = [];
+            const suggestedHeadlessUrls = [];
+            let headlessAttempts = 0;
+            let lastPass;
+            for (let passIndex = 0; passIndex < DEFAULT_MAX_PASSES; passIndex++) {
+                const queries = planSearchQueries({
+                    originalQuery: query,
+                    passIndex,
+                    previousQueries,
+                    gaps: allGaps.map((gap) => gap.message)
+                });
+                for (const plannedQuery of queries) {
+                    previousQueries.push(plannedQuery);
+                    const pass = await worker.run({
+                        query: plannedQuery,
+                        maxSearchRounds: 1,
+                        maxFetches: DEFAULT_MAX_FETCHES_PER_PASS
+                    });
+                    lastPass = pass;
+                    allEvidence.push(...pass.evidence);
+                    allGaps.push(...pass.gaps);
+                    allLowValueOutcomes.push(...pass.lowValueOutcomes);
+                    if (pass.suggestedHeadlessUrl)
+                        suggestedHeadlessUrls.push(pass.suggestedHeadlessUrl);
+                    const ranked = rankEvidence(allEvidence.filter((item) => item.sourceKind !== 'package-page'));
+                    const decision = decideNextResearchStep({
+                        evidence: ranked,
+                        suggestedHeadlessUrls,
+                        passIndex,
+                        maxPasses: DEFAULT_MAX_PASSES,
+                        headlessAttempts,
+                        maxHeadlessAttempts: DEFAULT_MAX_HEADLESS_ATTEMPTS
+                    });
+                    if (decision.action === 'headless') {
+                        headlessAttempts++;
+                        const headlessResult = await headlessFetch({ url: decision.url });
+                        const headlessEvidence = evidenceFromHeadless(headlessResult);
+                        if (headlessEvidence) {
+                            allEvidence.push(headlessEvidence);
+                            const updatedRanked = rankEvidence(allEvidence.filter((item) => item.sourceKind !== 'package-page'));
+                            const updatedDecision = decideNextResearchStep({
+                                evidence: updatedRanked,
+                                suggestedHeadlessUrls: [],
+                                passIndex,
+                                maxPasses: DEFAULT_MAX_PASSES,
+                                headlessAttempts,
+                                maxHeadlessAttempts: DEFAULT_MAX_HEADLESS_ATTEMPTS
+                            });
+                            return {
+                                decision: decisionForAnswer(updatedDecision.action === 'answer' ? 'answer' : 'answer-with-caveat', query, updatedRanked),
+                                evidence: updatedRanked,
+                                workerPass: lastPass,
+                                metadata: buildMetadata({
+                                    previousQueries,
+                                    allEvidence,
+                                    allGaps,
+                                    allLowValueOutcomes,
+                                    headlessAttempts,
+                                    exhaustedBudget: updatedDecision.action !== 'answer'
+                                })
+                            };
+                        }
+                        return {
+                            decision: {
+                                action: 'escalate-headless',
+                                rationale: 'One high-value page is worth a single orchestrator-approved headless retry.',
+                                url: decision.url,
+                                approvedEvidence: ranked
+                            },
+                            evidence: ranked,
+                            workerPass: lastPass,
+                            metadata: buildMetadata({
+                                previousQueries,
+                                allEvidence,
+                                allGaps,
+                                allLowValueOutcomes,
+                                headlessAttempts,
+                                exhaustedBudget: false
+                            })
+                        };
+                    }
+                    if (decision.action === 'answer' || decision.action === 'answer-with-caveat') {
+                        return {
+                            decision: decisionForAnswer(decision.action, query, ranked),
+                            evidence: ranked,
+                            workerPass: lastPass,
+                            metadata: buildMetadata({
+                                previousQueries,
+                                allEvidence,
+                                allGaps,
+                                allLowValueOutcomes,
+                                headlessAttempts,
+                                exhaustedBudget: decision.action === 'answer-with-caveat'
+                            })
+                        };
+                    }
+                }
             }
-            const decision = {
-                action: 'research-again',
-                rationale: 'The first pass did not gather enough strong evidence to answer safely.',
-                followupQuery: query
+            const ranked = rankEvidence(allEvidence.filter((item) => item.sourceKind !== 'package-page'));
+            return {
+                decision: decisionForAnswer('answer-with-caveat', query, ranked),
+                evidence: ranked,
+                workerPass: lastPass ??
+                    fallbackWorkerPass({
+                        previousQueries,
+                        allGaps,
+                        allLowValueOutcomes,
+                        exhaustedBudget: true
+                    }),
+                metadata: buildMetadata({
+                    previousQueries,
+                    allEvidence,
+                    allGaps,
+                    allLowValueOutcomes,
+                    headlessAttempts,
+                    exhaustedBudget: true
+                })
             };
-            return { decision, evidence: approvedEvidence, workerPass: pass };
         }
     };
 }