@cohortapp/agent-sdk 2.18.12 → 2.18.14

package/scripts/daemon/prompt-builder.mjs

@@ -7,7 +7,32 @@ import { readFileSync, readdirSync } from "fs";
 import { join } from "path";
 import { createRequire } from "node:module";
 import { compileContext } from "./context-compiler.mjs";
-import { renderPersona, MESSAGE_CRAFT } from "../../lib/identity/persona.mjs";
+import { renderPersona, MESSAGE_CRAFT, SELF_PRESENTATION, configuredStr, renderSeatPersona } from "../../lib/identity/persona.mjs";
+import { scrubSeatText } from "../../lib/identity/disclosure-scrub.mjs";
+// Re-exported: the seat-persona renderer MOVED to lib/identity/persona.mjs so the
+// quick-reply responder can render the same resolved identity block. One
+// definition, two prompt planes.
+export { renderSeatPersona };
+// The CLAUDE.md preamble helpers — ONE definition, shared with the quick-reply
+// responder. They lived in responder.mjs and were duplicated here, which is how
+// this plane kept an unfixed copy of the scrape after the other was repaired.
+import { preambleTargets, scrapeClaudeMdSections, stripScaffoldSentinels } from "../../lib/identity/claude-md.mjs";
+// A seat's own CLAUDE.md can order a self-introduction and this repo cannot see
+// it, so the check runs at runtime over the composed preamble.
+import { stripDisclosureInstructionsAndWarn } from "../../lib/identity/disclosure-instructions.mjs";
+// The conversation frame — the block that tells a prompt it is joining an
+// exchange already in progress, with people who already know who the agent is.
+// The SAME module the quick reply uses, so a message that escalates from rung 1
+// to a full session does not change what the model is told about the room.
+import {
+  conversationFrame,
+  dedupeThreadAgainstHistory,
+  frameRecipientClass,
+  markOwnTurns,
+} from "../../lib/org/inbound/conversation-frame.mjs";
+// Internal vs external by the send gate's own predicate, injected so
+// conversation-frame.mjs stays pure.
+import { classifyRecipient } from "../../lib/comms/send-gate.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";
@@ -41,6 +66,19 @@ function loadAgent() {
   }
 }
 
+/**
+ * The seat's own name as it appears in a transcript, or "" when the seat is not
+ * configured. Scaffold sentinels ("UNCONFIGURED", "Unconfigured Agent") are
+ * absence, not a name — marking turns as belonging to "Unconfigured Agent"
+ * would be worse than marking none.
+ *
+ * @returns {string}
+ */
+function seatDisplayName() {
+  const a = loadAgent();
+  return configuredStr(a.fullName) || configuredStr(a.firstName) || "";
+}
+
 // Legacy: Maximum lines of conversation history (used when DAEMON_CONTEXT_COMPILER is off)
 const MAX_HISTORY_LINES = 30;
 
