@@ -37,7 +37,7 @@ describe('generateTeamProjects', () => {
   beforeEach(() => mockGetLLMClient.mockReset());
 
   it('short-circuits to [] when both commits and jira are empty (no LLM call)', async () => {
-    const out = await generateTeamProjects({ team_members: ['alice'], commits: [], jira_issues: [], in_flight_prs: [], in_flight_branches: [] });
+    const { projects: out } = await generateTeamProjects({ team_members: ['alice'], commits: [], jira_issues: [], in_flight_prs: [], in_flight_branches: [] });
     expect(out).toEqual([]);
     expect(mockGetLLMClient).not.toHaveBeenCalled();
   });
@@ -50,7 +50,7 @@ describe('generateTeamProjects', () => {
     }));
     mockGetLLMClient.mockResolvedValueOnce(client);
 
-    const out = await generateTeamProjects({
+    const { projects: out } = await generateTeamProjects({
       team_members: ['alice'],
       commits: [],
       jira_issues: [],
@@ -70,7 +70,7 @@ describe('generateTeamProjects', () => {
           last_activity: '2026-05-21T11:00:00Z' },
       ],
     })));
-    const out = await generateTeamProjects(baseInput());
+    const { projects: out } = await generateTeamProjects(baseInput());
     expect(out).toHaveLength(1);
     expect(out[0].name).toBe('P1');
     expect(out[0].developers).toEqual(['alice', 'bob']);
@@ -85,7 +85,7 @@ describe('generateTeamProjects', () => {
           last_activity: '2026-05-21T11:00:00Z' },
       ],
     })));
-    const out = await generateTeamProjects(baseInput());
+    const { projects: out } = await generateTeamProjects(baseInput());
     expect(out[0].developers).toEqual(['alice', 'bob']);
   });
 
@@ -100,7 +100,7 @@ describe('generateTeamProjects', () => {
           last_activity: '2026-05-20T10:00:00Z' },
       ],
     })));
-    const out = await generateTeamProjects(baseInput());
+    const { projects: out } = await generateTeamProjects(baseInput());
     expect(out).toHaveLength(1);
     expect(out[0].name).toBe('OK');
   });
@@ -114,7 +114,7 @@ describe('generateTeamProjects', () => {
           last_activity: '2020-01-01T00:00:00Z' },
       ],
     })));
-    const out = await generateTeamProjects(baseInput());
+    const { projects: out } = await generateTeamProjects(baseInput());
     // Max committed_at across the 2 baseInput commits is bob's '2026-05-21T11:00:00Z'
     expect(out[0].last_activity).toBe('2026-05-21T11:00:00Z');
   });
@@ -127,7 +127,7 @@ describe('generateTeamProjects', () => {
           last_activity: '2026-05-20T10:00:00Z' },
       ],
     }) + '\n```'));
-    const out = await generateTeamProjects(baseInput());
+    const { projects: out } = await generateTeamProjects(baseInput());
     expect(out).toHaveLength(1);
   });
 
 
