@dxos/plugin-magazine 0.0.0

package/dx.config.ts

@@ -0,0 +1,48 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Config2 } from '@dxos/app-framework/config';
+import { trim } from '@dxos/util';
+
+export default Config2.make({
+  plugin: {
+    key: 'org.dxos.plugin.magazine',
+    name: 'Magazine',
+    author: 'DXOS',
+    description: trim`
+      MagazinePlugin brings syndicated content into DXOS Composer by syncing RSS feeds
+      and ATproto (Bluesky) feeds as ECHO objects stored in the user's space.
+      Subscribed feeds are polled incrementally using a cursor so only new posts
+      are fetched on each sync, and feed metadata (name, icon, description) is
+      persisted alongside the posts for offline access.
+
+      Magazines are agent-curated collections drawn from one or more feeds. Each
+      Magazine carries the user's topic instructions describing what it should
+      cover; pressing the Curate button (or a scheduled trigger) syncs all
+      referenced feeds in parallel, then runs a single-shot agent pass that selects
+      matching posts and returns their ids, which the operation adds mechanically.
+      The agent's base methodology — how to select, how to dedup, and the structured
+      output contract — lives in the MagazineSkill. Each magazine stores a
+      persisted curation Routine (created at magazine creation time) whose instructions
+      hold the editorial brief; pressing Curate runs that Routine against the synced
+      candidates via RunInstructions. The skill also exposes a FetchArticleContent
+      tool the agent may call to read a candidate's full text when title and
+      description are insufficient to judge.
+      A short snippet and hero image are derived mechanically from each post for
+      display. A Masonry grid renders the curated tiles with images, titles, author
+      metadata, and read-state dimming.
+
+      Clicking a tile opens the PostArticle detail surface via the deck's layout
+      dispatch, routing to the appropriate location (complementary drawer, sibling
+      plank, or deck companion) based on the current layout mode. The schema also
+      scaffolds a future tagging feature — posts carry an optional tags array and
+      the tile renders a tag row when tags are present — enabling navigation and
+      feed-discovery flows in a later revision.
+    `,
+    source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-magazine',
+    icon: { key: 'ph--book-open-text--regular', hue: 'orange' },
+    spec: 'PLUGIN.mdl',
+    tags: ['labs'],
+  },
+});

package/package.json

