From 38f55d9204541ec41df960a441d38906397841a2 Mon Sep 17 00:00:00 2001
From: Kevin Lago <kevinthelago@gmail.com>
Date: Thu, 30 Jul 2026 13:51:14 -0400
Subject: [PATCH] feat(marketer): campaign/content
 draft-approve-schedule-publish loop (#3148/#3149)

Adds the Marketer feature's frontend: a pure domain model + state machine for
campaigns/content items (draft -> approved -> scheduled -> published, #3148),
compliance guardrails that block approval on noncompliant content (missing
unsubscribe/sender identity, PII, over-length social posts, #3150), a
channel-status view over the mcp feature's server catalog (#3146), an
analytics read-back with graceful degrade when the backend isn't wired yet
(#3149), and the workspace UI tying it together. Not yet mounted to a rail
Workspace/Settings page or folded into the composed app store -- both are
narrow follow-up integration steps outside this feature's write scope.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WDc7B2fkQxzAjhZPRfTRQ7
---
 src/features/marketer/ContentDrawer.tsx      | 131 +++++++++++
 src/features/marketer/MarketerStatus.tsx     |  27 +++
 src/features/marketer/MarketerWorkspace.tsx  | 219 +++++++++++++++++++
 src/features/marketer/index.ts               |  19 ++
 src/features/marketer/lib/api.test.ts        |  52 +++++
 src/features/marketer/lib/api.ts             |  46 ++++
 src/features/marketer/lib/campaign.test.ts   | 104 +++++++++
 src/features/marketer/lib/campaign.ts        | 133 +++++++++++
 src/features/marketer/lib/channels.test.ts   |  45 ++++
 src/features/marketer/lib/channels.ts        |  51 +++++
 src/features/marketer/lib/compliance.test.ts |  59 +++++
 src/features/marketer/lib/compliance.ts      |  61 ++++++
 src/features/marketer/lib/metrics.test.ts    |  45 ++++
 src/features/marketer/lib/metrics.ts         |  49 +++++
 src/features/marketer/marketer.test.tsx      |  72 ++++++
 src/features/marketer/store.test.ts          | 103 +++++++++
 src/features/marketer/store.ts               | 147 +++++++++++++
 17 files changed, 1363 insertions(+)
 create mode 100644 src/features/marketer/ContentDrawer.tsx
 create mode 100644 src/features/marketer/MarketerStatus.tsx
 create mode 100644 src/features/marketer/MarketerWorkspace.tsx
 create mode 100644 src/features/marketer/index.ts
 create mode 100644 src/features/marketer/lib/api.test.ts
 create mode 100644 src/features/marketer/lib/api.ts
 create mode 100644 src/features/marketer/lib/campaign.test.ts
 create mode 100644 src/features/marketer/lib/campaign.ts
 create mode 100644 src/features/marketer/lib/channels.test.ts
 create mode 100644 src/features/marketer/lib/channels.ts
 create mode 100644 src/features/marketer/lib/compliance.test.ts
 create mode 100644 src/features/marketer/lib/compliance.ts
 create mode 100644 src/features/marketer/lib/metrics.test.ts
 create mode 100644 src/features/marketer/lib/metrics.ts
 create mode 100644 src/features/marketer/marketer.test.tsx
 create mode 100644 src/features/marketer/store.test.ts
 create mode 100644 src/features/marketer/store.ts

diff --git a/src/features/marketer/ContentDrawer.tsx b/src/features/marketer/ContentDrawer.tsx
new file mode 100644
index 00000000..042e5d3a
--- /dev/null
+++ b/src/features/marketer/ContentDrawer.tsx
@@ -0,0 +1,131 @@
+import { useState } from "react";
+import { Pane } from "@/shared/ui/overlay/Pane";
+import { Chip } from "@/shared/ui/data/Chip";
+import { InlineError } from "@/shared/ui/feedback/InlineError";
+import { Button } from "@/shared/ui/controls/Button";
+import { TextField, TextArea, Field } from "@/shared/ui/controls/Field";
+import { SegmentedControl } from "@/shared/ui/controls/SegmentedControl";
+import { Stack } from "@/shared/ui/layout/Stack";
+import { Row } from "@/shared/ui/layout/Row";
+import { Box } from "@/shared/ui/layout/Box";
+import { Text } from "@/shared/ui/typography/Text";
+import { complianceViolations } from "./lib/compliance";
+import type { ContentItem, ContentStatus, ChannelKind } from "./lib/campaign";
+
+const STATUS_TONE: Record<ContentStatus, "neutral" | "accent" | "success" | "info"> = {
+  draft: "neutral",
+  approved: "info",
+  scheduled: "accent",
+  published: "success",
+};
+
+export interface ContentDrawerProps {
+  item: ContentItem | null;
+  onClose: () => void;
+  onPatch: (patch: Partial<ContentItem>) => void;
+  onApprove: () => { ok: boolean };
+  onSchedule: (whenIso: string) => void;
+  onPublish: () => void;
+  publishing?: boolean;
+}
+
+/** The compose/approve/schedule/publish editor for one content item (#3148's loop). Shows the
+ *  compliance guardrail violations (#3150) blocking approval, and the action available for the
+ *  item's current status — never lets the user reach for an action the state machine forbids. */
+export function ContentDrawer({ item, onClose, onPatch, onApprove, onSchedule, onPublish, publishing }: ContentDrawerProps) {
+  const [scheduleAt, setScheduleAt] = useState("");
+  const violations = item ? complianceViolations(item) : [];
+  const editable = item?.status === "draft";
+
+  return (
+    <Pane
+      open={!!item}
+      onClose={onClose}
+      header={item && (
+        <>
+          <Chip tone={STATUS_TONE[item.status]}>{item.status}</Chip>
+          <Text as="div" style={{ fontWeight: 600, fontSize: 13 }}>{item.channel}</Text>
+        </>
+      )}
+      body={item && (
+        <Stack gap={12}>
+          {editable && (
+            <Field label="content kind">
+              <SegmentedControl
+                options={(["email", "social"] as ChannelKind[]).map((k) => ({
+                  label: k, on: item.channelKind === k, onClick: () => onPatch({ channelKind: k }),
+                }))}
+              />
+            </Field>
+          )}
+          {item.channelKind === "email" && (
+            <TextField label="subject" placeholder="subject line" value={item.subject ?? ""} onChange={(v) => onPatch({ subject: v })} disabled={!editable} />
+          )}
+          <TextArea label="body" placeholder="draft the content…" value={item.body} onChange={(v) => onPatch({ body: v })} disabled={!editable} rows={8} />
+          {item.channelKind === "email" && (
+            <TextField
+              label="sender identity"
+              hint="company name + physical address — required for CAN-SPAM/GDPR"
+              placeholder="Acme Inc, 1 Main St"
+              value={item.senderIdentity ?? ""}
+              onChange={(v) => onPatch({ senderIdentity: v })}
+              disabled={!editable}
+            />
+          )}
+
+          {violations.length > 0 && (
+            <Stack gap={6}>
+              {violations.map((v) => (
+                <InlineError key={v.code}>{v.message}</InlineError>
+              ))}
+            </Stack>
+          )}
+
+          {item.status === "scheduled" && (
+            <Box className="hint">scheduled for {new Date(item.scheduleAt ?? "").toLocaleString()}</Box>
+          )}
+          {item.status === "published" && (
+            <Row gap={8} wrap>
+              <Chip tone="success">published {item.publishedAt ? new Date(item.publishedAt).toLocaleString() : ""}</Chip>
+              {item.receiptId && <Chip>receipt: {item.receiptId}</Chip>}
+            </Row>
+          )}
+        </Stack>
+      )}
+      footer={item && (
+        <Row gap={8} justify="between" style={{ width: "100%" }}>
+          <Button variant="ghost" onClick={onClose}>close</Button>
+          <Row gap={8}>
+            {item.status === "draft" && (
+              <Button variant="primary" disabled={violations.length > 0} onClick={onApprove}>approve</Button>
+            )}
+            {item.status === "approved" && (
+              <>
+                {/* eslint-disable-next-line no-restricted-syntax -- inline datetime-local input paired with a Schedule button in the footer row; a TextField .field wrapper would break the row layout */}
+                <input
+                  type="datetime-local"
+                  className="input"
+                  value={scheduleAt}
+                  onChange={(e) => setScheduleAt(e.target.value)}
+                  style={{ height: 28 }}
+                />
+                <Button
+                  onClick={() => scheduleAt && onSchedule(new Date(scheduleAt).toISOString())}
+                  disabled={!scheduleAt}
+                >schedule</Button>
+                <Button variant="primary" onClick={onPublish} disabled={publishing}>
+                  {publishing ? "publishing…" : "publish now"}
+                </Button>
+              </>
+            )}
+            {item.status === "scheduled" && (
+              <Button variant="primary" onClick={onPublish} disabled={publishing}>
+                {publishing ? "publishing…" : "publish now"}
+              </Button>
+            )}
+          </Row>
+        </Row>
+      )}
+    />
+  );
+}
diff --git a/src/features/marketer/MarketerStatus.tsx b/src/features/marketer/MarketerStatus.tsx
new file mode 100644
index 00000000..a56f439d
--- /dev/null
+++ b/src/features/marketer/MarketerStatus.tsx
@@ -0,0 +1,27 @@
+import { useMarketerStore } from "./store";
+import { Box } from "@/shared/ui/layout/Box";
+import { StatusDot } from "@/shared/ui/feedback/StatusDot";
+
+/** Live marketing-loop summary (mirrors AutomationsStatus) — how many drafts are waiting on
+ *  approval and how many items are queued for send. A future Glance marketing band (#3800) can
+ *  reuse this same read rather than re-deriving it. */
+export function MarketerStatus() {
+  const items = useMarketerStore((s) => s.contentItems);
+  const drafts = items.filter((i) => i.status === "draft").length;
+  const queued = items.filter((i) => i.status === "approved" || i.status === "scheduled").length;
+
+  if (items.length === 0) {
+    return (
+      <Box as="span" className="s" style={{ color: "var(--fg-dim)" }}>
+        <StatusDot color="var(--fg-dim)" size={7} /> no campaigns yet
+      </Box>
+    );
+  }
+  return (
+    <Box as="span" className="s">
+      <StatusDot color={drafts > 0 ? "var(--accent)" : "var(--fg-dim)"} size={7} />
+      {drafts > 0 ? `${drafts} draft${drafts === 1 ? "" : "s"} awaiting approval` : "all drafts approved"}
+      {queued > 0 && ` · ${queued} queued to send`}
+    </Box>
+  );
+}
diff --git a/src/features/marketer/MarketerWorkspace.tsx b/src/features/marketer/MarketerWorkspace.tsx
new file mode 100644
index 00000000..b4b3069e
--- /dev/null
+++ b/src/features/marketer/MarketerWorkspace.tsx
@@ -0,0 +1,219 @@
+import { useEffect, useMemo, useState } from "react";
+import { useAppStore } from "@/store";
+import { useMarketerStore } from "./store";
+import { ContentDrawer } from "./ContentDrawer";
+import { resolveAllInstalledMcp } from "@/features/mcp";
+import { deriveChannelViews, type ChannelView } from "./lib/channels";
+import { contentForCampaign, type ContentStatus } from "./lib/campaign";
+import { summarizeMetrics, fmtMetric, fmtChannelReadout, type ChannelMetricsReadout } from "./lib/metrics";
+import { fetchChannelMetrics } from "./lib/api";
+import { Screen } from "@/shared/ui/layouts/Screen";
+import { usePageTabs } from "@/shared/hooks/usePageTabs";
+import type { TabItem } from "@/shared/ui/layouts/TabBar";
+import { Card } from "@/shared/ui/data/Card";
+import { CardListRow } from "@/shared/ui/data/CardListRow";
+import { SectionHeader } from "@/shared/ui/layout/SectionHeader";
+import { EmptyState } from "@/shared/ui/feedback/EmptyState";
+import { Chip } from "@/shared/ui/data/Chip";
+import { StatusDot } from "@/shared/ui/feedback/StatusDot";
+import { Button } from "@/shared/ui/controls/Button";
+import { Row } from "@/shared/ui/layout/Row";
+import { Stack } from "@/shared/ui/layout/Stack";
+import { Box } from "@/shared/ui/layout/Box";
+import { Text } from "@/shared/ui/typography/Text";
+
+const STATUS_TONE: Record<ContentStatus, "neutral" | "accent" | "success" | "info"> = {
+  draft: "neutral", approved: "info", scheduled: "accent", published: "success",
+};
+
+/** The Marketer feature's page shell (#3148/#3149, epic #3145) — Campaigns (the draft→approve→
+ *  schedule→publish loop), Channels (read-only status over the mcp feature's catalog, #3146), and
+ *  Analytics (the read-back, #3149). Not yet mounted to a rail Workspace or Settings page — that
+ *  wiring is a director-owned integration step; this export is the feature's public surface, ready
+ *  for it. */
+export function MarketerWorkspace({ pageOverride }: { pageOverride?: string } = {}) {
+  const campaigns = useMarketerStore((s) => s.campaigns);
+  const contentItems = useMarketerStore((s) => s.contentItems);
+  const addCampaign = useMarketerStore((s) => s.addCampaign);
+  const addContentItem = useMarketerStore((s) => s.addContentItem);
+  const updateContentItem = useMarketerStore((s) => s.updateContentItem);
+  const approveContentItem = useMarketerStore((s) => s.approveContentItem);
+  const scheduleContentItem = useMarketerStore((s) => s.scheduleContentItem);
+  const publishContentItem = useMarketerStore((s) => s.publishContentItem);
+
+  const mcpServers = useAppStore((s) => s.mcpServers);
+  const activeProjectId = useAppStore((s) => s.activeProjectId);
+
+  const [selectedId, setSelectedId] = useState<string | null>(null);
+  const [publishing, setPublishing] = useState(false);
+  const selected = contentItems.find((i) => i.id === selectedId) ?? null;
+
+  const channels = useMemo(() => deriveChannelViews(resolveAllInstalledMcp(mcpServers)), [mcpServers]);
+  const summary = useMemo(() => summarizeMetrics(contentItems), [contentItems]);
+
+  const defs: TabItem[] = useMemo(() => [
+    { id: "campaigns", label: "Campaigns", count: campaigns.length },
+    { id: "channels", label: "Channels", count: channels.length },
+    { id: "analytics", label: "Analytics" },
+  ], [campaigns.length, channels.length]);
+  const { tabs, activeId, select, reorder, tearOff } = usePageTabs("marketer", defs);
+  const tab = pageOverride ?? activeId;
+
+  function createDraft(campaignId: string) {
+    // A single channel server (e.g. the built-in mock) can carry either shape of send — email vs
+    // social is a property of the DRAFT, not of which server backs it — so default to "email" (the
+    // richer, compliance-gated case) and let the drawer switch it before approval.
+    const first = channels[0];
+    const id = addContentItem({
+      campaignId,
+      channel: first?.name ?? "Channel (mock)",
+      channelKind: "email",
+      body: "",
+    });
+    setSelectedId(id);
+  }
+
+  async function handlePublish() {
+    if (!selected) return;
+    setPublishing(true);
+    try {
+      await publishContentItem(selected.id, activeProjectId ?? "");
+    } finally {
+      setPublishing(false);
+    }
+  }
+
+  function campaignsView() {
+    if (campaigns.length === 0) {
+      return (
+        <EmptyState
+          title="No campaigns yet"
+          description="Campaigns ground in the market-research stage's findings — draft one to start the publish loop."
+          actions={<Button variant="primary" onClick={() => addCampaign("New campaign")}>+ New campaign</Button>}
+        />
+      );
+    }
+    return (
+      <Stack gap={14}>
+        <SectionHeader title="Campaigns" meta={<>{campaigns.length} campaign{campaigns.length === 1 ? "" : "s"}</>} right={<Button variant="ghost" onClick={() => addCampaign("New campaign")}>+ New campaign</Button>} />
+        {campaigns.map((c) => {
+          const items = contentForCampaign(contentItems, c.id);
+          return (
+            <Card key={c.id} title={c.name} hint={c.researchRef?.gap ? `grounded in: ${c.researchRef.gap}` : undefined}
+              right={<Button variant="ghost" size="sm" onClick={() => createDraft(c.id)}>+ draft</Button>}>
+              {items.length === 0 ? (
+                <Box className="hint">no drafts yet</Box>
+              ) : (
+                <Stack gap={6}>
+                  {items.map((i) => (
+                    <CardListRow
+                      key={i.id}
+                      lead={<StatusDot color={i.status === "published" ? "var(--success)" : i.status === "draft" ? "var(--fg-dim)" : "var(--accent)"} />}
+                      title={i.channel}
+                      badge={<Chip tone={STATUS_TONE[i.status]}>{i.status}</Chip>}
+                      subtitle={i.subject || i.body.slice(0, 80) || "(empty draft)"}
+                      trailing={<Button variant="ghost" size="sm" onClick={() => setSelectedId(i.id)}>open</Button>}
+                      onClick={() => setSelectedId(i.id)}
+                    />
+                  ))}
+                </Stack>
+              )}
+            </Card>
+          );
+        })}
+      </Stack>
+    );
+  }
+
+  function channelsView() {
+    return (
+      <Stack gap={10}>
+        <SectionHeader title="Channels" hint="a marketing channel is an MCP server (#3146) — connect/assign one from the MCP page" meta={<>{channels.length} known</>} />
+        {channels.length === 0 ? (
+          <EmptyState
+            title="No channels yet"
+            description="Add a channel MCP server from the MCP catalog (e.g. the built-in mock channel), then assign it to the marketer stream."
+          />
+        ) : (
+          <Stack gap={6}>
+            {channels.map((c) => (
+              <CardListRow
+                key={c.id}
+                lead={<StatusDot color={c.installed ? "var(--success)" : "var(--fg-dim)"} />}
+                title={c.name}
+                badge={<Chip tone="info">{c.kind}</Chip>}
+                subtitle={c.installed ? "installed" : "not installed — add it from the MCP catalog"}
+                trailing={c.assigned ? <Chip tone="success">assigned to marketer</Chip> : <Chip>not assigned</Chip>}
+              />
+            ))}
+          </Stack>
+        )}
+      </Stack>
+    );
+  }
+
+  return (
+    <Screen
+      tabs={tabs}
+      active={tab}
+      onSelect={select}
+      onReorder={reorder}
+      onTearOff={tearOff}
+      pageOverride={pageOverride}
+      className="marketer-workspace"
+      overlay={
+        <ContentDrawer
+          item={selected}
+          onClose={() => setSelectedId(null)}
+          onPatch={(patch) => selected && updateContentItem(selected.id, patch)}
+          onApprove={() => (selected ? approveContentItem(selected.id) : { ok: false })}
+          onSchedule={(whenIso) => selected && scheduleContentItem(selected.id, whenIso)}
+          onPublish={handlePublish}
+          publishing={publishing}
+        />
+      }
+    >
+      {tab === "channels" ? channelsView() : tab === "analytics" ? (
+        <AnalyticsView summary={summary} channels={channels} project={activeProjectId ?? ""} />
+      ) : campaignsView()}
+    </Screen>
+  );
+}
+
+function AnalyticsView({ summary, channels, project }: { summary: ReturnType<typeof summarizeMetrics>; channels: ChannelView[]; project: string }) {
+  const [readouts, setReadouts] = useState<Record<string, ChannelMetricsReadout | null>>({});
+
+  useEffect(() => {
+    let cancelled = false;
+    void Promise.all(channels.map(async (c) => {
+      const r = await fetchChannelMetrics(project, c.name);
+      if (!cancelled) setReadouts((prev) => ({ ...prev, [c.name]: r }));
+    }));
+    return () => { cancelled = true; };
+    // Re-fetch when the channel set or project changes; the channel objects are re-derived each
+    // render so key on their names rather than identity.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [project, channels.map((c) => c.name).join(",")]);
+
+  return (
+    <Stack gap={14}>
+      <SectionHeader title="Analytics" hint="the marketer's read-back (#3149) — reads whatever each channel reports" />
+      <Row gap={10} wrap>
+        <Card pad="sm" title="published"><Text size="lg" mono>{summary.published}</Text></Card>
+        <Card pad="sm" title="opens"><Text size="lg" mono>{fmtMetric(summary.opens)}</Text></Card>
+        <Card pad="sm" title="clicks"><Text size="lg" mono>{fmtMetric(summary.clicks)}</Text></Card>
+        <Card pad="sm" title="impressions"><Text size="lg" mono>{fmtMetric(summary.impressions)}</Text></Card>
+      </Row>
+      <SectionHeader title="Per channel" />
+      {channels.length === 0 ? (
+        <Box className="hint">no channels connected yet</Box>
+      ) : (
+        <Stack gap={6}>
+          {channels.map((c) => (
+            <CardListRow key={c.id} lead={<StatusDot color="var(--fg-dim)" />} title={c.name} subtitle={fmtChannelReadout(readouts[c.name] ?? null)} />
+          ))}
+        </Stack>
+      )}
+    </Stack>
+  );
+}
diff --git a/src/features/marketer/index.ts b/src/features/marketer/index.ts
new file mode 100644
index 00000000..081c6e82
--- /dev/null
+++ b/src/features/marketer/index.ts
@@ -0,0 +1,19 @@
+// Marketer feature (#3145 epic, #3146–#3150) — public API barrel (#1309). Cross-feature consumers
+// (a future Glance marketing band #3800, the app shell once this is mounted) import ONLY from here.
+export { MarketerWorkspace } from "./MarketerWorkspace";
+export { MarketerStatus } from "./MarketerStatus";
+
+export { useMarketerStore, type MarketerState } from "./store";
+
+export {
+  newCampaign, newContentItem, canTransition, advanceStatus, dueForDispatch, contentForCampaign,
+  type Campaign, type ContentItem, type ContentStatus, type ChannelKind,
+  type ContentMetrics, type ResearchRef, type NewContentInput, type AdvanceResult,
+} from "./lib/campaign";
+export { complianceViolations, canApprove, type ComplianceViolation } from "./lib/compliance";
+export { deriveChannelViews, channelKindOf, type ChannelView } from "./lib/channels";
+export {
+  summarizeMetrics, fmtMetric, fmtChannelReadout,
+  type ChannelMetricsReadout, type CampaignMetricsSummary,
+} from "./lib/metrics";
+export { dispatchContent, fetchChannelMetrics, fetchCampaigns, syncContentItem, syncCampaign } from "./lib/api";
diff --git a/src/features/marketer/lib/api.test.ts b/src/features/marketer/lib/api.test.ts
new file mode 100644
index 00000000..735d3540
--- /dev/null
+++ b/src/features/marketer/lib/api.test.ts
@@ -0,0 +1,52 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { invoke } from "@tauri-apps/api/core";
+import { dispatchContent, fetchChannelMetrics, fetchCampaigns, syncContentItem, syncCampaign } from "./api";
+import { newContentItem, newCampaign } from "./campaign";
+
+const item = newContentItem({ campaignId: "c1", channel: "Resend", channelKind: "email", body: "hi" }, "i1", 1000);
+const campaign = newCampaign("Launch", "c1", 1000);
+
+describe("marketing API bridge (contract-first, graceful degrade)", () => {
+  beforeEach(() => vi.mocked(invoke).mockReset());
+
+  it("dispatchContent returns the receipt on success", async () => {
+    vi.mocked(invoke).mockResolvedValue({ id: "send_email-1" });
+    const r = await dispatchContent("proj", item);
+    expect(r).toEqual({ id: "send_email-1" });
+    expect(invoke).toHaveBeenCalledWith("marketing_publish_content", { project: "proj", contentItemId: "i1" });
+  });
+
+  it("dispatchContent returns null when the backend command isn't wired yet", async () => {
+    vi.mocked(invoke).mockRejectedValueOnce(new Error("command marketing_publish_content not found"));
+    expect(await dispatchContent("proj", item)).toBeNull();
+  });
+
+  it("fetchChannelMetrics degrades to null on failure", async () => {
+    vi.mocked(invoke).mockRejectedValueOnce(new Error("not found"));
+    expect(await fetchChannelMetrics("proj", "Resend")).toBeNull();
+  });
+
+  it("fetchChannelMetrics returns the readout on success", async () => {
+    vi.mocked(invoke).mockResolvedValue({ total: 2, byTool: { send_email: 2 } });
+    expect(await fetchChannelMetrics("proj", "Resend")).toEqual({ total: 2, byTool: { send_email: 2 } });
+  });
+
+  it("fetchCampaigns degrades to null (not []) so the caller can tell 'no backend' apart from 'empty'", async () => {
+    vi.mocked(invoke).mockRejectedValueOnce(new Error("not found"));
+    expect(await fetchCampaigns("proj")).toBeNull();
+  });
+
+  it("syncContentItem / syncCampaign fire-and-forget without throwing even when the backend rejects", async () => {
+    // .mockRejectedValueOnce twice — a fresh rejected promise per call, one per fireInvoke below
+    // (mirrors safeInvoke.test.ts's convention; a shared mockRejectedValue promise can otherwise
+    // surface as an unhandled rejection depending on how many callers observe the same instance).
+    vi.mocked(invoke).mockRejectedValueOnce(new Error("not found")).mockRejectedValueOnce(new Error("not found"));
+    expect(() => syncContentItem("proj", item)).not.toThrow();
+    expect(() => syncCampaign("proj", campaign)).not.toThrow();
+    expect(invoke).toHaveBeenCalledWith("marketing_upsert_content", { project: "proj", item });
+    expect(invoke).toHaveBeenCalledWith("marketing_upsert_campaign", { project: "proj", campaign });
+    // fireInvoke's rejection handling is async (its .catch runs on a later microtask) — let it settle
+    // before the test ends, so the rejection is observed here rather than leaking as unhandled.
+    await new Promise((r) => setTimeout(r, 0));
+  });
+});
diff --git a/src/features/marketer/lib/api.ts b/src/features/marketer/lib/api.ts
new file mode 100644
index 00000000..cbbd6a4e
--- /dev/null
+++ b/src/features/marketer/lib/api.ts
@@ -0,0 +1,46 @@
+// Contract-first bridge to the marketing backend (crates/marketing + its Tauri commands — the
+// durable, bsc-CLI-reachable store #3148 describes, "reachable from a live session like the other
+// stores"). That backend hasn't landed yet, so every call here degrades gracefully on failure — the
+// same pattern `planner/bodies/sourceConnection.ts` uses for `data_platform_scan`: try the real
+// invoke, and on rejection (command not registered) return null/no-op so the UI stays fully driven
+// by the local store until the backend exists, then picks up the real data with no UI change.
+//
+// Command names are a PROPOSED contract (not yet implemented backend-side) — `marketing_*`, mirroring
+// the `bsc marketing` CLI surface #3148 describes and the channel tool's own receipt/metrics shapes
+// (crates/channel) so the same data reaches both the CLI and the desktop UI.
+
+import { safeInvoke, fireInvoke } from "@/shared/lib/core/safeInvoke";
+import type { Campaign, ContentItem } from "./campaign";
+import type { ChannelMetricsReadout } from "./metrics";
+
+/** Dispatch one approved/scheduled content item through its channel's MCP tool
+ *  (send_email/post/schedule) — the backend resolves the stream's channel assignment and makes the
+ *  real (confirm-gated, #3147) tool call, returning the channel's own receipt id (`<tool>-<n>`,
+ *  crates/channel). Null when the backend command isn't wired yet. */
+export async function dispatchContent(project: string, item: ContentItem): Promise<{ id: string } | null> {
+  return safeInvoke<{ id: string } | null>("marketing_publish_content", { project, contentItemId: item.id }, null);
+}
+
+/** Read one channel's aggregate metrics (mirrors the channel tool's `get_metrics`). Null on
+ *  failure — callers show "no data yet" rather than an error (#3149: a missing-metrics channel
+ *  degrades gracefully). */
+export async function fetchChannelMetrics(project: string, channel: string): Promise<ChannelMetricsReadout | null> {
+  return safeInvoke<ChannelMetricsReadout | null>("marketing_channel_metrics", { project, channel }, null);
+}
+
+/** Load the durable campaign/content-item set for a project, if the backend store exists yet.
+ *  Null (not `[]`) on failure, so the caller can tell "no backend" from "genuinely empty". */
+export async function fetchCampaigns(project: string): Promise<{ campaigns: Campaign[]; contentItems: ContentItem[] } | null> {
+  return safeInvoke("marketing_list_campaigns", { project }, null);
+}
+
+/** Fire-and-forget persistence of a campaign/content-item change to the durable backend store — the
+ *  frontend's locally-persisted copy stays the source of truth until the backend lands (graceful
+ *  degrade); once it does, every local mutation starts flowing through with no code change here. */
+export function syncContentItem(project: string, item: ContentItem): void {
+  fireInvoke("marketing_upsert_content", { project, item });
+}
+
+export function syncCampaign(project: string, campaign: Campaign): void {
+  fireInvoke("marketing_upsert_campaign", { project, campaign });
+}
diff --git a/src/features/marketer/lib/campaign.test.ts b/src/features/marketer/lib/campaign.test.ts
new file mode 100644
index 00000000..889c8e1f
--- /dev/null
+++ b/src/features/marketer/lib/campaign.test.ts
@@ -0,0 +1,104 @@
+import { describe, it, expect } from "vitest";
+import {
+  newCampaign, newContentItem, canTransition, advanceStatus, dueForDispatch, contentForCampaign,
+  type ContentItem,
+} from "./campaign";
+
+function item(over: Partial<ContentItem> = {}): ContentItem {
+  const base = newContentItem(
+    { campaignId: "c1", channel: "Channel (mock)", channelKind: "email", body: "hello" },
+    over.id ?? "i1",
+    1000,
+  );
+  return { ...base, ...over };
+}
+
+describe("newCampaign / newContentItem", () => {
+  it("mints a draft content item with no schedule/publish fields", () => {
+    const i = newContentItem({ campaignId: "c1", channel: "Channel (mock)", channelKind: "email", body: "hi" }, "i1", 1000);
+    expect(i.status).toBe("draft");
+    expect(i.scheduleAt).toBeUndefined();
+    expect(i.publishedAt).toBeUndefined();
+  });
+
+  it("mints a campaign with an empty content list", () => {
+    const c = newCampaign("Launch week", "c1", 1000, { gap: "no self-hosted option", keywords: ["self-hosted"] });
+    expect(c.contentItemIds).toEqual([]);
+    expect(c.researchRef?.gap).toBe("no self-hosted option");
+  });
+});
+
+describe("canTransition / advanceStatus", () => {
+  it("allows draft → approved, approved → scheduled|published, scheduled → published", () => {
+    expect(canTransition("draft", "approved")).toBe(true);
+    expect(canTransition("approved", "scheduled")).toBe(true);
+    expect(canTransition("approved", "published")).toBe(true);
+    expect(canTransition("scheduled", "published")).toBe(true);
+  });
+
+  it("rejects publish directly from draft (#3148)", () => {
+    expect(canTransition("draft", "published")).toBe(false);
+    expect(canTransition("draft", "scheduled")).toBe(false);
+  });
+
+  it("rejects any move out of published (terminal)", () => {
+    expect(canTransition("published", "draft")).toBe(false);
+    expect(canTransition("published", "approved")).toBe(false);
+  });
+
+  it("advanceStatus returns ok:false with a reason for a disallowed transition", () => {
+    const draft = item();
+    const res = advanceStatus(draft, "published", 2000);
+    expect(res.ok).toBe(false);
+    if (!res.ok) expect(res.reason).toContain("draft");
+  });
+
+  it("advanceStatus approves a draft", () => {
+    const draft = item();
+    const res = advanceStatus(draft, "approved", 2000);
+    expect(res.ok).toBe(true);
+    if (res.ok) {
+      expect(res.item.status).toBe("approved");
+      expect(res.item.updatedAt).toBe(2000);
+    }
+  });
+
+  it("requires a schedule time to move to scheduled", () => {
+    const approved = { ...item(), status: "approved" as const };
+    const res = advanceStatus(approved, "scheduled", 2000);
+    expect(res.ok).toBe(false);
+  });
+
+  it("scheduling sets scheduleAt; publishing sets publishedAt + receiptId", () => {
+    const approved = { ...item(), status: "approved" as const };
+    const scheduled = advanceStatus(approved, "scheduled", 2000, { scheduleAt: "2026-08-01T00:00:00Z" });
+    expect(scheduled.ok).toBe(true);
+    if (!scheduled.ok) return;
+    expect(scheduled.item.scheduleAt).toBe("2026-08-01T00:00:00Z");
+
+    const published = advanceStatus(scheduled.item, "published", 3000, { receiptId: "send_email-1" });
+    expect(published.ok).toBe(true);
+    if (!published.ok) return;
+    expect(published.item.publishedAt).toBe(3000);
+    expect(published.item.receiptId).toBe("send_email-1");
+  });
+});
+
+describe("dueForDispatch", () => {
+  it("surfaces only scheduled items whose fire time has passed", () => {
+    const past = { ...item({ id: "past" }), status: "scheduled" as const, scheduleAt: "2020-01-01T00:00:00Z" };
+    const future = { ...item({ id: "future" }), status: "scheduled" as const, scheduleAt: "2999-01-01T00:00:00Z" };
+    const draft = item({ id: "draft" });
+    const due = dueForDispatch([past, future, draft], Date.parse("2026-01-01T00:00:00Z"));
+    expect(due.map((i) => i.id)).toEqual(["past"]);
+  });
+});
+
+describe("contentForCampaign", () => {
+  it("filters by campaign and sorts by creation order", () => {
+    const a = item({ id: "a", campaignId: "c1", createdAt: 200 });
+    const b = item({ id: "b", campaignId: "c1", createdAt: 100 });
+    const other = item({ id: "x", campaignId: "c2", createdAt: 50 });
+    expect(contentForCampaign([a, b, other], "c1").map((i) => i.id)).toEqual(["b", "a"]);
+  });
+});
diff --git a/src/features/marketer/lib/campaign.ts b/src/features/marketer/lib/campaign.ts
new file mode 100644
index 00000000..7da2429a
--- /dev/null
+++ b/src/features/marketer/lib/campaign.ts
@@ -0,0 +1,133 @@
+// Campaign/content domain model + the draft→approve→schedule→publish state machine (#3148, epic
+// #3145 P3). Pure (no React/Tauri) so the state machine is unit-testable independent of whatever
+// store or backend ends up persisting it. A campaign grounds in the market-research stage
+// (`bsc plan market`) via an optional `researchRef` snapshot — the gap/keyword/channel/pricing
+// findings it was drafted from.
+
+export type ChannelKind = "email" | "social" | "other";
+export type ContentStatus = "draft" | "approved" | "scheduled" | "published";
+
+export interface ContentMetrics {
+  opens?: number;
+  clicks?: number;
+  impressions?: number;
+  engagement?: number;
+}
+
+export interface ResearchRef {
+  gap?: string;
+  keywords?: string[];
+  channels?: string[];
+  pricing?: string;
+}
+
+export interface ContentItem {
+  id: string;
+  campaignId: string;
+  /** The channel MCP server's name (e.g. "Channel (mock)", "Resend") — see lib/channels.ts. */
+  channel: string;
+  channelKind: ChannelKind;
+  subject?: string;
+  /** Required for email compliance (CAN-SPAM): company name + physical address. */
+  senderIdentity?: string;
+  body: string;
+  status: ContentStatus;
+  /** ISO-8601 — set on transition to "scheduled". */
+  scheduleAt?: string;
+  /** Epoch ms — set on transition to "published". */
+  publishedAt?: number;
+  /** The channel tool's receipt id (`<tool>-<n>`, crates/channel), once dispatched. */
+  receiptId?: string;
+  metrics?: ContentMetrics;
+  createdAt: number;
+  updatedAt: number;
+}
+
+export interface Campaign {
+  id: string;
+  name: string;
+  researchRef?: ResearchRef;
+  contentItemIds: string[];
+  createdAt: number;
+  updatedAt: number;
+}
+
+export interface NewContentInput {
+  campaignId: string;
+  channel: string;
+  channelKind: ChannelKind;
+  subject?: string;
+  senderIdentity?: string;
+  body: string;
+}
+
+export function newCampaign(name: string, id: string, now: number, researchRef?: ResearchRef): Campaign {
+  return { id, name, researchRef, contentItemIds: [], createdAt: now, updatedAt: now };
+}
+
+export function newContentItem(input: NewContentInput, id: string, now: number): ContentItem {
+  return {
+    id,
+    campaignId: input.campaignId,
+    channel: input.channel,
+    channelKind: input.channelKind,
+    subject: input.subject,
+    senderIdentity: input.senderIdentity,
+    body: input.body,
+    status: "draft",
+    createdAt: now,
+    updatedAt: now,
+  };
+}
+
+/** Allowed forward transitions — no backward moves, and critically "no publish from draft"
+ *  (#3148): a draft must be approved first, then either scheduled or published directly. */
+const TRANSITIONS: Record<ContentStatus, ContentStatus[]> = {
+  draft: ["approved"],
+  approved: ["scheduled", "published"],
+  scheduled: ["published"],
+  published: [],
+};
+
+export function canTransition(from: ContentStatus, to: ContentStatus): boolean {
+  return TRANSITIONS[from]?.includes(to) ?? false;
+}
+
+export type AdvanceResult =
+  | { ok: true; item: ContentItem }
+  | { ok: false; reason: string };
+
+/** Advance `item` to `to` — pure; the caller (the store) applies the result. Rejects any
+ *  transition not in {@link TRANSITIONS} with a human-readable reason rather than throwing, so a
+ *  caller can surface it inline (e.g. a disabled button's tooltip). */
+export function advanceStatus(
+  item: ContentItem,
+  to: ContentStatus,
+  now: number,
+  opts?: { scheduleAt?: string; receiptId?: string },
+): AdvanceResult {
+  if (!canTransition(item.status, to)) {
+    return { ok: false, reason: `cannot move from ${item.status} to ${to}` };
+  }
+  if (to === "scheduled" && !opts?.scheduleAt && !item.scheduleAt) {
+    return { ok: false, reason: "a schedule time is required" };
+  }
+  const next: ContentItem = { ...item, status: to, updatedAt: now };
+  if (to === "scheduled") next.scheduleAt = opts?.scheduleAt ?? item.scheduleAt;
+  if (to === "published") {
+    next.publishedAt = now;
+    if (opts?.receiptId) next.receiptId = opts.receiptId;
+  }
+  return { ok: true, item: next };
+}
+
+/** Scheduled items whose fire time has passed — the set a dispatcher should publish next
+ *  (#3148: "scheduled items surface for dispatch"). */
+export function dueForDispatch(items: ContentItem[], now: number): ContentItem[] {
+  return items.filter((i) => i.status === "scheduled" && i.scheduleAt != null && new Date(i.scheduleAt).getTime() <= now);
+}
+
+/** Every content item belonging to a campaign, in creation order. */
+export function contentForCampaign(items: ContentItem[], campaignId: string): ContentItem[] {
+  return items.filter((i) => i.campaignId === campaignId).sort((a, b) => a.createdAt - b.createdAt);
+}
diff --git a/src/features/marketer/lib/channels.test.ts b/src/features/marketer/lib/channels.test.ts
new file mode 100644
index 00000000..c7c8d429
--- /dev/null
+++ b/src/features/marketer/lib/channels.test.ts
@@ -0,0 +1,45 @@
+import { describe, it, expect } from "vitest";
+import { deriveChannelViews, channelKindOf } from "./channels";
+import type { McpServer } from "@/features/mcp";
+
+const mk = (over: Partial<McpServer>): McpServer => ({
+  id: over.id ?? "e", name: over.name ?? "e", enabled: true, projects: [], transport: "stdio", ...over,
+});
+
+describe("channelKindOf", () => {
+  it("recognizes known email/social provider names", () => {
+    expect(channelKindOf("Resend")).toBe("email");
+    expect(channelKindOf("Bluesky")).toBe("social");
+    expect(channelKindOf("Channel (mock)")).toBe("other");
+  });
+});
+
+describe("deriveChannelViews", () => {
+  it("keeps only channel-shaped servers (named 'channel' or a known provider)", () => {
+    const servers = [
+      mk({ id: "c1", name: "Channel (mock)", enabled: false, command: "bsc-channel-mock-mcp" }),
+      mk({ id: "r1", name: "Research", command: "bsc-research-mcp" }),
+      mk({ id: "e1", name: "Resend", command: "resend-mcp" }),
+    ];
+    const views = deriveChannelViews(servers);
+    expect(views.map((v) => v.id).sort()).toEqual(["c1", "e1"]);
+  });
+
+  it("marks a server installed when it has a runnable command/url", () => {
+    const servers = [
+      mk({ id: "c1", name: "Channel (mock)", command: "bsc-channel-mock-mcp" }),
+      mk({ id: "c2", name: "Channel (broken)", command: undefined }),
+      mk({ id: "c3", name: "Channel (http)", transport: "http", url: "https://x" }),
+    ];
+    const byId = Object.fromEntries(deriveChannelViews(servers).map((v) => [v.id, v]));
+    expect(byId.c1.installed).toBe(true);
+    expect(byId.c2.installed).toBe(false);
+    expect(byId.c3.installed).toBe(true);
+  });
+
+  it("marks a channel assigned when its name is in the marketer stream's assignment list (case-insensitive)", () => {
+    const servers = [mk({ id: "c1", name: "Channel (mock)" })];
+    expect(deriveChannelViews(servers, ["channel (mock)"])[0].assigned).toBe(true);
+    expect(deriveChannelViews(servers, [])[0].assigned).toBe(false);
+  });
+});
diff --git a/src/features/marketer/lib/channels.ts b/src/features/marketer/lib/channels.ts
new file mode 100644
index 00000000..f632b9ef
--- /dev/null
+++ b/src/features/marketer/lib/channels.ts
@@ -0,0 +1,51 @@
+// Channel status view (#3146/#3800 prep, epic #3145) — derives a marketer-facing channel list from
+// the mcp feature's server catalog. The epic's architecture is that "a marketing channel IS an MCP
+// server" (its tools are the channel actions, its `env` holds credentials); this module only READS
+// that catalog through the mcp feature's public barrel (`@/features/mcp`) — it never mutates MCP
+// server config, which stays the mcp feature's own concern.
+
+import type { McpServer } from "@/features/mcp";
+import type { ChannelKind } from "./campaign";
+
+export interface ChannelView {
+  id: string;
+  name: string;
+  kind: ChannelKind;
+  /** Enabled/runnable — has a command (stdio) or url (http) it could actually dispatch through. */
+  installed: boolean;
+  /** Assigned to the marketer stream by name (mirrors `resolveStreamMcp`'s case-insensitive match). */
+  assigned: boolean;
+}
+
+const EMAIL_HINT = /email|mail|resend|sendgrid|postmark/i;
+const SOCIAL_HINT = /social|bluesky|mastodon|twitter|\bx\b|linkedin|threads/i;
+const CHANNEL_HINT = /channel/i;
+
+/** Heuristic channel kind from a server's display name (e.g. "Resend" → email, "Bluesky" → social). */
+export function channelKindOf(name: string): ChannelKind {
+  if (EMAIL_HINT.test(name)) return "email";
+  if (SOCIAL_HINT.test(name)) return "social";
+  return "other";
+}
+
+/** Whether an MCP server looks like a marketing channel — named "channel" (the built-in mock,
+ *  #3146) or matching a known email/social provider hint. */
+function looksLikeChannel(s: McpServer): boolean {
+  return CHANNEL_HINT.test(s.name) || EMAIL_HINT.test(s.name) || SOCIAL_HINT.test(s.name);
+}
+
+/** Every channel-shaped MCP server, annotated with whether it's runnable and whether the marketer
+ *  stream has it assigned. `servers` should be the full installed catalog (including disabled
+ *  built-ins, e.g. `resolveAllInstalledMcp`) so a not-yet-assigned channel still shows up to connect. */
+export function deriveChannelViews(servers: McpServer[], streamAssigned: string[] = []): ChannelView[] {
+  const assigned = new Set(streamAssigned.map((n) => n.toLowerCase()));
+  return servers
+    .filter(looksLikeChannel)
+    .map((s) => ({
+      id: s.id,
+      name: s.name,
+      kind: channelKindOf(s.name),
+      installed: s.transport === "http" ? !!s.url : !!s.command,
+      assigned: assigned.has(s.name.toLowerCase()),
+    }));
+}
diff --git a/src/features/marketer/lib/compliance.test.ts b/src/features/marketer/lib/compliance.test.ts
new file mode 100644
index 00000000..4559131b
--- /dev/null
+++ b/src/features/marketer/lib/compliance.test.ts
@@ -0,0 +1,59 @@
+import { describe, it, expect } from "vitest";
+import { complianceViolations, canApprove } from "./compliance";
+import { newContentItem, type ContentItem } from "./campaign";
+
+function email(over: Partial<ContentItem> = {}): ContentItem {
+  return {
+    ...newContentItem({ campaignId: "c1", channel: "Resend", channelKind: "email", body: "Hello!" }, "i1", 1000),
+    ...over,
+  };
+}
+
+function social(over: Partial<ContentItem> = {}): ContentItem {
+  return {
+    ...newContentItem({ campaignId: "c1", channel: "Bluesky", channelKind: "social", body: "gm" }, "i1", 1000),
+    ...over,
+  };
+}
+
+describe("email compliance", () => {
+  it("flags a missing unsubscribe link and missing sender identity", () => {
+    const v = complianceViolations(email({ body: "Buy now!" }));
+    expect(v.map((x) => x.code)).toEqual(expect.arrayContaining(["missing-unsubscribe", "missing-sender-identity"]));
+  });
+
+  it("passes with an unsubscribe link + sender identity + no PII", () => {
+    const item = email({ body: "Buy now! Unsubscribe here: /u", senderIdentity: "Acme Inc, 1 Main St" });
+    expect(complianceViolations(item)).toEqual([]);
+    expect(canApprove(item)).toBe(true);
+  });
+});
+
+describe("social compliance", () => {
+  it("flags a post over the channel character limit", () => {
+    const v = complianceViolations(social({ body: "x".repeat(400) }));
+    expect(v.map((x) => x.code)).toContain("over-length");
+  });
+
+  it("passes a short post", () => {
+    expect(canApprove(social({ body: "gm frens" }))).toBe(true);
+  });
+});
+
+describe("content PII check", () => {
+  it("flags an SSN-shaped number in the body", () => {
+    const v = complianceViolations(social({ body: "SSN: 123-45-6789" }));
+    expect(v.map((x) => x.code)).toContain("possible-pii");
+  });
+
+  it("does not flag ordinary short numbers", () => {
+    const v = complianceViolations(social({ body: "50% off through July 4" }));
+    expect(v.map((x) => x.code)).not.toContain("possible-pii");
+  });
+});
+
+describe("canApprove", () => {
+  it("is false while any violation exists (#3150: cannot reach approved)", () => {
+    expect(canApprove(email({ body: "no unsubscribe here" }))).toBe(false);
+  });
+});
diff --git a/src/features/marketer/lib/compliance.ts b/src/features/marketer/lib/compliance.ts
new file mode 100644
index 00000000..c6071ca0
--- /dev/null
+++ b/src/features/marketer/lib/compliance.ts
@@ -0,0 +1,61 @@
+// Compliance guardrails for outbound marketing content (#3150, epic #3145 P5) — a content item that
+// fails these checks cannot reach "approved" (enforced by the store's approveContentItem action).
+// Pure heuristic checks, not legal advice, but enough of a floor that an obviously-noncompliant
+// draft — no unsubscribe link, no sender identity, raw PII — gets caught before it can be sent.
+
+import type { ContentItem } from "./campaign";
+
+export interface ComplianceViolation {
+  code: string;
+  message: string;
+}
+
+// SSN-shaped (123-45-6789) or a 13–16 digit run (credit-card-shaped), allowing common separators.
+const PII_PATTERNS: RegExp[] = [
+  /\b\d{3}-\d{2}-\d{4}\b/,
+  /\b(?:\d[ -]?){13,16}\b/,
+];
+
+const SOCIAL_CHAR_LIMIT = 300;
+
+function checkEmailCompliance(item: ContentItem): ComplianceViolation[] {
+  const v: ComplianceViolation[] = [];
+  if (!/unsubscribe/i.test(item.body)) {
+    v.push({ code: "missing-unsubscribe", message: "Email body must include an unsubscribe link (CAN-SPAM / GDPR)." });
+  }
+  if (!item.senderIdentity?.trim()) {
+    v.push({ code: "missing-sender-identity", message: "Email requires a sender identity — company name + physical address (CAN-SPAM)." });
+  }
+  return v;
+}
+
+function checkSocialCompliance(item: ContentItem): ComplianceViolation[] {
+  const v: ComplianceViolation[] = [];
+  if (item.body.length > SOCIAL_CHAR_LIMIT) {
+    v.push({ code: "over-length", message: `Social post exceeds the ${SOCIAL_CHAR_LIMIT}-character channel limit.` });
+  }
+  return v;
+}
+
+function checkContentCompliance(item: ContentItem): ComplianceViolation[] {
+  const v: ComplianceViolation[] = [];
+  if (PII_PATTERNS.some((re) => re.test(item.body))) {
+    v.push({ code: "possible-pii", message: "Content appears to contain PII (an SSN- or card-shaped number) — remove it before approving." });
+  }
+  return v;
+}
+
+/** Every guardrail violation blocking `item` from being approved — the per-channel checks
+ *  (email: unsubscribe + sender identity; social: length/ToS) plus the generic content checks
+ *  (no-PII) that apply regardless of channel. */
+export function complianceViolations(item: ContentItem): ComplianceViolation[] {
+  const byChannel =
+    item.channelKind === "email" ? checkEmailCompliance(item)
+    : item.channelKind === "social" ? checkSocialCompliance(item)
+    : [];
+  return [...byChannel, ...checkContentCompliance(item)];
+}
+
+export function canApprove(item: ContentItem): boolean {
+  return complianceViolations(item).length === 0;
+}
diff --git a/src/features/marketer/lib/metrics.test.ts b/src/features/marketer/lib/metrics.test.ts
new file mode 100644
index 00000000..14ae7f5a
--- /dev/null
+++ b/src/features/marketer/lib/metrics.test.ts
@@ -0,0 +1,45 @@
+import { describe, it, expect } from "vitest";
+import { summarizeMetrics, fmtMetric, fmtChannelReadout } from "./metrics";
+import { newContentItem, type ContentItem } from "./campaign";
+
+function published(over: Partial<ContentItem> = {}): ContentItem {
+  return {
+    ...newContentItem({ campaignId: "c1", channel: "Resend", channelKind: "email", body: "hi" }, over.id ?? "i1", 1000),
+    status: "published",
+    ...over,
+  };
+}
+
+describe("summarizeMetrics", () => {
+  it("counts published items and sums their metrics", () => {
+    const items = [
+      published({ id: "a", metrics: { opens: 10, clicks: 2 } }),
+      published({ id: "b", metrics: { opens: 5, impressions: 100 } }),
+      newContentItem({ campaignId: "c1", channel: "Resend", channelKind: "email", body: "draft" }, "d", 1000), // still draft
+    ];
+    expect(summarizeMetrics(items)).toEqual({ published: 2, opens: 15, clicks: 2, impressions: 100 });
+  });
+
+  it("degrades gracefully with no metrics at all (#3149)", () => {
+    expect(summarizeMetrics([])).toEqual({ published: 0, opens: 0, clicks: 0, impressions: 0 });
+  });
+});
+
+describe("fmtMetric", () => {
+  it("shows an em-dash for missing/zero, and a localized number otherwise", () => {
+    expect(fmtMetric(undefined)).toBe("—");
+    expect(fmtMetric(0)).toBe("—");
+    expect(fmtMetric(1234)).toBe((1234).toLocaleString());
+  });
+});
+
+describe("fmtChannelReadout", () => {
+  it("reports 'no sends yet' for a null or empty readout", () => {
+    expect(fmtChannelReadout(null)).toBe("no sends yet");
+    expect(fmtChannelReadout({ total: 0, byTool: {} })).toBe("no sends yet");
+  });
+
+  it("formats the total + per-tool breakdown", () => {
+    expect(fmtChannelReadout({ total: 3, byTool: { send_email: 2, post: 1 } })).toBe("3 sent · 2 send_email · 1 post");
+  });
+});
diff --git a/src/features/marketer/lib/metrics.ts b/src/features/marketer/lib/metrics.ts
new file mode 100644
index 00000000..dcbb0d68
--- /dev/null
+++ b/src/features/marketer/lib/metrics.ts
@@ -0,0 +1,49 @@
+// Analytics read-back (#3149, epic #3145 P4) — the shapes + pure helpers for surfacing channel
+// performance so the marketer iterates instead of firing blind. `ChannelMetricsReadout` mirrors the
+// channel tool's own `get_metrics` shape (`{ total, by_tool }`, crates/channel) so the same readout
+// the agent sees is what the UI displays.
+
+import type { ContentItem } from "./campaign";
+
+export interface ChannelMetricsReadout {
+  total: number;
+  byTool: Record<string, number>;
+}
+
+export interface CampaignMetricsSummary {
+  published: number;
+  opens: number;
+  clicks: number;
+  impressions: number;
+}
+
+/** Roll up per-item metrics across a set of content items (e.g. one campaign's items) — the
+ *  aggregate a campaign card or analytics tab shows. Items with no metrics yet contribute zero
+ *  (#3149: "a missing-metrics channel degrades gracefully" — never throws, never blocks the roll-up). */
+export function summarizeMetrics(items: ContentItem[]): CampaignMetricsSummary {
+  return items.reduce<CampaignMetricsSummary>(
+    (acc, i) => {
+      if (i.status === "published") acc.published += 1;
+      acc.opens += i.metrics?.opens ?? 0;
+      acc.clicks += i.metrics?.clicks ?? 0;
+      acc.impressions += i.metrics?.impressions ?? 0;
+      return acc;
+    },
+    { published: 0, opens: 0, clicks: 0, impressions: 0 },
+  );
+}
+
+/** A metric count for display — "—" when there's nothing to show yet, rather than "0" (which reads
+ *  as "confirmed zero" instead of "no data"). */
+export function fmtMetric(n: number | undefined): string {
+  return n == null || n === 0 ? "—" : n.toLocaleString();
+}
+
+/** A one-line channel readout for display, e.g. "3 sent · 2 send_email · 1 post". */
+export function fmtChannelReadout(readout: ChannelMetricsReadout | null): string {
+  if (!readout || readout.total === 0) return "no sends yet";
+  const byTool = Object.entries(readout.byTool)
+    .map(([tool, n]) => `${n} ${tool}`)
+    .join(" · ");
+  return `${readout.total} sent${byTool ? " · " + byTool : ""}`;
+}
diff --git a/src/features/marketer/marketer.test.tsx b/src/features/marketer/marketer.test.tsx
new file mode 100644
index 00000000..249be357
--- /dev/null
+++ b/src/features/marketer/marketer.test.tsx
@@ -0,0 +1,72 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { render, screen, fireEvent, waitFor } from "@testing-library/react";
+import { MarketerWorkspace } from "./MarketerWorkspace";
+import { useMarketerStore } from "./store";
+import { useAppStore } from "@/store";
+import { resetPageTabs } from "@/test/storeReset";
+
+beforeEach(() => {
+  resetPageTabs();
+  useMarketerStore.setState({ campaigns: [], contentItems: [] });
+  useAppStore.setState({
+    mcpServers: [{ id: "c1", name: "Channel (mock)", enabled: false, projects: [], transport: "stdio", command: "bsc-channel-mock-mcp" }],
+    activeProjectId: "proj-1",
+  });
+});
+
+describe("MarketerWorkspace (wired to its own store)", () => {
+  it("shows an empty state with no campaigns", () => {
+    render(<MarketerWorkspace />);
+    expect(screen.getByText("No campaigns yet")).toBeTruthy();
+  });
+
+  it("creates a campaign and a draft, then blocks approval until compliant", () => {
+    render(<MarketerWorkspace />);
+    fireEvent.click(screen.getByText("+ New campaign"));
+    expect(useMarketerStore.getState().campaigns.length).toBe(1);
+
+    fireEvent.click(screen.getByText("+ draft"));
+    expect(useMarketerStore.getState().contentItems.length).toBe(1);
+
+    // The drawer opens for the new draft; approve is disabled while the compliance gate fails
+    // (email channel with an empty body — no unsubscribe link, no sender identity).
+    const approveBtn = screen.getByText("approve") as HTMLButtonElement;
+    expect(approveBtn.disabled).toBe(true);
+    expect(screen.getByText(/unsubscribe link/i)).toBeTruthy();
+  });
+
+  it("approves a draft once it's compliant, then schedules and publishes it", async () => {
+    render(<MarketerWorkspace />);
+    fireEvent.click(screen.getByText("+ New campaign"));
+    fireEvent.click(screen.getByText("+ draft"));
+
+    const bodyField = screen.getByPlaceholderText("draft the content…") as HTMLTextAreaElement;
+    fireEvent.change(bodyField, { target: { value: "Hello! Unsubscribe: /u" } });
+    const senderField = screen.getByPlaceholderText("Acme Inc, 1 Main St") as HTMLInputElement;
+    fireEvent.change(senderField, { target: { value: "Acme Inc, 1 Main St" } });
+
+    const approveBtn = screen.getByText("approve") as HTMLButtonElement;
+    expect(approveBtn.disabled).toBe(false);
+    fireEvent.click(approveBtn);
+    expect(useMarketerStore.getState().contentItems[0].status).toBe("approved");
+
+    fireEvent.click(screen.getByText("publish now"));
+    await waitFor(() => expect(useMarketerStore.getState().contentItems[0].status).toBe("published"));
+    expect(useMarketerStore.getState().contentItems[0].receiptId).toBeTruthy();
+  });
+
+  it("switches to the Channels tab and shows the known channel", () => {
+    render(<MarketerWorkspace />);
+    fireEvent.click(screen.getByText("Channels"));
+    expect(screen.getByText("Channel (mock)")).toBeTruthy();
+  });
+
+  it("switches to the Analytics tab and shows the rollup tiles", async () => {
+    render(<MarketerWorkspace />);
+    fireEvent.click(screen.getByText("Analytics"));
+    expect(screen.getByText("published")).toBeTruthy();
+    // AnalyticsView fetches each channel's metrics readout on mount; let that settle so the
+    // resulting state update lands inside act() instead of after the test returns.
+    await waitFor(() => expect(screen.getByText("no sends yet")).toBeTruthy());
+  });
+});
diff --git a/src/features/marketer/store.test.ts b/src/features/marketer/store.test.ts
new file mode 100644
index 00000000..43c7d800
--- /dev/null
+++ b/src/features/marketer/store.test.ts
@@ -0,0 +1,103 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { useMarketerStore } from "./store";
+
+const emailInput = { campaignId: "c1", channel: "Resend", channelKind: "email" as const, body: "Buy now! Unsubscribe: /u", senderIdentity: "Acme, 1 Main St" };
+const badEmailInput = { campaignId: "c1", channel: "Resend", channelKind: "email" as const, body: "Buy now!" }; // no unsubscribe/sender
+
+beforeEach(() => {
+  useMarketerStore.setState({ campaigns: [], contentItems: [] });
+});
+
+describe("campaign CRUD", () => {
+  it("adds a campaign and links content items to it", () => {
+    const campId = useMarketerStore.getState().addCampaign("Launch week");
+    const itemId = useMarketerStore.getState().addContentItem({ ...emailInput, campaignId: campId });
+    expect(useMarketerStore.getState().campaigns[0].contentItemIds).toEqual([itemId]);
+    expect(useMarketerStore.getState().contentItems[0].status).toBe("draft");
+  });
+
+  it("removing a campaign cascades to its content items", () => {
+    const campId = useMarketerStore.getState().addCampaign("Launch week");
+    useMarketerStore.getState().addContentItem({ ...emailInput, campaignId: campId });
+    useMarketerStore.getState().removeCampaign(campId);
+    expect(useMarketerStore.getState().campaigns).toEqual([]);
+    expect(useMarketerStore.getState().contentItems).toEqual([]);
+  });
+
+  it("removing a content item unlinks it from its campaign", () => {
+    const campId = useMarketerStore.getState().addCampaign("Launch week");
+    const itemId = useMarketerStore.getState().addContentItem({ ...emailInput, campaignId: campId });
+    useMarketerStore.getState().removeContentItem(itemId);
+    expect(useMarketerStore.getState().campaigns[0].contentItemIds).toEqual([]);
+    expect(useMarketerStore.getState().contentItems).toEqual([]);
+  });
+});
+
+describe("approveContentItem — the compliance gate (#3150)", () => {
+  it("blocks approval and reports violations for noncompliant content", () => {
+    const campId = useMarketerStore.getState().addCampaign("Launch week");
+    const itemId = useMarketerStore.getState().addContentItem({ ...badEmailInput, campaignId: campId });
+    const res = useMarketerStore.getState().approveContentItem(itemId);
+    expect(res.ok).toBe(false);
+    expect(res.violations.length).toBeGreaterThan(0);
+    expect(useMarketerStore.getState().contentItems[0].status).toBe("draft");
+  });
+
+  it("approves compliant content", () => {
+    const campId = useMarketerStore.getState().addCampaign("Launch week");
+    const itemId = useMarketerStore.getState().addContentItem({ ...emailInput, campaignId: campId });
+    const res = useMarketerStore.getState().approveContentItem(itemId);
+    expect(res.ok).toBe(true);
+    expect(useMarketerStore.getState().contentItems[0].status).toBe("approved");
+  });
+});
+
+describe("scheduleContentItem", () => {
+  it("rejects scheduling a draft (must be approved first)", () => {
+    const campId = useMarketerStore.getState().addCampaign("Launch week");
+    const itemId = useMarketerStore.getState().addContentItem({ ...emailInput, campaignId: campId });
+    const res = useMarketerStore.getState().scheduleContentItem(itemId, "2026-08-01T00:00:00Z");
+    expect(res.ok).toBe(false);
+  });
+
+  it("schedules an approved item", () => {
+    const campId = useMarketerStore.getState().addCampaign("Launch week");
+    const itemId = useMarketerStore.getState().addContentItem({ ...emailInput, campaignId: campId });
+    useMarketerStore.getState().approveContentItem(itemId);
+    const res = useMarketerStore.getState().scheduleContentItem(itemId, "2026-08-01T00:00:00Z");
+    expect(res.ok).toBe(true);
+    expect(useMarketerStore.getState().contentItems[0].status).toBe("scheduled");
+    expect(useMarketerStore.getState().contentItems[0].scheduleAt).toBe("2026-08-01T00:00:00Z");
+  });
+});
+
+describe("publishContentItem", () => {
+  it("rejects publishing a draft (#3148: no publish from draft)", async () => {
+    const campId = useMarketerStore.getState().addCampaign("Launch week");
+    const itemId = useMarketerStore.getState().addContentItem({ ...emailInput, campaignId: campId });
+    const res = await useMarketerStore.getState().publishContentItem(itemId, "proj");
+    expect(res.ok).toBe(false);
+  });
+
+  it("publishes an approved item, setting publishedAt + a receipt id (simulated when no backend)", async () => {
+    const campId = useMarketerStore.getState().addCampaign("Launch week");
+    const itemId = useMarketerStore.getState().addContentItem({ ...emailInput, campaignId: campId });
+    useMarketerStore.getState().approveContentItem(itemId);
+    const res = await useMarketerStore.getState().publishContentItem(itemId, "proj");
+    expect(res.ok).toBe(true);
+    const published = useMarketerStore.getState().contentItems[0];
+    expect(published.status).toBe("published");
+    expect(published.publishedAt).toBeTypeOf("number");
+    expect(published.receiptId).toBeTruthy();
+  });
+});
+
+describe("recordMetrics", () => {
+  it("merges metrics onto the right content item", () => {
+    const campId = useMarketerStore.getState().addCampaign("Launch week");
+    const itemId = useMarketerStore.getState().addContentItem({ ...emailInput, campaignId: campId });
+    useMarketerStore.getState().recordMetrics(itemId, { opens: 5 });
+    useMarketerStore.getState().recordMetrics(itemId, { clicks: 2 });
+    expect(useMarketerStore.getState().contentItems[0].metrics).toEqual({ opens: 5, clicks: 2 });
+  });
+});
diff --git a/src/features/marketer/store.ts b/src/features/marketer/store.ts
new file mode 100644
index 00000000..ec352cc3
--- /dev/null
+++ b/src/features/marketer/store.ts
@@ -0,0 +1,147 @@
+// Marketer feature store (#3148, epic #3145 P3) — campaigns + content items, the
+// draft→approve→schedule→publish loop.
+//
+// NOT folded into the app's composed `useAppStore` (#1309's `AppStore extends …Slice` pattern, see
+// e.g. `features/automations/store.ts`): that would require a two-line edit to `src/store/index.ts` +
+// `src/store/types.ts`, both outside this feature's write scope (`src/features/marketer/**`). This is
+// a deliberate, working interim: a standalone store using the SAME persistence adapter the composed
+// store uses (`persistStorage` — Tauri plugin-store's `app-state.json` in the app, localStorage in
+// browser-only dev), under its own top-level key (`"bsc-marketer"`) so it never collides with the
+// main store's key. Folding this into `AppStore` is a natural follow-up once a stream that owns
+// `store/index.ts` does the two-line wiring — nothing here needs to change to support that.
+import { create } from "zustand";
+import { persist, createJSONStorage } from "zustand/middleware";
+import { persistStorage } from "@/shared/lib/core/storage";
+import {
+  newCampaign, newContentItem, advanceStatus,
+  type Campaign, type ContentItem, type ContentStatus, type NewContentInput, type ContentMetrics, type ResearchRef,
+} from "./lib/campaign";
+import { complianceViolations, type ComplianceViolation } from "./lib/compliance";
+import { dispatchContent } from "./lib/api";
+
+let seq = 0;
+/** A locally-unique id (no clock dependency for ordering within a session). */
+function mintId(prefix: string): string {
+  seq += 1;
+  return `${prefix}_${Date.now().toString(36)}${seq.toString(36)}`;
+}
+
+export interface MarketerState {
+  campaigns: Campaign[];
+  contentItems: ContentItem[];
+
+  addCampaign: (name: string, researchRef?: ResearchRef) => string;
+  removeCampaign: (id: string) => void;
+
+  addContentItem: (input: NewContentInput) => string;
+  updateContentItem: (id: string, patch: Partial<ContentItem>) => void;
+  removeContentItem: (id: string) => void;
+
+  /** Approve a draft — blocked (returns the violations, no state change) while any compliance
+   *  guardrail fails (#3150: "a content item failing a compliance check cannot reach approved"). */
+  approveContentItem: (id: string) => { ok: boolean; violations: ComplianceViolation[] };
+  /** Move an approved item to scheduled for a future ISO-8601 time. */
+  scheduleContentItem: (id: string, scheduleAt: string) => { ok: boolean; reason?: string };
+  /** Dispatch an approved/scheduled item through its channel (#3146/#3147) and mark it published.
+   *  Tries the real backend command; when it isn't wired yet, mints a locally-simulated receipt
+   *  (matching the channel tool's `<tool>-<n>` shape) so the loop still demos end to end. */
+  publishContentItem: (id: string, project: string) => Promise<{ ok: boolean; reason?: string }>;
+  recordMetrics: (id: string, metrics: ContentMetrics) => void;
+}
+
+/** The MCP tool a channel kind dispatches through — mirrors crates/channel's tool catalog. */
+function toolFor(item: Pick<ContentItem, "channelKind">): "send_email" | "post" {
+  return item.channelKind === "email" ? "send_email" : "post";
+}
+
+export const useMarketerStore = create<MarketerState>()(
+  persist(
+    (set, get) => ({
+      campaigns: [],
+      contentItems: [],
+
+      addCampaign: (name, researchRef) => {
+        const id = mintId("camp");
+        const now = Date.now();
+        set((s) => ({ campaigns: [...s.campaigns, newCampaign(name, id, now, researchRef)] }));
+        return id;
+      },
+
+      removeCampaign: (id) =>
+        set((s) => ({
+          campaigns: s.campaigns.filter((c) => c.id !== id),
+          contentItems: s.contentItems.filter((i) => i.campaignId !== id),
+        })),
+
+      addContentItem: (input) => {
+        const id = mintId("item");
+        const now = Date.now();
+        const item = newContentItem(input, id, now);
+        set((s) => ({
+          contentItems: [...s.contentItems, item],
+          campaigns: s.campaigns.map((c) => (c.id === input.campaignId ? { ...c, contentItemIds: [...c.contentItemIds, id], updatedAt: now } : c)),
+        }));
+        return id;
+      },
+
+      updateContentItem: (id, patch) =>
+        set((s) => ({
+          contentItems: s.contentItems.map((i) => (i.id === id ? { ...i, ...patch, updatedAt: Date.now() } : i)),
+        })),
+
+      removeContentItem: (id) =>
+        set((s) => {
+          const item = s.contentItems.find((i) => i.id === id);
+          return {
+            contentItems: s.contentItems.filter((i) => i.id !== id),
+            campaigns: item
+              ? s.campaigns.map((c) => (c.id === item.campaignId ? { ...c, contentItemIds: c.contentItemIds.filter((cid) => cid !== id) } : c))
+              : s.campaigns,
+          };
+        }),
+
+      approveContentItem: (id) => {
+        const item = get().contentItems.find((i) => i.id === id);
+        if (!item) return { ok: false, violations: [] };
+        const violations = complianceViolations(item);
+        if (violations.length > 0) return { ok: false, violations };
+        const res = advanceStatus(item, "approved", Date.now());
+        if (!res.ok) return { ok: false, violations: [] };
+        set((s) => ({ contentItems: s.contentItems.map((i) => (i.id === id ? res.item : i)) }));
+        return { ok: true, violations: [] };
+      },
+
+      scheduleContentItem: (id, scheduleAt) => {
+        const item = get().contentItems.find((i) => i.id === id);
+        if (!item) return { ok: false, reason: "not found" };
+        const res = advanceStatus(item, "scheduled", Date.now(), { scheduleAt });
+        if (!res.ok) return { ok: false, reason: res.reason };
+        set((s) => ({ contentItems: s.contentItems.map((i) => (i.id === id ? res.item : i)) }));
+        return { ok: true };
+      },
+
+      publishContentItem: async (id, project) => {
+        const item = get().contentItems.find((i) => i.id === id);
+        if (!item) return { ok: false, reason: "not found" };
+        if (!canTransitionToPublished(item.status)) return { ok: false, reason: `cannot publish from ${item.status}` };
+
+        const receipt = await dispatchContent(project, item);
+        const receiptId = receipt?.id ?? `${toolFor(item)}-sim-${mintId("r")}`;
+        const res = advanceStatus(item, "published", Date.now(), { receiptId });
+        if (!res.ok) return { ok: false, reason: res.reason };
+        set((s) => ({ contentItems: s.contentItems.map((i) => (i.id === id ? res.item : i)) }));
+        return { ok: true };
+      },
+
+      recordMetrics: (id, metrics) =>
+        set((s) => ({
+          contentItems: s.contentItems.map((i) => (i.id === id ? { ...i, metrics: { ...i.metrics, ...metrics }, updatedAt: Date.now() } : i)),
+        })),
+    }),
+    { name: "bsc-marketer", storage: createJSONStorage(() => persistStorage) },
+  ),
+);
+
+function canTransitionToPublished(status: ContentStatus): boolean {
+  return status === "approved" || status === "scheduled";
+}