@animalabs/connectome-host 0.3.5 → 0.3.8

package/test/recipe-compression-fallback.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, test } from 'bun:test';
+import { validateRecipe } from '../src/recipe.js';
+
+function recipe(strategy: Record<string, unknown>) {
+  return {
+    name: 'compression-fallback-test',
+    agent: { systemPrompt: 'sys', strategy: { type: 'autobiographical', ...strategy } },
+  };
+}
+
+describe('compression recall-curve recipe settings', () => {
+  test('preserves valid fallback count and complete-request budget', () => {
+    const parsed = validateRecipe(recipe({
+      compressionRefusalCurveFallbacks: 3,
+      compressionContextBudgetTokens: 200_000,
+    }));
+    expect(parsed.agent.strategy?.compressionRefusalCurveFallbacks).toBe(3);
+    expect(parsed.agent.strategy?.compressionContextBudgetTokens).toBe(200_000);
+  });
+
+  test('accepts zero as an explicit fallback disable', () => {
+    expect(validateRecipe(recipe({ compressionRefusalCurveFallbacks: 0 }))
+      .agent.strategy?.compressionRefusalCurveFallbacks).toBe(0);
+  });
+
+  test('rejects malformed fallback settings', () => {
+    expect(() => validateRecipe(recipe({ compressionRefusalCurveFallbacks: -1 })))
+      .toThrow(/compressionRefusalCurveFallbacks/);
+    expect(() => validateRecipe(recipe({ compressionRefusalCurveFallbacks: 1.5 })))
+      .toThrow(/compressionRefusalCurveFallbacks/);
+    expect(() => validateRecipe(recipe({ compressionContextBudgetTokens: 0 })))
+      .toThrow(/compressionContextBudgetTokens/);
+    expect(() => validateRecipe(recipe({ compressionContextBudgetTokens: '200000' })))
+      .toThrow(/compressionContextBudgetTokens/);
+  });
+});

package/test/recipe-primary-summary-fallback.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, test } from 'bun:test';
+import { validateRecipe } from '../src/recipe.js';
+
+function recipe(primarySummaryFallback?: Record<string, unknown>) {
+  return {
+    name: 'primary-summary-fallback-test',
+    agent: {
+      systemPrompt: 'sys',
+      refusalHandling: primarySummaryFallback
+        ? { primarySummaryFallback }
+        : undefined,
+    },
+  };
+}
+
+describe('recipe primary summary fallback validation', () => {
+  test('leaves the fallback disabled by default when omitted', () => {
+    const parsed = validateRecipe(recipe());
+    expect(parsed.agent.refusalHandling?.primarySummaryFallback).toBeUndefined();
+  });
+
+  test('preserves valid fallback settings', () => {
+    const parsed = validateRecipe(recipe({
+      enabled: true,
+      maxNewSummaries: 4,
+      requestBudgetTokens: 216_000,
+    }));
+    expect(parsed.agent.refusalHandling?.primarySummaryFallback).toEqual({
+      enabled: true,
+      maxNewSummaries: 4,
+      requestBudgetTokens: 216_000,
+    });
+  });
+
+  test('rejects malformed fallback settings', () => {
+    expect(() => validateRecipe(recipe({ enabled: 'yes' }))).toThrow(/primarySummaryFallback\.enabled/);
+    expect(() => validateRecipe(recipe({ maxNewSummaries: -1 }))).toThrow(/maxNewSummaries/);
+    expect(() => validateRecipe(recipe({ requestBudgetTokens: 0 }))).toThrow(/requestBudgetTokens/);
+  });
+});