@@ -0,0 +1,164 @@
+{
+  "name": "@dxos/plugin-magazine",
+  "version": "0.0.0",
+  "description": "Magazine plugin for RSS and open protocol subscriptions.",
+  "homepage": "https://dxos.org",
+  "bugs": "https://github.com/dxos/dxos/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dxos/dxos"
+  },
+  "license": "FSL-1.1-Apache-2.0",
+  "author": "DXOS.org",
+  "sideEffects": true,
+  "type": "module",
+  "imports": {
+    "#atoms": {
+      "source": "./src/atoms/index.ts",
+      "types": "./dist/types/src/atoms/index.d.ts",
+      "default": "./dist/lib/neutral/atoms/index.mjs"
+    },
+    "#skills": {
+      "source": "./src/skills/index.ts",
+      "types": "./dist/types/src/skills/index.d.ts",
+      "default": "./dist/lib/neutral/skills/index.mjs"
+    },
+    "#capabilities": {
+      "source": "./src/capabilities/index.ts",
+      "types": "./dist/types/src/capabilities/index.d.ts",
+      "default": "./dist/lib/neutral/capabilities/index.mjs"
+    },
+    "#components": {
+      "source": "./src/components/index.ts",
+      "types": "./dist/types/src/components/index.d.ts",
+      "default": "./dist/lib/neutral/components/index.mjs"
+    },
+    "#containers": {
+      "source": "./src/containers/index.ts",
+      "types": "./dist/types/src/containers/index.d.ts",
+      "default": "./dist/lib/neutral/containers/index.mjs"
+    },
+    "#meta": {
+      "source": "./src/meta.ts",
+      "types": "./dist/types/src/meta.d.ts",
+      "default": "./dist/lib/neutral/meta.mjs"
+    },
+    "#operations": {
+      "source": "./src/operations/index.ts",
+      "types": "./dist/types/src/operations/index.d.ts",
+      "default": "./dist/lib/neutral/operations/index.mjs"
+    },
+    "#plugin": {
+      "source": {
+        "workerd": "./src/MagazinePlugin.workerd.ts",
+        "default": "./src/MagazinePlugin.tsx"
+      },
+      "types": "./dist/types/src/MagazinePlugin.d.ts",
+      "workerd": "./dist/lib/neutral/MagazinePlugin.workerd.mjs",
+      "default": "./dist/lib/neutral/MagazinePlugin.mjs"
+    },
+    "#testing": "./src/testing/index.ts",
+    "#translations": {
+      "source": "./src/translations.ts",
+      "types": "./dist/types/src/translations.d.ts",
+      "default": "./dist/lib/neutral/translations.mjs"
+    },
+    "#types": {
+      "source": "./src/types/index.ts",
+      "types": "./dist/types/src/types/index.d.ts",
+      "default": "./dist/lib/neutral/types/index.mjs"
+    }
+  },
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/types/src/index.d.ts",
+      "default": "./dist/lib/neutral/index.mjs"
+    },
+    "./assets/PLUGIN.mdl": "./PLUGIN.mdl",
+    "./plugin": {
+      "source": {
+        "workerd": "./src/plugin.workerd.ts",
+        "default": "./src/plugin.ts"
+      },
+      "types": "./dist/types/src/plugin.d.ts",
+      "workerd": "./dist/lib/neutral/plugin.workerd.mjs",
+      "default": "./dist/lib/neutral/plugin.mjs"
+    },
+    "./translations": {
+      "source": "./src/translations.ts",
+      "types": "./dist/types/src/translations.d.ts",
+      "default": "./dist/lib/neutral/translations.mjs"
+    }
+  },
+  "types": "dist/types/src/index.d.ts",
+  "files": [
+    "dist",
+    "dx.config.ts",
+    "src",
+    "PLUGIN.mdl"
+  ],
+  "dependencies": {
+    "@dxos/app-framework": "workspace:*",
+    "@dxos/app-toolkit": "workspace:*",
+    "@dxos/assistant-toolkit": "workspace:*",
+    "@dxos/client": "workspace:*",
+    "@dxos/compute": "workspace:*",
+    "@dxos/echo": "workspace:*",
+    "@dxos/echo-react": "workspace:*",
+    "@dxos/effect": "workspace:*",
+    "@dxos/invariant": "workspace:*",
+    "@dxos/keys": "workspace:*",
+    "@dxos/log": "workspace:*",
+    "@dxos/markdown": "workspace:*",
+    "@dxos/plugin-assistant": "workspace:*",
+    "@dxos/plugin-attention": "workspace:*",
+    "@dxos/plugin-client": "workspace:*",
+    "@dxos/plugin-graph": "workspace:*",
+    "@dxos/plugin-routine": "workspace:*",
+    "@dxos/plugin-space": "workspace:*",
+    "@dxos/react-client": "workspace:*",
+    "@dxos/react-ui-attention": "workspace:*",
+    "@dxos/react-ui-form": "workspace:*",
+    "@dxos/react-ui-markdown": "workspace:*",
+    "@dxos/react-ui-masonry": "workspace:*",
+    "@dxos/react-ui-menu": "workspace:*",
+    "@dxos/schema": "workspace:*",
+    "@dxos/util": "workspace:*",
+    "@effect-atom/atom-react": "catalog:",
+    "@effect/platform": "catalog:",
+    "date-fns": "catalog:",
+    "defuddle": "catalog:",
+    "fast-xml-parser": "catalog:"
+  },
+  "devDependencies": {
+    "@dxos/ai": "workspace:*",
+    "@dxos/echo-client": "workspace:*",
+    "@dxos/functions-runtime": "workspace:*",
+    "@dxos/plugin-testing": "workspace:*",
+    "@dxos/random": "workspace:*",
+    "@dxos/react-ui": "workspace:*",
+    "@dxos/react-ui-mosaic": "workspace:*",
+    "@dxos/react-ui-syntax-highlighter": "workspace:*",
+    "@dxos/storybook-utils": "workspace:*",
+    "@dxos/ui-theme": "workspace:*",
+    "@storybook/react-vite": "catalog:",
+    "@types/react": "catalog:",
+    "@types/react-dom": "catalog:",
+    "effect": "catalog:",
+    "react": "catalog:",
+    "react-dom": "catalog:",
+    "vite": "catalog:"
+  },
+  "peerDependencies": {
+    "@dxos/react-ui": "workspace:*",
+    "@dxos/react-ui-mosaic": "workspace:*",
+    "@dxos/ui-theme": "workspace:*",
+    "effect": "catalog:",
+    "react": "catalog:",
+    "react-dom": "catalog:"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/MagazinePlugin.test.ts

@@ -0,0 +1,36 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { ActivationEvents } from '@dxos/app-framework';
+import { ClientPlugin } from '@dxos/plugin-client/plugin';
+import { createComposerTestApp } from '@dxos/plugin-testing/harness';
+
+import { MagazinePlugin } from '#plugin';
+
+import { meta } from './meta';
+
+const moduleId = (name: string) => `${meta.profile.key}.module.${name}`;
+
+describe('MagazinePlugin', () => {
+  test('modules activate on the expected events', async ({ expect }) => {
+    await using harness = await createComposerTestApp({
+      plugins: [ClientPlugin({}), MagazinePlugin()],
+    });
+
+    expect(harness.manager.getActive()).toEqual(
+      expect.arrayContaining([
+        moduleId('AppGraphBuilder'),
+        moduleId('CreateObject'),
+        moduleId('schema'),
+        moduleId('ReactSurface'),
+      ]),
+    );
+
+    // Operation handlers are not loaded on startup — SetupProcessManager fires lazily when an operation is invoked.
+    await harness.fire(ActivationEvents.SetupProcessManager);
+    expect(harness.manager.getActive()).toContain(moduleId('OperationHandler'));
+  });
+});

package/src/MagazinePlugin.tsx

@@ -0,0 +1,61 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { ActivationEvent, Plugin } from '@dxos/app-framework';
+import { AppActivationEvents, AppPlugin } from '@dxos/app-toolkit';
+import { Instructions } from '@dxos/compute';
+import { AttentionEvents } from '@dxos/plugin-attention';
+import { ClientEvents } from '@dxos/plugin-client';
+import { StateMap, TagIndex } from '@dxos/schema';
+
+import {
+  AppGraphBuilder,
+  CreateObject,
+  NavigationResolver,
+  OperationHandler,
+  ReactSurface,
+  RoutineTemplates,
+  SkillDefinition,
+} from '#capabilities';
+import { meta } from '#meta';
+import { translations } from '#translations';
+import { Magazine, Subscription } from '#types';
+
+// eslint-disable-next-line import/no-relative-packages
+import pluginSpec from '../PLUGIN.mdl?raw';
+
+export const MagazinePlugin = Plugin.define(meta).pipe(
+  AppPlugin.addAppGraphModule({
+    activatesOn: ActivationEvent.allOf(AppActivationEvents.SetupAppGraph, AttentionEvents.AttentionReady),
+    activate: AppGraphBuilder,
+  }),
+  AppPlugin.addCreateObjectModule({ activate: CreateObject }),
+  AppPlugin.addNavigationResolverModule({ activatesOn: ClientEvents.ClientReady, activate: NavigationResolver }),
+  AppPlugin.addOperationHandlerModule({ activate: OperationHandler }),
+  AppPlugin.addPluginAssetModule({
+    asset: { pluginId: meta.profile.key, path: 'PLUGIN.mdl', content: pluginSpec, mimeType: 'application/x-mdl' },
+  }),
+  AppPlugin.addSchemaModule({
+    schema: [
+      Subscription.Subscription,
+      Subscription.Post,
+      Subscription.PostContent,
+      Magazine.Magazine,
+      Instructions.Instructions,
+      StateMap.StateMap,
+      TagIndex.TagIndex,
+    ],
+  }),
+  AppPlugin.addSkillDefinitionModule({ activate: SkillDefinition }),
+  AppPlugin.addSurfaceModule({ activate: ReactSurface }),
+  AppPlugin.addTranslationsModule({ translations }),
+  Plugin.addModule({
+    id: 'magazine-automation-templates',
+    activatesOn: AppActivationEvents.SetupSchema,
+    activate: RoutineTemplates,
+  }),
+  Plugin.make,
+);
+
+export default MagazinePlugin;

package/src/MagazinePlugin.workerd.ts

@@ -0,0 +1,31 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Plugin } from '@dxos/app-framework';
+import { AppPlugin } from '@dxos/app-toolkit';
+import { StateMap, TagIndex } from '@dxos/schema';
+
+import { meta } from '#meta';
+import { Magazine, Subscription } from '#types';
+
+import OperationHandler from './capabilities/operation-handler';
+import SkillDefinition from './capabilities/skill-definition';
+
+export const MagazinePlugin = Plugin.define(meta).pipe(
+  AppPlugin.addSkillDefinitionModule({ id: 'skill-definition', activate: SkillDefinition }),
+  AppPlugin.addOperationHandlerModule({ id: 'operation-handler', activate: OperationHandler }),
+  AppPlugin.addSchemaModule({
+    schema: [
+      Subscription.Subscription,
+      Subscription.Post,
+      Subscription.PostContent,
+      Magazine.Magazine,
+      StateMap.StateMap,
+      TagIndex.TagIndex,
+    ],
+  }),
+  Plugin.make,
+);
+
+export default MagazinePlugin;

