@cohortapp/agent-sdk 2.10.0 → 2.11.0

package/scripts/daemon/classifier.mjs

@@ -71,23 +71,68 @@ try {
 // peers list. Prevents cross-agent message interception in shared channels
 // (ib-20260418-cross-agent-routing).
 
-const AGENT_DIR = process.env.AGENT_DIR || process.env.AGENT_ROOT || resolve(__dirname, "../..");
+// Resolved lazily so a test (or a re-exec that re-points AGENT_DIR) sees the
+// current value rather than whatever env the module happened to load under.
+function agentDir() {
+  return process.env.AGENT_DIR || process.env.AGENT_ROOT || resolve(__dirname, "../..");
+}
+
+/**
+ * A config value the operator has not filled in yet. config/company.json ships
+ * `"name": "UNCONFIGURED"` in the scaffold and empty strings elsewhere, so BOTH
+ * shapes mean absent.
+ * @param {*} v @returns {string}
+ */
+function configuredStr(v) {
+  const s = typeof v === "string" ? v.trim() : "";
+  // The scaffold ships SENTINELS, not blanks: config/company.json has
+  // "UNCONFIGURED", config/agent.json has "UNCONFIGURED" / "Unconfigured Agent"
+  // / "Unconfigured Role". A sentinel is an absence and must never be rendered.
+  if (!s || /^unconfigured\b/i.test(s)) return "";
+  return s;
+}
+
+/** Read config/company.json (the company SOT). Never throws. */
+function loadCompanyConfig(dir) {
+  try {
+    return JSON.parse(readFileSync(resolve(dir, "config/company.json"), "utf-8"));
+  } catch {
+    return {};
+  }
+}
 
-let _agentIdentity = null;   // { name, slackId, role, fullName, principal: {…} }
+let _agentIdentity = null;   // { name, slackId, role, fullName, company, principal: {…} }
 let _peerAgents = [];         // [{ name, slackId, role }] — all agents EXCEPT me
 
+/** For tests: drop the cached registry so a fresh AGENT_DIR is re-read. */
+export function _resetAgentRegistry() {
+  _agentIdentity = null;
+  _peerAgents = [];
+}
+
 function loadAgentRegistry() {
   if (_agentIdentity) return; // already loaded
+  const dir = agentDir();
 
   // 1. Primary: load THIS agent's identity from config/agent.json (SOT).
   try {
-    const me = JSON.parse(readFileSync(resolve(AGENT_DIR, "config/agent.json"), "utf-8"));
+    const me = JSON.parse(readFileSync(resolve(dir, "config/agent.json"), "utf-8"));
     _agentIdentity = {
-      name: me.firstName,
-      fullName: me.fullName,
+      // Scrubbed to "" when unset — each consumer then picks its own honest
+      // default (a generic noun in prose; NO match at all in the @-mention test,
+      // which must never widen because identity is missing).
+      name: configuredStr(me.firstName),
+      fullName: configuredStr(me.fullName),
       slackId: me.slackMemberId || "",
-      role: me.title || "agent",
+      role: configuredStr(me.title),
       repo: me.repoSlug,
+      // The employer, from the SAME object the name and role come from — and
+      // config/company.json when agent.json leaves it blank. It used to be
+      // a hardcoded example-company literal in the prompt below while
+      // everything around it was interpolated. INTERNAL classification comes
+      // from CONFIG, never a hardcoded company (the same doctrine as
+      // scripts/poller/gmail-poller.mjs#internalDomains).
+      company: configuredStr(me.company) || configuredStr(loadCompanyConfig(dir).name),
       principal: me.principal
         ? {
             firstName: me.principal.firstName || "the principal",
@@ -99,13 +144,14 @@ function loadAgentRegistry() {
   } catch {
     // Backwards compatibility for repos that haven't migrated yet.
     try {
-      const agentTs = readFileSync(resolve(AGENT_DIR, "config/agent.ts"), "utf-8");
+      const agentTs = readFileSync(resolve(dir, "config/agent.ts"), "utf-8");
       const nameMatch = agentTs.match(/firstName:\s*['"](\w+)['"]/);
       const slackMatch = agentTs.match(/slackMemberId:\s*['"]([^'"]+)['"]/);
       _agentIdentity = {
         name: nameMatch ? nameMatch[1] : "Agent",
         slackId: slackMatch ? slackMatch[1] : "",
         role: "agent",
+        company: configuredStr(loadCompanyConfig(dir).name),
         principal: { firstName: "the principal", fullName: "the principal", title: "principal" },
       };
     } catch {
@@ -113,6 +159,7 @@ function loadAgentRegistry() {
         name: "Agent",
         slackId: "",
         role: "agent",
+        company: configuredStr(loadCompanyConfig(dir).name),
         principal: { firstName: "the principal", fullName: "the principal", title: "principal" },
       };
     }
@@ -122,7 +169,7 @@ function loadAgentRegistry() {
   // maintains its own peer registry (shipped via `npx @cohortapp/agent-sdk upgrade`).
   let agents = [];
   try {
-    const raw = readFileSync(resolve(AGENT_DIR, "config/known-agents.json"), "utf-8");
+    const raw = readFileSync(resolve(dir, "config/known-agents.json"), "utf-8");
     agents = JSON.parse(raw).agents || [];
   } catch { /* not present — proceed without peer filtering */ }
 
@@ -131,7 +178,7 @@ function loadAgentRegistry() {
     ? agents.filter(a => a.slackId !== mySlackId)
     : agents;
 
-  console.log(`[classifier] Agent identity: ${_agentIdentity.name} (${_agentIdentity.slackId || "no slack ID"}), ${_peerAgents.length} peer agents`);
+  console.log(`[classifier] Agent identity: ${_agentIdentity.name || "(unconfigured)"} (${_agentIdentity.slackId || "no slack ID"}), ${_peerAgents.length} peer agents`);
 }
 
 const ANTHROPIC_MODEL = "claude-haiku-4-5-20251001";
@@ -142,10 +189,41 @@ const CLAUDE_CLI_TIMEOUT_MS = 30_000;
 
 // ── System prompt shared by both LLM classifiers ────────────────────────────
 
+/**
+ * The classifier's identity sentence. Pure, so the omission rule is testable.
+ *
+ * The employer is INTERPOLATED FROM CONFIG or the clause is dropped entirely —
+ * it was a hardcoded example-company literal sitting between two interpolated
+ * fields. This
+ * is not cosmetic: the classifier's `summary` is carried verbatim into
+ * assurance.composeAck (text a human reads) and board-mirror's board row title,
+ * so a fabricated employer in its frame of reference leaks into the org record.
+ *
+ * @param {{name?:string, role?:string, company?:string, principal?:object}} id
+ * @returns {string}
+ */
+export function renderClassifierIdentityLine(id) {
+  const agentName = configuredStr(id && id.name) || "the agent";
+  const agentRole = configuredStr(id && id.role) || "agent";
+  const company = configuredStr(id && id.company);
+  const p = (id && id.principal && typeof id.principal === "object") ? id.principal : {};
+  const pFull = configuredStr(p.fullName);
+  const pTitle = configuredStr(p.title);
+
+  const at = company ? ` at ${company}` : "";
+  const lines = [`You are a message classifier for ${agentName}, ${agentRole} (AI-operated)${at}.`];
+  // Only assert a principal when one is actually on record — the loader's
+  // "the principal" placeholder is an absence, not a person.
+  if (pFull && pFull !== "the principal") {
+    const who = pTitle && pTitle !== "principal" ? `${pTitle} ${pFull}` : pFull;
+    lines.push(`${agentName} is the autonomous executive command layer for ${who}.`);
+  }
+  return lines.join(" ");
+}
+
 function buildSystemPrompt() {
   loadAgentRegistry();
-  const agentName = _agentIdentity.name;
-  const agentRole = _agentIdentity.role || "agent";
+  const agentName = configuredStr(_agentIdentity.name) || "the agent";
   const principalName = _agentIdentity.principal.firstName;
   const principalFullName = _agentIdentity.principal.fullName;
   const principalTitle = _agentIdentity.principal.title;
@@ -155,7 +233,7 @@ function buildSystemPrompt() {
     ? `\nKNOWN PEER AGENTS (other AI agents in the organisation — if a message @-mentions one of these by name or Slack ID, it is NOT directed at ${agentName}):\n${_peerAgents.map(a => `- ${a.name} (${a.role}, Slack: <@${a.slackId}>)`).join("\n")}\n`
     : "";
 
-  return `You are a message classifier for ${agentName}, ${agentRole} (AI-operated) at Northwind. ${agentName} is the autonomous executive command layer for ${principalTitle} ${principalFullName}.
+  return `${renderClassifierIdentityLine(_agentIdentity)}
 
 Your job: classify each incoming message and return a JSON object with exactly these fields:
 
@@ -212,7 +290,7 @@ DIRECTED_AT_AGENT (CRITICAL — determines whether ${agentName} should respond.
 
 Context:
 - sender_privilege "ceo" = ${principalFullName} (always critical, always opus)
-- sender_privilege "leadership" = Sam (CFO/CIO/SEO), Jordan (GC), Casey (PartnerCo) — usually high priority
+- sender_privilege "leadership" = executive-team senders (CFO, CIO, General Counsel, and equivalent function heads) — usually high priority
 - sender_privilege "team" = internal team members
 - sender_privilege "external" = partners, candidates, advisors, vendors
 - sender_privilege "unknown" = unrecognised sender
@@ -273,7 +351,7 @@ function formatItemPrompt(item) {
   ];
   // Indicate channel type so the classifier can assess directed-ness
   loadAgentRegistry();
-  const agentName = _agentIdentity.name;
+  const agentName = configuredStr(_agentIdentity.name) || "the agent";
   if (item.is_dm) {
     parts.push(`Channel type: Direct message (1:1 with ${agentName})`);
   } else if (item.is_group) {
@@ -530,10 +608,13 @@ function isDirectedAtAgent(item) {
 
   // Explicit @mention or name mention in the message content
   const content = (item.content || "").toLowerCase();
-  const myName = (_agentIdentity.name || "agent").toLowerCase();
+  // FAIL CLOSED on an unconfigured name. The old fallback was the bare word
+  // "agent", so an unnamed seat matched any message containing "agent" and
+  // treated it as addressed to itself. No name on record ⇒ no name match.
+  const myName = configuredStr(_agentIdentity.name).toLowerCase();
   const mySlackId = (_agentIdentity.slackId || "").toLowerCase();
 
-  if (content.includes(myName)) return true;
+  if (myName && content.includes(myName)) return true;
   if (mySlackId && content.includes(mySlackId.toLowerCase())) return true;
 
   // Gmail/calendar messages are directed at the current agent (they're in its inbox)
@@ -630,7 +711,7 @@ function classifyWithRules(item) {
 }
 
 // Export for use in daemon's pre-classification gate
-export { isDirectedAtAgent, mentionsOtherAgent, loadAgentRegistry };
+export { isDirectedAtAgent, mentionsOtherAgent, loadAgentRegistry, buildSystemPrompt };
 
 // ── Main export ─────────────────────────────────────────────────────────────
 

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

@@ -0,0 +1,210 @@
+/**
+ * prompt-builder-preamble.test.mjs — the fallback preamble must not FABRICATE
+ * authority.
+ *
+ * WHAT BROKE
+ *   `buildFallbackPreamble()` used to hardcode an autonomy grant:
+ *     "<Agent> sends autonomously: all internal messages, external operational
+ *      messages, candidate comms, follow-ups, calendar coordination"
+ *   read from nowhere. It fires 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. It also stated "You are <name>, <title> at
+ *   <company>" with `company` interpolated unconditionally.
+ *
+ * WHAT THESE TESTS PIN
+ *   1. GROUNDED PATH — with a real config/agent.json + config/company.json + a
+ *      GENERATED policies/action-classification.yaml, every band in the preamble
+ *      comes from those files.
+ *   2. EMPTY PATH — with the scaffold's UNCONFIGURED config and no generated
+ *      policy, the preamble asserts NO employer, NO autonomy grant, and says
+ *      draft-not-send. Nothing is invented.
+ *   3. The hand-written TEMPLATE action-classification.yaml (which grants "fully
+ *      autonomous executive operator" to every seat) is treated as ABSENT.
+ *
+ * Run: node --test scripts/daemon/prompt-builder-preamble.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 {
+  buildFallbackPreamble,
+  loadSeatAutonomyPolicy,
+  renderAutonomySection,
+} from "./prompt-builder.mjs";
+
+/** A repo root with whatever files the case needs. */
+function seat(files) {
+  const root = mkdtempSync(join(tmpdir(), "seat-"));
+  for (const [rel, body] of Object.entries(files)) {
+    const abs = join(root, rel);
+    mkdirSync(join(abs, ".."), { recursive: true });
+    writeFileSync(abs, body);
+  }
+  return root;
+}
+
+const SCAFFOLD_AGENT = JSON.stringify({
+  firstName: "UNCONFIGURED",
+  lastName: "AGENT",
+  fullName: "Unconfigured Agent",
+  title: "Unconfigured Role",
+  company: "",
+  principal: { firstName: "", fullName: "", title: "" },
+  responsibilities: [],
+  operatingPrinciples: [],
+});
+const SCAFFOLD_COMPANY = JSON.stringify({ name: "UNCONFIGURED", description: "", products: [] });
+
+const REAL_AGENT = JSON.stringify({
+  firstName: "Robin",
+  lastName: "Okafor",
+  fullName: "Robin Okafor",
+  title: "VP Operations",
+  altitude: "vp",
+  company: "",
+  principal: { firstName: "Dana", fullName: "Dana Lee", title: "CEO" },
+  responsibilities: ["Run the ops cadence"],
+  operatingPrinciples: ["Close the loop on every commitment"],
+});
+const REAL_COMPANY = JSON.stringify({ name: "Meridian Freight", description: "Regional logistics." });
+
+/** What scripts/setup/generate-autonomy.mjs writes — note archetype + delegation_breadth. */
+const GENERATED_POLICY = `
+archetype: operations@vp
+autonomy_default: execute
+delegation_breadth: moderate
+action_levels:
+  execute_autonomous:
+    examples:
+      - Reschedule internal meetings
+  approval_preferred:
+    examples:
+      - Send a quote to a customer
+  escalate:
+    examples:
+      - Sign a supplier contract
+    escalate_to:
+      - principal
+decision_rights:
+  - id: dr-1
+    scope: Carrier selection
+    authority: decide
+`;
+
+/** The hand-written framework TEMPLATE — no archetype, no delegation_breadth. */
+const TEMPLATE_POLICY = `
+action_levels:
+  execute_autonomous:
+    description: Operational actions the agent executes on its own authority.
+    examples:
+      - Send emails in the agent's voice to any recipient
+      - Send candidate communications (outreach, scheduling, offers, rejections)
+`;
+
+// ── 1. GROUNDED PATH ────────────────────────────────────────────────────────
+
+test("grounded: identity, employer and every autonomy band come from the real files", () => {
+  const root = seat({
+    "config/agent.json": REAL_AGENT,
+    "config/company.json": REAL_COMPANY,
+    "policies/action-classification.yaml": GENERATED_POLICY,
+  });
+  const out = buildFallbackPreamble(root);
+
+  assert.match(out, /You are Robin Okafor, VP Operations at Meridian Freight\./);
+  assert.match(out, /You report to Dana Lee, CEO\./);
+  assert.match(out, /Close the loop on every commitment/, "operating principles come from config");
+
+  assert.match(out, /generated for archetype operations@vp/);
+  assert.match(out, /You act on your own authority: Reschedule internal meetings/);
+  assert.match(out, /You get agreement first: Send a quote to a customer/);
+  assert.match(out, /You escalate and do NOT act alone: Sign a supplier contract/);
+  assert.match(out, /Escalate to: principal/);
+  assert.match(out, /Decision right — Carrier selection \(decide\)/);
+
+  // The fabricated grant is gone, verbatim.
+  assert.doesNotMatch(out, /sends autonomously/i);
+  assert.doesNotMatch(out, /all internal messages, external operational messages/i);
+  assert.doesNotMatch(out, /Full autonomy, full accountability/i);
+
+  rmSync(root, { recursive: true, force: true });
+});
+
+// ── 2. EMPTY PATH — nothing configured means nothing asserted ────────────────
+
+test("empty: an unconfigured seat gets NO employer and NO autonomy grant", () => {
+  const root = seat({
+    "config/agent.json": SCAFFOLD_AGENT,
+    "config/company.json": SCAFFOLD_COMPANY,
+  });
+  const out = buildFallbackPreamble(root);
+
+  // No invented employer anywhere — including the scaffold's own sentinel.
+  assert.doesNotMatch(out, /UNCONFIGURED/);
+  assert.doesNotMatch(out, / at \./, "no dangling 'at <blank>' clause");
+
+  // No grant of any kind.
+  assert.doesNotMatch(out, /sends autonomously/i);
+  assert.doesNotMatch(out, /You act on your own authority/);
+  assert.doesNotMatch(out, /escalates only/i);
+
+  // Fail closed, and say why.
+  assert.match(out, /NO AUTONOMY POLICY IS CONFIGURED FOR THIS SEAT/);
+  assert.match(out, /Draft, do not send/);
+  assert.match(out, /Nothing here grants that\./);
+
+  rmSync(root, { recursive: true, force: true });
+});
+
+test("empty: a repo with NO config at all still produces a safe, non-fabricated preamble", () => {
+  const root = seat({});
+  const out = buildFallbackPreamble(root);
+  assert.doesNotMatch(out, /You are .* at /, "no identity is asserted");
+  assert.match(out, /NO AUTONOMY POLICY IS CONFIGURED/);
+  assert.match(out, /Draft, do not send/);
+  rmSync(root, { recursive: true, force: true });
+});
+
+// ── 3. The template is NOT ground truth ─────────────────────────────────────
+
+test("the framework TEMPLATE action-classification.yaml is treated as ABSENT", () => {
+  const root = seat({
+    "config/agent.json": REAL_AGENT,
+    "config/company.json": REAL_COMPANY,
+    "policies/action-classification.yaml": TEMPLATE_POLICY,
+  });
+  assert.equal(loadSeatAutonomyPolicy(root), null, "no archetype/delegation_breadth ⇒ not this seat's policy");
+
+  const out = buildFallbackPreamble(root);
+  assert.match(out, /NO AUTONOMY POLICY IS CONFIGURED FOR THIS SEAT/);
+  assert.doesNotMatch(
+    out,
+    /Send candidate communications/,
+    "the template's maximal grant must never reach a prompt",
+  );
+  rmSync(root, { recursive: true, force: true });
+});
+
+test("a GENERATED policy whose bands are all empty grants nothing", () => {
+  const section = renderAutonomySection({
+    archetype: "ops@vp",
+    delegation_breadth: "narrow",
+    action_levels: { execute_autonomous: { examples: [] }, approval_preferred: {}, escalate: {} },
+    decision_rights: [],
+  });
+  assert.match(section, /declares no bands/);
+  assert.match(section, /draft, do not send/i);
+});
+
+test("loadSeatAutonomyPolicy never throws on malformed YAML", () => {
+  const root = seat({ "policies/action-classification.yaml": "::: not: [valid" });
+  assert.equal(loadSeatAutonomyPolicy(root), null);
+  rmSync(root, { recursive: true, force: true });
+});