clearotron 0.3.2-beta.13 → 0.3.2-beta.15

package/providers/signa/src/capabilities.js

@@ -125,6 +125,35 @@ export const CAPABILITIES = Object.freeze({
   maxOrWidth: 1,
   // filters.nice_classes[] is a top-level OR filter — one call, no fan-out.
   classFilter: "native",
+  // ── THE GOODS-AND-SERVICES TEXT FILTER ──────────────────────────────────────────────────────────
+  // `filters.goods_services_text` — a free-text filter over the goods and services descriptions,
+  // documented by the vendor and composing with `nice_classes` and the query in the same request. It
+  // is what lets a crowded contains sweep be narrowed to what a filing actually covers rather than
+  // the bucket it was filed in.
+  //
+  // The key is accepted, it NARROWS, and it takes FREE TEXT — not the whole-word-plus-OR shape
+  // Clarivate's equivalent field demands. So the same word list goes to both providers and each
+  // connector writes it the way its own field takes it.
+  //
+  // This API rejects an unknown filter key outright (`HTTP 400 Unrecognized key: …` — the defect that
+  // hid a bogus `status` key for two months), which is why one call could settle acceptance.
+  goodsTextSearch: true,
+  // A multi-word goods term: a bare space here is an implicit AND and quoting is IGNORED, so a phrase
+  // cannot be matched AS a phrase — the words simply intersect. That intersection is the nearest
+  // honest form of what a phrase asks for, and it is what this connector sends. Nothing pretends it
+  // is a phrase.
+  // A multi-word term here INTERSECTS its words — it is not a phrase match, and the name says so.
+  // See clarivate/capabilities.js for the vocabulary.
+  goodsTextMultiWord: "word-intersection",
+  // A LIST of alternatives cannot be expressed here AT ALL. Every form was tried and none answers the
+  // union: `OR`, lower-case `or` and a quoted OR all return a population SMALLER than either word
+  // alone (the OR is matched as a literal third word), a pipe and a comma return the two words
+  // INTERSECTED, and an array is refused outright. A long list would therefore intersect to nothing
+  // while still answering 200 — the quiet false clean this contract exists to refuse.
+  //
+  // So the compiler does not build a multi-term goods entry for this provider, and it must never fall
+  // back to a space-joined string. No coverage is lost: the broad class-wide sweep still runs.
+  goodsTextListOr: false,
   // Search rows already carry status / nice_classes / owner_name → screening is inline, zero extra calls.
   screenSource: "search-row",
   // No hard result ceiling, and no total to compare one against.

package/providers/signa/src/core.js

@@ -23,6 +23,7 @@
 import { readFileSync, existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { goodsTermsList } from "../../_shared/term-shape.mjs";   // the shared reader for the goods words
 
 import { makeLedger } from "../../_shared/ledger.mjs";
 import { nonAnswerBodyError, parseJsonBody, unparsedBodyError } from "../../_shared/http-body.mjs";
@@ -132,6 +133,22 @@ function buildFilters(p) {
   // with a text query in ONE request, and the intersection is a real narrowing rather than one clause
   // being silently ignored — the three populations (term alone, owner alone, both) differ from each other.
   if (typeof p.owner === "string" && p.owner.trim()) f.owner_name = p.owner.trim();
+  // The goods-and-services narrowing. ONE term only: this filter is a single string whose words are
+  // ANDed, and no OR form exists (OR is matched as a literal third word; a pipe and a comma intersect;
+  // an array is refused). So a list of alternatives cannot be expressed, and joining one with spaces
+  // would ask for filings covering EVERY word — a population that shrinks as the list grows while
+  // still answering 200. The compiler does not build a multi-term entry for this provider; this
+  // refusal is the backstop for any path that does not go through it.
+  const goods = goodsTermsList(p);
+  if (goods.length > 1) {
+    throw new Error(
+      `goods_text carries ${goods.length} terms and this register has no OR on its goods filter: the `
+      + `words would be intersected, not offered as alternatives, and the answer would narrow as the `
+      + `list grew with no error. Send one term.`);
+  }
+  // A single term's own words ARE intersected, and that is the nearest honest form of the phrase the
+  // caller asked for — it is sent as written, and nothing here calls it a phrase match.
+  if (goods.length) f.goods_services_text = goods[0];
   return f;
 }
 

package/shared/demo-start-args.mjs

@@ -12,6 +12,16 @@
  * `--demo-own-base` says it is the demo's default, which is what lets the supervisor remove the folder
  * when the window closes. `--keep` is the reader's, and it travels as given.
  */
+/**
+ * The Node flag the demo runs under, so Node's one-time warning that its built-in SQLite is experimental
+ * does not land on the demo's first screen. Named once: the launcher puts it on the demo's own process,
+ * and `bin/example.mjs` hands it to the services it starts through NODE_OPTIONS.
+ */
+export const EXPERIMENTAL_WARNING_OFF = "--disable-warning=ExperimentalWarning";
+
+/** The same flag added to whatever NODE_OPTIONS the reader already has, which is kept. PURE. */
+export const withWarningOff = (nodeOptions) => [nodeOptions, EXPERIMENTAL_WARNING_OFF].filter(Boolean).join(" ");
+
 export function demoStartArgs({ demoBase, readerBase = false, keep = false, port = null, noOpen = false } = {}) {
   const args = ["--demo", "--base", demoBase];
   if (!readerBase) args.push("--demo-own-base");

package/shared/stdio-connect.mjs

@@ -32,6 +32,7 @@
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { stableInstallRoot } from "./permanent-install.mjs";
+import { tomlString } from "./toml-string.mjs";
 
 /** The install root — the directory holding `mcp-server/`, resolved from this module rather than cwd. */
 export const INSTALL_ROOT = join(fileURLToPath(new URL(".", import.meta.url)), "..");
@@ -103,15 +104,38 @@ export function stdioConnectOffer(opts = {}) {
 function envOf({ workDir = null, reportsDir = null } = {}) {
   return { ...(workDir ? { CLEAROTRON_WORK_DIR: workDir } : {}), ...(reportsDir ? { CLEAROTRON_REPORTS_DIR: reportsDir } : {}) };
 }
-const envFlags = (o) => Object.entries(envOf(o)).map(([k, v]) => ` -e ${k}=${v}`).join("");
 const envBlock = (o) => (Object.keys(envOf(o)).length ? { env: envOf(o) } : {});
 
+// ── ONE WORD PER ARGUMENT, IN THE SHELL THAT READS THE LINE ───────────────────────────────────────────
+//
+// The command was the arguments joined with spaces, so a path with a space in it became two arguments:
+// `/tmp/Example User/node/bin/node` reached the assistant as `/tmp/Example` and `User/node/bin/node`
+// (measured on the published beta, 2026-09-19). Each argument is now written as one word for the shell it
+// is pasted into. A word made only of characters no shell treats specially is left bare, so the line for
+// an ordinary install reads exactly as it did.
+//
+// POSIX shells: single quotes, the one quoting in which no character is special. A single quote inside is
+// closed, escaped and reopened.
+const POSIX_BARE = /^[A-Za-z0-9_@%+=:,./-]+$/;
+export const posixWord = (s) => (POSIX_BARE.test(String(s)) ? String(s) : `'${String(s).replace(/'/g, "'\\''")}'`);
+// Windows: cmd and PowerShell both honour double quotes, and the program then splits its command line by
+// the C runtime's rules, under which backslashes are literal except where they run up to a quote; there
+// they are doubled, and a quote inside the word is escaped. A comma or a parenthesis is quoted too, because
+// PowerShell reads a bare one as an array or an expression. `$`, a backtick and `%` cannot be quoted the
+// same way for both shells, and a path holding one is left to the reader.
+const WINDOWS_BARE = /^[A-Za-z0-9_+=:./\\-]+$/;
+export const windowsWord = (s) => {
+  const w = String(s);
+  if (WINDOWS_BARE.test(w)) return w;
+  return `"${w.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/, "$1$1")}"`;
+};
+
 /**
  * The argument that ends Claude Code's own options. Windows PowerShell 5.1 drops a bare `--` before it
  * reaches a native program, so the line failed with "missing required argument"; quoted, every shell passes
  * it through (bash, zsh, PowerShell and cmd alike), so a Windows install is handed the quoted form.
  */
-const separator = (platform = process.platform) => (platform === "win32" ? '"--"' : "--");
+const separator = (windowsShell) => (windowsShell ? '"--"' : "--");
 
 /**
  * WHAT THE HOST ACTUALLY RUNS, and on WSL that is not `node`.
@@ -180,11 +204,17 @@ export const STDIO_SHAPES = Object.freeze({
     where: null,
     render: ({ server, workDir, reportsDir, platform, wsl, node }) => {
       const l = stdioLauncher({ server, workDir, reportsDir, wsl, node });
+      // WHICH SHELL READS IT. A native Windows install's line is pasted on Windows, and so is the row
+      // that crosses into WSL: it exists for an assistant on the Windows side. Everything else is pasted
+      // into a POSIX shell.
+      const windowsShell = platform === "win32" || l.crossesIntoWsl;
+      const word = windowsShell ? windowsWord : posixWord;
       // The host's own `-e` flags set variables for the process IT starts. Off WSL that is the server;
       // through the wrapper it is `wsl.exe`, and they stop at the boundary — so on WSL they ride inside
       // the command instead and this line carries none.
-      const flags = l.crossesIntoWsl ? "" : envFlags({ workDir, reportsDir });
-      return `claude mcp add ${STDIO_SERVER_NAME} --scope user${flags} ${separator(platform)} ${l.command} ${l.args.join(" ")}`;
+      const flags = l.crossesIntoWsl ? ""
+        : Object.entries(envOf({ workDir, reportsDir })).map(([k, v]) => ` -e ${windowsShell ? word(`${k}=${v}`) : `${k}=${word(v)}`}`).join("");
+      return `claude mcp add ${STDIO_SERVER_NAME} --scope user${flags} ${separator(windowsShell)} ${[l.command, ...l.args].map(word).join(" ")}`;
     },
     after: null,
   },
@@ -224,7 +254,8 @@ export const STDIO_SHAPES = Object.freeze({
     kind: "config",
     where: "~/.codex/config.toml",
     // Written out rather than produced by a TOML library: this is four lines with no user-supplied
-    // strings in key positions, and adding a dependency to emit them would be the larger risk.
+    // strings in key positions, and adding a dependency to emit them would be the larger risk. Every
+    // value goes through `tomlString`, so a Windows path's backslashes are escaped as TOML requires.
     //
     // `env` and not `env_vars`, deliberately, and CONNECT.md explains why the distinction matters:
     // Codex does not forward the shell environment, and a credential would have to be forwarded BY NAME
@@ -234,10 +265,10 @@ export const STDIO_SHAPES = Object.freeze({
       const l = stdioLauncher({ server, workDir, reportsDir, wsl, node });
       return [
         `[mcp_servers.${STDIO_SERVER_NAME}]`,
-        `command = "${l.command}"`,
-        `args = [${l.args.map((a) => `"${a}"`).join(", ")}]`,
+        `command = ${tomlString(l.command)}`,
+        `args = [${l.args.map(tomlString).join(", ")}]`,
         ...(Object.keys(l.env).length
-          ? [`env = { ${Object.entries(l.env).map(([k, v]) => `${k} = "${v}"`).join(", ")} }`] : []),
+          ? [`env = { ${Object.entries(l.env).map(([k, v]) => `${k} = ${tomlString(v)}`).join(", ")} }`] : []),
       ].join("\n");
     },
     after: null,
@@ -297,7 +328,7 @@ export const REMOTE_SHAPES = Object.freeze({
     label: "Copy block",
     render: ({ address }) => [
       `[mcp_servers.${STDIO_SERVER_NAME}]`,
-      `url = "${address}"`,
+      `url = ${tomlString(address)}`,
     ].join("\n"),
   },
   "claude-cli-http": {
@@ -309,7 +340,7 @@ export const REMOTE_SHAPES = Object.freeze({
     label: null,
     render: ({ address }) => [
       `[mcp_servers.${STDIO_SERVER_NAME}]`,
-      `url = "${address}"`,
+      `url = ${tomlString(address)}`,
       `bearer_token_env_var = "${KEY_ENV_VAR}"`,
     ].join("\n"),
   },

package/shared/toml-string.mjs

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026 Cordillera Sàrl. Additional terms under section 7 of the AGPL-3.0 apply — see ADDITIONAL-TERMS.md
+//
+// ONE TOML STRING ENCODER, for every block this product writes.
+//
+// Two composers write TOML: the engine's per-run Codex configuration and the connection block a reader
+// pastes into `~/.codex/config.toml`. The second wrapped raw values in double quotes, so a Windows path
+// such as `C:\Program Files\nodejs\node.exe` produced a file TOML parsers refuse ("Unescaped '\' in a
+// string"). A value is a TOML string only once it has been through here.
+
+/**
+ * A TOML basic string holding exactly `s`. PURE.
+ *
+ * TOML requires the quotation mark, the backslash and every control character other than tab to be
+ * escaped (U+0000 to U+0008, U+000A to U+001F, and U+007F). The named escapes are used where TOML has one,
+ * and `\uXXXX` for the rest.
+ */
+export function tomlString(s) {
+  const esc = String(s ?? "")
+    .replace(/\\/g, "\\\\").replace(/"/g, '\\"')
+    .replace(/\x08/g, "\\b").replace(/\t/g, "\\t").replace(/\n/g, "\\n")
+    .replace(/\f/g, "\\f").replace(/\r/g, "\\r")
+    .replace(/[\x00-\x1f\x7f]/g, (c) => "\\u" + c.charCodeAt(0).toString(16).padStart(4, "0"));
+  return `"${esc}"`;
+}