@cohortapp/agent-sdk 2.10.0 → 2.11.0

package/scripts/test-employer-grounding.py

@@ -0,0 +1,348 @@
+#!/usr/bin/env python3
+"""test-employer-grounding.py — the send-path Python must read the employer, never assume one.
+
+WHAT BROKE
+  scripts/validate_outbound.py carried SIXTEEN hardcoded 'company:<example>-*'
+  entity ids plus a matching `startswith` prefix test, and built its
+  possessive-claim regex and AI-self-disclosure business exceptions around the
+  same invented name. This file is Layer 0 of the sanctioned send path
+  (send-email-threaded.py imports validate_message; it runs in series with
+  lib/comms/send-gate.mjs#screenOutbound and either can block), so on any REAL
+  deployment nothing matched: every colleague was classified external, every
+  legitimate "our engineer" was flagged, and the AI-disclosure exceptions never
+  fired. scripts/pre-draft-context.py had the same id set, and
+  scripts/disclosure_boundaries.py rendered "Relationship to <invented company>"
+  into every clearance summary.
+
+WHAT THIS PINS
+  1. GROUNDED — with a real config/company.json, the employer's entity ids,
+     possessive regex and AI-product exceptions all resolve from it, and the
+     clearance summary names the real company.
+  2. EMPTY — with the scaffold's UNCONFIGURED config, the id set is EMPTY and
+     `is_own_entity()` is False for everything. That is the FAIL-CLOSED
+     direction on every consumer: unknown people are external, possessive claims
+     stay flagged, and no company-specific AI-disclosure exception fires.
+
+The modules read config from $AGENT_DIR (validate_outbound) / the repo root
+(pre-draft-context, disclosure_boundaries), and resolve the employer at IMPORT
+time, so each case is loaded in a fresh subprocess against a fresh fixture root.
+
+Usage: python3 scripts/test-employer-grounding.py   (exit 0 ok / 1 failures)
+"""
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+REPO_ROOT = SCRIPT_DIR.parent
+
+REAL_COMPANY = {
+    "name": "Meridian Freight",
+    "legalName": "Meridian Freight Holdings Ltd",
+    "domain": "meridianfreight.com",
+}
+SCAFFOLD_COMPANY = {
+    "name": "UNCONFIGURED",
+    "legalName": "",
+    "domain": "",
+}
+
+_passed = 0
+_failed = 0
+
+
+def check(name, condition, detail=""):
+    global _passed, _failed
+    if condition:
+        _passed += 1
+        print(f"  PASS: {name}")
+    else:
+        _failed += 1
+        print(f"  FAIL: {name}{' — ' + detail if detail else ''}")
+
+
+def make_root(company):
+    """A throwaway agent repo carrying only config/company.json."""
+    root = Path(tempfile.mkdtemp(prefix="employer-"))
+    (root / "config").mkdir(parents=True)
+    (root / "config" / "company.json").write_text(json.dumps(company))
+    return root
+
+
+def run_probe(module_path, root, body, extra_env=None):
+    """Import `module_path` with the repo rooted at `root`, run `body`, print JSON.
+
+    The module is loaded by absolute path with AGENT_DIR pointed at the fixture,
+    and — for the modules that resolve the repo root from __file__ — a COPY of
+    the script placed inside the fixture's scripts/ dir.
+    """
+    probe = f'''
+import importlib.util, json, sys
+spec = importlib.util.spec_from_file_location("under_test", {str(module_path)!r})
+m = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(m)
+print("@@" + json.dumps({body}))
+'''
+    env = dict(os.environ)
+    env["AGENT_DIR"] = str(root)
+    if extra_env:
+        env.update(extra_env)
+    out = subprocess.run(
+        [sys.executable, "-c", probe], capture_output=True, text=True, env=env, cwd=str(root)
+    )
+    if out.returncode != 0:
+        raise AssertionError(f"probe failed: {out.stderr.strip()[:800]}")
+    line = [ln for ln in out.stdout.splitlines() if ln.startswith("@@")][-1]
+    return json.loads(line[2:])
+
+
+def staged_copy(root, rel):
+    """Copy a repo script into the fixture root so REPO_ROOT-from-__file__ resolves there.
+
+    HARNESS ADAPTATION (not a code change): scripts/disclosure_boundaries.py uses
+    PEP 604 annotations (`dict | None`), which are evaluated at def time before
+    Python 3.10 — a PRE-EXISTING 3.10+ requirement of that file, unrelated to
+    this lane. Prepending `from __future__ import annotations` to the COPY makes
+    annotations lazy so the real, unmodified function bodies can be exercised on
+    the 3.9 interpreter this machine ships. Nothing else about the file changes.
+    """
+    dst = root / rel
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    src = (REPO_ROOT / rel).read_text()
+    dst.write_text("from __future__ import annotations\n" + src)
+    return dst
+
+
+# ── validate_outbound.py ─────────────────────────────────────────────────────
+
+def test_validate_outbound_grounded():
+    print("\n[validate_outbound — GROUNDED]")
+    root = make_root(REAL_COMPANY)
+    r = run_probe(
+        REPO_ROOT / "scripts" / "validate_outbound.py",
+        root,
+        '{'
+        '"name": m.COMPANY_NAME,'
+        '"ids": sorted(m.OWN_ENTITY_IDS),'
+        '"own_exact": m.is_own_entity("company:meridian-freight"),'
+        '"own_subsidiary": m.is_own_entity("company:meridian-freight-uk"),'
+        '"other": m.is_own_entity("company:someone-else"),'
+        '"ai_exception": len(m.check_ai_self_disclosure("Our Meridian Freight AI platform ships next week.")),'
+        '}',
+    )
+    check("employer name read from config", r["name"] == "Meridian Freight", str(r["name"]))
+    check("entity ids derive from name/legalName/domain", "company:meridian-freight" in r["ids"], str(r["ids"]))
+    check("own entity resolves", r["own_exact"] is True)
+    check("group subsidiary resolves via prefix", r["own_subsidiary"] is True)
+    check("an unrelated company does NOT resolve", r["other"] is False)
+    check("'<Employer> AI' is a business exception, not a self-disclosure", r["ai_exception"] == 0, str(r["ai_exception"]))
+    shutil.rmtree(root, ignore_errors=True)
+
+
+def test_validate_outbound_empty():
+    print("\n[validate_outbound — EMPTY / fail closed]")
+    root = make_root(SCAFFOLD_COMPANY)
+    r = run_probe(
+        REPO_ROOT / "scripts" / "validate_outbound.py",
+        root,
+        '{'
+        '"name": m.COMPANY_NAME,'
+        '"ids": sorted(m.OWN_ENTITY_IDS),'
+        '"prefixes": sorted(m.OWN_ENTITY_PREFIXES),'
+        '"any": m.is_own_entity("company:anything-at-all"),'
+        '"none": m.is_own_entity(""),'
+        '}',
+    )
+    check("UNCONFIGURED reads as absent", r["name"] == "", repr(r["name"]))
+    check("NO employer ids are invented", r["ids"] == [], str(r["ids"]))
+    check("NO prefixes are invented", r["prefixes"] == [], str(r["prefixes"]))
+    check("is_own_entity is False for everything (fail closed)", r["any"] is False)
+    check("is_own_entity tolerates junk", r["none"] is False)
+    shutil.rmtree(root, ignore_errors=True)
+
+
+def test_legacy_profile_key():
+    print("\n[validate_outbound — legacy profile key, read generically]")
+    root = make_root(REAL_COMPANY)
+    r = run_probe(
+        REPO_ROOT / "scripts" / "validate_outbound.py",
+        root,
+        '{'
+        '"canonical": m.legacy_relationship_value({"relationship_to_company": "advisor"}),'
+        '"legacy": m.legacy_relationship_value({"relationship_to_someoldcompany": "vendor"}),'
+        '"precedence": m.legacy_relationship_value({"relationship_to_company": "advisor", "relationship_to_old": "vendor"}),'
+        '"none": m.legacy_relationship_value({"unrelated": "x"}),'
+        '"junk": m.legacy_relationship_value(None),'
+        '}',
+    )
+    check("canonical key wins", r["canonical"] == "advisor")
+    check("ANY relationship_to_* key resolves (no company name pinned)", r["legacy"] == "vendor")
+    check("canonical takes precedence over legacy", r["precedence"] == "advisor")
+    check("absent ⇒ empty string", r["none"] == "")
+    check("junk ⇒ empty string", r["junk"] == "")
+    shutil.rmtree(root, ignore_errors=True)
+
+
+# ── pre-draft-context.py ─────────────────────────────────────────────────────
+
+def test_pre_draft_context():
+    print("\n[pre-draft-context — GROUNDED and EMPTY]")
+    for label, company, expect_own in (("grounded", REAL_COMPANY, True), ("empty", SCAFFOLD_COMPANY, False)):
+        root = make_root(company)
+        staged = staged_copy(root, "scripts/pre-draft-context.py")
+        r = run_probe(
+            staged,
+            root,
+            '{'
+            '"name": m.COMPANY_NAME,'
+            '"own": m.is_own_entity("company:meridian-freight"),'
+            '"other": m.is_own_entity("company:someone-else"),'
+            '}',
+        )
+        check(f"{label}: own-employer test is {expect_own}", r["own"] is expect_own, str(r))
+        check(f"{label}: an unrelated company is never own", r["other"] is False)
+        shutil.rmtree(root, ignore_errors=True)
+
+
+# ── disclosure_boundaries.py ─────────────────────────────────────────────────
+
+def test_disclosure_boundaries():
+    print("\n[disclosure_boundaries — clearance summary names the REAL employer]")
+    root = make_root(REAL_COMPANY)
+    staged = staged_copy(root, "scripts/disclosure_boundaries.py")
+    r = run_probe(
+        staged,
+        root,
+        '{'
+        '"name": m.COMPANY_NAME,'
+        '"summary": m._build_clearance_summary('
+        '  {"name": "Sam Rivera", "role": "Advisor", "relationship_to_company": "external advisor"},'
+        '  {"domains_of_interest": ["engineering"]}),'
+        '"legacy_summary": m._build_clearance_summary('
+        '  {"name": "Sam Rivera", "relationship_to_someoldcompany": "external advisor"},'
+        '  {"domains_of_interest": []}),'
+        '}',
+    )
+    check("employer name read from config", r["name"] == "Meridian Freight")
+    check("summary names the real employer", "Relationship to Meridian Freight: external advisor." in r["summary"], r["summary"])
+    check("a legacy relationship_to_* key still resolves", "external advisor" in r["legacy_summary"], r["legacy_summary"])
+    check("no permitted domains ⇒ default deny is stated", "default deny" in r["legacy_summary"], r["legacy_summary"])
+    shutil.rmtree(root, ignore_errors=True)
+
+    print("\n[disclosure_boundaries — EMPTY: a neutral noun, never an invented name]")
+    root = make_root(SCAFFOLD_COMPANY)
+    staged = staged_copy(root, "scripts/disclosure_boundaries.py")
+    r = run_probe(
+        staged,
+        root,
+        '{'
+        '"name": m.COMPANY_NAME,'
+        '"summary": m._build_clearance_summary('
+        '  {"name": "Sam Rivera", "relationship_to_company": "external advisor"},'
+        '  {"domains_of_interest": ["engineering"]}),'
+        '}',
+    )
+    check("UNCONFIGURED reads as absent", r["name"] == "")
+    check("summary falls back to 'the company'", "Relationship to the company: external advisor." in r["summary"], r["summary"])
+    check("no sentinel leaks into the summary", "UNCONFIGURED" not in r["summary"], r["summary"])
+    shutil.rmtree(root, ignore_errors=True)
+
+
+# ── policies/information-barriers.yaml ───────────────────────────────────────
+
+def test_information_barriers_policy():
+    print("\n[information-barriers.yaml — company-neutral, default-deny]")
+    raw = (REPO_ROOT / "policies" / "information-barriers.yaml").read_text()
+    descriptions = [ln for ln in raw.splitlines() if ln.strip().startswith("description:")]
+    check("domain descriptions exist", len(descriptions) > 10, str(len(descriptions)))
+    # Descriptions are parsed into the live keyword matcher by
+    # context-compiler.mjs#buildDomainKeywords, so a party name here becomes a
+    # classification keyword for every customer.
+    for ln in descriptions:
+        low = ln.lower()
+        check(
+            f"description is company-neutral: {ln.strip()[:60]}",
+            "northwind" not in low and "partnerco" not in low,
+        )
+    check("unrestricted_recipients ships EMPTY (default deny)", "unrestricted_recipients: []" in raw)
+    check("the taxonomy itself is kept", "internal-legal:" in raw and "board-governance:" in raw)
+
+
+# ── spawn-session.sh ─────────────────────────────────────────────────────────
+
+def test_spawn_session_identity():
+    print("\n[spawn-session.sh — identity clause from config/agent.env]")
+    src = (REPO_ROOT / "scripts" / "spawn-session.sh").read_text()
+    check("sources config/agent.env", 'config/agent.env' in src)
+    check(
+        "uses the real config/agent.env variable names",
+        "AGENT_FULL_NAME" in src and "COMPANY_NAME" in src,
+    )
+    check("no invented employer in the sub-session prompt", "northwind" not in src.lower())
+    check("the instance-specific dir variable is renamed", "SOPHIE_AI_DIR" not in src)
+
+    # Behavioural: the clause is assembled by the shell, so drive the shell.
+    def clause(env):
+        script = (
+            'set -e\n'
+            '_agent_name="${AGENT_FULL_NAME:-}"\n'
+            '_company="${COMPANY_NAME:-}"\n'
+            'if [ "$_agent_name" = "UNCONFIGURED" ]; then _agent_name=""; fi\n'
+            'if [ "$_company" = "UNCONFIGURED" ]; then _company=""; fi\n'
+            'if [ -n "$_agent_name" ] && [ -n "$_company" ]; then\n'
+            '  echo "IMPORTANT: You are a sub-session spawned for $_agent_name at $_company."\n'
+            'elif [ -n "$_agent_name" ]; then\n'
+            '  echo "IMPORTANT: You are a sub-session spawned for $_agent_name."\n'
+            'else\n'
+            '  echo "IMPORTANT: You are a sub-session spawned by an agent."\n'
+            'fi\n'
+        )
+        # The block under test is lifted verbatim from the script — assert that first.
+        assert 'if [ -n "$_agent_name" ] && [ -n "$_company" ]; then' in src, "identity block changed shape"
+        e = dict(os.environ)
+        e.pop("AGENT_FULL_NAME", None)
+        e.pop("COMPANY_NAME", None)
+        e.update(env)
+        return subprocess.run(["bash", "-c", script], capture_output=True, text=True, env=e).stdout.strip()
+
+    check(
+        "grounded: both fields present ⇒ full clause",
+        clause({"AGENT_FULL_NAME": "Robin Okafor", "COMPANY_NAME": "Meridian Freight"})
+        == "IMPORTANT: You are a sub-session spawned for Robin Okafor at Meridian Freight.",
+    )
+    check(
+        "empty: no company ⇒ the employer clause is dropped",
+        clause({"AGENT_FULL_NAME": "Robin Okafor"})
+        == "IMPORTANT: You are a sub-session spawned for Robin Okafor.",
+    )
+    check(
+        "empty: UNCONFIGURED counts as absent",
+        clause({"AGENT_FULL_NAME": "UNCONFIGURED", "COMPANY_NAME": "UNCONFIGURED"})
+        == "IMPORTANT: You are a sub-session spawned by an agent.",
+    )
+    check(
+        "empty: nothing at all ⇒ a generic, true statement",
+        clause({}) == "IMPORTANT: You are a sub-session spawned by an agent.",
+    )
+
+
+def main():
+    print("Running employer-grounding tests...\n")
+    test_validate_outbound_grounded()
+    test_validate_outbound_empty()
+    test_legacy_profile_key()
+    test_pre_draft_context()
+    test_disclosure_boundaries()
+    test_information_barriers_policy()
+    test_spawn_session_identity()
+    print(f"\n{_passed} passed, {_failed} failed")
+    return 1 if _failed else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/validate_outbound.py

