@agent-native/dispatch 0.7.0 → 0.8.0

package/src/server/lib/dreams-store.spec.ts

@@ -0,0 +1,1492 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  getDb: vi.fn(),
+  currentOwnerEmail: vi.fn(() => "owner@example.test"),
+  currentOrgId: vi.fn(() => null),
+  getApprovalPolicy: vi.fn(),
+  createApprovalRequest: vi.fn(),
+  recordAudit: vi.fn(),
+  searchAgentThreads: vi.fn(),
+  getAgentThreadDebug: vi.fn(),
+  listThreadDebugSources: vi.fn(),
+  resourceGetByPath: vi.fn(),
+  resourceList: vi.fn(),
+  resourcePut: vi.fn(),
+  getOrgSetting: vi.fn(),
+  getUserSetting: vi.fn(),
+  putOrgSetting: vi.fn(),
+  putUserSetting: vi.fn(),
+  createWorkspaceResource: vi.fn(),
+  listWorkspaceResources: vi.fn(),
+  updateWorkspaceResource: vi.fn(),
+}));
+
+vi.mock("../../db/index.js", async () => {
+  const schemaModule =
+    await vi.importActual<typeof import("../../db/schema.js")>(
+      "../../db/schema.js",
+    );
+  return {
+    ...schemaModule,
+    schema: schemaModule,
+    getDb: mocks.getDb,
+  };
+});
+
+vi.mock("./dispatch-store.js", () => ({
+  currentOwnerEmail: mocks.currentOwnerEmail,
+  currentOrgId: mocks.currentOrgId,
+  getApprovalPolicy: mocks.getApprovalPolicy,
+  createApprovalRequest: mocks.createApprovalRequest,
+  recordAudit: mocks.recordAudit,
+}));
+
+vi.mock("./thread-debug-store.js", () => ({
+  searchAgentThreads: mocks.searchAgentThreads,
+  getAgentThreadDebug: mocks.getAgentThreadDebug,
+  listThreadDebugSources: mocks.listThreadDebugSources,
+}));
+
+vi.mock("@agent-native/core/resources/store", () => ({
+  SHARED_OWNER: "__shared__",
+  resourceGetByPath: mocks.resourceGetByPath,
+  resourceList: mocks.resourceList,
+  resourcePut: mocks.resourcePut,
+}));
+
+vi.mock("@agent-native/core/settings", () => ({
+  getOrgSetting: mocks.getOrgSetting,
+  getUserSetting: mocks.getUserSetting,
+  putOrgSetting: mocks.putOrgSetting,
+  putUserSetting: mocks.putUserSetting,
+}));
+
+vi.mock("./workspace-resources-store.js", () => ({
+  createWorkspaceResource: mocks.createWorkspaceResource,
+  listWorkspaceResources: mocks.listWorkspaceResources,
+  updateWorkspaceResource: mocks.updateWorkspaceResource,
+}));
+
+import { schema } from "../../db/index.js";
+import {
+  applyApprovedDreamProposal,
+  applyDreamProposal,
+  buildProposalInputs,
+  ensureDreamJob,
+  getDreamSettings,
+  listDreamCandidates,
+  previewDreamProposal,
+  setDreamSettings,
+  type DreamCandidate,
+  type DreamEvidence,
+} from "./dreams-store.js";
+
+function resource(path: string, content: string, owner = "owner@example.test") {
+  return {
+    id: `res-${path}`,
+    owner,
+    path,
+    content,
+    mimeType: "text/markdown",
+    size: Buffer.byteLength(content, "utf8"),
+    createdAt: 1,
+    updatedAt: 2,
+    createdBy: "agent",
+    visibility: "workspace",
+    threadId: null,
+    runId: null,
+    expiresAt: null,
+    metadata: null,
+  };
+}
+
+function resourceWithMime(
+  path: string,
+  content: string,
+  owner = "owner@example.test",
+  mimeType = "text/markdown",
+) {
+  return {
+    ...resource(path, content, owner),
+    mimeType,
+  };
+}
+
+function createDbMock(proposal?: Record<string, unknown>) {
+  let currentProposal = proposal;
+  return {
+    insert: vi.fn(() => ({ values: vi.fn(async () => undefined) })),
+    update: vi.fn((table) => ({
+      set: vi.fn((values) => ({
+        where: vi.fn(async () => {
+          if (table === schema.dispatchDreamProposals && currentProposal) {
+            currentProposal = { ...currentProposal, ...values };
+          }
+        }),
+      })),
+    })),
+    select: vi.fn(() => ({
+      from: vi.fn((table) => ({
+        where: vi.fn(() => ({
+          limit: vi.fn(async () => {
+            if (table === schema.dispatchDreamProposals && currentProposal) {
+              return [currentProposal];
+            }
+            return [];
+          }),
+          orderBy: vi.fn(async () => {
+            if (table === schema.dispatchDreamProposals && currentProposal) {
+              return [currentProposal];
+            }
+            return [];
+          }),
+        })),
+        orderBy: vi.fn(() => ({
+          limit: vi.fn(async () => []),
+        })),
+      })),
+    })),
+  };
+}
+
+function explicitEvidence(
+  overrides: Partial<DreamEvidence> = {},
+): DreamEvidence {
+  return {
+    kind: "explicit-correction",
+    label: "User corrected the agent",
+    snippet:
+      "Actually, remember to use shadcn DropdownMenu for action menus next time",
+    threadId: "thread-1",
+    threadTitle: "Memory correction",
+    messageIndex: 0,
+    createdAt: 1,
+    ...overrides,
+  };
+}
+
+function candidateWithEvidence(
+  evidence: DreamEvidence[],
+  sourceId = "current",
+): DreamCandidate {
+  return {
+    thread: {
+      id: evidence[0]?.threadId ?? "thread-1",
+      ownerEmail: "owner@example.test",
+      title: evidence[0]?.threadTitle ?? "Dream thread",
+      preview: "preview",
+      messageCount: 1,
+      createdAt: 1,
+      updatedAt: 2,
+    },
+    sourceId,
+    score: 50,
+    reasons: [
+      {
+        code: "explicit-correction",
+        label: "User corrections should be considered for memory",
+        score: 25,
+        evidenceCount: evidence.length,
+      },
+    ],
+    evidenceCounts: {},
+    evidence,
+    latestRunStatus: null,
+  };
+}
+
+function pendingProposal(overrides: Record<string, unknown> = {}) {
+  return {
+    id: "proposal-1",
+    dreamId: "dream-1",
+    ownerEmail: "owner@example.test",
+    orgId: null,
+    targetType: "personal-memory",
+    targetPath: "memory/custom.md",
+    title: "Save explicit user corrections",
+    summary: "Remember a user-grounded Dispatch correction.",
+    rationale: "Explicit user corrections are high-signal evidence.",
+    content: "# Dispatch Dream Memory\n\nUse shadcn menus.",
+    evidence: JSON.stringify([explicitEvidence()]),
+    confidence: 80,
+    risk: "low",
+    status: "pending",
+    appliedBy: null,
+    appliedAt: null,
+    rejectedBy: null,
+    rejectedAt: null,
+    createdAt: 1,
+    updatedAt: 1,
+    ...overrides,
+  };
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mocks.currentOwnerEmail.mockReturnValue("owner@example.test");
+  mocks.currentOrgId.mockReturnValue(null);
+  mocks.getApprovalPolicy.mockResolvedValue({
+    enabled: false,
+    approverEmails: [],
+  });
+  mocks.createApprovalRequest.mockResolvedValue({
+    id: "approval-1",
+    status: "pending",
+  });
+  mocks.listThreadDebugSources.mockResolvedValue({
+    access: {
+      viewerEmail: "owner@example.test",
+      orgId: null,
+      role: null,
+      envAdmin: true,
+      canInspectAll: true,
+      memberCount: 1,
+    },
+    sources: [
+      {
+        id: "current",
+        label: "Current Dispatch DB",
+        kind: "current",
+        current: true,
+        connected: true,
+        databaseUrlEnv: "DATABASE_URL",
+        databaseAuthTokenEnv: null,
+        canInspectAll: true,
+      },
+    ],
+  });
+  mocks.recordAudit.mockResolvedValue(undefined);
+  mocks.resourceGetByPath.mockResolvedValue(null);
+  mocks.resourceList.mockResolvedValue([]);
+  mocks.resourcePut.mockImplementation(
+    async (
+      owner: string,
+      path: string,
+      content: string,
+      mimeType = "text/markdown",
+    ) => resourceWithMime(path, content, owner, mimeType),
+  );
+  mocks.getOrgSetting.mockResolvedValue(null);
+  mocks.getUserSetting.mockResolvedValue(null);
+  mocks.putOrgSetting.mockResolvedValue(undefined);
+  mocks.putUserSetting.mockResolvedValue(undefined);
+  mocks.listWorkspaceResources.mockResolvedValue([]);
+  mocks.createWorkspaceResource.mockImplementation(async (input) => ({
+    id: `workspace-${input.path}`,
+    ownerEmail: "owner@example.test",
+    orgId: null,
+    createdBy: "owner@example.test",
+    createdAt: 1,
+    updatedAt: 2,
+    ...input,
+  }));
+  mocks.updateWorkspaceResource.mockImplementation(
+    async (resourceId, input) => ({
+      id: resourceId,
+      ownerEmail: "owner@example.test",
+      orgId: null,
+      kind: "instruction",
+      path: "instructions/existing.md",
+      scope: "all",
+      createdBy: "owner@example.test",
+      createdAt: 1,
+      updatedAt: 2,
+      ...input,
+    }),
+  );
+  mocks.getDb.mockReturnValue(createDbMock());
+});
+
+afterEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("listDreamCandidates", () => {
+  it("scores grounded thread signals and keeps per-thread debug errors isolated", async () => {
+    mocks.searchAgentThreads.mockResolvedValue({
+      source: { id: "current" },
+      access: { mode: "local" },
+      query: null,
+      threads: [{ id: "thread-1" }, { id: "thread-2" }],
+    });
+    mocks.getAgentThreadDebug.mockImplementation(async ({ threadId }) => {
+      if (threadId === "thread-2") {
+        throw new Error("debug unavailable");
+      }
+      return {
+        thread: {
+          id: "thread-1",
+          ownerEmail: "owner@example.test",
+          title: "Memory correction",
+          preview: "remember this",
+          messageCount: 1,
+          createdAt: 1,
+          updatedAt: 2,
+        },
+        messages: [
+          {
+            role: "user",
+            text: "Actually, remember to use shadcn DropdownMenu for action menus next time",
+            index: 0,
+            createdAt: 1,
+          },
+        ],
+        runs: [
+          {
+            id: "run-1",
+            status: "failed",
+            abortReason: null,
+            events: [{ type: "tool", error: "timed out" }],
+          },
+        ],
+        feedback: [],
+        evals: [],
+        satisfaction: [],
+        checkpoints: [],
+      };
+    });
+
+    const result = await listDreamCandidates({ limit: 5 });
+
+    expect(result.candidateCount).toBe(1);
+    expect(result.errors).toEqual([
+      expect.objectContaining({
+        threadId: "thread-2",
+        sourceId: "current",
+        message: "debug unavailable",
+        timedOut: false,
+      }),
+    ]);
+    const candidate = result.candidates[0]!;
+    expect(candidate.evidenceCounts.rememberRequests).toBe(1);
+    expect(candidate.evidenceCounts.explicitCorrections).toBe(1);
+    expect(candidate.evidenceCounts.failedRuns).toBe(1);
+    expect(candidate.evidenceCounts.toolErrors).toBe(1);
+    expect(candidate.reasons.map((entry) => entry.code)).toEqual(
+      expect.arrayContaining([
+        "remember-request",
+        "explicit-correction",
+        "failed-run",
+        "tool-error",
+      ]),
+    );
+  });
+
+  it("keeps all-source scans partial when one source times out", async () => {
+    mocks.listThreadDebugSources.mockResolvedValue({
+      access: {
+        viewerEmail: "owner@example.test",
+        orgId: null,
+        role: null,
+        envAdmin: true,
+        canInspectAll: true,
+        memberCount: 1,
+      },
+      sources: [
+        {
+          id: "voice",
+          label: "Voice",
+          kind: "env",
+          current: false,
+          connected: true,
+          databaseUrlEnv: "VOICE_DATABASE_URL",
+          databaseAuthTokenEnv: null,
+          canInspectAll: true,
+        },
+        {
+          id: "mail",
+          label: "Mail",
+          kind: "env",
+          current: false,
+          connected: true,
+          databaseUrlEnv: "MAIL_DATABASE_URL",
+          databaseAuthTokenEnv: null,
+          canInspectAll: true,
+        },
+      ],
+    });
+    mocks.searchAgentThreads.mockImplementation(async ({ sourceId }) => {
+      if (sourceId === "mail") {
+        await new Promise(() => undefined);
+      }
+      return {
+        source: {
+          id: sourceId,
+          label: sourceId === "voice" ? "Voice" : "Mail",
+        },
+        access: { mode: "local" },
+        query: null,
+        threads: [{ id: "voice-thread-1" }],
+      };
+    });
+    mocks.getAgentThreadDebug.mockResolvedValue({
+      thread: {
+        id: "voice-thread-1",
+        ownerEmail: "owner@example.test",
+        title: "Remember correction",
+        preview: "remember",
+        messageCount: 1,
+        createdAt: 1,
+        updatedAt: 2,
+      },
+      messages: [
+        {
+          role: "user",
+          text: "Remember to keep dream source scans partial.",
+          index: 0,
+          createdAt: 1,
+        },
+      ],
+      runs: [],
+      feedback: [],
+      evals: [],
+      satisfaction: [],
+      checkpoints: [],
+    });
+
+    const result = await listDreamCandidates({
+      sourceId: "all",
+      allSources: true,
+      limit: 5,
+      sourceTimeoutMs: 5,
+      sourceStartStaggerMs: 0,
+    });
+
+    expect(result.source).toMatchObject({ id: "all" });
+    expect(result.candidateCount).toBe(1);
+    expect(result.inspectedThreadCount).toBe(1);
+    expect(result.sources).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          sourceId: "voice",
+          status: "ok",
+          timeoutMs: 5,
+          threadErrorCount: 0,
+          inspectedThreadCount: 1,
+          candidateCount: 1,
+        }),
+        expect.objectContaining({
+          sourceId: "mail",
+          status: "timed_out",
+          timeoutMs: 5,
+          inspectedThreadCount: 0,
+          candidateCount: 0,
+        }),
+      ]),
+    );
+    expect(result.errors).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          sourceId: "mail",
+          message: "Timed out after 5ms",
+        }),
+      ]),
+    );
+  });
+
+  it("keeps source scans partial when one thread debug read times out", async () => {
+    mocks.searchAgentThreads.mockResolvedValue({
+      source: { id: "current", label: "Current Dispatch DB" },
+      access: { mode: "local" },
+      query: null,
+      threads: [{ id: "thread-ok" }, { id: "thread-hangs" }],
+    });
+    mocks.getAgentThreadDebug.mockImplementation(async ({ threadId }) => {
+      if (threadId === "thread-hangs") {
+        await new Promise(() => undefined);
+      }
+      return {
+        thread: {
+          id: "thread-ok",
+          ownerEmail: "owner@example.test",
+          title: "Remember correction",
+          preview: "remember",
+          messageCount: 1,
+          createdAt: 1,
+          updatedAt: 2,
+        },
+        messages: [
+          {
+            role: "user",
+            text: "Remember that source scans should keep partial thread results.",
+            index: 0,
+            createdAt: 1,
+          },
+        ],
+        runs: [],
+        feedback: [],
+        evals: [],
+        satisfaction: [],
+        checkpoints: [],
+      };
+    });
+
+    const result = await listDreamCandidates({
+      limit: 5,
+      sourceTimeoutMs: 50,
+      threadTimeoutMs: 5,
+    });
+
+    expect(result.candidateCount).toBe(1);
+    expect(result.inspectedThreadCount).toBe(2);
+    expect(result.errors).toEqual([
+      expect.objectContaining({
+        threadId: "thread-hangs",
+        sourceId: "current",
+        timedOut: true,
+        message: "Timed out after 5ms",
+      }),
+    ]);
+    expect(result.sources[0]).toEqual(
+      expect.objectContaining({
+        sourceId: "current",
+        status: "ok",
+        inspectedThreadCount: 2,
+        candidateCount: 1,
+        threadErrorCount: 1,
+      }),
+    );
+  });
+
+  it("does not treat feature wording or successful eval metadata as dream failures", async () => {
+    mocks.searchAgentThreads.mockResolvedValue({
+      source: { id: "current" },
+      access: { mode: "local" },
+      query: null,
+      threads: [{ id: "thread-1" }],
+    });
+    mocks.getAgentThreadDebug.mockResolvedValue({
+      thread: {
+        id: "thread-1",
+        ownerEmail: "owner@example.test",
+        title: "Create an extension",
+        preview: "image instead of camera",
+        messageCount: 1,
+        createdAt: 1,
+        updatedAt: 2,
+      },
+      messages: [
+        {
+          role: "user",
+          text: "Create an extension to add image instead of camera when recording",
+          index: 0,
+          createdAt: 1,
+        },
+      ],
+      runs: [
+        {
+          id: "run-1",
+          status: "completed",
+          abortReason: null,
+          events: [
+            {
+              event: {
+                type: "tool_done",
+                tool: "db-query",
+                result:
+                  "query: select status, failure_reason from transcripts\nrows: 1\nstatus | failure_reason\nfailed | no native transcript",
+              },
+            },
+          ],
+        },
+      ],
+      feedback: [],
+      evals: [
+        {
+          eval_type: "automated",
+          criteria: "tool_success_rate",
+          score: 1,
+          metadata: JSON.stringify({ failedTools: 0, successfulTools: 1 }),
+        },
+      ],
+      satisfaction: [],
+      checkpoints: [],
+    });
+
+    const result = await listDreamCandidates({ limit: 5 });
+
+    expect(result.candidateCount).toBe(0);
+  });
+
+  it("ignores injected context when detecting user corrections", async () => {
+    mocks.searchAgentThreads.mockResolvedValue({
+      source: { id: "videos" },
+      access: { mode: "local" },
+      query: null,
+      threads: [{ id: "thread-context" }],
+    });
+    mocks.getAgentThreadDebug.mockResolvedValue({
+      thread: {
+        id: "thread-context",
+        ownerEmail: "owner@example.test",
+        title: "einstein shaking head",
+        preview: "composition request",
+        messageCount: 1,
+        createdAt: 1,
+        updatedAt: 2,
+      },
+      messages: [
+        {
+          role: "user",
+          text: "einstein shaking head\n\n<context>\nUse the Videos app flow. Do not route this as source-code generation.</context>",
+          index: 0,
+          createdAt: 1,
+        },
+      ],
+      runs: [],
+      feedback: [],
+      evals: [],
+      satisfaction: [],
+      checkpoints: [],
+    });
+
+    const result = await listDreamCandidates({
+      sourceId: "videos",
+      limit: 5,
+    });
+
+    expect(result.candidateCount).toBe(0);
+  });
+});
+
+describe("buildProposalInputs", () => {
+  it("skips personal memory proposals whose source evidence is already captured", () => {
+    const result = buildProposalInputs(
+      [candidateWithEvidence([explicitEvidence()])],
+      {
+        personalIndex: "# Memory Index\n",
+        personalNotes: [
+          {
+            path: "memory/ui.md",
+            content:
+              "Use shadcn DropdownMenu for action menus.\n\nSource thread: thread-1",
+          },
+        ],
+        sharedLearnings: "",
+      },
+    );
+
+    expect(result.proposals).toEqual([]);
+    expect(result.guardrailNotes.join("\n")).toContain("Skipped duplicate");
+  });
+
+  it("uses the personal memory index as part of duplicate detection", () => {
+    const result = buildProposalInputs(
+      [candidateWithEvidence([explicitEvidence()])],
+      {
+        personalIndex:
+          "# Memory Index\n\n- [ui](ui.md) — Source thread: thread-1\n",
+        personalNotes: [],
+        sharedLearnings: "",
+      },
+    );
+
+    expect(result.proposals).toEqual([]);
+    expect(result.guardrailNotes.join("\n")).toContain("Skipped duplicate");
+  });
+
+  it("retargets likely stale personal memories instead of creating parallel notes", () => {
+    const result = buildProposalInputs(
+      [candidateWithEvidence([explicitEvidence()])],
+      {
+        personalIndex: "# Memory Index\n",
+        personalNotes: [
+          {
+            path: "memory/ui-patterns.md",
+            content: "Use shadcn DropdownMenu for action menus.",
+          },
+        ],
+        sharedLearnings: "",
+      },
+    );
+
+    expect(result.proposals).toHaveLength(1);
+    expect(result.proposals[0]).toMatchObject({
+      targetType: "personal-memory",
+      targetPath: "memory/ui-patterns.md",
+      title: "Update existing memory from recent corrections",
+    });
+    expect(result.guardrailNotes.join("\n")).toContain("Retargeted proposal");
+  });
+
+  it("skips shared learning proposals already captured in LEARNINGS.md", () => {
+    const failureEvidence: DreamEvidence[] = [
+      {
+        kind: "failed-run",
+        label: "Run failed or aborted",
+        snippet: "tool timed out while syncing workspace resources",
+        threadId: "thread-a",
+        threadTitle: "Sync A",
+      },
+      {
+        kind: "tool-error",
+        label: "Tool call reported an error",
+        snippet: "tool timed out while syncing workspace resources",
+        threadId: "thread-b",
+        threadTitle: "Sync B",
+      },
+    ];
+
+    const result = buildProposalInputs(
+      [
+        candidateWithEvidence([failureEvidence[0]!]),
+        candidateWithEvidence([failureEvidence[1]!]),
+      ],
+      {
+        personalIndex: "",
+        personalNotes: [],
+        sharedLearnings:
+          "# Learnings\n\n## Patterns\n\nSource threads: thread-a, thread-b\n",
+      },
+    );
+
+    expect(result.proposals).toEqual([]);
+    expect(result.guardrailNotes.join("\n")).toContain("Skipped duplicate");
+  });
+
+  it("routes personal-memory proposals to shared learnings when the owner scope is not personal", () => {
+    const result = buildProposalInputs(
+      [
+        candidateWithEvidence([explicitEvidence({ threadId: "thread-1" })]),
+        candidateWithEvidence(
+          [
+            explicitEvidence({
+              threadId: "thread-2",
+              snippet: "Remember to keep dream proposals reviewable",
+            }),
+          ],
+          "mail",
+        ),
+      ],
+      {
+        personalIndex: "# Memory Index\n",
+        personalNotes: [],
+        sharedLearnings: "",
+      },
+      {
+        personalMemoryAllowed: false,
+        personalMemoryBlockReason:
+          "source evidence includes a thread owned by another user",
+      },
+    );
+
+    expect(result.proposals).toHaveLength(1);
+    expect(result.proposals[0]).toMatchObject({
+      targetType: "shared-learnings",
+      targetPath: "LEARNINGS.md",
+      risk: "medium",
+    });
+    expect(result.proposals[0]?.content).toContain(
+      "Provenance: Personal memory was disabled",
+    );
+    expect(result.guardrailNotes.join("\n")).toContain(
+      "Routed personal-memory dream proposals to shared learnings",
+    );
+  });
+
+  it("proposes workspace instructions from repeated corrections", () => {
+    const result = buildProposalInputs(
+      [
+        candidateWithEvidence([
+          explicitEvidence({
+            threadId: "thread-1",
+            snippet: "Actually use actions first",
+          }),
+        ]),
+        candidateWithEvidence([
+          explicitEvidence({
+            threadId: "thread-2",
+            snippet:
+              "Remember to use workspace resources for shared instructions",
+          }),
+          explicitEvidence({
+            threadId: "thread-2",
+            snippet: "From now on, keep dream proposals reviewable",
+          }),
+        ]),
+      ],
+      {
+        personalIndex: "",
+        personalNotes: [],
+        sharedLearnings: "",
+      },
+    );
+
+    expect(result.proposals).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          targetType: "workspace-instruction",
+          targetPath: expect.stringMatching(
+            /^instructions\/dream-corrections-/,
+          ),
+          risk: "medium",
+        }),
+      ]),
+    );
+  });
+
+  it("deduplicates repeated evidence and keeps single-app UI wording out of global instructions", () => {
+    const repeatedCorrection = explicitEvidence({
+      threadId: "thread-clips",
+      threadTitle: "Clips export copy",
+      snippet: "Actually the Clips UI button label should say Export",
+      sourceId: "clips",
+    });
+    const result = buildProposalInputs(
+      [
+        candidateWithEvidence(
+          [
+            repeatedCorrection,
+            {
+              ...repeatedCorrection,
+              messageIndex: 1,
+            },
+          ],
+          "clips",
+        ),
+        candidateWithEvidence(
+          [
+            explicitEvidence({
+              threadId: "thread-clips-2",
+              threadTitle: "Clips export wording",
+              snippet:
+                "Remember the Clips button wording should use Export in this screen",
+              sourceId: "clips",
+            }),
+          ],
+          "clips",
+        ),
+      ],
+      {
+        personalIndex: "",
+        personalNotes: [],
+        sharedLearnings: "",
+      },
+      {
+        personalMemoryAllowed: false,
+        personalMemoryBlockReason: "admin scan spans shared production data",
+      },
+    );
+
+    const shared = result.proposals.find(
+      (proposal) => proposal.targetType === "shared-learnings",
+    );
+
+    expect(shared?.evidence).toHaveLength(2);
+    expect(
+      shared?.content.match(/Actually the Clips UI button label/g),
+    ).toHaveLength(1);
+    expect(
+      result.proposals.some(
+        (proposal) => proposal.targetType === "workspace-instruction",
+      ),
+    ).toBe(false);
+  });
+
+  it("summarizes raw eval failure rows before writing proposal content", () => {
+    const result = buildProposalInputs(
+      [
+        candidateWithEvidence(
+          [
+            {
+              kind: "failed-run",
+              label: "Run failed or aborted",
+              snippet: "failed: Notion import exceeded retry budget",
+              threadId: "thread-a",
+              threadTitle: "Slow dream run A",
+              runId: "run-a",
+            },
+            {
+              kind: "eval-failure",
+              label: "Evaluation failed or scored low",
+              snippet: {
+                name: "latency_score",
+                score: 0,
+                passed: false,
+                run_id: "run-a",
+                metadata: JSON.stringify({
+                  actualMs: 61_250,
+                  expectedMs: 30_000,
+                }),
+              } as any,
+              threadId: "thread-a",
+              threadTitle: "Slow dream run A",
+              runId: "run-a",
+            },
+          ],
+          "dispatch-prod",
+        ),
+        candidateWithEvidence(
+          [
+            {
+              kind: "failed-run",
+              label: "Run failed or aborted",
+              snippet: "failed: Notion import exceeded retry budget",
+              threadId: "thread-b",
+              threadTitle: "Slow dream run B",
+              runId: "run-b",
+            },
+            {
+              kind: "eval-failure",
+              label: "Evaluation failed or scored low",
+              snippet: {
+                name: "latency_score",
+                score: 0.2,
+                passed: false,
+                run_id: "run-b",
+                metadata: JSON.stringify({
+                  actualMs: 44_000,
+                  expectedMs: 30_000,
+                }),
+              } as any,
+              threadId: "thread-b",
+              threadTitle: "Slow dream run B",
+              runId: "run-b",
+            },
+          ],
+          "analytics-prod",
+        ),
+      ],
+      {
+        personalIndex: "",
+        personalNotes: [],
+        sharedLearnings: "",
+      },
+    );
+
+    const content = result.proposals
+      .map((proposal) => proposal.content)
+      .join("\n");
+
+    expect(content).toContain("latency score failed");
+    expect(content).toContain("actual 61250ms, expected 30000ms");
+    expect(content).not.toContain('"metadata"');
+    expect(content).not.toContain('"run_id"');
+    expect(content).not.toContain("{");
+  });
+
+  it("does not create durable proposals from eval-only or account setup failures", () => {
+    const result = buildProposalInputs(
+      [
+        candidateWithEvidence(
+          [
+            {
+              kind: "eval-failure",
+              label: "Evaluation failed or scored low",
+              snippet: {
+                name: "cost_efficiency",
+                score: 0,
+                passed: false,
+                metadata: JSON.stringify({
+                  actualCx100: 4160,
+                  expectedCx100: 300,
+                }),
+              } as any,
+              threadId: "thread-a",
+              threadTitle: "Costly run",
+            },
+            {
+              kind: "tool-error",
+              label: "Tool call reported an error",
+              snippet:
+                "Tool error (credits-limit-daily): You've reached the daily AI credits limit for your current plan.",
+              threadId: "thread-a",
+              threadTitle: "Costly run",
+            },
+          ],
+          "mail",
+        ),
+        candidateWithEvidence(
+          [
+            {
+              kind: "eval-failure",
+              label: "Evaluation failed or scored low",
+              snippet: {
+                name: "latency_score",
+                score: 0,
+                passed: false,
+                metadata: JSON.stringify({
+                  actual_ms: 61_250,
+                  expected_ms: 30_000,
+                }),
+              } as any,
+              threadId: "thread-b",
+              threadTitle: "Slow run",
+            },
+            {
+              kind: "tool-error",
+              label: "Tool call reported an error",
+              snippet:
+                "Tool error (missing_credentials): No LLM provider is connected.",
+              threadId: "thread-b",
+              threadTitle: "Slow run",
+            },
+          ],
+          "content",
+        ),
+      ],
+      {
+        personalIndex: "",
+        personalNotes: [],
+        sharedLearnings: "",
+      },
+    );
+
+    expect(result.proposals).toEqual([]);
+    expect(result.guardrailNotes.join("\n")).toContain(
+      "Skipped failure proposals because the signals were eval-only noise",
+    );
+  });
+
+  it("explains why admin-visible one-off corrections produce no proposal", () => {
+    const result = buildProposalInputs(
+      [
+        candidateWithEvidence(
+          [
+            explicitEvidence({
+              threadId: "thread-forms",
+              threadTitle: "Recording answer",
+              snippet:
+                "Actually this Forms screen should say record instead of upload",
+              sourceId: "forms",
+            }),
+          ],
+          "forms",
+        ),
+      ],
+      {
+        personalIndex: "",
+        personalNotes: [],
+        sharedLearnings: "",
+      },
+      {
+        personalMemoryAllowed: false,
+        personalMemoryBlockReason:
+          "source evidence includes a thread owned by another user",
+      },
+    );
+
+    expect(result.proposals).toEqual([]);
+    const notes = result.guardrailNotes.join("\n");
+    expect(notes).toContain(
+      "Skipped explicit user-correction proposals because personal memory is blocked",
+    );
+    expect(notes).toContain(
+      "Skipped workspace-instruction promotion for explicit corrections",
+    );
+  });
+
+  it("requires workspace instruction evidence to span threads or source apps", () => {
+    const sameThreadFailures: DreamEvidence[] = [
+      {
+        kind: "failed-run",
+        label: "Run failed or aborted",
+        snippet: "failed: resource sync wrote an invalid workspace resource",
+        threadId: "thread-a",
+        threadTitle: "Production timeout",
+        sourceId: "dispatch-prod",
+      },
+      {
+        kind: "tool-error",
+        label: "Tool call reported an error",
+        snippet:
+          "Tool error (schema-mismatch): resource grant failed validation",
+        threadId: "thread-a",
+        threadTitle: "Production timeout",
+        sourceId: "dispatch-prod",
+      },
+      {
+        kind: "eval-failure",
+        label: "Evaluation failed or scored low",
+        snippet: "latency score failed; score 0",
+        threadId: "thread-a",
+        threadTitle: "Production timeout",
+        sourceId: "dispatch-prod",
+      },
+      {
+        kind: "frustration",
+        label: "User expressed friction or repeated failure",
+        snippet: "This keeps failing again",
+        threadId: "thread-a",
+        threadTitle: "Production timeout",
+        sourceId: "dispatch-prod",
+      },
+      {
+        kind: "negative-feedback",
+        label: "Negative feedback was recorded",
+        snippet: "User said the workspace sync fix did not work",
+        threadId: "thread-a",
+        threadTitle: "Production timeout",
+        sourceId: "dispatch-prod",
+      },
+    ];
+
+    const singleSource = buildProposalInputs(
+      [candidateWithEvidence(sameThreadFailures, "dispatch-prod")],
+      {
+        personalIndex: "",
+        personalNotes: [],
+        sharedLearnings: "",
+      },
+    );
+
+    expect(
+      singleSource.proposals.some(
+        (proposal) => proposal.targetType === "workspace-instruction",
+      ),
+    ).toBe(false);
+
+    const crossSource = buildProposalInputs(
+      [
+        candidateWithEvidence(sameThreadFailures.slice(0, 2), "dispatch-prod"),
+        candidateWithEvidence(
+          sameThreadFailures.slice(2).map((entry) => ({
+            ...entry,
+            sourceId: "analytics-prod",
+          })),
+          "analytics-prod",
+        ),
+      ],
+      {
+        personalIndex: "",
+        personalNotes: [],
+        sharedLearnings: "",
+      },
+    );
+
+    expect(crossSource.proposals).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          targetType: "workspace-instruction",
+          targetPath: expect.stringMatching(
+            /^instructions\/dream-run-reliability-/,
+          ),
+        }),
+      ]),
+    );
+  });
+});
+
+describe("applyDreamProposal", () => {
+  it("previews workspace proposal target content and approval behavior", async () => {
+    mocks.getApprovalPolicy.mockResolvedValue({
+      enabled: true,
+      approverEmails: ["admin@example.test"],
+    });
+    mocks.getDb.mockReturnValue(
+      createDbMock(
+        pendingProposal({
+          targetType: "workspace-instruction",
+          targetPath: "instructions/dream-corrections.md",
+          title: "Create workspace instruction from repeated corrections",
+          summary:
+            "Repeated corrections should become a workspace instruction.",
+          content: "# Proposed instruction\n\nUse reviewed guidance.",
+        }),
+      ),
+    );
+    mocks.listWorkspaceResources.mockResolvedValue([
+      {
+        id: "workspace-existing",
+        ownerEmail: "owner@example.test",
+        orgId: null,
+        kind: "instruction",
+        name: "Existing instruction",
+        description: "Existing",
+        path: "instructions/dream-corrections.md",
+        content: "# Existing instruction\n",
+        scope: "all",
+        createdBy: "owner@example.test",
+        createdAt: 1,
+        updatedAt: 2,
+      },
+    ]);
+
+    const preview = await previewDreamProposal("proposal-1");
+
+    expect(preview).toMatchObject({
+      operation: "update",
+      targetExists: true,
+      currentContent: "# Existing instruction\n",
+      proposedContent: expect.stringContaining("Proposed instruction"),
+      target: {
+        kind: "instruction",
+        resourceId: "workspace-existing",
+        path: "instructions/dream-corrections.md",
+      },
+      approval: {
+        required: true,
+        policyEnabled: true,
+        willRequestApproval: true,
+      },
+    });
+  });
+
+  it("writes personal memory and updates the memory index before auditing", async () => {
+    mocks.getDb.mockReturnValue(createDbMock(pendingProposal()));
+    mocks.resourceGetByPath.mockImplementation(async (_owner, path) => {
+      if (path === "memory/MEMORY.md") {
+        return resource("memory/MEMORY.md", "# Memory Index\n");
+      }
+      return null;
+    });
+
+    const result = await applyDreamProposal("proposal-1");
+
+    expect(mocks.resourcePut).toHaveBeenCalledWith(
+      "owner@example.test",
+      "memory/custom.md",
+      expect.stringContaining("## Provenance"),
+      "text/markdown",
+      expect.objectContaining({
+        createdBy: "agent",
+        metadata: { dreamId: "dream-1", proposalId: "proposal-1" },
+      }),
+    );
+    expect(mocks.resourcePut).toHaveBeenCalledWith(
+      "owner@example.test",
+      "memory/MEMORY.md",
+      expect.stringContaining("[custom](custom.md)"),
+      "text/markdown",
+      expect.any(Object),
+    );
+    expect(result.proposal.status).toBe("applied");
+    expect(mocks.recordAudit).toHaveBeenCalledWith(
+      expect.objectContaining({
+        action: "dream.proposal.applied",
+        targetId: "proposal-1",
+      }),
+    );
+  });
+
+  it("rejects personal memory proposals owned by another user", async () => {
+    mocks.getDb.mockReturnValue(
+      createDbMock(pendingProposal({ ownerEmail: "other@example.test" })),
+    );
+
+    await expect(applyDreamProposal("proposal-1")).rejects.toThrow(
+      "Personal memory proposals can only be applied by owner",
+    );
+    expect(mocks.resourcePut).not.toHaveBeenCalled();
+  });
+
+  it("queues shared proposals for approval when approval policy is enabled", async () => {
+    mocks.getApprovalPolicy.mockResolvedValue({
+      enabled: true,
+      approverEmails: ["admin@example.test"],
+    });
+    mocks.getDb.mockReturnValue(
+      createDbMock(
+        pendingProposal({
+          targetType: "shared-learnings",
+          targetPath: "LEARNINGS.md",
+        }),
+      ),
+    );
+
+    const result = await applyDreamProposal("proposal-1");
+
+    expect(mocks.createApprovalRequest).toHaveBeenCalledWith(
+      expect.objectContaining({
+        changeType: "dream-proposal.apply",
+        targetType: "dream-proposal",
+        targetId: "proposal-1",
+        payload: { proposalId: "proposal-1" },
+      }),
+    );
+    expect(mocks.resourcePut).not.toHaveBeenCalled();
+    expect(result.proposal.status).toBe("approval_requested");
+    expect(result.result).toEqual({
+      approvalRequired: true,
+      approvalId: "approval-1",
+    });
+  });
+
+  it("applies approved shared proposals to LEARNINGS.md", async () => {
+    mocks.getDb.mockReturnValue(
+      createDbMock(
+        pendingProposal({
+          status: "approval_requested",
+          targetType: "shared-learnings",
+          targetPath: "LEARNINGS.md",
+          summary: "Record a repeated Dispatch failure pattern.",
+        }),
+      ),
+    );
+    mocks.resourceGetByPath.mockResolvedValue(
+      resource("LEARNINGS.md", "# Learnings\n\n## Patterns\n", "__shared__"),
+    );
+
+    const result = await applyApprovedDreamProposal(
+      "proposal-1",
+      "admin@example.test",
+      { ownerEmail: "owner@example.test", orgId: null },
+    );
+
+    expect(mocks.resourcePut).toHaveBeenCalledWith(
+      "__shared__",
+      "LEARNINGS.md",
+      expect.stringContaining("Record a repeated Dispatch failure pattern."),
+      "text/markdown",
+      expect.objectContaining({
+        createdBy: "agent",
+        metadata: { dreamId: "dream-1", proposalId: "proposal-1" },
+      }),
+    );
+    expect(result.proposal.status).toBe("applied");
+    expect(mocks.recordAudit).toHaveBeenCalledWith(
+      expect.objectContaining({
+        action: "dream.proposal.applied",
+        actor: "admin@example.test",
+      }),
+    );
+  });
+
+  it("creates all-scope workspace resources for approved workspace proposals", async () => {
+    mocks.getDb.mockReturnValue(
+      createDbMock(
+        pendingProposal({
+          status: "approval_requested",
+          targetType: "workspace-instruction",
+          targetPath: "instructions/dream-corrections.md",
+          title: "Create workspace instruction from repeated corrections",
+          summary:
+            "Repeated corrections should become a workspace instruction.",
+          content: "# Dream instruction\n\nUse reviewed workspace guidance.",
+        }),
+      ),
+    );
+
+    const result = await applyApprovedDreamProposal(
+      "proposal-1",
+      "admin@example.test",
+      { ownerEmail: "owner@example.test", orgId: null },
+    );
+
+    expect(mocks.createWorkspaceResource).toHaveBeenCalledWith(
+      expect.objectContaining({
+        kind: "instruction",
+        path: "instructions/dream-corrections.md",
+        scope: "all",
+        content: expect.stringContaining("Dream instruction"),
+      }),
+    );
+    expect(result.proposal.status).toBe("applied");
+    expect(mocks.recordAudit).toHaveBeenCalledWith(
+      expect.objectContaining({
+        action: "dream.proposal.applied",
+        actor: "admin@example.test",
+      }),
+    );
+  });
+});
+
+describe("ensureDreamJob", () => {
+  it("materializes the recurring dream job with schedule metadata", async () => {
+    const result = await ensureDreamJob({
+      schedule: "0 10 * * 2",
+      sourceId: "current",
+      query: "memory",
+      limit: 12,
+    });
+
+    expect(mocks.resourcePut).toHaveBeenCalledWith(
+      "owner@example.test",
+      "jobs/dispatch-dream.md",
+      expect.stringContaining('schedule: "0 10 * * 2"'),
+      "text/markdown",
+      expect.objectContaining({
+        createdBy: "agent",
+        metadata: expect.objectContaining({
+          sourceId: "current",
+          query: "memory",
+          limit: 12,
+          sourceTimeoutMs: 30000,
+        }),
+      }),
+    );
+    expect(result).toMatchObject({
+      path: "jobs/dispatch-dream.md",
+      schedule: "0 10 * * 2",
+      runAs: "creator",
+      sourceId: "current",
+      query: "memory",
+      limit: 12,
+    });
+  });
+
+  it("rejects invalid cron before writing the job resource", async () => {
+    await expect(ensureDreamJob({ schedule: "weekly please" })).rejects.toThrow(
+      "Invalid cron expression",
+    );
+    expect(mocks.resourcePut).not.toHaveBeenCalled();
+  });
+
+  it("persists recurring dream settings", async () => {
+    mocks.getUserSetting.mockResolvedValueOnce(null).mockResolvedValueOnce({
+      enabled: true,
+      schedule: "0 8 * * 1",
+      sourceId: "all",
+      allSources: true,
+      limit: 9,
+      sourceTimeoutMs: 45000,
+      minCandidateCount: 3,
+    });
+
+    const result = await setDreamSettings({
+      enabled: true,
+      schedule: "0 8 * * 1",
+      sourceId: "all",
+      allSources: true,
+      limit: 9,
+      sourceTimeoutMs: 45000,
+      minCandidateCount: 3,
+    });
+
+    expect(mocks.putUserSetting).toHaveBeenCalledWith(
+      "owner@example.test",
+      "dispatch-dream-settings",
+      expect.objectContaining({
+        enabled: true,
+        schedule: "0 8 * * 1",
+        sourceId: "all",
+        allSources: true,
+        limit: 9,
+        sourceTimeoutMs: 45000,
+        minCandidateCount: 3,
+      }),
+    );
+    expect(result).toMatchObject({
+      enabled: true,
+      schedule: "0 8 * * 1",
+      sourceId: "all",
+      allSources: true,
+      limit: 9,
+      sourceTimeoutMs: 45000,
+      minCandidateCount: 3,
+    });
+  });
+
+  it("reads persisted recurring dream settings", async () => {
+    mocks.getUserSetting.mockResolvedValue({
+      enabled: true,
+      schedule: "0 8 * * 1",
+      sourceId: "voice",
+      allSources: false,
+      limit: 7,
+      sourceTimeoutMs: 20000,
+      minCandidateCount: 2,
+    });
+
+    await expect(getDreamSettings()).resolves.toMatchObject({
+      enabled: true,
+      schedule: "0 8 * * 1",
+      sourceId: "voice",
+      allSources: false,
+      limit: 7,
+      sourceTimeoutMs: 20000,
+      minCandidateCount: 2,
+    });
+  });
+});