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

package/mcp-server/lib/audit-view.mjs

@@ -285,8 +285,10 @@ const TIMELINE_FIELDS = ["ts", "seq", "kind", "phase", "stage", "decision", "tri
   "changedFromPrevious", "attempt", "axes", "axis", "escalated", "verdict", "display", "cause",
   "recovered", "count", "uris", "findings", "negatives", "audit", "snapshot", "resume"];
 
-// `state` and `verdict` TRAVEL — the timeline's own conclusion, and dropping them here while
-// accountTrace keeps `judgment.verdict` would have been two surfaces disagreeing about one fact.
+// `state` and `tier` TRAVEL — the run's state and its BAND. The band replaced the gate's word here (824):
+// CLEAR / CONDITIONAL / BLOCKING is engine vocabulary, and a client's assistant reading it beside a
+// rating of Medium reported the run as delivered BLOCKING. The gate's decisions are not lost — every one
+// of them is a timeline entry and a `verdictHistory` row, which is what this surface exists to narrate.
 //
 // `riskLadderAvailable` and `note` do NOT, together and for one reason: the flag exists only to say
 // whether `diff_artifact` could show the word-by-word change, and `diff_artifact` is sealed. A flag
@@ -303,7 +305,7 @@ export function accountTimeline(result, { brandName = "The firm" } = {}) {
     return out;
   };
   return {
-    ...pick(result, ["runId", "state", "verdict", "_note"]),
+    ...pick(result, ["runId", "state", "tier", "_note"]),
     timeline: Array.isArray(result.timeline) ? result.timeline.map(entry) : [],
     verdictHistory: Array.isArray(result.verdictHistory)
       ? result.verdictHistory.map((v) => pick(v, ["ts", "kind", "verdict", "stage"]))

package/mcp-server/lib/brief.mjs

@@ -74,9 +74,12 @@ export function buildBrief(run) {
   const delivered = run.state === "delivered" || Boolean(run.deliveredAt);
   const lines = [];
 
-  const overall = clearance?.verdict?.band ?? clearance?.verdict?.verdict
+  // THE BAND, AND NEVER THE GATE'S WORD. This chain used to fall through to the delivery verdict — the
+  // sidecar's `verdict`, then the run's — so a run whose report reads Medium could be briefed as BLOCKING.
+  // The band is what the report shows; where no band is recorded the line is not drawn at all.
+  const overall = clearance?.verdict?.band ?? clearance?.verdict?.tier
     ?? (koDocs.length === 1 ? (koDocs[0].overall ?? null) : null)
-    ?? fm.overall_label ?? run.verdict ?? null;
+    ?? fm.overall_label ?? run.tier ?? null;
 
   // headline — the mark, the product THIS run actually is, and the run date. A null product prints
   // nothing rather than a fallback name.
@@ -100,7 +103,10 @@ export function buildBrief(run) {
     const paused = run.state === "postponed" ? ` — paused on a usage-limit cap, auto-resumes ${run.resetsAt ? `at ${String(run.resetsAt).replace("T", " ").slice(0, 16)} UTC` : "when the cap resets"}`
       : run.state === "recovering" ? ` — auto-recovery backoff, resumes ${run.recoveryResumesAt ? `at ${String(run.recoveryResumesAt).replace("T", " ").slice(0, 16)} UTC` : "on its own"}`
       : run.state === "parked-for-human" ? ` — parked by a runner stop (deploy/restart), resumes on the next runner activation` : "";
-    lines.push(`Status: ${run.state}${paused}${run.verdict ? ` (reviewer verdict: ${run.verdict})` : ""}.`);
+    lines.push(`Status: ${run.state}${paused}.`);
+    // The run's own sentence, composed once by the driver and rendered on every client surface. It says
+    // what the gate word used to be reached for, in the words the report itself uses.
+    if (run.statement) lines.push(String(run.statement));
   }
 
   let source = "none";
@@ -198,7 +204,7 @@ export function buildBrief(run) {
   return {
     runId: run.runId, markName: run.markName ?? clearance?.markName ?? fm.title ?? null,
     product,
-    overall, verdict: run.verdict ?? null, state: run.state ?? null, date: run.date ?? null,
+    overall, tier: run.tier ?? null, statement: run.statement ?? null, state: run.state ?? null, date: run.date ?? null,
     source, brief: lines.join("\n"),
   };
 }

package/mcp-server/lib/runs.mjs

@@ -36,6 +36,28 @@ function findStatusFiles(root, depth, acc) {
  * workspace, lists exactly as before, and an empty list from either still means an empty list. PURE given
  * its inputs.
  */
+// The three words the delivery gate decides in. They are engine vocabulary and never a rating.
+const GATE_WORDS = new Set(["CLEAR", "CONDITIONAL", "BLOCKING"]);
+/** A recorded outcome word read as a rating band, or null where it is the gate's decision. PURE. */
+export const bandWord = (v) => {
+  const w = String(v ?? "").trim();
+  return w && !GATE_WORDS.has(w.toUpperCase()) ? w : null;
+};
+
+/**
+ * The band a run recorded before `status.json` carried one: the verdict record's own `tier`. Read only
+ * where the status has neither a band nor a band-shaped outcome word, so a current run costs no read.
+ * Null where there is no record to read — an absence, never a guess. PURE of everything but the file.
+ */
+export function tierFromRecord(runDir) {
+  if (!runDir) return null;
+  try {
+    const v = JSON.parse(readFileSync(driverDir(runDir, "verdict.json"), "utf8"));
+    const t = String(v?.tier ?? "").trim();
+    return t || null;
+  } catch { return null; }
+}
+
 export function unreadableRunsReason({ workSet, workRoot, workExists, poolSet }) {
   if (workSet || workExists || poolSet) return null;
   return `no searches can be read here: CLEAROTRON_WORK_DIR is unset and ${workRoot} does not exist, `
@@ -68,7 +90,19 @@ function runFromStatusFile(statusFile, agent) {
     runId: s.runId ?? `${s.slug}-${s.date}-${s.codename}`,
     slug: s.slug, codename: s.codename, date: s.date,
     agent: s.agent ?? agent,
-    state: s.state ?? null, verdict: s.verdict ?? null, url: s.url ?? null,
+    // The BAND and the run's own composed sentence, never the delivery gate's word: `verdict` is
+    // engine vocabulary (CLEAR / CONDITIONAL / BLOCKING) and stays in the run record.
+    //
+    // ONE FIELD, TWO LANES. The knockout lane records its BAND in `verdict` — "High", "Manageable" — and
+    // every archived run of either lane has only that field, so the band is read from it where it is a
+    // band and dropped where it is the gate's word. A clearance run recorded since 2026-09-20 carries
+    // `tier` and needs no such reading.
+    // THE BAND IS ALWAYS HERE, and the gate's word is not. Reading `bandWord` alone left a run recorded
+    // before the band was written with NO band at all — `bandWord` answers null for a gate word — so an
+    // assistant saw the gate's word and nothing beside it, which is the shape this whole item is about.
+    // The verdict record holds the band for those runs, so it is read from there.
+    state: s.state ?? null,
+    tier: s.tier ?? bandWord(s.verdict) ?? tierFromRecord(runDir), statement: s.statement ?? null, url: s.url ?? null,
     markName: s.markName ?? null, ref: s.ref ?? null, classes: s.classes ?? null,
     stepN: s.stepN ?? null, stepLabel: s.stepLabel ?? null, stepTotal: s.stepTotal ?? null,
     failedStage: s.failedStage ?? null, reason: s.reason ?? null,

package/mcp-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trademark-artifacts-mcp",
-  "version": "0.3.2-beta.13",
+  "version": "0.3.2-beta.15",
   "license": "AGPL-3.0-only",
   "private": true,
   "description": "MCP server to interrogate clearotron trademark-clearance runs — list/read artifacts, trace the full decision flow, telemetry/cost, coverage, single-run search, and a gated single-step what-if. Imports the clearotron-driver read-only; touches no driver/template/deploy files.",

package/mcp-server/server.mjs

@@ -207,7 +207,8 @@ function runSummary(run) {
     // once. null where the registry cannot name it — the row says nothing rather than guessing, because
     // a hardcoded fallback is how a knockout once announced itself as a product it provably was not.
     product: productIdentityFor(run),
-    state: run.state, location: run.location, verdict: run.verdict, url: run.url,
+    // The band and the run's own sentence; the gate's word stays in the run record (824).
+    state: run.state, location: run.location, tier: run.tier, statement: run.statement, url: run.url,
     markName: run.markName, ref: run.ref, classes: run.classes,
     step: s.stepN ? `${s.stepN}/${s.stepTotal} ${s.stepLabel ?? ""}`.trim() : null,
     startedAt: run.startedAt, updatedAt: run.updatedAt, deliveredAt: run.deliveredAt,
@@ -480,7 +481,9 @@ const tools = {
     // a generic _history dir for some OTHER stage does not make register-findings diffable.
     const riskLadderAvailable = listArtifactVersions(run.P, run.runDir, "register-digest", null).length > 1;
     return {
-      runId: run.runId, state: run.state, verdict: run.verdict, verdictHistory, timeline,
+      // The chain narrates the gate's decisions, and every one of them is on the timeline and in
+      // `verdictHistory`, which is where they belong. The run's own headline is its BAND (824).
+      runId: run.runId, state: run.state, tier: run.tier, verdictHistory, timeline,
       riskLadderAvailable,
       note: riskLadderAvailable
         ? "A prior register-findings (digest) snapshot exists — diff_artifact can show the word-by-word change."
@@ -497,7 +500,7 @@ const tools = {
     let changes = timeline;
     if (Array.isArray(kinds) && kinds.length) changes = changes.filter((c) => kinds.includes(c.kind));
     return {
-      runId: run.runId, state: run.state, verdict: run.verdict, since: since ?? null, cursor,
+      runId: run.runId, state: run.state, tier: run.tier, since: since ?? null, cursor,
       count: changes.length, changes,
       note: "Poll again with since=cursor (a stable sequence number) for only newer events — MCP has no push. cursor is independent of the kinds filter.",
     };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "clearotron",
   "type": "module",
-  "version": "0.3.2-beta.13",
+  "version": "0.3.2-beta.15",
   "license": "AGPL-3.0-only",
   "repository": {
     "type": "git",

package/portal-ui/dist/assets/{index-7Lq-dXDV.css → index-5CCwiJG7.css}

@@ -2922,6 +2922,16 @@ details[open] > .fold-summary .fold-chev {
   border: 1px solid var(--border-hairline); border-radius: 11px; background: var(--surface-raised);
 }
 
+/* THE WAIT IS NOT A FAULT, AND IT MUST NOT BE READ AS ONE. It looks like `.home2-notice` because both
+   are a quiet line above the lists, but it is deliberately NOT that class: `.home2-notice` is where
+   this page states a fault, and home-render-check reads it as exactly that. Drawing the wait there
+   made a page with nothing wrong report a fault in both themes — the very thing the wait was added to
+   stop, arriving through the class attribute. */
+.home2-waiting {
+  margin: 0 0 13px; padding: 11px 14px; font-size: 13px; color: var(--text-body);
+  border: 1px solid var(--border-hairline); border-radius: 11px; background: var(--surface-raised);
+}
+
 /* 340px minimum is LOAD-BEARING: the depth label must never be clipped, and three of the five depths
    differ only in their suffix. */
 .home2-cards { display: grid; grid-template-columns: repeat(auto-fit, minmax(340px, 1fr)); gap: 13px; }

package/portal-ui/dist/assets/{index-w8GFZftk.js → index-DMthc7PQ.js}

@@ -13299,7 +13299,10 @@ function AppShell({ render }) {
 		setDrawer(false);
 		setAvatarOpen(false);
 	}, [path]);
-	if (!meResult) return (0, import_jsx_runtime.jsx)("div", { className: "screen" });
+	if (!meResult) return (0, import_jsx_runtime.jsx)("div", {
+		className: "screen",
+		children: (0, import_jsx_runtime.jsx)("p", { children: "Loading…" })
+	});
 	if (sessionEnded || meResult && meResult.kind === "signedOut") return (0, import_jsx_runtime.jsx)(SessionEnded, {});
 	if (!meResult || meResult.kind !== "ok") return (0, import_jsx_runtime.jsx)("div", {
 		className: "screen",
@@ -15530,6 +15533,10 @@ function Home({ ctx }) {
 					label: "Filter by company"
 				})
 			}),
+			answer === "loading" ? (0, import_jsx_runtime.jsx)("p", {
+				className: "home2-waiting",
+				children: "Loading…"
+			}) : null,
 			answer === "error" ? (0, import_jsx_runtime.jsx)("p", {
 				className: "home2-notice",
 				children: result?.kind === "rateLimited" ? "Too many requests just now. The portal is pacing itself; this will refresh on its own." : "This did not load. Nothing is wrong with your runs — the list will try again."

package/portal-ui/dist/index.html

@@ -49,8 +49,8 @@
     -->
     <link rel="preconnect" href="https://api.fontshare.com" crossorigin />
     <link href="https://api.fontshare.com/v2/css?f[]=satoshi@400,500,700,900&display=swap" rel="stylesheet" />
-    <script type="module" crossorigin src="/portal/assets/index-w8GFZftk.js"></script>
-    <link rel="stylesheet" crossorigin href="/portal/assets/index-7Lq-dXDV.css">
+    <script type="module" crossorigin src="/portal/assets/index-DMthc7PQ.js"></script>
+    <link rel="stylesheet" crossorigin href="/portal/assets/index-5CCwiJG7.css">
   </head>
   <body>
     <div id="root"></div>

package/portal-ui/package.json

@@ -2,7 +2,7 @@
   "name": "portal-ui",
   "private": true,
   "type": "module",
-  "version": "0.3.2-beta.13",
+  "version": "0.3.2-beta.15",
   "license": "AGPL-3.0-only",
   "description": "The unified trademark portal UI. One address, one login: who you are decides what you see. Built as a static bundle, served by driver/portal-service.mjs — the browser never reaches profile-service or recipe-service.",
   "engines": {

package/providers/_shared/execute-plan.mjs

@@ -17,7 +17,7 @@
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { nativeScriptIndexGap } from "./script-form.mjs";
-import { entryTermIssues } from "./term-shape.mjs";
+import { entryTermIssues, goodsTermsList } from "./term-shape.mjs";
 import { faultText, guardToolCall } from "./transport-guard.mjs";
 import { clipProviderText } from "./provider-text.mjs";   // — keep the discriminator
 
@@ -240,6 +240,16 @@ export function defaultBuildEntryQuery(e, pp) {
     // F1 owner×term intersection: a mark-text entry carrying `owner` rides it as an additional
     // owner filter beside the name clause (see the doc block above defaultBuildEntryQuery).
     ...(!__owner && typeof e.owner === "string" && e.owner.trim() ? { owner: e.owner.trim() } : {}),
+    // The goods-and-services narrowing, carried the same way and for the same reason as `owner`: an
+    // extra FIELD on the same request, never a second query. A provider that cannot send it declares
+    // `goodsTextSearch` false and the entry is refused before the query is built (goodsTextGap), so
+    // this line never reaches a connector that would quietly drop the clause and run the wide sweep.
+    ...(goodsTermsList(e).length ? { goods_text: goodsTermsList(e) } : {}),
+    // …and the DISTANCES those words stood at. The compiler stripped the register's operator words
+    // once and stored what will be asked, so a term arrives here with nothing left to strip: without
+    // the gaps a connector would join "controllers peripherals" as a plain adjacency, which is the
+    // query that matches nothing. The plan states the distances; this carries them.
+    ...(Array.isArray(e?.goods_text_gaps) && e.goods_text_gaps.length ? { goods_text_gaps: e.goods_text_gaps } : {}),
     ...modeParams,
     nice_classes: (e.nice_classes ?? []).map(Number).filter(Number.isFinite),
     ...(Array.isArray(e.regions) && e.regions.length ? { regions: e.regions } : {}),

package/providers/_shared/term-shape.mjs

@@ -249,3 +249,79 @@ export function termSubstanceIssue(term) {
     + `match, under any predicate. Refused at the builder rather than bounced by the provider and `
     + `disclosed as a coverage gap the run could never have closed`;
 }
+
+// ── THE GOODS-AND-SERVICES TERMS AN ENTRY CARRIES ─────────────────────────────────────────────────
+//
+// ONE definition, because three places must agree on what "this entry asks for goods text" means: the
+// plan compiler stamping the capability gap, the executor building the query, and each connector
+// writing the clause. Two hand-rolled readings of the same field is how `filters.status` stayed wrong
+// for two months on one provider while looking right on the other.
+//
+// A scalar and a one-element list are the SAME request. Blanks are dropped and duplicates collapse, so
+// an entry asking for the same term twice compiles byte-identically to one asking once — the plan is a
+// pure function of its input, and that must survive this field like every other. PURE.
+export function goodsTermsList(entry) {
+  const raw = Array.isArray(entry?.goods_text) ? entry.goods_text
+    : (typeof entry?.goods_text === "string" ? [entry.goods_text] : []);
+  const out = [];
+  for (const t of raw) {
+    const s = String(t ?? "").trim();
+    if (s && !out.includes(s)) out.push(s);
+  }
+  return out;
+}
+
+// ── A GOODS TERM CARRYING A WORD THE REGISTER READS AS AN OPERATOR ────────────────────────────────
+//
+// `AND`, `OR`, `NOT`, `ADJ` and `NEAR` are operators INSIDE the value string on the register this
+// engine runs on in production, and that field has no escape syntax. A goods term carrying one is not
+// a narrower search there — it is a 400, and because the list rides ONE OR-joined value, a single bad
+// term takes the whole narrowing down with it for the run.
+//
+// `NEAR` is why this is its own function rather than a reused check: the connector's own term
+// validator tests AND/OR/NOT only, so "near field communication" passes every offline check and fails
+// on the wire — the shape that reads as working right up until it does not.
+//
+// THE WORD IS REMOVED, THE ITEM IS NOT. "near field communication" still narrows usefully as
+// "field communication", and dropping it whole would throw away a term the model chose on account of
+// one word the vendor happens to reserve. Only an item that is NOTHING BUT reserved words disappears.
+// Every removal is reported so the caller can disclose it: a term that reached the wire in a
+// different shape than it was written must never do so silently.
+//
+// PURE.
+const GOODS_RESERVED_WORDS = new Set(["and", "or", "not", "adj", "near"]);
+
+/**
+ * Strip the words this register parses as operators out of a goods term.
+ *
+ * `{ words, gaps, removed, cleaned }`. `gaps[i]` is the distance from `words[i]` to `words[i+1]` — 1
+ * when they were adjacent, 2 when one word was taken out between them, and so on.
+ *
+ * THE GAP IS THE WHOLE POINT and it is the rule the mark field already follows. Removing a word from
+ * the middle of a phrase leaves the survivors further apart than they were written: "controllers and
+ * peripherals" asked as a strict adjacency finds nothing, because no filing says "controllers
+ * peripherals". Widened by the gap it finds what was meant. A word taken off the FRONT or the BACK
+ * changes no distance between the words that remain, so "near field communication" stays a strict
+ * adjacency of "field" and "communication".
+ *
+ * PURE.
+ */
+export function stripGoodsReservedWords(term) {
+  const removed = [];
+  const words = [];
+  const gaps = [];
+  let owed = 1;                       // the distance owed to the NEXT kept word
+  for (const tok of String(term ?? "").trim().split(/\s+/)) {
+    if (!tok) continue;
+    // `ADJ2`/`NEAR3` are the numbered forms of the same operators.
+    if (GOODS_RESERVED_WORDS.has(tok.toLowerCase().replace(/\d+$/, ""))) {
+      removed.push(tok);
+      if (words.length) owed += 1;    // …only widens a gap once there is something to widen it FROM
+      continue;
+    }
+    if (words.length) gaps.push(owed);
+    words.push(tok);
+    owed = 1;
+  }
+  return { words, gaps, removed, cleaned: words.join(" ") };
+}

package/providers/clarivate/src/capabilities.js

@@ -214,6 +214,42 @@ export const CAPABILITIES = Object.freeze({
   // (expandOwnerTerms → assertSearchableTerm → degrade-to-unresolved) applies to the owner value on
   // this path exactly as on a bare owner sweep — resolution stays additive-only.
   ownerTermIntersection: true,
+  // ── CAN THE REGISTER BE ASKED WHAT A FILING COVERS, NOT JUST WHICH BUCKET IT SITS IN? ────────────
+  // `true` — `INT_GOODS_SERVICES_DESCRIPTION` is in the vendor's search-field enum, and it AND-joins
+  // with the mark and class clauses in one request exactly as the owner field does. That is the whole
+  // lever behind narrowing a crowded contains sweep: the Nice class is a filing bucket that holds
+  // headphones and jukeboxes alike, so class-scoping alone cannot cut a crowd on a common word.
+  //
+  // A provider that does not declare this gets a DISCLOSED DEFERRED ROW for any goods-narrowed slice
+  // (register-plan.mjs goodsTextGap → `unsupported`). It must never fall back to the un-narrowed
+  // sweep: that would return the crowd the narrowing exists to avoid and record it under the narrowed
+  // slice's qid — a widened search wearing a narrow slice's name.
+  goodsTextSearch: true,
+  // Does this register match a MULTI-WORD goods term as a phrase? YES, but only through `ADJ`, and the
+  // connector must do the joining. A BARE SPACE ON THIS FIELD IS AN IMPLICIT OR: both word orders
+  // return the same population, that population equals the explicit OR, and the explicit AND is a
+  // fraction of it. So a two-word value sent as written WIDENS the sweep to either word, answers 200
+  // and reads like a filter that worked — a clause meant to narrow doing the opposite, silently.
+  // `A ADJ B` is ordered and is the form core.js emits.
+  // What a MULTI-WORD goods term means on this register, named rather than flagged: the two registers
+  // that accept one do ENTIRELY DIFFERENT THINGS with it, and a shared boolean said only "yes".
+  //   "ordered-phrase"    — the words in that order, adjacent. Here, via the ADJ operator.
+  //   "word-intersection" — filings whose description carries every word, anywhere, in any order.
+  //   null                — unmeasured or unsupported: a multi-word term must not be sent.
+  goodsTextMultiWord: "ordered-phrase",
+  // Several goods terms ride ONE clause joined by OR — this register expresses a list natively.
+  goodsTextListOr: true,
+  // The operator the goods clause rides. `EQUALS` on WHOLE WORDS: `CONTAINS` is a hard 400 here
+  // exactly as it is on APPLICANT_NAME, and so is a mid-word wildcard. Several words are asked for
+  // with `OR` inside the value.
+  //
+  // That makes this field the opposite of the mark field, where every mode is EQUALS with `*TERM*`
+  // infix wildcards. The two are NOT interchangeable, and the vendor's own documentation does not
+  // separate them. Do not "make it consistent" with the mark modes.
+  goodsTextOperator: "EQUALS",
+  // Whole words only: no wildcard may be sent on this field, so core.js splits a multi-word term into
+  // its words and ORs them rather than compiling an adjacency the field would reject.
+  goodsTextWholeWordOnly: true,
   // ── WHICH FORM OF A NON-LATIN MARK DOES THE INDEX HOLD? ──────────────────────────────────────────
   // `false` = the TRANSLITERATION ONLY. The characters are not indexed, so searching them returns 0
   // with no error — the exact false-clean shape a reader calls CLEAN:

package/providers/clarivate/src/core.js

@@ -41,6 +41,7 @@ import { makeCountProbe } from "../../_shared/count.mjs";
 import { CAPABILITY_GAP_MARKER, defaultBuildEntryQuery, makeExecutePlan, makeRegionRequiredBuildEntryQuery, planPredicateParams } from "../../_shared/execute-plan.mjs";
 import { isNonLatinTerm } from "../../_shared/script-form.mjs";
 import { CAPABILITIES, CLARIVATE_OFFICE_CODES } from "./capabilities.js";
+import { stripGoodsReservedWords } from "../../_shared/term-shape.mjs";   // the goods field parses these words as operators
 
 export const DEFAULT_BASE = "https://api.clarivate.com/compumark-content/api/v1";
 
@@ -116,6 +117,11 @@ const errText = (r) => r?.body?.errorMessage ?? r?.body?.message ?? (r?.raw ? St
 // OR-stack — the operator stays EQUALS and the value does the vendor's query-string work.
 export const MARK_FIELD = "WORD_MARK_SPECIFICATION";
 export const OWNER_FIELD = "APPLICANT_NAME";
+// The goods-and-services DESCRIPTION field — the text of what a filing covers, not the Nice class
+// number it was filed under. The two are separate fields here and they answer separate questions.
+export const GOODS_FIELD = "INT_GOODS_SERVICES_DESCRIPTION";
+// Declared in capabilities.js, read here — one constant, so the operator changes in one place.
+export const GOODS_OPERATOR = CAPABILITIES.goodsTextOperator ?? "EQUALS";
 
 /**
  * match_mode → { name, operator, pre, post, … }.
@@ -496,6 +502,18 @@ export function ownerTermsOf(p) {
   return out;
 }
 
+/**
+ * The goods-and-services terms a request carries. Accepts a scalar or a list; a one-element list and
+ * a scalar are the same request. Never an element on its own — see hasAnyElement below.
+ */
+export function goodsTermsOf(p) {
+  const out = [];
+  for (const t of (Array.isArray(p?.goods_text) ? p.goods_text : [p?.goods_text])) {
+    if (t != null && String(t).trim()) out.push(String(t).trim());
+  }
+  return out;
+}
+
 export function hasAnyElement(p) {
   return markTermsOf(p).length > 0 || ownerTermsOf(p).length > 0 || !!p?.representative;
 }
@@ -651,6 +669,107 @@ export function buildSearchRequest(p) {
     searchFields.push({ operator: "EQUALS", name: "INT_CLASS_NUMBER", value: joinOrValue([...new Set(classes)]) });
   }
 
+  // ── the goods-and-services NARROWING ─────────────────────────────────────────────────────────────
+  //
+  // A class is a filing bucket, not a specification: class 9 holds headphones and jukeboxes alike, so
+  // a contains sweep scoped to the class alone crowds out on any common word. This clause asks the
+  // description text instead, and it AND-joins with the mark and class clauses like every other field
+  // here — narrowing the same sweep rather than running a second one.
+  //
+  // THIS FIELD IS NOT THE MARK FIELD, and assuming it was would ship a 400 on every narrowed sweep:
+  //
+  //   EQUALS, whole word            → works
+  //   CONTAINS                      → hard 400, as on APPLICANT_NAME
+  //   a mid-word wildcard (`*foo*`) → hard 400
+  //   `WORD1 OR WORD2`              → works, and is how several words are asked for
+  //
+  // So the value is a list of WHOLE WORDS joined by OR, with no wildcards anywhere — the opposite of
+  // the `*TERM*` infix every mark mode uses. THE CLAUSE MUST NOT ROUTE THROUGH `MATCH_MODE_TO_FIELD`:
+  // every mode there carries `pre:"*", post:"*"`, so a goods clause built through that map would
+  // inherit the wrap, pass every offline test, and 400 on the wire.
+  //
+  // A MULTI-WORD TERM IS REFUSED RATHER THAN SPLIT. Splitting "computer software" into
+  // `computer OR software` would match a filing that only ever says "computer" — a WIDER search than
+  // the caller asked for, arriving silently, which is the one thing this engine never does. The word
+  // list's contract is whole words (the variants manual says so), so a phrase here is a caller defect
+  // and it fails at the door. What the wire does with a two-word value is unprobed, and guessing it
+  // into an OR is the same guess wearing a different hat.
+  //
+  // PLURALS COME FROM THE VENDOR (queryOptions.plurals), SYNONYMS DO NOT. "headphones" does not reach
+  // "earphones" on any documented surface here. Nothing in this file invents one: a synonym list is a
+  // recall decision about what a search is allowed to miss, and it belongs to whoever writes the word
+  // list, never to the connector spending it.
+  const goodsTerms = goodsTermsOf(p);
+  if (goodsTerms.length) {
+    // A NARROWING WITH NOTHING TO NARROW IS NOT A NARROW SEARCH — IT IS A WIDE ONE. Goods text is not
+    // a search element (hasAnyElement excludes it deliberately): on its own it asks for every filing
+    // in these classes whose description carries the word, from every owner, which is far wider than
+    // the sweep it was added to cut. The request would succeed and read as a narrowed slice.
+    if (!markTerms.length && !ownerTermsOf(p).length && !p?.representative) {
+      throw new Error(
+        "goods_text narrows a search and is not one: this request carries no mark term, owner or "
+        + "representative, so the goods clause would be the whole query — every filing in these classes "
+        + "whose description carries the word. Send it alongside the term it narrows.");
+    }
+    const words = [];
+    let gi = -1;
+    for (const t of goodsTerms) {
+      gi += 1;
+      // A PHRASE IS NEVER PASSED AS TYPED. A bare space on this field is an implicit OR — both word
+      // orders return the same population, it equals the explicit OR, and the explicit AND is a
+      // fraction of it. So "wireless headphones" sent as written would quietly search for EITHER word:
+      // a WIDER sweep than was asked for, answering 200 and reading like a filter that worked.
+      //
+      // `ADJ` is the operator that expresses a real phrase here, and it is ORDERED. So a multi-word
+      // term becomes its words joined by ADJ, and the list of terms is joined by OR — "either of these
+      // things, and this one is two words in this order".
+      // A WORD THIS FIELD READS AS AN OPERATOR COMES OUT HERE TOO, AND DOES NOT THROW. AND, OR, NOT,
+      // ADJ and NEAR are parsed inside the value and there is no escape syntax — and `NEAR` is
+      // ordinary specification language, so this is not a contrived input. The plan compiler already
+      // strips them and discloses it; this is the backstop for the paths that never go through a plan.
+      //
+      // It must STRIP rather than refuse: the list rides one OR-joined value, so throwing here would
+      // take every good term down with the bad one and leave the crowd a crowd. Refusing loudly is
+      // right when the alternative is a wrong answer; here the alternative is a narrower one, and the
+      // narrower one is what the caller asked for minus a word the vendor happens to reserve.
+      // THE ADJACENCY IS WIDENED BY WHAT WAS TAKEN OUT, which is the rule the mark field already
+      // follows: no filing says "controllers peripherals", so a strict adjacency of the survivors
+      // finds nothing where `controllers ADJ2 peripherals` finds the phrase that was meant. A word
+      // removed from the front or the back changes no distance between the words that remain.
+      //
+      // THE DISTANCES COME FROM THE PLAN WHERE THERE IS ONE. The compiler strips once and stores what
+      // will be asked, so a planned term arrives here already stripped and re-stripping it finds
+      // nothing to remove — the gaps would come back all 1 and the query would assert an adjacency
+      // that was never written. Stripping again locally is right only for the paths that never went
+      // through a plan, and it is a no-op on the ones that did.
+      const planned = Array.isArray(p?.goods_text_gaps) ? p.goods_text_gaps[gi] : null;
+      const local = stripGoodsReservedWords(t);
+      const { words: stripped, removed } = local;
+      const gaps = Array.isArray(planned) && planned.length ? planned : local.gaps;
+      if (!stripped.length) continue;
+      const parts = [];
+      for (const w of stripped) {
+        const safe = assertSearchableTerm(w, { allowWildcard: false });
+        if (safe) parts.push(safe);
+      }
+      if (!parts.length) continue;
+      if (parts.length > 1 && !CAPABILITIES.goodsTextMultiWord) {
+        throw new Error(
+          `goods term ${JSON.stringify(String(t).slice(0, 40))} is more than one word, and this register `
+          + `is not known to match a phrase as a phrase. Send the words you mean, one per entry.`);
+      }
+      // Single word: itself. Several: an adjacency chain whose every step carries the distance the
+      // words actually stood at, so a removal in the middle widens it and a removal at either end
+      // does not.
+      let value = parts[0];
+      for (let i = 1; i < parts.length; i++) {
+        value += ` ADJ${gaps[i - 1] > 1 ? gaps[i - 1] : ""} ${parts[i]}`;
+      }
+      if (!words.includes(value)) words.push(value);
+    }
+    if (words.length) searchFields.push({ operator: GOODS_OPERATOR, name: GOODS_FIELD, value: joinOrValue(words) });
+  }
+
   const queryOptions = {};
   if (p?.active_only != null)        queryOptions.activeOnly = !!p.active_only;
   if (p?.plurals != null)            queryOptions.plurals = !!p.plurals;

package/providers/corsearch/src/capabilities.js

@@ -109,6 +109,30 @@ export const CAPABILITIES = Object.freeze({
   // with the term"). Declared as data so the planner/mint/executor hang off the declaration, never the
   // vendor name.
   ownerTermIntersection: true,
+  // ── GOODS-AND-SERVICES TEXT ──────────────────────────────────────────────────────────────────────
+  // `assembleQuery` builds a `product:` clause — this vendor's name for the goods description the
+  // others search too, documented in its own screening help as the written description of goods and
+  // services. The clause existed here long before anything passed it, which is the only reason this
+  // capability was ever false.
+  //
+  // A capability describes what a request through this adapter will actually do, never what the vendor
+  // is capable of — declaring `true` while the connector dropped the clause would compile narrowed
+  // slices into silently un-narrowed searches, the exact widened-search-wearing-a-narrow-name failure
+  // the deferral lane exists to prevent. So this flipped in the same commit that passed `product`
+  // through, and not before.
+  //
+  // Several words become several `product:` clauses; within one field this query language ORs them
+  // implicitly, which is the same "any of these words" the other two write with an explicit OR.
+  goodsTextSearch: true,
+  // A multi-word goods term: UNMEASURED on this vendor, so refused rather than guessed. A space that
+  // means AND on one register and OR on another changes the population either way and still answers
+  // 200, which is the failure that never announces itself.
+  // Unmeasured here, so a multi-word term is not sent at all. See clarivate/capabilities.js for the
+  // vocabulary; `null` is "we do not know what it would mean", which is not the same as "no".
+  goodsTextMultiWord: null,
+  // Several goods terms become several `product:` clauses, and within one field this query language
+  // ORs them implicitly — the same "any of these words" the explicit OR writes elsewhere.
+  goodsTextListOr: true,
   // ── WHICH FORM OF A NON-LATIN MARK DOES THE INDEX HOLD? ──────────────────────────────────────────
   // `true` = the CHARACTERS. A native-script term is a legitimate, productive query here and MUST be
   // sent — the shared executor's script-form refusal (providers/_shared/script-form.mjs) is switched

package/providers/corsearch/src/core.js

@@ -15,6 +15,7 @@
 import { makeLedger } from "../../_shared/ledger.mjs";
 import { nonAnswerBodyError, parseJsonBody, unparsedBodyError } from "../../_shared/http-body.mjs";
 import { normalizeTerritory } from "../../_shared/territory-codes.mjs";
+import { goodsTermsList } from "../../_shared/term-shape.mjs";   // the shared reader for the goods words
 import {
   BATCH_SCREEN_CHUNK, chunk, classifyStatus, isAllClass, normalizeBrandRow, screenVerdict,
 } from "../../_shared/screen.mjs";
@@ -133,6 +134,12 @@ export function assembleQuery(p) {
   if (p.owner)          parts.push(clause("", "owner", p.owner));
   if (Array.isArray(p.owners)) for (const o of p.owners) parts.push(clause("", "owner", o));   // OR-stack of owner names (same-field implicit OR — mirrors `names`)
   if (p.product)        parts.push(clause("", "product", p.product));
+  // The goods-and-services narrowing, in the vocabulary every provider shares. `product:` is this
+  // vendor's name for the same field the others call a goods description, and it was already built
+  // here — nothing passed it until now, which is why the capability declared false.
+  // Several words become several clauses: within one field the clauses implicitly OR, which is the
+  // same "any of these words" the other connectors write with an explicit OR.
+  for (const g of goodsTermsList(p)) parts.push(clause("", "product", g));
   if (p.representative) parts.push(clause("", "representative", p.representative));
 
   // Filters (each value must be backtick-quoted)

package/providers/oauth-mcp-bridge/CHANGELOG.md

@@ -1,5 +1,13 @@
 # trademark-oauth-mcp-bridge
 
+## 0.3.2-beta.15
+
+No changes in this release.
+
+## 0.3.2-beta.14
+
+No changes in this release.
+
 ## 0.3.2-beta.13
 
 No changes in this release.

package/providers/oauth-mcp-bridge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trademark-oauth-mcp-bridge",
-  "version": "0.3.2-beta.13",
+  "version": "0.3.2-beta.15",
   "license": "AGPL-3.0-only",
   "private": true,
   "description": "OAuth 2.1 MCP stdio bridge used by the engine's case-law gather stage (courtlistener / legaldatahunter).",