fix: the scorer never knew the company sizes or the industries the customer chose

The wizard asks for headcount bands and sectors, stores both on the agent row, and until now only
the yes/no fit judge in messages/generate.ts ever read them. scoreLead, which produces the number
and the sentence a customer reads on their queue and which decides who is worth an invitation, was
told the ICP, the countries and what the customer sells, and nothing about the two other fields
they filled in. So an agent set to "11-50, marketing agencies" scored its leads with a model that
had never been given either, and two of the four things the wizard collects were decorative.

Both arrive as evidence rather than as a filter, and the wording is the whole of it. A headcount is
printed on a company page and almost never on a person's profile, so a band list dropped in with no
instruction reads as a filter and scores a good prospect at zero for a fact LinkedIn never showed
us. The scorer is told to read the size off what the person and their company say about themselves,
and to leave the score alone and say so when nothing does. The industry line carries the warning the
fit judge already carries next door: it is the sector their company works in, not the words in their
job title.

targetingLines is pure and exported so the wording is testable without a model call.

Also fixes two tests left red by ef1f12e: "Greater Paris Metropolitan Region" now resolves to
France, so it is no longer an example of an unreadable place. Greater Cambridge Area takes its
place, being one of the labels the table refuses to resolve on purpose, and the readable half of
that change gets the test it did not have.

Author: DigiHold

worker/src/ai.ts

@@ -353,6 +353,47 @@ export async function classifyReply(
   return { handOver: verdict, why: why || answer.trim().slice(0, 120), intent };
 }
 
