@cohortapp/agent-sdk 2.10.0 → 2.11.0

package/scripts/daemon/agent-daemon.test.mjs

@@ -523,3 +523,193 @@ test("OUTCOMES: the daemon hook never throws into the dispatch path", async () =
   assert.ok(res && typeof res.created === "number", "benign result, no throw");
   assert.equal(res.created, 0);
 });
+
+// ===========================================================================
+// ELECTION — the multi-AI storm fix. An UNDIRECTED message in a cohort channel
+// defers the should-I-respond decision to hq's electResponder; this seat
+// answers IFF elected, and a failed/empty election FAILS SAFE (stays silent).
+// A DIRECT address (@mention / DM) skips the election entirely. And a holding
+// ack is never posted when the reply session cannot run (claude unavailable).
+//
+// These drive the REAL answerItem() with the hq election call + the claude
+// liveness probe stubbed via deps — the same injection seam the DIAG tests use.
+// ===========================================================================
+
+// An org config that configFromAgent() reads: enabled, with this seat's own
+// member slug so the verdict can tell "elected me" from "elected someone else".
+const ELECTION_ORG_CFG = {
+  org: { cohort: { enabled: true, base: "https://hq.example", orgId: "org_x", agentId: "robin" } },
+};
+
+// A cohort CHANNEL item (not a DM): service+channel_id give cohortChannelId,
+// raw_ref's third segment gives cohortMessageId. Content is deliberately generic
+// so isDirectedAtAgent() is false and the election path is taken.
+function cohortChannelItem(overrides = {}) {
+  return {
+    id: overrides.id || "MSG-EL",
+    raw_ref: overrides.raw_ref || "cohort:message:msg-el:0",
+    service: "cohort",
+    channel: "channel/roadmap",
+    channel_id: overrides.channel_id || "chan-el",
+    is_dm: false,
+    sender: "alice",
+    content: overrides.content || "what should our Q3 priorities be?",
+  };
+}
+
+const ELECTED_CLASS = {
+  priority: "high", action: "respond", model: "opus",
+  summary: "roadmap discussion", category: "action_required", directed_at_agent: false,
+};
+
+test("ELECTION: the elected seat responds (dispatches) and the hq call carried {messageId, channelId}", async () => {
+  resetState();
+  delete process.env.COHORT_AGENT_ID; // let the cfg's agentId be the seat's slug
+  const cls = await import("./classifier.mjs");
+  cls._resetAgentRegistry();
+
+  const item = cohortChannelItem({ id: "MSG-EL-YES", raw_ref: "cohort:message:msg-yes:0", channel_id: "chan-yes" });
+  const electionCalls = [];
+  let dispatched = false;
+
+  const res = await daemon.answerItem(item, "cohort", item.raw_ref, "trace-el-yes", {
+    classify: async () => ({ ...ELECTED_CLASS, summary: "elected-yes topic" }),
+    isQuickReply: () => false,
+    sendHoldingMessage: async () => ({ sent: false, holdingText: null }),
+    dispatch: (_p, _it, _cr, _s, opts) => { dispatched = true; opts.onClose({ ok: true, code: 0 }); },
+    claudeAvailable: () => true,
+    orgCfg: ELECTION_ORG_CFG,
+    electResponder: async (params) => {
+      electionCalls.push(params);
+      return { ok: true, result: { election: "group", mode: "single", responders: [{ slug: "robin", dimension: "mandate" }], deferredToHuman: false } };
+    },
+  });
+
+  assert.equal(electionCalls.length, 1, "the election was consulted exactly once");
+  assert.deepEqual(electionCalls[0], { messageId: "msg-yes", channelId: "chan-yes" }, "hq got the message + channel identity");
+  assert.equal(dispatched, true, "the elected seat proceeds to dispatch a reply session");
+  assert.equal(res.path, "session", "answerItem took the session path");
+});
+
+test("ELECTION: a NON-elected seat stays silent on the same message (no dispatch)", async () => {
+  resetState();
+  delete process.env.COHORT_AGENT_ID;
+  const cls = await import("./classifier.mjs");
+  cls._resetAgentRegistry();
+
+  const item = cohortChannelItem({ id: "MSG-EL-NO", raw_ref: "cohort:message:msg-no:0", channel_id: "chan-no" });
+  const electionCalls = [];
+  let dispatched = false;
+  let acked = false;
+
+  const res = await daemon.answerItem(item, "cohort", item.raw_ref, "trace-el-no", {
+    classify: async () => ({ ...ELECTED_CLASS, summary: "not-elected topic" }),
+    isQuickReply: () => false,
+    sendHoldingMessage: async () => { acked = true; return { sent: true, holdingText: "on it" }; },
+    dispatch: (_p, _it, _cr, _s, opts) => { dispatched = true; opts.onClose({ ok: true, code: 0 }); },
+    claudeAvailable: () => true,
+    orgCfg: ELECTION_ORG_CFG,
+    // hq elected a DIFFERENT seat — this one is not in the responders list.
+    electResponder: async (params) => {
+      electionCalls.push(params);
+      return { ok: true, result: { election: "group", mode: "single", responders: [{ slug: "kai", dimension: "mandate" }], deferredToHuman: false } };
+    },
+  });
+
+  assert.equal(electionCalls.length, 1, "the election was consulted");
+  assert.equal(dispatched, false, "a non-elected seat must NOT dispatch");
+  assert.equal(acked, false, "a non-elected seat must NOT post a holding ack");
+  assert.equal(res.path, "filtered", "answerItem filtered the item");
+  assert.equal(res.reason, "not_elected", "…because it was not elected");
+});
+
+test("ELECTION: an election ERROR fails safe — the seat stays silent (never respond-to-all)", async () => {
+  resetState();
+  delete process.env.COHORT_AGENT_ID;
+  const cls = await import("./classifier.mjs");
+  cls._resetAgentRegistry();
+
+  const item = cohortChannelItem({ id: "MSG-EL-ERR", raw_ref: "cohort:message:msg-err:0", channel_id: "chan-err" });
+  let dispatched = false;
+
+  const res = await daemon.answerItem(item, "cohort", item.raw_ref, "trace-el-err", {
+    classify: async () => ({ ...ELECTED_CLASS, summary: "election-error topic" }),
+    isQuickReply: () => false,
+    sendHoldingMessage: async () => ({ sent: false, holdingText: null }),
+    dispatch: (_p, _it, _cr, _s, opts) => { dispatched = true; opts.onClose({ ok: true, code: 0 }); },
+    claudeAvailable: () => true,
+    orgCfg: ELECTION_ORG_CFG,
+    // hq is unreachable / throwing — the INVERSION: this must resolve to silence.
+    electResponder: async () => { throw new Error("hq unreachable"); },
+  });
+
+  assert.equal(dispatched, false, "an unreachable election must NOT fall back to responding");
+  assert.equal(res.path, "filtered", "answerItem filtered the item");
+  assert.equal(res.reason, "not_elected", "election failure ⇒ treated as not-elected (silent)");
+});
+
+test("ELECTION: an @mention/named-address responds WITHOUT calling electResponder (fast path)", async () => {
+  resetState();
+  delete process.env.COHORT_AGENT_ID;
+  // Give this seat a distinctive name and point isDirectedAtAgent at it.
+  mkdirSync(join(AGENT_DIR, "config"), { recursive: true });
+  writeFileSync(join(AGENT_DIR, "config", "agent.json"), JSON.stringify({ firstName: "Zephyr", slackMemberId: "" }));
+  const cls = await import("./classifier.mjs");
+  cls._resetAgentRegistry();
+
+  const item = cohortChannelItem({
+    id: "MSG-EL-MENTION", raw_ref: "cohort:message:msg-mention:0", channel_id: "chan-mention",
+    content: "hey zephyr, can you own the Q3 rollout?",
+  });
+  const electionCalls = [];
+  let dispatched = false;
+
+  const res = await daemon.answerItem(item, "cohort", item.raw_ref, "trace-el-mention", {
+    classify: async () => ({ ...ELECTED_CLASS, summary: "mention topic", directed_at_agent: true }),
+    isQuickReply: () => false,
+    sendHoldingMessage: async () => ({ sent: false, holdingText: null }),
+    dispatch: (_p, _it, _cr, _s, opts) => { dispatched = true; opts.onClose({ ok: true, code: 0 }); },
+    claudeAvailable: () => true,
+    orgCfg: ELECTION_ORG_CFG,
+    electResponder: async (params) => { electionCalls.push(params); return { ok: true, result: { responders: [] } }; },
+  });
+
+  assert.equal(electionCalls.length, 0, "a directly-addressed message does NOT hold an election");
+  assert.equal(dispatched, true, "the addressed seat answers on its local fast path");
+  assert.equal(res.path, "session", "answerItem took the session path");
+
+  // Tidy: drop the identity so later tests re-read a nameless seat.
+  rmSync(join(AGENT_DIR, "config", "agent.json"), { force: true });
+  cls._resetAgentRegistry();
+});
+
+test("FAIL-SAFE: no holding ack is posted when the reply session cannot run (claude unavailable)", async () => {
+  resetState();
+  // A slack DM — always directed, so this isolates the ack gate from the election.
+  // is_dm is normally set by enrichItem; answerItem is called directly here, so
+  // set it on the item as the poller/enrichment would.
+  // Distinct channel + subject per run so the request-claim from one run does not
+  // deny the other (the claim key is recipient + subject + action_type).
+  const mkItem = (tag) => ({ id: `MSG-ACK-${tag}`, raw_ref: `slack:DACK${tag}:1`, service: "slack", channel: "dm/ceo", channel_id: `DACK${tag}0001`, is_dm: true, sender: "ceo", content: "please draft the memo" });
+  const baseDeps = (spy, claudeUp, tag) => ({
+    classify: async () => ({ priority: "critical", action: "respond", model: "opus", summary: `draft memo ${tag}`, category: "action_required", directed_at_agent: true }),
+    isQuickReply: () => false,
+    sendHoldingMessage: async () => { spy.calls++; return { sent: true, holdingText: "on it" }; },
+    dispatch: (_p, _it, _cr, _s, opts) => { spy.dispatched = true; opts.onClose({ ok: true, code: 0 }); },
+    claudeAvailable: () => claudeUp,
+  });
+
+  // CONTROL: claude available ⇒ the ack path runs (holding message attempted).
+  const up = { calls: 0, dispatched: false };
+  await daemon.answerItem(mkItem("UP"), "slack", "slack:DACKUP:1", "trace-ack-up", baseDeps(up, true, "UP"));
+  assert.equal(up.calls, 1, "with claude available, a holding ack IS attempted");
+  assert.equal(up.dispatched, true, "control: the session is dispatched");
+
+  // TREATMENT: claude unavailable ⇒ NO ack is emitted, but the session still runs
+  // (the assurance sweep owns the outcome; the human just isn't promised a reply).
+  const down = { calls: 0, dispatched: false };
+  const res = await daemon.answerItem(mkItem("DN"), "slack", "slack:DACKDN:1", "trace-ack-down", baseDeps(down, false, "DN"));
+  assert.equal(down.calls, 0, "with claude unavailable, NO holding ack is posted before the working session");
+  assert.equal(down.dispatched, true, "the session is still dispatched");
+  assert.equal(res.path, "session", "answerItem took the session path");
+});