package/src/atoms/atoms.test.ts

@@ -0,0 +1,323 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Registry } from '@effect-atom/atom-react';
+import * as Data from 'effect/Data';
+import { afterEach, beforeEach, describe, test } from 'vitest';
+
+import { Feed, Obj, Ref, Tag } from '@dxos/echo';
+import { EchoTestBuilder } from '@dxos/echo-client/testing';
+import { StateMap, TagIndex } from '@dxos/schema';
+
+import { Magazine, Subscription } from '../types';
+import { postCurationAtom } from './post-curation';
+import { postDisplayAtom } from './post-display';
+import { postReadAtom } from './post-read';
+import { postTagsAtom } from './post-tags';
+
+describe('postReadAtom', () => {
+  let builder: EchoTestBuilder;
+
+  beforeEach(async () => {
+    builder = await new EchoTestBuilder().open();
+  });
+
+  afterEach(async () => {
+    await builder.close();
+  });
+
+  test('fires when this post is marked read', async ({ expect }) => {
+    const { db } = await builder.createDatabase({
+      types: [Tag.Tag, Subscription.Subscription, Subscription.Post, StateMap.StateMap, TagIndex.TagIndex],
+    });
+    const subscription = db.add(Subscription.makeSubscription({ name: 'Test', url: 'https://example.com' }));
+    const post = db.add(Obj.make(Subscription.Post, { source: Ref.make(subscription) }));
+    await db.flush();
+
+    const registry = Registry.make();
+    const atom = postReadAtom(post);
+    let fireCount = 0;
+    registry.subscribe(atom, () => fireCount++, { immediate: true });
+    expect(fireCount).toBe(1);
+
+    Subscription.setReadAt(subscription, post.id, new Date().toISOString());
+    await db.flush();
+    expect(fireCount).toBe(2);
+    expect(registry.get(atom).readAt).toBeDefined();
+  });
+
+  test('does not fire when a sibling post is marked read', async ({ expect }) => {
+    const { db } = await builder.createDatabase({
+      types: [Tag.Tag, Subscription.Subscription, Subscription.Post, StateMap.StateMap, TagIndex.TagIndex],
+    });
+    const subscription = db.add(Subscription.makeSubscription({ name: 'Test', url: 'https://example.com' }));
+    const postA = db.add(Obj.make(Subscription.Post, { source: Ref.make(subscription) }));
+    const postB = db.add(Obj.make(Subscription.Post, { source: Ref.make(subscription) }));
+    await db.flush();
+
+    const registry = Registry.make();
+    const atomA = postReadAtom(postA);
+    let fireCount = 0;
+    registry.subscribe(atomA, () => fireCount++, { immediate: true });
+    expect(fireCount).toBe(1);
+
+    Subscription.setReadAt(subscription, postB.id, new Date().toISOString());
+    await db.flush();
+    expect(fireCount).toBe(1); // postA's readAt unchanged — should not re-fire.
+  });
+
+  test('does not fire when an unrelated subscription field changes', async ({ expect }) => {
+    const { db } = await builder.createDatabase({
+      types: [Tag.Tag, Subscription.Subscription, Subscription.Post, StateMap.StateMap, TagIndex.TagIndex],
+    });
+    const subscription = db.add(Subscription.makeSubscription({ name: 'Test', url: 'https://example.com' }));
+    const post = db.add(Obj.make(Subscription.Post, { source: Ref.make(subscription) }));
+    await db.flush();
+
+    const registry = Registry.make();
+    const atom = postReadAtom(post);
+    let fireCount = 0;
+    registry.subscribe(atom, () => fireCount++, { immediate: true });
+    expect(fireCount).toBe(1);
+
+    Obj.update(subscription, (subscription) => {
+      subscription.name = 'Updated';
+    });
+    await db.flush();
+    expect(fireCount).toBe(1); // name change — should not re-fire.
+  });
+});
+
+describe('postTagsAtom', () => {
+  let builder: EchoTestBuilder;
+
+  beforeEach(async () => {
+    builder = await new EchoTestBuilder().open();
+  });
+
+  afterEach(async () => {
+    await builder.close();
+  });
+
+  test('fires when this post is starred', async ({ expect }) => {
+    const { db } = await builder.createDatabase({
+      types: [Tag.Tag, Subscription.Subscription, Subscription.Post, StateMap.StateMap, TagIndex.TagIndex],
+    });
+    const subscription = db.add(Subscription.makeSubscription({ name: 'Test', url: 'https://example.com' }));
+    const post = db.add(Obj.make(Subscription.Post, { source: Ref.make(subscription) }));
+    await db.flush();
+
+    const registry = Registry.make();
+    const atom = postTagsAtom(post);
+    let fireCount = 0;
+    registry.subscribe(atom, () => fireCount++, { immediate: true });
+    expect(fireCount).toBe(1);
+    expect(registry.get(atom).starred).toBe(false);
+
+    await Subscription.setTag(subscription, post.id, db, 'starred', true);
+    await db.flush();
+    // tagUrisAtom fires once when Tag.Tag is created (intermediate re-run, still starred=false),
+    // then Obj.subscribe fires when subscription.tags is mutated (starred=true, setSelf).
+    expect(fireCount).toBe(3);
+    expect(registry.get(atom).starred).toBe(true);
+  });
+
+  test('does not fire when a sibling post is starred (after tag warm-up)', async ({ expect }) => {
+    const { db } = await builder.createDatabase({
+      types: [Tag.Tag, Subscription.Subscription, Subscription.Post, StateMap.StateMap, TagIndex.TagIndex],
+    });
+    const subscription = db.add(Subscription.makeSubscription({ name: 'Test', url: 'https://example.com' }));
+    const postA = db.add(Obj.make(Subscription.Post, { source: Ref.make(subscription) }));
+    const postB = db.add(Obj.make(Subscription.Post, { source: Ref.make(subscription) }));
+    // Pre-warm the Tag.Tag so tagUrisAtom is already populated when the atom subscribes.
+    // Without this, the first setTag creates Tag.Tag → tagUrisAtom fires → one extra body re-run.
+    await Subscription.setTag(subscription, postA.id, db, 'starred', true);
+    await Subscription.setTag(subscription, postA.id, db, 'starred', false);
+    await db.flush();
+
+    const registry = Registry.make();
+    const atomA = postTagsAtom(postA);
+    let fireCount = 0;
+    registry.subscribe(atomA, () => fireCount++, { immediate: true });
+    expect(fireCount).toBe(1);
+
+    await Subscription.setTag(subscription, postB.id, db, 'starred', true);
+    await db.flush();
+    expect(fireCount).toBe(1); // postA's tags unchanged — should not re-fire.
+  });
+});
+
+describe('postCurationAtom', () => {
+  let builder: EchoTestBuilder;
+
+  beforeEach(async () => {
+    builder = await new EchoTestBuilder().open();
+  });
+
+  afterEach(async () => {
+    await builder.close();
+  });
+
+  test('fires when this post gets a curated snippet', async ({ expect }) => {
+    const { db } = await builder.createDatabase({
+      types: [
+        Tag.Tag,
+        Feed.Feed,
+        Subscription.Subscription,
+        Subscription.Post,
+        Magazine.Magazine,
+        StateMap.StateMap,
+        TagIndex.TagIndex,
+      ],
+    });
+    const subscription = db.add(Subscription.makeSubscription({ name: 'Test', url: 'https://example.com' }));
+    const post = db.add(Obj.make(Subscription.Post, { source: Ref.make(subscription) }));
+    const magazine = db.add(Magazine.make({ feeds: [Ref.make(subscription)] }));
+    await db.flush();
+
+    const registry = Registry.make();
+    const atom = postCurationAtom(Data.tuple(post, magazine));
+    let fireCount = 0;
+    registry.subscribe(atom, () => fireCount++, { immediate: true });
+    expect(fireCount).toBe(1);
+    expect(registry.get(atom).snippet).toBeUndefined();
+
+    Magazine.patchPostState(magazine, post.id, { snippet: 'A great article about AI.' });
+    await db.flush();
+    expect(fireCount).toBe(2);
+    expect(registry.get(atom).snippet).toBe('A great article about AI.');
+  });
+
+  test('does not fire when a sibling post gets a snippet', async ({ expect }) => {
+    const { db } = await builder.createDatabase({
+      types: [
+        Tag.Tag,
+        Feed.Feed,
+        Subscription.Subscription,
+        Subscription.Post,
+        Magazine.Magazine,
+        StateMap.StateMap,
+        TagIndex.TagIndex,
+      ],
+    });
+    const subscription = db.add(Subscription.makeSubscription({ name: 'Test', url: 'https://example.com' }));
+    const postA = db.add(Obj.make(Subscription.Post, { source: Ref.make(subscription) }));
+    const postB = db.add(Obj.make(Subscription.Post, { source: Ref.make(subscription) }));
+    const magazine = db.add(Magazine.make({ feeds: [Ref.make(subscription)] }));
+    await db.flush();
+
+    const registry = Registry.make();
+    const atomA = postCurationAtom(Data.tuple(postA, magazine));
+    let fireCount = 0;
+    registry.subscribe(atomA, () => fireCount++, { immediate: true });
+    expect(fireCount).toBe(1);
+
+    Magazine.patchPostState(magazine, postB.id, { snippet: 'Sibling snippet.' });
+    await db.flush();
+    expect(fireCount).toBe(1); // postA's curation unchanged — should not re-fire.
+  });
+
+  test('does not fire when an unrelated magazine field changes', async ({ expect }) => {
+    const { db } = await builder.createDatabase({
+      types: [
+        Tag.Tag,
+        Feed.Feed,
+        Subscription.Subscription,
+        Subscription.Post,
+        Magazine.Magazine,
+        StateMap.StateMap,
+        TagIndex.TagIndex,
+      ],
+    });
+    const subscription = db.add(Subscription.makeSubscription({ name: 'Test', url: 'https://example.com' }));
+    const post = db.add(Obj.make(Subscription.Post, { source: Ref.make(subscription) }));
+    const magazine = db.add(Magazine.make({ feeds: [Ref.make(subscription)] }));
+    await db.flush();
+
+    const registry = Registry.make();
+    const atom = postCurationAtom(Data.tuple(post, magazine));
+    let fireCount = 0;
+    registry.subscribe(atom, () => fireCount++, { immediate: true });
+    expect(fireCount).toBe(1);
+
+    Obj.update(magazine, (magazine) => {
+      magazine.name = 'Updated Magazine';
+    });
+    await db.flush();
+    expect(fireCount).toBe(1); // name change — should not re-fire.
+  });
+});
+
+describe('postDisplayAtom', () => {
+  let builder: EchoTestBuilder;
+
+  beforeEach(async () => {
+    builder = await new EchoTestBuilder().open();
+  });
+
+  afterEach(async () => {
+    await builder.close();
+  });
+
+  test('prefers agent snippet over RSS description', async ({ expect }) => {
+    const { db } = await builder.createDatabase({
+      types: [
+        Tag.Tag,
+        Feed.Feed,
+        Subscription.Subscription,
+        Subscription.Post,
+        Magazine.Magazine,
+        StateMap.StateMap,
+        TagIndex.TagIndex,
+      ],
+    });
+    const subscription = db.add(Subscription.makeSubscription({ name: 'Feed', url: 'https://example.com' }));
+    const post = db.add(
+      Obj.make(Subscription.Post, { source: Ref.make(subscription), description: 'RSS description.' }),
+    );
+    const magazine = db.add(Magazine.make({ feeds: [Ref.make(subscription)], posts: [Ref.make(post)] }));
+    await db.flush();
+
+    const registry = Registry.make();
+    const atom = postDisplayAtom(Data.tuple(post, magazine));
+    registry.subscribe(atom, () => {}, { immediate: true });
+
+    // Before curation: falls back to RSS description.
+    expect(registry.get(atom).snippet).toContain('RSS description');
+
+    Magazine.patchPostState(magazine, post.id, { snippet: 'Agent snippet.' });
+    await db.flush();
+
+    expect(registry.get(atom).snippet).toBe('Agent snippet.');
+  });
+
+  test('fires on read state change', async ({ expect }) => {
+    const { db } = await builder.createDatabase({
+      types: [
+        Tag.Tag,
+        Feed.Feed,
+        Subscription.Subscription,
+        Subscription.Post,
+        Magazine.Magazine,
+        StateMap.StateMap,
+        TagIndex.TagIndex,
+      ],
+    });
+    const subscription = db.add(Subscription.makeSubscription({ name: 'Feed', url: 'https://example.com' }));
+    const post = db.add(Obj.make(Subscription.Post, { source: Ref.make(subscription) }));
+    const magazine = db.add(Magazine.make({ feeds: [Ref.make(subscription)], posts: [Ref.make(post)] }));
+    await db.flush();
+
+    const registry = Registry.make();
+    const atom = postDisplayAtom(Data.tuple(post, magazine));
+    let fireCount = 0;
+    registry.subscribe(atom, () => fireCount++, { immediate: true });
+    expect(registry.get(atom).read).toBe(false);
+
+    Subscription.setReadAt(subscription, post.id, new Date().toISOString());
+    await db.flush();
+    expect(registry.get(atom).read).toBe(true);
+    expect(fireCount).toBe(2);
+  });
+});

package/src/atoms/index.ts

@@ -0,0 +1,10 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export * from './magazine-posts';
+export * from './post-content';
+export * from './post-curation';
+export * from './post-display';
+export * from './post-read';
+export * from './post-tags';