@@ -58,6 +58,152 @@ except Exception:
     _AGENT = {"firstName": "Agent", "fullName": "Agent"}
 AGENT_FIRST_NAME = _AGENT.get("firstName", "Agent")
 
+
+# ─────────────────────────────────────────────
+# Employer identity — resolved ONCE at load from config/company.json
+#
+# WHY THIS EXISTS
+#   The entity-relationship checks below used to carry sixteen hardcoded
+#   entity ids for the framework's example employer, plus a matching
+#   `startswith` prefix test. This file is Layer 0 of the sanctioned send path
+#   (send-email-threaded.py imports validate_message; it runs in series with
+#   lib/comms/send-gate.mjs#screenOutbound and either can block), so on any real
+#   deployment NOTHING matched: every colleague was classified external, every
+#   legitimate "our engineer" was flagged as an unverified possessive claim, and
+#   the AI-self-disclosure business exceptions never fired.
+#
+#   Employer identity now comes from config/company.json — the same SOT
+#   lib/setup/enroll-from-cohort.mjs syncs from Cohort — exactly as
+#   scripts/poller/gmail-poller.mjs#internalDomains was de-hardcoded.
+#
+# FAIL CLOSED
+#   When nothing is configured the id set is EMPTY, so `is_own_entity()` is
+#   always False. That is the conservative direction on every consumer here:
+#   unknown-relationship people are treated as external, possessive claims stay
+#   flagged, and the AI-disclosure exception list stays empty (so "AI" wording
+#   is flagged rather than waved through). Silence, not a guess.
+# ─────────────────────────────────────────────
+try:
+    with open(REPO_ROOT / "config" / "company.json") as _f:
+        _COMPANY = json.load(_f)
+except Exception:
+    _COMPANY = {}
+
+
+def _configured(value):
+    """Return a trimmed config string, or '' when it is absent/UNCONFIGURED.
+
+    config/company.json ships `"name": "UNCONFIGURED"` and empty strings in the
+    scaffold, so both shapes mean 'the operator has not filled this in'.
+    """
+    if not isinstance(value, str):
+        return ''
+    v = value.strip()
+    if not v or v.upper() == 'UNCONFIGURED':
+        return ''
+    return v
+
+
+COMPANY_NAME = _configured(_COMPANY.get('name'))
+COMPANY_LEGAL_NAME = _configured(_COMPANY.get('legalName'))
+COMPANY_DOMAIN = _configured(_COMPANY.get('domain'))
+
+
+def _slugify(value):
+    """'Acme Holdings, Ltd.' -> 'acme-holdings-ltd'. Returns '' for junk."""
+    if not value:
+        return ''
+    slug = re.sub(r'[^a-z0-9]+', '-', value.lower()).strip('-')
+    return slug
+
+
+def _resolve_own_entity_ids(company):
+    """Build the set of entity-index ids that denote THIS agent's employer.
+
+    Precedence:
+      1. an explicit `own_entity_ids` list in config/company.json (the escape
+         hatch for a group with entity ids that do not derive from its name);
+      2. otherwise, ids derived from name / legalName / domain.
+
+    Returns (ids, prefixes). `prefixes` lets a group's subsidiaries
+    ('company:acme-holdings', 'company:acme-am-uk') resolve without every entity
+    being enumerated — the same reach the hardcoded prefix test had, but keyed
+    to the real employer.
+    """
+    explicit = company.get('own_entity_ids')
+    if isinstance(explicit, list):
+        ids = {str(x).strip() for x in explicit if isinstance(x, (str,)) and str(x).strip()}
+        if ids:
+            # An explicit list is exhaustive by construction — no prefix reach.
+            return ids, set()
+
+    stems = set()
+    for raw in (COMPANY_NAME, COMPANY_LEGAL_NAME):
+        slug = _slugify(raw)
+        if slug:
+            stems.add(slug)
+    if COMPANY_DOMAIN:
+        # 'acme.com' / 'www.acme.co.uk' -> 'acme'
+        host = COMPANY_DOMAIN.lower().strip().split('/')[0]
+        host = host[4:] if host.startswith('www.') else host
+        label = host.split('.')[0]
+        slug = _slugify(label)
+        if slug:
+            stems.add(slug)
+
+    ids = {'company:' + s for s in stems}
+    # Every stem is also a prefix, so a group's subsidiaries resolve without
+    # each entity being enumerated ('acme' matches 'company:acme-holdings',
+    # 'company:acme-am-uk'). This is the same reach the old hardcoded
+    # `startswith('company:<example>')` test had, keyed to the real employer
+    # instead. An operator who needs it tighter sets `own_entity_ids` in
+    # config/company.json, which is exhaustive and disables prefix reach.
+    prefixes = {'company:' + s for s in stems}
+    return ids, prefixes
+
+
+OWN_ENTITY_IDS, OWN_ENTITY_PREFIXES = _resolve_own_entity_ids(_COMPANY)
+
+
+def is_own_entity(obj):
+    """True when an entity-index object id denotes the agent's own employer.
+
+    Returns False for everything when no employer is configured — see FAIL
+    CLOSED above.
+    """
+    if not obj or not isinstance(obj, str):
+        return False
+    if obj in OWN_ENTITY_IDS:
+        return True
+    return any(obj.startswith(p) for p in OWN_ENTITY_PREFIXES)
+
+
+def legacy_relationship_value(data):
+    """Read a profile's flat "relationship to the employer" field.
+
+    The canonical key is `relationship_to_company`. Profiles written before this
+    was de-hardcoded used `relationship_to_<employer-name>`, so rather than
+    naming any one company here we accept ANY `relationship_to_*` key. That
+    resolves existing memory/profiles/ without pinning a company name into the
+    reader — a hardcoded legacy key would only work for the one deployment whose
+    name it happened to be.
+
+    Returns '' when nothing usable is present.
+    """
+    if not isinstance(data, dict):
+        return ''
+    primary = data.get('relationship_to_company')
+    if isinstance(primary, str) and primary.strip():
+        return primary
+    for key in sorted(data.keys()):
+        if not isinstance(key, str) or not key.startswith('relationship_to_'):
+            continue
+        value = data.get(key)
+        if isinstance(value, str) and value.strip():
+            return value
+    return ''
+
+
 # Data source paths
 CONTACTS_PATH = REPO_ROOT / "config" / "contacts.yaml"
 ORG_CHART_PATH = REPO_ROOT / "knowledge" / "entities" / "org-chart.md"
