onbuzz 4.8.0 → 4.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onbuzz",
-  "version": "4.8.0",
+  "version": "4.8.2",
   "description": "Loxia OnBuzz - Your AI Fleet",
   "type": "module",
   "main": "src/index.js",

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

@@ -420,6 +420,191 @@ describe('AgentPool', () => {
       expect(agent.delayEndTime).toBe(pastIso);
     });
 
+    // ── Auto-save user messages as plan/* memories ────────────────────
+    // Talisman case study: agents never voluntarily wrote memories
+    // and the user's literal asks vanished in compaction. The pool
+    // now auto-saves substantive user messages to the plan/* store
+    // as a system-level safety net (the agent itself can still write
+    // better-titled plans on top; these auto-saves are cleanup-safe).
+
+    describe('REGRESSION: auto-save substantive user messages as plan/*', () => {
+      test('calls _autoSaveUserMessageAsPlan for each user message (best-effort)', async () => {
+        const agent = await pool.createAgent(agentCfg());
+        const spy = jest.spyOn(pool, '_autoSaveUserMessageAsPlan').mockResolvedValue(undefined);
+        await pool.addUserMessage(agent.id, { content: 'please do a thing that is long enough to count as substantive content here, more than 120 chars total for the heuristic', role: 'user' });
+        expect(spy).toHaveBeenCalledTimes(1);
+        expect(spy.mock.calls[0][0]).toBe(agent.id);
+        expect(spy.mock.calls[0][1].content).toMatch(/please do a thing/);
+        spy.mockRestore();
+      });
+
+      test('a memory-service failure does NOT block the message-enqueue path', async () => {
+        // Auto-save is best-effort. If memoryService blows up, the
+        // user's message must still land on the queue.
+        const agent = await pool.createAgent(agentCfg());
+        jest.spyOn(pool, '_autoSaveUserMessageAsPlan').mockRejectedValue(new Error('memory store offline'));
+        await pool.addUserMessage(agent.id, { content: 'hello', role: 'user' });
+        expect(agent.messageQueues.userMessages).toHaveLength(1);
+      });
+    });
+
+    describe('_looksSubstantive heuristic — pollution audit', () => {
+      // ── TRUE POSITIVES — these SHOULD be saved ─────────────────────
+      test('TRUE POSITIVE: numbered request (Talisman literal case)', () => {
+        const msg = `Amazing! a few more things
+1. "choose your hero" page - lets put a nice fantasy image at the background.
+2. play screen - why is the board still round? plus, not all nodes have their own art.
+3. when we roll for combat - there is no dice animation visible`;
+        expect(pool._looksSubstantive(msg)).toBe(true);
+      });
+
+      test('TRUE POSITIVE: multi-paragraph feature request', () => {
+        const msg = 'Implement OAuth login. Replace the existing session-cookie flow with Google and Microsoft sign-in. Migrate existing users by linking their email to the new auth records on first sign-in. Update the docs.';
+        expect(pool._looksSubstantive(msg)).toBe(true);
+      });
+
+      test('TRUE POSITIVE: numbered bug list (descriptions, not paths)', () => {
+        const msg = `Fix these bugs:\n1. login button does nothing on Safari\n2. cart total wrong when discount applied\n3. 500 error on /api/orders/export`;
+        expect(pool._looksSubstantive(msg)).toBe(true);
+      });
+
+      test('TRUE POSITIVE: bulleted plan with imperative verbs', () => {
+        const msg = `fixes needed:\n- fix bug in login flow that breaks on slow networks\n- add retry logic to the cache layer\n- write a test for the missing error case`;
+        expect(pool._looksSubstantive(msg)).toBe(true);
+      });
+
+      // ── POLLUTION RISKS — these should NOT be saved ────────────────
+      test('POLLUTION: short ack is rejected', () => {
+        expect(pool._looksSubstantive('ok thanks')).toBe(false);
+        expect(pool._looksSubstantive('thanks!')).toBe(false);
+        expect(pool._looksSubstantive('yes please')).toBe(false);
+      });
+
+      test('POLLUTION: question with no imperative is rejected (user wants an answer, not a plan)', () => {
+        const msg = 'what does this function do? I see it referenced in three places but the docs do not explain its purpose at all.';
+        expect(pool._looksSubstantive(msg)).toBe(false);
+      });
+
+      test('POLLUTION: numbered list of QUESTIONS is rejected (not a plan)', () => {
+        const msg = `quick questions:\n1. why is the cache key the user id?\n2. is the rate limit per-user or per-ip?`;
+        expect(pool._looksSubstantive(msg)).toBe(false);
+      });
+
+      test('POLLUTION: list of file paths is rejected (just references)', () => {
+        const msg = `look at these:\n- src/auth/login.js\n- src/auth/session.js\n- src/middleware/auth.js\n- tests/auth.test.js`;
+        expect(pool._looksSubstantive(msg)).toBe(false);
+      });
+
+      test('POLLUTION: long pleasantry with no imperative is rejected', () => {
+        const msg = 'hey, hope you are well today, that was a good run earlier and I am happy with the progress so far!';
+        expect(pool._looksSubstantive(msg)).toBe(false);
+      });
+
+      test('POLLUTION: trivial numbered nonsense is rejected (too short under list rule)', () => {
+        expect(pool._looksSubstantive('1. yes 2. no 3. maybe')).toBe(false);
+      });
+
+      test('POLLUTION: reading-comprehension feedback is rejected', () => {
+        expect(pool._looksSubstantive('I do not understand what you wrote in your last message. Can you explain it differently?')).toBe(false);
+      });
+
+      test('POLLUTION: agreement / confirmation is rejected', () => {
+        expect(pool._looksSubstantive('yes, please proceed with that plan. it looks correct to me.')).toBe(false);
+      });
+
+      test('POLLUTION: simple one-shot instruction is rejected (too short)', () => {
+        expect(pool._looksSubstantive('run the tests again')).toBe(false);
+      });
+
+      // ── Defensive corner cases ─────────────────────────────────────
+      test('tool-result wrappers are rejected', () => {
+        expect(pool._looksSubstantive('[Tool Results — 1 result from 1 tool batch: filesystem] {...lots of content...}')).toBe(false);
+        expect(pool._looksSubstantive('[Previous Task — Final Tool Results] [jobdone] {...}')).toBe(false);
+      });
+
+      test('non-string content is rejected defensively', () => {
+        expect(pool._looksSubstantive(null)).toBe(false);
+        expect(pool._looksSubstantive(undefined)).toBe(false);
+        expect(pool._looksSubstantive({ obj: true })).toBe(false);
+      });
+    });
+
+    describe('helpers: question / reference / imperative detection', () => {
+      test('_dominatedByQuestions detects majority-question content', () => {
+        expect(pool._dominatedByQuestions('what does X do?')).toBe(true);
+        expect(pool._dominatedByQuestions('1. what?\n2. why?\n3. how?')).toBe(true);
+        expect(pool._dominatedByQuestions('fix the bug')).toBe(false);
+        // Mixed: 1 question + 2 commands → not dominated.
+        expect(pool._dominatedByQuestions('why is this slow?\nfix the cache\nadd metrics')).toBe(false);
+      });
+
+      test('_listItemsAreJustReferences detects path-only lists', () => {
+        const refList = `look:\n- src/a.js\n- src/b.js\n- src/c.js`;
+        expect(pool._listItemsAreJustReferences(refList)).toBe(true);
+      });
+
+      test('_listItemsAreJustReferences does NOT flag bug descriptions', () => {
+        const bugList = `bugs:\n- login breaks on Safari\n- cart total wrong with discount`;
+        expect(pool._listItemsAreJustReferences(bugList)).toBe(false);
+      });
+
+      test('_hasImperativeSignal matches common command verbs', () => {
+        expect(pool._hasImperativeSignal('fix the login bug')).toBe(true);
+        expect(pool._hasImperativeSignal('add a retry')).toBe(true);
+        expect(pool._hasImperativeSignal('refactor this module')).toBe(true);
+        expect(pool._hasImperativeSignal('what does this do')).toBe(false);
+        expect(pool._hasImperativeSignal('looks good')).toBe(false);
+      });
+    });
+
+    describe('dedup + cap (Jaccard similarity, AUTO_PLAN_CAP)', () => {
+      test('_tokenize lowercases + drops short words + strips punctuation', () => {
+        const tokens = pool._tokenize('Fix THE login button on iOS!');
+        // 'the', 'on' are <3 chars dropped; 'fix', 'login', 'button', 'ios' remain.
+        expect(tokens.has('fix')).toBe(true);
+        expect(tokens.has('login')).toBe(true);
+        expect(tokens.has('button')).toBe(true);
+        expect(tokens.has('ios')).toBe(true);
+        expect(tokens.has('the')).toBe(false);
+        expect(tokens.has('on')).toBe(false);
+      });
+
+      test('_jaccard returns 1 for identical text, 0 for disjoint, 1 for both empty', () => {
+        const a = pool._tokenize('fix the login button');
+        const b = pool._tokenize('fix the login button');
+        const c = pool._tokenize('build the cache layer');
+        expect(pool._jaccard(a, b)).toBe(1);
+        expect(pool._jaccard(a, c)).toBe(0);
+        expect(pool._jaccard(new Set(), new Set())).toBe(1);
+      });
+
+      test('_overlapCoefficient catches "I repeat my old message" near-duplicate (containment ≥0.85)', () => {
+        // Real Talisman case: user repeated themselves verbatim with
+        // an "I repeat my old message" preamble. Jaccard alone marks
+        // these as merely "similar" because the preamble adds new
+        // words; the overlap coefficient (intersection / smaller-set)
+        // correctly reports that the original is fully contained in
+        // the repeated version.
+        const original = pool._tokenize(
+          `1. "choose your hero" page - lets put a nice fantasy image at the background. also, lets create a character card art (general)`,
+        );
+        const repeated = pool._tokenize(
+          `Amazing! I repeat my old message - a few more things\n\n"choose your hero" page - lets put a nice fantasy image at the background. also, lets create a character card art (general)`,
+        );
+        expect(pool._overlapCoefficient(original, repeated)).toBeGreaterThanOrEqual(0.85);
+      });
+
+      test('_overlapCoefficient is 0 for disjoint sets, 1 for one fully contained in the other', () => {
+        const a = pool._tokenize('fix login button');
+        const b = pool._tokenize('fix login button additional extra words');
+        const c = pool._tokenize('build cache layer');
+        // 'a' fully contained in 'b' → 1.0
+        expect(pool._overlapCoefficient(a, b)).toBe(1);
+        // disjoint
+        expect(pool._overlapCoefficient(a, c)).toBe(0);
+      });
+    });
+
     test('no-ops when delayEndTime is null', async () => {
       const agent = await pool.createAgent(agentCfg());
       agent.delayEndTime = null;

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

@@ -0,0 +1,319 @@
+/**
+ * Unit tests for `_resolveModelApiType` + `_pickSystemPromptForModel`
+ * on AgentScheduler — the runtime-side half of the "trim duplicated
+ * tool docs for Responses-API models" feature.
+ *
+ * Three concerns covered:
+ *   1. Classification (_resolveModelApiType) — every catalog shape the
+ *      backend's _inferRouting recognizes must produce the same answer
+ *      on the CLI side, or the optimization fires on the wrong models.
+ *   2. Selection (_pickSystemPromptForModel) — must fall back to
+ *      `agent.systemPrompt` for every safety-net path:
+ *         • modelsService missing                → fallback
+ *         • model not in catalog                 → fallback
+ *         • apiType resolves to chat_completion → fallback
+ *         • originalSystemPrompt missing         → fallback
+ *         • toolsRegistry missing                → fallback
+ *         • rebuild throws                       → fallback
+ *      Only the happy path (Responses model + everything available)
+ *      returns the trimmed rebuild.
+ *   3. Caching — same (agent, model) twice should rebuild ONCE; the
+ *      invalidator should clear entries for ONE agent only.
+ */
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+
+// Stub the activity service so importing the scheduler doesn't drag in
+// the full agent dependency graph for these unit tests.
+jest.unstable_mockModule('../../services/agentActivityService.js', () => ({
+  shouldAgentBeActive: () => ({ active: false, reason: 'stub' }),
+  getActiveAgents: () => [],
+  shouldSkipIteration: () => false,
+}));
+
+const { default: AgentScheduler } = await import('../agentScheduler.js');
+
+// ─── Test-only helpers ────────────────────────────────────────────────
+function makeScheduler({ models = [], registry = null, logger = null } = {}) {
+  const modelsService = {
+    getModels: () => models,
+  };
+  const agentPool = {
+    toolsRegistry: registry,
+    getAllAgents: async () => new Map(),
+    getAgent: async () => null,
+  };
+  const aiService = {};
+  const messageProcessor = {};
+  const log = logger || {
+    info() {}, warn() {}, error() {}, debug() {},
+  };
+  return new AgentScheduler(
+    agentPool,
+    messageProcessor,
+    aiService,
+    log,
+    null,           // webSocketManager
+    null,           // modelRouterService
+    modelsService,  // ← what we care about
+  );
+}
+
+// A minimal fake registry that records the apiType it was called with
+// so we can assert the scheduler propagates it correctly.
+function makeRegistry({ shouldThrow = false } = {}) {
+  const calls = [];
+  return {
+    calls,
+    enhanceSystemPrompt(prompt, capabilities, options) {
+      calls.push({ prompt, capabilities, options });
+      if (shouldThrow) throw new Error('boom');
+      const apiTag = options?.apiType === 'responses' ? '[trimmed]' : '[full]';
+      return `${prompt}\n## TOOLS ${apiTag} for caps=${(capabilities || []).join(',')}`;
+    },
+  };
+}
+
+// ──────────────────────────────────────────────────────────────────────
+// 1. _resolveModelApiType — parity with backend's _inferRouting
+// ──────────────────────────────────────────────────────────────────────
+
+describe('_resolveModelApiType — catalog → routing decision', () => {
+  test('api_type=["responses"] alone → "responses"', () => {
+    const s = makeScheduler({ models: [{ name: 'codex-mini', api_type: ['responses'] }] });
+    expect(s._resolveModelApiType('codex-mini')).toBe('responses');
+  });
+
+  test('api_type=["chat_completion","responses"] (BOTH present) → "chat_completion"', () => {
+    // Backend rule: only flips to responses when chat_completion is ABSENT.
+    const s = makeScheduler({
+      models: [{ name: 'gpt-5', api_type: ['chat_completion', 'responses'] }],
+    });
+    expect(s._resolveModelApiType('gpt-5')).toBe('chat_completion');
+  });
+
+  test('api_type=["chat_completion"] → "chat_completion"', () => {
+    const s = makeScheduler({ models: [{ name: 'claude', api_type: ['chat_completion'] }] });
+    expect(s._resolveModelApiType('claude')).toBe('chat_completion');
+  });
+
+  test('capabilities.responses=="true" + chatCompletion=="false" → "responses"', () => {
+    const s = makeScheduler({
+      models: [{
+        name: 'o3',
+        api_type: ['responses'],
+        capabilities: { responses: 'true', chatCompletion: 'false' },
+      }],
+    });
+    expect(s._resolveModelApiType('o3')).toBe('responses');
+  });
+
+  test('explicit useResponsesApi flag → "responses"', () => {
+    const s = makeScheduler({
+      models: [{ name: 'foo', api_type: [], useResponsesApi: true }],
+    });
+    expect(s._resolveModelApiType('foo')).toBe('responses');
+  });
+
+  test('name-pattern fallback: "codex" → "responses" even with no catalog data', () => {
+    const s = makeScheduler({ models: [{ name: 'gpt-5-1-codex-mini' }] });
+    expect(s._resolveModelApiType('gpt-5-1-codex-mini')).toBe('responses');
+  });
+
+  test('name-pattern fallback: "gpt-X-pro" → "responses"', () => {
+    const s = makeScheduler({ models: [{ name: 'gpt-5-pro' }] });
+    expect(s._resolveModelApiType('gpt-5-pro')).toBe('responses');
+  });
+
+  test('unknown model returns undefined (caller falls back to old behaviour)', () => {
+    const s = makeScheduler({ models: [{ name: 'claude', api_type: ['chat_completion'] }] });
+    expect(s._resolveModelApiType('mystery-model')).toBeUndefined();
+  });
+
+  test('modelsService missing → undefined (safe — caller falls back)', () => {
+    const s = new AgentScheduler({ toolsRegistry: null }, {}, {}, {
+      info() {}, warn() {}, error() {}, debug() {},
+    });
+    expect(s._resolveModelApiType('codex-mini')).toBeUndefined();
+  });
+
+  test('arbitrary exception in catalog → undefined (defensive)', () => {
+    // getModels() throws — must not propagate.
+    const s = new AgentScheduler(
+      { toolsRegistry: null },
+      {},
+      {},
+      { info() {}, warn() {}, error() {}, debug() {} },
+      null,
+      null,
+      { getModels() { throw new Error('catalog offline'); } },
+    );
+    expect(s._resolveModelApiType('codex-mini')).toBeUndefined();
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────
+// 2. _pickSystemPromptForModel — happy path + every safety-net path
+// ──────────────────────────────────────────────────────────────────────
+
+describe('_pickSystemPromptForModel — back-compat fallbacks', () => {
+  const BAKED_PROMPT = 'BAKED: agent persona\n## AVAILABLE TOOLS\n…lots of text…';
+  const ORIGINAL_PROMPT = 'Agent persona';
+
+  const agentFor = (overrides = {}) => ({
+    id: 'agent-1',
+    systemPrompt: BAKED_PROMPT,
+    originalSystemPrompt: ORIGINAL_PROMPT,
+    capabilities: ['memory', 'terminal'],
+    skills: [],
+    ...overrides,
+  });
+
+  test('chat-completion model → returns agent.systemPrompt verbatim', async () => {
+    const s = makeScheduler({
+      models: [{ name: 'claude', api_type: ['chat_completion'] }],
+      registry: makeRegistry(),
+    });
+    const out = await s._pickSystemPromptForModel(agentFor(), 'claude');
+    expect(out).toBe(BAKED_PROMPT);
+  });
+
+  test('unknown model → returns agent.systemPrompt verbatim', async () => {
+    const s = makeScheduler({ models: [], registry: makeRegistry() });
+    const out = await s._pickSystemPromptForModel(agentFor(), 'never-heard-of');
+    expect(out).toBe(BAKED_PROMPT);
+  });
+
+  test('Responses model BUT originalSystemPrompt missing → fallback', async () => {
+    // Very old persisted agent (pre-originalSystemPrompt storage).
+    const s = makeScheduler({
+      models: [{ name: 'codex', api_type: ['responses'] }],
+      registry: makeRegistry(),
+    });
+    const out = await s._pickSystemPromptForModel(
+      agentFor({ originalSystemPrompt: undefined }),
+      'codex',
+    );
+    expect(out).toBe(BAKED_PROMPT);
+  });
+
+  test('Responses model BUT toolsRegistry missing → fallback', async () => {
+    const s = makeScheduler({
+      models: [{ name: 'codex', api_type: ['responses'] }],
+      registry: null,
+    });
+    const out = await s._pickSystemPromptForModel(agentFor(), 'codex');
+    expect(out).toBe(BAKED_PROMPT);
+  });
+
+  test('Responses model AND rebuild throws → fallback (no crash)', async () => {
+    const s = makeScheduler({
+      models: [{ name: 'codex', api_type: ['responses'] }],
+      registry: makeRegistry({ shouldThrow: true }),
+    });
+    const out = await s._pickSystemPromptForModel(agentFor(), 'codex');
+    expect(out).toBe(BAKED_PROMPT);
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────
+// 3. _pickSystemPromptForModel — happy path
+// ──────────────────────────────────────────────────────────────────────
+
+describe('_pickSystemPromptForModel — Responses model rebuild', () => {
+  const agent = {
+    id: 'agent-1',
+    systemPrompt: 'STALE (chat-completion shape)',
+    originalSystemPrompt: 'Agent persona',
+    capabilities: ['memory', 'terminal'],
+    skills: [],
+  };
+
+  test('rebuilds with apiType:"responses" and returns trimmed prompt', async () => {
+    const reg = makeRegistry();
+    const s = makeScheduler({
+      models: [{ name: 'codex', api_type: ['responses'] }],
+      registry: reg,
+    });
+    const out = await s._pickSystemPromptForModel(agent, 'codex');
+    expect(out).toContain('[trimmed]');
+    expect(out).toContain('Agent persona');
+    // The registry was called with apiType: 'responses' AND the agent's capabilities.
+    expect(reg.calls).toHaveLength(1);
+    expect(reg.calls[0].options.apiType).toBe('responses');
+    expect(reg.calls[0].capabilities).toEqual(['memory', 'terminal']);
+  });
+
+  test('caches per (agentId, modelName) — second call does NOT rebuild', async () => {
+    const reg = makeRegistry();
+    const s = makeScheduler({
+      models: [{ name: 'codex', api_type: ['responses'] }],
+      registry: reg,
+    });
+    await s._pickSystemPromptForModel(agent, 'codex');
+    await s._pickSystemPromptForModel(agent, 'codex');
+    await s._pickSystemPromptForModel(agent, 'codex');
+    expect(reg.calls).toHaveLength(1);
+  });
+
+  test('different models for same agent → SEPARATE cache entries', async () => {
+    const reg = makeRegistry();
+    const s = makeScheduler({
+      models: [
+        { name: 'codex', api_type: ['responses'] },
+        { name: 'gpt-5-pro', api_type: ['responses'] },
+      ],
+      registry: reg,
+    });
+    await s._pickSystemPromptForModel(agent, 'codex');
+    await s._pickSystemPromptForModel(agent, 'gpt-5-pro');
+    expect(reg.calls).toHaveLength(2);
+  });
+
+  test('switching back to chat-completion mid-session uses the persisted prompt unchanged', async () => {
+    const reg = makeRegistry();
+    const s = makeScheduler({
+      models: [
+        { name: 'codex',  api_type: ['responses'] },
+        { name: 'claude', api_type: ['chat_completion'] },
+      ],
+      registry: reg,
+    });
+    const native = await s._pickSystemPromptForModel(agent, 'codex');
+    const inline = await s._pickSystemPromptForModel(agent, 'claude');
+    expect(native).toContain('[trimmed]');
+    expect(inline).toBe('STALE (chat-completion shape)');  // persisted, untouched
+    expect(reg.calls).toHaveLength(1);                     // only the codex rebuild ran
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────
+// 4. Cache invalidation
+// ──────────────────────────────────────────────────────────────────────
+
+describe('_invalidateNativePromptCache — selective per-agent clear', () => {
+  test('clears entries for ONE agent only, leaves others alone', async () => {
+    const reg = makeRegistry();
+    const s = makeScheduler({
+      models: [{ name: 'codex', api_type: ['responses'] }],
+      registry: reg,
+    });
+    const a1 = { id: 'a1', systemPrompt: 'p1', originalSystemPrompt: 'persona-1', capabilities: ['memory'], skills: [] };
+    const a2 = { id: 'a2', systemPrompt: 'p2', originalSystemPrompt: 'persona-2', capabilities: ['terminal'], skills: [] };
+
+    await s._pickSystemPromptForModel(a1, 'codex');
+    await s._pickSystemPromptForModel(a2, 'codex');
+    expect(reg.calls).toHaveLength(2);
+
+    s._invalidateNativePromptCache('a1');
+
+    // Re-fetching a1 → rebuild. a2 → still cached.
+    await s._pickSystemPromptForModel(a1, 'codex');
+    await s._pickSystemPromptForModel(a2, 'codex');
+    expect(reg.calls).toHaveLength(3); // only a1 rebuilt
+  });
+
+  test('invalidating for an agent that never rendered is a no-op (does not throw)', async () => {
+    const s = makeScheduler({ models: [], registry: makeRegistry() });
+    expect(() => s._invalidateNativePromptCache('never-seen')).not.toThrow();
+  });
+});

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

@@ -0,0 +1,94 @@
+/**
+ * Contract tests for the per-turn task-list injection in agentScheduler.
+ *
+ * Why this exists: the Talisman production failure was caused by
+ * post-compaction context loss — the agent forgot it already had a
+ * 9-task plan and called `taskmanager sync` with 4 unrelated tasks,
+ * silently destroying the in-flight work. The destructive-sync
+ * guardrail in taskManagerTool catches that AT THE SYNC POINT, but
+ * the cleaner fix is to never let the agent forget the task list in
+ * the first place — inject it into the system prompt every turn.
+ *
+ * This test pins the contract by source-grep (matches the existing
+ * pattern in agentScheduler.taskLifecycleInstruction.test.js): the
+ * scheduler's source must contain the injection block AND its key
+ * properties. Reading the file is cheaper than instantiating the
+ * full scheduler graph (websocket, compaction service, AI service,
+ * etc.) just to assert on prompt content.
+ */
+import { describe, test, expect } from '@jest/globals';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SRC = readFileSync(join(__dirname, '../agentScheduler.js'), 'utf-8');
+
+describe('agentScheduler — per-turn task-list injection', () => {
+  test('injection block exists in agentScheduler.js source', () => {
+    expect(SRC).toContain('CURRENT TASK LIST');
+  });
+
+  test('emits the heading the agent will key off of', () => {
+    // The block heading must be specific and stable — the agent's
+    // system prompt is the only thing it sees, so the heading needs
+    // to be unambiguous.
+    expect(SRC).toMatch(/##\s*CURRENT TASK LIST/);
+  });
+
+  test('reads from durable agent state (agent.taskList.tasks), not from conversation history', () => {
+    // The whole point of this injection is to recover from a
+    // conversation-history loss (compaction). It MUST read the live,
+    // durable taskList — not derive from messages.
+    expect(SRC).toMatch(/agent\.taskList\??\.tasks/);
+  });
+
+  test('the block runs AFTER the plan/* injection (cache-friendly ordering)', () => {
+    // Stable cacheable system-prompt prefix is critical for the
+    // model-side prompt cache. Both injections are dynamic per turn,
+    // but ordering must be consistent so the prefix up to plan/*
+    // stays stable across turns when only the task list moves.
+    const planIdx = SRC.indexOf('AGENT WORKING PLAN');
+    const taskIdx = SRC.indexOf('CURRENT TASK LIST');
+    expect(planIdx).toBeGreaterThan(-1);
+    expect(taskIdx).toBeGreaterThan(-1);
+    expect(taskIdx).toBeGreaterThan(planIdx);
+  });
+
+  test('mentions compaction-resistance explicitly', () => {
+    // The agent reads the injected block. It must know that the
+    // injection is a deliberate signal — not just historical residue
+    // — so it gives appropriate weight to the listed tasks.
+    expect(SRC).toMatch(/(survives compaction|compaction summarized|compaction)/);
+  });
+
+  test('warns the agent about destructive sync inside the injected block', () => {
+    // The injection is the natural place to point the agent at the
+    // guardrail. Strong message: do not blindly sync past the
+    // existing tasks.
+    expect(SRC).toMatch(/(sync|drop).*existing|before issuing.*sync/i);
+  });
+
+  test('groups tasks by status (in_progress / pending / completed / cancelled)', () => {
+    // A flat list of 30 tasks is hard to scan. Status grouping puts
+    // in_progress first — what the agent needs to act on.
+    expect(SRC).toContain('in_progress');
+    expect(SRC).toContain('pending');
+    expect(SRC).toContain('completed');
+    expect(SRC).toContain('cancelled');
+  });
+
+  test('degrades gracefully — never throws on missing taskList', () => {
+    // If taskList is undefined or .tasks is missing/empty, the
+    // injection should silently skip — never break the turn.
+    expect(SRC).toMatch(/agent\.taskList\?\.tasks/);
+    // And the whole block is wrapped in try/catch with a logger warn.
+    const block = SRC.slice(
+      SRC.indexOf('Auto-inject CURRENT TASK LIST'),
+      SRC.indexOf('Check if streaming is enabled'),
+    );
+    expect(block).toMatch(/try\s*{/);
+    expect(block).toMatch(/catch\s*\(/);
+    expect(block).toMatch(/continuing without/);
+  });
+});