+/**
+ * The customer's own targeting, written for a model rather than for a form.
+ *
+ * Pure and exported so the wording is testable without a model call, because
+ * the wording is the whole of it: a band list dropped into a prompt with no
+ * instruction is read as a filter, and a scorer that treats an unprintable fact
+ * as a filter scores good prospects at zero.
+ *
+ * "11-50" is a range LinkedIn prints on a company page and almost never on a
+ * person's profile, so the scorer is told to read it off what the person and
+ * their company say about themselves, and to leave the score alone when nothing
+ * says either way.
+ */
+export function targetingLines(companySizes: string[], industries: string[]): string[] {
+  const lines: string[] = [];
+  const bands = companySizes.filter((b) => b.trim());
+  const trades = industries.filter((t) => t.trim());
+
+  if (bands.length) {
+    lines.push(
+      `Company sizes the customer sells to, by headcount: ${bands.join(", ")}. ` +
+        "Judge it from what the person and their company say about themselves, an agency of a few people, a team, a department, a group. " +
+        "A company clearly bigger or smaller than every band listed is a weak match however good the title reads. " +
+        "When nothing here says how big the company is, that is neither evidence for nor against them, so score the rest and say the size is unknown."
+    );
+  }
+
+  if (trades.length) {
+    // The industry is the sector the prospect's company works in. Matching it
+    // against a job title is how a supermarket planning assistant reached a
+    // queue meant for website owners, and the fit judge next door carries the
+    // same warning for the same reason.
+    lines.push(
+      `Industries the customer sells to: ${trades.join(", ")}. ` +
+        "That is the sector their own company works in, not the words in their job title."
+    );
+  }
+
+  return lines;
+}
+
 /** Full scoring, still on the fast model. The writer here is the biggest cost mistake available. */
 export async function scoreLead(
   ctx: AgentContext,
@@ -442,6 +483,26 @@ export async function scoreLead(
     ? `The customer only sells to people in: ${places.map((c) => countryName(c)).join(", ")}. Anybody outside those scores 0, whatever their title reads.`
     : "";
 
+  /**
+   * The headcount bands and the sectors, which this prompt never carried.
+   *
+   * The wizard asks for both, stores both on the agent row, and until now only
+   * the yes/no fit judge in messages/generate.ts ever read them. So a customer
+   * who said "11-50, marketing agencies" got a queue scored by a model that had
+   * been told neither, and the number and the sentence they read on the
+   * dashboard came from a judgement their own targeting never entered. Two of
+   * the four things the wizard collects were decorative.
+   *
+   * Both are written as evidence to weigh rather than as a filter. The size of
+   * a company is rarely printed on a person's profile and inferring it from a
+   * headline is a guess; saying so keeps a good prospect from being scored down
+   * for a fact LinkedIn never showed us, which is the failure mode a hard rule
+   * here would create.
+   */
+  const bands = ctx.companySizes ?? [];
+  const trades = ctx.cfg.leads.industries ?? [];
+  const wantedShape = targetingLines(bands, trades).join("\n");
+
   const m = await models();
   const answer = await generate(
     ctx,
@@ -454,6 +515,7 @@ Headline: ${profile.headline}
 Company: ${profile.company ?? "unknown"}
 ${profile.location ? `Where LinkedIn says they are: ${profile.location}` : ""}
 ${wantedPlaces}
+${wantedShape}
 ${profile.signal ? `How they were found: ${profile.signal}` : ""}${repeats}
 ${profile.about ? `About: ${profile.about.slice(0, 600)}` : ""}
 

worker/src/linkedin/sources.test.ts

@@ -298,7 +298,23 @@ test("a card with no place on it is unknown, not allowed", () => {
   assert.equal(placeOf(FRANCE, null), "unknown");
   assert.equal(placeOf(FRANCE, ""), "unknown");
   assert.equal(placeOf(FRANCE, "   "), "unknown");
-  assert.equal(placeOf(FRANCE, "Greater Paris Metropolitan Region"), "unknown");
+  // A metro label built on a city that exists in two countries stays unread on
+  // purpose, which is the rule the whole table runs on: there is a Cambridge in
+  // England and one in Massachusetts, and LinkedIn prints both this way.
+  assert.equal(placeOf(FRANCE, "Greater Cambridge Area"), "unknown");
+});
+
+/**
+ * The metro labels, which used to be unreadable and are now read from the city.
+ *
+ * LinkedIn labels most of the United States, and Paris, Zurich and Mumbai with
+ * it, as a metro area with no country after it. Answering unknown for those
+ * sent an agent aimed at the United States to a profile visit for most of its
+ * own market and then closed the lead.
+ */
+test("a metro label with no country after it is read from its city", () => {
+  assert.equal(placeOf(FRANCE, "Greater Paris Metropolitan Region"), "in");
+  assert.equal(placeOf(FRANCE, "Greater Boston Area"), "out");
 });
 
 test("the country is read whatever language LinkedIn printed it in", () => {

worker/src/safety/geo-fence.test.ts

@@ -194,21 +194,45 @@ test("the profile settling on the wrong country stops everything", async () => {
 /**
  * A country that still cannot be read is a refusal, not a shrug.
  *
- * "Greater Paris Metropolitan Region" names no country and neither does a blank
- * profile. Guessing at one is the whole shape of the bug, so a customer who
- * named their countries gets the strict reading and the row says why.
+ * "Greater Cambridge Area" names no country and neither does a blank profile.
+ * Guessing at one is the whole shape of the bug, so a customer who named their
+ * countries gets the strict reading and the row says why. The city is the
+ * example on purpose: there is a Cambridge in England and one in Massachusetts,
+ * so it is one of the few metro labels the table refuses to resolve.
  */
 test("a place the profile does not give either is refused and said so", async () => {
   await freshDb();
   const lead = await seed("Unreadable", null);
   const { actions, done } = spyActions();
-  const fenced = onlyInCountries(actions, ctxWith(AMERICAS), page, async () => "Greater Paris Metropolitan Region");
+  const fenced = onlyInCountries(actions, ctxWith(AMERICAS), page, async () => "Greater Cambridge Area");
 
   assert.equal(await fenced.sendConnect(lead, ""), "failed");
   assert.deepEqual(done, []);
   assert.equal((await rowOf("Unreadable")).excluded_reason, UNREADABLE_REASON);
 });
 
+/**
+ * A metro label the table does resolve is decided on, not sent to a visit.
+ *
+ * This is the half of the same change that matters to the customer: an agent
+ * aimed at the Americas keeps a lead labelled "Greater Boston Area" instead of
+ * spending a profile read to find out what the string already said.
+ */
+test("a metro label naming a city we know is decided without a second look", async () => {
+  await freshDb();
+  const lead = await seed("Bostonian", "Greater Boston Area");
+  const { actions, done } = spyActions();
+  let visits = 0;
+  const fenced = onlyInCountries(actions, ctxWith(AMERICAS), page, async () => {
+    visits += 1;
+    return null;
+  });
+
+  assert.equal(await fenced.sendConnect(lead, ""), "sent");
+  assert.deepEqual(done, ["invite:Bostonian"]);
+  assert.equal(visits, 0);
+});
+
 test("a profile that will not load is refused rather than allowed", async () => {
   await freshDb();
   const lead = await seed("Would Not Load", null);

worker/src/score.test.ts

@@ -1,6 +1,6 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { cleanReason, parseScore } from "./ai.ts";
+import { cleanReason, parseScore, targetingLines } from "./ai.ts";
 
 /**
  * The shapes the scorer actually answered in.
@@ -101,3 +101,37 @@ test("the parser and the guard agree on a real answer", () => {
   assert.equal(parsed.score, 78);
   assert.equal(parsed.reason, "Co-founder with product architecture background.");
 });
+
+/**
+ * The targeting the wizard collects and the scorer used to ignore.
+ *
+ * Both fields were stored on the agent row from the first release and read only
+ * by the yes/no fit judge, so the number and the sentence a customer reads on
+ * the dashboard were produced by a model that had never been told the headcount
+ * bands or the sectors they asked for.
+ */
+
+test("the headcount bands reach the prompt, worded as evidence rather than as a filter", () => {
+  const [sizes] = targetingLines(["1-10", "11-50"], []);
+  assert.ok(sizes?.includes("1-10, 11-50"));
+  assert.ok(/neither evidence for nor against/i.test(sizes ?? ""));
+});
+
+test("the industries reach the prompt, and say they are a sector and not a job title", () => {
+  const lines = targetingLines([], ["Marketing agencies", "Ecommerce"]);
+  assert.equal(lines.length, 1);
+  assert.ok(lines[0]?.includes("Marketing agencies, Ecommerce"));
+  assert.ok(/not the words in their job title/i.test(lines[0] ?? ""));
+});
+
+test("an agent that named neither adds nothing to the prompt", () => {
+  assert.deepEqual(targetingLines([], []), []);
+  assert.deepEqual(targetingLines(["", "  "], [""]), []);
+});
+
+test("both named produce both lines, in the order the prompt reads them", () => {
+  const lines = targetingLines(["11-50"], ["SaaS"]);
+  assert.equal(lines.length, 2);
+  assert.ok(lines[0]?.startsWith("Company sizes"));
+  assert.ok(lines[1]?.startsWith("Industries"));
+});