package/scripts/daemon/assurance.mjs

@@ -308,12 +308,25 @@ function variant(seed, n) {
   return h % n;
 }
 
-/** Trim the classifier's summary into a clause that reads naturally mid-sentence. */
+/**
+ * Trim the classifier's summary into a short topic phrase — casing preserved.
+ *
+ * This used to lowercase the first letter so the phrase could sit mid-sentence.
+ * Applied to a summary that starts with an acronym or a name, that manufactures
+ * a typo the requester reads as the agent's own: "Picking up: cEO checking in
+ * on work progress." went to a real human, first letter of "CEO" folded. No
+ * local rule can tell "Fix" (safe to downcase) from "CEO", "Q3" or a person's
+ * name (not safe), so the phrase is taken exactly as the classifier wrote it, and
+ * every slot that renders it — the parentheses here and in topicAside — is one
+ * where original casing reads correctly. The stored `rec.summary` flows into
+ * progress/failure/interrupted messages and the board-row title too, so the
+ * no-recasing rule protects all of them at once.
+ */
 function topicClause(classResult, item) {
   const raw = (classResult && classResult.summary) || (item && item.subject) || "";
   const t = String(raw).trim().replace(/\s+/g, " ").replace(/[.!?]+$/, "");
   if (!t || t.length > 120) return null;
-  return t.charAt(0).toLowerCase() + t.slice(1);
+  return t;
 }
 
 /** Rough, honest expectation. Derived from the measured distribution of real
@@ -327,23 +340,29 @@ export function expectedWindow(classResult) {
 }
 
 /**
- * The acknowledgement. Two or three sentences, warm, specific where it can be,
- * and — critically — it commits to coming back "either way". That clause is a
- * promise the rest of this module now actually keeps: failure notices, interim
- * updates and the stale sweep all exist so it is never a lie.
+ * The acknowledgement. Two sentences, written the way a colleague would type
+ * them, and — critically — it commits to coming back "either way". That clause
+ * is a promise the rest of this module now actually keeps: failure notices,
+ * interim updates and the stale sweep all exist so it is never a lie. The time
+ * window is expectedWindow's — measured, not invented.
+ *
+ * The topic rides in parentheses at the end of the opener, never spliced into
+ * the sentence: the summary is an arbitrary phrase in arbitrary case, and the
+ * previous template — `Picking up: <lowercased summary>. It needs a bit of
+ * work, …` — showed the daemon's internal framing to the requester and mangled
+ * acronym-initial summaries on top (see topicClause). "Picking up:" is triage
+ * vocabulary; a human answering a human does not narrate their queue.
  */
 export function composeAck(item, classResult = {}) {
   const topic = topicClause(classResult, item);
+  const aside = topic ? ` (${topic})` : "";
   const v = variant(obligationKey(item) || (item && item.sender), 3);
   const openers = [
-    "No problem — let me look into this and sort it out.",
-    "Got it — I'm on this now.",
-    "Understood — let me dig into this.",
+    `No problem — I'm looking into this now${aside}.`,
+    `Got it — I'm on it now${aside}.`,
+    `Understood — I'm digging into this now${aside}.`,
   ];
-  const parts = [openers[v]];
-  if (topic) parts.push(`Picking up: ${topic}.`);
-  parts.push(`It needs a bit of work, so I'll come back to you here with an answer — ${expectedWindow(classResult)}, and I'll message you either way.`);
-  return parts.join(" ");
+  return `${openers[v]} I want to get this right, so I'll come back to you here with a full answer — ${expectedWindow(classResult)} — and you'll hear from me either way.`;
 }
 
 /**
@@ -359,13 +378,17 @@ function topicAside(rec) {
   return rec && rec.summary ? ` (${rec.summary})` : "";
 }
 
-/** An interim update. Says how long it has been and that the work is live. */
+/** An interim update. Says how long it has been and that the work is live.
+ *  The first update no longer claims "it's taking longer than I expected": it
+ *  fires at PROGRESS_AFTER_MS (5 min), squarely inside the 10-20 minute window
+ *  the acknowledgement promised for opus work minutes earlier — a claim the
+ *  same human could see was false. */
 export function composeProgress(rec, o = {}) {
   const now = Number.isFinite(o.now) ? o.now : Date.now();
   const mins = Math.max(1, Math.round((now - (rec.openedAt || now)) / 60_000));
   const topic = topicAside(rec);
   if ((rec.progressSent || 0) === 0) {
-    return `Still working on this${topic} — ${mins} minutes in, and it's taking longer than I expected. Nothing's stuck; I'll come back as soon as I have something worth sending.`;
+    return `Still working on this${topic} — ${mins} minutes in. Nothing's stuck; I'll come back as soon as I have something worth sending.`;
   }
   return `Quick check-in: still on this${topic}, ${mins} minutes in. I haven't forgotten it — I'll follow up the moment it's done, or tell you if I can't finish it.`;
 }

