@cgh567/agent 2.4.1 → 2.4.2

package/lib/compression/dist/smart-crusher.js

@@ -0,0 +1,251 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmartCrusher = exports.DEFAULT_CRUSHER_CONFIG = void 0;
+/**
+ * lib/compression/smart-crusher.ts
+ *
+ * TypeScript implementation of the Headroom SmartCrusher algorithm.
+ *
+ * SmartCrusher compresses JSON arrays by:
+ *   1. Lossless path: for homogeneous arrays, render as CSV+schema (removes
+ *      repeated key names).  Wins when savings ≥ 15%.
+ *   2. Lossy path: keep first 30% + last 15% + importance-scored middle 55%.
+ *      Dropped rows are stored in the CCR store and retrievable on demand.
+ *
+ * Ported from headroom/crates/headroom-core (Rust) algorithm.
+ * No external dependencies — pure TypeScript.
+ *
+ * Every company's HBO data (signals, leads, pipeline, tasks, goals) flows
+ * through this compressor before reaching the LLM, reducing token cost
+ * by 70–92% for typical array payloads.
+ */
+const crypto_1 = require("crypto");
+exports.DEFAULT_CRUSHER_CONFIG = {
+    minItemsToAnalyze: 5,
+    minCharsToCompress: 200,
+    maxItemsAfterCrush: 15,
+    firstFraction: 0.3,
+    lastFraction: 0.15,
+    losslessMinSavingsRatio: 0.15,
+    compactionCoreFieldFraction: 0.8,
+};
+// ── Helpers ───────────────────────────────────────────────────────────────────
+function shortHash(data) {
+    return (0, crypto_1.createHash)('sha256').update(data).digest('hex').slice(0, 12);
+}
+/**
+ * Check if an array is homogeneous enough for lossless CSV compaction.
+ *
+ * Conditions (all must be true):
+ *   1. ≥90% of items are plain objects
+ *   2. At least 3 fields appear in ≥ coreFieldFraction of items
+ *      (single shared field like 'id' is not enough structure for CSV)
+ *   3. Core fields cover ≥50% of the average object's field count
+ *      (prevents trivial matches where most fields are non-shared)
+ */
+function isHomogeneousArray(items, coreFieldFraction) {
+    if (items.length === 0)
+        return { homogeneous: false, coreFields: [] };
+    const objectItems = items.filter((x) => x !== null && typeof x === 'object' && !Array.isArray(x));
+    if (objectItems.length / items.length < 0.9) {
+        return { homogeneous: false, coreFields: [] };
+    }
+    // Count field frequencies
+    const fieldFreq = new Map();
+    let totalFields = 0;
+    for (const obj of objectItems) {
+        const keys = Object.keys(obj);
+        totalFields += keys.length;
+        for (const key of keys) {
+            fieldFreq.set(key, (fieldFreq.get(key) ?? 0) + 1);
+        }
+    }
+    // Core fields: appear in ≥ coreFieldFraction of objects
+    const threshold = objectItems.length * coreFieldFraction;
+    const coreFields = [...fieldFreq.entries()]
+        .filter(([, count]) => count >= threshold)
+        .map(([key]) => key)
+        .sort();
+    // Gate 1: must have at least 3 core fields
+    // A single shared key (like 'id') is not enough structure for meaningful CSV
+    if (coreFields.length < 3) {
+        return { homogeneous: false, coreFields: [] };
+    }
+    // Gate 2: core fields must cover ≥50% of the average object's field count
+    // Prevents trivial CSV on objects where most fields are non-shared
+    const avgFieldCount = totalFields / objectItems.length;
+    const coverage = coreFields.length / avgFieldCount;
+    if (coverage < 0.5) {
+        return { homogeneous: false, coreFields: [] };
+    }
+    return { homogeneous: true, coreFields };
+}
+/**
+ * Lossless CSV compaction for homogeneous arrays.
+ * Format: header row + value rows, tab-separated within each row,
+ * pipe-separated rows. Significantly reduces token count for repeated keys.
+ */
+function losslessCsvCompress(items, coreFields) {
+    const header = coreFields.join('\t');
+    const rows = items.map((item) => coreFields
+        .map((f) => {
+        const v = item[f];
+        if (v === null || v === undefined)
+            return '';
+        if (typeof v === 'object')
+            return JSON.stringify(v);
+        return String(v);
+    })
+        .join('\t'));
+    return `[csv:${coreFields.length}cols×${items.length}rows]\n${header}\n${rows.join('\n')}`;
+}
+/**
+ * Score items for importance. Higher = more important to keep.
+ * Keeps items that: have errors, have non-null/non-zero values,
+ * or are at structural boundaries (first/last).
+ * Mid-range items are scored by field diversity (more unique values = more important).
+ */
+function scoreItems(items) {
+    return items.map((item) => {
+        let score = 0;
+        const str = JSON.stringify(item);
+        // Error/anomaly signals — always preserve
+        if (str.includes('"error"') ||
+            str.includes('"failed"') ||
+            str.includes('"ERROR"') ||
+            str.includes('"FAILED"')) {
+            score += 100;
+        }
+        // Non-trivial values (not null, not 0, not empty string)
+        const values = Object.values(item);
+        const nonTrivial = values.filter((v) => v !== null && v !== undefined && v !== '' && v !== 0 && v !== false).length;
+        score += (nonTrivial / Math.max(values.length, 1)) * 10;
+        // Field diversity (unique values signal interesting data)
+        const uniqueVals = new Set(values.map((v) => JSON.stringify(v))).size;
+        score += (uniqueVals / Math.max(values.length, 1)) * 5;
+        return score;
+    });
+}
+// ── Main SmartCrusher ─────────────────────────────────────────────────────────
+class SmartCrusher {
+    cfg;
+    constructor(config = {}) {
+        this.cfg = { ...exports.DEFAULT_CRUSHER_CONFIG, ...config };
+    }
+    /**
+     * Compress a JSON array string.
+     * If input is not a JSON array, returns passthrough.
+     * If array is too small, returns passthrough.
+     * Otherwise attempts lossless CSV then lossy sampling.
+     */
+    compress(input, ccrStore) {
+        const passthrough = {
+            output: input,
+            compressed: false,
+            strategy: 'passthrough',
+            ccrHash: null,
+            rowsDropped: 0,
+            originalCount: 0,
+            keptCount: 0,
+        };
+        // Gate: too short
+        if (input.length < this.cfg.minCharsToCompress)
+            return passthrough;
+        // Parse JSON
+        let parsed;
+        try {
+            parsed = JSON.parse(input);
+        }
+        catch {
+            return passthrough;
+        }
+        // Must be a non-empty array
+        if (!Array.isArray(parsed) || parsed.length < this.cfg.minItemsToAnalyze) {
+            return passthrough;
+        }
+        const items = parsed;
+        // ── Lossless path ────────────────────────────────────────────────────────
+        const { homogeneous, coreFields } = isHomogeneousArray(items, this.cfg.compactionCoreFieldFraction);
+        if (homogeneous) {
+            const objectItems = items.filter((x) => x !== null && typeof x === 'object' && !Array.isArray(x));
+            const losslessOutput = losslessCsvCompress(objectItems, coreFields);
+            const savingsRatio = 1 - losslessOutput.length / input.length;
+            if (savingsRatio >= this.cfg.losslessMinSavingsRatio) {
+                return {
+                    output: losslessOutput,
+                    compressed: true,
+                    strategy: 'lossless-csv',
+                    ccrHash: null,
+                    rowsDropped: 0,
+                    originalCount: items.length,
+                    keptCount: items.length,
+                };
+            }
+        }
+        // ── Lossy path ───────────────────────────────────────────────────────────
+        const n = items.length;
+        const maxKeep = this.cfg.maxItemsAfterCrush;
+        if (n <= maxKeep) {
+            // Already small enough — check if lossless was worth it
+            return passthrough;
+        }
+        const firstCount = Math.max(1, Math.floor(n * this.cfg.firstFraction));
+        const lastCount = Math.max(1, Math.floor(n * this.cfg.lastFraction));
+        const midBudget = Math.max(0, maxKeep - firstCount - lastCount);
+        const firstItems = items.slice(0, firstCount);
+        const lastItems = items.slice(n - lastCount);
+        const midItems = items.slice(firstCount, n - lastCount);
+        // Score mid-range items and keep the most important
+        const objectMidItems = midItems.filter((x) => x !== null && typeof x === 'object' && !Array.isArray(x));
+        let keptMid;
+        let droppedMid;
+        if (objectMidItems.length > 0 && midBudget > 0) {
+            const scores = scoreItems(objectMidItems);
+            const indexed = scores.map((s, i) => ({ s, i }));
+            indexed.sort((a, b) => b.s - a.s);
+            const keepIndices = new Set(indexed.slice(0, midBudget).map((x) => x.i));
+            keptMid = objectMidItems.filter((_, i) => keepIndices.has(i));
+            droppedMid = objectMidItems.filter((_, i) => !keepIndices.has(i));
+            // Dedup: remove items from keptMid that are identical to firstItems or lastItems
+            const existingSet = new Set([...firstItems, ...lastItems].map((x) => JSON.stringify(x)));
+            keptMid = keptMid.filter((x) => !existingSet.has(JSON.stringify(x)));
+        }
+        else {
+            keptMid = midBudget > 0 ? midItems.slice(0, midBudget) : [];
+            droppedMid = midItems.slice(midBudget);
+        }
+        const keptItems = [...firstItems, ...keptMid, ...lastItems];
+        const droppedItems = droppedMid;
+        const rowsDropped = droppedItems.length;
+        // Store dropped rows in CCR
+        let ccrHash = null;
+        if (rowsDropped > 0 && ccrStore) {
+            const droppedJson = JSON.stringify(droppedItems);
+            ccrHash = shortHash(droppedJson);
+            ccrStore.set(ccrHash, droppedJson);
+        }
+        // Build output
+        const ccrMarker = ccrHash && rowsDropped > 0
+            ? `\n{"_ccr_dropped":"<<ccr:${ccrHash} ${rowsDropped}_rows_offloaded>>"}`
+            : '';
+        const output = JSON.stringify(keptItems) + ccrMarker;
+        const savingsRatio = 1 - output.length / input.length;
+        // Only return lossy result if it actually saved something meaningful
+        if (savingsRatio < this.cfg.losslessMinSavingsRatio) {
+            // Clean up CCR entry — not worth it
+            if (ccrHash && ccrStore)
+                ccrStore.delete(ccrHash);
+            return passthrough;
+        }
+        return {
+            output,
+            compressed: true,
+            strategy: 'lossy-sample',
+            ccrHash,
+            rowsDropped,
+            originalCount: items.length,
+            keptCount: keptItems.length,
+        };
+    }
+}
+exports.SmartCrusher = SmartCrusher;

