@animalabs/connectome-host 0.3.10 → 0.4.0

package/test/commands-checkpoint-restore.test.ts

@@ -0,0 +1,118 @@
+import { describe, test, expect } from 'bun:test';
+import { handleCommand, createBranchState } from '../src/commands.js';
+
+// Regression tests for /checkpoint + /restore POSITION semantics. The
+// original bug: checkpoints stored only a branch name, so /restore switched
+// to the branch HEAD — including everything after the checkpoint — rolling
+// back nothing, silently. These tests run over a stub ContextManager that
+// mimics Chronicle's contract: branchAt resolves ids against the CURRENT
+// branch's view of the log and throws for unreachable ids.
+
+interface StubMessage { id: string; participant: string; content: unknown[] }
+
+function makeStubWorld() {
+  const messagesByBranch = new Map<string, StubMessage[]>([['main', []]]);
+  let currentName = 'main';
+  let msgCounter = 0;
+
+  const cm = {
+    currentBranch: () => ({ id: currentName, name: currentName, head: messagesByBranch.get(currentName)!.length }),
+    listBranches: () => [...messagesByBranch.keys()].map(name => ({ id: name, name, head: messagesByBranch.get(name)!.length })),
+    queryMessages: (_q: unknown) => ({ messages: messagesByBranch.get(currentName)! }),
+    branchAt: (messageId: string, newName: string): string => {
+      const msgs = messagesByBranch.get(currentName)!;
+      const idx = msgs.findIndex(m => m.id === messageId);
+      if (idx === -1) throw new Error(`Message not found: ${messageId}`);
+      messagesByBranch.set(newName, msgs.slice(0, idx + 1));
+      return newName;
+    },
+    switchBranch: async (name: string): Promise<void> => {
+      if (!messagesByBranch.has(name)) throw new Error(`No such branch: ${name}`);
+      currentName = name;
+    },
+  };
+
+  const addMessage = (participant = 'user'): StubMessage => {
+    const msg: StubMessage = { id: `m${++msgCounter}`, participant, content: [] };
+    messagesByBranch.get(currentName)!.push(msg);
+    return msg;
+  };
+
+  const app = {
+    framework: {
+      getAgent: () => undefined,
+      getAllAgents: () => [{ getContextManager: () => cm }],
+      getAllModules: () => [],
+    },
+    branchState: createBranchState(),
+    userMessageCount: 0,
+  } as any;
+
+  return { cm, app, addMessage, branchCount: () => messagesByBranch.size, currentName: () => currentName };
+}
+
+describe('/checkpoint + /restore position semantics', () => {
+  test('checkpoint records the last message id, not just the branch', () => {
+    const { app, addMessage } = makeStubWorld();
+    addMessage();
+    const last = addMessage('agent');
+    handleCommand('/checkpoint cp', app);
+    const point = app.branchState.checkpoints.get('cp');
+    expect(point.branchName).toBe('main');
+    expect(point.messageId).toBe(last.id);
+  });
+
+  test('restore rolls back to the checkpoint position, not the branch head', async () => {
+    const { app, addMessage, currentName } = makeStubWorld();
+    addMessage();
+    const cpMsg = addMessage('agent');
+    handleCommand('/checkpoint cp', app);
+    addMessage();
+    addMessage('agent'); // work after the checkpoint that must be rolled back
+
+    const result = handleCommand('/restore cp', app);
+    const outcome = await result.asyncWork!;
+    expect(outcome.branchChanged).toBe(true);
+    expect(currentName().startsWith('restore-cp-')).toBe(true);
+
+    const { messages } = (app.framework.getAllAgents()[0].getContextManager() as any).queryMessages({});
+    expect(messages[messages.length - 1].id).toBe(cpMsg.id);
+  });
+
+  test('restoring while already at the checkpoint is a no-op — no branch minted', async () => {
+    const { app, addMessage, branchCount } = makeStubWorld();
+    addMessage();
+    addMessage('agent');
+    handleCommand('/checkpoint cp', app);
+    addMessage();
+
+    await handleCommand('/restore cp', app).asyncWork!;
+    const branchesAfterFirst = branchCount();
+
+    // Second restore at the same position: the guard must hold even though
+    // we're now on restore-cp-… rather than the original branch (the guard
+    // used to compare branch names and died after the first restore,
+    // minting a sibling branch per repeat).
+    const second = handleCommand('/restore cp', app);
+    expect(second.asyncWork).toBeUndefined();
+    expect(second.lines[0]!.text).toContain('Already at checkpoint');
+    expect(branchCount()).toBe(branchesAfterFirst);
+  });
+
+  test('unreachable checkpoint position degrades to the branch head with a note', async () => {
+    const { app, cm, addMessage, currentName } = makeStubWorld();
+    const early = addMessage();
+    addMessage('agent');
+    handleCommand('/checkpoint cp', app);
+
+    // Simulate /undo: branch truncated BEFORE the checkpoint message, so the
+    // checkpoint id is unreachable from the current branch's view.
+    const undoBranch = cm.branchAt(early.id, 'undo-1');
+    await cm.switchBranch(undoBranch);
+
+    const result = handleCommand('/restore cp', app);
+    const outcome = await result.asyncWork!;
+    expect(currentName()).toBe('main');
+    expect(outcome.lines.some(l => l.text.includes('unreachable'))).toBe(true);
+  });
+});

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');
+  });
+});