@animalabs/connectome-host 0.8.0 → 0.8.1

package/test/subconscious-recipe.test.ts

@@ -0,0 +1,86 @@
+/**
+ * Recipe surface for tune-out's subconscious resident (agent-framework#77):
+ * schema validation of the `subconscious` block. The block passes through to
+ * FrameworkConfig.subconscious verbatim, so validation is the host's whole
+ * contribution — a typo'd key or a missing mode block must fail at recipe
+ * load, not surface as a subconscious running on an empty system prompt.
+ */
+import { describe, test, expect } from 'bun:test';
+import { validateRecipe } from '../src/recipe.js';
+
+function baseRecipe(extra: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    name: 'Test',
+    agent: { name: 'sherlock', systemPrompt: 'test' },
+    ...extra,
+  };
+}
+
+const MODE = 'You are the Subconscious. Watch tuned-out channels and report in second person.';
+
+describe('validateRecipe — subconscious schema', () => {
+  test('absent block is accepted', () => {
+    expect(() => validateRecipe(baseRecipe())).not.toThrow();
+    expect(validateRecipe(baseRecipe()).subconscious).toBeUndefined();
+  });
+
+  test('full valid block is accepted and passes through verbatim', () => {
+    const block = {
+      enabled: true,
+      name: 'Subconscious',
+      model: 'claude-sonnet-4-5',
+      systemPrompt: MODE,
+      allowChannelSpeech: false,
+      reAnchorFraction: 0.5,
+    };
+    const recipe = validateRecipe(baseRecipe({ subconscious: block }));
+    expect(recipe.subconscious).toEqual(block);
+  });
+
+  test('minimal block: enabled + systemPrompt', () => {
+    expect(() => validateRecipe(baseRecipe({ subconscious: { enabled: true, systemPrompt: MODE } }))).not.toThrow();
+    expect(() => validateRecipe(baseRecipe({ subconscious: { enabled: false, systemPrompt: MODE } }))).not.toThrow();
+  });
+
+  test('non-object block is refused', () => {
+    expect(() => validateRecipe(baseRecipe({ subconscious: true }))).toThrow(/subconscious must be an object/);
+    expect(() => validateRecipe(baseRecipe({ subconscious: [] }))).toThrow(/subconscious must be an object/);
+  });
+
+  test('enabled must be a boolean', () => {
+    expect(() => validateRecipe(baseRecipe({ subconscious: { enabled: 'yes', systemPrompt: MODE } })))
+      .toThrow(/subconscious\.enabled must be a boolean/);
+    expect(() => validateRecipe(baseRecipe({ subconscious: { systemPrompt: MODE } })))
+      .toThrow(/subconscious\.enabled must be a boolean/);
+  });
+
+  test('systemPrompt is required and non-empty — the mode block is the whole character', () => {
+    expect(() => validateRecipe(baseRecipe({ subconscious: { enabled: true } })))
+      .toThrow(/subconscious\.systemPrompt must be a non-empty string/);
+    expect(() => validateRecipe(baseRecipe({ subconscious: { enabled: true, systemPrompt: '   ' } })))
+      .toThrow(/subconscious\.systemPrompt must be a non-empty string/);
+  });
+
+  test('unknown fields are refused by name', () => {
+    expect(() => validateRecipe(baseRecipe({ subconscious: { enabled: true, systemPrompt: MODE, cadence: 30 } })))
+      .toThrow(/unknown field "cadence"/);
+  });
+
+  test('name and model must be non-empty strings when present', () => {
+    expect(() => validateRecipe(baseRecipe({ subconscious: { enabled: true, systemPrompt: MODE, name: '' } })))
+      .toThrow(/subconscious\.name must be a non-empty string/);
+    expect(() => validateRecipe(baseRecipe({ subconscious: { enabled: true, systemPrompt: MODE, model: 7 } })))
+      .toThrow(/subconscious\.model must be a non-empty string/);
+  });
+
+  test('allowChannelSpeech must be a boolean; reAnchorFraction must be in (0, 1]', () => {
+    expect(() => validateRecipe(baseRecipe({ subconscious: { enabled: true, systemPrompt: MODE, allowChannelSpeech: 'no' } })))
+      .toThrow(/allowChannelSpeech must be a boolean/);
+    for (const bad of [0, 1.5, -0.2, 'half']) {
+      expect(() => validateRecipe(baseRecipe({ subconscious: { enabled: true, systemPrompt: MODE, reAnchorFraction: bad } })))
+        .toThrow(/reAnchorFraction must be a number in \(0, 1\]/);
+    }
+    expect(() => validateRecipe(baseRecipe({ subconscious: { enabled: true, systemPrompt: MODE, reAnchorFraction: 1 } })))
+      .not.toThrow();
+  });
+});