@@ -384,9 +530,9 @@ def lookup_entity(name, entity_index=None):
     Returns:
         dict with keys:
           - 'entity': the entity dict (or None)
-          - 'relationships_to_northwind': list of relationship dicts describing
-            this entity's relationship to Northwind/its entities
-          - 'is_internal': bool — True if entity is employed by a Northwind entity
+          - 'relationships_to_company': list of relationship dicts describing
+            this entity's relationship to the agent's employer / its entities
+          - 'is_internal': bool — True if entity is employed by one of those entities
           - 'relationship_type': str — summary classification
             ('internal', 'vendor_candidate', 'external_vendor', 'external_advisor',
              'investor', 'regulator', 'external', 'unknown')
@@ -423,19 +569,9 @@ def lookup_entity(name, entity_index=None):
     # Collect relationships where this entity is the subject
     subject_rels = rels_by_subject.get(entity_id, [])
 
-    # Determine relationship to Northwind
-    northwind_ids = {
-        'company:northwind-group', 'company:northwind-holdings',
-        'company:northwind-am-difc', 'company:northwind-technologies',
-        'company:northwind-group-investments', 'company:northwind-investments',
-        'company:northwind-inc', 'company:northwind-ai-uk',
-        'company:northwind-am-uk', 'company:northwind-am-cayman',
-        'company:northwind-am-asia', 'company:northwind-asia',
-        'company:northwind-am-eu', 'company:northwind-am-us',
-        'company:northwind-am-ksa', 'company:northwind-ksa',
-    }
-
-    rels_to_northwind = []
+    # Determine relationship to the agent's own employer (resolved from
+    # config/company.json at load — see OWN_ENTITY_IDS above).
+    rels_to_company = []
     is_internal = False
     rel_type = 'unknown'
 
