bereach-openclaw 1.4.7 → 1.4.8-beta.1

package/__tests__/hooks.test.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { createSessionState, READ_TOOLS, WRITE_TOOLS, PACED_FREE_TOOLS, type SessionState } from "../src/hooks/types";
+import { createSessionState, READ_TOOLS, WRITE_TOOLS, PACED_FREE_TOOLS, classifyUpgrade, type SessionState } from "../src/hooks/types";
 import * as cache from "../src/hooks/cache";
+import type { CacheStore } from "../src/hooks/cache";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -45,6 +46,30 @@ function mockFetchResponses(responses: Record<string, unknown>) {
   });
 }
 
+/** Build a standard snapshot response for the /api/agent/snapshot endpoint. */
+function buildSnapshot(overrides: Partial<CacheStore & { campaignState?: any }> = {}): Record<string, unknown> {
+  return {
+    "/api/agent/snapshot": {
+      credits: overrides.credits ?? { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 },
+      limits: overrides.limits ?? { multiplier: 1, limits: {} },
+      pipeline: overrides.pipeline ?? { contact: 0, lead: 0, qualified: 0, approved: 0, rejected: 0, total: 0 },
+      contexts: overrides.contexts ?? [],
+      pendingDrafts: overrides.pendingDrafts ?? 0,
+      failedDrafts: overrides.failedDrafts ?? 0,
+      unreadDMs: overrides.unreadDMs ?? 0,
+      pendingSentInvitations: overrides.pendingSentInvitations ?? 0,
+      activeAccount: overrides.activeAccount ?? null,
+      accounts: overrides.accounts ?? [],
+      leadGenState: overrides.leadGenState ?? null,
+      outreachState: overrides.outreachState ?? null,
+      activeCampaigns: overrides.activeCampaigns ?? [],
+      campaignChecks: overrides.campaignChecks ?? {},
+      sessionMeta: overrides.sessionMeta ?? null,
+      onboardingState: overrides.onboardingState ?? null,
+    },
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
@@ -56,7 +81,6 @@ describe("hooks/types", () => {
     expect(state.creditsUsedThisSession).toBe(0);
     expect(state.toolCallCount).toBe(0);
     expect(state.visitedProfiles.size).toBe(0);
-    expect(state.engagementSignals.size).toBe(0);
     expect(state.initialized).toBe(false);
   });
 });