package/test/recipe-provider.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, test } from 'bun:test';
+import { validateRecipe } from '../src/recipe.js';
+
+function recipe(agent: Record<string, unknown> = {}) {
+  return { name: 'provider-test', agent: { systemPrompt: 'sys', ...agent } };
+}
+
+describe('recipe provider validation', () => {
+  test('preserves Anthropic as the omitted provider and accepts Responses', () => {
+    expect(validateRecipe(recipe()).agent.provider).toBeUndefined();
+    expect(validateRecipe(recipe({ provider: 'openai-responses' })).agent.provider)
+      .toBe('openai-responses');
+  });
+
+  test('accepts Responses reasoning and compaction settings', () => {
+    expect(validateRecipe(recipe({
+      provider: 'openai-responses',
+      responses: {
+        reasoningEffort: 'xhigh',
+        reasoningContext: 'all_turns',
+        compactThreshold: 100_000,
+      },
+    })).agent.responses).toEqual({
+      reasoningEffort: 'xhigh',
+      reasoningContext: 'all_turns',
+      compactThreshold: 100_000,
+    });
+  });
+
+  test('rejects unknown providers and malformed Responses settings', () => {
+    expect(() => validateRecipe(recipe({ provider: 'openai-chat' }))).toThrow(/agent.provider/);
+    expect(() => validateRecipe(recipe({ responses: { reasoningEffort: 'ultra' } }))).toThrow(/reasoningEffort/);
+    expect(() => validateRecipe(recipe({ responses: { reasoningContext: 'previous_turn' } }))).toThrow(/reasoningContext/);
+    expect(() => validateRecipe(recipe({ responses: { compactThreshold: 0 } }))).toThrow(/compactThreshold/);
+  });
+});

package/test/recipe-think-policy.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, test } from 'bun:test';
+import { validateRecipe } from '../src/recipe.js';
+import { buildFrameworkAgentConfig } from '../src/framework-agent-config.js';
+
+function recipe(agent: Record<string, unknown> = {}) {
+  return { name: 'think-policy-test', agent: { systemPrompt: 'sys', ...agent } };
+}
+
+describe('recipe sameRoundThinkTextPolicy', () => {
+  test('valid public/private values are preserved and passed through to Agent Framework config', () => {
+    const publicRecipe = validateRecipe(recipe({ sameRoundThinkTextPolicy: 'public' }));
+    expect(publicRecipe.agent.sameRoundThinkTextPolicy).toBe('public');
+    expect(
+      buildFrameworkAgentConfig(publicRecipe, 'agent', 'model', undefined).sameRoundThinkTextPolicy,
+    ).toBe('public');
+
+    const privateRecipe = validateRecipe(recipe({ sameRoundThinkTextPolicy: 'private' }));
+    expect(privateRecipe.agent.sameRoundThinkTextPolicy).toBe('private');
+    expect(
+      buildFrameworkAgentConfig(privateRecipe, 'agent', 'model', undefined).sameRoundThinkTextPolicy,
+    ).toBe('private');
+  });
+
+  test('omitted value stays omitted so Agent Framework can report the compatibility source', () => {
+    const parsed = validateRecipe(recipe());
+    expect(parsed.agent.sameRoundThinkTextPolicy).toBeUndefined();
+    const config = buildFrameworkAgentConfig(parsed, 'agent', 'model', undefined);
+    expect(Object.prototype.hasOwnProperty.call(config, 'sameRoundThinkTextPolicy')).toBe(false);
+  });
+
+  test('invalid strings and types are rejected', () => {
+    expect(() => validateRecipe(recipe({ sameRoundThinkTextPolicy: 'secret' })))
+      .toThrow(/sameRoundThinkTextPolicy/);
+    expect(() => validateRecipe(recipe({ sameRoundThinkTextPolicy: true })))
+      .toThrow(/sameRoundThinkTextPolicy/);
+    expect(() => validateRecipe(recipe({ sameRoundThinkTextPolicy: { mode: 'public' } })))
+      .toThrow(/sameRoundThinkTextPolicy/);
+  });
+});

package/test/recipe-timezone.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, test } from 'bun:test';
+import { validateRecipe } from '../src/recipe.js';
+
+function recipe(timezone?: unknown) {
+  return { name: 'tz', agent: { systemPrompt: 'test', ...(timezone === undefined ? {} : { timezone }) } };
+}
+
+describe('recipe agent.timezone validation', () => {
+  test('accepts an IANA timezone', () => {
+    expect(validateRecipe(recipe('America/Los_Angeles')).agent.timezone).toBe('America/Los_Angeles');
+  });
+
+  test('allows the setting to be omitted', () => {
+    expect(validateRecipe(recipe()).agent.timezone).toBeUndefined();
+  });
+
+  test('rejects invalid timezone names', () => {
+    expect(() => validateRecipe(recipe('Pacific/Definitely_Not'))).toThrow(/valid IANA time zone/);
+  });
+});

