@cgh567/agent 2.4.3 → 2.4.4

package/lib/broker/__tests__/lifecycle-channels.test.js

@@ -1,8 +1,14 @@
 import { describe, test, expect } from 'vitest';
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
 
-const HOOKS_PATH = path.join(require('os').homedir(), 'helios-agent/extensions/lifecycle-hooks.ts');
+// Desktop-first path resolution (P1-B2 fix)
+const DESKTOP_ROOT = path.join(os.homedir(), 'Desktop', 'Helios', 'helios-agent-main');
+const AGENT_ROOT = fs.existsSync(path.join(DESKTOP_ROOT, 'extensions'))
+  ? DESKTOP_ROOT
+  : path.join(os.homedir(), 'helios-agent');
+const HOOKS_PATH = path.join(AGENT_ROOT, 'extensions/lifecycle-hooks.ts');
 
 describe('lifecycle-hooks channel usage', () => {
   let content;
@@ -40,4 +46,22 @@ describe('lifecycle-hooks channel usage', () => {
       expect(hasBlackboard).toBe(true);
     }
   });
+
+  // P2-C2: graphWrite channel verification
+  test('lifecycle.mission channel string is passed to graphWrite (not safeWrite)', () => {
+    content = content || (fs.existsSync(HOOKS_PATH) ? fs.readFileSync(HOOKS_PATH, 'utf8') : null);
+    if (!content) return;
+    // graphWrite is the broker-aware write — verify lifecycle.mission channel is threaded to it
+    const hasGraphWrite = content.includes('graphWrite') || content.includes('safeWrite');
+    const hasMissionChannel = content.includes("'lifecycle.mission'") || content.includes('"lifecycle.mission"');
+    expect(hasGraphWrite).toBe(true);
+    expect(hasMissionChannel).toBe(true);
+  });
+
+  test('lifecycle.step channel string is passed to graphWrite', () => {
+    content = content || (fs.existsSync(HOOKS_PATH) ? fs.readFileSync(HOOKS_PATH, 'utf8') : null);
+    if (!content) return;
+    const hasStepChannel = content.includes("'lifecycle.step'") || content.includes('"lifecycle.step"');
+    expect(hasStepChannel).toBe(true);
+  });
 });

package/lib/compression/__tests__/ccr-store.test.js