@@ -74,16 +98,10 @@ describe("hooks/cache", () => {
   });
 
   it("getOrFetch returns data and caches it", async () => {
-    const mockFetch = mockFetchResponses({
-      "/api/me/credits": { credits: { current: 10, limit: 100, remaining: 90, isUnlimited: false, percentage: 10 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: { contact: 5, lead: 3, qualified: 1, approved: 0, rejected: 0 } },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [{ id: "acc1", linkedinName: "Test", accountPlan: "premium", isUnlimited: false, creditsLimit: 200, creditsCount: 10, isCurrent: true }] },
-      "/api/agent-state/lead-gen": { data: null },
-      "/api/agent-state/outreach": { data: null },
-    });
+    const mockFetch = mockFetchResponses(buildSnapshot({
+      credits: { current: 10, limit: 100, remaining: 90, isUnlimited: false, percentage: 10 },
+      pipeline: { contact: 5, lead: 3, qualified: 1, approved: 0, rejected: 0, total: 9 },
+    }));
     globalThis.fetch = mockFetch as any;
 
     const data = await cache.getOrFetch("brc_test");
@@ -100,16 +118,9 @@ describe("hooks/cache", () => {
   });
 
   it("invalidate clears a specific key", async () => {
-    globalThis.fetch = mockFetchResponses({
-      "/api/me/credits": { credits: { current: 10, limit: 100, remaining: 90, isUnlimited: false, percentage: 10 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: { contact: 0, lead: 0, qualified: 0, approved: 0, rejected: 0 } },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/lead-gen": { data: null },
-      "/api/agent-state/outreach": { data: null },
-    }) as any;
+    globalThis.fetch = mockFetchResponses(buildSnapshot({
+      credits: { current: 10, limit: 100, remaining: 90, isUnlimited: false, percentage: 10 },
+    })) as any;
 
     await cache.getOrFetch("brc_test");
     cache.invalidate("credits");
@@ -145,14 +156,15 @@ describe("hooks/context", () => {
 
     globalThis.fetch = mockFetchResponses({
       "/api/onboarding/soul": { soul: "<!-- bereach-workspace-v2 -->\nTest Template\n<!-- /bereach-workspace -->" },
-      "/api/me/credits": { credits: { current: 5, limit: 50, remaining: 45, isUnlimited: false, percentage: 10 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: { contact: 10, lead: 5, qualified: 2, approved: 1, rejected: 0 } },
-      "/api/context": { entries: [{ type: "icp", label: "ICP", content: "B2B SaaS founders", scope: "user" }] },
-      "/api/scheduled-messages": { messages: [], total: 2 },
-      "/api/me/linkedin/accounts": { accounts: [{ id: "a1", linkedinName: "John", accountPlan: "premium", isUnlimited: false, creditsLimit: 50, creditsCount: 5, isCurrent: true }] },
-      "/api/agent-state/lead-gen": { data: { phase: "enrich", totalFound: 42 } },
-      "/api/agent-state/outreach": { data: null },
+      ...buildSnapshot({
+        credits: { current: 5, limit: 50, remaining: 45, isUnlimited: false, percentage: 10 },
+        pipeline: { contact: 10, lead: 5, qualified: 2, approved: 1, rejected: 0, total: 18 },
+        contexts: [{ type: "icp", label: "ICP", content: "B2B SaaS founders", scope: "user" }],
+        pendingDrafts: 2,
+        activeAccount: { id: "a1", name: "John", plan: "premium", headline: null, isUnlimited: false, creditsLimit: 50, creditsCount: 5, isCurrent: true },
+        accounts: [{ id: "a1", name: "John", plan: "premium", headline: null, isUnlimited: false, creditsLimit: 50, creditsCount: 5, isCurrent: true }],
+        leadGenState: { phase: "enrich", totalFound: 42 },
+      }),
     }) as any;
 
     registerContextHook(api, "brc_test_key");
@@ -163,11 +175,9 @@ describe("hooks/context", () => {
     expect(result.appendSystemContext).toContain("BeReach Live Status");
     expect(result.appendSystemContext).toContain("45 remaining");
     expect(result.appendSystemContext).toContain("Contact | 10");
-    expect(result.appendSystemContext).toContain("2 draft messages");
+    expect(result.appendSystemContext).toContain("2 draft");
     expect(result.appendSystemContext).toContain("ICP");
     expect(result.appendSystemContext).toContain("B2B SaaS founders");
-    expect(result.appendSystemContext).toContain("Lead gen state found");
-    expect(result.appendSystemContext).toContain("42 leads found");
   });
 });
 
@@ -193,16 +203,9 @@ describe("hooks/enforcement", () => {
     const { registerEnforcementHook } = await import("../src/hooks/enforcement");
     const api = createMockApi();
 
-    globalThis.fetch = mockFetchResponses({
-      "/api/me/credits": { credits: { current: 100, limit: 100, remaining: 0, isUnlimited: false, percentage: 100 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: {} },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/lead-gen": { data: null },
-      "/api/agent-state/outreach": { data: null },
-    }) as any;
+    globalThis.fetch = mockFetchResponses(buildSnapshot({
+      credits: { current: 100, limit: 100, remaining: 0, isUnlimited: false, percentage: 100 },
+    })) as any;
 
     registerEnforcementHook(api, "brc_test_key", {}, state);
 
@@ -220,16 +223,9 @@ describe("hooks/enforcement", () => {
     const { registerEnforcementHook } = await import("../src/hooks/enforcement");
     const api = createMockApi();
 
-    globalThis.fetch = mockFetchResponses({
-      "/api/me/credits": { credits: { current: 100, limit: 100, remaining: 0, isUnlimited: false, percentage: 100 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: {} },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/lead-gen": { data: null },
-      "/api/agent-state/outreach": { data: null },
-    }) as any;
+    globalThis.fetch = mockFetchResponses(buildSnapshot({
+      credits: { current: 100, limit: 100, remaining: 0, isUnlimited: false, percentage: 100 },
+    })) as any;
 
     registerEnforcementHook(api, "brc_test_key", {}, state);
 
@@ -246,14 +242,7 @@ describe("hooks/enforcement", () => {
     const api = createMockApi();
 
     globalThis.fetch = mockFetchResponses({
-      "/api/me/credits": { credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: {} },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/lead-gen": { data: null },
-      "/api/agent-state/outreach": { data: null },
+      ...buildSnapshot({ credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 } }),
       "/api/contacts/by-url": { contact: { doNotContact: false } },
     }) as any;
 
@@ -274,14 +263,7 @@ describe("hooks/enforcement", () => {
     const api = createMockApi();
 
     globalThis.fetch = mockFetchResponses({
-      "/api/me/credits": { credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: {} },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/lead-gen": { data: null },
-      "/api/agent-state/outreach": { data: null },
+      ...buildSnapshot({ credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 } }),
       "/api/contacts/by-url": { contact: { doNotContact: false } },
     }) as any;
 
@@ -301,16 +283,9 @@ describe("hooks/enforcement", () => {
     const { registerEnforcementHook } = await import("../src/hooks/enforcement");
     const api = createMockApi();
 
-    globalThis.fetch = mockFetchResponses({
-      "/api/me/credits": { credits: { current: 0, limit: 1000, remaining: 1000, isUnlimited: false, percentage: 0 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: {} },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/lead-gen": { data: null },
-      "/api/agent-state/outreach": { data: null },
-    }) as any;
+    globalThis.fetch = mockFetchResponses(buildSnapshot({
+      credits: { current: 0, limit: 1000, remaining: 1000, isUnlimited: false, percentage: 0 },
+    })) as any;
 
     state.visitCount = 50;
     registerEnforcementHook(api, "brc_test_key", { maxVisitsPerSession: 50 }, state);
@@ -330,17 +305,11 @@ describe("hooks/enforcement", () => {
     const api = createMockApi();
 
     globalThis.fetch = mockFetchResponses({
-      "/api/me/credits": { credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: {} },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/lead-gen": { data: null },
-      "/api/agent-state/outreach": { data: null },
+      ...buildSnapshot({ credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 } }),
       "/api/contacts/by-url": { contact: { doNotContact: true } },
     }) as any;
 
+    state.dmHistoryChecked.add("https://linkedin.com/in/blocked-person");
     registerEnforcementHook(api, "brc_test_key", { writePacingMin: 0, writePacingMax: 0 }, state);
 
     const result = await api._fire("before_tool_call", {
@@ -381,96 +350,6 @@ describe("hooks/tracking", () => {
     cache.clearAll();
   });
 
-  it("truncates long post text in results", async () => {
-    const { registerTrackingHook } = await import("../src/hooks/tracking");
-    const api = createMockApi();
-    registerTrackingHook(api, state, undefined, 50, 10);
-
-    const longText = "A".repeat(200);
-    const ctx = {
-      toolName: "bereach_collect_posts",
-      result: {
-        content: [{ type: "text", text: JSON.stringify({ posts: [{ text: longText, title: "Test" }] }) }],
-      },
-    };
-
-    await api._fire("after_tool_call", ctx);
-    const parsed = JSON.parse(ctx.result.content[0].text);
-    expect(parsed.posts[0].text.length).toBeLessThan(200);
-    expect(parsed.posts[0].text).toContain("...");
-  });
-
-  it("strips image URL fields", async () => {
-    const { registerTrackingHook } = await import("../src/hooks/tracking");
-    const api = createMockApi();
-    registerTrackingHook(api, state);
-
-    const ctx = {
-      toolName: "bereach_search_people",
-      result: {
-        content: [{
-          type: "text",
-          text: JSON.stringify({
-            profiles: [
-              { name: "Test", profilePicture: "https://cdn.example.com/pic.jpg", profileUrl: "https://linkedin.com/in/test" },
-            ],
-          }),
-        }],
-      },
-    };
-
-    await api._fire("after_tool_call", ctx);
-    const parsed = JSON.parse(ctx.result.content[0].text);
-    expect(parsed.profiles[0].profilePicture).toBeUndefined();
-    expect(parsed.profiles[0].name).toBe("Test");
-    expect(parsed.profiles[0].profileUrl).toBe("https://linkedin.com/in/test");
-  });
-
-  it("truncates large arrays", async () => {
-    const { registerTrackingHook } = await import("../src/hooks/tracking");
-    const api = createMockApi();
-    registerTrackingHook(api, state, undefined, 500, 5);
-
-    const profiles = Array.from({ length: 50 }, (_, i) => ({ name: `Person ${i}` }));
-    const ctx = {
-      toolName: "bereach_search_people",
-      result: {
-        content: [{ type: "text", text: JSON.stringify({ profiles }) }],
-      },
-    };
-
-    await api._fire("after_tool_call", ctx);
-    const parsed = JSON.parse(ctx.result.content[0].text);
-    expect(parsed.profiles.length).toBe(5);
-    expect(parsed._truncated.total).toBe(50);
-    expect(parsed._truncated.shown).toBe(5);
-  });
-
-  it("tracks engagement signals from collect_likes", async () => {
-    const { registerTrackingHook } = await import("../src/hooks/tracking");
-    const api = createMockApi();
-    registerTrackingHook(api, state);
-
-    const ctx = {
-      toolName: "bereach_collect_likes",
-      result: {
-        content: [{
-          type: "text",
-          text: JSON.stringify({
-            profiles: [
-              { profileUrl: "https://linkedin.com/in/alice" },
-              { profileUrl: "https://linkedin.com/in/bob" },
-            ],
-          }),
-        }],
-      },
-    };
-
-    await api._fire("after_tool_call", ctx);
-    expect(state.engagementSignals.get("https://linkedin.com/in/alice")).toBe(1);
-    expect(state.engagementSignals.get("https://linkedin.com/in/bob")).toBe(1);
-  });
-
   it("tracks visits and invalidates credits cache", async () => {
     const { registerTrackingHook } = await import("../src/hooks/tracking");
     const api = createMockApi();
@@ -493,21 +372,18 @@ describe("hooks/tracking", () => {
     expect(state.creditsUsedThisSession).toBe(1);
   });
 
-  it("uses compact JSON (no pretty-print)", async () => {
+  it("records DM pacing timestamp on send_message", async () => {
     const { registerTrackingHook } = await import("../src/hooks/tracking");
     const api = createMockApi();
     registerTrackingHook(api, state);
 
     const ctx = {
-      toolName: "bereach_contacts_search",
-      result: {
-        content: [{ type: "text", text: JSON.stringify({ contacts: [{ name: "Test" }] }, null, 2) }],
-      },
+      toolName: "bereach_send_message",
+      result: JSON.stringify({ success: true }),
     };
 
     await api._fire("after_tool_call", ctx);
-    // Should be compact (no newlines from pretty-print)
-    expect(ctx.result.content[0].text).not.toContain("\n");
+    expect(state.lastDmSentAt).toBeGreaterThan(0);
   });
 });
 
@@ -575,45 +451,47 @@ describe("hooks/lifecycle", () => {
 // ---------------------------------------------------------------------------
 
 describe("hooks/model-routing", () => {
-  it("routes to opus for code generation", async () => {
-    const { registerModelRoutingHook } = await import("../src/hooks/model-routing");
+  it("detects weak models and sets isWeakModel", async () => {
+    const { registerModelRoutingHook, modelState } = await import("../src/hooks/model-routing");
     const api = createMockApi();
 
     registerModelRoutingHook(api);
 
-    const result = await api._fire("before_model_resolve", {
-      pendingActions: [{ type: "write" }],
+    await api._fire("before_model_resolve", {
+      model: "anthropic/claude-haiku-3",
     });
 
-    expect(result).toBeDefined();
-    expect(result.model).toContain("opus");
+    expect(modelState.isWeakModel).toBe(true);
+    expect(modelState.detectedModel).toBe("anthropic/claude-haiku-3");
   });
 
-  it("returns undefined for non-code tasks", async () => {
-    const { registerModelRoutingHook } = await import("../src/hooks/model-routing");
+  it("returns undefined for non-weak models without creative mode", async () => {
+    const { registerModelRoutingHook, modelState } = await import("../src/hooks/model-routing");
     const api = createMockApi();
+    modelState.creativeMode = false;
+    modelState.consecutiveErrors = 0;
 
     registerModelRoutingHook(api);
 
     const result = await api._fire("before_model_resolve", {
-      pendingActions: [{ type: "search" }],
+      model: "anthropic/claude-sonnet-4-6",
     });
 
     expect(result).toBeUndefined();
   });
 
-  it("uses custom model ID when configured", async () => {
-    const { registerModelRoutingHook } = await import("../src/hooks/model-routing");
+  it("auto-detects creative model for Anthropic Haiku", async () => {
+    const { registerModelRoutingHook, modelState } = await import("../src/hooks/model-routing");
     const api = createMockApi();
+    modelState.creativeMode = true;
 
-    registerModelRoutingHook(api, { opusModelId: "anthropic/claude-opus-5" });
+    registerModelRoutingHook(api);
 
-    const result = await api._fire("before_model_resolve", {
-      pendingActions: [{ type: "edit" }],
+    await api._fire("before_model_resolve", {
+      model: "anthropic/claude-haiku-3",
     });
 
-    expect(result).toBeDefined();
-    expect(result.model).toBe("anthropic/claude-opus-5");
+    expect(modelState.resolvedCreativeModel).toContain("sonnet");
   });
 });
 
@@ -639,25 +517,10 @@ describe("hooks/enforcement - rate limits", () => {
     const { registerEnforcementHook } = await import("../src/hooks/enforcement");
     const api = createMockApi();
 
-    globalThis.fetch = mockFetchResponses({
-      "/api/me/credits": { credits: { current: 5, limit: 100, remaining: 95, isUnlimited: false, percentage: 5 } },
-      "/api/rate-limits": {
-        multiplier: 1,
-        linkedIn: {
-          limits: {
-            profile_visit: {
-              daily: { current: 100, limit: 100, remaining: 0 },
-            },
-          },
-        },
-      },
-      "/api/contacts/stats": { funnel: {} },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/lead-gen": { data: null },
-      "/api/agent-state/outreach": { data: null },
-    }) as any;
+    globalThis.fetch = mockFetchResponses(buildSnapshot({
+      credits: { current: 5, limit: 100, remaining: 95, isUnlimited: false, percentage: 5 },
+      limits: { multiplier: 1, limits: { profile_visit: { daily: { current: 100, limit: 100, remaining: 0 } } } },
+    })) as any;
 
     registerEnforcementHook(api, "brc_test_key", { readPacingMin: 0, readPacingMax: 0 }, state);
 
@@ -677,24 +540,10 @@ describe("hooks/enforcement - rate limits", () => {
     const api = createMockApi();
 
     globalThis.fetch = mockFetchResponses({
-      "/api/me/credits": { credits: { current: 5, limit: 100, remaining: 95, isUnlimited: false, percentage: 5 } },
-      "/api/rate-limits": {
-        multiplier: 1,
-        linkedIn: {
-          limits: {
-            connection_request: {
-              daily: { current: 10, limit: 30, remaining: 20 },
-              weekly: { current: 100, limit: 100, remaining: 0 },
-            },
-          },
-        },
-      },
-      "/api/contacts/stats": { funnel: {} },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/lead-gen": { data: null },
-      "/api/agent-state/outreach": { data: null },
+      ...buildSnapshot({
+        credits: { current: 5, limit: 100, remaining: 95, isUnlimited: false, percentage: 5 },
+        limits: { multiplier: 1, limits: { connection_request: { daily: { current: 10, limit: 30, remaining: 20 }, weekly: { current: 100, limit: 100, remaining: 0 } } } },
+      }),
       "/api/contacts/by-url": { contact: { doNotContact: false } },
     }) as any;
 
@@ -715,16 +564,9 @@ describe("hooks/enforcement - rate limits", () => {
     const { registerEnforcementHook } = await import("../src/hooks/enforcement");
     const api = createMockApi();
 
-    globalThis.fetch = mockFetchResponses({
-      "/api/me/credits": { credits: { current: 500, limit: null, remaining: null, isUnlimited: true, percentage: 0 } },
-      "/api/rate-limits": { multiplier: 3, linkedIn: { limits: {} } },
-      "/api/contacts/stats": { funnel: {} },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/lead-gen": { data: null },
-      "/api/agent-state/outreach": { data: null },
-    }) as any;
+    globalThis.fetch = mockFetchResponses(buildSnapshot({
+      credits: { current: 500, limit: null, remaining: null, isUnlimited: true, percentage: 0 },
+    })) as any;
 
     registerEnforcementHook(api, "brc_test_key", { readPacingMin: 0, readPacingMax: 0 }, state);
 
@@ -740,16 +582,9 @@ describe("hooks/enforcement - rate limits", () => {
     const { registerEnforcementHook } = await import("../src/hooks/enforcement");
     const api = createMockApi();
 
-    globalThis.fetch = mockFetchResponses({
-      "/api/me/credits": { credits: { current: 100, limit: 100, remaining: 0, isUnlimited: false, percentage: 100 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: {} },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/lead-gen": { data: null },
-      "/api/agent-state/outreach": { data: null },
-    }) as any;
+    globalThis.fetch = mockFetchResponses(buildSnapshot({
+      credits: { current: 100, limit: 100, remaining: 0, isUnlimited: false, percentage: 100 },
+    })) as any;
 
     const startMs = Date.now();
     registerEnforcementHook(api, "brc_test_key", { readPacingMin: 5, readPacingMax: 10 }, state);
@@ -773,6 +608,13 @@ describe("hooks/enforcement - rate limits", () => {
 describe("hooks/context - campaign dispatch", () => {
   const originalFetch = globalThis.fetch;
 
+  beforeEach(async () => {
+    cache.clearAll();
+    const { modelState } = await import("../src/hooks/model-routing");
+    modelState.isWeakModel = false;
+    modelState.consecutiveErrors = 0;
+  });
+
   afterEach(() => {
     globalThis.fetch = originalFetch;
     cache.clearAll();
@@ -783,43 +625,19 @@ describe("hooks/context - campaign dispatch", () => {
     const api = createMockApi();
 
     const now = new Date();
-    const tenMinAgo = new Date(now.getTime() - 10 * 60 * 1000).toISOString();
     const twoHoursAgo = new Date(now.getTime() - 120 * 60 * 1000).toISOString();
 
     globalThis.fetch = mockFetchResponses({
       "/api/onboarding/soul": { soul: "<!-- bereach-workspace-v2 -->\nTest\n<!-- /bereach-workspace -->" },
-      "/api/me/credits": { credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: { contact: 0, lead: 0, qualified: 0, approved: 0, rejected: 0 } },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/lead-gen": { data: null },
-      "/api/agent-state/outreach": { data: null },
-      "/api/chats/linkedin/unread": { unreadCount: 0 },
-      "/api/agent-state/campaigns": {
-        data: {
-          schemaVersion: 1,
-          campaigns: [
-            {
-              id: "lm-1", type: "lead-magnet", name: "AI tools post",
-              status: "active", priority: "high",
-              checkIntervalMinutes: 5, lastCheckAt: tenMinAgo,
-              createdAt: twoHoursAgo, config: {}, progress: {}, stats: {},
-              lockedUntil: null, errorMessage: null, consecutiveErrors: 0, lastSuccessAt: tenMinAgo,
-            },
-            {
-              id: "lg-1", type: "lead-gen", name: "competitor scrape",
-              status: "active", priority: "medium",
-              checkIntervalMinutes: 60, lastCheckAt: twoHoursAgo,
-              createdAt: twoHoursAgo, config: {}, progress: {}, stats: {},
-              lockedUntil: null, errorMessage: null, consecutiveErrors: 0, lastSuccessAt: twoHoursAgo,
-            },
-          ],
-          updatedAt: tenMinAgo,
-        },
-      },
-      "registry.npmjs.org": null,
+      ...buildSnapshot({
+        credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 },
+        onboardingState: { completed: true },
+        activeCampaigns: [
+          { id: "lm-1", type: "lead-magnet", name: "AI tools post", status: "active" },
+          { id: "lg-1", type: "lead-gen", name: "competitor scrape", status: "active" },
+        ],
+        campaignChecks: { "lm-1": twoHoursAgo, "lg-1": twoHoursAgo },
+      }),
     }) as any;
 
     registerContextHook(api, "brc_test_key");
@@ -837,17 +655,10 @@ describe("hooks/context - campaign dispatch", () => {
 
     globalThis.fetch = mockFetchResponses({
       "/api/onboarding/soul": { soul: "<!-- bereach-workspace-v2 -->\nTest\n<!-- /bereach-workspace -->" },
-      "/api/me/credits": { credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: { contact: 0, lead: 0, qualified: 0, approved: 0, rejected: 0 } },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/lead-gen": { data: null },
-      "/api/agent-state/outreach": { data: null },
-      "/api/chats/linkedin/unread": { unreadCount: 0 },
-      "/api/agent-state/campaigns": { data: null },
-      "registry.npmjs.org": null,
+      ...buildSnapshot({
+        credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 },
+        onboardingState: { completed: true },
+      }),
     }) as any;
 
     registerContextHook(api, "brc_test_key");
@@ -862,17 +673,10 @@ describe("hooks/context - campaign dispatch", () => {
 
     globalThis.fetch = mockFetchResponses({
       "/api/onboarding/soul": { soul: "<!-- bereach-workspace-v2 -->\nTest\n<!-- /bereach-workspace -->" },
-      "/api/me/credits": { credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: {} },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/lead-gen": { data: null },
-      "/api/agent-state/outreach": { data: null },
-      "/api/chats/linkedin/unread": { unreadCount: 0 },
-      "/api/agent-state/campaigns": { data: null },
-      "registry.npmjs.org": null,
+      ...buildSnapshot({
+        credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 },
+        onboardingState: { completed: true },
+      }),
     }) as any;
 
     registerContextHook(api, "brc_test_key");
@@ -881,8 +685,6 @@ describe("hooks/context - campaign dispatch", () => {
     expect(result.appendSystemContext).toContain("Execution Modes");
     expect(result.appendSystemContext).toContain("One-shot");
     expect(result.appendSystemContext).toContain("Recurring");
-    expect(result.appendSystemContext).toContain("Campaign Orchestrator");
-    expect(result.appendSystemContext).toContain("*/5 * * * *");
   });
 
   it("injects execution modes when campaign state has 0 campaigns", async () => {
@@ -891,17 +693,11 @@ describe("hooks/context - campaign dispatch", () => {
 
     globalThis.fetch = mockFetchResponses({
       "/api/onboarding/soul": { soul: "<!-- bereach-workspace-v2 -->\nTest\n<!-- /bereach-workspace -->" },
-      "/api/me/credits": { credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: {} },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/lead-gen": { data: null },
-      "/api/agent-state/outreach": { data: null },
-      "/api/chats/linkedin/unread": { unreadCount: 0 },
-      "/api/agent-state/campaigns": { data: { schemaVersion: 1, campaigns: [], updatedAt: "2026-01-01" } },
-      "registry.npmjs.org": null,
+      ...buildSnapshot({
+        credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 },
+        activeCampaigns: [],
+        onboardingState: { completed: true },
+      }),
     }) as any;
 
     registerContextHook(api, "brc_test_key");
@@ -919,29 +715,14 @@ describe("hooks/context - campaign dispatch", () => {
     const now = new Date();
     globalThis.fetch = mockFetchResponses({
       "/api/onboarding/soul": { soul: "<!-- bereach-workspace-v2 -->\nTest\n<!-- /bereach-workspace -->" },
-      "/api/me/credits": { credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: {} },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/lead-gen": { data: null },
-      "/api/agent-state/outreach": { data: null },
-      "/api/chats/linkedin/unread": { unreadCount: 0 },
-      "/api/agent-state/campaigns": {
-        data: {
-          schemaVersion: 1,
-          campaigns: [{
-            id: "c1", type: "lead-gen", name: "Test", status: "active",
-            priority: "medium", checkIntervalMinutes: 60,
-            lastCheckAt: new Date(now.getTime() - 30 * 60_000).toISOString(),
-            createdAt: now.toISOString(), config: {}, progress: {}, stats: {},
-            lockedUntil: null, errorMessage: null, consecutiveErrors: 0, lastSuccessAt: null,
-          }],
-          updatedAt: now.toISOString(),
-        },
-      },
-      "registry.npmjs.org": null,
+      ...buildSnapshot({
+        credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 },
+        activeCampaigns: [
+          { id: "c1", type: "lead-gen", name: "Test", status: "active" },
+        ],
+        campaignChecks: { c1: new Date(now.getTime() - 30 * 60_000).toISOString() },
+        onboardingState: { completed: true },
+      }),
     }) as any;
 
     registerContextHook(api, "brc_test_key");
@@ -951,170 +732,117 @@ describe("hooks/context - campaign dispatch", () => {
     expect(result.appendSystemContext).toContain("Campaign Dispatch");
   });
 
-  it("injects AUTO-RESUME directive when auto-resume flag and incomplete lead-gen state exist", async () => {
+  it("injects incomplete task directive when lead-gen state is in progress", async () => {
     const { registerContextHook } = await import("../src/hooks/context");
     const api = createMockApi();
 
     globalThis.fetch = mockFetchResponses({
       "/api/onboarding/soul": { soul: "<!-- bereach-workspace-v2 -->\nTest\n<!-- /bereach-workspace -->" },
-      "/api/me/credits": { credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: {} },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/lead-gen": { data: { phase: "qualification", totalFound: 30, target: 100 } },
-      "/api/agent-state/outreach": { data: null },
-      "/api/chats/linkedin/unread": { unreadCount: 0 },
-      "/api/agent-state/campaigns": { data: null },
-      "/api/agent-state/auto-resume": { data: { taskType: "lead-gen", savedAt: new Date().toISOString(), phase: "qualification", found: 30, target: 100, stateKey: "lead-gen" } },
-      "registry.npmjs.org": null,
+      ...buildSnapshot({
+        credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 },
+        leadGenState: { phase: "qualification", totalFound: 30, target: 100 },
+        onboardingState: { completed: true },
+      }),
     }) as any;
 
     registerContextHook(api, "brc_test_key");
     const result = await api._fire("before_prompt_build");
 
-    expect(result.appendSystemContext).toContain("AUTO-RESUME");
     expect(result.appendSystemContext).toContain("Incomplete Task");
     expect(result.appendSystemContext).toContain("bereach_state_get('lead-gen')");
-    expect(result.appendSystemContext).toContain("bereach_state_delete('auto-resume')");
-    // Should also inject cron setup since no campaigns exist
-    expect(result.appendSystemContext).toContain("Ensure Cron");
   });
 
-  it("skips AUTO-RESUME when lead-gen state is completed (orphaned flag)", async () => {
+  it("skips incomplete task when lead-gen state is completed", async () => {
     const { registerContextHook } = await import("../src/hooks/context");
     const api = createMockApi();
 
     globalThis.fetch = mockFetchResponses({
       "/api/onboarding/soul": { soul: "<!-- bereach-workspace-v2 -->\nTest\n<!-- /bereach-workspace -->" },
-      "/api/me/credits": { credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: {} },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/lead-gen": { data: { phase: "complete", totalFound: 100, target: 100 } },
-      "/api/agent-state/outreach": { data: null },
-      "/api/chats/linkedin/unread": { unreadCount: 0 },
-      "/api/agent-state/campaigns": { data: null },
-      "/api/agent-state/auto-resume": { data: { taskType: "lead-gen", savedAt: new Date().toISOString(), phase: "qualification", found: 30, target: 100, stateKey: "lead-gen" } },
-      "registry.npmjs.org": null,
+      ...buildSnapshot({
+        credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 },
+        leadGenState: { phase: "complete", totalFound: 100, target: 100 },
+        onboardingState: { completed: true },
+      }),
     }) as any;
 
     registerContextHook(api, "brc_test_key");
     const result = await api._fire("before_prompt_build");
 
-    expect(result.appendSystemContext).not.toContain("AUTO-RESUME");
-    expect(result.appendSystemContext).not.toContain("Ensure Cron");
+    expect(result.appendSystemContext).not.toContain("Incomplete Task");
   });
 
-  it("skips AUTO-RESUME when lead-gen state is absent (deleted)", async () => {
+  it("skips incomplete task when lead-gen state is absent", async () => {
     const { registerContextHook } = await import("../src/hooks/context");
     const api = createMockApi();
 
     globalThis.fetch = mockFetchResponses({
       "/api/onboarding/soul": { soul: "<!-- bereach-workspace-v2 -->\nTest\n<!-- /bereach-workspace -->" },
-      "/api/me/credits": { credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: {} },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/lead-gen": { data: null },
-      "/api/agent-state/outreach": { data: null },
-      "/api/chats/linkedin/unread": { unreadCount: 0 },
-      "/api/agent-state/campaigns": { data: null },
-      "/api/agent-state/auto-resume": { data: { taskType: "lead-gen", savedAt: new Date().toISOString(), phase: "search", found: 10, target: 50, stateKey: "lead-gen" } },
-      "registry.npmjs.org": null,
+      ...buildSnapshot({
+        credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 },
+        onboardingState: { completed: true },
+      }),
     }) as any;
 
     registerContextHook(api, "brc_test_key");
     const result = await api._fire("before_prompt_build");
 
-    expect(result.appendSystemContext).not.toContain("AUTO-RESUME");
+    expect(result.appendSystemContext).not.toContain("Incomplete Task");
   });
 
-  it("uses live lead-gen state data for progress display (not stale auto-resume snapshot)", async () => {
+  it("uses live lead-gen state data for progress display", async () => {
     const { registerContextHook } = await import("../src/hooks/context");
     const api = createMockApi();
 
     globalThis.fetch = mockFetchResponses({
       "/api/onboarding/soul": { soul: "<!-- bereach-workspace-v2 -->\nTest\n<!-- /bereach-workspace -->" },
-      "/api/me/credits": { credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: {} },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/lead-gen": { data: { phase: "qualification", totalFound: 55, target: 100 } },
-      "/api/agent-state/outreach": { data: null },
-      "/api/chats/linkedin/unread": { unreadCount: 0 },
-      "/api/agent-state/campaigns": { data: null },
-      "/api/agent-state/auto-resume": { data: { taskType: "lead-gen", savedAt: new Date().toISOString(), phase: "search", found: 30, target: 100, stateKey: "lead-gen" } },
-      "registry.npmjs.org": null,
+      ...buildSnapshot({
+        credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 },
+        leadGenState: { phase: "qualification", totalFound: 55, target: 100 },
+        onboardingState: { completed: true },
+      }),
     }) as any;
 
     registerContextHook(api, "brc_test_key");
     const result = await api._fire("before_prompt_build");
 
-    // Should show live progress (55) not stale auto-resume snapshot (30)
     expect(result.appendSystemContext).toContain("55");
     expect(result.appendSystemContext).toContain("100");
   });
 
-  it("ignores stale auto-resume flag (>24h old)", async () => {
+  it("does not inject incomplete task for completed lead-gen state", async () => {
     const { registerContextHook } = await import("../src/hooks/context");
     const api = createMockApi();
 
-    const staleTime = new Date(Date.now() - 25 * 60 * 60 * 1000).toISOString(); // 25h ago
     globalThis.fetch = mockFetchResponses({
       "/api/onboarding/soul": { soul: "<!-- bereach-workspace-v2 -->\nTest\n<!-- /bereach-workspace -->" },
-      "/api/me/credits": { credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: {} },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/lead-gen": { data: { phase: "search", totalFound: 10, target: 50 } },
-      "/api/agent-state/outreach": { data: null },
-      "/api/chats/linkedin/unread": { unreadCount: 0 },
-      "/api/agent-state/campaigns": { data: null },
-      "/api/agent-state/auto-resume": { data: { taskType: "lead-gen", savedAt: staleTime, phase: "search", found: 10, target: 50, stateKey: "lead-gen" } },
-      "registry.npmjs.org": null,
+      ...buildSnapshot({
+        credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 },
+        leadGenState: { phase: "complete", totalFound: 50, target: 50 },
+        onboardingState: { completed: true },
+      }),
     }) as any;
 
     registerContextHook(api, "brc_test_key");
     const result = await api._fire("before_prompt_build");
 
-    // Stale auto-resume (>24h) should be ignored by cache layer
-    expect(result.appendSystemContext).not.toContain("AUTO-RESUME");
+    expect(result.appendSystemContext).not.toContain("Incomplete Task");
   });
 
   it("does not inject cron setup for one-shot scenarios", async () => {
     const { registerContextHook } = await import("../src/hooks/context");
     const api = createMockApi();
 
-    const now = new Date();
     globalThis.fetch = mockFetchResponses({
       "/api/onboarding/soul": { soul: "<!-- bereach-workspace-v2 -->\nTest\n<!-- /bereach-workspace -->" },
-      "/api/me/credits": { credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: {} },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/lead-gen": { data: null },
-      "/api/agent-state/outreach": { data: null },
-      "/api/chats/linkedin/unread": { unreadCount: 0 },
-      "/api/agent-state/campaigns": { data: null },
-      "registry.npmjs.org": null,
+      ...buildSnapshot({
+        credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 },
+        onboardingState: { completed: true },
+      }),
     }) as any;
 
     registerContextHook(api, "brc_test_key");
     const result = await api._fire("before_prompt_build");
 
-    // Execution modes are shown, but the directive says "Most requests are one-shot"
     expect(result.appendSystemContext).toContain("Most requests are one-shot");
     expect(result.appendSystemContext).toContain("Do not force campaigns on simple tasks");
   });
@@ -1132,106 +860,46 @@ describe("hooks/cache - campaign state", () => {
     cache.clearAll();
   });
 
-  it("fetches and validates campaign state schema", async () => {
-    globalThis.fetch = mockFetchResponses({
-      "/api/me/credits": { credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: {} },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/lead-gen": { data: null },
-      "/api/agent-state/outreach": { data: null },
-      "/api/chats/linkedin/unread": { unreadCount: 3 },
-      "/api/agent-state/campaigns": {
-        data: { schemaVersion: 1, campaigns: [{ id: "test", status: "active" }], updatedAt: "2026-01-01" },
-      },
-    }) as any;
+  it("fetches and returns campaign data from snapshot", async () => {
+    globalThis.fetch = mockFetchResponses(buildSnapshot({
+      credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 },
+      unreadDMs: 3,
+      activeCampaigns: [{ id: "test", name: "Test", type: "lead-gen", status: "active" }],
+    })) as any;
 
-    const data = await cache.fetchAll("brc_test");
-    expect(data.campaignState).not.toBeNull();
-    expect(data.campaignState!.campaigns.length).toBe(1);
+    const data = await cache.fetchSnapshot("brc_test");
+    expect(data.activeCampaigns.length).toBe(1);
+    expect(data.activeCampaigns[0].id).toBe("test");
     expect(data.unreadDMs).toBe(3);
   });
 
-  it("rejects invalid campaign state schema version", async () => {
-    globalThis.fetch = mockFetchResponses({
-      "/api/me/credits": { credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: {} },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/lead-gen": { data: null },
-      "/api/agent-state/outreach": { data: null },
-      "/api/chats/linkedin/unread": { unreadCount: 0 },
-      "/api/agent-state/campaigns": {
-        data: { schemaVersion: 99, campaigns: [], updatedAt: "2026-01-01" },
-      },
-    }) as any;
+  it("returns empty campaigns when none provided in snapshot", async () => {
+    globalThis.fetch = mockFetchResponses(buildSnapshot({
+      credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 },
+    })) as any;
 
-    const data = await cache.fetchAll("brc_test");
-    // Invalid schema triggers auto-repair → returns a clean state instead of null
-    expect(data.campaignState).toEqual({
-      schemaVersion: 1,
-      campaigns: [],
-      updatedAt: expect.any(String),
-    });
+    const data = await cache.fetchSnapshot("brc_test");
+    expect(data.activeCampaigns).toEqual([]);
   });
 
-  it("checks both credits AND limits for cache freshness", async () => {
-    const mockFetch = mockFetchResponses({
-      "/api/me/credits": { credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: {} },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/lead-gen": { data: null },
-      "/api/agent-state/outreach": { data: null },
-      "/api/chats/linkedin/unread": { unreadCount: 0 },
-      "/api/agent-state/campaigns": { data: null },
-    });
+  it("invalidating credits triggers full refetch", async () => {
+    const mockFetch = mockFetchResponses(buildSnapshot({
+      credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 },
+      limits: { multiplier: 1, limits: {} },
+    }));
     globalThis.fetch = mockFetch as any;
 
     await cache.getOrFetch("brc_test");
     const callsAfterFirst = mockFetch.mock.calls.length;
 
-    // Invalidate limits only — should trigger full refetch
-    cache.invalidate("limits");
+    // Invalidate credits — credits is the cache sentinel, triggers refetch
+    cache.invalidate("credits");
     await cache.getOrFetch("brc_test");
     expect(mockFetch.mock.calls.length).toBeGreaterThan(callsAfterFirst);
   });
 });
 
-// ---------------------------------------------------------------------------
-// Context Compat (backward compatibility)
-// ---------------------------------------------------------------------------
-
-describe("hooks/context-compat", () => {
-  it("injectSoulTemplate works with empty existing", async () => {
-    const { injectSoulTemplate } = await import("../src/hooks/context-compat");
-    const result = injectSoulTemplate("", "template content");
-    expect(result).toBe("template content");
-  });
-
-  it("injectSoulTemplate appends when no markers", async () => {
-    const { injectSoulTemplate } = await import("../src/hooks/context-compat");
-    const result = injectSoulTemplate("existing content", "new template");
-    expect(result).toContain("existing content");
-    expect(result).toContain("new template");
-  });
-
-  it("injectSoulTemplate replaces between markers", async () => {
-    const { injectSoulTemplate } = await import("../src/hooks/context-compat");
-    const existing = "before <!-- bereach-workspace-v1 -->\nold\n<!-- /bereach-workspace --> after";
-    const result = injectSoulTemplate(existing, "new template");
-    expect(result).toContain("before ");
-    expect(result).toContain("new template");
-    expect(result).toContain(" after");
-    expect(result).not.toContain("old");
-  });
-});
+// (context-compat module was removed — tests deleted)
 
 // ---------------------------------------------------------------------------
 // TEST-5: checkBusinessHours and applyUserIntervalOverrides
@@ -1294,41 +962,46 @@ describe("hooks/context - checkBusinessHours", () => {
   });
 });
 
-describe("hooks/context - applyUserIntervalOverrides", () => {
+describe("hooks/context - interval overrides via rankCampaigns", () => {
   it("overrides campaign check interval from context entries", async () => {
-    const { _applyUserIntervalOverrides } = await import("../src/hooks/context");
+    const { _rankCampaigns } = await import("../src/hooks/context");
+    const now = Date.now();
     const campaigns = [
-      { id: "c1", type: "lead-magnet" as const, checkIntervalMinutes: 60, name: "test", status: "active" as const, priority: "medium" as const, lastCheckAt: null, createdAt: "2026-01-01", config: {}, progress: {}, stats: {}, lockedUntil: null, errorMessage: null, consecutiveErrors: 0, lastSuccessAt: null },
-      { id: "c2", type: "lead-gen" as const, checkIntervalMinutes: 120, name: "test2", status: "active" as const, priority: "high" as const, lastCheckAt: null, createdAt: "2026-01-01", config: {}, progress: {}, stats: {}, lockedUntil: null, errorMessage: null, consecutiveErrors: 0, lastSuccessAt: null },
+      { id: "c1", type: "lead-magnet", name: "test", status: "active" },
+      { id: "c2", type: "lead-gen", name: "test2", status: "active" },
     ];
+    const checks = {
+      c1: new Date(now - 20 * 60_000).toISOString(),
+      c2: new Date(now - 40 * 60_000).toISOString(),
+    };
     const contexts = [
       { type: "check_interval_lead_magnet", content: "15" },
       { type: "check_interval_lead_gen", content: "30" },
     ];
-    const result = _applyUserIntervalOverrides(campaigns, contexts);
-    expect(result[0].checkIntervalMinutes).toBe(15);
-    expect(result[1].checkIntervalMinutes).toBe(30);
+    const result = _rankCampaigns(campaigns, checks, contexts);
+    expect(result.find((r) => r.campaign.id === "c1")!.interval).toBe(15);
+    expect(result.find((r) => r.campaign.id === "c2")!.interval).toBe(30);
   });
 
-  it("does not override when context is missing", async () => {
-    const { _applyUserIntervalOverrides } = await import("../src/hooks/context");
+  it("uses default interval when context is missing", async () => {
+    const { _rankCampaigns } = await import("../src/hooks/context");
     const campaigns = [
-      { id: "c1", type: "lead-magnet" as const, checkIntervalMinutes: 60, name: "test", status: "active" as const, priority: "medium" as const, lastCheckAt: null, createdAt: "2026-01-01", config: {}, progress: {}, stats: {}, lockedUntil: null, errorMessage: null, consecutiveErrors: 0, lastSuccessAt: null },
+      { id: "c1", type: "lead-magnet", name: "test", status: "active" },
     ];
-    const result = _applyUserIntervalOverrides(campaigns, []);
-    expect(result[0].checkIntervalMinutes).toBe(60);
+    const result = _rankCampaigns(campaigns, {}, []);
+    expect(result[0].interval).toBe(60);
   });
 
-  it("ignores invalid override values", async () => {
-    const { _applyUserIntervalOverrides } = await import("../src/hooks/context");
+  it("ignores invalid override values and falls back to default", async () => {
+    const { _rankCampaigns } = await import("../src/hooks/context");
     const campaigns = [
-      { id: "c1", type: "outreach" as const, checkIntervalMinutes: 60, name: "test", status: "active" as const, priority: "medium" as const, lastCheckAt: null, createdAt: "2026-01-01", config: {}, progress: {}, stats: {}, lockedUntil: null, errorMessage: null, consecutiveErrors: 0, lastSuccessAt: null },
+      { id: "c1", type: "outreach", name: "test", status: "active" },
     ];
     const contexts = [
       { type: "outreach_cadence", content: "not-a-number" },
     ];
-    const result = _applyUserIntervalOverrides(campaigns, contexts);
-    expect(result[0].checkIntervalMinutes).toBe(60);
+    const result = _rankCampaigns(campaigns, {}, contexts);
+    expect(result[0].interval).toBe(60);
   });
 });
 
@@ -1337,11 +1010,16 @@ describe("hooks/context - rankCampaigns", () => {
     const { _rankCampaigns } = await import("../src/hooks/context");
     const now = Date.now();
     const campaigns = [
-      { id: "ok", type: "lead-gen" as const, status: "active" as const, priority: "high" as const, checkIntervalMinutes: 60, lastCheckAt: new Date(now - 10 * 60_000).toISOString(), name: "OK", createdAt: "2026-01-01", config: {}, progress: {}, stats: {}, lockedUntil: null, errorMessage: null, consecutiveErrors: 0, lastSuccessAt: null },
-      { id: "overdue", type: "lead-magnet" as const, status: "active" as const, priority: "low" as const, checkIntervalMinutes: 30, lastCheckAt: new Date(now - 120 * 60_000).toISOString(), name: "Overdue", createdAt: "2026-01-01", config: {}, progress: {}, stats: {}, lockedUntil: null, errorMessage: null, consecutiveErrors: 0, lastSuccessAt: null },
-      { id: "due", type: "outreach" as const, status: "active" as const, priority: "medium" as const, checkIntervalMinutes: 60, lastCheckAt: new Date(now - 65 * 60_000).toISOString(), name: "Due", createdAt: "2026-01-01", config: {}, progress: {}, stats: {}, lockedUntil: null, errorMessage: null, consecutiveErrors: 0, lastSuccessAt: null },
+      { id: "ok", type: "lead-gen", name: "OK", status: "active" },
+      { id: "overdue", type: "lead-magnet", name: "Overdue", status: "active" },
+      { id: "due", type: "outreach", name: "Due", status: "active" },
     ];
-    const ranked = _rankCampaigns(campaigns);
+    const checks = {
+      ok: new Date(now - 10 * 60_000).toISOString(),
+      overdue: new Date(now - 120 * 60_000).toISOString(),
+      due: new Date(now - 65 * 60_000).toISOString(),
+    };
+    const ranked = _rankCampaigns(campaigns, checks, []);
     expect(ranked[0].campaign.id).toBe("overdue");
     expect(ranked[0].status).toBe("OVERDUE");
     expect(ranked[1].campaign.id).toBe("due");
@@ -1350,15 +1028,14 @@ describe("hooks/context - rankCampaigns", () => {
     expect(ranked[2].status).toBe("OK");
   });
 
-  it("filters out non-active campaigns", async () => {
+  it("treats all campaigns as rankable (active filtering is upstream)", async () => {
     const { _rankCampaigns } = await import("../src/hooks/context");
     const campaigns = [
-      { id: "active", type: "lead-gen" as const, status: "active" as const, priority: "medium" as const, checkIntervalMinutes: 60, lastCheckAt: null, name: "Active", createdAt: "2026-01-01", config: {}, progress: {}, stats: {}, lockedUntil: null, errorMessage: null, consecutiveErrors: 0, lastSuccessAt: null },
-      { id: "paused", type: "outreach" as const, status: "paused" as const, priority: "high" as const, checkIntervalMinutes: 30, lastCheckAt: null, name: "Paused", createdAt: "2026-01-01", config: {}, progress: {}, stats: {}, lockedUntil: null, errorMessage: null, consecutiveErrors: 0, lastSuccessAt: null },
+      { id: "active", type: "lead-gen", name: "Active", status: "active" },
+      { id: "paused", type: "outreach", name: "Paused", status: "paused" },
     ];
-    const ranked = _rankCampaigns(campaigns);
-    expect(ranked.length).toBe(1);
-    expect(ranked[0].campaign.id).toBe("active");
+    const ranked = _rankCampaigns(campaigns, {}, []);
+    expect(ranked.length).toBe(2);
   });
 });
 
@@ -1392,11 +1069,9 @@ describe("hooks/enforcement - actionMap coverage", () => {
   });
 });
 
-// ---------------------------------------------------------------------------
-// TEST-4: Lifecycle — engagement persistence and auto-promotion
-// ---------------------------------------------------------------------------
+// (engagementSignals, auto-resume, and auto-pause features were removed from lifecycle hook — tests deleted)
 
-describe("hooks/lifecycle - engagement", () => {
+describe("hooks/lifecycle - session meta", () => {
   const originalFetch = globalThis.fetch;
   let state: SessionState;
 
@@ -1410,350 +1085,65 @@ describe("hooks/lifecycle - engagement", () => {
     cache.clearAll();
   });
 
-  it("persists engagement signals and merges with existing data", async () => {
+  it("does NOT call auto-resume or campaigns endpoints (simplified lifecycle)", async () => {
     const { registerLifecycleHook } = await import("../src/hooks/lifecycle");
     const api = createMockApi();
 
-    const fetchCalls: { url: string; method: string; body: any }[] = [];
+    const fetchCalls: { url: string; method: string }[] = [];
     globalThis.fetch = vi.fn(async (url: string, opts?: any) => {
-      const method = opts?.method ?? "GET";
-      fetchCalls.push({ url, method, body: opts?.body ? JSON.parse(opts.body) : null });
-
-      if (url.includes("engagement-tracking") && method === "GET") {
-        return {
-          ok: true,
-          json: async () => ({ data: { "https://linkedin.com/in/alice": 2 } }),
-          headers: new Headers(),
-        };
-      }
+      fetchCalls.push({ url, method: opts?.method ?? "GET" });
       return { ok: true, json: async () => ({ data: {} }), headers: new Headers() };
     }) as any;
 
-    state.toolCallCount = 5;
-    state.engagementSignals.set("https://linkedin.com/in/alice", 3);
-    state.engagementSignals.set("https://linkedin.com/in/bob", 1);
-
-    registerLifecycleHook(api, "brc_test_key", { engagementThreshold: 100 }, state);
-    await api._fire("agent_end");
-
-    const putCall = fetchCalls.find((c) => c.url.includes("engagement-tracking") && c.method === "PUT");
-    expect(putCall).toBeDefined();
-    expect(putCall!.body.data["https://linkedin.com/in/alice"]).toBe(5);
-    expect(putCall!.body.data["https://linkedin.com/in/bob"]).toBe(1);
-  });
-
-  it("auto-promotes contacts exceeding engagement threshold", async () => {
-    const { registerLifecycleHook } = await import("../src/hooks/lifecycle");
-    const api = createMockApi();
-
-    const fetchCalls: { url: string; method: string; body: any }[] = [];
-    globalThis.fetch = vi.fn(async (url: string, opts?: any) => {
-      const method = opts?.method ?? "GET";
-      fetchCalls.push({ url, method, body: opts?.body ? JSON.parse(opts.body) : null });
-
-      if (url.includes("engagement-tracking") && method === "GET") {
-        return { ok: true, json: async () => ({ data: {} }), headers: new Headers() };
-      }
-      if (url.includes("/api/contacts/by-url")) {
-        return {
-          ok: true,
-          json: async () => ({ contact: { id: "c-123", lifecycleStage: "contact" } }),
-          headers: new Headers(),
-        };
-      }
-      return { ok: true, json: async () => ({ data: {} }), headers: new Headers() };
-    }) as any;
-
-    state.toolCallCount = 3;
-    state.engagementSignals.set("https://linkedin.com/in/alice", 10);
-
-    registerLifecycleHook(api, "brc_test_key", { engagementThreshold: 5 }, state);
+    state.toolCallCount = 10;
+    registerLifecycleHook(api, "brc_test_key", {}, state);
     await api._fire("agent_end");
 
-    const patchCall = fetchCalls.find((c) => c.url.includes("/api/contacts/c-123") && c.method === "PATCH");
-    expect(patchCall).toBeDefined();
-    expect(patchCall!.body.lifecycleStage).toBe("lead");
+    const autoResumeCall = fetchCalls.find((c) => c.url.includes("auto-resume"));
+    expect(autoResumeCall).toBeUndefined();
 
-    const activityCall = fetchCalls.find((c) => c.url.includes("/api/contacts/c-123/activities") && c.method === "POST");
-    expect(activityCall).toBeDefined();
-    expect(activityCall!.body.activities[0].type).toBe("engagement_observed");
+    const campaignsCall = fetchCalls.find((c) => c.url.includes("campaigns"));
+    expect(campaignsCall).toBeUndefined();
   });
+});
 
-  it("does not promote contacts already past 'contact' stage", async () => {
-    const { registerLifecycleHook } = await import("../src/hooks/lifecycle");
-    const api = createMockApi();
-
-    const fetchCalls: { url: string; method: string; body: any }[] = [];
-    globalThis.fetch = vi.fn(async (url: string, opts?: any) => {
-      const method = opts?.method ?? "GET";
-      fetchCalls.push({ url, method, body: opts?.body ? JSON.parse(opts.body) : null });
-
-      if (url.includes("engagement-tracking") && method === "GET") {
-        return { ok: true, json: async () => ({ data: {} }), headers: new Headers() };
-      }
-      if (url.includes("/api/contacts/by-url")) {
-        return {
-          ok: true,
-          json: async () => ({ contact: { id: "c-456", lifecycleStage: "lead" } }),
-          headers: new Headers(),
-        };
-      }
-      return { ok: true, json: async () => ({ data: {} }), headers: new Headers() };
-    }) as any;
-
-    state.toolCallCount = 3;
-    state.engagementSignals.set("https://linkedin.com/in/already-lead", 10);
-
-    registerLifecycleHook(api, "brc_test_key", { engagementThreshold: 5 }, state);
-    await api._fire("agent_end");
+// ---------------------------------------------------------------------------
+// classifyUpgrade
+// ---------------------------------------------------------------------------
 
-    const patchCall = fetchCalls.find((c) => c.url.includes("/api/contacts/c-456") && c.method === "PATCH");
-    expect(patchCall).toBeUndefined();
+describe("classifyUpgrade", () => {
+  it("returns 'none' when versions are equal", () => {
+    expect(classifyUpgrade("1.4.6", "1.4.6")).toBe("none");
   });
 
-  it("sets auto-resume flag when lead-gen state is incomplete", async () => {
-    const { registerLifecycleHook } = await import("../src/hooks/lifecycle");
-    const api = createMockApi();
-
-    const fetchCalls: { url: string; method: string; body: any }[] = [];
-    const baseMock = mockFetchResponses({
-      "/api/agent-state/session-meta": { data: {} },
-      "/api/agent-state/lead-gen": { data: { phase: "qualification", totalFound: 15, target: 100 } },
-      "/api/agent-state/campaigns": { data: { schemaVersion: 1, campaigns: [], updatedAt: "" } },
-      "/api/agent-state/auto-resume": { data: {} },
-      "/api/me/credits": { credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: {} },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/outreach": { data: null },
-      "/api/chats/linkedin/unread": { unreadCount: 0 },
-    });
-
-    globalThis.fetch = vi.fn(async (url: string, opts?: any) => {
-      const method = opts?.method ?? "GET";
-      let body = null;
-      try { body = opts?.body ? JSON.parse(opts.body) : null; } catch {}
-      fetchCalls.push({ url, method, body });
-      return baseMock(url, opts);
-    }) as any;
-
-    state.toolCallCount = 20;
-    state.visitCount = 15;
-    registerLifecycleHook(api, "brc_test_key", {}, state);
-    await api._fire("agent_end");
-
-    const putCall = fetchCalls.find((c) => c.url.includes("auto-resume") && c.method === "PUT");
-    expect(putCall).toBeDefined();
-    expect(putCall!.body.data.taskType).toBe("lead-gen");
-    expect(putCall!.body.data.phase).toBe("qualification");
-    expect(putCall!.body.data.found).toBe(15);
-    expect(putCall!.body.data.target).toBe(100);
-    expect(putCall!.body.data.stateKey).toBe("lead-gen");
+  it("returns 'patch' for patch bump", () => {
+    expect(classifyUpgrade("1.4.6", "1.4.7")).toBe("patch");
   });
 
-  it("does NOT set auto-resume when lead-gen state is complete", async () => {
-    const { registerLifecycleHook } = await import("../src/hooks/lifecycle");
-    const api = createMockApi();
-
-    const fetchCalls: { url: string; method: string; body: any }[] = [];
-    const baseMock = mockFetchResponses({
-      "/api/agent-state/session-meta": { data: {} },
-      "/api/agent-state/lead-gen": { data: { phase: "complete", totalFound: 100, target: 100 } },
-      "/api/agent-state/campaigns": { data: { schemaVersion: 1, campaigns: [], updatedAt: "" } },
-      "/api/me/credits": { credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: {} },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/outreach": { data: null },
-      "/api/chats/linkedin/unread": { unreadCount: 0 },
-    });
-
-    globalThis.fetch = vi.fn(async (url: string, opts?: any) => {
-      const method = opts?.method ?? "GET";
-      let body = null;
-      try { body = opts?.body ? JSON.parse(opts.body) : null; } catch {}
-      fetchCalls.push({ url, method, body });
-      return baseMock(url, opts);
-    }) as any;
-
-    state.toolCallCount = 20;
-    registerLifecycleHook(api, "brc_test_key", {}, state);
-    await api._fire("agent_end");
-
-    const putCall = fetchCalls.find((c) => c.url.includes("auto-resume") && c.method === "PUT");
-    expect(putCall).toBeUndefined();
+  it("returns 'minor' for minor bump", () => {
+    expect(classifyUpgrade("1.4.6", "1.5.0")).toBe("minor");
   });
 
-  it("does NOT set auto-resume when target is met even with active phase", async () => {
-    const { registerLifecycleHook } = await import("../src/hooks/lifecycle");
-    const api = createMockApi();
-
-    const fetchCalls: { url: string; method: string; body: any }[] = [];
-    const baseMock = mockFetchResponses({
-      "/api/agent-state/session-meta": { data: {} },
-      "/api/agent-state/lead-gen": { data: { phase: "qualification", totalFound: 100, target: 50 } },
-      "/api/agent-state/campaigns": { data: { schemaVersion: 1, campaigns: [], updatedAt: "" } },
-      "/api/me/credits": { credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: {} },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/outreach": { data: null },
-      "/api/chats/linkedin/unread": { unreadCount: 0 },
-    });
-
-    globalThis.fetch = vi.fn(async (url: string, opts?: any) => {
-      const method = opts?.method ?? "GET";
-      let body = null;
-      try { body = opts?.body ? JSON.parse(opts.body) : null; } catch {}
-      fetchCalls.push({ url, method, body });
-      return baseMock(url, opts);
-    }) as any;
-
-    state.toolCallCount = 5;
-    registerLifecycleHook(api, "brc_test_key", {}, state);
-    await api._fire("agent_end");
-
-    const putCall = fetchCalls.find((c) => c.url.includes("auto-resume") && c.method === "PUT");
-    expect(putCall).toBeUndefined();
+  it("returns 'major' for major bump", () => {
+    expect(classifyUpgrade("1.4.6", "2.0.0")).toBe("major");
   });
 
-  it("sets auto-resume when state has unmet target but no phase", async () => {
-    const { registerLifecycleHook } = await import("../src/hooks/lifecycle");
-    const api = createMockApi();
-
-    const fetchCalls: { url: string; method: string; body: any }[] = [];
-    const baseMock = mockFetchResponses({
-      "/api/agent-state/session-meta": { data: {} },
-      "/api/agent-state/lead-gen": { data: { totalFound: 30, target: 100 } },
-      "/api/agent-state/campaigns": { data: { schemaVersion: 1, campaigns: [], updatedAt: "" } },
-      "/api/agent-state/auto-resume": { data: {} },
-      "/api/me/credits": { credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: {} },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/outreach": { data: null },
-      "/api/chats/linkedin/unread": { unreadCount: 0 },
-    });
-
-    globalThis.fetch = vi.fn(async (url: string, opts?: any) => {
-      const method = opts?.method ?? "GET";
-      let body = null;
-      try { body = opts?.body ? JSON.parse(opts.body) : null; } catch {}
-      fetchCalls.push({ url, method, body });
-      return baseMock(url, opts);
-    }) as any;
-
-    state.toolCallCount = 10;
-    registerLifecycleHook(api, "brc_test_key", {}, state);
-    await api._fire("agent_end");
-
-    const putCall = fetchCalls.find((c) => c.url.includes("auto-resume") && c.method === "PUT");
-    expect(putCall).toBeDefined();
-    expect(putCall!.body.data.found).toBe(30);
-    expect(putCall!.body.data.target).toBe(100);
+  it("strips prerelease tags before comparing", () => {
+    expect(classifyUpgrade("1.4.6-beta.1", "1.4.7-beta.2")).toBe("patch");
+    expect(classifyUpgrade("1.4.6-beta.1", "1.5.0-beta.1")).toBe("minor");
+    expect(classifyUpgrade("1.4.6-beta.1", "2.0.0")).toBe("major");
   });
 
-  it("does NOT set auto-resume when lead-gen state is null", async () => {
-    const { registerLifecycleHook } = await import("../src/hooks/lifecycle");
-    const api = createMockApi();
-
-    const fetchCalls: { url: string; method: string; body: any }[] = [];
-    const baseMock = mockFetchResponses({
-      "/api/agent-state/session-meta": { data: {} },
-      "/api/agent-state/lead-gen": { data: null },
-      "/api/agent-state/campaigns": { data: { schemaVersion: 1, campaigns: [], updatedAt: "" } },
-      "/api/me/credits": { credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: {} },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/outreach": { data: null },
-      "/api/chats/linkedin/unread": { unreadCount: 0 },
-    });
-
-    globalThis.fetch = vi.fn(async (url: string, opts?: any) => {
-      const method = opts?.method ?? "GET";
-      let body = null;
-      try { body = opts?.body ? JSON.parse(opts.body) : null; } catch {}
-      fetchCalls.push({ url, method, body });
-      return baseMock(url, opts);
-    }) as any;
-
-    state.toolCallCount = 5;
-    registerLifecycleHook(api, "brc_test_key", {}, state);
-    await api._fire("agent_end");
-
-    const putCall = fetchCalls.find((c) => c.url.includes("auto-resume") && c.method === "PUT");
-    expect(putCall).toBeUndefined();
+  it("returns 'none' when latest is older", () => {
+    expect(classifyUpgrade("1.5.0", "1.4.9")).toBe("none");
+    expect(classifyUpgrade("2.0.0", "1.9.9")).toBe("none");
   });
 
-  it("auto-pauses campaigns with consecutive errors >= threshold", async () => {
-    const { registerLifecycleHook } = await import("../src/hooks/lifecycle");
-    const api = createMockApi();
-
-    const campaignData = {
-      schemaVersion: 1,
-      campaigns: [{
-        id: "failing-camp",
-        type: "lead-gen",
-        name: "Failing Campaign",
-        status: "active",
-        priority: "medium",
-        checkIntervalMinutes: 60,
-        lastCheckAt: null,
-        createdAt: "2026-01-01",
-        config: {},
-        progress: {},
-        stats: {},
-        lockedUntil: null,
-        errorMessage: null,
-        consecutiveErrors: 5,
-        lastSuccessAt: null,
-      }],
-      updatedAt: "2026-01-01",
-    };
-
-    const fetchCalls: { url: string; method: string; body: any }[] = [];
-    const baseMock = mockFetchResponses({
-      "/api/me/credits": { credits: { current: 0, limit: 100, remaining: 100, isUnlimited: false, percentage: 0 } },
-      "/api/rate-limits": { multiplier: 1, limits: {} },
-      "/api/contacts/stats": { funnel: {} },
-      "/api/context": { entries: [] },
-      "/api/scheduled-messages": { messages: [], total: 0 },
-      "/api/me/linkedin/accounts": { accounts: [] },
-      "/api/agent-state/lead-gen": { data: null },
-      "/api/agent-state/outreach": { data: null },
-      "/api/chats/linkedin/unread": { unreadCount: 0 },
-      "/api/agent-state/campaigns": { data: campaignData },
-      "/api/agent-state/engagement-tracking": { data: {} },
-      "/api/agent-state/session-meta": { data: {} },
-    });
-
-    globalThis.fetch = vi.fn(async (url: string, opts?: any) => {
-      const method = opts?.method ?? "GET";
-      let body = null;
-      try { body = opts?.body ? JSON.parse(opts.body) : null; } catch {}
-      fetchCalls.push({ url, method, body });
-      return baseMock(url, opts);
-    }) as any;
-
-    state.toolCallCount = 1;
-    registerLifecycleHook(api, "brc_test_key", {}, state);
-    await api._fire("agent_end");
+  it("returns 'major' even when minor/patch are lower", () => {
+    expect(classifyUpgrade("1.9.9", "2.0.0")).toBe("major");
+  });
 
-    const putCall = fetchCalls.find((c) => c.url.includes("/api/agent-state/campaigns") && c.method === "PUT");
-    expect(putCall).toBeDefined();
-    const savedCampaign = putCall!.body.data.campaigns[0];
-    expect(savedCampaign.status).toBe("error");
-    expect(savedCampaign.errorMessage).toContain("Auto-paused");
+  it("returns 'minor' even when patch is lower", () => {
+    expect(classifyUpgrade("1.4.9", "1.5.0")).toBe("minor");
   });
 });