@cohortapp/agent-sdk 2.10.0 → 2.11.0

package/scripts/daemon/prompt-builder.mjs

@@ -5,8 +5,9 @@
 
 import { readFileSync, readdirSync } from "fs";
 import { join } from "path";
+import { createRequire } from "node:module";
 import { compileContext } from "./context-compiler.mjs";
-import { loadPersonaBlock } from "../../lib/identity/persona.mjs";
+import { renderPersona } from "../../lib/identity/persona.mjs";
 import { wrapExternalContent } from "../../lib/security/external-content.mjs";
 import { isEnabled as orgEnabled } from "../../lib/org/client.mjs";
 import { recall as orgRecall } from "../../lib/org/knowledge.mjs";
@@ -14,12 +15,22 @@ import { outcomeSourceShareable } from "./session-outcomes.mjs";
 
 const AGENT_REPO_DIR = process.env.AGENT_DIR || join(new URL(".", import.meta.url).pathname, "../..");
 
-// Load agent identity from canonical SOT for use in prompts and fallback preamble.
+// js-yaml, synchronously. The autonomy policy is read on the fallback-preamble
+// path, which is sync by contract; the org-config reader below can afford the
+// dynamic import, this cannot. js-yaml is a declared dependency of this package.
+const _require = createRequire(import.meta.url);
+const yaml = _require("js-yaml");
+
+// Load agent identity from canonical SOT. Used for the backlog-item owner label.
+// The fallback carries ONLY a generic first name — it used to also carry
+// `company: "the company"` and a fabricated principal, which is a claim about
+// the seat that nothing read. Identity for prompts goes through
+// renderSeatPersona() below, which omits an unset field rather than filling it.
 function loadAgent() {
   try {
     return JSON.parse(readFileSync(join(AGENT_REPO_DIR, "config/agent.json"), "utf-8"));
   } catch {
-    return { firstName: "Agent", fullName: "Agent", title: "agent", company: "the company", principal: { firstName: "principal", fullName: "the principal", title: "principal" } };
+    return { firstName: "agent" };
   }
 }
 
@@ -128,10 +139,94 @@ let cachedPreamble = null;
 // back to a generic-assistant register.
 let cachedPersona = null;
 