@@ -0,0 +1,138 @@
+/**
+ * lib/compression/__tests__/ccr-store.test.js
+ *
+ * Unit tests for CcrStore (TTL-based in-memory key/value store for CCR dropped rows).
+ * Tests: set/get, TTL expiry, delete, has, stats, destroy, singleton.
+ *
+ * No mocks — tests real CcrStore behavior.
+ */
+'use strict';
+
+const { describe, it, expect, beforeEach, afterEach } = require('vitest');
+const { CcrStore, getCcrStore } = require('../dist/ccr-store.js');
+
+describe('CcrStore — basic operations', () => {
+  let store;
+  beforeEach(() => { store = new CcrStore(60); }); // 60s TTL
+  afterEach(() => { store.destroy(); });
+
+  it('set and get returns stored value', () => {
+    store.set('abc123', '["row1","row2"]');
+    expect(store.get('abc123')).toBe('["row1","row2"]');
+  });
+
+  it('get returns null for missing key', () => {
+    expect(store.get('nonexistent')).toBeNull();
+  });
+
+  it('has returns true for existing key', () => {
+    store.set('key1', 'data');
+    expect(store.has('key1')).toBe(true);
+  });
+
+  it('has returns false for missing key', () => {
+    expect(store.has('missing')).toBe(false);
+  });
+
+  it('delete removes a key', () => {
+    store.set('del-key', 'value');
+    store.delete('del-key');
+    expect(store.get('del-key')).toBeNull();
+    expect(store.has('del-key')).toBe(false);
+  });
+
+  it('delete on missing key does not throw', () => {
+    expect(() => store.delete('no-such-key')).not.toThrow();
+  });
+});
+
+describe('CcrStore — TTL expiry', () => {
+  it('expires entries after TTL', async () => {
+    const store = new CcrStore(0); // 0s TTL — expires immediately
+    store.set('exp-key', 'expiring data');
+    // After 0s TTL, the entry should already be past expiry
+    await new Promise((r) => setTimeout(r, 5));
+    expect(store.get('exp-key')).toBeNull();
+    store.destroy();
+  });
+
+  it('does not expire entries before TTL', () => {
+    const store = new CcrStore(3600); // 1h TTL
+    store.set('live-key', 'live data');
+    expect(store.get('live-key')).toBe('live data');
+    store.destroy();
+  });
+});
+
+describe('CcrStore — stats', () => {
+  let store;
+  beforeEach(() => { store = new CcrStore(60); });
+  afterEach(() => { store.destroy(); });
+
+  it('stats returns 0 entries for empty store', () => {
+    const s = store.stats();
+    expect(s.entries).toBe(0);
+    expect(s.totalOriginalBytes).toBe(0);
+  });
+
+  it('stats reflects current live entries', () => {
+    const data1 = 'data-string-one'; // 15 bytes
+    const data2 = 'data-string-two'; // 15 bytes
+    store.set('h1', data1);
+    store.set('h2', data2);
+    const s = store.stats();
+    expect(s.entries).toBe(2);
+    expect(s.totalOriginalBytes).toBe(data1.length + data2.length);
+  });
+
+  it('stats decrements after delete', () => {
+    store.set('a', 'aaa');
+    store.set('b', 'bbb');
+    store.delete('a');
+    const s = store.stats();
+    expect(s.entries).toBe(1);
+  });
+
+  it('stats excludes expired entries', async () => {
+    const storeShort = new CcrStore(0);
+    storeShort.set('exp', 'expiring');
+    await new Promise((r) => setTimeout(r, 10));
+    const s = storeShort.stats();
+    expect(s.entries).toBe(0);
+    storeShort.destroy();
+  });
+});
+
+describe('CcrStore — destroy', () => {
+  it('destroy clears all entries', () => {
+    const store = new CcrStore(60);
+    store.set('k1', 'v1');
+    store.set('k2', 'v2');
+    store.destroy();
+    expect(store.get('k1')).toBeNull();
+    expect(store.stats().entries).toBe(0);
+  });
+
+  it('destroy clears the cleanup interval (no unref error)', () => {
+    const store = new CcrStore(60);
+    expect(() => store.destroy()).not.toThrow();
+    // Second destroy is idempotent
+    expect(() => store.destroy()).not.toThrow();
+  });
+});
+
+describe('CcrStore — getCcrStore singleton', () => {
+  it('getCcrStore returns same instance on repeated calls', () => {
+    const a = getCcrStore();
+    const b = getCcrStore();
+    expect(a).toBe(b); // referential equality — same singleton
+  });
+
+  it('singleton accepts set/get operations', () => {
+    const store = getCcrStore();
+    const testKey = `test-singleton-${Date.now()}`;
+    store.set(testKey, 'singleton-data');
+    expect(store.get(testKey)).toBe('singleton-data');
+    store.delete(testKey); // cleanup
+  });
+});

package/lib/compression/__tests__/pipeline.test.js

