@animalabs/connectome-host 0.7.2 → 0.7.4

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

@@ -291,3 +291,155 @@ describe('system pins (pin_channel_idle_limit)', () => {
     expect(bad2.success).toBe(false);
   });
 });
+
+describe('close provenance + explicit-open protection (issue #5)', () => {
+  test('closes carry source subscription-gc; default budget certifies no lease', async () => {
+    const m = new SubscriptionGcModule({ defaultLimitChars: 10, serverId: 'discord' });
+    const { ctx, toolCalls } = mockCtx();
+    await m.start(ctx);
+
+    await m.onProcess(ambient('c1', 'abcdefghijkl'), PS); // 12 > 10 → close
+    expect(toolCalls.length).toBe(1);
+    expect(toolCalls[0].input.source).toBe('subscription-gc');
+    expect(toolCalls[0].input.overrideExplicitOpen).toBe(false);
+
+    await m.stop();
+  });
+
+  test('a configured numeric budget is an explicit lease: overrideExplicitOpen true', async () => {
+    const m = new SubscriptionGcModule({ defaultLimitChars: 10, serverId: 'discord' });
+    const { ctx, toolCalls } = mockCtx();
+    await m.start(ctx);
+
+    await m.handleToolCall({
+      id: 't1',
+      name: 'set_channel_idle_limit',
+      input: { channelId: 'discord:g1:c1', limit: 8 },
+    });
+    await m.onProcess(ambient('c1', 'abcdefghij'), PS); // 10 > 8 → close under lease
+    expect(toolCalls.length).toBe(1);
+    expect(toolCalls[0].input.overrideExplicitOpen).toBe(true);
+
+    await m.stop();
+  });
+
+  test('a structural explicit-open refusal stands down without a retry loop', async () => {
+    const m = new SubscriptionGcModule({ defaultLimitChars: 10, serverId: 'discord' });
+    const { ctx, toolCalls, getState } = mockCtx();
+    (ctx as unknown as { callTool: unknown }).callTool = async (call: { name: string; input: Record<string, unknown> }) => {
+      toolCalls.push(call);
+      return {
+        success: false,
+        isError: false,
+        error: 'explicitly opened',
+        data: { refusal: 'explicit-open' },
+      };
+    };
+    await m.start(ctx);
+
+    const r = await m.onProcess(ambient('c1', 'abcdefghijkl'), PS); // 12 > 10
+    expect(toolCalls.length).toBe(1);
+    // No context spam, no counter restore: the janitor stands down and the
+    // next attempt is at least a full budget away.
+    expect(r.addMessages).toBeUndefined();
+    const counters = (getState() as { counters: Record<string, number> }).counters;
+    expect(counters['discord:g1:c1']).toBeUndefined();
+
+    // Next ambient message counts from zero rather than instantly re-firing.
+    await m.onProcess(ambient('c1', 'ab'), PS);
+    expect(toolCalls.length).toBe(1);
+
+    await m.stop();
+  });
+
+  test('a successful close emits a privacy-minimal ops receipt when notifyOps exists', async () => {
+    const m = new SubscriptionGcModule({ defaultLimitChars: 10, serverId: 'discord' });
+    const { ctx } = mockCtx();
+    const receipts: Array<{ kind: string; agent: string; message: string; data?: Record<string, unknown> }> = [];
+    // The mock is deliberately `this`-sensitive, like the real
+    // ModuleContextImpl.notifyOps (which reads this.registry): a detached
+    // `const f = ctx.notifyOps; f(...)` throws here instead of passing —
+    // the exact bug class Sol caught in the first revision.
+    Object.assign(ctx as object, {
+      getAgents: () => [{ name: 'mythos' }],
+      _receipts: receipts,
+      notifyOps(
+        this: { _receipts: typeof receipts },
+        kind: string,
+        agent: string,
+        message: string,
+        data?: Record<string, unknown>,
+      ) {
+        this._receipts.push({ kind, agent, message, data });
+      },
+    });
+    await m.start(ctx);
+
+    await m.onProcess(ambient('c1', 'abcdefghijkl'), PS);
+    expect(receipts.length).toBe(1);
+    expect(receipts[0].kind).toBe('subscription-gc-close');
+    expect(receipts[0].agent).toBe('mythos');
+    expect(receipts[0].data).toMatchObject({
+      channelId: 'discord:g1:c1',
+      limitChars: 10,
+      decisionSource: 'subscription-gc',
+      lease: 'default',
+    });
+    // Privacy-minimal: the receipt names ids and thresholds, never content.
+    expect(receipts[0].message).not.toContain('abcdef');
+
+    await m.stop();
+  });
+
+  test('a configured-budget close reports lease configured-budget, claiming no actor', async () => {
+    const m = new SubscriptionGcModule({ defaultLimitChars: 10, serverId: 'discord' });
+    const { ctx } = mockCtx();
+    const receipts: Array<{ message: string; data?: Record<string, unknown> }> = [];
+    Object.assign(ctx as object, {
+      getAgents: () => [{ name: 'mythos' }],
+      _receipts: receipts,
+      notifyOps(
+        this: { _receipts: typeof receipts },
+        _kind: string,
+        _agent: string,
+        message: string,
+        data?: Record<string, unknown>,
+      ) {
+        this._receipts.push({ message, data });
+      },
+    });
+    await m.start(ctx);
+
+    await m.handleToolCall({
+      id: 't1',
+      name: 'set_channel_idle_limit',
+      input: { channelId: 'discord:g1:c1', limit: 8 },
+    });
+    await m.onProcess(ambient('c1', 'abcdefghij'), PS); // 10 > 8
+    expect(receipts.length).toBe(1);
+    // The override state records no actor (agent, operator, or imported are
+    // all possible) — the receipt must not claim 'agent-set'.
+    expect(receipts[0].data?.lease).toBe('configured-budget');
+    expect(receipts[0].message).toContain('configured per-channel budget');
+    expect(receipts[0].message).not.toContain('agent-set');
+
+    await m.stop();
+  });
+
+  test('an ordinary close failure still restores the counter for retry', async () => {
+    const m = new SubscriptionGcModule({ defaultLimitChars: 10, serverId: 'discord' });
+    const { ctx, toolCalls, getState } = mockCtx();
+    (ctx as unknown as { callTool: unknown }).callTool = async (call: { name: string; input: Record<string, unknown> }) => {
+      toolCalls.push(call);
+      return { success: false, error: 'server unreachable', isError: true };
+    };
+    await m.start(ctx);
+
+    await m.onProcess(ambient('c1', 'abcdefghijkl'), PS);
+    expect(toolCalls.length).toBe(1);
+    const counters = (getState() as { counters: Record<string, number> }).counters;
+    expect(counters['discord:g1:c1']).toBe(12);
+
+    await m.stop();
+  });
+});