+/**
+ * A config value the operator has not filled in yet.
+ *
+ * The scaffold does not ship empty strings for everything — it ships SENTINELS:
+ * config/company.json has `"name": "UNCONFIGURED"`, config/agent.json has
+ * `"firstName": "UNCONFIGURED"`, `"fullName": "Unconfigured Agent"`,
+ * `"title": "Unconfigured Role"`. lib/identity/persona.mjs#renderPersona omits
+ * EMPTY fields, which is right, but a sentinel is not empty — so an untouched
+ * scaffold rendered "You are Unconfigured Agent, Unconfigured Role at
+ * UNCONFIGURED." into a live prompt. Treat the sentinel as absence.
+ *
+ * @param {*} v
+ * @returns {string} the trimmed value, or "" when absent/sentinel
+ */
+function configuredStr(v) {
+  const s = typeof v === "string" ? v.trim() : "";
+  if (!s) return "";
+  if (/^unconfigured\b/i.test(s)) return "";
+  return s;
+}
+
+/**
+ * Strip scaffold sentinels out of config/agent.json before it is rendered, so
+ * `renderPersona`'s omit-when-unset rule actually fires on a fresh repo.
+ * @param {object} a
+ * @returns {object}
+ */
+function scrubAgentConfig(a) {
+  const src = a && typeof a === "object" ? a : {};
+  const out = { ...src };
+  for (const k of ["firstName", "lastName", "fullName", "title", "company", "companyDescription", "persona", "background", "bio"]) {
+    if (k in out) out[k] = configuredStr(out[k]);
+  }
+  // A surname with no first name and no full name is not an identity — better
+  // to render no name at all than "You are AGENT." (the scaffold ships
+  // firstName "UNCONFIGURED" / lastName "AGENT").
+  if (!out.firstName && !out.fullName) out.lastName = "";
+  if (src.principal && typeof src.principal === "object") {
+    const p = { ...src.principal };
+    for (const k of ["firstName", "lastName", "fullName", "title"]) p[k] = configuredStr(p[k]);
+    out.principal = p;
+  }
+  return out;
+}
+
+/** Same, for config/company.json. */
+function scrubCompanyConfig(c) {
+  const src = c && typeof c === "object" ? c : {};
+  const out = { ...src };
+  for (const k of ["name", "legalName", "description", "tagline", "industry", "stage"]) {
+    if (k in out) out[k] = configuredStr(out[k]);
+  }
+  return out;
+}
+
+/** Read + scrub both config files. Never throws. @returns {{agent:object, company:object}} */
+function readSeatConfig(root) {
+  const read = (rel) => {
+    try { return JSON.parse(readFileSync(join(root, rel), "utf-8")); } catch { return {}; }
+  };
+  return {
+    agent: scrubAgentConfig(read("config/agent.json")),
+    company: scrubCompanyConfig(read("config/company.json")),
+  };
+}
+
+/**
+ * Render the persona block for a seat — config/agent.json + config/company.json
+ * through lib/identity/persona.mjs#renderPersona, with scaffold sentinels
+ * scrubbed first so an unconfigured field is OMITTED rather than asserted.
+ *
+ * @param {string} root agent repo root
+ * @param {object} [opts] forwarded to renderPersona
+ * @returns {string} "" when nothing is configured
+ */
+export function renderSeatPersona(root, opts = {}) {
+  try {
+    const { agent, company } = readSeatConfig(root);
+    return renderPersona(agent, company, opts) || "";
+  } catch {
+    return "";
+  }
+}
+
 /** Render (once per process) the persona block from config/agent.json. */
 function loadPersona() {
   if (cachedPersona !== null) return cachedPersona;
-  cachedPersona = loadPersonaBlock(AGENT_REPO_DIR) || "";
+  cachedPersona = renderSeatPersona(AGENT_REPO_DIR);
   return cachedPersona;
 }
 
@@ -148,7 +243,7 @@ function loadPreamble() {
     cachedPreamble = extractPreamble(raw);
   } catch (err) {
     console.error(`[prompt-builder] Failed to read CLAUDE.md: ${err.message}`);
-    cachedPreamble = FALLBACK_PREAMBLE;
+    cachedPreamble = fallbackPreamble();
   }
   return cachedPreamble;
 }
