@animalabs/connectome-host 0.3.9 → 0.4.0

package/test/recipe-extensions.test.ts

@@ -0,0 +1,295 @@
+/**
+ * Tests for the recipe `extensions` seam: schema validation, load-time path
+ * resolution, the extension loader/registry, and custom strategy dispatch
+ * through buildFrameworkStrategy.
+ */
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { loadRecipe, validateRecipe, type Recipe } from '../src/recipe.js';
+import {
+  loadExtensions,
+  emptyExtensionRegistry,
+  isBuiltinStrategyType,
+} from '../src/extensions.js';
+import { buildFrameworkStrategy } from '../src/framework-strategy.js';
+
+let dir: string;
+beforeEach(() => {
+  dir = mkdtempSync(join(tmpdir(), 'recipe-ext-'));
+});
+afterEach(() => {
+  rmSync(dir, { recursive: true, force: true });
+});
+
+function baseRecipe(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    name: 'Ext Test',
+    agent: { systemPrompt: 'x' },
+    ...overrides,
+  };
+}
+
+/** Write an extension module file and return its absolute path. */
+function writeExtension(filename: string, body: string): string {
+  const path = join(dir, filename);
+  writeFileSync(path, body, 'utf-8');
+  return path;
+}
+
+// ---------------------------------------------------------------------------
+// validateRecipe
+// ---------------------------------------------------------------------------
+
+describe('validateRecipe extensions block', () => {
+  test('accepts a well-formed extensions block', () => {
+    const recipe = validateRecipe(baseRecipe({
+      extensions: {
+        zk: { kind: 'strategy', path: './ext.ts', config: { a: 1 } },
+        feeder: { kind: 'module', path: '/abs/feeder.ts' },
+      },
+    }));
+    expect(Object.keys(recipe.extensions!)).toEqual(['zk', 'feeder']);
+  });
+
+  test('rejects bad kind', () => {
+    expect(() => validateRecipe(baseRecipe({
+      extensions: { zk: { kind: 'plugin', path: './ext.ts' } },
+    }))).toThrow(/kind must be "strategy" or "module"/);
+  });
+
+  test('rejects missing path', () => {
+    expect(() => validateRecipe(baseRecipe({
+      extensions: { zk: { kind: 'strategy' } },
+    }))).toThrow(/path must be a non-empty string/);
+  });
+
+  test('rejects non-object config', () => {
+    expect(() => validateRecipe(baseRecipe({
+      extensions: { zk: { kind: 'strategy', path: './e.ts', config: [1] } },
+    }))).toThrow(/config must be an object/);
+  });
+
+  test('rejects array extensions block', () => {
+    expect(() => validateRecipe(baseRecipe({ extensions: [] })))
+      .toThrow(/must be an object mapping names/);
+  });
+
+  test('custom strategy type without a strategy-kind extension is rejected', () => {
+    expect(() => validateRecipe(baseRecipe({
+      agent: { systemPrompt: 'x', strategy: { type: 'zk' } },
+    }))).toThrow(/Invalid strategy type "zk"/);
+  });
+
+  test('custom strategy type with only module-kind extensions is rejected', () => {
+    expect(() => validateRecipe(baseRecipe({
+      agent: { systemPrompt: 'x', strategy: { type: 'zk' } },
+      extensions: { feeder: { kind: 'module', path: './f.ts' } },
+    }))).toThrow(/Invalid strategy type "zk"/);
+  });
+
+  test('custom strategy type with a strategy-kind extension is accepted', () => {
+    const recipe = validateRecipe(baseRecipe({
+      agent: { systemPrompt: 'x', strategy: { type: 'zk' } },
+      extensions: { zk: { kind: 'strategy', path: './e.ts' } },
+    }));
+    expect(recipe.agent.strategy?.type).toBe('zk');
+  });
+
+  test('built-in strategy types still validate without extensions', () => {
+    const recipe = validateRecipe(baseRecipe({
+      agent: { systemPrompt: 'x', strategy: { type: 'frontdesk' } },
+    }));
+    expect(recipe.agent.strategy?.type).toBe('frontdesk');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// loadRecipe path resolution
+// ---------------------------------------------------------------------------
+
+describe('loadRecipe extension path resolution', () => {
+  test('relative extension paths resolve against the recipe dir', async () => {
+    const recipePath = join(dir, 'r.json');
+    writeFileSync(recipePath, JSON.stringify(baseRecipe({
+      extensions: { zk: { kind: 'module', path: './exts/zk.ts' } },
+    })), 'utf-8');
+    const recipe = await loadRecipe(recipePath);
+    expect(recipe.extensions!.zk!.path).toBe(join(dir, 'exts', 'zk.ts'));
+  });
+
+  test('absolute extension paths pass through', async () => {
+    const recipePath = join(dir, 'r.json');
+    writeFileSync(recipePath, JSON.stringify(baseRecipe({
+      extensions: { zk: { kind: 'module', path: '/opt/zk/index.ts' } },
+    })), 'utf-8');
+    const recipe = await loadRecipe(recipePath);
+    expect(recipe.extensions!.zk!.path).toBe('/opt/zk/index.ts');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// loadExtensions
+// ---------------------------------------------------------------------------
+
+describe('loadExtensions', () => {
+  test('empty when no extensions declared', async () => {
+    const recipe = validateRecipe(baseRecipe());
+    const registry = await loadExtensions(recipe);
+    expect(registry.strategies.size).toBe(0);
+    expect(registry.modules.length).toBe(0);
+  });
+
+  test('collects strategy and module registrations, passing config', async () => {
+    const path = writeExtension('combo.mjs', `
+      export function register(api, config) {
+        api.registerStrategy('zk', (ctx) => ({ kind: 'zk-strategy', opts: ctx }));
+        api.registerModule((ctx) => ({ name: 'zk-feeder', ctx }));
+        if (config.marker !== 'hello') throw new Error('config not passed');
+      }
+    `);
+    const recipe = validateRecipe(baseRecipe({
+      extensions: { zk: { kind: 'strategy', path, config: { marker: 'hello' } } },
+    }));
+    const registry = await loadExtensions(recipe);
+    expect(registry.strategies.has('zk')).toBe(true);
+    expect(registry.modules.length).toBe(1);
+    expect(registry.modules[0]!.extensionName).toBe('zk');
+    expect(registry.modules[0]!.config).toEqual({ marker: 'hello' });
+  });
+
+  test('accepts a default-export register function', async () => {
+    const path = writeExtension('default.mjs', `
+      export default function (api) {
+        api.registerStrategy('dflt', () => ({ kind: 'dflt' }));
+      }
+    `);
+    const recipe = validateRecipe(baseRecipe({
+      extensions: { d: { kind: 'strategy', path } },
+    }));
+    const registry = await loadExtensions(recipe);
+    expect(registry.strategies.has('dflt')).toBe(true);
+  });
+
+  test('supports async register', async () => {
+    const path = writeExtension('async.mjs', `
+      export async function register(api) {
+        await Promise.resolve();
+        api.registerModule(() => ({ name: 'late' }));
+      }
+    `);
+    const recipe = validateRecipe(baseRecipe({
+      extensions: { a: { kind: 'module', path } },
+    }));
+    const registry = await loadExtensions(recipe);
+    expect(registry.modules.length).toBe(1);
+  });
+
+  test('rejects a module without a register function', async () => {
+    const path = writeExtension('bad.mjs', `export const nothing = 1;`);
+    const recipe = validateRecipe(baseRecipe({
+      extensions: { bad: { kind: 'module', path } },
+    }));
+    await expect(loadExtensions(recipe)).rejects.toThrow(/must export a "register" function/);
+  });
+
+  test('rejects relative paths at load time', async () => {
+    const recipe = validateRecipe(baseRecipe({
+      extensions: { rel: { kind: 'module', path: './never-resolved.ts' } },
+    }));
+    await expect(loadExtensions(recipe)).rejects.toThrow(/not absolute/);
+  });
+
+  test('rejects registering a built-in strategy name', async () => {
+    const path = writeExtension('builtin-clash.mjs', `
+      export function register(api) {
+        api.registerStrategy('autobiographical', () => ({}));
+      }
+    `);
+    const recipe = validateRecipe(baseRecipe({
+      extensions: { clash: { kind: 'strategy', path } },
+    }));
+    await expect(loadExtensions(recipe)).rejects.toThrow(/collides with a built-in/);
+  });
+
+  test('rejects duplicate strategy registrations across extensions', async () => {
+    const p1 = writeExtension('one.mjs', `
+      export function register(api) { api.registerStrategy('zk', () => ({})); }
+    `);
+    const p2 = writeExtension('two.mjs', `
+      export function register(api) { api.registerStrategy('zk', () => ({})); }
+    `);
+    const recipe = validateRecipe(baseRecipe({
+      extensions: {
+        one: { kind: 'strategy', path: p1 },
+        two: { kind: 'strategy', path: p2 },
+      },
+    }));
+    await expect(loadExtensions(recipe)).rejects.toThrow(/already registered/);
+  });
+
+  test('wraps import failures with the extension name', async () => {
+    const path = writeExtension('boom.mjs', `throw new Error('kaboom at import');`);
+    const recipe = validateRecipe(baseRecipe({
+      extensions: { boom: { kind: 'module', path } },
+    }));
+    await expect(loadExtensions(recipe)).rejects.toThrow(/extension "boom".*failed to import/);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// buildFrameworkStrategy custom dispatch
+// ---------------------------------------------------------------------------
+
+describe('buildFrameworkStrategy with extensions', () => {
+  test('dispatches a custom type through the registry with full config', async () => {
+    const path = writeExtension('strat.mjs', `
+      export function register(api) {
+        api.registerStrategy('zk', (ctx) => ({
+          kind: 'zk',
+          model: ctx.model,
+          timeZone: ctx.timeZone,
+          customKnob: ctx.config.customKnob,
+        }));
+      }
+    `);
+    const recipe = validateRecipe(baseRecipe({
+      agent: {
+        systemPrompt: 'x',
+        strategy: { type: 'zk', customKnob: 42 },
+      },
+      extensions: { zk: { kind: 'strategy', path } },
+    })) as Recipe;
+    const registry = await loadExtensions(recipe);
+    const strategy = buildFrameworkStrategy(recipe, 'test-model', 'UTC', registry) as unknown as Record<string, unknown>;
+    expect(strategy.kind).toBe('zk');
+    expect(strategy.model).toBe('test-model');
+    expect(strategy.timeZone).toBe('UTC');
+    expect(strategy.customKnob).toBe(42);
+  });
+
+  test('throws a precise error when a declared type was never registered', () => {
+    const recipe = validateRecipe(baseRecipe({
+      agent: { systemPrompt: 'x', strategy: { type: 'ghost' } },
+      extensions: { zk: { kind: 'strategy', path: '/tmp/unused.ts' } },
+    })) as Recipe;
+    expect(() => buildFrameworkStrategy(recipe, 'm', 'UTC', emptyExtensionRegistry()))
+      .toThrow(/"ghost" is not built-in and no loaded extension registered it/);
+  });
+
+  test('built-in dispatch is unaffected by an empty registry', () => {
+    const recipe = validateRecipe(baseRecipe()) as Recipe;
+    const strategy = buildFrameworkStrategy(recipe, 'm', 'UTC', emptyExtensionRegistry());
+    expect(strategy).toBeDefined();
+  });
+});
+
+describe('isBuiltinStrategyType', () => {
+  test('recognizes the three built-ins and nothing else', () => {
+    expect(isBuiltinStrategyType('autobiographical')).toBe(true);
+    expect(isBuiltinStrategyType('passthrough')).toBe(true);
+    expect(isBuiltinStrategyType('frontdesk')).toBe(true);
+    expect(isBuiltinStrategyType('zk')).toBe(false);
+  });
+});

package/test/recipe-provider.test.ts

@@ -6,10 +6,19 @@ function recipe(agent: Record<string, unknown> = {}) {
 }
 
 describe('recipe provider validation', () => {
-  test('preserves Anthropic as the omitted provider and accepts Responses', () => {
+  test('preserves Anthropic as the omitted provider and accepts OpenAI providers', () => {
     expect(validateRecipe(recipe()).agent.provider).toBeUndefined();
     expect(validateRecipe(recipe({ provider: 'openai-responses' })).agent.provider)
       .toBe('openai-responses');
+    expect(validateRecipe(recipe({ provider: 'openai-codex' })).agent.provider)
+      .toBe('openai-codex');
+  });
+
+  test('accepts Codex subscription settings', () => {
+    expect(validateRecipe(recipe({
+      provider: 'openai-codex',
+      codex: { fastMode: true },
+    })).agent.codex).toEqual({ fastMode: true });
   });
 
   test('accepts Responses reasoning and compaction settings', () => {
@@ -19,11 +28,13 @@ describe('recipe provider validation', () => {
         reasoningEffort: 'xhigh',
         reasoningContext: 'all_turns',
         compactThreshold: 100_000,
+        serviceTier: 'priority',
       },
     })).agent.responses).toEqual({
       reasoningEffort: 'xhigh',
       reasoningContext: 'all_turns',
       compactThreshold: 100_000,
+      serviceTier: 'priority',
     });
   });
 
@@ -32,5 +43,7 @@ describe('recipe provider validation', () => {
     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/);
+    expect(() => validateRecipe(recipe({ responses: { serviceTier: 'fast' } }))).toThrow(/serviceTier/);
+    expect(() => validateRecipe(recipe({ codex: { fastMode: 'yes' } }))).toThrow(/fastMode/);
   });
 });

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

@@ -94,7 +94,7 @@ describe('SubscriptionGcModule', () => {
     await m.stop();
   });
 
-  test('"off" override pins a channel; counters persist across restart', async () => {
+  test('"off" override disables auto-close; counters persist across restart', async () => {
     const m = new SubscriptionGcModule({ defaultLimitChars: 5 });
     const { ctx, toolCalls, getState } = mockCtx();
     await m.start(ctx);
@@ -136,3 +136,158 @@ describe('SubscriptionGcModule', () => {
     await m2.stop();
   });
 });
+
+describe('agent_settings extension (channel_idle_limits)', () => {
+  test('declares no standalone tools but keeps the old names routable', async () => {
+    const mod = new SubscriptionGcModule();
+    await mod.start(mockCtx().ctx as unknown as ModuleContext);
+    expect(mod.getTools()).toEqual([]);
+    // Undeclared ≠ dead: agent muscle memory routes via the old name.
+    const result = await mod.handleToolCall({
+      id: 't1',
+      name: 'set_channel_idle_limit',
+      input: { channelId: 'C1', limit: 'off' },
+    });
+    expect(result.success).toBe(true);
+    const ext = mod.getAgentSettingsExtension();
+    expect(ext.get('agent').channel_idle_limits).toEqual({ C1: 'off' });
+  });
+
+  test('get reports read-only status: default, counters, pins', async () => {
+    const mod = new SubscriptionGcModule({ defaultLimitChars: 10 });
+    const { ctx } = mockCtx();
+    await mod.start(ctx);
+    await mod.onProcess(ambient('c1', 'abc'), PS);
+    await mod.handleToolCall({
+      id: 't1',
+      name: 'pin_channel_idle_limit',
+      input: { channelId: 'C9', pinned: true },
+    });
+    const ext = mod.getAgentSettingsExtension();
+    expect(ext.get('agent')).toEqual({
+      channel_idle_limits: {},
+      channel_idle_default: 10,
+      channel_idle_counters: { 'discord:g1:c1': 3 },
+      channel_idle_pinned: ['C9'],
+    });
+    await mod.stop();
+  });
+
+  test('update merges per entry: number, off, default/null', async () => {
+    const mod = new SubscriptionGcModule();
+    await mod.start(mockCtx().ctx as unknown as ModuleContext);
+    const ext = mod.getAgentSettingsExtension();
+    ext.update('agent', { channel_idle_limits: { A: 5000, B: 'off', C: '12000' } });
+    expect(ext.get('agent').channel_idle_limits).toEqual({ A: 5000, B: 'off', C: 12000 });
+    // merge: only mentioned entries change; default/null clear
+    ext.update('agent', { channel_idle_limits: { A: 'default', B: null } });
+    expect(ext.get('agent').channel_idle_limits).toEqual({ C: 12000 });
+  });
+
+  test('update rejects junk values with a clear error', async () => {
+    const mod = new SubscriptionGcModule();
+    await mod.start(mockCtx().ctx as unknown as ModuleContext);
+    const ext = mod.getAgentSettingsExtension();
+    expect(() => ext.update('agent', { channel_idle_limits: { A: -3 } })).toThrow(/positive/);
+    expect(() => ext.update('agent', { channel_idle_limits: 'off' })).toThrow(/object/);
+    expect(() => ext.update('agent', { channel_idle_limits: ['A'] })).toThrow(/object/);
+  });
+
+  test('a partially-invalid patch applies nothing', async () => {
+    const mod = new SubscriptionGcModule();
+    const { ctx, getState } = mockCtx();
+    await mod.start(ctx);
+    const ext = mod.getAgentSettingsExtension();
+    // A is valid, B is junk: the whole patch must be rejected — per-entry
+    // application would leave A live (limitFor reads the map directly) and
+    // persisted by the next flush, after the agent was told the update failed.
+    expect(() => ext.update('agent', { channel_idle_limits: { A: 5000, B: -3 } })).toThrow(
+      /positive/,
+    );
+    expect(ext.get('agent').channel_idle_limits).toEqual({});
+    const persisted = getState() as { overrides: Record<string, unknown> } | null;
+    expect(persisted?.overrides ?? {}).toEqual({});
+  });
+
+  test('reset clears all overrides', async () => {
+    const mod = new SubscriptionGcModule();
+    await mod.start(mockCtx().ctx as unknown as ModuleContext);
+    const ext = mod.getAgentSettingsExtension();
+    ext.update('agent', { channel_idle_limits: { A: 5000, B: 'off' } });
+    expect(ext.reset('agent').channel_idle_limits).toEqual({});
+    // keyed reset also clears
+    ext.update('agent', { channel_idle_limits: { A: 5000 } });
+    expect(ext.reset('agent', ['channel_idle_limits']).channel_idle_limits).toEqual({});
+    // reset for other keys leaves ours alone
+    ext.update('agent', { channel_idle_limits: { A: 5000 } });
+    expect(ext.reset('agent', ['reasoning_enabled']).channel_idle_limits).toEqual({ A: 5000 });
+  });
+});
+
+describe('system pins (pin_channel_idle_limit)', () => {
+  test('reset-all clears overrides but not pins; pinned channel stays open', async () => {
+    const mod = new SubscriptionGcModule({ defaultLimitChars: 5 });
+    const { ctx, toolCalls } = mockCtx();
+    await mod.start(ctx);
+    // ChannelMode's debounced-mode step 3.
+    await mod.handleToolCall({
+      id: 't1',
+      name: 'pin_channel_idle_limit',
+      input: { channelId: 'discord:g1:c1', pinned: true },
+    });
+    const ext = mod.getAgentSettingsExtension();
+    ext.update('agent', { channel_idle_limits: { A: 5000 } });
+    // Blanket `agent_settings reset` (e.g. to restore default reasoning).
+    const after = ext.reset('agent');
+    expect(after.channel_idle_limits).toEqual({});
+    expect(after.channel_idle_pinned).toEqual(['discord:g1:c1']);
+    // The pinned channel must NOT auto-close after the reset.
+    await mod.onProcess(ambient('c1', 'waytoolongambienttraffic'), PS);
+    expect(toolCalls.length).toBe(0);
+    await mod.stop();
+  });
+
+  test('pin/unpin round-trip preserves an agent override', async () => {
+    const mod = new SubscriptionGcModule({ defaultLimitChars: 5 });
+    const { ctx, toolCalls } = mockCtx();
+    await mod.start(ctx);
+    const ext = mod.getAgentSettingsExtension();
+    ext.update('agent', { channel_idle_limits: { 'discord:g1:c1': 9 } });
+    await mod.handleToolCall({
+      id: 't1',
+      name: 'pin_channel_idle_limit',
+      input: { channelId: 'discord:g1:c1', pinned: true },
+    });
+    await mod.onProcess(ambient('c1', 'longerthannine'), PS); // pinned → no close
+    expect(toolCalls.length).toBe(0);
+    await mod.handleToolCall({
+      id: 't2',
+      name: 'pin_channel_idle_limit',
+      input: { channelId: 'discord:g1:c1', pinned: false },
+    });
+    expect(ext.get('agent').channel_idle_limits).toEqual({ 'discord:g1:c1': 9 });
+    // Override (9) is live again: counter is at 14 from the pinned message,
+    // so the next ambient char crosses it.
+    await mod.onProcess(ambient('c1', 'x'), PS);
+    expect(toolCalls.length).toBe(1);
+    expect(toolCalls[0].name).toBe('channel_close');
+    await mod.stop();
+  });
+
+  test('pin tool validates its input', async () => {
+    const mod = new SubscriptionGcModule();
+    await mod.start(mockCtx().ctx as unknown as ModuleContext);
+    const bad1 = await mod.handleToolCall({
+      id: 't1',
+      name: 'pin_channel_idle_limit',
+      input: { pinned: true },
+    });
+    expect(bad1.success).toBe(false);
+    const bad2 = await mod.handleToolCall({
+      id: 't2',
+      name: 'pin_channel_idle_limit',
+      input: { channelId: 'C1', pinned: 'yes' },
+    });
+    expect(bad2.success).toBe(false);
+  });
+});

package/test/tui-quit-confirm.test.ts

@@ -0,0 +1,42 @@
+import { describe, test, expect } from 'bun:test';
+import { resolveQuitConfirm } from '../src/tui.js';
+
+// Pins the quit-prompt semantics. The pre-fix behavior — "anything that
+// isn't n/no/cancel → kill every fleet child and exit" — meant a user who
+// forgot the armed prompt and typed a normal chat message killed the fleet.
+// The default for arbitrary input MUST stay 'cancel-keep-input'; a refactor
+// that flips it back should fail here, loudly.
+describe('resolveQuitConfirm', () => {
+  test('only explicit consent kills', () => {
+    expect(resolveQuitConfirm('y')).toBe('kill');
+    expect(resolveQuitConfirm('yes')).toBe('kill');
+    expect(resolveQuitConfirm('YES')).toBe('kill');
+  });
+
+  test('re-typing the quit command confirms, not cancels', () => {
+    expect(resolveQuitConfirm('/quit')).toBe('kill');
+    expect(resolveQuitConfirm('/q')).toBe('kill');
+    expect(resolveQuitConfirm('quit')).toBe('kill');
+    expect(resolveQuitConfirm('q')).toBe('kill');
+  });
+
+  test('detach', () => {
+    expect(resolveQuitConfirm('d')).toBe('detach');
+    expect(resolveQuitConfirm('detach')).toBe('detach');
+  });
+
+  test('explicit and empty cancels (Enter takes the advertised [y/N/d] default)', () => {
+    expect(resolveQuitConfirm('')).toBe('cancel');
+    expect(resolveQuitConfirm('  ')).toBe('cancel');
+    expect(resolveQuitConfirm('n')).toBe('cancel');
+    expect(resolveQuitConfirm('no')).toBe('cancel');
+    expect(resolveQuitConfirm('cancel')).toBe('cancel');
+  });
+
+  test('a real message cancels AND must be restored to the input', () => {
+    expect(resolveQuitConfirm('actually, first summarize what miner found')).toBe('cancel-keep-input');
+    expect(resolveQuitConfirm('[paste #1: "…" 40000ch, 900L]')).toBe('cancel-keep-input');
+    expect(resolveQuitConfirm('/status')).toBe('cancel-keep-input');
+    expect(resolveQuitConfirm('yeah')).toBe('cancel-keep-input');
+  });
+});

package/test/tui-short-agent-name.test.ts

@@ -0,0 +1,36 @@
+import { describe, test, expect } from 'bun:test';
+import { shortAgentName } from '../src/tui.js';
+
+// Guards full↔short agent-name resolution against the naming schemes the
+// SubagentModule actually produces (see its spawn/fork paths). A helper that
+// misses one scheme silently breaks fleet-tree attribution for that agent
+// type — forks slipped through exactly this way once.
+describe('shortAgentName', () => {
+  test('spawn names: spawn-{name}-{ts}', () => {
+    expect(shortAgentName('spawn-web-1753221234567')).toBe('web');
+    expect(shortAgentName('spawn-zulip-reader-1753221234567')).toBe('zulip-reader');
+  });
+
+  test('fork names: {name}-d{depth}-{ts}, no fork- prefix', () => {
+    expect(shortAgentName('web-d1-1753221234567')).toBe('web');
+    expect(shortAgentName('zulip-reader-d3-1753221234567')).toBe('zulip-reader');
+  });
+
+  test('fork retry names: {name}-d{depth}-retry{n}-{ts}', () => {
+    expect(shortAgentName('web-d2-retry1-1753221234567')).toBe('web');
+  });
+
+  test('bare trailing -retryN (historical defensive strip)', () => {
+    expect(shortAgentName('web-retry2')).toBe('web');
+  });
+
+  test('names that are substrings of each other stay distinct', () => {
+    expect(shortAgentName('websearch-d1-1753221234567')).toBe('websearch');
+    expect(shortAgentName('spawn-websearch-1753221234567')).toBe('websearch');
+  });
+
+  test('plain names pass through', () => {
+    expect(shortAgentName('miner')).toBe('miner');
+    expect(shortAgentName('web')).toBe('web');
+  });
+});

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

@@ -326,6 +326,20 @@ describe('WebUiModule observer flow (e2e)', () => {
     const errFrame = await got('error');
     expect(String(errFrame.message)).toContain('forbidden');
 
+    // Branch listing rides the 'messages' scope, which this grant lacks.
+    ws.send(JSON.stringify({ type: 'request-branches' }));
+    const branchErr = await new Promise<Record<string, unknown>>((resolvePromise, reject) => {
+      const t = setTimeout(() => reject(new Error('timeout waiting for request-branches refusal')), 5000);
+      const check = () => {
+        const f = frames.find((m) => m.type === 'error' && String(m.message).includes('request-branches'));
+        if (f) { clearTimeout(t); resolvePromise(f); return true; }
+        return false;
+      };
+      if (check()) return;
+      ws.addEventListener('message', () => { check(); });
+    });
+    expect(String(branchErr.message)).toContain('forbidden');
+
     // Session cookie: health allowed, debug denied (not in scopes).
     const cookie = `fkm_obs=${ack.sessionToken}`;
     // healthz returns 503 (app not bound in this harness) — auth passed.