package/test/tui-format.test.ts

@@ -0,0 +1,106 @@
+import { describe, expect, test } from 'bun:test';
+import { ctxSeverity, fmtElapsed, pickTopAlert, sliceViewport } from '../src/tui.js';
+
+describe('fmtElapsed', () => {
+  test('seconds under a minute stay bare', () => {
+    expect(fmtElapsed(0)).toBe('0s');
+    expect(fmtElapsed(48)).toBe('48s');
+    expect(fmtElapsed(59)).toBe('59s');
+  });
+
+  test('minutes pad seconds to two digits', () => {
+    expect(fmtElapsed(60)).toBe('1m00s');
+    expect(fmtElapsed(348)).toBe('5m48s');
+    expect(fmtElapsed(305)).toBe('5m05s');
+  });
+
+  test('hours pad minutes and drop seconds', () => {
+    expect(fmtElapsed(3600)).toBe('1h00m');
+    expect(fmtElapsed(3720)).toBe('1h02m');
+    expect(fmtElapsed(7500)).toBe('2h05m');
+  });
+});
+
+describe('ctxSeverity', () => {
+  test('no budget → always ok', () => {
+    expect(ctxSeverity(150_000)).toBe('ok');
+    expect(ctxSeverity(150_000, 0)).toBe('ok');
+    expect(ctxSeverity(150_000, undefined)).toBe('ok');
+  });
+
+  test('escalates at 75% and 90% of budget', () => {
+    expect(ctxSeverity(100_000, 200_000)).toBe('ok');
+    expect(ctxSeverity(149_999, 200_000)).toBe('ok');
+    expect(ctxSeverity(150_000, 200_000)).toBe('warn');
+    expect(ctxSeverity(179_999, 200_000)).toBe('warn');
+    expect(ctxSeverity(180_000, 200_000)).toBe('high');
+    expect(ctxSeverity(250_000, 200_000)).toBe('high');
+  });
+
+  test('zero context is ok regardless of budget', () => {
+    expect(ctxSeverity(0, 100)).toBe('ok');
+  });
+});
+
+describe('pickTopAlert', () => {
+  test('empty → null', () => {
+    expect(pickTopAlert([])).toBeNull();
+  });
+
+  test('priority kinds beat recency', () => {
+    expect(pickTopAlert(['refusal-streak', 'compression-quarantine'])).toBe('compression-quarantine');
+    expect(pickTopAlert(['inference-exhausted', 'refusal-streak'])).toBe('inference-exhausted');
+    // quarantine outranks hard-down
+    expect(pickTopAlert(['inference-exhausted', 'compression-quarantine'])).toBe('compression-quarantine');
+  });
+
+  test('no priority kind → most recent (last) wins', () => {
+    expect(pickTopAlert(['a-alert', 'b-alert'])).toBe('b-alert');
+  });
+});
+
+describe('sliceViewport', () => {
+  test('everything fits → whole range', () => {
+    expect(sliceViewport(10, 3, 20)).toEqual({ start: 0, end: 10 });
+    expect(sliceViewport(20, 0, 20)).toEqual({ start: 0, end: 20 });
+  });
+
+  test('cursor at top: no top marker row, one extra body line', () => {
+    const { start, end } = sliceViewport(100, 0, 20);
+    expect(start).toBe(0);
+    expect(end).toBe(19); // 19 body rows + 1 bottom-marker row = 20
+  });
+
+  test('cursor at bottom: no bottom marker row', () => {
+    const { start, end } = sliceViewport(100, 99, 20);
+    expect(end).toBe(100);
+    expect(start).toBe(81); // 1 top-marker row + 19 body rows = 20
+    expect(99).toBeGreaterThanOrEqual(start);
+  });
+
+  test('cursor mid-list: centered window with both markers budgeted', () => {
+    const { start, end } = sliceViewport(100, 50, 20);
+    expect(end - start).toBe(18); // 18 body + 2 marker rows = 20
+    expect(50).toBeGreaterThanOrEqual(start);
+    expect(50).toBeLessThan(end);
+  });
+
+  test('cursor always lands inside the window', () => {
+    for (let cursor = 0; cursor < 60; cursor++) {
+      const { start, end } = sliceViewport(60, cursor, 12);
+      expect(cursor).toBeGreaterThanOrEqual(start);
+      expect(cursor).toBeLessThan(end);
+      // rendered rows (body + markers actually shown) never exceed avail
+      const rows = (end - start) + (start > 0 ? 1 : 0) + (end < 60 ? 1 : 0);
+      expect(rows).toBeLessThanOrEqual(12);
+    }
+  });
+
+  test('degenerate tiny viewport still contains the cursor', () => {
+    for (const avail of [3, 4, 5]) {
+      const { start, end } = sliceViewport(50, 25, avail);
+      expect(25).toBeGreaterThanOrEqual(start);
+      expect(25).toBeLessThan(end);
+    }
+  });
+});

