gnome-jarvis/test/compaction.test.js

import test from 'node:test';
import assert from 'node:assert/strict';
import { createRequire } from 'node:module';
import { VOICE_SYSTEM_PROMPT, voiceSystemPrompt } from '../skills/voice-prompt.js';

const require = createRequire(import.meta.url);
const compaction = require('../vendor/agent-harness/agent/compaction.js');
const prompts = require('../vendor/agent-harness/agent/prompts.js');

function hugeTools() {
  return Array.from({ length: 24 }, (_, i) => ({
    name: 'tool_' + i,
    description: 'schema '.repeat(80),
    parameters: { type: 'object', properties: { q: { type: 'string' } } },
  }));
}

test('short voice chats do not compact just because tool schemas are large', () => {
  const tools = hugeTools();
  const hist = [
    { role: 'system', content: VOICE_SYSTEM_PROMPT },
    { role: 'assistant', content: 'Hello! How can I help you today?' },
    { role: 'user', content: 'Hi, please tell me about my computer.' },
  ];
  assert.equal(compaction.shouldCompact(hist, tools, 8192), false);
  const out = compaction.compact(hist, {
    budgetTokens: compaction.historyBudget(8192, tools, 0),
    tools,
    voice: true,
  });
  assert.equal(out.length, hist.length);
  assert.equal(out[2].content, hist[2].content);
  assert.equal(JSON.stringify(out).includes('Earlier turns were compacted'), false);
});

test('heuristic compact does not double-count tools against the history budget', () => {
  const tools = hugeTools();
  const hist = [
    { role: 'system', content: 'You are Jarvis' },
    { role: 'assistant', content: 'Hello! How can I help you today?' },
    { role: 'user', content: 'Hi, please tell me about my computer.' },
    { role: 'assistant', content: 'Let me check that.' },
    { role: 'user', content: 'Please continue.' },
  ];
  const budget = compaction.historyBudget(8192, tools, 0);
  assert.ok(budget <= 240 || compaction.toolTokens(tools) > 1000);
  const out = compaction.heuristicCompact(hist, { budgetTokens: budget, tools });
  assert.ok(out.some((m) => String(m.content).includes('tell me about my computer')));
  assert.equal(JSON.stringify(out).includes('Earlier turns were compacted'), false);
});

test('voice compaction does not auto-continue a new greeting', () => {
  const cont = compaction.autoContinue([{ role: 'assistant', content: 'Hello!' }], { voice: true });
  assert.equal(cont, null);
  assert.match(compaction.compactReminder({ voice: true }), /Do not greet again/);
});