@@ -0,0 +1,156 @@
+import {
+  generateTeamProjects,
+  projectsTokenBudget,
+  TeamProjectsUnusableError,
+} from '@/lib/team-pulse/projects';
+
+/**
+ * GLOOK-51. The Integrations team (14 developers) showed an empty Current
+ * Projects section on every reload. The model HAD produced good output — it was
+ * truncated mid-object by a flat tokenLimit(1500), JSON.parse threw, the catch
+ * returned [], and service.ts cached that [] as a success. Because the lazy
+ * top-up only re-runs when the column is NULL, one truncation blanked the
+ * section permanently.
+ *
+ * The contract: a failure must be distinguishable from "this team genuinely has
+ * no projects", because only the latter may be cached.
+ */
+
+const mockCreate = jest.fn();
+jest.mock('@/lib/llm-provider', () => ({
+  getLLMClient: async () => ({ chat: { completions: { create: mockCreate } } }),
+  LLM_MODEL: 'test-model',
+  extraBodyProps: () => ({}),
+  // Mirrors the real tokenLimit(): the openai provider gets
+  // max_completion_tokens, everything else max_tokens. Hard-coding max_tokens
+  // here would assert against a shape production may not use.
+  tokenLimit: (n: number) => ({ max_tokens: n, max_completion_tokens: n }),
+  promptTag: () => ({}),
+  samplingParams: () => ({}),
+}));
+jest.mock('@/lib/prompt-loader', () => ({ loadPrompt: () => 'SYSTEM PROMPT' }));
+
+function input(teamSize: number) {
+  const team_members = Array.from({ length: teamSize }, (_, i) => `dev${i}`);
+  return {
+    team_members,
+    commits: [{ github_login: 'dev0', committed_at: '2026-09-10T00:00:00Z', commit_message: 'x', repo: 'r' }],
+    jira_issues: [],
+    in_flight_prs: [],
+    in_flight_branches: [],
+  } as any;
+}
+
+function reply(content: string, finish_reason = 'stop') {
+  return { choices: [{ finish_reason, message: { content } }] };
+}
+
+beforeEach(() => mockCreate.mockReset());
+
+describe('projectsTokenBudget', () => {
+  it('scales with team size instead of a flat cap', () => {
+    // The flat 1500 is what truncated a 14-developer team.
+    expect(projectsTokenBudget(14)).toBeGreaterThan(1500);
+    expect(projectsTokenBudget(14)).toBeGreaterThan(projectsTokenBudget(3));
+  });
+
+  it('is bounded, and non-zero for an empty roster', () => {
+    expect(projectsTokenBudget(1000)).toBeLessThanOrEqual(8000);
+    expect(projectsTokenBudget(0)).toBeGreaterThan(0);
+  });
+});
+
+describe('an unusable response RAISES rather than returning []', () => {
+  it('raises on truncation, naming it as truncation', async () => {
+    // The exact incident shape: good JSON, cut off mid-object.
+    mockCreate.mockResolvedValue(reply(
+      '{"projects":[{"name":"Datadog On-Call Migration","estimated_prs":20,',
+      'length',
+    ));
+    await expect(generateTeamProjects(input(14), 'Integrations'))
+      .rejects.toThrow(TeamProjectsUnusableError);
+    await expect(generateTeamProjects(input(14), 'Integrations'))
+      .rejects.toThrow(/truncated[\s\S]*finish_reason=length/);
+  });
+
+  it('raises on unparseable output that was NOT truncated', async () => {
+    mockCreate.mockResolvedValue(reply('not json at all'));
+    await expect(generateTeamProjects(input(5), 'Data'))
+      .rejects.toThrow(/unparseable/);
+  });
+
+  it('reports truncation distinctly from malformed JSON', async () => {
+    // Both used to log "parse error", which sent the investigation looking at
+    // the model instead of the token budget.
+    mockCreate.mockResolvedValue(reply('{"projects":[{"name":"x",', 'length'));
+    const truncated = await generateTeamProjects(input(14), 'T').catch((e) => e.message);
+    mockCreate.mockResolvedValue(reply('garbage'));
+    const malformed = await generateTeamProjects(input(14), 'T').catch((e) => e.message);
+    expect(truncated).toMatch(/truncated/);
+    expect(malformed).not.toMatch(/truncated/);
+  });
+});
+
+describe('a genuine empty result is still a success', () => {
+  it('returns [] without raising when the model reports no projects', async () => {
+    // Must stay cacheable — otherwise every load pays for the LLM.
+    mockCreate.mockResolvedValue(reply('{"projects":[]}'));
+    await expect(generateTeamProjects(input(5), 'Small'))
+      .resolves.toEqual({ projects: [], cacheable: true });
+  });
+
+  it('short-circuits with no LLM call when there is nothing to cluster', async () => {
+    const empty = { team_members: ['a'], commits: [], jira_issues: [], in_flight_prs: [], in_flight_branches: [] } as any;
+    await expect(generateTeamProjects(empty, 'Quiet'))
+      .resolves.toEqual({ projects: [], cacheable: true });
+    expect(mockCreate).not.toHaveBeenCalled();
+  });
+});
+
+describe('a usable response is still parsed normally', () => {
+  it('keeps projects whose developers are on the team', async () => {
+    mockCreate.mockResolvedValue(reply(JSON.stringify({
+      projects: [
+        { name: 'Real', summary: 's', developers: ['dev0'], jira_count: 1, estimated_commits: 5, estimated_prs: 2 },
+        { name: 'Nobody', summary: 's', developers: ['stranger'], jira_count: 0 },
+      ],
+    })));
+    const { projects: out } = await generateTeamProjects(input(3), 'T');
+    expect(out).toHaveLength(1);
+    expect(out[0].name).toBe('Real');
+    // last_activity is overridden from real commit data.
+    expect(out[0].last_activity).toBe('2026-09-10T00:00:00Z');
+  });
+
+  it('requests a literal budget for the incident team, not just "whatever the fn returns"', async () => {
+    // Asserted as a literal on purpose: comparing against
+    // projectsTokenBudget(14) compares the implementation to itself, and a
+    // regression to the flat 1500 that caused GLOOK-51 would still pass.
+    mockCreate.mockResolvedValue(reply('{"projects":[]}'));
+    await generateTeamProjects(input(14), 'Integrations');
+    expect(projectsTokenBudget(14)).toBe(7600);
+    expect(mockCreate.mock.calls[0][0].max_tokens).toBe(7600);
+    expect(mockCreate.mock.calls[0][0].max_completion_tokens).toBe(7600);
+  });
+});
+
+describe('an empty that the validator produced is served but NOT cached', () => {
+  it('marks cacheable=false when the model named nobody on the team', async () => {
+    // The model returned projects; every developer failed the teamSet filter
+    // (e.g. display names instead of logins). Caching this would blank the
+    // section permanently — GLOOK-51 arriving by a second route. Deliberately
+    // not a throw: the empty may be correct, and raising buys a paid retry loop.
+    mockCreate.mockResolvedValue(reply(JSON.stringify({
+      projects: [{ name: 'Real work', summary: 's', developers: ['Some Person'] }],
+    })));
+    const res = await generateTeamProjects(input(3), 'T');
+    expect(res.projects).toEqual([]);
+    expect(res.cacheable).toBe(false);
+  });
+
+  it('still marks a genuinely empty model response as cacheable', async () => {
+    mockCreate.mockResolvedValue(reply('{"projects":[]}'));
+    const res = await generateTeamProjects(input(3), 'T');
+    expect(res).toEqual({ projects: [], cacheable: true });
+  });
+});
@@ -0,0 +1,116 @@
+/**
+ * GLOOK-51 storage behaviour, driven against the REAL SQLite driver.
+ *
+ * A mocked-DB test is not sufficient here and would have shipped the bug: the
+ * first fix bumped PROMPT_VERSION believing that invalidated poisoned rows, and
+ * a mock asserting "null was passed for projects" would have passed while the
+ * row still ended up '[]'. prompt_version is in the SELECT key but NOT in the
+ * unique key — `UNIQUE (report_id, team_name)` — so the upsert lands on the
+ * same physical row, where `COALESCE(VALUES(projects), projects)` preserves the
+ * old value. Only executing the upsert shows that.
+ */
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+const UPSERT = `INSERT INTO team_pulse_summaries (report_id, team_name, org, summary_text, health_json, projects, prompt_version)
+     VALUES (?, ?, ?, ?, ?, ?, ?)
+     ON DUPLICATE KEY UPDATE summary_text = VALUES(summary_text), health_json = VALUES(health_json), projects = CASE WHEN VALUES(prompt_version) <> prompt_version THEN VALUES(projects) ELSE COALESCE(VALUES(projects), projects) END, prompt_version = VALUES(prompt_version), generated_at = NOW()`;
+
+describe('team_pulse_summaries upsert — poisoned-row recovery', () => {
+  const prevSqlitePath = process.env.SQLITE_PATH;
+  const prevDbType = process.env.DB_TYPE;
+  let tmpDir: string;
+  let db: { execute: <T = any>(sql: string, params?: any[]) => Promise<[T[], any]> };
+
+  beforeAll(async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'glooker-glook51-'));
+    process.env.SQLITE_PATH = path.join(tmpDir, 'test.db');
+    process.env.DB_TYPE = 'sqlite';
+    const { createSQLiteDB } = await import('@/lib/db/sqlite');
+    db = createSQLiteDB();
+    await db.execute(
+      `INSERT INTO reports (id, org, period_days, status) VALUES (?, ?, ?, ?)`,
+      ['r1', 'Smartling', 14, 'completed'],
+    );
+  });
+
+  afterAll(() => {
+    if (prevSqlitePath === undefined) delete process.env.SQLITE_PATH;
+    else process.env.SQLITE_PATH = prevSqlitePath;
+    if (prevDbType === undefined) delete process.env.DB_TYPE;
+    else process.env.DB_TYPE = prevDbType;
+    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch { /* already gone */ }
+  });
+
+  const upsert = (team: string, projects: string | null, version: string) =>
+    db.execute(UPSERT, ['r1', team, 'Smartling', 'summary', '{}', projects, version]);
+
+  const readRow = async (team: string) => {
+    const [rows] = await db.execute(
+      `SELECT projects, prompt_version FROM team_pulse_summaries WHERE report_id = ? AND team_name = ?`,
+      ['r1', team],
+    ) as [any[], any];
+    return rows[0];
+  };
+
+  it('confirms the premise: prompt_version is NOT part of the unique key', async () => {
+    // If it were, the second insert would create a second row and the whole
+    // invalidation story would work as originally claimed.
+    await upsert('KeyProbe', '[]', 'v4-inflight');
+    await upsert('KeyProbe', null, 'v5-budget');
+    const [rows] = await db.execute(
+      `SELECT COUNT(*) AS n FROM team_pulse_summaries WHERE report_id = ? AND team_name = ?`,
+      ['r1', 'KeyProbe'],
+    ) as [any[], any];
+    expect(Number(rows[0].n)).toBe(1);
+  });
+
+  it('a version change REPLACES a poisoned projects value with NULL', async () => {
+    // The GLOOK-51 recovery. Without the CASE, COALESCE keeps '[]' here and the
+    // lazy top-up guard (row.projects === null) never fires again.
+    await upsert('Integrations', '[]', 'v4-inflight');
+    expect((await readRow('Integrations')).projects).toBe('[]');
+
+    await upsert('Integrations', null, 'v5-budget');
+    const row = await readRow('Integrations');
+    expect(row.projects).toBeNull();
+    expect(row.prompt_version).toBe('v5-budget');
+  });
+
+  it('still protects the concurrency race WITHIN a version', async () => {
+    // Documented at service.ts: a no-withProjects write must not clobber a
+    // successfully generated value back to NULL. Deleting the COALESCE to fix
+    // the case above would reintroduce exactly this.
+    await upsert('Data', JSON.stringify([{ name: 'Real' }]), 'v5-budget');
+    await upsert('Data', null, 'v5-budget');
+    expect(await readRow('Data').then(r => r.projects)).toBe('[{"name":"Real"}]');
+  });
+
+  it('a version change still carries a good new value through', async () => {
+    await upsert('GDN', '[]', 'v4-inflight');
+    await upsert('GDN', JSON.stringify([{ name: 'Fresh' }]), 'v5-budget');
+    expect(await readRow('GDN').then(r => r.projects)).toBe('[{"name":"Fresh"}]');
+  });
+
+  it('NEGATIVE CONTROL: the pre-fix upsert preserves the poison, proving the CASE is load-bearing', async () => {
+    // This is the SQL that shipped in the first GLOOK-51 attempt. Executing it
+    // shows the bump was a no-op that additionally mis-stamped the row, which
+    // is what the review found and what a mocked DB could not have shown.
+    const OLD = UPSERT.replace(
+      'projects = CASE WHEN VALUES(prompt_version) <> prompt_version THEN VALUES(projects) ELSE COALESCE(VALUES(projects), projects) END',
+      'projects = COALESCE(VALUES(projects), projects)',
+    );
+    await upsert('OldSql', '[]', 'v4-inflight');
+    await db.execute(OLD, ['r1', 'OldSql', 'Smartling', 'summary', '{}', null, 'v5-budget']);
+    const row = await readRow('OldSql');
+    expect(row.projects).toBe('[]');          // still poisoned
+    expect(row.prompt_version).toBe('v5-budget'); // but now claims to be fixed
+  });
+
+  it('a genuine empty result is still persisted, so the page does not re-pay', async () => {
+    await upsert('Quiet', '[]', 'v5-budget');
+    const row = await readRow('Quiet');
+    expect(row.projects).toBe('[]');
+  });
+});
@@ -70,6 +70,16 @@ export function createBedrockClient() {
           return {
             choices: [
               {
+                // Bedrock reports truncation as stop_reason: 'max_tokens'.
+                // Without this mapping every caller sees finish_reason
+                // undefined, so truncation checks are dead on this provider and
+                // a cut-off response gets misreported as malformed output
+                // (GLOOK-51). Also repairs the existing reads in
+                // projects/insights.ts and projects/untracked.ts.
+                finish_reason:
+                  decoded.stop_reason === 'max_tokens' ? 'length'
+                  : decoded.stop_reason === 'end_turn' ? 'stop'
+                  : (decoded.stop_reason ?? 'stop'),
                 message: {
                   role: 'assistant',
                   content: decoded.content?.[0]?.text ?? '',
 
@@ -87,6 +87,9 @@ export function createMockLLMClient() {
           return {
             choices: [
               {
+                // Mock the field too, so a caller that checks finish_reason
+                // behaves the same in mock mode as against a real provider.
+                finish_reason: 'stop',
                 message: {
                   role: 'assistant',
                   content,