package/test/web-ui-context-coverage.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'bun:test';
-import { buildContextCoverageSnapshot } from '../src/modules/web-ui-module.js';
+import { buildContextCoverageSnapshot } from '../src/web/panel-data.js';
 
 function contextManager(strategy: Record<string, unknown>) {
   return {

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

@@ -38,6 +38,7 @@ const BASIC_USER = 'admin';
 const BASIC_PASS = 'open-sesame';
 
 let handle: ServerHandle;
+let webUiModule: WebUiModule;
 
 function basicAuthHeader(user: string, pass: string): string {
   return `Basic ${Buffer.from(`${user}:${pass}`).toString('base64')}`;
@@ -59,13 +60,13 @@ beforeAll(async () => {
 
   // Bun.serve supports port=0 → OS picks a free port; we read it back from
   // the server. Avoids collisions when the test harness retries.
-  const mod = new WebUiModule({
+  webUiModule = new WebUiModule({
     port: 0,
     host: '127.0.0.1',
     basicAuth: { username: BASIC_USER, password: BASIC_PASS },
     staticDir: staticRoot,
   });
-  await mod.start({} as ModuleContext);
+  await webUiModule.start({} as ModuleContext);
 
   const port = __getSharedServerPortForTests();
   if (!port) throw new Error('webui server not bound; did start() succeed?');
@@ -74,7 +75,7 @@ beforeAll(async () => {
     port,
     staticRoot,
     cleanup: async () => {
-      await mod.stop();
+      await webUiModule.stop();
       await __resetSharedServerForTests();
       rmSync(tmp, { recursive: true, force: true });
       rmSync(sibling, { recursive: true, force: true });
@@ -125,6 +126,191 @@ describe('WebUiModule HTTP', () => {
     expect(body).toContain('console.log');
   });
 
+  test('retrieval trace routes require auth and expose the in-memory viewer', async () => {
+    for (const path of ['/debug/retrieval', '/debug/retrieval/view']) {
+      const unauthenticated = await fetch(`http://127.0.0.1:${handle.port}${path}`);
+      expect(unauthenticated.status).toBe(401);
+      expect(unauthenticated.headers.get('cache-control')).toBe('no-store');
+    }
+
+    const headers = { authorization: basicAuthHeader(BASIC_USER, BASIC_PASS) };
+    const unbound = await fetch(`http://127.0.0.1:${handle.port}/debug/retrieval`, { headers });
+    expect(unbound.status).toBe(503);
+    expect(unbound.headers.get('cache-control')).toBe('no-store');
+    expect(await unbound.json()).toEqual({ error: 'app not bound yet' });
+
+    const viewer = await fetch(`http://127.0.0.1:${handle.port}/debug/retrieval/view`, { headers });
+    expect(viewer.status).toBe(200);
+    expect(viewer.headers.get('cache-control')).toBe('no-store');
+    const viewerHtml = await viewer.text();
+    expect(viewerHtml).toContain('Retrieval traces');
+    expect(viewerHtml).toContain('Selected lessons');
+    expect(viewerHtml).toContain('Candidate lessons');
+    expect(viewerHtml).toContain('Raw JSON (diagnostic)');
+    expect(viewerHtml).toContain("'agent: ' + (trace.agentName || 'unknown')");
+    expect(viewerHtml).toContain("reasoning ? reasoning.effort : 'default'");
+    expect(viewerHtml).not.toContain('reasoning.context');
+    expect(viewerHtml).toContain('node.textContent = String(text)');
+    expect(viewerHtml).not.toContain('.innerHTML');
+    expect(viewerHtml).not.toContain('\\u201C');
+    expect(viewerHtml).not.toContain('\\u201D');
+
+    const signIn = await fetch(`http://127.0.0.1:${handle.port}/auth/basic`, {
+      headers,
+      redirect: 'manual',
+    });
+    const cookie = (signIn.headers.get('set-cookie') ?? '').split(';', 1)[0];
+    expect(signIn.status).toBe(302);
+    expect(cookie.startsWith('fkm_obs=')).toBe(true);
+
+    const sessionJson = await fetch(`http://127.0.0.1:${handle.port}/debug/retrieval`, {
+      headers: { cookie },
+    });
+    expect(sessionJson.status).toBe(503);
+    expect(sessionJson.headers.get('cache-control')).toBe('no-store');
+    const sessionViewer = await fetch(
+      `http://127.0.0.1:${handle.port}/debug/retrieval/view`,
+      { headers: { cookie } },
+    );
+    expect(sessionViewer.status).toBe(200);
+    expect(sessionViewer.headers.get('cache-control')).toBe('no-store');
+  });
+
+  test('bound retrieval JSON is no-store, redacted by default, and inputs require exact 1', async () => {
+    let observedOptions: { limit?: number; includeInputs?: boolean } | undefined;
+    const malicious = '</script><img src=x onerror="globalThis.pwned=true">';
+    const retrieval = {
+      name: 'retrieval',
+      getRetrievalTraces: (options: { limit?: number; includeInputs?: boolean } = {}) => {
+        observedOptions = options;
+        return [{
+          schemaVersion: 1,
+          id: 1,
+          startedAt: '2026-07-31T00:00:00.000Z',
+          agentName: 'test-agent',
+          config: {
+            model: 'test-retrieval-model',
+            requestedReasoning: { effort: 'high' },
+            minConfidence: 0.3,
+            maxCandidates: 20,
+            maxInjectedLessons: 5,
+          },
+          context: {
+            hash: 'abc', messageCount: 1, messageIds: ['m1'],
+            ...(options.includeInputs ? { input: 'private recent conversation' } : {}),
+          },
+          cache: { hit: false },
+          candidates: [{
+            id: 'malicious-lesson', content: malicious, confidence: 0.9,
+            tags: [malicious], evidence: [], created: 1, updated: 1,
+            deprecated: false, matches: [],
+          }],
+          relevantLessonIds: [],
+          injected: { lessonIds: [], lessons: [] },
+          outcome: 'no-concepts',
+        }];
+      },
+    };
+    const framework = {
+      getAllAgents: () => [],
+      getAllModules: () => [retrieval],
+      getSessionUsage: () => { throw new Error('no usage in HTTP harness'); },
+      onTrace: () => {},
+    };
+    webUiModule.setApp({ framework } as never);
+
+    const headers = { authorization: basicAuthHeader(BASIC_USER, BASIC_PASS) };
+    try {
+      const defaultRes = await fetch(
+        `http://127.0.0.1:${handle.port}/debug/retrieval?limit=7`, { headers },
+      );
+      expect(defaultRes.status).toBe(200);
+      expect(defaultRes.headers.get('cache-control')).toBe('no-store');
+      const defaultBody = await defaultRes.json() as Record<string, unknown>;
+      expect(defaultBody.enabled).toBe(true);
+      expect(defaultBody.includeInputs).toBe(false);
+      expect(JSON.stringify(defaultBody)).not.toContain('private recent conversation');
+      const returnedTraces = defaultBody.traces as Array<{
+        candidates: Array<{ content: string }>;
+      }>;
+      expect(returnedTraces[0].candidates[0].content).toBe(malicious);
+      expect(observedOptions).toEqual({ limit: 7, includeInputs: false });
+
+      const viewerRes = await fetch(
+        `http://127.0.0.1:${handle.port}/debug/retrieval/view`, { headers },
+      );
+      const viewerHtml = await viewerRes.text();
+      // Static viewer markup does not inline trace data; dynamic values use text sinks.
+      expect(viewerHtml).not.toContain(malicious);
+      expect(viewerHtml).toContain('textContent');
+      expect(viewerHtml).not.toContain('.innerHTML');
+
+      for (const alias of ['true', 'yes', '01']) {
+        const res = await fetch(
+          `http://127.0.0.1:${handle.port}/debug/retrieval?includeInputs=${alias}`, { headers },
+        );
+        const body = await res.json() as Record<string, unknown>;
+        expect(body.includeInputs).toBe(false);
+        expect(JSON.stringify(body)).not.toContain('private recent conversation');
+      }
+
+      const exactRes = await fetch(
+        `http://127.0.0.1:${handle.port}/debug/retrieval?includeInputs=1`, { headers },
+      );
+      const exactBody = await exactRes.json() as Record<string, unknown>;
+      expect(exactBody.includeInputs).toBe(true);
+      expect(JSON.stringify(exactBody)).toContain('private recent conversation');
+      expect(observedOptions).toEqual({ limit: 20, includeInputs: true });
+    } finally {
+      await webUiModule.stop();
+    }
+  });
+
+  test('bound app without retrieval reports tracing disabled', async () => {
+    const framework = {
+      getAllAgents: () => [],
+      getAllModules: () => [],
+      getSessionUsage: () => { throw new Error('no usage in HTTP harness'); },
+      onTrace: () => {},
+    };
+    webUiModule.setApp({ framework } as never);
+    try {
+      const res = await fetch(`http://127.0.0.1:${handle.port}/debug/retrieval`, {
+        headers: { authorization: basicAuthHeader(BASIC_USER, BASIC_PASS) },
+      });
+      expect(res.status).toBe(200);
+      expect(res.headers.get('cache-control')).toBe('no-store');
+      expect(await res.json()).toEqual({
+        schemaVersion: 1, enabled: false, includeInputs: false, traces: [],
+      });
+    } finally {
+      await webUiModule.stop();
+    }
+  });
+
+  test('retrieval JSON errors are also no-store', async () => {
+    const framework = {
+      getAllAgents: () => [],
+      getAllModules: () => [{
+        name: 'retrieval',
+        getRetrievalTraces: () => { throw new Error('trace listing failed'); },
+      }],
+      getSessionUsage: () => { throw new Error('no usage in HTTP harness'); },
+      onTrace: () => {},
+    };
+    webUiModule.setApp({ framework } as never);
+    try {
+      const res = await fetch(`http://127.0.0.1:${handle.port}/debug/retrieval`, {
+        headers: { authorization: basicAuthHeader(BASIC_USER, BASIC_PASS) },
+      });
+      expect(res.status).toBe(500);
+      expect(res.headers.get('cache-control')).toBe('no-store');
+      expect(await res.json()).toEqual({ error: 'trace listing failed' });
+    } finally {
+      await webUiModule.stop();
+    }
+  });
+
   // Path containment: a request for /../<sibling-of-staticRoot>/secret.txt
   // would, pre-fix, slip past the `startsWith(root)` check because the
   // sibling directory's path begins with `<staticRoot>-evil`. The new check

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

@@ -287,7 +287,7 @@ describe('WebUiModule observer flow (e2e)', () => {
 
   test('grant appears (hot-reload): static public, observer WS flow end-to-end', async () => {
     saveObserversFile(observersPath, {
-      observers: [{ key: kp.id, label: 'e2e-device', scopes: ['health', 'ops'] }],
+      observers: [{ key: kp.id, label: 'e2e-device', scopes: ['health', 'ops', 'debug'] }],
     });
     await new Promise((r) => setTimeout(r, 3600)); // registry poll is 3s
 
@@ -319,7 +319,7 @@ describe('WebUiModule observer flow (e2e)', () => {
     ws.send(JSON.stringify({ type: 'observer-hello', identity: helloFor(kp, host) }));
     const ack = await got('observer-ack');
     expect(ack.label).toBe('e2e-device');
-    expect((ack.scopes as string[]).sort()).toEqual(['health', 'ops']);
+    expect((ack.scopes as string[]).sort()).toEqual(['debug', 'health', 'ops']);
 
     // Read-only: mutating messages are refused.
     ws.send(JSON.stringify({ type: 'user-message', content: 'hi' }));
@@ -340,11 +340,14 @@ describe('WebUiModule observer flow (e2e)', () => {
     });
     expect(String(branchErr.message)).toContain('forbidden');
 
-    // Session cookie: health allowed, debug denied (not in scopes).
+    // Session cookie: ordinary debug is allowed by scope, but retrieval traces
+    // remain operator-only because they can expose lessons and opt-in inputs.
     const cookie = `fkm_obs=${ack.sessionToken}`;
-    // healthz returns 503 (app not bound in this harness) — auth passed.
+    // 503 means authorization passed but this harness has no bound app.
     expect((await fetch(`${base()}/healthz`, { headers: { cookie } })).status).toBe(503);
-    expect((await fetch(`${base()}/debug/context`, { headers: { cookie } })).status).toBe(401);
+    expect((await fetch(`${base()}/debug/context`, { headers: { cookie } })).status).toBe(503);
+    expect((await fetch(`${base()}/debug/retrieval`, { headers: { cookie } })).status).toBe(401);
+    expect((await fetch(`${base()}/debug/retrieval/view`, { headers: { cookie } })).status).toBe(401);
     // Basic auth still works for everything.
     expect((await fetch(`${base()}/healthz`, { headers: { authorization: BASIC } })).status).toBe(503);