@@ -443,8 +579,8 @@ def lookup_entity(name, entity_index=None):
         obj = rel.get('object', '')
         pred = rel.get('predicate', '')
 
-        if obj in northwind_ids or obj.startswith('company:northwind'):
-            rels_to_northwind.append(rel)
+        if is_own_entity(obj):
+            rels_to_company.append(rel)
 
             if pred in ('employed_by', 'directs'):
                 is_internal = True
@@ -460,7 +596,7 @@ def lookup_entity(name, entity_index=None):
             elif pred == 'regulates' and rel_type not in ('internal',):
                 rel_type = 'regulator'
 
-    # Check if entity is employed by a non-Northwind company (external person)
+    # Check if entity is employed by some OTHER company (external person)
     if rel_type == 'unknown':
         for rel in subject_rels:
             pred = rel.get('predicate', '')
@@ -470,7 +606,7 @@ def lookup_entity(name, entity_index=None):
 
     return {
         'entity': entity,
-        'relationships_to_northwind': rels_to_northwind,
+        'relationships_to_company': rels_to_company,
         'is_internal': is_internal,
         'relationship_type': rel_type,
     }
@@ -549,10 +685,12 @@ def load_user_profiles():
             # Company: identity.company or top-level
             company = _nested_get(data, 'identity', 'company') or data.get('company', '')
 