@@ -196,44 +291,172 @@ function extractPreamble(raw) {
 
   // If extraction got something reasonable, use it; otherwise fall back
   if (extracted.length > 200) return extracted;
-  return FALLBACK_PREAMBLE;
+  return fallbackPreamble();
+}
+
+/**
+ * Read the seat's GENERATED autonomy policy, or null.
+ *
+ * Provenance check, not just a file check. `policies/action-classification.yaml`
+ * exists in two very different shapes:
+ *
+ *   - the hand-written TEMPLATE that ships with the framework, whose header says
+ *     "the agent is a fully autonomous executive operator" for every seat; and
+ *   - the per-seat artefact `scripts/setup/generate-autonomy.mjs` renders from
+ *     `lib/autonomy.mjs#buildActionClassification` for THIS agent's archetype
+ *     (function × altitude), which is the only one that describes a real grant.
+ *
+ * Only the generated artefact carries `archetype` + `delegation_breadth`, so we
+ * require both. A template copy is treated as ABSENT — inheriting another
+ * seat's maximal grant is precisely the fabrication this function exists to stop.
+ *
+ * Never throws; returns null on any read/parse failure.
+ *
+ * @param {string} [root=AGENT_REPO_DIR]
+ * @returns {object|null}
+ */
+export function loadSeatAutonomyPolicy(root = AGENT_REPO_DIR) {
+  try {
+    const raw = readFileSync(join(root, "policies/action-classification.yaml"), "utf-8");
+    const doc = yaml.load(raw);
+    if (!doc || typeof doc !== "object") return null;
+    if (!doc.archetype || !doc.delegation_breadth) return null;
+    return doc;
+  } catch {
+    return null;
+  }
+}
+
+/** Clean string[] from a config list; drops blanks. */
+function strList(v, max = 12) {
+  if (!Array.isArray(v)) return [];
+  return v.map((x) => (typeof x === "string" ? x.trim() : "")).filter(Boolean).slice(0, max);
+}
+
+/**
+ * Render what this seat may actually do, from the generated policy — or, when
+ * no policy has been generated, a fail-closed restraint.
+ *
+ * WHY THIS REPLACED A LITERAL
+ *   The previous text granted the seat authority to send, unreviewed, "all
+ *   internal messages, external operational messages, candidate comms,
+ *   follow-ups, calendar coordination" and to escalate only four narrow
+ *   categories. NONE of that was read from anywhere. It is a GOVERNANCE claim,
+ *   not a naming one, and it fired on exactly the population least entitled to
+ *   it: this preamble is used when CLAUDE.md is unreadable OR its extracted
+ *   sections total <= 200 chars, i.e. on a freshly scaffolded repo that has
+ *   never had autonomy bands set — while driving a real `claude --print`
+ *   session that can send real messages.
+ *
+ *   So: bands come from the seat's generated policy or they are not asserted.
+ *   With no policy the correct posture is LESS authority, not more — the
+ *   preamble says draft-and-confirm and says why. That is a statement about the
+ *   ABSENCE of a configured grant, not an invented grant.
+ *
+ * @param {object|null} policy result of loadSeatAutonomyPolicy()
+ * @returns {string}
+ */
+export function renderAutonomySection(policy) {
+  if (!policy) {
+    return [
+      "Authority (NO AUTONOMY POLICY IS CONFIGURED FOR THIS SEAT):",
+      "- `policies/action-classification.yaml` has not been generated for you (run `maestro upgrade`, which runs scripts/setup/generate-autonomy.mjs).",
+      "- Until it has been, assume NO standing authority to act outward. Draft, do not send. Prepare the message, document or calendar change and put it in front of your principal for a decision.",
+      "- Do not make commitments, send outbound communications, or take irreversible actions on your own authority on the strength of this prompt. Nothing here grants that.",
+    ].join("\n");
+  }
+
+  const levels = (policy.action_levels && typeof policy.action_levels === "object") ? policy.action_levels : {};
+  const green = strList(levels.execute_autonomous && levels.execute_autonomous.examples);
+  const amber = strList(levels.approval_preferred && levels.approval_preferred.examples);
+  const red = strList(levels.escalate && levels.escalate.examples);
+  const escalateTo = strList(levels.escalate && levels.escalate.escalate_to, 4);
+  const rights = Array.isArray(policy.decision_rights) ? policy.decision_rights.slice(0, 8) : [];
+
+  const out = [
+    `Authority (from policies/action-classification.yaml, generated for archetype ${policy.archetype}):`,
+  ];
+  if (policy.autonomy_default) out.push(`- Default posture: ${policy.autonomy_default}`);
+  if (green.length) out.push(`- You act on your own authority: ${green.join("; ")}`);
+  if (amber.length) out.push(`- You get agreement first: ${amber.join("; ")}`);
+  if (red.length) out.push(`- You escalate and do NOT act alone: ${red.join("; ")}`);
+  if (escalateTo.length) out.push(`- Escalate to: ${escalateTo.join(", ")}`);
+  for (const d of rights) {
+    if (!d || typeof d !== "object") continue;
+    const scope = typeof d.scope === "string" ? d.scope.trim() : "";
+    const authority = typeof d.authority === "string" ? d.authority.trim() : "";
+    if (!scope) continue;
+    out.push(`- Decision right — ${scope}${authority ? ` (${authority})` : ""}`);
+  }
+  // A generated policy with every band empty asserts nothing. Say so rather
+  // than implying the empty bands are a grant.
+  if (out.length === 1) {
+    out.push("- The generated policy declares no bands. Treat that as no standing authority: draft, do not send.");
+  }
+  return out.join("\n");
+}
+
+/**
+ * Preamble used ONLY when CLAUDE.md is unreadable or effectively empty.
+ *
+ * Everything seat-specific is rendered from the source of truth:
+ *   identity/company/responsibilities/operating principles → config/agent.json +
+ *   config/company.json via lib/identity/persona.mjs#renderPersona (which omits
+ *   an unset field rather than faking it);
+ *   authority → the seat's generated action-classification policy.
+ *
+ * What remains hardcoded is framework craft doctrine that makes NO claim about
+ * this seat's employer or its authority, so it is honest on any deployment.
+ *
+ * @returns {string}
+ */
+export function buildFallbackPreamble(root = AGENT_REPO_DIR) {
+  const parts = [];
+
+  // Identity, company, responsibilities and operating principles — all from
+  // config. Voice rules are omitted here because buildPrompt() already leads
+  // with the full persona block; this is the degraded path, not a second copy.
+  const persona = renderSeatPersona(root, { includeVoiceRules: false });
+  if (persona) parts.push(persona);
+
+  parts.push(renderAutonomySection(loadSeatAutonomyPolicy(root)));
+
+  parts.push(
+    [
+      "How you work:",
+      "- Follow-through over brilliance — track every commitment until it closes",
+      "- Concise over comprehensive — sharp recommendations, not exhaustive reports",
+      "- Evidence over opinion — cite sources, and say when you do not know",
+      "- Audit everything — every action is logged",
+    ].join("\n"),
+  );
+
+  parts.push(
+    [
+      "Document Sharing (CRITICAL):",
+      "- NEVER reference local file paths in outbound communications",
+      "- Upload to shared storage or generate a branded PDF for sharing",
+      "- Inline short content directly in messages",
+      "- Never attach raw .md or .yaml files",
+    ].join("\n"),
+  );
+
+  return parts.join("\n\n");
+}
+
+// Computed lazily (and cached) rather than at module load: the autonomy policy
+// and config/agent.json are read from disk, and a test that points AGENT_DIR at
+// a fixture must not be beaten to it by import-time evaluation.
+let _fallbackPreamble = null;
+function fallbackPreamble() {
+  if (_fallbackPreamble === null) _fallbackPreamble = buildFallbackPreamble();
+  return _fallbackPreamble;
 }
 
