onbuzz 5.0.1 → 5.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onbuzz",
-  "version": "5.0.1",
+  "version": "5.1.0",
   "description": "Loxia OnBuzz - Your AI Fleet",
   "type": "module",
   "main": "src/index.js",
@@ -133,7 +133,7 @@
       {
         "provider": "github",
         "owner": "Loxia-ai",
-        "repo": "autopilot"
+        "repo": "autopilot-releases"
       }
     ],
     "directories": {

package/scripts/recall-value-check.mjs

@@ -0,0 +1,92 @@
+/**
+ * Recall VALUE check — does the shipped 0.5 threshold actually deliver recall
+ * with the REAL nomic model? (Embedding quality, not plumbing.)
+ *
+ * Run in PLAIN NODE (not jest — jest's VM sandbox breaks onnxruntime):
+ *   node scripts/recall-value-check.mjs
+ * Point at an existing weights cache to skip a download (recommended):
+ *   LOXIA_NOMIC_STATE_DIR=<...>/loxia-autopilot/state node scripts/recall-value-check.mjs
+ *
+ * Exits 1 if the system fails to deliver value (so it works as a check):
+ *   - relevant question→fact pairs must clear the 0.5 gate
+ *   - the canonical name pair must sit BELOW the old 0.78 gate (proving the
+ *     threshold change was necessary — value quantified)
+ *   - unrelated pairs must stay below 0.5 (no new noise)
+ */
+import os from 'os';
+import path from 'path';
+import { EmbeddingService } from '../src/services/embeddings/embeddingService.js';
+
+const NEW_GATE = 0.5;
+const OLD_GATE = 0.78;
+
+const stateDir = process.env.LOXIA_NOMIC_STATE_DIR
+  || path.join(os.tmpdir(), 'loxia-nomic-value-cache');
+
+const svc = new EmbeddingService({
+  config: { provider: 'local', local: { modelId: 'nomic-ai/nomic-embed-text-v1' } },
+  apiKeyManager: { getEmbeddingApiKey: () => null },
+  baseUrl: 'http://unused',
+  stateDir,
+});
+
+function cosine(a, b) {
+  let dot = 0, na = 0, nb = 0;
+  for (let i = 0; i < a.length; i++) { dot += a[i] * b[i]; na += a[i] * a[i]; nb += b[i] * b[i]; }
+  return dot / (Math.sqrt(na) * Math.sqrt(nb));
+}
+async function sim(q, d) {
+  const qv = await svc.embedQuery(q);
+  const dv = (await svc.embedDocuments([d], 'document'))[0];
+  return cosine(qv, dv);
+}
+
+// [question, document, expectation] — 'hit' must clear NEW_GATE, 'miss' must not.
+const RELEVANT = [
+  ["what's my name?", 'My name is Daniel.'],
+  ['where do I live?', 'I live in Tel Aviv.'],
+  ['what do I do for work?', 'I work as a software engineer.'],
+];
+const UNRELATED = [
+  ["what's my name?", 'The sky is blue today.'],
+  ['where do I live?', 'My favorite color is green.'],
+];
+
+console.log('Loading nomic model…', process.env.LOXIA_NOMIC_STATE_DIR ? `(cache: ${stateDir})` : '(downloading to temp cache)');
+await svc.warmup();
+
+const failures = [];
+
+console.log(`\nGate: recall if cosine >= ${NEW_GATE}  (old gate was ${OLD_GATE})\n`);
+console.log('RELEVANT (must be RECALLED):');
+const namePair = [];
+for (const [q, d] of RELEVANT) {
+  const s = await sim(q, d);
+  const ok = s >= NEW_GATE;
+  console.log(`  ${s.toFixed(4)}  ${ok ? 'RECALLED ✓' : 'MISSED   ✗'}  "${q}" ← "${d}"`);
+  if (!ok) failures.push(`relevant pair missed (${s.toFixed(3)}): "${q}" / "${d}"`);
+  if (d === 'My name is Daniel.') namePair.push(s);
+}
+
+console.log('\nUNRELATED (must be REJECTED):');
+for (const [q, d] of UNRELATED) {
+  const s = await sim(q, d);
+  const ok = s < NEW_GATE;
+  console.log(`  ${s.toFixed(4)}  ${ok ? 'rejected ✓' : 'LEAKED   ✗'}  "${q}" ← "${d}"`);
+  if (!ok) failures.push(`unrelated pair leaked (${s.toFixed(3)}): "${q}" / "${d}"`);
+}
+
+// Value of the threshold change: the canonical name pair must sit in (0.5, 0.78)
+// — recalled now, dropped before.
+const name = namePair[0];
+if (!(name >= NEW_GATE && name < OLD_GATE)) {
+  failures.push(`name pair ${name?.toFixed(3)} not in the (${NEW_GATE}, ${OLD_GATE}) band that proves the fix`);
+}
+console.log(`\nThreshold-change value: name pair = ${name?.toFixed(4)} → recalled at ${NEW_GATE}, would have been DROPPED at ${OLD_GATE}.`);
+
+if (failures.length) {
+  console.error(`\n❌ VALUE CHECK FAILED (${failures.length}):`);
+  for (const f of failures) console.error('  - ' + f);
+  process.exit(1);
+}
+console.log('\n✅ VALUE CHECK PASSED — recall delivers value at the shipped threshold.');

package/src/__tests__/autoUpdateConfig.test.js

@@ -63,6 +63,19 @@ describe('package.json — auto-update presence', () => {
     expect(github.repo).not.toMatch(/^(your-repo|TODO|placeholder)$/i);
   });
 
+  test('GitHub publish repo matches the release workflow target (autopilot-releases)', () => {
+    // build-binaries.yml's create-release job uploads assets (and the
+    // electron-updater latest.yml feed) to `Loxia-ai/autopilot-releases`.
+    // If build.publish.repo drifts back to `autopilot`, electron-updater
+    // polls a repo with no release feed and the desktop app never updates.
+    const entries = Array.isArray(pkg.build.publish) ? pkg.build.publish : [pkg.build.publish];
+    const github = entries.find(e => e.provider === 'github');
+    expect(github).toBeTruthy();
+    expect(github.repo).toBe('autopilot-releases');
+    const workflow = readFileSync(join(REPO_ROOT, '.github/workflows/build-binaries.yml'), 'utf8');
+    expect(workflow).toMatch(new RegExp(`${github.owner}/${github.repo}`));
+  });
+
   test('update-notifier source file exists and is referenced by the CLI entry point', () => {
     // Tripwire against accidental file deletion. The runtime is
     // tolerant of missing dependencies (dynamic import), but if the

package/src/core/__tests__/agentPool.deprecatedCapabilities.test.js

@@ -0,0 +1,105 @@
+/**
+ * Deprecated-capability sanitization. `foundry_web_search` was removed from
+ * the tool registry but lingers in old persisted agent state, where it leaked
+ * into "Capabilities: …" prompt text and prompted the model to call a tool
+ * that no longer exists (58× "Tool not found" in one customer log). These
+ * tests prove it is stripped at every point capabilities enter an agent:
+ * create, update, and rehydrate-on-load (self-heal).
+ */
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger, createMockConfig, createMockStateManager } from '../../__test-utils__/mockFactories.js';
+
+const mockValidateAccessConfiguration = jest.fn().mockReturnValue({ valid: true });
+const mockCreateProjectDefaults = jest.fn().mockReturnValue({
+  workingDirectory: '/tmp/project', readOnlyDirectories: [], writeEnabledDirectories: ['/tmp/project'],
+});
+jest.unstable_mockModule('../../utilities/directoryAccessManager.js', () => {
+  const MockDAM = jest.fn().mockImplementation(() => ({ validateAccessConfiguration: mockValidateAccessConfiguration }));
+  MockDAM.createProjectDefaults = mockCreateProjectDefaults;
+  return { default: MockDAM };
+});
+jest.unstable_mockModule('../../services/visualEditorBridge.js', () => ({
+  getVisualEditorBridge: jest.fn().mockReturnValue({
+    hasInstance: jest.fn().mockReturnValue(false),
+    stopInstance: jest.fn().mockResolvedValue(undefined),
+  }),
+}));
+
+const { default: AgentPool, sanitizeCapabilities, DEPRECATED_CAPABILITIES, CAPABILITY_ALIASES } = await import('../agentPool.js');
+
+function makePool() {
+  const pool = new AgentPool(createMockConfig(), createMockLogger(), createMockStateManager(), { getContext: jest.fn() }, null);
+  return pool;
+}
+
+beforeEach(() => jest.clearAllMocks());
+
+describe('sanitizeCapabilities', () => {
+  test('strips deprecated names (case-insensitive) and keeps the rest', () => {
+    expect(sanitizeCapabilities(['web', 'foundry_web_search', 'terminal'])).toEqual(['web', 'terminal']);
+    expect(sanitizeCapabilities(['FOUNDRY_WEB_SEARCH'])).toEqual([]);
+  });
+
+  test('returns a new array and does not mutate the input', () => {
+    const input = ['web', 'foundry_web_search'];
+    const out = sanitizeCapabilities(input);
+    expect(out).not.toBe(input);
+    expect(input).toHaveLength(2);
+  });
+
+  test('passes non-array input through unchanged', () => {
+    expect(sanitizeCapabilities(undefined)).toBeUndefined();
+    expect(sanitizeCapabilities(null)).toBeNull();
+  });
+
+  test('foundry_web_search is in the deprecated set', () => {
+    expect(DEPRECATED_CAPABILITIES.has('foundry_web_search')).toBe(true);
+  });
+
+  test('migrates consolidated capabilities doc/spreadsheet → office (case-insensitive)', () => {
+    expect(sanitizeCapabilities(['doc', 'web'])).toEqual(['office', 'web']);
+    expect(sanitizeCapabilities(['SPREADSHEET'])).toEqual(['office']);
+    expect(CAPABILITY_ALIASES.get('doc')).toBe('office');
+    expect(CAPABILITY_ALIASES.get('spreadsheet')).toBe('office');
+  });
+
+  test('de-duplicates after migration (doc + spreadsheet + office → one office)', () => {
+    expect(sanitizeCapabilities(['doc', 'spreadsheet', 'office'])).toEqual(['office']);
+    expect(sanitizeCapabilities(['web', 'web'])).toEqual(['web']);
+  });
+
+  test('migration and deprecation compose (foundry dropped, doc mapped)', () => {
+    expect(sanitizeCapabilities(['foundry_web_search', 'doc', 'terminal']))
+      .toEqual(['office', 'terminal']);
+  });
+});
+
+describe('AgentPool strips deprecated capabilities', () => {
+  test('createAgent drops foundry_web_search', async () => {
+    const pool = makePool();
+    const agent = await pool.createAgent({
+      name: 'A', systemPrompt: 'x', preferredModel: 'm', projectDir: '/tmp/project',
+      capabilities: ['web', 'foundry_web_search', 'memory'],
+    });
+    expect(agent.capabilities).toEqual(['web', 'memory']);
+  });
+
+  test('updateAgent drops foundry_web_search from incoming updates', async () => {
+    const pool = makePool();
+    const agent = await pool.createAgent({
+      name: 'B', systemPrompt: 'x', preferredModel: 'm', projectDir: '/tmp/project', capabilities: ['web'],
+    });
+    const updated = await pool.updateAgent(agent.id, { capabilities: ['web', 'foundry_web_search'] });
+    expect(updated.capabilities).toEqual(['web']);
+  });
+
+  test('rehydrateFromState self-heals an old persisted agent', async () => {
+    const pool = makePool();
+    const restored = await pool.rehydrateFromState({
+      id: 'agent-old-1', name: 'Old', status: 'active',
+      capabilities: ['terminal', 'foundry_web_search'],
+      conversations: { full: { messages: [], lastUpdated: null } },
+    });
+    expect(restored.capabilities).toEqual(['terminal']);
+  });
+});

package/src/core/__tests__/agentScheduler.autoRecall.test.js

@@ -43,8 +43,6 @@ async function runAutoRecallStep({
 }) {
   const lastUserMsg = [...conversationHistory].reverse().find(m => m.role === 'user');
   if (
-    Array.isArray(agent.capabilities) &&
-    agent.capabilities.includes('memory') &&
     typeof aiService?.augmentSystemPrompt === 'function'
   ) {
     try {
@@ -114,19 +112,19 @@ describe('agentScheduler — auto-recall wiring (Phase 6d.2)', () => {
     );
   });
 
-  test('skipped when agent lacks memory capability', async () => {
+  test('fires even when agent lacks memory capability (recall is ungated)', async () => {
     const out = await runAutoRecallStep({
-      agent: { id: 'a1', capabilities: ['terminal'] },          // no memory
+      agent: { id: 'a1', capabilities: ['terminal'] },          // no memory capability
       conversationHistory: [{ role: 'user', content: 'hi' }],
       aiService, logger,
       enhancedSystemPrompt: 'BASE',
     });
-    expect(aiService.augmentSystemPrompt).not.toHaveBeenCalled();
-    expect(out).toBe('BASE');                                    // unchanged
+    expect(aiService.augmentSystemPrompt).toHaveBeenCalledWith('BASE', 'a1', 'hi');
+    expect(out).toContain('## RELEVANT CONTEXT (auto-recalled)');
   });
 
-  test('skipped when capabilities is missing or non-array', async () => {
-    for (const caps of [undefined, null, 'memory', 42]) {
+  test('fires regardless of capabilities shape (capability no longer gates recall)', async () => {
+    for (const caps of [undefined, null, 'memory', 42, ['terminal']]) {
       aiService.augmentSystemPrompt.mockClear();
       const out = await runAutoRecallStep({
         agent: { id: 'a1', capabilities: caps },
@@ -134,8 +132,8 @@ describe('agentScheduler — auto-recall wiring (Phase 6d.2)', () => {
         aiService, logger,
         enhancedSystemPrompt: 'BASE',
       });
-      expect(aiService.augmentSystemPrompt).not.toHaveBeenCalled();
-      expect(out).toBe('BASE');
+      expect(aiService.augmentSystemPrompt).toHaveBeenCalledTimes(1);
+      expect(out).toContain('## RELEVANT CONTEXT (auto-recalled)');
     }
   });
 

package/src/core/__tests__/agentScheduler.emptyConversation.test.js

@@ -0,0 +1,132 @@
+/**
+ * Empty-conversation guard on AgentScheduler.
+ *
+ * Repro for the recurring "No messages to send - messages array is empty"
+ * error stream: an AGENT-mode agent can be scheduled active (pending tasks,
+ * or residual TTL) while its PERSISTED conversation is empty — history was
+ * cleared, an imported/seeded agent, or tasks that outlived their messages.
+ * getMessagesForAI() then returns [], the AI service rejects the empty
+ * array, and the scheduler burns a cycle EVERY tick logging the same error.
+ *
+ * The fix resolves the empty case deterministically:
+ *   - AGENT mode + an actionable (pending/in-progress) task → seed a
+ *     transient kickoff user turn so the model can start its task list.
+ *   - otherwise → skip the AI request entirely (return null) and stay idle.
+ *
+ * Two layers are covered:
+ *   1. _resolveEmptyConversationMessages() — the pure decision (all branches).
+ *   2. getAgentAIResponse() — proves the AI service is NEVER called when the
+ *      conversation is empty and there's no actionable task (no error stream).
+ */
+import { jest, describe, test, expect } from '@jest/globals';
+
+// Stub the activity service so importing the scheduler doesn't drag in the
+// full agent dependency graph.
+jest.unstable_mockModule('../../services/agentActivityService.js', () => ({
+  shouldAgentBeActive: () => ({ active: false, reason: 'stub' }),
+  getActiveAgents: () => [],
+  shouldSkipIteration: () => false,
+}));
+
+const { default: AgentScheduler } = await import('../agentScheduler.js');
+
+function makeScheduler({ agentPool = {}, aiService = {}, logger = null } = {}) {
+  const pool = {
+    getAllAgents: async () => new Map(),
+    getAgent: async () => null,
+    getMessagesForAI: async () => [],
+    persistAgentState: async () => {},
+    getCompactionMetadata: async () => null,
+    ...agentPool,
+  };
+  const log = logger || { info() {}, warn() {}, error() {}, debug() {} };
+  return new AgentScheduler(pool, {}, aiService, log, null, null, null);
+}
+
+// ─── 1. Pure decision: _resolveEmptyConversationMessages ────────────────
+
+describe('_resolveEmptyConversationMessages', () => {
+  const scheduler = makeScheduler();
+
+  test('AGENT mode + a pending task → seeds a single user kickoff turn', () => {
+    const out = scheduler._resolveEmptyConversationMessages({
+      mode: 'agent',
+      taskList: { tasks: [{ status: 'pending' }] },
+    });
+    expect(Array.isArray(out)).toBe(true);
+    expect(out).toHaveLength(1);
+    expect(out[0].role).toBe('user');
+    expect(out[0].content.length).toBeGreaterThan(0);
+  });
+
+  test('AGENT mode + an in-progress task → also seeds a kickoff turn', () => {
+    const out = scheduler._resolveEmptyConversationMessages({
+      mode: 'agent',
+      taskList: { tasks: [{ status: 'in_progress' }] },
+    });
+    expect(out).toHaveLength(1);
+    expect(out[0].role).toBe('user');
+  });
+
+  test('AGENT mode + only completed/cancelled tasks → null (idle)', () => {
+    const out = scheduler._resolveEmptyConversationMessages({
+      mode: 'agent',
+      taskList: { tasks: [{ status: 'completed' }, { status: 'cancelled' }] },
+    });
+    expect(out).toBeNull();
+  });
+
+  test('AGENT mode + no taskList → null (e.g. residual TTL, no work)', () => {
+    expect(scheduler._resolveEmptyConversationMessages({ mode: 'agent' })).toBeNull();
+  });
+
+  test('CHAT mode + a pending task → null (only AGENT mode kicks off)', () => {
+    const out = scheduler._resolveEmptyConversationMessages({
+      mode: 'chat',
+      taskList: { tasks: [{ status: 'pending' }] },
+    });
+    expect(out).toBeNull();
+  });
+
+  test('null/undefined agent → null (defensive, no throw)', () => {
+    expect(scheduler._resolveEmptyConversationMessages(null)).toBeNull();
+    expect(scheduler._resolveEmptyConversationMessages(undefined)).toBeNull();
+  });
+});
+
+// ─── 2. getAgentAIResponse never calls the AI service when empty+idle ────
+
+describe('getAgentAIResponse — empty conversation, no actionable task', () => {
+  test('returns null and NEVER calls the AI service (no error stream)', async () => {
+    const agent = {
+      id: 'a1',
+      name: 'Idle Agent',
+      mode: 'agent',
+      currentModel: 'model-x',
+      sessionId: 'sess-1',
+      dynamicModelRouting: false,
+      taskList: { tasks: [] },               // no actionable work
+      conversations: { full: { messages: [] } },
+    };
+
+    const sendMessage = jest.fn();
+    const sendMessageStream = jest.fn();
+
+    const scheduler = makeScheduler({
+      agentPool: { getAgent: async () => agent, getMessagesForAI: async () => [] },
+      aiService: { sendMessage, sendMessageStream },
+    });
+
+    // Skip the compaction subsystem — not under test here.
+    scheduler.checkAndPerformCompaction = async () => ({
+      shouldContinue: true,
+      compactionPerformed: false,
+    });
+
+    const result = await scheduler.getAgentAIResponse('a1');
+
+    expect(result).toBeNull();
+    expect(sendMessage).not.toHaveBeenCalled();
+    expect(sendMessageStream).not.toHaveBeenCalled();
+  });
+});

package/src/core/__tests__/agentScheduler.errorCategorisation.test.js

@@ -102,6 +102,13 @@ const errorClasses = [
   // -- PERSISTENT: genuinely unknown → server-error --
   { name: 'unknown: random 500',     msg: 'Random 500 Internal Server Error from the AI', expectBroadcast: true, label: 'server-error' },
   { name: 'unknown: weird shape',    msg: 'Provider returned malformed JSON',   expectBroadcast: true, label: 'server-error' },
+
+  // -- INTERNAL client-side payload error → internal-empty-payload (silent).
+  // Our OWN empty-array guard, NOT a model fault. Must NOT broadcast (no
+  // user alarm) and must NOT be misclassified as server-error (which would
+  // blame the model). See the dedicated "model not blamed" block below.
+  { name: 'empty payload: no messages to send', msg: 'No messages to send - messages array is empty', expectBroadcast: false, label: 'internal-empty-payload' },
+  { name: 'empty payload: array is empty',      msg: 'messages array is empty', expectBroadcast: false, label: 'internal-empty-payload' },
 ];
 
 describe('handleAIServiceFailure: error categorisation', () => {
@@ -194,6 +201,33 @@ describe('handleAIServiceFailure: diagnostic conversation turn + lastError snaps
   });
 });
 
+describe('handleAIServiceFailure: internal empty-payload does NOT blame the model', () => {
+  // Regression guard for the "burned model" symptom: an internal empty-array
+  // error must never be attributed to agent.currentModel.
+  const messages = [
+    'No messages to send - messages array is empty',
+    'messages array is empty',
+  ];
+
+  describe.each(messages)('"%s"', (msg) => {
+    test('records NO model-attributed failure turn and sets no lastError', async () => {
+      const { scheduler, agent, broadcasts } = makeScheduler();
+      await scheduler.handleAIServiceFailure('a1', new Error(msg));
+
+      // The whole point: no error turn stamped with `model`, no lastError.
+      expect(agent.conversations.full.messages.length).toBe(0);
+      expect(agent.conversations['test-model'].messages.length).toBe(0);
+      expect(agent.lastError).toBeUndefined();
+
+      // No user-facing alarm.
+      expect(broadcasts.filter(b => b.payload?.type === 'agent_error').length).toBe(0);
+
+      // Quiet state hint with the dedicated label (not 'server-error').
+      expect(scheduler.broadcastAgentStateUpdate).toHaveBeenCalledWith('a1', 'internal-empty-payload');
+    });
+  });
+});
+
 describe('handleAIServiceFailure: gateway 503 takes the network delay, not the rate-limit delay', () => {
   test('uses NETWORK_ERROR_DELAY_MS for 503 errors', async () => {
     const { scheduler, agentPool, agent } = makeScheduler();

package/src/core/__tests__/agentScheduler.toolOutputOffload.test.js

@@ -0,0 +1,96 @@
+/**
+ * Scheduler wiring for generic large-tool-output offload. The pure offload
+ * logic is covered in toolResultOffload.test.js; here we prove the scheduler's
+ * lazy DocumentMemory accessor and the per-batch driver behave (delegation,
+ * caching, empty/non-array guards, and best-effort error swallowing).
+ */
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger } from '../../__test-utils__/mockFactories.js';
+
+const mockShouldAgentBeActive = jest.fn(() => ({ active: false, reason: 'idle' }));
+const mockGetActiveAgents = jest.fn(() => []);
+const mockShouldSkipIteration = jest.fn(() => false);
+jest.unstable_mockModule('../../services/agentActivityService.js', () => ({
+  shouldAgentBeActive: mockShouldAgentBeActive,
+  getActiveAgents: mockGetActiveAgents,
+  shouldSkipIteration: mockShouldSkipIteration,
+}));
+
+const { default: AgentScheduler } = await import('../agentScheduler.js');
+
+function makeScheduler(aiService = {}) {
+  const logger = createMockLogger();
+  const agentPool = { getAgent: jest.fn(), persistAgentState: jest.fn().mockResolvedValue(undefined) };
+  const scheduler = new AgentScheduler(agentPool, {}, aiService, logger);
+  return { scheduler, logger };
+}
+
+const big = () => 'x'.repeat(scheduleThreshold + 500);
+let scheduleThreshold;
+beforeEach(() => { jest.clearAllMocks(); });
+
+describe('_getToolOutputDocumentMemory', () => {
+  test('builds a DocumentMemory and caches it (idempotent)', () => {
+    const { scheduler } = makeScheduler({ getEmbeddingService: () => null });
+    const mem1 = scheduler._getToolOutputDocumentMemory();
+    const mem2 = scheduler._getToolOutputDocumentMemory();
+    expect(mem1).toBeTruthy();
+    expect(typeof mem1.remember).toBe('function');
+    expect(mem2).toBe(mem1); // cached
+  });
+
+  test('works even when aiService has no embedding service', () => {
+    const { scheduler } = makeScheduler({});
+    expect(scheduler._getToolOutputDocumentMemory()).toBeTruthy();
+  });
+});
+
+describe('_maybeOffloadToolResults', () => {
+  test('no-op for empty / non-array input', async () => {
+    const { scheduler } = makeScheduler();
+    const spy = jest.spyOn(scheduler, '_getToolOutputDocumentMemory');
+    await scheduler._maybeOffloadToolResults('a1', []);
+    await scheduler._maybeOffloadToolResults('a1', null);
+    await scheduler._maybeOffloadToolResults('a1', undefined);
+    expect(spy).not.toHaveBeenCalled();
+  });
+
+  test('externalizes oversized results in place via the document memory', async () => {
+    const { scheduler } = makeScheduler();
+    scheduleThreshold = scheduler.toolOutputOffloadThreshold;
+    const remember = jest.fn().mockResolvedValue({
+      docId: 'doc-9', lines: 10, bytes: 1, chunkCount: 1, indexed: true, embeddingsEnabled: true,
+    });
+    scheduler._toolOutputDocumentMemory = { remember }; // inject cached memory
+
+    const results = [
+      { id: 'r1', status: 'completed', toolId: 'terminal', result: big() },
+      { id: 'r2', status: 'completed', toolId: 'filesystem', result: 'small' },
+    ];
+    await scheduler._maybeOffloadToolResults('a1', results);
+
+    expect(remember).toHaveBeenCalledTimes(1);
+    expect(results[0].result.toolOutputExternalized).toBe(true);
+    expect(results[1].result).toBe('small'); // untouched
+  });
+
+  test('returns quietly when the document memory cannot be built', async () => {
+    const { scheduler } = makeScheduler();
+    jest.spyOn(scheduler, '_getToolOutputDocumentMemory').mockImplementation(() => {
+      throw new Error('no store');
+    });
+    const results = [{ id: 'r1', status: 'completed', toolId: 'terminal', result: 'x'.repeat(99999) }];
+    await expect(scheduler._maybeOffloadToolResults('a1', results)).resolves.toBeUndefined();
+    expect(results[0].result).toMatch(/^x+$/); // left inline
+  });
+
+  test('swallows per-result offload errors without throwing', async () => {
+    const { scheduler } = makeScheduler();
+    scheduler._toolOutputDocumentMemory = {
+      remember: jest.fn().mockRejectedValue(new Error('boom')),
+    };
+    const results = [{ id: 'r1', status: 'completed', toolId: 'terminal', result: 'x'.repeat(99999) }];
+    await expect(scheduler._maybeOffloadToolResults('a1', results)).resolves.toBeUndefined();
+    expect(typeof results[0].result).toBe('string'); // unchanged
+  });
+});