-            # Relationship type: relationship.type, or flat relationship_to_northwind, or top-level type
+            # Relationship type: relationship.type, then the flat
+            # relationship_to_* key (see legacy_relationship_value), then
+            # top-level type.
             rel_type = (
                 _nested_get(data, 'relationship', 'type')
-                or data.get('relationship_to_northwind', '')
+                or legacy_relationship_value(data)
                 or data.get('type', '')
             )
 
@@ -659,9 +797,22 @@ def check_relationship_claims(message):
         'investor', 'regulator', 'external', 'unknown',
     }
 
-    # Relationship claim patterns
+    # Relationship claim patterns.
+    # The possessive alternation is built from the RESOLVED employer name
+    # (config/company.json) rather than a hardcoded one — "Acme's engineer" is
+    # the same claim as "our engineer" and must be checked the same way. When no
+    # employer is configured the company alternative is simply absent and the
+    # generic possessives still apply.
+    possessive_alternatives = ['our', 'my', r'the company\'s', r'the team\'s']
+    for _name in (COMPANY_NAME, COMPANY_LEGAL_NAME):
+        if _name:
+            frag = re.escape(_name) + r'(?:\'s|’s)'
+            if frag not in possessive_alternatives:
+                possessive_alternatives.append(frag)
+    possessive_group = '(' + '|'.join(possessive_alternatives) + ')'
+
     claim_patterns = [
-        (r'\b(our|my|the company\'s|Northwind\'s|the team\'s)\s+'
+        (possessive_group + r'\s+'
          r'(project manager|PM|consultant|advisor|counsel|lawyer|developer|'
          r'engineer|designer|analyst|hire|employee|team member|colleague|'
          r'staff member|contractor|associate|partner|director|officer|'
@@ -925,20 +1076,33 @@ def check_title_accuracy(message):
 def check_ai_self_disclosure(message):
     """Scan for language that reveals the agent is AI.
 
-    Must NOT flag general business discussion of Northwind's AI products.
+    Must NOT flag general business discussion of the company's OWN AI products
+    ("Acme AI", "acme.ai") — those exceptions are built from the resolved
+    employer name, not a hardcoded one. With no employer configured the
+    company-specific exceptions are simply absent, which errs toward FLAGGING.
     Returns list of issue dicts.
     """
     issues = []
 
     # Business context exceptions — if these appear, the word "AI" is OK
     business_exceptions = [
-        r'AI[- ]Born', r'AI[- ]native', r'Northwind\s*AI', r'Northwind\.ai',
+        r'AI[- ]Born', r'AI[- ]native',
         r'artificial intelligence\s+strategy', r'AI\s+products?',
         r'AI\s+platform', r'AI\s+capabilit', r'machine learning\s+models?',
         r'AI[- ]driven', r'AI\s+solutions?', r'AI\s+technolog',
         r'AI\s+invest', r'AI\s+fund', r'AI\s+sector', r'AI\s+market',
         r'AI\s+infrastructure', r'AI\s+research', r'generative\s+AI',
     ]
+    # "<Employer> AI" / "<employer>.ai" — the company's own product naming.
+    for _name in (COMPANY_NAME, COMPANY_LEGAL_NAME):
+        if _name:
+            business_exceptions.append(re.escape(_name) + r'\s*AI')
+    if COMPANY_DOMAIN:
+        _host = COMPANY_DOMAIN.lower().strip().split('/')[0]
+        _host = _host[4:] if _host.startswith('www.') else _host
+        _label = _host.split('.')[0]
+        if _label:
+            business_exceptions.append(re.escape(_label) + r'\.ai')
 
     # Self-referential AI disclosure patterns
     disclosure_patterns = [