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, 89 insertions, 0 deletions

diff --git a/test/engine-target.test.ts b/test/engine-target.test.ts
new file mode 100644
index 0000000..e5ced6d
--- /dev/null
+++ b/test/engine-target.test.ts
@@ -0,0 +1,89 @@
+/**
+ * Engine selection, and the promise that an unsupported recency window is
+ * refused rather than dropped.
+ */
+
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { ENGINE_ENV_VAR, DEFAULT_ENGINE, resolveEngine } from "../src/engine-target.ts";
+import { enginesSupportingRecency, parseEngineId } from "../src/engines.ts";
+import { selectEngine } from "../src/search.ts";
+
+const ok = (r: ReturnType<typeof resolveEngine>) => {
+  assert.equal(r.kind, "ok");
+  if (r.kind !== "ok") throw new Error("unreachable");
+  return r;
+};
+
+test("nothing configured means the built-in default", () => {
+  const r = ok(resolveEngine(null, {}, null));
+  assert.equal(r.id, DEFAULT_ENGINE);
+  assert.equal(r.source, "default");
+});
+
+test("precedence is parameter, then env, then stored", () => {
+  assert.equal(ok(resolveEngine(null, {}, "bing")).id, "bing");
+  assert.equal(ok(resolveEngine(null, { [ENGINE_ENV_VAR]: "brave" }, "bing")).id, "brave");
+  // The parameter beating the env var is the deliberate difference from the CDP
+  // target: it is what lets the agent fall back when an engine is blocked.
+  const r = ok(resolveEngine("duckduckgo", { [ENGINE_ENV_VAR]: "brave" }, "bing"));
+  assert.equal(r.id, "duckduckgo");
+  assert.equal(r.source, "parameter");
+});
+
+test("aliases resolve, including the short ones a human would type", () => {
+  for (const [raw, expected] of [
+    ["ddg", "duckduckgo"],
+    ["duck", "duckduckgo"],
+    ["DuckDuckGo", "duckduckgo"],
+    ["  bing  ", "bing"],
+    ["g", "google"],
+    ["BRAVE", "brave"],
+  ] as const) {
+    assert.equal(parseEngineId(raw), expected, raw);
+  }
+});
+
+test("an unknown name is reported, never quietly skipped for the next source", () => {
+  // A typo in the env var must not silently search Google instead.
+  const r = resolveEngine(null, { [ENGINE_ENV_VAR]: "gooogle" }, "bing");
+  assert.equal(r.kind, "invalid");
+  if (r.kind !== "invalid") throw new Error("unreachable");
+  assert.equal(r.source, "env");
+  assert.equal(r.raw, "gooogle");
+});
+
+test("blank values fall through rather than counting as a choice", () => {
+  assert.equal(ok(resolveEngine("  ", { [ENGINE_ENV_VAR]: "  " }, "bing")).id, "bing");
+});
+
+test("an unsupported recency window is refused, and names engines that support it", async () => {
+  // Bing has no year window and Brave has no time filter; both must say so
+  // rather than returning unfiltered results that look filtered.
+  for (const engine of ["bing", "brave"] as const) {
+    const error = await selectEngine({ query: "q", numResults: 5, recency: "year", engine }).then(
+      () => null,
+      (e: Error) => e,
+    );
+    assert.ok(error, `${engine} should have refused`);
+    assert.equal(error.name, "RecencyUnsupportedError", engine);
+    for (const alt of enginesSupportingRecency("year")) assert.match(error.message, new RegExp(alt), engine);
+  }
+});
+
+test("windows an engine does support are accepted", async () => {
+  for (const [engine, recency] of [
+    ["google", "year"],
+    ["duckduckgo", "year"],
+    ["bing", "month"],
+  ] as const) {
+    const chosen = await selectEngine({ query: "q", numResults: 5, recency, engine });
+    assert.equal(chosen.engine.id, engine);
+  }
+});
+
+test("brave with no recency is fine — the refusal is about the window, not the engine", async () => {
+  const chosen = await selectEngine({ query: "q", numResults: 5, engine: "brave" });
+  assert.equal(chosen.engine.id, "brave");
+});