@@ -2,9 +2,12 @@ import { parseWithZod } from "@conform-to/zod/v4";
 import { type ActionFunctionArgs, json } from "@remix-run/server-runtime";
 import { uiComponent } from "@team-plain/ui-components";
 import { z } from "zod";
+import { $replica, prisma } from "~/db.server";
 import { redirectWithSuccessMessage } from "~/models/message.server";
+import { logger } from "~/services/logger.server";
 import { requireUser } from "~/services/session.server";
 import { sanitizeRedirectPath } from "~/utils";
+import { feedbackOrganization } from "~/utils/feedbackOrganization.server";
 import { sendToPlain } from "~/utils/plain.server";
 
 export const feedbackTypes = {
@@ -80,12 +83,24 @@ export async function action({ request }: ActionFunctionArgs) {
   const inquiry = feedbackTypes[submission.value.feedbackType as FeedbackType];
   const redirectPath = sanitizeRedirectPath(submission.value.path);
   try {
+    // Best-effort: a failed lookup sends the message without an org rather than losing it.
+    const organization = await feedbackOrganization(
+      user.id,
+      submission.value.path,
+      $replica,
+      prisma
+    ).catch((error) => {
+      logger.error("Failed to resolve feedback organization", { error });
+      return undefined;
+    });
     await sendToPlain({
       userId: user.id,
       email: user.email,
       name: user.name ?? user.displayName ?? user.email,
       title: inquiry.threadTitle,
       labelTypeIds: inquiry.labelTypeId ? [inquiry.labelTypeId] : undefined,
+      organizationId: organization?.id,
+      organizationName: organization?.title,
       components: [
         uiComponent.text({
           text: `New ${inquiry.label} reported by ${user.name} (${user.email})`,
 
@@ -0,0 +1,93 @@
+import { postgresTest } from "@internal/testcontainers";
+import type { PrismaClient } from "@trigger.dev/database";
+import { describe, expect } from "vitest";
+import { feedbackOrganization } from "./feedbackOrganization.server";
+
+async function createUser(prisma: PrismaClient, name: string) {
+  return prisma.user.create({
+    data: { email: `${name}@example.com`, authenticationMethod: "MAGIC_LINK" },
+  });
+}
+
+async function createOrg(prisma: PrismaClient, slug: string, memberIds: string[]) {
+  return prisma.organization.create({
+    data: {
+      title: `Org ${slug}`,
+      slug,
+      members: { create: memberIds.map((userId) => ({ userId })) },
+    },
+  });
+}
+
+describe("feedbackOrganization", () => {
+  postgresTest("uses the org page the message was sent from", async ({ prisma }) => {
+    const user = await createUser(prisma, "multi");
+    const a = await createOrg(prisma, "org-a", [user.id]);
+    await createOrg(prisma, "org-b", [user.id]);
+
+    const org = await feedbackOrganization(
+      user.id,
+      "/orgs/org-a/projects/p/env/dev/runs",
+      prisma,
+      prisma
+    );
+    expect(org).toEqual({ id: a.id, title: a.title });
+  });
+
+  postgresTest("never resolves an org the user isn't a member of", async ({ prisma }) => {
+    const user = await createUser(prisma, "member");
+    const other = await createUser(prisma, "other");
+    await createOrg(prisma, "mine", [user.id]);
+    await createOrg(prisma, "theirs", [other.id]);
+
+    expect(await feedbackOrganization(user.id, "/orgs/theirs", prisma, prisma)).toBeUndefined();
+  });
+
+  postgresTest("falls back to the user's only org outside an org page", async ({ prisma }) => {
+    const user = await createUser(prisma, "single");
+    const only = await createOrg(prisma, "only", [user.id]);
+
+    expect(await feedbackOrganization(user.id, "/account", prisma, prisma)).toEqual({
+      id: only.id,
+      title: only.title,
+    });
+  });
+
+  postgresTest("leaves it unattributed when the org is ambiguous", async ({ prisma }) => {
+    const user = await createUser(prisma, "ambiguous");
+    await createOrg(prisma, "first", [user.id]);
+    await createOrg(prisma, "second", [user.id]);
+
+    expect(await feedbackOrganization(user.id, "/account", prisma, prisma)).toBeUndefined();
+  });
+
+  postgresTest("finds a just-created org the replica hasn't caught up on", async ({ prisma }) => {
+    const user = await createUser(prisma, "lagged");
+
+    // The org exists only inside an uncommitted transaction: the transaction stands in for the
+    // primary, and the plain client for a replica that can't see it yet.
+    await prisma.$transaction(async (tx) => {
+      const fresh = await tx.organization.create({
+        data: { title: "Org fresh", slug: "fresh", members: { create: [{ userId: user.id }] } },
+      });
+      expect(await feedbackOrganization(user.id, "/orgs/fresh", prisma, prisma)).toBeUndefined();
+      expect(await feedbackOrganization(user.id, "/orgs/fresh", prisma, tx)).toEqual({
+        id: fresh.id,
+        title: fresh.title,
+      });
+    });
+  });
+
+  postgresTest("ignores deleted orgs", async ({ prisma }) => {
+    const user = await createUser(prisma, "deleted");
+    const gone = await createOrg(prisma, "gone", [user.id]);
+    const live = await createOrg(prisma, "live", [user.id]);
+    await prisma.organization.update({ where: { id: gone.id }, data: { deletedAt: new Date() } });
+
+    expect(await feedbackOrganization(user.id, "/orgs/gone", prisma, prisma)).toBeUndefined();
+    expect(await feedbackOrganization(user.id, "/account", prisma, prisma)).toEqual({
+      id: live.id,
+      title: live.title,
+    });
+  });
+});
@@ -0,0 +1,25 @@
+import type { PrismaReplicaClient } from "@trigger.dev/database";
+import { organizationSlugFromPath } from "./organizationSlugFromPath";
+
+type OrgReader = Pick<PrismaReplicaClient, "organization">;
+
+// The org a feedback message is about: the org page it was sent from, else the user's only org.
+// Membership-scoped, so a forged path can't attribute a thread to someone else's org.
+export async function feedbackOrganization(
+  userId: string,
+  path: string,
+  replica: OrgReader,
+  primary: OrgReader
+): Promise<{ id: string; title: string } | undefined> {
+  const slug = organizationSlugFromPath(path);
+  const query = (client: OrgReader) =>
+    client.organization.findMany({
+      where: { members: { some: { userId } }, deletedAt: null, ...(slug ? { slug } : {}) },
+      select: { id: true, title: true },
+      take: 2,
+    });
+  // Replica first; a miss may be replication lag on a just-created org, so retry the primary.
+  let orgs = await query(replica);
+  if (orgs.length === 0) orgs = await query(primary);
+  return orgs.length === 1 ? orgs[0] : undefined;
+}
@@ -0,0 +1,21 @@
+import { describe, expect, it } from "vitest";
+import { organizationSlugFromPath } from "./organizationSlugFromPath";
+
+describe("organizationSlugFromPath", () => {
+  it("returns the slug of an org page", () => {
+    expect(organizationSlugFromPath("/orgs/acme-1a2b")).toBe("acme-1a2b");
+    expect(organizationSlugFromPath("/orgs/acme-1a2b/projects/web-x9/env/dev/runs")).toBe(
+      "acme-1a2b"
+    );
+    expect(organizationSlugFromPath("/orgs/acme-1a2b?tab=usage")).toBe("acme-1a2b");
+  });
+
+  it("returns undefined outside an org", () => {
+    expect(organizationSlugFromPath("/")).toBeUndefined();
+    expect(organizationSlugFromPath("/account")).toBeUndefined();
+    expect(organizationSlugFromPath("/orgs")).toBeUndefined();
+    expect(organizationSlugFromPath("/orgs/")).toBeUndefined();
+    expect(organizationSlugFromPath("/orgs/new")).toBeUndefined();
+    expect(organizationSlugFromPath("/admin/orgs/acme-1a2b")).toBeUndefined();
+  });
+});
@@ -0,0 +1,8 @@
+// The org slug of a dashboard path like `/orgs/<slug>/...`, or undefined outside an org.
+export function organizationSlugFromPath(path: string): string | undefined {
+  const match = /^\/orgs\/([^/?#]+)/.exec(path);
+  if (!match || match[1] === "new") {
+    return undefined;
+  }
+  return decodeURIComponent(match[1]);
+}