-// Generic preamble derived from config/agent.json. This is only used when
-// CLAUDE.md is unreadable; ordinarily the daemon pulls the full identity
-// block straight from the agent's CLAUDE.md.
-function buildFallbackPreamble() {
-  const a = loadAgent();
-  const principal = a.principal || {};
-  const principalName = principal.fullName || "the principal";
-  const principalTitle = principal.title || "principal";
-  // "<title> to <principal>" only reads correctly for assistant-shaped titles;
-  // for a functional seat ("SVP AI Systems & Agent Platform") it turns the role
-  // into a service relationship. State the seat, then the reporting line.
-  return `You are ${a.fullName}, ${a.title} at ${a.company}. You report to ${principalName}, ${principalTitle}.
-You operate as the autonomous executive command layer for the company.
-
-${a.companyDescription || a.company}.
-
-Operating Principles:
-1. Follow-through over brilliance — track every commitment until it closes
-2. Concise over comprehensive — sharp recommendations, not exhaustive reports
-3. Evidence over opinion — cite sources
-4. Bias to action — act decisively on operational matters; escalate only strategic commitments
-5. Audit everything — every action is logged
-6. Full autonomy, full accountability
-
-Autonomy Model:
-- ${a.firstName} sends autonomously: all internal messages, external operational messages, candidate comms, follow-ups, calendar coordination
-- ${a.firstName} escalates only: binding legal/financial obligations, regulatory submissions, acquisition deal terms, public statements
-
-Document Sharing (CRITICAL):
-- NEVER reference local file paths in outbound communications
-- Upload to Google Drive or generate branded PDF for sharing
-- Inline short content directly in messages
-- Never attach raw .md or .yaml files`;
+/** For tests: drop the cached fallback preamble. */
+export function _resetFallbackPreamble() {
+  _fallbackPreamble = null;
 }
-const FALLBACK_PREAMBLE = buildFallbackPreamble();
 
 /**
  * Proactive self-learning habit (WS3). Injected near the top of every reactive /
@@ -531,7 +754,7 @@ function buildBacklogContext(queueItem) {
   lines.push(`Title: ${queueItem.title || "untitled"}`);
   lines.push(`Status: ${queueItem.status || "open"}`);
   lines.push(`Priority: ${queueItem.priority || "normal"}`);
-  lines.push(`Owner: ${queueItem.owner || loadAgent().firstName.toLowerCase()}`);
+  lines.push(`Owner: ${queueItem.owner || configuredStr(loadAgent().firstName).toLowerCase() || "agent"}`);
   if (queueItem.source) lines.push(`Source: ${queueItem.source}`);
   if (queueItem.source_ref) lines.push(`Source ref: ${queueItem.source_ref}`);
   // ── what to act ON, and with WHAT ────────────────────────────────────────

package/scripts/daemon/prompt-builder.test.mjs

@@ -215,18 +215,18 @@ test("buildPrompt caps the number of injected org facts (bounded)", async () =>
 test("buildPrompt states the acknowledgement was sent when it actually was", async () => {
   const prompt = await buildPrompt(ITEM, CLASS, {
     type: "inbox",
-    holdingMessage: "Understood — let me dig into this.",
+    holdingMessage: "Understood — I'm digging into this now (the noted issues). I want to get this right, so I'll come back to you here with a full answer — usually within 10-20 minutes — and you'll hear from me either way.",
     holdingSent: true,
   });
   assert.match(prompt, /A HOLDING MESSAGE has ALREADY been sent/);
-  assert.ok(prompt.includes("Understood — let me dig into this."));
+  assert.ok(prompt.includes("Understood — I'm digging into this now (the noted issues). I want to get this right, so I'll come back to you here with a full answer — usually within 10-20 minutes — and you'll hear from me either way."));
   assert.ok(!/DELIVERY FAILED/.test(prompt), "no failure framing on a delivered ack");
 });
 
 test("buildPrompt does NOT claim delivery when the acknowledgement failed to send", async () => {
   const prompt = await buildPrompt(ITEM, CLASS, {
     type: "inbox",
-    holdingMessage: "Understood — let me dig into this.",
+    holdingMessage: "Understood — I'm digging into this now (the noted issues). I want to get this right, so I'll come back to you here with a full answer — usually within 10-20 minutes — and you'll hear from me either way.",
     holdingSent: false,
   });
   // The lie: telling the session a human already heard from us when they did not.
@@ -242,13 +242,13 @@ test("buildPrompt does NOT claim delivery when the acknowledgement failed to sen
   assert.match(prompt, /DELIVERY FAILED/);
   assert.match(prompt, /received NOTHING/);
   // The composed text is still shown — it is what the sender would have seen.
-  assert.ok(prompt.includes("Understood — let me dig into this."));
+  assert.ok(prompt.includes("Understood — I'm digging into this now (the noted issues). I want to get this right, so I'll come back to you here with a full answer — usually within 10-20 minutes — and you'll hear from me either way."));
 });
 
 test("buildPrompt treats an unspecified holdingSent as delivered (back-compat)", async () => {
   const prompt = await buildPrompt(ITEM, CLASS, {
     type: "inbox",
-    holdingMessage: "Understood — let me dig into this.",
+    holdingMessage: "Understood — I'm digging into this now (the noted issues). I want to get this right, so I'll come back to you here with a full answer — usually within 10-20 minutes — and you'll hear from me either way.",
   });
   assert.match(prompt, /A HOLDING MESSAGE has ALREADY been sent/);
 });

package/scripts/disclosure_boundaries.py

@@ -9,8 +9,8 @@ Generates dynamic disclosure boundary guidance for a given recipient by:
      recent sensitive context, and excluded domains active
 
 Usage (CLI):
-  python3 scripts/disclosure_boundaries.py --recipient casey-morgan
-  python3 scripts/disclosure_boundaries.py --recipient alex-chen --hours 24
+  python3 scripts/disclosure_boundaries.py --recipient <profile-slug>
+  python3 scripts/disclosure_boundaries.py --recipient <profile-slug> --hours 24
 
 Exit codes:
   0 = always (profile not found prints to stderr and exits 0)
@@ -35,6 +35,57 @@ USER_PROFILES_DIR = REPO_ROOT / "memory" / "profiles" / "users"
 PROVENANCE_INDEX = REPO_ROOT / "memory" / "provenance" / "index.jsonl"
 
 
+# ─── Employer identity (config/company.json — the SOT) ───────────────────────
+# The clearance summary states a recipient's relationship to the agent's
+# EMPLOYER. That employer used to be a hardcoded name in the sentence, so every
+# deployment's clearance summaries named a company that does not exist. It now
+# comes from config/company.json, and when nothing is configured the sentence
+# says "the company" rather than inventing one.
+def _load_company() -> dict:
+    """Read config/company.json. Never raises."""
+    try:
+        with open(REPO_ROOT / "config" / "company.json") as f:
+            data = json.load(f)
+        return data if isinstance(data, dict) else {}
+    except Exception:
+        return {}
+
+
+def _configured(value) -> str:
+    """Trimmed config string, or '' when absent/UNCONFIGURED (both mean unset)."""
+    if not isinstance(value, str):
+        return ''
+    v = value.strip()
+    if not v or v.upper() == 'UNCONFIGURED':
+        return ''
+    return v
+
+
+COMPANY_NAME = _configured(_load_company().get('name'))
+
+
+def legacy_relationship_value(profile: dict) -> str:
+    """Read a profile's flat "relationship to the employer" field.
+
+    Canonical key: `relationship_to_company`. Profiles written before this was
+    de-hardcoded used `relationship_to_<employer-name>`, so ANY
+    `relationship_to_*` key is accepted rather than pinning one company name
+    into the reader.
+    """
+    if not isinstance(profile, dict):
+        return ''
+    primary = profile.get('relationship_to_company')
+    if isinstance(primary, str) and primary.strip():
+        return primary
+    for key in sorted(profile.keys()):
+        if not isinstance(key, str) or not key.startswith('relationship_to_'):
+            continue
+        value = profile.get(key)
+        if isinstance(value, str) and value.strip():
+            return value
+    return ''
+
+
 # ─── YAML Parser ─────────────────────────────────────────────────────────────
 # Custom minimal YAML parser — no PyYAML dependency (consistent with repo pattern).
 # Handles: top-level scalars, nested mappings, inline lists [a, b, c],
@@ -427,7 +478,7 @@ def _build_clearance_summary(profile: dict, boundaries: dict) -> str:
     name = profile.get('name') or profile.get('preferred_name') or 'Unknown'
     role = profile.get('role') or ''
     org = profile.get('organisation') or ''
-    relationship = profile.get('relationship_to_northwind') or ''
+    relationship = legacy_relationship_value(profile)
     domains_of_interest = boundaries.get('domains_of_interest') or []
     excluded_domains = boundaries.get('excluded_domains') or []
     conflicts = boundaries.get('conflicts') or []
@@ -446,7 +497,7 @@ def _build_clearance_summary(profile: dict, boundaries: dict) -> str:
     if org:
         parts.append(f"Organisation: {org}.")
     if relationship:
-        parts.append(f"Relationship to Northwind: {relationship}.")
+        parts.append(f"Relationship to {COMPANY_NAME or 'the company'}: {relationship}.")
 
     if domains_of_interest:
         parts.append(f"Permitted domains: {', '.join(str(d) for d in domains_of_interest)}.")
@@ -536,7 +587,7 @@ def main():
     parser.add_argument(
         '--recipient',
         required=True,
-        help="Recipient slug (e.g. casey-morgan)",
+        help="Recipient profile slug (memory/profiles/users/<slug>.yaml)",
     )
     parser.add_argument(
         '--hours',

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

@@ -0,0 +1,176 @@
+/**
+ * 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");
+});