@@ -0,0 +1,280 @@
+/**
+ * lib/compression/__tests__/pipeline.test.js
+ *
+ * Unit tests for CompressionPipeline and ContentRouter.
+ * Tests: message routing, system message skip, tool_result compression,
+ *        headroom_retrieve protection, content type detection.
+ *
+ * No mocks — tests real behavior.
+ */
+'use strict';
+
+const { describe, it, expect, beforeEach, afterEach } = require('vitest');
+const { CompressionPipeline } = require('../dist/pipeline.js');
+const { ContentRouter, detectContentType } = require('../dist/content-router.js');
+const { CcrStore } = require('../dist/ccr-store.js');
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function makeUniformJson(n) {
+  return JSON.stringify(
+    Array.from({ length: n }, (_, i) => ({
+      id: `lead-${String(i).padStart(4, '0')}`,
+      type: 'signal',
+      status: i % 2 === 0 ? 'active' : 'inactive',
+      score: 70 + (i % 30),
+      source: 'salesforce',
+      ts: `2026-06-${String((i % 28) + 1).padStart(2, '0')}T00:00:00Z`,
+    }))
+  );
+}
+
+function makeMessages(toolResultContent) {
+  return [
+    { role: 'system', content: 'You are a helpful assistant.' },
+    { role: 'user', content: 'What signals are there?' },
+    {
+      role: 'assistant',
+      content: [{ type: 'tool_use', id: 'tu_001', name: 'get_signals', input: {} }],
+    },
+    {
+      role: 'user',
+      content: [
+        {
+          type: 'tool_result',
+          tool_use_id: 'tu_001',
+          content: toolResultContent,
+        },
+      ],
+    },
+  ];
+}
+
+// ── detectContentType ─────────────────────────────────────────────────────────
+
+describe('detectContentType', () => {
+  it('detects JSON_ARRAY for array input', () => {
+    expect(detectContentType('[{"id":1},{"id":2}]')).toBe('JSON_ARRAY');
+  });
+
+  it('detects JSON_OBJECT for object input', () => {
+    expect(detectContentType('{"key":"value"}')).toBe('JSON_OBJECT');
+  });
+
+  it('detects SOURCE_CODE for backtick code block', () => {
+    expect(detectContentType('```js\nconsole.log("hi")\n```')).toBe('SOURCE_CODE');
+  });
+
+  it('detects SOURCE_CODE for function keyword', () => {
+    expect(detectContentType('Some text\nfunction foo() { return 1; }')).toBe('SOURCE_CODE');
+  });
+
+  it('detects PLAIN_TEXT for regular prose', () => {
+    expect(detectContentType('The agent should focus on high-priority leads.')).toBe('PLAIN_TEXT');
+  });
+
+  it('returns PLAIN_TEXT for malformed JSON that starts with [', () => {
+    expect(detectContentType('[not valid json')).toBe('PLAIN_TEXT');
+  });
+});
+
+// ── ContentRouter ─────────────────────────────────────────────────────────────
+
+describe('ContentRouter — protection gates', () => {
+  let router;
+  let store;
+  beforeEach(() => {
+    router = new ContentRouter();
+    store = new CcrStore(60);
+  });
+  afterEach(() => { store.destroy(); });
+
+  it('returns passthrough for content shorter than 500 chars', () => {
+    const short = makeUniformJson(3); // tiny array
+    expect(short.length).toBeLessThan(500);
+    const result = router.route(short, 'some_tool', store);
+    expect(result.compressed).toBe(false);
+    expect(result.tokensSaved).toBe(0);
+  });
+
+  it('never compresses headroom_retrieve tool results (infinite loop prevention)', () => {
+    const large = makeUniformJson(30);
+    expect(large.length).toBeGreaterThan(500);
+    const result = router.route(large, 'headroom_retrieve', store);
+    expect(result.compressed).toBe(false);
+    expect(result.strategy).toBe('passthrough');
+  });
+
+  it('does not compress small error outputs (<=8000 chars + error keyword)', () => {
+    const errorOut = JSON.stringify({ error: 'timeout', traceback: 'at line 42' }) + ' '.repeat(100);
+    const result = router.route(errorOut, 'bash', store);
+    // Passthrough because: contains "error" AND length <= 8000
+    expect(result.compressed).toBe(false);
+  });
+
+  it('compresses large error-containing payloads (>8000 chars)', () => {
+    // > 8000 chars with error key — protection does NOT apply
+    const largeWithError = JSON.stringify(
+      Array.from({ length: 30 }, (_, i) => ({
+        id: `e-${i}`,
+        type: 'signal',
+        status: 'active',
+        score: 80,
+        source: 'crm',
+        ts: `2026-06-${String(i % 28 + 1).padStart(2, '0')}T00:00:00Z`,
+        extra: 'padding'.repeat(20),
+      }))
+    );
+    expect(largeWithError.length).toBeGreaterThan(8000);
+    const result = router.route(largeWithError, 'get_signals', store);
+    // Should be compressed (not a small error output)
+    expect(result.compressed).toBe(true);
+  });
+});
+
+describe('ContentRouter — compression', () => {
+  let router;
+  let store;
+  beforeEach(() => {
+    router = new ContentRouter();
+    store = new CcrStore(60);
+  });
+  afterEach(() => { store.destroy(); });
+
+  it('compresses a large JSON_ARRAY to lossless-csv', () => {
+    const content = makeUniformJson(30);
+    const result = router.route(content, 'get_signals', store);
+    expect(result.compressed).toBe(true);
+    expect(result.contentType).toBe('JSON_ARRAY');
+    expect(result.tokensSaved).toBeGreaterThan(0);
+  });
+
+  it('returns passthrough for PLAIN_TEXT', () => {
+    const text = 'The agent should focus on high-priority leads. '.repeat(30);
+    expect(text.length).toBeGreaterThan(500);
+    const result = router.route(text, 'recall', store);
+    expect(result.compressed).toBe(false);
+  });
+
+  it('returns passthrough for JSON_OBJECT', () => {
+    const obj = JSON.stringify({ items: [1, 2, 3], count: 3, total: 6 }) + ' '.repeat(600);
+    const result = router.route(obj, 'get_stats', store);
+    expect(result.compressed).toBe(false);
+  });
+});
+
+// ── CompressionPipeline ───────────────────────────────────────────────────────
+
+describe('CompressionPipeline — message routing', () => {
+  let pipeline;
+  let store;
+  beforeEach(() => {
+    pipeline = new CompressionPipeline();
+    store = new CcrStore(60);
+  });
+  afterEach(() => { store.destroy(); });
+
+  it('compresses tool_result blocks in user messages', () => {
+    const messages = makeMessages(makeUniformJson(30));
+    const result = pipeline.compress(messages, store);
+    expect(result.tokensSaved).toBeGreaterThan(0);
+    expect(result.transformsApplied.length).toBeGreaterThan(0);
+  });
+
+  it('does NOT mutate original messages array', () => {
+    const messages = makeMessages(makeUniformJson(30));
+    const originalJson = JSON.stringify(messages);
+    pipeline.compress(messages, store);
+    expect(JSON.stringify(messages)).toBe(originalJson);
+  });
+
+  it('skips system messages (preserves prompt cache stability)', () => {
+    const systemContent = 'You are a helpful assistant.';
+    const messages = [
+      { role: 'system', content: systemContent },
+      {
+        role: 'user',
+        content: [
+          { type: 'tool_result', tool_use_id: 'tu_1', content: makeUniformJson(30) },
+        ],
+      },
+    ];
+    const result = pipeline.compress(messages, store);
+    // System message content must be unchanged
+    expect(result.messages[0].content).toBe(systemContent);
+  });
+
+  it('skips non-tool_result blocks in user messages', () => {
+    const messages = [
+      {
+        role: 'user',
+        content: [
+          { type: 'text', text: 'What are the signals?' },
+          { type: 'tool_result', tool_use_id: 'tu_1', content: makeUniformJson(30) },
+        ],
+      },
+    ];
+    const result = pipeline.compress(messages, store);
+    // Text block must be unchanged
+    expect(result.messages[0].content[0].type).toBe('text');
+    expect(result.messages[0].content[0].text).toBe('What are the signals?');
+    // tool_result block should be compressed
+    expect(result.tokensSaved).toBeGreaterThan(0);
+  });
+
+  it('returns compressionRatio < 1 when compression succeeds', () => {
+    const messages = makeMessages(makeUniformJson(30));
+    const result = pipeline.compress(messages, store);
+    expect(result.compressionRatio).toBeGreaterThan(0);
+    expect(result.compressionRatio).toBeLessThan(1);
+  });
+
+  it('returns compressionRatio = 1 for uncompressible input', () => {
+    // String content that's too short to compress
+    const messages = [
+      { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'tu_1', content: 'hi' }] },
+    ];
+    const result = pipeline.compress(messages, store);
+    expect(result.tokensSaved).toBe(0);
+    expect(result.compressionRatio).toBe(1);
+  });
+
+  it('collects ccrHashes when lossy-sample is applied', () => {
+    // Sparse array to trigger lossy-sample
+    const pad = 'x'.repeat(200);
+    const sparse = JSON.stringify(
+      Array.from({ length: 40 }, (_, i) => {
+        const o = { id: `item-${String(i).padStart(5, '0')}` };
+        if (i % 2 === 0) o.payload = `data_${i}_${pad}`;
+        if (i % 3 === 0) o.stage = 'active';
+        if (i % 4 === 0) o.value = i * 100;
+        if (i % 5 === 0) o.ts = `2026-06-${String((i % 28) + 1).padStart(2, '0')}`;
+        if (i % 6 === 0) o.owner = `rep-${i % 8}`;
+        if (i % 7 === 0) o.src = 'crm';
+        return o;
+      })
+    );
+    const messages = makeMessages(sparse);
+    const result = pipeline.compress(messages, store);
+    if (result.transformsApplied.includes('lossy-sample')) {
+      expect(result.ccrHashes.length).toBeGreaterThan(0);
+    }
+  });
+
+  it('handles empty messages array', () => {
+    const result = pipeline.compress([], store);
+    expect(result.messages).toEqual([]);
+    expect(result.tokensSaved).toBe(0);
+    expect(result.compressionRatio).toBe(1);
+  });
+
+  it('handles messages with string content (not array)', () => {
+    const messages = [
+      { role: 'user', content: 'simple string content' },
+      { role: 'assistant', content: 'simple assistant response' },
+    ];
+    const result = pipeline.compress(messages, store);
+    expect(result.messages[0].content).toBe('simple string content');
+    expect(result.tokensSaved).toBe(0);
+  });
+});