package/test/subscription-gc-module.test.ts

@@ -37,6 +37,7 @@ function ambient(
     origin: {
       source: 'discord',
       channelId,
+      mcplChannelId: `discord:g1:${channelId}`,
       isMention: !!opts.isMention,
       isDM: !!opts.isDM,
     },
@@ -59,8 +60,9 @@ describe('SubscriptionGcModule', () => {
 
     r = await m.onProcess(ambient('c1', 'ghijkl'), PS); // +6 = 12 > 10 → unsub
     expect(toolCalls.length).toBe(1);
-    expect(toolCalls[0].name).toBe('mcpl--discord--unsubscribe_channel');
-    expect(toolCalls[0].input.channelId).toBe('c1');
+    expect(toolCalls[0].name).toBe('channel_close');
+    expect(toolCalls[0].input.channelId).toBe('discord:g1:c1');
+    expect(toolCalls[0].input.serverId).toBe('discord');
     expect(r.addMessages?.length).toBe(1);
 
     await m.stop();
@@ -100,7 +102,7 @@ describe('SubscriptionGcModule', () => {
     await m.handleToolCall({
       id: 't1',
       name: 'set_channel_idle_limit',
-      input: { channelId: 'c1', limit: 'off' },
+      input: { channelId: 'discord:g1:c1', limit: 'off' },
     });
     await m.onProcess(ambient('c1', 'waytoolongambient'), PS);
     expect(toolCalls.length).toBe(0); // pinned → never unsubscribed
@@ -108,7 +110,7 @@ describe('SubscriptionGcModule', () => {
     // A different channel still accrues, and state is persisted.
     await m.onProcess(ambient('c2', 'abc'), PS);
     const persisted = getState() as { overrides: Record<string, unknown>; counters: Record<string, number> };
-    expect(persisted.overrides.c1).toBe('off');
+    expect(persisted.overrides['discord:g1:c1']).toBe('off');
 
     // Simulate restart: a new module loads the persisted state (counters carry
     // across — a restart is not an activation).
@@ -128,7 +130,7 @@ describe('SubscriptionGcModule', () => {
     // c2 was at 3; +3 = 6 > 5 → unsubscribe (counter survived the "restart")
     await m2.onProcess(ambient('c2', 'def'), PS);
     expect(restart.toolCalls.length).toBe(1);
-    expect(restart.toolCalls[0].input.channelId).toBe('c2');
+    expect(restart.toolCalls[0].input.channelId).toBe('discord:g1:c2');
 
     await m.stop();
     await m2.stop();

package/test/time-module.test.ts

@@ -0,0 +1,13 @@
+import { describe, expect, test } from 'bun:test';
+import { formatNow } from '../src/modules/time-module.js';
+
+describe('TimeModule presentation timezone', () => {
+  test('formats current time independently of the host timezone', () => {
+    expect(formatNow(new Date('2026-07-15T12:34:56.789Z'), 'America/Los_Angeles')).toEqual({
+      iso: '2026-07-15T05:34:56.789-07:00',
+      local: '2026-07-15T05:34:56.789-07:00 [America/Los_Angeles]',
+      timezone: 'America/Los_Angeles',
+      unixMs: 1_784_118_896_789,
+    });
+  });
+});

package/test/web-ui-observers.test.ts

@@ -174,17 +174,65 @@ describe('scope filters', () => {
     expect(w.history.startIndex).toBe(240);
     expect(w.usage.input).toBe(1); // structure/usage survive
   });
+
+  // Health-gated telemetry must be masked exactly like its live frames:
+  // `usage` and `call-ledger` pushes require the 'health' scope, so the
+  // welcome cannot hand the same data to a messages-only observer.
+  test('scopeWelcome without health strips callLedger/perAgentCost and zeroes usage', () => {
+    const welcome = {
+      type: 'welcome', protocolVersion: 1,
+      messages: [entry],
+      history: { startIndex: 40, totalCount: 240 },
+      localTree: { asOfTs: 1, nodes: [], callIdIndex: {} },
+      childTrees: [],
+      usage: { input: 1, output: 2, cacheRead: 3, cacheWrite: 4, cost: { total: 5, currency: 'USD' } },
+      perAgentCost: [{ name: 'main', usage: { input: 1, output: 2, cacheRead: 0, cacheWrite: 0 } }],
+      callLedger: {
+        calls: [{ model: 'secret-model', error: 'raw provider error', costUsd: 0.42 }],
+      },
+    } as unknown as WelcomeMessage;
+
+    const w = scopeWelcome(welcome, new Set<ObserverScope>(['messages']));
+    expect(w.callLedger).toBeUndefined();
+    expect(w.perAgentCost).toBeUndefined();
+    expect(w.usage).toEqual({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
+    expect(w.messages.length).toBe(1); // messages scope still gets content
+    // No trace of the ledger anywhere in the serialized frame.
+    expect(JSON.stringify(w)).not.toContain('secret-model');
+    expect(JSON.stringify(w)).not.toContain('raw provider error');
+
+    // Same masking on the no-messages branch (e.g. ops-only observer).
+    const opsOnly = scopeWelcome(welcome, new Set<ObserverScope>(['ops']));
+    expect(opsOnly.callLedger).toBeUndefined();
+    expect(opsOnly.perAgentCost).toBeUndefined();
+    expect(opsOnly.usage).toEqual({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
+
+    // A health-scoped observer keeps the telemetry verbatim.
+    const h = scopeWelcome(welcome, new Set<ObserverScope>(['health']));
+    expect(h.callLedger).toEqual(welcome.callLedger);
+    expect(h.perAgentCost).toEqual(welcome.perAgentCost);
+    expect(h.usage).toEqual(welcome.usage);
+
+    // Input welcome is never mutated (shared across clients in sendWelcome).
+    expect(welcome.callLedger).toBeDefined();
+    expect(welcome.usage.input).toBe(1);
+  });
 });
 
 describe('ObserverSessions', () => {
-  test('mint/lookup round-trip; bad token null', () => {
+  test('mint/lookup round-trip; bad token null; full flag carried', () => {
     const s = new ObserverSessions();
     const scopes = new Set<ObserverScope>(['health']);
     const token = s.mint(scopes);
     expect(token).toMatch(/^[a-f0-9]{64}$/);
-    expect(s.lookup(token)).toBe(scopes);
+    expect(s.lookup(token)!.scopes).toBe(scopes);
+    expect(s.lookup(token)!.full).toBe(false);
     expect(s.lookup('0'.repeat(64))).toBeNull();
     expect(s.lookup(null)).toBeNull();
+
+    // Full sessions (password sign-in path) carry operator authority.
+    const fullToken = s.mint(new Set(), { full: true });
+    expect(s.lookup(fullToken)!.full).toBe(true);
   });
 });
 
@@ -289,6 +337,26 @@ describe('WebUiModule observer flow (e2e)', () => {
     ws.close();
   }, 15_000);
 
+  test('password sign-in mints a full-session cookie the WS upgrade honors', async () => {
+    // /auth/basic with valid credentials → 302 + full-session cookie.
+    const res = await fetch(`${base()}/auth/basic`, { headers: { authorization: BASIC }, redirect: 'manual' });
+    expect(res.status).toBe(302);
+    const m = /fkm_obs=([a-f0-9]{64})/.exec(res.headers.get('set-cookie') ?? '');
+    expect(m).not.toBeNull();
+
+    // A WS upgrade carrying ONLY the cookie (no Authorization — the Chrome
+    // situation) must be treated as a FULL client: no observer-auth-required
+    // demand. (Full clients are parked silently in this app-less harness;
+    // the observer path would send auth-required immediately.)
+    const ws = new WebSocket(`ws://127.0.0.1:${port}/ws`, { headers: { cookie: `fkm_obs=${m![1]}` } } as never);
+    const firstFrame = await Promise.race([
+      new Promise<string>((r) => ws.addEventListener('message', (ev) => r(String((ev as MessageEvent).data)))),
+      new Promise<string>((r) => setTimeout(() => r('SILENCE'), 1500)),
+    ]);
+    ws.close();
+    expect(firstFrame).toBe('SILENCE'); // not observer-auth-required
+  }, 10_000);
+
   test('wrong key: hello rejected and socket closed', async () => {
     const stranger = makeKeypair();
     const host = `127.0.0.1:${port}`;