@cohortapp/agent-sdk 2.10.0 → 2.11.1

package/scripts/media-generation/brand-clause.test.mjs

@@ -0,0 +1,135 @@
+/**
+ * brand-clause.test.mjs — generated imagery must not be branded for a company
+ * that does not exist.
+ *
+ * WHAT BROKE
+ *   `buildDefaultPrompt()` appended, to EVERY illustration prompt on EVERY
+ *   deployment: "IMPORTANT: This is for <one fictional company>, an
+ *   institutional-grade AI asset management platform." — while `spec.style`,
+ *   `spec.mood` and `spec.colorPalette` three lines above were already
+ *   parameterised correctly. `gemini-image-client.mjs` then closed every
+ *   refinement pass with "... and <that company>'s brand aesthetic
+ *   requirements", re-asserting a brand the module cannot know.
+ *
+ * WHAT THESE TESTS PIN
+ *   1. GROUNDED — the brand sentence is built from config/company.json (name,
+ *      tagline, description, industry) and config/brand-assets.yaml
+ *      (usage_rules), which bin/maestro.mjs generates per agent.
+ *   2. EMPTY — nothing configured ⇒ NO brand clause is emitted at all. The
+ *      craft direction (which names no company) survives, because it is true on
+ *      any deployment. An unbranded illustration is a correct outcome.
+ *
+ * HOW IT RUNS
+ *   generate-assets.mjs imports "dotenv/config" and gemini-image-client.mjs
+ *   imports "@google/genai" — neither is a dependency of this package, so
+ *   neither module can be imported in-process. The renderers are pure, so we
+ *   lift their REAL source and evaluate it.
+ *
+ * Run: node --test scripts/media-generation/brand-clause.test.mjs
+ */
+
+"use strict";
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+
+const ASSETS_SRC = readFileSync(new URL("./generate-assets.mjs", import.meta.url), "utf8");
+const GEMINI_SRC = readFileSync(new URL("./gemini-image-client.mjs", import.meta.url), "utf8");
+
+function extractFunction(src, name, file) {
+  const re = new RegExp(`(?:export\\s+)?function\\s+${name}\\s*\\(`);
+  const m = re.exec(src);
+  assert.ok(m, `${file} 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++) {
+    if (src[i] === "{") depth++;
+    else if (src[i] === "}" && --depth === 0) return src.slice(m.index, i + 1).replace(/^export\s+/, "");
+  }
+  throw new Error(`unbalanced braces extracting ${name}`);
+}
+
+const assetNames = ["configuredStr", "buildBrandClause", "buildDefaultPrompt"];
+const assets = new Function(
+  `${assetNames.map((n) => extractFunction(ASSETS_SRC, n, "generate-assets.mjs")).join("\n\n")}\n` +
+    `return { ${assetNames.join(", ")} };`,
+)();
+const gemini = new Function(
+  `${extractFunction(GEMINI_SRC, "buildRefinementPrompt", "gemini-image-client.mjs")}\nreturn { buildRefinementPrompt };`,
+)();
+
+const { buildBrandClause, buildDefaultPrompt } = assets;
+const { buildRefinementPrompt } = gemini;
+
+const SPEC = { title: "Depot network", purpose: "Board deck cover", elements: ["a map"] };
+
+// ── GROUNDED ────────────────────────────────────────────────────────────────
+
+test("grounded: the brand sentence is built from config/company.json", () => {
+  const clause = buildBrandClause(
+    { name: "Meridian Freight", tagline: "Cold chain, unbroken", industry: "Logistics" },
+    {},
+  );
+  assert.equal(clause, "This is for Meridian Freight — Cold chain, unbroken.");
+});
+
+test("grounded: description or industry stands in when there is no tagline", () => {
+  assert.match(buildBrandClause({ name: "Meridian Freight", description: "Regional logistics." }, {}), /— Regional logistics\./);
+  assert.match(buildBrandClause({ name: "Meridian Freight", industry: "Logistics" }, {}), /— Logistics\./);
+  assert.equal(buildBrandClause({ name: "Meridian Freight" }, {}), "This is for Meridian Freight.");
+});
+
+test("grounded: config/brand-assets.yaml usage_rules pass through verbatim", () => {
+  const clause = buildBrandClause(
+    { name: "Meridian Freight" },
+    { usage_rules: { never: "stretch, rotate, recolour, or modify the assets" } },
+  );
+  assert.match(clause, /Never stretch, rotate, recolour, or modify the assets\./);
+});
+
+test("grounded: the brand clause reaches the prompt", () => {
+  const prompt = buildDefaultPrompt(SPEC, "This is for Meridian Freight — Cold chain, unbroken.");
+  assert.match(prompt, /IMPORTANT: This is for Meridian Freight — Cold chain, unbroken\./);
+  assert.match(prompt, /premium, restrained, and sophisticated/, "craft direction survives");
+});
+
+// ── EMPTY — no config, no brand claim ───────────────────────────────────────
+
+test("empty: the scaffold's UNCONFIGURED company yields NO brand clause", () => {
+  assert.equal(buildBrandClause({ name: "UNCONFIGURED", tagline: "", description: "", industry: "" }, {}), "");
+});
+
+test("empty: a missing/garbage config yields NO brand clause", () => {
+  assert.equal(buildBrandClause({}, {}), "");
+  assert.equal(buildBrandClause(null, null), "");
+  assert.equal(buildBrandClause(undefined, undefined), "");
+});
+
+test("empty: with no brand clause the prompt names NO company at all", () => {
+  const prompt = buildDefaultPrompt(SPEC, "");
+  assert.doesNotMatch(prompt, /This is for/);
+  assert.doesNotMatch(prompt, /UNCONFIGURED/);
+  // The company-agnostic craft direction is still stated — it is true anywhere.
+  assert.match(prompt, /IMPORTANT: The illustration must feel premium, restrained, and sophisticated\./);
+  assert.match(prompt, /Create an illustration for: Depot network/);
+});
+
+test("empty: buildDefaultPrompt defaults to no brand clause when called with one argument", () => {
+  assert.doesNotMatch(buildDefaultPrompt(SPEC), /This is for/);
+});
+
+// ── The refinement pass re-asserts nothing ──────────────────────────────────
+
+test("the refinement prompt preserves the brand STATED ABOVE, it does not name one", () => {
+  const out = buildRefinementPrompt("ORIGINAL PROMPT BODY", "fix the horizon line");
+  assert.match(out, /ORIGINAL PROMPT BODY/);
+  assert.match(out, /fix the horizon line/);
+  assert.match(out, /every brand and style requirement stated above/);
+});
+
+test("neither media-generation source carries a hardcoded brand", () => {
+  assert.doesNotMatch(ASSETS_SRC, /\bNorthwind\b/i);
+  assert.doesNotMatch(GEMINI_SRC, /\bNorthwind\b/i);
+  assert.doesNotMatch(ASSETS_SRC, /institutional-grade AI asset management/i);
+});

package/scripts/media-generation/gemini-image-client.mjs

@@ -1,5 +1,5 @@
 /**
- * Gemini Image Generation Client for Northwind CEO Brain
+ * Gemini Image Generation Client
  *
  * Generates branded illustrations, diagrams, and visual assets for
  * board materials, investor presentations, and corporate communications.
@@ -140,14 +140,20 @@ async function generateViaImagen(ai, model, prompt, aspectRatio) {
 }
 
 /**
- * Generate a refined image by re-generating with enhanced prompt
+ * Build the refinement prompt. Pure, so the wording is testable.
+ *
+ * The closing sentence used to name one specific company's brand aesthetic on
+ * every refinement, for every deployment. The originalPrompt ALREADY carries whatever brand direction the
+ * caller resolved from config/company.json + config/brand-assets.yaml
+ * (generate-assets.mjs#buildBrandClause), so the correct instruction here is to
+ * preserve THAT — not to re-assert a brand this module cannot know.
+ *
+ * @param {string} originalPrompt
+ * @param {string} refinementInstructions
+ * @returns {string}
  */
-export async function generateImageGeminiWithRefinement(
-  originalPrompt,
-  refinementInstructions,
-  options = {},
-) {
-  const enhancedPrompt = `${originalPrompt}
+export function buildRefinementPrompt(originalPrompt, refinementInstructions) {
+  return `${originalPrompt}
 
 ---
 
@@ -158,7 +164,18 @@ ${refinementInstructions}
 ---
 
 Generate a corrected version addressing ALL refinement instructions above while maintaining
-the original composition, concept, and Northwind brand aesthetic requirements.`;
+the original composition, concept, and every brand and style requirement stated above.`;
+}
+
+/**
+ * Generate a refined image by re-generating with enhanced prompt
+ */
+export async function generateImageGeminiWithRefinement(
+  originalPrompt,
+  refinementInstructions,
+  options = {},
+) {
+  const enhancedPrompt = buildRefinementPrompt(originalPrompt, refinementInstructions);
 
   console.log(
     `   [ImageGen] Regenerating with refinement instructions (${refinementInstructions.length} chars)`,
@@ -170,4 +187,5 @@ the original composition, concept, and Northwind brand aesthetic requirements.`;
 export default {
   generateImageGemini,
   generateImageGeminiWithRefinement,
+  buildRefinementPrompt,
 };

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/poller/inbox-scan-poller.mjs

@@ -111,6 +111,13 @@ export function parseInboxItemYaml(body) {
   if (channelType) item.channel_type = channelType;
   if (isPrivate !== undefined) item.is_private = isPrivate;
   if (isDm !== undefined) item.is_dm = isDm;
+  // THE CHANNEL KIND. Cohort's only reliable DM signal, written by
+  // scripts/poller/utils.inboxItemToYaml when present. Attached only when the
+  // writer emitted it so a non-Cohort item keeps its old shape; the daemon's
+  // enrichItem reads it to tell a 1:1 DM (skips the election) from a GROUP_DM
+  // (goes through the election as a multi-participant channel).
+  const channelKind = scalar("channel_kind");
+  if (channelKind) item.channel_kind = channelKind;
   // The hq chain kind, when the org projection carried one through the writer.
   // Attached only when present so a non-org item keeps exactly its old shape;
   // `lib/execution/intake.fromInboxItem` prefers it over the surface so an

package/scripts/poller/utils.mjs

@@ -239,6 +239,17 @@ raw_ref: "${item.raw_ref || ""}"
     yaml += `channel_id: "${item.channel_id}"\n`;
   }
 
+  // THE CHANNEL KIND (DM / GROUP_DM / PUBLIC / …). Cohort's only reliable DM
+  // signal (its channel ids are cuids, so the "D…"/"dm/" prefix heuristics never
+  // fire). Written ONLY when present so a non-Cohort item is byte-identical to
+  // before; the daemon's `enrichItem` reads it to route a 1:1 DM past the group
+  // election gate while a GROUP_DM still goes through it. Enumerated writers like
+  // this one drop anything not named here, which is exactly how the signal was
+  // lost between eventToInboxItem and parseInboxItemYaml.
+  if (item.channel_kind) {
+    yaml += `channel_kind: "${item.channel_kind}"\n`;
+  }
+
   // CONFIDENTIALITY SIGNALS. Slack's conversation-ID prefix is not a reliable
   // type indicator (a private channel can carry a `C…` id), so downstream
   // consumers — notably the daemon's fail-closed outcome gate,

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."
 
 (