Support DuckDuckGo, Bing and Brave, switchable like the CDP host

Engine resolution mirrors the browser target: CCS_SEARCH_ENGINE, then a
/search-engine choice persisted machine-wide, then Google. A per-call
`engine` parameter sits above both so the agent can fall back when one
engine starts serving captchas — the one case where the model, not the
operator, has to make the call. Unlike the CDP target there is no safety
argument for the environment winning: driving the wrong browser means
automating someone's signed-in Chrome, choosing a different index does not.

An unsupported recency window is refused, naming the engines that support
it, rather than dropped. Silently returning unfiltered results is
indistinguishable from success, which is the failure this whole design is
trying to avoid.

Extraction grows a second mode. DuckDuckGo, Bing and Brave have clean
per-result containers; Google does not, so its heading-walk stays as its
own path rather than being bent into the item shape. DuckDuckGo and Bing
route links through redirectors, unwrapped in the page.

Third silent-failure trap found, alongside Google's two: on Bing, `count`
cancels `filters`. With ex1:"ez1" alone every result is hours old; add
count in either order and months-old results return, looking perfectly
ordinary. Bing now drops count whenever a date filter is present.

Challenge detection widened to Brave's "Verifying you're not a bot" and
"Quick check before you continue searching", which the previous Google-
shaped matcher missed entirely — found by tripping it.

1 files changed, 32 insertions, 5 deletions

diff --git a/src/errors.ts b/src/errors.ts
index d003e4f..2318b27 100644
--- a/src/errors.ts
+++ b/src/errors.ts
@@ -19,15 +19,35 @@ export class SearchChallengeError extends Error {
   readonly pageUrl: string;
   /** Which browser is blocked, e.g. "10.88.0.25:9223 (built-in default)". */
   readonly endpoint: string;
+  /** Which engine is blocked. */
+  readonly engine: string;
+  /** Engines that are not blocked and could be tried instead. */
+  readonly alternatives: readonly string[];
 
-  constructor(options: { challenge: string; pageUrl: string; endpoint: string; detail?: string | undefined }) {
+  constructor(options: {
+    challenge: string;
+    pageUrl: string;
+    endpoint: string;
+    engine: string;
+    alternatives: readonly string[];
+    detail?: string | undefined;
+  }) {
     super(
       [
-        `Search is blocked by a human verification challenge (${options.challenge}).`,
+        `${options.engine} is blocked by a human verification challenge (${options.challenge}).`,
         options.detail ? `Page said: ${options.detail}` : null,
-        `This cannot be solved by the agent — a person has to clear it in the browser at ${options.endpoint}.`,
-        `Ask the user to open ${options.pageUrl} in that Chrome, complete the challenge or accept the consent dialog,`,
-        `then retry the search. The cookie it sets persists in that browser profile, so one pass unblocks later searches.`,
+        // Retrying elsewhere comes first because it is the action the agent can
+        // take on its own; a challenge on one engine says nothing about the
+        // others, and asking the operator for help should be the fallback, not
+        // the first move.
+        options.alternatives.length > 0
+          ? `A challenge on one engine does not affect the others: retry the same query with engine set to ` +
+            `${options.alternatives.join(", ")} before asking anyone for help.`
+          : null,
+        `If every engine is blocked, this needs a person — the challenge cannot be solved by the agent.`,
+        `Ask the user to open ${options.pageUrl} in the Chrome at ${options.endpoint}, complete the challenge or`,
+        `accept the consent dialog, then retry. The cookie it sets persists in that browser profile, so one pass`,
+        `unblocks later searches.`,
       ]
         .filter((line) => line !== null)
         .join(" "),
@@ -35,9 +55,16 @@ export class SearchChallengeError extends Error {
     this.challenge = options.challenge;
     this.pageUrl = options.pageUrl;
     this.endpoint = options.endpoint;
+    this.engine = options.engine;
+    this.alternatives = options.alternatives;
   }
 }
 
+/** The chosen engine cannot express the requested recency window. */
+export class RecencyUnsupportedError extends Error {
+  override readonly name = "RecencyUnsupportedError";
+}
+
 /** The browser could not be reached or spoke CDP badly. */
 export class BrowserUnavailableError extends Error {
   override readonly name = "BrowserUnavailableError";