package/scripts/daemon/assurance.test.mjs

@@ -147,6 +147,26 @@ describe("composeAck", () => {
     assert.ok(a.length > 40);
     assert.match(a, /either way/i);
   });
+
+  test("REGRESSION: an acronym-initial summary keeps its casing — no 'cEO'", () => {
+    // Owner screenshot, verbatim: "Picking up: cEO checking in on work
+    // progress." — topicClause downcased the first letter of whatever the
+    // classifier wrote so it could sit mid-sentence, and "CEO…" became a typo
+    // the requester reads as the agent's own. The summary is now carried
+    // exactly as written.
+    const a = composeAck(ITEM, { ...CLASS_COMPLEX, summary: "CEO checking in on work progress" });
+    assert.match(a, /CEO checking in on work progress/);
+    assert.doesNotMatch(a, /cEO/);
+  });
+
+  test("reads like a colleague, not a template — no internal framing shown to the human", () => {
+    // "Picking up:" is triage vocabulary and "It needs a bit of work" is the
+    // daemon explaining its own dispatch decision. Both leaked the machinery at
+    // the person being acknowledged.
+    const a = composeAck(ITEM, CLASS_COMPLEX);
+    assert.doesNotMatch(a, /picking up:/i);
+    assert.doesNotMatch(a, /needs a bit of work/i);
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -203,6 +223,21 @@ describe("openAndAcknowledge", () => {
     assert.equal(openObligations().length, 1, "the debt must be visible to the sweep");
   });
 
+  test("the stored summary keeps the classifier's casing — every later message reads from it", async () => {
+    // `rec.summary` feeds topicAside (progress, failure, silent-success,
+    // interrupted), the sweep's compensating ack, and board-mirror's row title.
+    // A summary mangled at open time would resurface in all of them.
+    const t = fakeTransport();
+    const r = await openAndAcknowledge({
+      item: ITEM,
+      classResult: { ...CLASS_COMPLEX, summary: "CEO checking in on work progress" },
+      deps: { ackSender: t.ackSender },
+    });
+    const rec = readObligation(r.key);
+    assert.equal(rec.summary, "CEO checking in on work progress");
+    assert.match(composeProgress(rec, { now: Date.now() + 6 * 60_000 }), /\(CEO checking in on work progress\)/);
+  });
+
   test("acknowledges ONCE — a re-delivered item does not re-announce itself", async () => {
     const t = fakeTransport();
     await openAndAcknowledge({ item: ITEM, classResult: CLASS_COMPLEX, deps: { ackSender: t.ackSender } });
@@ -362,6 +397,9 @@ describe("sweepObligations", () => {
     const msg = t.sent.at(-1).text;
     assert.match(msg, /still working/i);
     assert.match(msg, /minutes in/i, "an interim update that omits how long it has been is not much of an update");
+    // Six minutes in is INSIDE the 10-20 minute window the ack just promised
+    // for opus work; claiming it here contradicts a message the same human read.
+    assert.doesNotMatch(msg, /longer than I expected/i);
   });
 
   test("interim updates are CAPPED — attentive, not noisy", async () => {
@@ -604,7 +642,7 @@ describe("attribution: which debt did that message actually discharge", () => {
     const stats = await sweepObligations({ now: Date.now() + ACK_GRACE_MS + 1000, deps: { deliverImpl: t.impl } });
     assert.equal(stats.closed, 0, "no session of ours had run — that message was not our answer");
     assert.equal(stats.acked, 1, "instead the missing acknowledgement is finally sent");
-    assert.match(t.sent.at(-1).text, /let me look into this|I'm on this now|let me dig into this/i);
+    assert.match(t.sent.at(-1).text, /looking into this|on it now|digging into this/i);
   });
 });
 

package/scripts/daemon/classifier-identity.test.mjs

@@ -0,0 +1,137 @@
+/**
+ * classifier-identity.test.mjs — the classifier's frame of reference must be
+ * READ, not asserted.
+ *
+ * WHAT BROKE
+ *   `buildSystemPrompt()` opened with:
+ *     "You are a message classifier for ${agentName}, ${agentRole} (AI-operated)
+ *      at Northwind."
+ *   — a hardcoded employer sitting between two interpolated fields, on a file
+ *   that already loads config/agent.json two functions above. It matters more
+ *   than a naming slip: the classifier's `summary` is carried verbatim into
+ *   assurance.composeAck (text a waiting human reads) and board-mirror's board
+ *   row title, so a fabricated employer in the classifier's frame leaks into the
+ *   human ack and the org record.
+ *
+ * WHAT THESE TESTS PIN
+ *   1. GROUNDED — the employer comes from config/agent.json, and from
+ *      config/company.json when agent.json leaves `company` blank.
+ *   2. EMPTY — no employer configured ⇒ the "at <company>" clause is OMITTED
+ *      entirely. No sentinel, no default, no invented name.
+ *   3. No principal on record ⇒ no principal sentence at all.
+ *
+ * Run: node --test scripts/daemon/classifier-identity.test.mjs
+ */
+
+"use strict";
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { renderClassifierIdentityLine, buildSystemPrompt, _resetAgentRegistry } from "./classifier.mjs";
+
+function seat(agent, company) {
+  const root = mkdtempSync(join(tmpdir(), "clf-"));
+  mkdirSync(join(root, "config"), { recursive: true });
+  if (agent) writeFileSync(join(root, "config/agent.json"), JSON.stringify(agent));
+  if (company) writeFileSync(join(root, "config/company.json"), JSON.stringify(company));
+  return root;
+}
+
+// ── 1. GROUNDED ─────────────────────────────────────────────────────────────
+
+test("grounded: the employer is interpolated from config", () => {
+  const line = renderClassifierIdentityLine({
+    name: "Robin",
+    role: "VP Operations",
+    company: "Meridian Freight",
+    principal: { fullName: "Dana Lee", title: "CEO" },
+  });
+  assert.equal(
+    line,
+    "You are a message classifier for Robin, VP Operations (AI-operated) at Meridian Freight. " +
+      "Robin is the autonomous executive command layer for CEO Dana Lee.",
+  );
+});
+
+test("grounded: config/company.json supplies the employer when agent.json leaves it blank", () => {
+  const root = seat(
+    { firstName: "Robin", fullName: "Robin Okafor", title: "VP Operations", company: "" },
+    { name: "Meridian Freight" },
+  );
+  const prev = process.env.AGENT_DIR;
+  process.env.AGENT_DIR = root;
+  _resetAgentRegistry();
+  try {
+    // The whole system prompt, built by the real loader against real files.
+    const prompt = buildSystemPrompt();
+    assert.match(prompt, /^You are a message classifier for Robin, VP Operations \(AI-operated\) at Meridian Freight\./);
+  } finally {
+    if (prev === undefined) delete process.env.AGENT_DIR; else process.env.AGENT_DIR = prev;
+    _resetAgentRegistry();
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+// ── 2. EMPTY — omit, never fake ─────────────────────────────────────────────
+
+test("empty: an unconfigured seat's system prompt names NO employer", () => {
+  const root = seat(
+    { firstName: "UNCONFIGURED", lastName: "AGENT", fullName: "Unconfigured Agent", title: "Unconfigured Role", company: "" },
+    { name: "UNCONFIGURED" },
+  );
+  const prev = process.env.AGENT_DIR;
+  process.env.AGENT_DIR = root;
+  _resetAgentRegistry();
+  try {
+    const prompt = buildSystemPrompt();
+    assert.doesNotMatch(prompt.split("\n")[0], / at /, "no employer clause at all");
+    assert.doesNotMatch(prompt, /UNCONFIGURED/);
+  } finally {
+    if (prev === undefined) delete process.env.AGENT_DIR; else process.env.AGENT_DIR = prev;
+    _resetAgentRegistry();
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("empty: no employer configured ⇒ the 'at <company>' clause is dropped", () => {
+  const line = renderClassifierIdentityLine({ name: "Robin", role: "VP Operations", company: "" });
+  assert.equal(line, "You are a message classifier for Robin, VP Operations (AI-operated).");
+  assert.doesNotMatch(line, / at /);
+});
+
+test("empty: the scaffold's UNCONFIGURED sentinel counts as absent", () => {
+  const line = renderClassifierIdentityLine({ name: "Robin", role: "VP Operations", company: "UNCONFIGURED" });
+  assert.doesNotMatch(line, /UNCONFIGURED/);
+  assert.doesNotMatch(line, / at /);
+});
+
+test("empty: no principal on record ⇒ no principal sentence", () => {
+  const withNone = renderClassifierIdentityLine({ name: "Robin", role: "VP", principal: {} });
+  assert.doesNotMatch(withNone, /command layer/);
+
+  // The loader's "the principal" string is an ABSENCE marker, not a person.
+  const withPlaceholder = renderClassifierIdentityLine({
+    name: "Robin",
+    role: "VP",
+    principal: { firstName: "the principal", fullName: "the principal", title: "principal" },
+  });
+  assert.doesNotMatch(withPlaceholder, /command layer/);
+});
+
+test("empty: nothing at all still yields a coherent, non-fabricated line", () => {
+  const line = renderClassifierIdentityLine({});
+  assert.equal(line, "You are a message classifier for the agent, agent (AI-operated).");
+});
+
+// ── 3. The literal is gone from the source ──────────────────────────────────
+
+test("the classifier source carries no hardcoded employer", async () => {
+  const { readFileSync } = await import("node:fs");
+  const src = readFileSync(new URL("./classifier.mjs", import.meta.url), "utf8");
+  assert.doesNotMatch(src, /\bNorthwind\b/i);
+  assert.doesNotMatch(src, /\bPartnerCo\b/i);
+});