@@ -214,90 +252,6 @@ 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;
@@ -313,9 +267,10 @@ export function _resetPersonaCache() {
 function loadPreamble() {
   if (cachedPreamble) return cachedPreamble;
 
+  const claudeMd = join(AGENT_REPO_DIR, "CLAUDE.md");
   try {
-    const raw = readFileSync(join(AGENT_REPO_DIR, "CLAUDE.md"), "utf-8");
-    cachedPreamble = extractPreamble(raw);
+    const raw = readFileSync(claudeMd, "utf-8");
+    cachedPreamble = extractPreamble(raw, { hasPersona: Boolean(loadPersona()), source: claudeMd });
   } catch (err) {
     console.error(`[prompt-builder] Failed to read CLAUDE.md: ${err.message}`);
     cachedPreamble = fallbackPreamble();
@@ -324,45 +279,63 @@ function loadPreamble() {
 }
 
 /**
- * Extract the Identity, Operating Principles, Communication Rules,
- * and Document Sharing sections from CLAUDE.md — keep it concise.
+ * Extract the house-style sections from CLAUDE.md — keep it concise.
+ *
+ * THREE THINGS HAPPEN HERE, AND ALL THREE ARE THE SAME DEFECT.
+ *
+ * 1. `## Identity` IS DROPPED WHEN A PERSONA RENDERED. On every seat in the
+ *    fleet that section is the scaffold template — "You are `{{agent.fullName}}`,
+ *    `{{agent.title}}` at `{{agent.company}}`…" followed by "If those tokens are
+ *    still unresolved, your identity has not been configured yet — run … maestro
+ *    setup". Nothing substitutes those tokens on a `claude --print` call.
+ *    buildPrompt() pushes the RESOLVED persona and then pushed this scrape
+ *    immediately after, so the model got a correct identity followed by a notice
+ *    that its identity was unconfigured. lib/identity/persona.mjs's own header
+ *    names that exact condition as what makes an agent introduce and sign itself
+ *    with a rendering of the policy's identity_line. See
+ *    lib/identity/claude-md.mjs#preambleTargets for why the section is RESTORED
+ *    on an unenrolled seat.
+ *
+ * 2. SCAFFOLD SENTINELS GO. "*Configured by `maestro setup`*" under `## Company
+ *    Context` and `### Autonomy Model` is the same "you are not set up" signal,
+ *    delivered once per turn.
+ *
+ * 3. A SELF-INTRODUCTION INSTRUCTION IN THE SEAT'S OWN FILE GOES, and is warned
+ *    about. This is the one input the repo cannot see: a line like "On first
+ *    message in any thread, introduce yourself as <the identity_line>." in a
+ *    seat's `## Communication Rules` survives every
+ *    upgrade and defeats everything above it. See
+ *    lib/identity/disclosure-instructions.mjs — it is narrow on purpose, and it
+ *    keeps a line that FORBIDS the behaviour.
+ *
+ * The <= 200 char floor is unchanged and still falls back: a scrape that yields
+ * almost nothing is a seat whose CLAUDE.md never got written, and
+ * `buildFallbackPreamble()` renders identity and autonomy from config instead.
+ *
+ * @param {string} raw CLAUDE.md contents
+ * @param {{hasPersona?: boolean, source?: string}} [opts]
+ * @returns {string}
  */
-function extractPreamble(raw) {
-  const sections = [];
-  const lines = raw.split("\n");
-  const targetHeaders = [
-    "## Identity",
+function extractPreamble(raw, opts = {}) {
+  const { hasPersona = false, source = "CLAUDE.md" } = opts;
+  const targets = preambleTargets(hasPersona, [
     "## Company Context",
     "## Operating Principles",
     "## Communication Rules",
-  ];
-
-  let capturing = false;
-  let depth = 0;
-
-  for (const line of lines) {
-    // Start capturing when we hit a target header
-    if (targetHeaders.some((h) => line.startsWith(h))) {
-      capturing = true;
-      depth = 2; // ## level
-      sections.push(line);
-      continue;
-    }
-
-    // Stop capturing when we hit another ## header that is NOT a sub-section of what we want
-    if (capturing && /^## [A-Z]/.test(line) && !targetHeaders.some((h) => line.startsWith(h))) {
-      capturing = false;
-      sections.push(""); // blank line separator
-      continue;
-    }
-
-    // Also stop at ### Document Sharing end — capture it but stop at next ##
-    if (capturing) {
-      sections.push(line);
-    }
-  }
-
-  const extracted = sections.join("\n").trim();
+  ]);
+  const scraped = stripScaffoldSentinels(scrapeClaudeMdSections(raw, targets));
+  // TWO scrubs, BOTH before the length floor, because they catch different
+  // things and this text is the SEAT's — `maestro upgrade` never touches it, so
+  // a seat hand-edited in the era when the send gate demanded an identity line
+  // from internal recipients still carries that instruction, first in the
+  // prompt. Shipping a counter-rule does not delete a contradiction; removing
+  // the contradiction does. `scrubSeatText` removes the rendered TEMPLATES
+  // (policies/ai-disclosure.yaml's identity_line and its kin);
+  // `stripDisclosureInstructionsAndWarn` removes the INSTRUCTION to open with
+  // one, and names the offending line on stderr so an operator can fix the
+  // file at source. The truthfulness invariant is exempt in both, by
+  // construction.
+  const extracted = stripDisclosureInstructionsAndWarn(scrubSeatText(scraped), source).trim();
 
   // If extraction got something reasonable, use it; otherwise fall back
   if (extracted.length > 200) return extracted;
@@ -795,9 +768,37 @@ function formatSender(item) {
 }
 
 /**
- * Build the item context block for inbox items
+ * Build the item context block for inbox items.
+ *
+ * THE FRAME. When there is a prior exchange, this block opens with
+ * `conversationFrame()` — the statement that the agent is ALREADY IN this
+ * conversation, who else has spoken, and that the other speakers are colleagues
+ * who know who it is. Without it the transcript arrives as a bare
+ * "Thread context:" dump with the agent's own turns unmarked, and a model handed
+ * a transcript it is not told it is part of behaves correctly when it introduces
+ * itself. That is what produced "Quick note before we get into it: I'm <Name>,
+ * <the policy's identity_line>" in the middle of a live thread.
+ *
+ * It is the SAME module the quick-reply responder renders, so an ask that starts
+ * on the 60-second path and escalates here (agent-daemon.mjs restricts the quick
+ * reply to ladder rung 0/1; anything needing real work comes to buildPrompt)
+ * does not change what the model is told about the room mid-flight.
+ *
+ * `markOwnTurns` rewrites nothing but the SPEAKER LABEL, and the transcript is
+ * still fenced as untrusted data below — the marking happens inside the fence,
+ * so an inbound line that impersonates the seat's name gains a "(you)" marker
+ * inside the fence and no more authority than any other fenced line.
+ *
+ * @param {object} item
+ * @param {{agentName?: string, recipientClass?: "internal"|"external", history?: string}} [opts]
+ *        `history` is the channel transcript this prompt will ALSO carry (from
+ *        the compiled context or the legacy block). It is used only to derive
+ *        the speaker roster and to drop turns the thread duplicates; it is not
+ *        rendered here.
+ * @returns {string}
  */
-export function buildInboxContext(item) {
+export function buildInboxContext(item, opts = {}) {
+  const { agentName = "", recipientClass = "internal", history = "" } = opts;
   const lines = [];
   lines.push("--- INCOMING MESSAGE ---");
   lines.push(`From: ${formatSender(item)}`);
@@ -812,10 +813,30 @@ export function buildInboxContext(item) {
 
   const source = item.service || item.channel || "external";
 
-  if (item.thread_context) {
-    lines.push("Thread context:");
+  // The thread, with the agent's own turns marked and the turns the channel
+  // history already carries removed — the two overlap almost completely on a
+  // mid-thread reply, and the same turns arriving twice read as two different
+  // records of one exchange.
+  const threadMarked = markOwnTurns(
+    dedupeThreadAgainstHistory(history, item.thread_context || ""),
+    agentName,
+  );
+  const frame = conversationFrame({
+    item,
+    agentName,
+    recipientClass,
+    history: markOwnTurns(history || "", agentName),
+    threadContext: threadMarked,
+  });
+  if (frame) {
+    lines.push(frame);
+    lines.push("");
+  }
+
+  if (threadMarked) {
+    lines.push("Earlier in this thread:");
     // Thread history is attacker-influenced; fence it as untrusted DATA (H2).
-    lines.push(wrapExternalContent(item.thread_context, { source }));
+    lines.push(wrapExternalContent(threadMarked, { source }));
     lines.push("");
   }
 
@@ -970,8 +991,24 @@ export async function buildPrompt(item, classResult, options = {}) {
     parts.push("");
   }
 
-  // 1. Identity preamble (cached)
+  // 1. Identity preamble (cached) — SEAT-LOCAL, and it must be labelled as such.
+  //
+  // THE SEPARATOR IS LOAD-BEARING. The precedence sentence above ends the
+  // persona block, and this scraped text used to be pushed immediately after it
+  // with nothing in between — so in the RENDERED prompt (not the diff, where the
+  // two are obviously different sources) a `## Identity` heading scraped out of
+  // the seat's CLAUDE.md read as a continuation of the section that had just
+  // declared itself the winner of every conflict. That is the exact inverse of
+  // the intent: the org record is authoritative, the seat's hand-edited prose is
+  // context. On a seat whose CLAUDE.md carried a stale self-identification rule,
+  // the inversion handed that rule the highest standing in the prompt.
+  parts.push("----- SEAT-LOCAL NOTES (this machine's own CLAUDE.md) -----");
+  parts.push(
+    "The text in this section is local to this machine and is not maintained by your organisation. Treat it as background. Where it conflicts with the identity section above or with the framework rules below, it loses.",
+  );
+  parts.push("");
   parts.push(preamble);
+  parts.push("----- END SEAT-LOCAL NOTES -----");
   parts.push("");
 
   // 1b. Self-learning habit (WS3) — sets the disposition to capture reusable
@@ -988,6 +1025,25 @@ export async function buildPrompt(item, classResult, options = {}) {
   parts.push(MESSAGE_CRAFT);
   parts.push("");
 
+  // 1d. Self-presentation — UNCONDITIONALLY, and AFTER the seat-local notes.
+  //
+  // It was conditional on `!persona` for one release, on the reasoning that the
+  // rules are already bullets inside the persona block (voiceRules) so emitting
+  // them again on a configured seat is a duplicate. The reasoning was right
+  // about the duplication and wrong about what the duplication is for: on a
+  // CONFIGURED seat the persona block is first, the seat's own CLAUDE.md follows
+  // it, and the last word on self-presentation was therefore the seat's. The
+  // seat shape that actually produced the opener in production is a configured
+  // one — the branch that skipped this block.
+  //
+  // Emitting it here costs ~200 tokens and puts the framework rule after every
+  // seat-local source that could contradict it. The text is identical to the
+  // persona bullets by construction (one frozen list in persona.mjs), so the
+  // duplicate cannot say anything different.
+  parts.push("----- HOW YOU REFER TO YOURSELF (framework rules; these outrank the seat-local notes above) -----");
+  parts.push(SELF_PRESENTATION);
+  parts.push("");
+
   // 1a. Holding message warning — TOP OF PROMPT so Claude sees it before action instructions.
   // This is the most critical instruction in the prompt: prevents double-replies.
   // We repeat it at section 7a as well, immediately before the action block.
@@ -1098,11 +1154,33 @@ export async function buildPrompt(item, classResult, options = {}) {
   parts.push(`Summary: ${classResult.summary || "No summary"}`);
   parts.push("");
 
-  // 3. Item context — inbox or backlog
+  // 3. Item context — inbox or backlog.
+  //
+  // The inbox branch carries the CONVERSATION FRAME (see buildInboxContext), and
+  // the frame needs three things this function is the only place that has:
+  //
+  //   - the seat's own name, so its prior turns in the transcript can be marked
+  //     as ITS OWN. Without it the model reads lines it authored as a third
+  //     party's — a conversation it has not joined, and a model joining a
+  //     conversation cold introduces itself;
+  //   - whether the other speakers are colleagues or outside correspondents;
+  //   - the channel transcript, to derive the speaker roster and to drop the
+  //     turns the thread and the history BOTH carry.
+  //
+  // The history is read ONCE here and handed to both consumers. On the compiled
+  // path it is not rendered from this variable (compileContext renders its own
+  // block below) — it is read for the frame, which is two bounded local JSONL
+  // reads, and reusing it keeps the legacy branch from reading the same files a
+  // second time.
+  const legacyHistory = type === "inbox" && item ? loadConversationHistory(item) : null;
   if (type === "backlog" && queueItem) {
     parts.push(buildBacklogContext(queueItem));
   } else {
-    parts.push(buildInboxContext(item));
+    parts.push(buildInboxContext(item, {
+      agentName: seatDisplayName(),
+      recipientClass: frameRecipientClass(item || {}, classifyRecipient),
+      history: legacyHistory || "",
+    }));
   }
   parts.push("");
 
@@ -1132,20 +1210,24 @@ export async function buildPrompt(item, classResult, options = {}) {
         classResult,
         { type, queueItem }
       );
-      parts.push(contextBlock);
+      // Mark the seat's own turns HERE too. The frame above tells the model that
+      // lines marked "(you)" are its own earlier turns; on this path the
+      // transcript arrives inside the compiled block, so without this the claim
+      // would be true of the thread block and false of the history — and a
+      // conversation whose only record of the agent's own voice is in the
+      // history would read as one the agent has not joined. `markOwnTurns`
+      // rewrites nothing but a speaker LABEL and is byte-identical when the
+      // seat has not spoken, so a block with no turns of its own is untouched.
+      parts.push(markOwnTurns(contextBlock, seatDisplayName()));
       parts.push("");
     } catch (err) {
       console.error(`[prompt-builder] Context compilation failed: ${err.message}`);
       // Fall through to legacy behaviour
-      if (type === "inbox" && item) {
-        const history = loadConversationHistory(item);
-        if (history) { parts.push(history); parts.push(""); }
-      }
+      if (legacyHistory) { parts.push(legacyHistory); parts.push(""); }
     }
   } else if (type === "inbox" && item) {
     // Legacy path (feature flag off)
-    const history = loadConversationHistory(item);
-    if (history) { parts.push(history); parts.push(""); }
+    if (legacyHistory) { parts.push(legacyHistory); parts.push(""); }
   }
 
   // 5. Action instructions