@cohortapp/agent-sdk 2.10.0 → 2.11.0

package/scripts/media-generation/generate-assets.mjs

@@ -1,11 +1,18 @@
 #!/usr/bin/env node
 
 /**
- * Visual Asset Generator for Northwind CEO Brain
+ * Visual Asset Generator
  *
  * Generates branded illustrations, diagrams, and videos for
  * board materials, investor presentations, and corporate communications.
  *
+ * BRAND CONTEXT IS READ, NOT WRITTEN. The brand sentence appended to every
+ * image prompt comes from config/brand-assets.yaml (generated per agent by
+ * bin/maestro.mjs) and config/company.json (the SOT synced from Cohort). When
+ * neither is populated NO brand clause is emitted at all — an unbranded
+ * illustration is a correct outcome; one branded for a company that does not
+ * exist is not.
+ *
  * Ported from ~/company-web/app/scripts/media-generation/generate-visual-assets.mjs
  *
  * Usage:
@@ -37,6 +44,76 @@ const LOG_FILE = path.join(__dirname, "generation-log.json");
 
 const RATE_LIMIT_DELAY = 15000; // 15s between requests
 
+// ─── Brand context (config/company.json + config/brand-assets.yaml) ───
+
+/** Trimmed config string, or "" when absent/UNCONFIGURED (both mean unset). */
+export function configuredStr(v) {
+  const s = typeof v === "string" ? v.trim() : "";
+  if (!s || s.toUpperCase() === "UNCONFIGURED") return "";
+  return s;
+}
+
+/**
+ * Build the brand sentence appended to an image prompt.
+ *
+ * Pure, so the empty case is testable. Every clause is conditional: with an
+ * unpopulated config/company.json this returns "" and the caller appends
+ * nothing. It previously hardcoded one company's positioning into every
+ * generated asset on every deployment.
+ *
+ * @param {object} company parsed config/company.json
+ * @param {object} [brand] parsed config/brand-assets.yaml
+ * @returns {string} the sentence, or "" when nothing is configured
+ */
+export function buildBrandClause(company, brand) {
+  const co = company && typeof company === "object" ? company : {};
+  const br = brand && typeof brand === "object" ? brand : {};
+
+  const name = configuredStr(co.name);
+  const tagline = configuredStr(co.tagline);
+  const industry = configuredStr(co.industry);
+  const description = configuredStr(co.description);
+
+  const parts = [];
+  if (name) {
+    const gloss = tagline || description || industry;
+    parts.push(gloss ? `This is for ${name} — ${gloss}.` : `This is for ${name}.`);
+  } else if (industry) {
+    parts.push(`This is for a company in ${industry}.`);
+  }
+
+  // usage_rules from config/brand-assets.yaml are the operator's own stated
+  // rules — pass them through verbatim rather than paraphrasing them.
+  const rules = br.usage_rules && typeof br.usage_rules === "object" ? br.usage_rules : {};
+  const never = configuredStr(rules.never);
+  if (never) parts.push(`Never ${never}.`);
+
+  if (parts.length === 0) return "";
+  return parts.join(" ");
+}
+
+/** Read config/company.json. Never throws. */
+async function loadCompanyConfig() {
+  try {
+    return JSON.parse(await fs.readFile(path.join(ROOT, "config/company.json"), "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+/** Read config/brand-assets.yaml. Never throws; {} when js-yaml or file is absent. */
+async function loadBrandAssets() {
+  try {
+    const raw = await fs.readFile(path.join(ROOT, "config/brand-assets.yaml"), "utf-8");
+    const m = await import("js-yaml");
+    const yaml = m && m.default ? m.default : m;
+    const doc = yaml.load(raw);
+    return doc && typeof doc === "object" ? doc : {};
+  } catch {
+    return {};
+  }
+}
+
 // ─── Helpers ───
 
 async function loadPromptSpec(type, slug) {
@@ -95,7 +172,7 @@ async function generateIllustration(slug) {
 
   await fs.mkdir(outputDir, { recursive: true });
 
-  const prompt = spec.prompt || buildDefaultPrompt(spec);
+  const prompt = spec.prompt || buildDefaultPrompt(spec, await loadBrandContext());
   const aspectRatio = spec.aspectRatio || "16:9";
 
   const result = await generateImageGemini(prompt, { aspectRatio });
@@ -121,7 +198,21 @@ async function generateIllustration(slug) {
   return outputPath;
 }
 
-function buildDefaultPrompt(spec) {
+/**
+ * Resolve the brand clause once from the two real sources. Returns "" when
+ * neither is populated — the caller then emits no brand clause at all.
+ * @returns {Promise<string>}
+ */
+async function loadBrandContext() {
+  const [company, brand] = await Promise.all([loadCompanyConfig(), loadBrandAssets()]);
+  return buildBrandClause(company, brand);
+}
+
+/**
+ * @param {object} spec the prompt spec
+ * @param {string} [brandClause] rendered brand sentence; "" omits the clause
+ */
+export function buildDefaultPrompt(spec, brandClause = "") {
   const parts = [
     `Create an illustration for: ${spec.title}`,
     `Purpose: ${spec.purpose}`,
@@ -136,9 +227,13 @@ function buildDefaultPrompt(spec) {
     );
   }
 
-  parts.push(
-    "IMPORTANT: This is for Northwind, an institutional-grade AI asset management platform. The illustration must feel premium, restrained, and sophisticated. Avoid cartoon, isometric, or generic SaaS illustration styles.",
-  );
+  // Craft direction is framework doctrine and names no company, so it is always
+  // safe to state. The BRAND clause is only added when the config actually
+  // carries one — no config, no brand sentence.
+  const craft =
+    "IMPORTANT: The illustration must feel premium, restrained, and sophisticated. " +
+    "Avoid cartoon, isometric, or generic SaaS illustration styles.";
+  parts.push(brandClause ? `IMPORTANT: ${brandClause} ${craft.slice("IMPORTANT: ".length)}` : craft);
 
   return parts.join("\n\n");
 }
@@ -228,7 +323,7 @@ async function main() {
 
   if (args.length === 0 || args.includes("--help")) {
     console.log(`
-  Northwind Visual Asset Generator
+  Visual Asset Generator
 
   Usage:
     --illustration <slug>    Generate a single illustration

package/scripts/pre-draft-context.py

@@ -367,22 +367,98 @@ def lookup_entity(name_or_email):
 # ─────────────────────────────────────────────
 # Relationship classification
 # ─────────────────────────────────────────────
-ADAPTIC_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',
-}
+# Employer identity — resolved ONCE at load from config/company.json (the SOT
+# lib/setup/enroll-from-cohort.mjs syncs from Cohort).
+#
+# This used to be sixteen hardcoded entity ids for the framework's example
+# employer plus a matching `startswith` prefix test, so on any real deployment
+# NOTHING matched: every colleague classified as external, and the pre-draft
+# brief handed the model a wrong relationship label for its own teammates.
+#
+# FAIL CLOSED: with no employer configured the id set is EMPTY and
+# `is_own_entity()` is always False — people resolve as external/unknown, which
+# is the conservative direction for a pre-send context brief.
+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 = _load_company()
+COMPANY_NAME = _configured(_COMPANY.get('name'))
+COMPANY_LEGAL_NAME = _configured(_COMPANY.get('legalName'))
+COMPANY_DOMAIN = _configured(_COMPANY.get('domain'))
+
+
+def _slugify(value: str) -> str:
+    """'Acme Holdings, Ltd.' -> 'acme-holdings-ltd'. '' for junk."""
+    if not value:
+        return ''
+    return re.sub(r'[^a-z0-9]+', '-', value.lower()).strip('-')
+
+
+def _resolve_own_entity_ids():
+    """(ids, prefixes) for the agent's own employer. See the note above.
+
+    An explicit `own_entity_ids` list in config/company.json wins; otherwise ids
+    are derived from name / legalName / domain, with prefix reach from the
+    shortest stem so a group's subsidiaries resolve without enumeration.
+    """
+    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:
+            return ids, set()
+
+    stems = set()
+    for raw in (COMPANY_NAME, COMPANY_LEGAL_NAME):
+        slug = _slugify(raw)
+        if slug:
+            stems.add(slug)
+    if COMPANY_DOMAIN:
+        host = COMPANY_DOMAIN.lower().strip().split('/')[0]
+        host = host[4:] if host.startswith('www.') else host
+        slug = _slugify(host.split('.')[0])
+        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
+    # enumeration; `own_entity_ids` in config/company.json overrides both.
+    prefixes = {'company:' + s for s in stems}
+    return ids, prefixes
+
+
+OWN_ENTITY_IDS, OWN_ENTITY_PREFIXES = _resolve_own_entity_ids()
+
+
+def is_own_entity(obj) -> bool:
+    """True when an entity-index object id denotes the agent's own employer."""
+    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 classify_relationship(entity_id):
-    """Classify a person or company's relationship to Northwind.
+    """Classify a person or company's relationship to the agent's employer.
 
-    Returns dict: relationship_type, is_internal, relationships_to_northwind.
+    Returns dict: relationship_type, is_internal, relationships_to_company.
     """
     idx = load_entity_index()
     rels = idx['rels_by_subject'].get(entity_id, [])
@@ -394,7 +470,7 @@ def classify_relationship(entity_id):
     for rel in rels:
         obj = rel.get('object', '')
         pred = rel.get('predicate', '')
-        if obj in ADAPTIC_IDS or obj.startswith('company:northwind'):
+        if is_own_entity(obj):
             company_rels.append(rel)
             if pred in ('employed_by', 'directs'):
                 is_internal = True
@@ -419,7 +495,7 @@ def classify_relationship(entity_id):
     return {
         'relationship_type': rel_type,
         'is_internal': is_internal,
-        'relationships_to_northwind': company_rels,
+        'relationships_to_company': company_rels,
     }
 
 
@@ -813,7 +889,7 @@ def retrieve_context(recipient, topic=None):
                     'scope': r.get('scope', ''),
                     'notes': r.get('notes', ''),
                 }
-                for r in rel_info['relationships_to_northwind']
+                for r in rel_info['relationships_to_company']
             ],
         },
         'communication': {

package/scripts/spawn-session.sh

@@ -8,17 +8,31 @@
 set -e
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-SOPHIE_AI_DIR="$(dirname "$SCRIPT_DIR")"
+# The agent repo root. Renamed from the old instance-specific variable name;
+# bin/maestro.mjs already exports AGENT_DIR (and treats the old name as an
+# alias of it), so honouring the environment first is the correct precedence.
+AGENT_DIR="${AGENT_DIR:-$(dirname "$SCRIPT_DIR")}"
+
+# Real identity for the sub-session prompt. config/agent.env is generated from
+# config/agent.json by scripts/setup/generate-agent-env.mjs on every
+# `maestro upgrade` — it exists precisely so shell scripts can read the SOT.
+# Absent or unset fields stay EMPTY and their clause is dropped below; the
+# prompt never names an employer the config does not have.
+if [ -f "$AGENT_DIR/config/agent.env" ]; then
+    # shellcheck disable=SC1091
+    . "$AGENT_DIR/config/agent.env"
+fi
+
 SESSION_ID="${1:?Session ID required}"
 TASK_FILE="${2:?Task file path required}"
 TIME_BUDGET="${3:-600}"  # Default 10 minutes
 TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
 
-SESSION_DIR="$SOPHIE_AI_DIR/outputs/sessions/$SESSION_ID"
-LOG_FILE="$SOPHIE_AI_DIR/logs/sessions/$SESSION_ID.log"
+SESSION_DIR="$AGENT_DIR/outputs/sessions/$SESSION_ID"
+LOG_FILE="$AGENT_DIR/logs/sessions/$SESSION_ID.log"
 
 # Validate
-if [ -f "$SOPHIE_AI_DIR/.emergency-stop" ]; then
+if [ -f "$AGENT_DIR/.emergency-stop" ]; then
     echo "[$TIMESTAMP] BLOCKED: Emergency stop is active" >&2
     exit 1
 fi
@@ -72,12 +86,28 @@ echo "[$TIMESTAMP] Spawning session $SESSION_ID (budget: ${TIME_BUDGET}s)" | tee
 #   MAESTRO_SESSION_BACKEND=claudraband — persistent sessions via claudraband daemon
 SESSION_BACKEND="${MAESTRO_SESSION_BACKEND:-claude}"
 
+# Identity clause — assembled from config/agent.env, omitting whatever is unset.
+# "UNCONFIGURED" is what the scaffold ships, so it counts as unset too.
+_agent_name="${AGENT_FULL_NAME:-}"
+_company="${COMPANY_NAME:-}"
+# `set -e` is on: use `if`, not `[ … ] && …` (a false test would exit the script).
+if [ "$_agent_name" = "UNCONFIGURED" ]; then _agent_name=""; fi
+if [ "$_company" = "UNCONFIGURED" ]; then _company=""; fi
+
+if [ -n "$_agent_name" ] && [ -n "$_company" ]; then
+    SESSION_IDENTITY="IMPORTANT: You are a sub-session spawned for $_agent_name at $_company."
+elif [ -n "$_agent_name" ]; then
+    SESSION_IDENTITY="IMPORTANT: You are a sub-session spawned for $_agent_name."
+else
+    SESSION_IDENTITY="IMPORTANT: You are a sub-session spawned by an agent."
+fi
+
 SESSION_PROMPT="$TASK_CONTENT
 
-IMPORTANT: You are a sub-session spawned for a Northwind AI agent.
+$SESSION_IDENTITY
 Write your output to: $SESSION_DIR/output.md
 When complete, write 'DONE' to: $SESSION_DIR/complete
-Working directory: $SOPHIE_AI_DIR
+Working directory: $AGENT_DIR
 Do NOT send any communications. Only produce the requested output."
 
 (