aegiscode 5.2.31 → 5.2.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aegiscode",
-  "version": "5.2.31",
+  "version": "5.2.33",
   "description": "AEGIS CLI — AI-powered coding assistant",
   "type": "module",
   "bin": {

package/scripts/repro-tokencount.ts

@@ -0,0 +1,45 @@
+/**
+ * Reproduce the interactive turn flow: ContextManager.addMessage for each
+ * user/assistant turn, then the post-turn recount from useCommandProcessor.
+ * Verify the stored token count tracks the actual conversation.
+ */
+import { ContextManager } from '../src/context/ContextManager.js';
+import { TokenCounter } from '../src/context/TokenCounter.js';
+
+async function main() {
+  const cm = new ContextManager({});
+  await cm.createSession();
+
+  // Simulate what useCommandProcessor does per turn, with realistic content
+  const turns = 8;
+  for (let i = 0; i < turns; i++) {
+    const userMsg = `Turn ${i}: please review the function at src/agent/Agent.ts, explain the auto-compact logic, and tell me whether the inter-turn truncation respects the reserved response budget. ${'Details: '.repeat(3)}${i}`;
+    const assistantMsg = `## Analysis (turn ${i})\n\nThe auto-compact path checks TokenCounter.estimateMessagesTokens first, then falls back to the exact BPE count when over threshold. The reserved response budget of 10k tokens is subtracted from maxTokens before truncation, so a long tool output cannot starve the final answer.\n\n| step | tokens |\n|------|--------|\n| pre-filter | ~${100 + i * 50} |\n| exact count | ${200 + i * 100} |\n\nThis is a moderately long assistant reply to simulate real conversation bulk across many turns. ${'words '.repeat(10)}end.`;
+
+    // 1. user message (ContextManager.addMessage)
+    await cm.addMessage('user', userMsg);
+
+    // 2. assistant message (ContextManager.addMessage)
+    await cm.addMessage('assistant', assistantMsg);
+
+    // 3. post-turn recount (useCommandProcessor lines 427-431)
+    const modelName = 'claude-sonnet-4-20250514';
+    const totalTokens = TokenCounter.countTokens(
+      cm.getMessages().map(m => ({ role: m.role as any, content: m.content })),
+      modelName
+    );
+    cm.updateTokenCount(totalTokens);
+
+    const stored = cm.getTokenCount();
+    const raw = cm.getContext()!.layers.conversation.messages.length;
+    console.log(`after turn ${i + 1}: store=${stored} tokens, msgs=${raw}`);
+  }
+
+  const final = cm.getTokenCount();
+  console.log('\n=== RESULT ===');
+  console.log('turns:', turns, '| final stored token count:', final);
+  console.log(final > 4000 ? 'PASS: /compact would proceed' : 'FAIL: /compact would refuse (stuck under 4000)');
+  await cm.cleanup();
+}
+
+main().catch(e => { console.error(e); process.exit(1); });

package/scripts/repro-toolcontext.ts

@@ -0,0 +1,74 @@
+/**
+ * End-to-end check for the "tool activity was never persisted" fix:
+ *  1. addToolActivity() records assistant(tool_calls) + tool results.
+ *  2. The stored token count reflects the tool content (→ /compact gate passes).
+ *  3. Persistence round-trips: reload from JSONL keeps messages, tool_calls,
+ *     tool_call_id linkage, and an accurate recount.
+ */
+import { ContextManager } from '../src/context/ContextManager.js';
+import { TokenCounter } from '../src/context/TokenCounter.js';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// Realistic tool output: actual source text (much denser than repeated chars)
+const BIG_TOOL_OUTPUT = fs.readFileSync(path.join(__dirname, '..', 'src', 'agent', 'Agent.ts'), 'utf8')
+  .split('\n').slice(0, 300).join('\n');
+
+async function main() {
+  const cm = new ContextManager({});
+  await cm.createSession();
+  const sessionId = cm.getCurrentSessionId()!;
+
+  // Turn 1: plain exchange (like repro-tokencount) — small.
+  await cm.addMessage('user', 'Turn 0: explain the auto-compact logic. Details: 0');
+  await cm.addMessage('assistant', '## Analysis (turn 0)\n\nThe auto-compact path checks TokenCounter first. ' + 'words '.repeat(20));
+
+  // Turn 2: tool-heavy turn — a Read returning a large file, plus a small tool.
+  await cm.addMessage('user', 'Turn 1: read src/agent/Agent.ts and summarize it. Details: 1');
+  await cm.addToolActivity(
+    [
+      { id: 'call_read', type: 'function', function: { name: 'Read', arguments: JSON.stringify({ path: 'src/agent/Agent.ts', offset: 0, limit: 200 }) } },
+      { id: 'call_bash', type: 'function', function: { name: 'Bash', arguments: JSON.stringify({ command: 'wc -l src/agent/Agent.ts' }) } },
+    ],
+    [
+      { id: 'call_read', name: 'Read', content: BIG_TOOL_OUTPUT },
+      { id: 'call_bash', name: 'Bash', content: '986 lines' },
+    ]
+  );
+  await cm.addMessage('assistant', '## Summary (turn 1)\n\nAgent.ts is 986 lines and its auto-compact path is straightforward.');
+
+  const stored = cm.getTokenCount();
+  const msgs = cm.getMessages();
+  console.log('stored token count:', stored);
+  console.log('stored messages:', msgs.length, '(roles: ' + msgs.map(m => m.role).join(',') + ')');
+  console.log('/compact gate (>=' + 4000 + '):', stored >= 4000 ? 'PASS' : 'FAIL');
+
+  // Verify message ordering / linkage for the API.
+  const asstIdx = msgs.findIndex(m => m.tool_calls && m.tool_calls.length > 0);
+  const toolIdx = msgs.findIndex(m => m.role === 'tool');
+  console.log('assistant(tool_calls) before tool results:', asstIdx !== -1 && toolIdx > asstIdx ? 'PASS' : 'FAIL');
+  const toolMsg = msgs[toolIdx];
+  console.log('tool message has tool_call_id + name:', toolMsg && toolMsg.tool_call_id === 'call_read' && toolMsg.name === 'Read' ? 'PASS' : 'FAIL');
+
+  await cm.flush();
+  await cm.cleanup();
+
+  // ── Reload from JSONL ──
+  const cm2 = new ContextManager({});
+  const ok = await cm2.loadSession(sessionId);
+  const msgs2 = cm2.getMessages();
+  const count2 = cm2.getTokenCount();
+  console.log('\nreload ok:', ok);
+  console.log('reloaded messages:', msgs2.length, '(roles: ' + msgs2.map(m => m.role).join(',') + ')');
+  console.log('reloaded tool_calls linkage:', (() => {
+    const a = msgs2.findIndex(m => m.tool_calls && m.tool_calls.length > 0);
+    const t = msgs2.findIndex(m => m.role === 'tool');
+    return a !== -1 && t > a && msgs2[t].tool_call_id === 'call_read' ? 'PASS' : 'FAIL';
+  })());
+  console.log('reloaded token count matches:', count2 === stored ? `PASS (${count2})` : `FAIL store=${stored} reload=${count2}`);
+  await cm2.cleanup();
+}
+
+main().catch(e => { console.error(e); process.exit(1); });