@cohortapp/agent-sdk 2.17.0 → 2.18.4

package/scripts/hooks/pre-send-audit.test.mjs

@@ -1,354 +0,0 @@
-// node:test for scripts/hooks/pre-send-audit.sh (audit M1)
-//
-// The hook is a Claude Code PreToolUse gate that must SCREEN outbound
-// content and FAIL CLOSED (exit 2) on any banned phrase, allowlist miss,
-// rate-cap breach, or parse/IO error. These tests execFile the real shell
-// script with crafted stdin JSON and assert the exit code.
-//
-// jq is required by the hook; if it is not on PATH we skip rather than
-// report a false failure (but jq is available in CI/dev here).
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { execFile, execFileSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const HOOK = join(__dirname, "pre-send-audit.sh");
-
-function jqAvailable() {
-  try {
-    execFileSync("jq", ["--version"], { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-const JQ = jqAvailable();
-
-// Run the hook with the given stdin, returning { code, stdout, stderr }.
-// Each call gets its own runtime dir so the rate counters never leak
-// between cases. The shell env is reset to a known baseline so a stray
-// MAESTRO_SEND_* in the test runner's environment cannot skew caps.
-function runHook(stdin, { channel = "slack", env = {} } = {}) {
-  const runtimeDir = mkdtempSync(join(tmpdir(), "presend-"));
-  return new Promise((resolve) => {
-    const child = execFile(
-      "bash",
-      [HOOK, channel],
-      {
-        env: {
-          PATH: process.env.PATH,
-          HOME: runtimeDir,
-          MAESTRO_RUNTIME_DIR: runtimeDir,
-          ...env,
-        },
-      },
-      (err, stdout, stderr) => {
-        const code = err && typeof err.code === "number" ? err.code : 0;
-        rmSync(runtimeDir, { recursive: true, force: true });
-        resolve({ code, stdout, stderr });
-      },
-    );
-    child.stdin.end(stdin);
-  });
-}
-
-test("clean message passes (exit 0)", { skip: JQ ? false : "jq not on PATH" }, async () => {
-  const payload = JSON.stringify({
-    tool_name: "send",
-    tool_input: { text: "In progress — only blocker is DBA approval, expected EOD.", to: "C123" },
-  });
-  const { code, stdout } = await runHook(payload);
-  assert.equal(code, 0, `expected exit 0, got ${code}`);
-  assert.match(stdout, /screened and logged/);
-});
-
-test("banned phrase 'Let me know if you need anything else' blocks (exit 2)", { skip: JQ ? false : "jq not on PATH" }, async () => {
-  const payload = JSON.stringify({ tool_input: { text: "Done. Let me know if you need anything else!" } });
-  const { code, stderr } = await runHook(payload);
-  assert.equal(code, 2, `expected exit 2, got ${code}`);
-  assert.match(stderr, /BLOCKED/);
-});
-
-test("banned phrase 'As an AI' blocks (exit 2)", { skip: JQ ? false : "jq not on PATH" }, async () => {
-  const payload = JSON.stringify({ tool_input: { body: "As an AI, I cannot make that commitment." } });
-  const { code } = await runHook(payload, { channel: "gmail" });
-  assert.equal(code, 2, `expected exit 2, got ${code}`);
-});
-
-test("banned phrase \"I'd be happy to\" blocks (exit 2)", { skip: JQ ? false : "jq not on PATH" }, async () => {
-  const payload = JSON.stringify({ tool_input: { message: "I'd be happy to set that up for you." } });
-  const { code } = await runHook(payload);
-  assert.equal(code, 2, `expected exit 2, got ${code}`);
-});
-
-test("filler opener 'Absolutely!' blocks (exit 2)", { skip: JQ ? false : "jq not on PATH" }, async () => {
-  const payload = JSON.stringify({ tool_input: { text: "Absolutely! I can pull that together." } });
-  const { code } = await runHook(payload);
-  assert.equal(code, 2, `expected exit 2, got ${code}`);
-});
-
-test("mid-sentence 'absolutely' (no opener) passes (exit 0)", { skip: JQ ? false : "jq not on PATH" }, async () => {
-  const payload = JSON.stringify({ tool_input: { text: "I am absolutely certain the deploy is fine." } });
-  const { code } = await runHook(payload);
-  assert.equal(code, 0, `expected exit 0, got ${code}`);
-});
-
-test("banned phrase inside Slack blocks array blocks (exit 2)", { skip: JQ ? false : "jq not on PATH" }, async () => {
-  const payload = JSON.stringify({
-    tool_input: { blocks: [{ type: "section", text: { type: "mrkdwn", text: "As an AI I will help with that." } }] },
-  });
-  const { code } = await runHook(payload);
-  assert.equal(code, 2, `expected exit 2, got ${code}`);
-});
-
-test("malformed JSON fails closed (exit 2)", { skip: JQ ? false : "jq not on PATH" }, async () => {
-  const { code, stderr } = await runHook("not json {{{");
-  assert.equal(code, 2, `expected exit 2, got ${code}`);
-  assert.match(stderr, /Malformed|fail closed/i);
-});
-
-test("empty stdin fails closed (exit 2)", { skip: JQ ? false : "jq not on PATH" }, async () => {
-  const { code } = await runHook("");
-  assert.equal(code, 2, `expected exit 2, got ${code}`);
-});
-
-test("missing channel arg fails closed (exit 2)", { skip: JQ ? false : "jq not on PATH" }, async () => {
-  // Invoke with no channel argument.
-  const runtimeDir = mkdtempSync(join(tmpdir(), "presend-"));
-  const code = await new Promise((resolve) => {
-    const child = execFile(
-      "bash",
-      [HOOK],
-      { env: { PATH: process.env.PATH, HOME: runtimeDir, MAESTRO_RUNTIME_DIR: runtimeDir } },
-      (err) => {
-        rmSync(runtimeDir, { recursive: true, force: true });
-        resolve(err && typeof err.code === "number" ? err.code : 0);
-      },
-    );
-    child.stdin.end(JSON.stringify({ tool_input: { text: "hi" } }));
-  });
-  assert.equal(code, 2, `expected exit 2, got ${code}`);
-});
-
-test("recipient on allowlist passes (exit 0)", { skip: JQ ? false : "jq not on PATH" }, async () => {
-  const dir = mkdtempSync(join(tmpdir(), "presend-allow-"));
-  const allow = join(dir, "allow.txt");
-  writeFileSync(allow, "C123\ngood@example.com\n# a comment\n");
-  const payload = JSON.stringify({ tool_input: { text: "hello", to: "C123" } });
-  const { code } = await runHook(payload, { env: { MAESTRO_SEND_ALLOWLIST: allow } });
-  rmSync(dir, { recursive: true, force: true });
-  assert.equal(code, 0, `expected exit 0, got ${code}`);
-});
-
-test("recipient NOT on allowlist fails closed (exit 2)", { skip: JQ ? false : "jq not on PATH" }, async () => {
-  const dir = mkdtempSync(join(tmpdir(), "presend-allow-"));
-  const allow = join(dir, "allow.txt");
-  writeFileSync(allow, "C123\ngood@example.com\n");
-  const payload = JSON.stringify({ tool_input: { text: "hello", to: "C999" } });
-  const { code, stderr } = await runHook(payload, { env: { MAESTRO_SEND_ALLOWLIST: allow } });
-  rmSync(dir, { recursive: true, force: true });
-  assert.equal(code, 2, `expected exit 2, got ${code}`);
-  assert.match(stderr, /allowlist/i);
-});
-
-test("hourly cap blocks once exceeded (exit 2)", { skip: JQ ? false : "jq not on PATH" }, async () => {
-  // Share one runtime dir across three sends with PER_HOUR=2.
-  const runtimeDir = mkdtempSync(join(tmpdir(), "presend-hour-"));
-  const payload = JSON.stringify({ tool_input: { text: "hi" } });
-  const send = () =>
-    new Promise((resolve) => {
-      const child = execFile(
-        "bash",
-        [HOOK, "slack"],
-        {
-          env: {
-            PATH: process.env.PATH,
-            HOME: runtimeDir,
-            MAESTRO_RUNTIME_DIR: runtimeDir,
-            MAESTRO_SEND_PER_HOUR: "2",
-          },
-        },
-        (err) => resolve(err && typeof err.code === "number" ? err.code : 0),
-      );
-      child.stdin.end(payload);
-    });
-  const c1 = await send();
-  const c2 = await send();
-  const c3 = await send();
-  rmSync(runtimeDir, { recursive: true, force: true });
-  assert.equal(c1, 0, `send 1 expected 0, got ${c1}`);
-  assert.equal(c2, 0, `send 2 expected 0, got ${c2}`);
-  assert.equal(c3, 2, `send 3 expected 2 (hourly cap), got ${c3}`);
-});
-
-test("daily cap blocks once exceeded (exit 2)", { skip: JQ ? false : "jq not on PATH" }, async () => {
-  const runtimeDir = mkdtempSync(join(tmpdir(), "presend-day-"));
-  const payload = JSON.stringify({ tool_input: { text: "hi" } });
-  const send = () =>
-    new Promise((resolve) => {
-      const child = execFile(
-        "bash",
-        [HOOK, "slack"],
-        {
-          env: {
-            PATH: process.env.PATH,
-            HOME: runtimeDir,
-            MAESTRO_RUNTIME_DIR: runtimeDir,
-            MAESTRO_SEND_PER_DAY: "1",
-          },
-        },
-        (err, stdout, stderr) => resolve({ code: err && typeof err.code === "number" ? err.code : 0, stderr }),
-      );
-      child.stdin.end(payload);
-    });
-  const r1 = await send();
-  const r2 = await send();
-  rmSync(runtimeDir, { recursive: true, force: true });
-  assert.equal(r1.code, 0, `send 1 expected 0, got ${r1.code}`);
-  assert.equal(r2.code, 2, `send 2 expected 2 (daily cap), got ${r2.code}`);
-  assert.match(r2.stderr, /Daily send limit/);
-});
-
-// ── WP-M4: persona-leak patterns (front-door session §3.6) ─────────────────
-//
-// Outbound text may never expose the machinery: "Claude Code", "Claude
-// session", "sub-session", a subagent that "said/reported", "workflow agent",
-// "as an AI" / "language model", or an internal session name (<first>-main,
-// <first>-<purpose>). The hook returns the offending phrase so the session can
-// rewrite in its own voice.
-
-const PERSONA_ENV = { MAESTRO_AGENT_FIRST: "alex" };
-
-for (const [label, text] of [
-  ["Claude Code", "I'll have Claude Code pick that up this afternoon."],
-  ["Claude session", "A separate claude session is running the numbers."],
-  ["sub-session", "I kicked off a sub-session for the deck."],
-  ["subagent said", "The subagent said the deploy finished."],
-  ["sub-agent reported", "My sub-agent reported two blockers."],
-  ["subagent session", "The subagent session is still going."],
-  ["workflow agent", "The workflow agent will file the summary."],
-  ["language model", "Every language model has limits, mine included."],
-  ["<first>-main", "Check with alex-main for the latest."],
-]) {
-  test(`persona leak "${label}" blocks (exit 2) and names the phrase`, { skip: JQ ? false : "jq not on PATH" }, async () => {
-    const payload = JSON.stringify({ tool_name: "mcp__cohort__messaging_send", tool_input: { channelId: "C1", body: text } });
-    const { code, stderr } = await runHook(payload, { channel: "cohort", env: PERSONA_ENV });
-    assert.equal(code, 2, `expected exit 2 for "${label}", got ${code}`);
-    assert.match(stderr, /BLOCKED/);
-    assert.match(stderr, /persona/i);
-  });
-}
-
-test("persona: the leak line names the offending phrase so the session can rewrite", { skip: JQ ? false : "jq not on PATH" }, async () => {
-  const payload = JSON.stringify({ tool_input: { channelId: "C1", body: "I'll have Claude Code pick that up." } });
-  const { stderr } = await runHook(payload, { channel: "cohort", env: PERSONA_ENV });
-  assert.match(stderr, /claude code/i);
-});
-
-test("persona: colleague phrasing passes; bare 'subagent' without said/reported/session passes; mid-word matches ignored", { skip: JQ ? false : "jq not on PATH" }, async () => {
-  for (const text of [
-    "One of my analysts is on it; I'll have the numbers by 3.",
-    "My team has the deck in review — sending the draft after lunch.",
-    "We use subagents internally for the heavy lifting.",
-    "Alexandra-Maine sent the invoice.",
-    "The session on Thursday (the board session) starts at 9.",
-  ]) {
-    const payload = JSON.stringify({ tool_input: { channelId: "C1", body: text } });
-    const { code, stderr } = await runHook(payload, { channel: "cohort", env: PERSONA_ENV });
-    assert.equal(code, 0, `expected exit 0 for "${text}", got ${code}: ${stderr}`);
-  }
-});
-
-test("persona: session-name pattern reads the first name from AGENT_ROOT/config/agent.json when the env is unset", { skip: JQ ? false : "jq not on PATH" }, async () => {
-  const dir = mkdtempSync(join(tmpdir(), "presend-agent-"));
-  try {
-    const cfg = join(dir, "config");
-    mkdirSyncP(cfg);
-    writeFileSync(join(cfg, "agent.json"), JSON.stringify({ firstName: "Robin", fullName: "Robin Park" }));
-    const payload = JSON.stringify({ tool_input: { channelId: "C1", body: "robin-main will chase it." } });
-    const { code, stderr } = await runHook(payload, { channel: "cohort", env: { AGENT_ROOT: dir } });
-    assert.equal(code, 2, `expected exit 2, got ${code}: ${stderr}`);
-    assert.match(stderr, /robin-main/);
-    // No first name resolvable anywhere → the name pattern is skipped (fail-open on that one check), the rest still applies.
-    const { code: c2 } = await runHook(payload, { channel: "cohort", env: {} });
-    assert.equal(c2, 0);
-  } finally { rmSync(dir, { recursive: true, force: true }); }
-});
-
-// ── Review fix: session names are BOUNDED (spec §3.6 gap) ──────────────────
-// `<first>-main` is always internal; any other `<first>-<x>` is internal only
-// when it is a registered peer (state/session/peers.json under AGENT_ROOT) or
-// listed in MAESTRO_SESSION_NAMES. A colleague's hyphenated name, a URL slug or
-// an email local part that happens to start with the first name must pass.
-
-test("persona: an unregistered <first>-<x> is ordinary text; a registered peer name (peers.json) or MAESTRO_SESSION_NAMES entry blocks", { skip: JQ ? false : "jq not on PATH" }, async () => {
-  const dir = mkdtempSync(join(tmpdir(), "presend-peers-"));
-  try {
-    const payload = JSON.stringify({ tool_input: { channelId: "C1", body: "alex-research has the draft ready." } });
-    const { code: c0, stderr: e0 } = await runHook(payload, { channel: "cohort", env: PERSONA_ENV });
-    assert.equal(c0, 0, `unregistered alex-research must pass: ${e0}`);
-
-    mkdirSyncP(join(dir, "state", "session"));
-    writeFileSync(join(dir, "state", "session", "peers.json"), JSON.stringify([{ name: "alex-research", muxName: "maestro-alex-research", purpose: "research" }]));
-    const { code: c1, stderr: e1 } = await runHook(payload, { channel: "cohort", env: { ...PERSONA_ENV, AGENT_ROOT: dir } });
-    assert.equal(c1, 2, `registered peer must block, got ${c1}: ${e1}`);
-    assert.match(e1, /alex-research/);
-
-    // {peers:[…]} shape is accepted too.
-    writeFileSync(join(dir, "state", "session", "peers.json"), JSON.stringify({ peers: [{ name: "alex-deck" }] }));
-    const deck = JSON.stringify({ tool_input: { channelId: "C1", body: "alex-deck is nearly done." } });
-    assert.equal((await runHook(deck, { channel: "cohort", env: { ...PERSONA_ENV, AGENT_ROOT: dir } })).code, 2);
-    assert.equal((await runHook(payload, { channel: "cohort", env: { ...PERSONA_ENV, AGENT_ROOT: dir } })).code, 0, "alex-research is no longer registered");
-
-    // A corrupt registry is an empty one — never a fail-closed on the whole send.
-    writeFileSync(join(dir, "state", "session", "peers.json"), "{nope");
-    assert.equal((await runHook(deck, { channel: "cohort", env: { ...PERSONA_ENV, AGENT_ROOT: dir } })).code, 0);
-
-    // Env override (comma-separated), no files needed.
-    const { code: c2, stderr: e2 } = await runHook(payload, { channel: "cohort", env: { ...PERSONA_ENV, MAESTRO_SESSION_NAMES: "alex-research, alex-ops" } });
-    assert.equal(c2, 2, `MAESTRO_SESSION_NAMES must block, got ${c2}: ${e2}`);
-  } finally { rmSync(dir, { recursive: true, force: true }); }
-});
-
-test("persona: a colleague's hyphenated name, a URL slug and an email local part starting with the first name all pass", { skip: JQ ? false : "jq not on PATH" }, async () => {
-  for (const [first, text] of [
-    ["marc", "Marc-Antoine confirmed the numbers."],
-    ["james", "See https://os.cohortapp.com/spaces/james-kirkland for the thread."],
-    ["ethan", "Loop in ethan-miller@example.com on the invoice."],
-    ["alex", "alex-mainland is the venue; alex-main-street too."],
-  ]) {
-    const payload = JSON.stringify({ tool_input: { channelId: "C1", body: text } });
-    const { code, stderr } = await runHook(payload, { channel: "cohort", env: { MAESTRO_AGENT_FIRST: first } });
-    assert.equal(code, 0, `expected exit 0 for "${text}" (first=${first}), got ${code}: ${stderr}`);
-  }
-  // …while the real session name still blocks, whatever the case.
-  const { code } = await runHook(JSON.stringify({ tool_input: { channelId: "C1", body: "Ask ALEX-MAIN." } }), { channel: "cohort", env: PERSONA_ENV });
-  assert.equal(code, 2);
-});
-
-// ── Review fix: the hook now fronts every mcp__cohort outbound tool ──────────
-// org_rpc carries the body under tool_input.params; email_send under text (+
-// subject); email_draft_send under bodyText (+ subject). All must be screened.
-
-test("persona: org_rpc (params.body), email_send (subject+text) and email_draft_send (bodyText) payload shapes are screened", { skip: JQ ? false : "jq not on PATH" }, async () => {
-  const cases = [
-    ["org_rpc", { tool_name: "mcp__cohort__org_rpc", tool_input: { method: "messaging.send", params: { channelId: "C1", body: "My sub-session is on it." } } }],
-    ["email_send text", { tool_name: "mcp__cohort__email_send", tool_input: { to: ["a@b.com"], subject: "Update", text: "Claude Code finished the deploy." } }],
-    ["email_send subject", { tool_name: "mcp__cohort__email_send", tool_input: { to: ["a@b.com"], subject: "From alex-main", text: "Deploy finished." } }],
-    ["email_draft_send bodyText", { tool_name: "mcp__cohort__email_draft_send", tool_input: { to: ["a@b.com"], subject: "Update", bodyText: "The workflow agent will send the summary." } }],
-  ];
-  for (const [label, payload] of cases) {
-    const { code, stderr } = await runHook(JSON.stringify(payload), { channel: "cohort", env: PERSONA_ENV });
-    assert.equal(code, 2, `expected exit 2 for ${label}, got ${code}: ${stderr}`);
-    assert.match(stderr, /persona/i);
-  }
-  const clean = { tool_name: "mcp__cohort__org_rpc", tool_input: { method: "messaging.send", params: { channelId: "C1", body: "Numbers are in; deck by 3." } } };
-  assert.equal((await runHook(JSON.stringify(clean), { channel: "cohort", env: PERSONA_ENV })).code, 0);
-});
-
-function mkdirSyncP(p) { mkdirSync(p, { recursive: true }); }

package/scripts/huddle/huddle-prompt.test.mjs

@@ -1,176 +0,0 @@
-/**
- * huddle-prompt.test.mjs — the huddle system prompt is SPOKEN ALOUD. It must
- * never say anything the config does not know.
- *
- * WHAT BROKE
- *   `buildHuddleSystemPrompt()` carried a five-bullet block headed
- *   a shout-case `ABOUT <ONE-COMPANY>:` header whose body described a
- *   completely different, equally
- *   fictional company (a head office, a jurisdiction count, a product, a
- *   licensing phase). Two non-current identities in one block is the tell that
- *   no code path ever grounded it. The server `autoJoin`s incoming huddle
- *   invitations, participants can include people outside the org, and every turn
- *   is persisted to logs/huddle/*.jsonl — so this was a fabricated employer said
- *   out loud to outsiders and then written to disk. The identity line above it
- *   also interpolated `${a.company}` unconditionally, so an unconfigured seat
- *   introduced itself as "… of .".
- *
- * WHAT THESE TESTS PIN
- *   1. GROUNDED — every bullet in the company block traces to a field of
- *      config/company.json (name, legalName, description, industry, stage,
- *      jurisdictions, products, strategicPriorities), one for one.
- *   2. EMPTY — an unpopulated (or scaffold-UNCONFIGURED) config produces NO
- *      company block AT ALL and no dangling "at <blank>" clause. Saying nothing
- *      about the employer is the correct outcome.
- *
- * HOW IT RUNS
- *   huddle-server.mjs imports `dotenv` and `@anthropic-ai/sdk`, neither of which
- *   is a dependency of this package (only better-sqlite3 + js-yaml are), so the
- *   module cannot be imported in-process here. The renderers are pure and
- *   dependency-free, so we lift their REAL source out of the shipped file and
- *   evaluate that — the text under test is exactly the text that ships, and
- *   deleting/renaming a renderer fails this file rather than silently skipping.
- *
- * Run: node --test scripts/huddle/huddle-prompt.test.mjs
- */
-
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-
-const SRC = readFileSync(new URL("./huddle-server.mjs", import.meta.url), "utf8");
-
-/**
- * Slice one top-level `function NAME(...) { ... }` out of a source file by
- * brace matching. Throws when the function is absent — a rename or deletion is
- * a test failure, not a skip.
- */
-function extractFunction(src, name) {
-  const re = new RegExp(`(?:export\\s+)?function\\s+${name}\\s*\\(`);
-  const m = re.exec(src);
-  assert.ok(m, `huddle-server.mjs no longer defines ${name}() — update this test deliberately`);
-  const open = src.indexOf("{", m.index + m[0].length - 1);
-  let depth = 0;
-  for (let i = open; i < src.length; i++) {
-    const c = src[i];
-    if (c === "{") depth++;
-    else if (c === "}") {
-      depth--;
-      if (depth === 0) return src.slice(m.index, i + 1).replace(/^export\s+/, "");
-    }
-  }
-  throw new Error(`unbalanced braces extracting ${name}`);
-}
-
-const names = ["configuredStr", "configuredList", "renderHuddleCompanyBlock", "renderHuddleIdentityLine"];
-const body = names.map((n) => extractFunction(SRC, n)).join("\n\n");
-// eslint-disable-next-line no-new-func
-const mod = new Function(`${body}\nreturn { ${names.join(", ")} };`)();
-const { renderHuddleCompanyBlock, renderHuddleIdentityLine } = mod;
-
-// ── 1. GROUNDED ─────────────────────────────────────────────────────────────
-
-const REAL_COMPANY = {
-  name: "Meridian Freight",
-  legalName: "Meridian Freight Holdings Ltd",
-  description: "A regional logistics operator moving temperature-controlled freight.",
-  industry: "Logistics",
-  stage: "Series B",
-  jurisdictions: ["Ireland", "United Kingdom"],
-  products: ["Meridian Cold Chain", "Meridian Track"],
-  strategicPriorities: ["Open the Cork depot", "Cut empty-mile rate below 12%"],
-};
-
-test("grounded: every bullet traces to a config/company.json field", () => {
-  const block = renderHuddleCompanyBlock(REAL_COMPANY);
-  assert.match(block, /^ABOUT MERIDIAN FREIGHT:/);
-  assert.match(block, /A regional logistics operator moving temperature-controlled freight\./);
-  assert.match(block, /Industry: Logistics/);
-  assert.match(block, /Legal entity: Meridian Freight Holdings Ltd/);
-  assert.match(block, /Jurisdictions: Ireland, United Kingdom/);
-  assert.match(block, /Products: Meridian Cold Chain, Meridian Track/);
-  assert.match(block, /Stage: Series B/);
-  assert.match(block, /Current priorities: Open the Cork depot; Cut empty-mile rate below 12%/);
-});
-
-test("grounded: a partially-filled config renders only the fields it has", () => {
-  const block = renderHuddleCompanyBlock({ name: "Meridian Freight", industry: "Logistics" });
-  assert.match(block, /^ABOUT MERIDIAN FREIGHT:/);
-  assert.match(block, /Meridian Freight operates in Logistics/);
-  assert.doesNotMatch(block, /Jurisdictions:/);
-  assert.doesNotMatch(block, /Products:/);
-  assert.doesNotMatch(block, /Stage:/);
-  assert.doesNotMatch(block, /Current priorities:/);
-});
-
-test("grounded: the identity line names the real employer and principal", () => {
-  const line = renderHuddleIdentityLine(
-    {
-      fullName: "Robin Okafor",
-      title: "VP Operations",
-      company: "",
-      principal: { fullName: "Dana Lee", title: "CEO" },
-    },
-    REAL_COMPANY,
-  );
-  assert.match(line, /^You are Robin Okafor, VP Operations at Meridian Freight\./m);
-  assert.match(line, /^You report to Dana Lee, CEO\./m);
-  assert.match(line, /Slack huddle/);
-});
-
-// ── 2. EMPTY — no config, no claim ──────────────────────────────────────────
-
-test("empty: the scaffold's UNCONFIGURED company yields NO company block at all", () => {
-  const scaffold = {
-    name: "UNCONFIGURED",
-    legalName: "",
-    description: "",
-    industry: "",
-    stage: "",
-    jurisdictions: [],
-    products: [],
-    strategicPriorities: [],
-  };
-  assert.equal(renderHuddleCompanyBlock(scaffold), "", "silence is the correct outcome");
-});
-
-test("empty: a missing/garbage config yields NO company block", () => {
-  assert.equal(renderHuddleCompanyBlock({}), "");
-  assert.equal(renderHuddleCompanyBlock(null), "");
-  assert.equal(renderHuddleCompanyBlock(undefined), "");
-  assert.equal(renderHuddleCompanyBlock("nonsense"), "");
-});
-
-test("empty: no employer ⇒ the identity line drops the 'at <company>' clause", () => {
-  const line = renderHuddleIdentityLine(
-    { fullName: "Robin Okafor", title: "VP Operations", company: "", principal: {} },
-    { name: "UNCONFIGURED" },
-  );
-  assert.match(line, /^You are Robin Okafor, VP Operations\.$/m);
-  assert.doesNotMatch(line, / at /);
-  assert.doesNotMatch(line, /UNCONFIGURED/);
-  assert.doesNotMatch(line, /You report to/, "no principal on record ⇒ no reporting line");
-});
-
-test("empty: no identity at all ⇒ no persona is asserted, only the setting", () => {
-  const line = renderHuddleIdentityLine({}, {});
-  assert.equal(line, "You are participating in a Slack huddle — a real-time voice conversation.");
-});
-
-// ── 3. The fabricated block is gone from the shipped source ─────────────────
-
-test("the shipped prompt carries no invented employer, jurisdiction or product", () => {
-  assert.doesNotMatch(SRC, /\bNorthwind\b/i);
-  // No shout-case literal company header of ANY name survives — the header is
-  // built as `ABOUT ${name.toUpperCase()}:` from config, so a literal one is a
-  // regression by construction.
-  assert.doesNotMatch(SRC, /ABOUT [A-Z]{4,}:/);
-  assert.doesNotMatch(SRC, /\bDIFC\b/);
-  assert.doesNotMatch(SRC, /Currently in regulatory licensing phase/i);
-  assert.doesNotMatch(SRC, /global AI-native institutional asset management/i);
-  // The company block must be a render call, not a literal.
-  assert.match(SRC, /renderHuddleCompanyBlock\(co\)/);
-  assert.match(SRC, /\$\{companyBlock \? /, "the block is conditional on there being one");
-});