package/lib/graph/lib/utils.js

@@ -468,7 +468,7 @@ async function mgQueryAsync(cypher, params = {}, opts = {}) {
         let _queryTimer;
         const result = await Promise.race([
           session.run(cleanCypher, params),
-          new Promise((_, rej) => { _queryTimer = setTimeout(() => rej(new Error('direct bolt query timeout (15s)')), 15000); })
+          new Promise((_, rej) => { _queryTimer = setTimeout(() => rej(new Error('direct bolt query timeout (15s)')), parseInt(process.env.HELIOS_BOLT_QUERY_TIMEOUT_MS || '25000', 10)); })
         ]);
         clearTimeout(_queryTimer);
         const keys = result.records.length > 0 ? result.records[0].keys : [];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cgh567/agent",
-  "version": "2.4.1",
-  "description": "Helios agent runtime — full stack: extensions, skills, daemon, brain-v2, HEMA, governance",
+  "version": "2.4.2",
+  "description": "Helios agent runtime \u2014 full stack: extensions, skills, daemon, brain-v2, HEMA, governance",
   "type": "commonjs",
   "bin": {
     "helios-rpc": "./bin/helios-rpc.cjs",
@@ -10,6 +10,7 @@
   },
   "scripts": {
     "build": "node scripts/build-brain-service.js",
+    "build:compression": "node node_modules/typescript/bin/tsc -p lib/compression/tsconfig.json",
     "postinstall": "node postinstall.cjs || echo '[helios-agent] postinstall skipped'",
     "patch-aliases": "node scripts/patch-pi-aliases.js",
     "update": "helios update",
@@ -25,7 +26,12 @@
     "test:hbo-wizard": "node tests/hbo/wizard-infra-gate.test.js && node tests/hbo/wizard-provider-validation.test.js && node tests/hbo/wizard-company-creation.test.js",
     "test:harbor": "python3 -m pytest evals/harbor/ -v --timeout=60 --tb=short",
     "test:harada": "python3 -m pytest evals/harbor/test_harada.py -v --timeout=60 --tb=short",
-    "test:harbor:all": "python3 -m pytest evals/harbor/ -v --timeout=60 --tb=short"
+    "test:harbor:all": "python3 -m pytest evals/harbor/ -v --timeout=60 --tb=short",
+    "test:compression": "python3 -m pytest evals/harbor/test_compression.py -v --tb=short",
+    "db:migrate-hbo": "node --experimental-sqlite daemon/db/hbo-core-migrate.js",
+    "db:migrate-all": "node --experimental-sqlite daemon/db/email-infrastructure-migrate.js && node --experimental-sqlite daemon/db/hbo-core-migrate.js",
+    "test:hbo-store": "node --experimental-sqlite lib/__tests__/hbo-core-store.test.js",
+    "test:hbo-fallback": "NODE_OPTIONS=--experimental-sqlite npx vitest run daemon/__tests__/hbo-core-fallback.test.js"
   },
   "pi": {
     "extensions": [
@@ -79,6 +85,7 @@
     "croner": "^9.0.0",
     "ghost-cursor": "^1.4.2",
     "googleapis": "^171.4.0",
+    "headroom-ai": "^0.22.4",
     "httpsms": "^0.0.4",
     "ioredis": "^5.10.1",
     "js-tiktoken": "^1.0.21",
@@ -94,7 +101,6 @@
     "tree-sitter-javascript": "^0.25.0",
     "tree-sitter-python": "^0.25.0",
     "tree-sitter-typescript": "^0.23.2",
-    "headroom-ai": "^0.22.4",
     "write-file-atomic": "^7.0.1"
   },
   "devDependencies": {

package/skills/talisman-ceo/SKILL.md

@@ -1,15 +1,13 @@
 ---
 disableModelInvocation: true
 name: talisman-ceo
-description: CEO/Strategy agent for Talisman — weekly planning, goal decomposition, department delegation
+description: CEO/Strategy agent — weekly planning, goal decomposition, department delegation
 when: Loaded by the CEO agent on all planning, review, and delegation tasks
 adapter:
   type: helios_rpc
   skills:
     - helios-prime
     - helios-business-operator
-agent_id: "agent:ceo"
-company_id: talisman
 departments:
   - Strategy
   - Engineering
@@ -30,14 +28,14 @@ If **YES** → Check the approval first. Do NOT start new planning cycles while
 ### ✅ Example of Good CEO Output:
 ```
 Weekly Plan — Week of 2026-05-19
-Goal: Ship Talisman v1.2 (30% complete)
+Goal: Grow revenue 30% this quarter (30% complete)
 
 Delegated This Week:
-- Engineering: Implement bank statement auto-import (priority: P1)
+- Engineering: Implement key product feature (priority: P1)
 - Sales: Follow up on 3 warm leads from last week (priority: P2)
-- Marketing: Draft blog post "5 Signs Your Accounting Firm Needs Automation" (priority: P3)
+- Marketing: Draft blog post on company value proposition (priority: P3)
 
-Pending Approvals: 1 (promote v1.1 to production — review before EOD)
+Pending Approvals: 1 (review before EOD)
 Budget Status: ✅ 42% used ($25/$60 monthly)
 ```
 
@@ -47,20 +45,20 @@ Budget Status: ✅ 42% used ($25/$60 monthly)
 
 **Step 1**: Query Memgraph for all pending approvals and current goal progress
 ```cypher
-MATCH (a:Approval {status: 'pending'}) RETURN a.title, a.type, a.createdAt;
-MATCH (g:Goal {companyId: 'talisman'}) WHERE g.status <> 'completed' RETURN g.title, g.level, g.status;
+MATCH (a:Approval {companyId: $HELIOS_COMPANY_ID, status: 'pending'}) RETURN a.title, a.type, a.createdAt;
+MATCH (g:CompanyGoal {companyId: $HELIOS_COMPANY_ID}) WHERE g.status <> 'completed' RETURN g.title, g.status;
 ```
 
 **Step 2**: Query all department statuses (Task counts by status for each department)
 ```cypher
-MATCH (t:Task {companyId: 'talisman'})
+MATCH (t:Task {companyId: $HELIOS_COMPANY_ID})
 WHERE t.status IN ['todo', 'in_progress', 'blocked']
 RETURN t.status, count(t) AS count;
 ```
 
 **Step 3**: Check budget health
-```bash
-cat ~/helios-agent/brainv2/budget-status.json
+```cypher
+MATCH (bp:BudgetPolicy {companyId: $HELIOS_COMPANY_ID}) RETURN bp.scope, bp.agentId, bp.limitCents, bp.spentCents, bp.percentUsed, bp.status
 ```
 
 ---
@@ -99,7 +97,7 @@ Company Goal (e.g., "Ship Talisman v1.2")
               └── Task (e.g., "Implement CSV parser for Chase format")
 ```
 
-- Goals must have: `title`, `level`, `status`, `companyId: 'talisman'`, `ownerId` (dept)
+- Goals must have: `title`, `level`, `status`, `companyId: $HELIOS_COMPANY_ID`, `ownerId` (dept)
 - Tasks must have: `title`, `priority`, `acceptanceCriteria`, `assignedTo` (dept head), `dueDate`
 - Never create a task without acceptance criteria
 
@@ -178,7 +176,7 @@ Approval gates. Your job is quality reviewer:
 - Any external payment processing → Approval required
 - New vendor agreements → Approval required
 - Budget override requests → Approval required
-- Approval node schema: `{title, type, status: 'pending', requestedBy, createdAt, companyId: 'talisman'}`
+- Approval node schema: `{title, type, status: 'pending', requestedBy, createdAt, companyId: $HELIOS_COMPANY_ID}`
 
 **Goal Rules:**
 - Goals have 4 levels: Company → Department → Project → Task
@@ -192,7 +190,7 @@ Approval gates. Your job is quality reviewer:
 - P2/P3 messages: handle in daily triage — batch processing OK
 
 **Budget Rules:**
-- Budget source of truth: `~/helios-agent/brainv2/budget-status.json`
+- Budget source of truth: Memgraph `MATCH (bp:BudgetPolicy {companyId: $HELIOS_COMPANY_ID})`
 - Alert threshold: 80% of monthly budget consumed
 - Hard stop: 95% — no new tasks until next billing cycle
 - Finance dept owns budget recovery plans
@@ -217,10 +215,10 @@ Before completing any planning cycle:
 ```cypher
 CREATE (wp:WeeklyPlan {
   id: randomUUID(),
-  companyId: 'talisman',
+  companyId: $HELIOS_COMPANY_ID,
   weekOf: date(),
   status: 'active',
-  createdBy: 'agent:ceo',
+  createdBy: $HELIOS_AGENT_ID,
   createdAt: datetime()
 });
 ```
@@ -229,7 +227,7 @@ CREATE (wp:WeeklyPlan {
 ```cypher
 CREATE (t:Task {
   id: randomUUID(),
-  companyId: 'talisman',
+  companyId: $HELIOS_COMPANY_ID,
   title: $title,
   priority: toInteger($priority),
   status: 'todo',
@@ -238,7 +236,7 @@ CREATE (t:Task {
   acceptanceCriteria: $criteria,
   dueDate: $dueDate,
   originKind: 'ceo_delegation',
-  createdBy: 'agent:ceo',
+  createdBy: $HELIOS_AGENT_ID,
   createdAt: localDateTime()
 });
 ```
@@ -247,18 +245,18 @@ CREATE (t:Task {
 ```cypher
 CREATE (a:Approval {
   id: randomUUID(),
-  companyId: 'talisman',
+  companyId: $HELIOS_COMPANY_ID,
   title: $title,
   type: $type,
   status: 'pending',
-  requestedBy: 'agent:ceo',
+  requestedBy: $HELIOS_AGENT_ID,
   createdAt: datetime()
 });
 ```
 
 ### Flag At-Risk Goal
 ```cypher
-MATCH (g:Goal {companyId: 'talisman', id: $goalId})
+MATCH (g:CompanyGoal {companyId: $HELIOS_COMPANY_ID, id: $goalId})
 SET g.atRisk = true, g.atRiskReason = $reason, g.atRiskFlaggedAt = datetime();
 ```
 
@@ -269,17 +267,17 @@ When you need to create follow-up work or delegate, create a BusinessTask node:
 ```cypher
 MERGE (bt:BusinessTask {id: $id})
 ON CREATE SET
-  bt.companyId = 'talisman',
+  bt.companyId = $HELIOS_COMPANY_ID,
   bt.title = $title,
   bt.description = $description,
-  bt.assigneeId = 'agent:ceo',
+  bt.assigneeId = $assigneeAgentId,
   bt.priority = $priority,
   bt.status = 'todo',
   bt.goalId = $goalId,
   bt.createdAt = datetime()
 ```
 
-**Your agent ID**: `agent:ceo`  
+**Your agent ID**: use `$HELIOS_AGENT_ID` env var  
 **Priority values**: `'critical'`, `'high'`, `'medium'`, `'low'`  
 **CRITICAL**: `assigneeId` must always be set — null means the task is never dispatched.
 

package/skills/talisman-comms/SKILL.md

@@ -1,7 +1,7 @@
 ---
 disableModelInvocation: true
 name: talisman-comms
-description: Communications/Triage department for Talisman — auto-routing, response drafting, and escalation via triage pipeline
+description: Communications/Triage department — auto-routing, response drafting, and escalation via triage pipeline
 when: Loaded by the Communications agent when running triage, classifying messages, or drafting responses
 disable-model-invocation: true
 ---
@@ -37,7 +37,7 @@ cd ~/helios-agent && node extensions/email/commands/triage.js --limit 20 2>&1 |
 
 **Step 2**: Query classification results — sort by priority
 ```
-MATCH (m:Message {companyId: 'talisman', processed: false}) 
+MATCH (m:Message {companyId: $HELIOS_COMPANY_ID, processed: false}) 
 RETURN m.priority, count(m) as count ORDER BY m.priority
 ```
 
@@ -83,17 +83,17 @@ When you need to create follow-up work or delegate, create a BusinessTask node:
 ```cypher
 MERGE (bt:BusinessTask {id: $id})
 ON CREATE SET
-  bt.companyId = 'talisman',
+  bt.companyId = $HELIOS_COMPANY_ID,
   bt.title = $title,
   bt.description = $description,
-  bt.assigneeId = 'agent:comms',
+  bt.assigneeId = $HELIOS_AGENT_ID,
   bt.priority = $priority,
   bt.status = 'todo',
   bt.goalId = $goalId,
   bt.createdAt = datetime()
 ```
 
-**Your agent ID**: `agent:comms`  
+**Your agent ID**: use `$HELIOS_AGENT_ID` env var  
 **Priority values**: `'critical'`, `'high'`, `'medium'`, `'low'`  
 **CRITICAL**: `assigneeId` must always be set — null means the task is never dispatched.
 

package/skills/talisman-engineering/SKILL.md

@@ -1,8 +1,8 @@
 ---
 disableModelInvocation: true
 name: talisman-engineering
-description: "Engineering department for Talisman — autonomous feature development from backlog to staging PR. Runs the complete pipeline: Plan → Code → Test → PR → Staging."
-when: Loaded by the CTO/Engineering agent when processing engineering tasks for the Talisman project
+description: "Engineering department — autonomous feature development from backlog to staging PR. Runs the complete pipeline: Plan → Code → Test → PR → Staging."
+when: Loaded by the CTO/Engineering agent when processing engineering tasks
 disable-model-invocation: true
 ---
 
@@ -261,17 +261,17 @@ When you need to create follow-up work or delegate, create a BusinessTask node:
 ```cypher
 MERGE (bt:BusinessTask {id: $id})
 ON CREATE SET
-  bt.companyId = 'talisman',
+  bt.companyId = $HELIOS_COMPANY_ID,
   bt.title = $title,
   bt.description = $description,
-  bt.assigneeId = 'agent:cto',
+  bt.assigneeId = $HELIOS_AGENT_ID,
   bt.priority = $priority,
   bt.status = 'todo',
   bt.goalId = $goalId,
   bt.createdAt = datetime()
 ```
 
-**Your agent ID**: `agent:cto`  
+**Your agent ID**: use `$HELIOS_AGENT_ID` env var  
 **Priority values**: `'critical'`, `'high'`, `'medium'`, `'low'`  
 **CRITICAL**: `assigneeId` must always be set — null means the task is never dispatched.