package/test/tool-wrapper-prose-guard-recipe.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from 'bun:test';
+import { buildFrameworkAgentConfig } from '../src/framework-agent-config.js';
+import { validateRecipe } from '../src/recipe.js';
+
+const base = (value?: unknown) => ({
+  name: 'tool-wrapper-prose-guard',
+  agent: {
+    systemPrompt: 'sys',
+    ...(value === undefined ? {} : { toolWrapperProseGuard: value }),
+  },
+});
+
+describe('toolWrapperProseGuard recipe wiring', () => {
+  test('is default-off by omission and composes true into AgentConfig', () => {
+    const absent = validateRecipe(base());
+    expect(absent.agent.toolWrapperProseGuard).toBeUndefined();
+    expect(buildFrameworkAgentConfig(absent, 'a', 'm', { kind: 's' } as never).toolWrapperProseGuard).toBeUndefined();
+
+    const enabled = validateRecipe(base(true));
+    expect(enabled.agent.toolWrapperProseGuard).toBe(true);
+    expect(buildFrameworkAgentConfig(enabled, 'a', 'm', { kind: 's' } as never).toolWrapperProseGuard).toBe(true);
+
+    const disabled = validateRecipe(base(false));
+    expect(disabled.agent.toolWrapperProseGuard).toBe(false);
+    expect(buildFrameworkAgentConfig(disabled, 'b', 'm', { kind: 's' } as never).toolWrapperProseGuard).toBe(false);
+
+    const reloaded = validateRecipe(JSON.parse(JSON.stringify(enabled)));
+    expect(buildFrameworkAgentConfig(reloaded, 'c', 'm', { kind: 's' } as never).toolWrapperProseGuard).toBe(true);
+    expect(buildFrameworkAgentConfig(absent, 'd', 'm', { kind: 's' } as never).toolWrapperProseGuard).toBeUndefined();
+  });
+
+  test('rejects non-boolean values instead of silently disabling the guard', () => {
+    for (const value of ['true', 1, null, {}]) {
+      expect(() => validateRecipe(base(value))).toThrow(/toolWrapperProseGuard/);
+    }
+  });
+});

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

@@ -330,6 +330,47 @@ describe('WebUiModule HTTP', () => {
     const body = res.status < 500 ? await res.text() : '';
     expect(body).not.toContain('pwned');
   });
+
+  // Honest-error regression set: unknown API routes and missing bundle
+  // assets used to fall through to the SPA shell with a 200, and wrong
+  // methods executed the GET handlers.
+
+  test('unknown /debug/* route returns a JSON 404, not the SPA shell', async () => {
+    for (const path of ['/debug/context/', '/debug/CONTEXT', '/debug/nonexistent']) {
+      const res = await fetch(`http://127.0.0.1:${handle.port}${path}`, {
+        headers: { authorization: basicAuthHeader(BASIC_USER, BASIC_PASS) },
+      });
+      expect(res.status).toBe(404);
+      expect(res.headers.get('content-type')).toContain('application/json');
+    }
+  });
+
+  test('missing /assets/* returns 404, not HTML', async () => {
+    const res = await fetch(`http://127.0.0.1:${handle.port}/assets/nonexistent.js`, {
+      headers: { authorization: basicAuthHeader(BASIC_USER, BASIC_PASS) },
+    });
+    expect(res.status).toBe(404);
+    expect(res.headers.get('content-type') ?? '').not.toContain('text/html');
+  });
+
+  test('non-GET methods get 405 with Allow header', async () => {
+    for (const method of ['POST', 'DELETE', 'PUT']) {
+      const res = await fetch(`http://127.0.0.1:${handle.port}/debug/context`, {
+        method,
+        headers: { authorization: basicAuthHeader(BASIC_USER, BASIC_PASS) },
+      });
+      expect(res.status).toBe(405);
+      expect(res.headers.get('allow')).toContain('GET');
+    }
+  });
+
+  test('SPA client-side routes still fall back to the shell', async () => {
+    const res = await fetch(`http://127.0.0.1:${handle.port}/totally/fake/route`, {
+      headers: { authorization: basicAuthHeader(BASIC_USER, BASIC_PASS) },
+    });
+    expect(res.status).toBe(200);
+    expect(await res.text()).toContain('<!doctype html>');
+  });
 });
 
 describe('WebUiModule WebSocket', () => {

package/web/src/App.tsx

@@ -1058,6 +1058,15 @@ export function App() {
     if (!text) return;
     setDraft('');
     if (text.startsWith('/')) {
+      // /clear is display-local (the TUI clears its scrollback the same
+      // way): wipe this client's transcript view without touching the
+      // Chronicle or other clients. Sending it to the host was a no-op
+      // that APPENDED a "(cleared)" line — the opposite of clearing.
+      if (text === '/clear' || text.startsWith('/clear ')) {
+        setMessages(produce((arr) => { arr.length = 0; }));
+        setStreamLines([]);
+        return;
+      }
       wire.send({ type: 'command', command: text });
       return;
     }