test('voice assemble inlines workspace identity files and skips a completed bootstrap', () => {
  const sys = prompts.assemble({
    personality: 'voice',
    extra: VOICE_SYSTEM_PROMPT,
    cwd: '/home/raven/.local/share/jarvis/workspace',
    hostWorkspace: true,
    fsRead: (_c, n) => {
      if (n === 'SOUL.md') return '# SOUL.md: Jarvis\nYou are Jarvis on this desktop.';
      if (n === 'AGENTS.md') return '# AGENTS.md\nFollow the workspace ritual.';
      if (n === 'PERSONA.md') return '# PERSONA.md\nBe a roast comedian.';
      if (n === 'BOOTSTRAP.md') return '# completed';
      return '';
    },
  });
  assert.match(sys, /You are Jarvis/);
  assert.match(sys, /SOUL\.md/);
  assert.match(sys, /AGENTS\.md/);
  assert.doesNotMatch(sys, /## PERSONA\.md/);
  assert.doesNotMatch(sys, /Be a roast comedian/);
  assert.doesNotMatch(sys, /You are a local coding agent/);
  assert.doesNotMatch(sys, /## BOOTSTRAP\.md/);
});

test('voice assemble keeps acting notes in the system prompt and skips SOUL identity files', () => {
  const extra = voiceSystemPrompt('Tony', 'Jarvis, you are acting as Tony Hinchcliffe. Never call yourself Jarvis.');
  const sys = prompts.assemble({
    personality: 'voice',
    extra,
    cwd: '/home/raven/.local/share/jarvis/workspace',
    hostWorkspace: true,
    fsRead: (_c, n) => {
      if (n === 'SOUL.md') return '# SOUL.md: Jarvis\nYou are **Jarvis**.';
      if (n === 'IDENTITY.md') return '# IDENTITY.md\nJarvis lives here.';
      if (n === 'PERSONA.md') return '# PERSONA.md\nDuplicate roast notes.';
      if (n === 'AGENTS.md') return '# AGENTS.md\nFollow the workspace ritual.';
      return '';
    },
  });
  assert.match(sys, /Your name is Tony/);
  assert.match(sys, /## Acting/);
  assert.match(sys, /Tony Hinchcliffe/);
  assert.match(sys, /AGENTS\.md/);
  assert.doesNotMatch(sys, /## SOUL\.md/);
  assert.doesNotMatch(sys, /## IDENTITY\.md/);
  assert.doesNotMatch(sys, /## PERSONA\.md/);
  assert.doesNotMatch(sys, /Duplicate roast notes/);
  assert.doesNotMatch(sys, /You are \*\*Jarvis\*\*/);
});

test('LLM compact skips a two-turn voice chat', async () => {
  let called = false;
  const hist = [
    { role: 'system', content: 'You are Jarvis' },
    { role: 'assistant', content: 'Hello! How can I help you today?' },
    { role: 'user', content: 'Hi, please tell me about my computer.' },
  ];
  const out = await compaction.compactWithLlm(hist, {
    voice: true,
    complete: async () => {
      called = true;
      return { text: '1. Latest user request\n2. Facts\n3. Answered\n4. Follow-ups\n' };
    },
  });
  assert.equal(called, false);
  assert.equal(out.length, hist.length);
  assert.equal(out[2].content, hist[2].content);
});

function exchange(id, size = 5000) {
  return [
    { role: 'assistant', content: 'Checking the device.', tool_calls: [{ id, type: 'function', function: { name: 'lookup', arguments: '{"device":"nest"}' } }] },
    { role: 'tool', tool_call_id: id, name: 'lookup', content: 'Hostname: nest. ' + 'details '.repeat(size) },
  ];
}

function assertValidTools(history) {
  let calls = new Set();
  for (const message of history) {
    if (message.role === 'tool') assert.ok(calls.has(message.tool_call_id), 'tool result must follow its original call');
    else calls = new Set((message.tool_calls || []).map((call) => call.id));
  }
}

test('summary rebuild keeps the latest request in order and preserves native tool metadata', () => {
  const latest = { role: 'user', content: 'What about its memory?' };
  const tool = exchange('memory', 1);
  const rebuilt = compaction.rebuildHistory([
    { role: 'system', content: 'You are Jarvis.' },
    { role: 'user', content: 'Check my computer.' },
    { role: 'assistant', content: 'It is named nest.' },
    latest, ...tool,
  ], 'The user is asking about their computer named nest.');
  assert.deepEqual(rebuilt.slice(2), [latest, ...tool]);
  assertValidTools(rebuilt);
});

test('large tool results trigger compaction even in a short conversation', () => {
  const history = [{ role: 'system', content: 'Jarvis' }, { role: 'user', content: 'Check nest.' }, ...exchange('large')];
  assert.equal(compaction.shouldCompact(history, [], 8192), true);
  const compacted = compaction.compact(history, { budgetTokens: 800 });
  assert.ok(compaction.conversationTokens(compacted) <= 800);
  assert.ok(compacted.some((m) => m.content === 'Check nest.'));
  assert.match(JSON.stringify(compacted), /Hostname: nest/);
  assertValidTools(compacted);
});

test('heuristic fallback retains useful conversational facts and fits its budget', () => {
  const request = { role: 'user', content: 'And what should I do next?' };
  const history = [
    { role: 'system', content: 'Jarvis' },
    { role: 'user', content: 'My computer is nest. Keep answers brief.' },
    { role: 'assistant', content: 'We are investigating memory usage. ' + 'details '.repeat(3000) },
    request,
  ];
  const compacted = compaction.compact(history, { budgetTokens: 500, aggressive: true });
  assert.ok(compaction.conversationTokens(compacted) <= 500);
  assert.match(compacted[1].content, /nest.*Keep answers brief/);
  assert.equal(compacted.at(-1), request);
  assert.doesNotMatch(compacted[1].content, /Earlier turns were compacted to fit/);
});

test('LLM summaries are bounded and repeated compaction retains preferences and the latest request', async () => {
  const request = { role: 'user', content: 'What is the next step?' };
  let history = [
    { role: 'system', content: 'Jarvis' },
    { role: 'user', content: 'My computer is nest. Keep answers brief.' },
    { role: 'assistant', content: 'We are checking memory.' },
    request, ...exchange('memory'),
  ];
  for (let i = 0; i < 3; i++) {
    history = await compaction.compactWithLlm(history, {
      voice: true, aggressive: true, budgetTokens: 700,
      complete: async ({ history: prompt }) => {
        assert.match(prompt[1].content, /nest/);
        assert.match(prompt[1].content, /Tool calls:/);
        return { text: 'The user owns nest and wants brief answers. We are investigating memory usage. ' + 'Additional findings. '.repeat(1000) };
      },
    });
    assert.ok(compaction.conversationTokens(history) <= 700);
    assert.match(history[1].content, /nest.*brief answers/);
    assert.ok(history.includes(request));
    assertValidTools(history);
    history.push(...exchange('next-' + i));
  }
});

test('failed summarization falls back without erasing the latest request or tool identities', async () => {
  const request = { role: 'user', content: 'Please check the computer named nest.' };
  const history = [{ role: 'system', content: 'Jarvis' }, request, ...exchange('failure')];
  const compacted = await compaction.compactWithLlm(history, {
    budgetTokens: 600, complete: async () => { throw new Error('summary failed'); },
  });
  assert.ok(compaction.conversationTokens(compacted) <= 600);
  assert.ok(compacted.includes(request));
  assertValidTools(compacted);
});

test('compaction never silently clips an oversized latest user request', () => {
  const request = { role: 'user', content: 'Keep this exact constraint. '.repeat(1000) };
  const compacted = compaction.compact([{ role: 'system', content: 'Jarvis' }, request], { budgetTokens: 300, aggressive: true });
  assert.equal(compacted.at(-1), request);
});

test('sidecar context is reserved in the history budget', () => {
  assert.equal(compaction.historyBudget(8192, [], 0) - compaction.historyBudget(8192, [], 0, 512), 512);
});

test('voice sessions keep a short spoken tail even on large model windows', () => {
  assert.equal(compaction.voiceKeepTokens(4096), 1024);
  assert.equal(compaction.voiceKeepTokens(16384), 1024);
  assert.equal(compaction.voiceKeepTokens(32768), 1024);
  assert.ok(compaction.voiceKeepTokens(2048) <= 573);
  const sys = { role: 'system', content: 'You are Jarvis. '.repeat(40) };
  const short = [
    sys,
    { role: 'assistant', content: 'Hello!' },
    { role: 'user', content: 'What time is it?' },
  ];
  assert.equal(compaction.shouldCompact(short, [], 32768, 0, { voice: true }), false);
  const long = [
    sys,
    { role: 'user', content: 'Remember nest.' },
    { role: 'assistant', content: 'details '.repeat(2000) },
    { role: 'user', content: 'And the hostname?' },
    { role: 'assistant', content: 'Still nest. ' + 'padding '.repeat(200) },
  ];
  assert.equal(compaction.shouldCompact(long, [], 32768, 0, { voice: true }), true);
  const sysTok = compaction.conversationTokens([sys]);
  const budget = compaction.historyBudget(32768, [], 0, 0, { voice: true, systemTokens: sysTok });
  assert.ok(budget <= sysTok + compaction.VOICE_KEEP_TOKENS);
  assert.ok(budget < compaction.historyBudget(32768, [], 0));
  const out = compaction.compact(long, { budgetTokens: budget, voice: true });
  assert.ok(compaction.dialogTokens(out) <= compaction.VOICE_KEEP_TOKENS + 32);
  assert.ok(out.some((m) => m.content === 'And the hostname?'));
});

for (const overflow of [false, true]) {
  test(`turn loop persists compaction and sends one-shot reminders through retries (overflow=${overflow})`, async (t) => {
    const { mkdtempSync, rmSync } = await import('node:fs');
    const { tmpdir } = await import('node:os');
    const path = await import('node:path');
    const engine = require('../vendor/agent-harness/lib/qvac.js');
    const sessions = require('../vendor/agent-harness/agent/sessions.js');
    const mcp = require('../vendor/agent-harness/agent/mcp.js');
    const loop = require('../vendor/agent-harness/agent/loop.js');
    const root = mkdtempSync(path.join(tmpdir(), 'jarvis-compaction-'));
    const previousRoot = process.env.AGENT_HARNESS_HOME;
    process.env.AGENT_HARNESS_HOME = root;
    const oldComplete = engine.complete;
    const oldLoaded = engine.getLoaded;
    const oldLocalLoaded = engine.localLoaded;
    const oldLoad = engine.load;
    const oldNotes = mcp.handshakeReminders;
    t.after(() => {
      engine.complete = oldComplete;
      engine.getLoaded = oldLoaded;
      engine.localLoaded = oldLocalLoaded;
      engine.load = oldLoad;
      mcp.handshakeReminders = oldNotes;
      if (previousRoot === undefined) delete process.env.AGENT_HARNESS_HOME;
      else process.env.AGENT_HARNESS_HOME = previousRoot;
      rmSync(root, { recursive: true, force: true });
    });
    const model = 'test-model';
    engine.localLoaded = engine.getLoaded = () => ({ modelId: model, friendlyId: model, ctxSize: 8192 });
    engine.load = async () => { throw new Error('test-model must stay mocked'); };
    let noteSent = false;
    mcp.handshakeReminders = () => {
      if (noteSent) return [];
      noteSent = true;
      return ['MCP test handshake failed: unavailable'];
    };
    const meta = sessions.create({ origin: 'jarvis-qvac', cwd: root, hostWorkspace: false, builtinTools: false, model });
    sessions.replaceHistory(meta.id, [
      { role: 'user', content: 'My computer is nest. Please keep answers brief.' },
      { role: 'assistant', content: 'Checking its memory. ' + 'history '.repeat(5000) },
      { role: 'user', content: 'Remember the hostname.' },
      { role: 'assistant', content: 'I will remember nest.' },
    ]);
    let completions = 0;
    const promptSizes = [];
    engine.complete = async ({ history }) => {
      if (history[0].content.startsWith('Reply with the four summary sections')) {
        throw new Error('voice turns must not spend a completion on LLM summarization');
      }
      completions++;
      promptSizes.push(compaction.conversationTokens(history));
      assert.equal(history.filter((m) => /Context was compacted/.test(m.content)).length, 1);
      assert.equal(history.filter((m) => /MCP test handshake/.test(m.content)).length, 1);
      assert.ok(history.some((m) => m.content === 'What is its hostname?'));
      assert.match(JSON.stringify(history), /nest/);
      assert.ok(compaction.estimateTokens(history, []) < 8192);
      if (overflow && completions === 1) throw new Error('prompt too long for context window');
      return { text: 'Its hostname is nest.', toolCalls: [] };
    };
    const updates = [];
    const result = await loop.runTurn({
      session: sessions.load(meta.id), userText: 'What is its hostname?', jobId: 'context-test',
      payload: { voice: true, system: 'Jarvis', maxTurns: 1 },
      emit: (_kind, event) => updates.push(event),
    });
    assert.equal(result.text, 'Its hostname is nest.');
    assert.equal(completions, overflow ? 2 : 1);
    if (overflow) assert.ok(promptSizes[1] < promptSizes[0], 'overflow recovery must actually shrink the prompt');
    assert.ok(updates.some((ev) => ev.type === 'compaction' && ev.status === 'done'));
    const saved = sessions.load(meta.id).history;
    assert.match(saved[1].content, /nest/);
    assert.equal(saved.at(-1).content, 'Its hostname is nest.');
    assert.ok(compaction.conversationTokens(saved) < 2000);

    // Follow-up requests reload the persisted summary, not the original large history.
    engine.complete = async ({ history }) => {
      assert.match(history[1].content, /nest/);
      assert.equal(history.at(-1).role, 'user');
      assert.ok(history.some((m) => m.content === 'And what were we checking?'));
      return { text: 'We were checking memory.', toolCalls: [] };
    };
    const followup = await loop.runTurn({
      session: sessions.load(meta.id), userText: 'And what were we checking?', jobId: 'followup-test',
      payload: { voice: true, system: 'Jarvis', maxTurns: 1 }, emit() {},
    });
    assert.equal(followup.text, 'We were checking memory.');
  });
}