diff --git a/.changeset/checkpointed-registry-ingestion.md b/.changeset/checkpointed-registry-ingestion.md
new file mode 100644
index 00000000..c2e17ce0
--- /dev/null
+++ b/.changeset/checkpointed-registry-ingestion.md
@@ -0,0 +1,14 @@
+---
+"chkit": patch
+"@chkit/plugin-ingest": patch
+---
+
+Allow registry resources to declare cursor checkpoints and timestamp windows alongside full scans. Upgrade the eight raw API integrations with provider-specific sync tokens, overlapping incremental ranges, and safe restart recovery, while preserving historical registry releases. Use one pipeline per installation with independent resource or configured collection streams, editable configuration, injectable clients, and meaningful resource readers. Attio creates independent object-type and list streams using existing full-sync pagination, with People and Companies enabled by default. GitHub separates eight raw resource types per repository, including independent issues, PRs, comments, reviews, and SHA/message commits with warehouse join keys; it no longer fetches PR files or assembles child arrays. Resources without reliable change filters use built-in full-sync completion; Calendar tokens and Lemlist activity intervals retain their necessary recovery state. Meet and Slack use recent rediscovery and coarse completed-page checkpoints, replaying unfinished children without retained-work queues. Circleback independently reads meetings, complete transcript snapshots, action items, people, and companies with replay-safe full pagination.
+
+Update the ingestion authoring skill with the registry sync quality bar, provider capability selection, meaningful stream boundaries, normalized raw ingestion by default with transformations and joins in ClickHouse, existing pagination/checkpoint primitives, coarse replay where affordable, explicit freshness coverage, durable recovery rules, and required failure/restart verification.
+
+Linear syncs issues, comments, projects, project updates, cycles, users, teams, issue relations, and issue history into nine independent raw destinations. Seven resources own update-time windows; relations and history use complete full reads, with history discovering all issues independently of parent progress. Preserve raw relationship IDs and complete issue label names as strings, and leave joins and metrics to ClickHouse. Populate new destinations independently and migrate retained legacy nested comments deliberately.
+
+Treat repeated pagination continuations as permanent provider-protocol errors so reader retries cannot repeatedly replay a cyclic collection.
+
+Add per-integration changelog metadata, shown in registry inspection and integration guides. Keep one draft release per integration in each PR, refresh it in place until merge, and validate release artifacts against the PR base to protect published versions and changelog history.
diff --git a/.changeset/circleback-independent-raw-resources.md b/.changeset/circleback-independent-raw-resources.md
new file mode 100644
index 00000000..ff0ffe89
--- /dev/null
+++ b/.changeset/circleback-independent-raw-resources.md
@@ -0,0 +1,5 @@
+---
+"chkit": patch
+---
+
+Split Circleback into independently selectable meetings, meeting transcripts, action items, people, and companies with raw destinations and replay-safe full reads. Cover all verified action-item statuses and ownership, keep transcript availability separate from successful content, retrieve complete same-resource person/company details, and represent applied tags as string names. Keep joins and transformations in ClickHouse and consolidate these changes into the integration's existing draft release.
diff --git a/.changeset/google-calendar-raw-events.md b/.changeset/google-calendar-raw-events.md
new file mode 100644
index 00000000..f92d99b8
--- /dev/null
+++ b/.changeset/google-calendar-raw-events.md
@@ -0,0 +1,5 @@
+---
+"chkit": patch
+---
+
+Document and verify Google Calendar's events-only raw contract: native nested event fields remain unchanged, and sparse cancellations replace recurring exceptions under stable identities. Preserve the existing recoverable page and sync-token protocol in the integration's single draft release.
diff --git a/.changeset/google-meet-core-raw-resources.md b/.changeset/google-meet-core-raw-resources.md
new file mode 100644
index 00000000..f5c68b1b
--- /dev/null
+++ b/.changeset/google-meet-core-raw-resources.md
@@ -0,0 +1,5 @@
+---
+"chkit": patch
+---
+
+Add independent Google Meet participant, participant-session, and recording metadata streams alongside conferences, transcripts, and transcript entries. Rediscover recent conferences with a 24-hour lookback and ordinary nested pagination. Checkpoint completed discovery pages and replay their unfinished children instead of retaining conferences or per-child positions. Keep scoped identities, date-bound backfills, and bounded token recovery in the existing draft release. Recording rows retain links without downloading media; artifacts that appear after a conference leaves the lookback require an explicit backfill.
diff --git a/.changeset/lemlist-core-raw-resources.md b/.changeset/lemlist-core-raw-resources.md
new file mode 100644
index 00000000..09bdeda2
--- /dev/null
+++ b/.changeset/lemlist-core-raw-resources.md
@@ -0,0 +1,5 @@
+---
+"chkit": patch
+---
+
+Expand Lemlist to seven independent raw streams: campaigns, contacts, companies, campaign leads, activities, inbox conversations, and inbox messages. Use complete campaign-lead exports and full contact payloads, keep inbox reads read-only, and retain acknowledged incremental activity intervals. Preserve native relationship keys for warehouse joins and refresh the single integration draft release.
diff --git a/.changeset/page-aware-pagination.md b/.changeset/page-aware-pagination.md
new file mode 100644
index 00000000..95ec57c0
--- /dev/null
+++ b/.changeset/page-aware-pagination.md
@@ -0,0 +1,7 @@
+---
+"@chkit/plugin-ingest": patch
+---
+
+Change `paginate()` to yield full `{ items, next, metadata? }` pages, including empty and terminal pages. This is a breaking return-type change: readers must consume `page.items` instead of treating a page as an item array. Metadata passes through unchanged and readers can explicitly map it to checkpoint state, which the existing executor commits after destination acknowledgement. Reject repeated continuations before yielding candidate progress, including a continuation back to the initial cursor. Migrate registry readers and use page metadata for Google Calendar sync-token checkpoints without changing their saved state format.
+
+Simplify Calendar token recovery into the same checkpointed pagination loop and Slack temporary message pagination through full pages with native completion metadata. Remove provider cursor-equality checks now covered by the shared paginator, retaining provider validation, durable timestamp frontiers, and bounded recovery.
diff --git a/.changeset/slack-independent-raw-messages.md b/.changeset/slack-independent-raw-messages.md
new file mode 100644
index 00000000..0f0e42f9
--- /dev/null
+++ b/.changeset/slack-independent-raw-messages.md
@@ -0,0 +1,5 @@
+---
+"chkit": patch
+---
+
+Document Slack's three raw resources and verify messages-first ingestion and metadata execution that leaves message progress unchanged. Default message bootstrap and overlap to 24 hours, with optional explicit historical bootstrap and isolated backfills. Complete each history page's replies before checkpointing its timestamp frontier; interruptions replay the unfinished page instead of retaining thread queues. Remove automatic historical reconciliation: edits and late replies on roots outside the chosen window are excluded. Replies remain individual native messages joined through thread references in ClickHouse.
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 26104484..8911f652 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -15,6 +15,8 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
 
       - name: Setup Bun
         uses: ./.github/actions/setup
diff --git a/CLAUDE.md b/CLAUDE.md
index 7c275d5d..61aec71a 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -101,6 +101,12 @@ A test may skip itself on `CHKIT_E2E_TARGET=obsessiondb` only for a known Obsess
 
 Uses changesets. Run `bun run changeset` to create a changeset, then `bun run version-packages` to bump versions.
 
+### Registry integration releases
+
+Keep at most one new release artifact per integration in a PR. Versions already on the merged base are immutable; artifacts added by the unmerged PR are drafts. Further edits refresh that same draft version and its current `meta.chkit.changelog` entry, without adding intermediate versions. Preserve earlier released changelog entries.
+
+Regenerate with `bun run registry:release -- --base origin/main <provider>` and validate with `bun run check:registry-releases -- --base origin/main`; use the actual PR base if different. Omit provider names to refresh all drafts. Do not hand-edit generated artifacts. `bun run verify` checks release history and source/artifact agreement.
+
 ### Releasing (GitHub Actions)
 
 Versions are semver; all 10 published packages share one version (a changesets `fixed` group). A release takes two steps, so the version reaches git before npm and any failure can be re-run:
diff --git a/apps/docs/src/components/RegistryApps.astro b/apps/docs/src/components/RegistryApps.astro
index 0a73066a..7f50caf6 100644
--- a/apps/docs/src/components/RegistryApps.astro
+++ b/apps/docs/src/components/RegistryApps.astro
@@ -1,5 +1,5 @@
 ---
-import { registryApps } from '../data/registry';
+import { registryApps, registryStrategyLabel } from '../data/registry';
 ---
 
 <ul class="registry-apps not-content" aria-label="Available ClickHouse integrations">
@@ -10,7 +10,7 @@ import { registryApps } from '../data/registry';
 					<div class="app-logo">{app.logo ? <img src={app.logo} alt={`${app.title} logo`} width="37" height="30" loading="lazy" /> : <span aria-hidden="true">{app.title.slice(0, 1)}</span>}</div>
 					<div>
 						<h3><a href={app.href}>{app.title}</a></h3>
-						<p class="app-meta">{app.resources.length} resources · {app.strategies.map((strategy) => strategy === 'full' ? 'Full reads' : strategy).join(', ')} · {app.language === 'typescript' ? 'TypeScript' : app.language}</p>
+						<p class="app-meta">{app.resources.length} resources · {app.strategies.map(registryStrategyLabel).join(', ')} · {app.language === 'typescript' ? 'TypeScript' : app.language}</p>
 					</div>
 					<span class="app-version">v{app.version}</span>
 				</div>
diff --git a/apps/docs/src/components/RegistryReference.astro b/apps/docs/src/components/RegistryReference.astro
index 95f53a76..afff6585 100644
--- a/apps/docs/src/components/RegistryReference.astro
+++ b/apps/docs/src/components/RegistryReference.astro
@@ -1,5 +1,5 @@
 ---
-import { registryApps, type RegistryReferenceSection } from '../data/registry';
+import { registryApps, registryStrategyLabel, type RegistryReferenceSection } from '../data/registry';
 
 interface Props {
 	name: string;
@@ -22,7 +22,7 @@ if (!app) throw new Error(`Unknown registry app: ${name}`);
 			<tr><td>Environment variables</td><td>{app.authentication?.env.map((env, index) => <>{index > 0 && ', '}<code>{env}</code></>) ?? 'See provider setup'}</td></tr>
 			<tr><td>ClickHouse</td><td><code>{app.clickhouse}</code></td></tr>
 			<tr><td>Coverage</td><td>{app.resources.length} synced resources, {app.views?.length ?? 0} derived views</td></tr>
-			<tr><td>Sync strategy</td><td>{app.strategies.map((strategy) => strategy === 'full' ? 'Full read on every run' : strategy).join(', ')}</td></tr>
+			<tr><td>Sync strategy</td><td>{app.strategies.map(registryStrategyLabel).join(', ')}</td></tr>
 		</tbody>
 	</table>
 )}
@@ -67,3 +67,9 @@ if (!app) throw new Error(`Unknown registry app: ${name}`);
 		</tbody>
 	</table>
 )}
+{section === 'changelog' && app.changelog?.map((release) => (
+	<>
+		<h3>Version {release.version}</h3>
+		<ul>{release.changes.map((change) => <li>{change}</li>)}</ul>
+	</>
+))}
diff --git a/apps/docs/src/content/docs/api-sync/agent-skill.md b/apps/docs/src/content/docs/api-sync/agent-skill.md
index 5c111198..92d41a2a 100644
--- a/apps/docs/src/content/docs/api-sync/agent-skill.md
+++ b/apps/docs/src/content/docs/api-sync/agent-skill.md
@@ -42,10 +42,11 @@ Include provider documentation, example responses, freshness needs, and any rest
 
 ## Skill scope
 
-The skill covers the authoring steps and requirements for bounded readers, checkpoint ordering, write identity, and scheduling. Use the linked docs for complete examples and tradeoffs.
+The skill covers bounded readers, provider-specific sync strategies, durable checkpoint ordering, write identity, and scheduling. For official registry integrations, it requires a source contract and recovery design, raw payload preservation, explicit freshness coverage, and portable interruption/replay tests. Prefer coarse checkpoints and replay when affordable; reconcile older changes when the chosen coverage requires it. Sync tokens, timestamp windows, and checkpointed full scans follow the provider's actual capabilities. Use the linked docs for complete examples and tradeoffs.
 
 ## Related pages
 
 - [Destinations and transformations](/api-sync/destinations/): choose storage and mapping for the source.
 - [Quickstart](/api-sync/quickstart/): a working first source.
+- [Publish a registry](/api-sync/registry-authoring/): metadata, portable tests, and immutable releases.
 - [For AI agents](/ai-agents/): general chkit setup and schema workflows.
diff --git a/apps/docs/src/content/docs/api-sync/incremental-syncs.md b/apps/docs/src/content/docs/api-sync/incremental-syncs.md
index 4d692050..c247b572 100644
--- a/apps/docs/src/content/docs/api-sync/incremental-syncs.md
+++ b/apps/docs/src/content/docs/api-sync/incremental-syncs.md
@@ -42,7 +42,7 @@ const tickets = defineStream({
       },
     })
     for await (const page of pages) {
-      yield { rows: rawRows(page, (ticket) => ticket.id) }
+      yield { rows: rawRows(page.items, (ticket) => ticket.id) }
     }
   },
 })
@@ -65,10 +65,10 @@ Use `timestampWindow({ from })` when `start` and `overlapMs` do not express the
 
 Choose `cursorState` when the provider guarantees resumption across runs. `parse` validates the saved state. `context.state` and `context.selection` expose it to the reader; neither contains uncommitted progress.
 
-This standalone fixture demonstrates a provider with stable, increasing change sequence numbers. Replace the fixture read with a documented provider operation inside `context.attempt`:
+This standalone fixture demonstrates a provider with stable, increasing change sequence numbers. `paginate` owns each request attempt and exposes its candidate checkpoint in metadata. Replace the fixture body of `fetchPage` with a documented provider operation, forwarding its signal:
 
 ```ts
-import { cursorState, definePipeline, defineStream, rawRows, rawTable } from '@chkit/plugin-ingest'
+import { cursorState, definePipeline, defineStream, paginate, rawRows, rawTable } from '@chkit/plugin-ingest'
 
 const changes = [
   { sequence: 1, id: 'a', subject: 'Opened' },
@@ -90,16 +90,24 @@ const tickets = defineStream({
     },
   }),
   async *read(context) {
-    let after = context.state ?? 0
-    while (true) {
-      const page = await context.attempt(async (signal) => {
+    const pages = paginate({
+      context,
+      initial: context.state ?? 0,
+      label: 'read changes',
+      fetchPage: async (after = 0, signal) => {
         signal.throwIfAborted()
-        return changes.filter((change) => change.sequence > after).slice(0, 2)
-      }, { label: 'read changes' })
-      const last = page.at(-1)
-      if (!last) return
-      yield { rows: rawRows(page, (ticket) => ticket.id), state: last.sequence }
-      after = last.sequence
+        const remaining = changes.filter((change) => change.sequence > after)
+        const items = remaining.slice(0, 2)
+        const checkpoint = items.at(-1)?.sequence ?? after
+        return {
+          items,
+          next: remaining.length > items.length ? checkpoint : undefined,
+          metadata: { checkpoint },
+        }
+      },
+    })
+    for await (const page of pages) {
+      yield { rows: rawRows(page.items, (ticket) => ticket.id), state: page.metadata?.checkpoint }
     }
   },
 })
@@ -109,6 +117,15 @@ export const fixture = definePipeline({ id: 'fixture', streams: [tickets] })
 
 `state` is the complete resume state safe after all rows through that chunk are saved. It can be a scalar or an object such as `{ snapshot, cursor }`. Omit it if the source cannot guarantee a safe boundary. An empty chunk with state can record progress when no destination rows are needed.
 
+`next` and checkpoint metadata have separate jobs. For a provider sync-token protocol, the page adapter can return:
+
+| Page | `next` request continuation | `metadata.checkpoint` candidate |
+| --- | --- | --- |
+| More pages remain | `'page-2'` | `{ syncToken: 'sync-old', pageToken: 'page-2' }` |
+| Final page, possibly empty | `undefined` | `{ syncToken: 'sync-new' }` |
+
+Start a resumed pagination sequence with the saved `pageToken` and keep its input `syncToken` fixed. Only the acknowledged terminal candidate replaces that sync token and clears the page position. Construct fresh complete checkpoint objects; metadata alone does not commit progress. [Google Calendar](/integrations/google-calendar/) implements this protocol with `paginate`, `cursorState`, and provider-specific expiry recovery.
+
 A pagination token may expire between runs. Confirm expiration, snapshot lifetime, ordering, and terminal-token behavior before storing one. Resumption must not skip unfinished pages or repeatedly reuse an expired cursor.
 
 ## Custom strategies and changes to state
diff --git a/apps/docs/src/content/docs/api-sync/operations.md b/apps/docs/src/content/docs/api-sync/operations.md
index 295c16d0..237efd16 100644
--- a/apps/docs/src/content/docs/api-sync/operations.md
+++ b/apps/docs/src/content/docs/api-sync/operations.md
@@ -100,7 +100,7 @@ chkit ingest status --tag pipeline:helpdesk --json
 | Symptom | Check |
 |---|---|
 | No pipeline / no matching streams | Entry exports and exact tag spelling |
-| No checkpoint after a successful run | Full syncs have no incremental bookmark |
+| No checkpoint after a successful run | The bundled `fullSync()` strategy has no checkpoint; custom full-scan strategies may record completion |
 | Window restarts from the beginning | Timestamp progress commits after the whole window; reduce work or use safe intermediate provider state |
 | Duplicated logical records | Destination keys/versioning, query reconciliation, deduplication settings, and volatile mapped fields |
 | Incompatible checkpoint | Strategy ID/version or state format changed |
diff --git a/apps/docs/src/content/docs/api-sync/readers.md b/apps/docs/src/content/docs/api-sync/readers.md
index 8175988e..d4be3601 100644
--- a/apps/docs/src/content/docs/api-sync/readers.md
+++ b/apps/docs/src/content/docs/api-sync/readers.md
@@ -46,18 +46,15 @@ export async function fetchTicketPage(
 
 This helper performs one request. Call it through `context.attempt` or from `paginate`'s `fetchPage` callback, as shown in [Incremental syncs](/api-sync/incremental-syncs/#timestamp-windows). Validate untrusted response shapes at the source boundary in production; a TypeScript assertion does not validate JSON.
 
-## Pagination is not a checkpoint
+## Pages and checkpoint metadata
 
-Use `paginate` when only the items matter. It supports an `initial` continuation, yields nonempty item arrays, and stops when `next` is `undefined` or `null`. It rejects repeated continuations to avoid infinite loops.
+`paginate` yields the complete `{ items, next, metadata? }` returned by `fetchPage`, including empty and terminal pages. Read rows from `page.items`. `initial` and `next` support offset, string-token, and compound-object continuations; `next: undefined` ends pagination. Repeated continuations, including a return to `initial`, fail with `IngestConfigError` before the invalid page reaches the reader.
 
-A page cursor can be temporary, tied to one snapshot, or expire before the next run. Only persist it with `cursorState` when the provider guarantees it is valid for later executions. Otherwise page through a timestamp window and commit progress after that whole window succeeds.
-
-<details>
-<summary>When a manual pagination loop is needed</summary>
+`next` controls the next request. `metadata` carries provider details such as a candidate checkpoint, replacement sync token, or page identity. The helper preserves metadata without interpreting or persisting it. With `cursorState`, explicitly map a safe, complete checkpoint from the page into `SourceChunk.state`; the executor commits it after the rows are saved. Empty pages can carry meaningful progress through the same path. See the complete [provider cursor example](/api-sync/incremental-syncs/#provider-cursors-and-compound-state).
 
-Use a manual loop when page metadata must become a chunk `id` or durable `state`, or when an empty page carries meaningful progress. The helper yields item arrays, so it does not expose the returned continuation to the consumer or persist it as a checkpoint. Wrap each manual page request in `context.attempt`.
+A page cursor can be temporary, tied to one snapshot, or expire before the next run. Only persist it with `cursorState` when the provider guarantees it is valid for later executions. Otherwise page through a timestamp window and commit progress after that whole window succeeds.
 
-</details>
+For a sync-token API, a nonterminal page can retain the input sync token and save its next-page position in metadata. Its terminal page has no `next`, but can carry a replacement sync token. Metadata and pagination therefore have independent types: `paginate<TItem, TCursor, TMetadata>`. Protocol-specific token recovery remains the reader's responsibility; use `context.attempt` for requests outside `paginate` and avoid wrapping its `fetchPage` in another attempt.
 
 ## Bound work and separate accounts
 
diff --git a/apps/docs/src/content/docs/api-sync/registry-authoring.md b/apps/docs/src/content/docs/api-sync/registry-authoring.md
index fd2d05e9..8e8e2e4b 100644
--- a/apps/docs/src/content/docs/api-sync/registry-authoring.md
+++ b/apps/docs/src/content/docs/api-sync/registry-authoring.md
@@ -96,20 +96,43 @@ The item name `registry` is reserved because `registry.json` contains the catalo
 | Field under `meta.chkit` | Meaning |
 |---|---|
 | `formatVersion` | Registry metadata format; currently `1` |
-| `version` | Immutable semantic version of this template |
+| `version` | Semantic version of this template; immutable after publication |
+| `changelog` | Newest-first version history with a semantic `version` and nonempty `changes` array per entry; optional for custom and legacy items, required for official current manifests |
 | `language` | Currently `typescript` |
 | `license` | License for the copied source |
 | `documentation` | Optional HTTP(S) URL of the app's integration guide; shown by CLI list and inspect |
 | `logo` | Optional HTTP(S) URL of the app's logo; included in discovery metadata |
 | `chkit`, `ingest`, `clickhouse` | Supported CLI, ingestion package, and ClickHouse version ranges |
 | `root`, `entry`, `exports` | Installation directory, provider entry, and explicit public exports |
-| `resources` | Resource names and descriptions, read scopes, sync strategy (`full`), optional `title`, default `table`, and `endpoints` with `method`, `path`, and provider `documentation` URL |
+| `resources` | Resource names and descriptions, read scopes, sync strategy (`full`, `timestamp`, or `cursor`), optional `title`, default `table`, and `endpoints` with `method`, `path`, and provider `documentation` URL |
 | `authentication` | Authentication `method`, required `env` names, ordered `setup` steps, and the provider's credential setup `documentation` URL |
 | `views` | Derived views with a `name`, source resource `source`, and `description`; these reuse synced records |
 | `sync` | Sync `description`, external `schedule`, and `deletions` behavior |
 | `env` | Environment variable names mapped to example values, such as `{"ATTIO_API_TOKEN": ""}` |
 | `fileHashes` | SHA-256 values keyed by target path; generated by the builder |
 
+Resource strategies describe selection: `full` performs complete scan cycles, including scans with completion checkpoints; `timestamp` selects time windows; `cursor` follows checkpointed provider state, such as a change token or a resumable snapshot traversal. Describe restart behavior, cursor lifetime, and deletion handling in `sync`. Metadata does not configure the runtime strategy. Older strict registry clients accept only `full`; templates advertising new labels must require a CLI version that accepts them.
+
+Keep a cumulative integration changelog in `meta.chkit.changelog`:
+
+```json
+{
+  "version": "0.2.0",
+  "changelog": [
+    {
+      "version": "0.2.0",
+      "changes": ["Give People and Companies independent ingestion streams."]
+    },
+    {
+      "version": "0.1.2",
+      "changes": ["Include fixture tests and expanded authentication and resource metadata."]
+    }
+  ]
+}
+```
+
+The first entry matches the template version, and subsequent versions descend without duplicates. Retain notes for earlier releases, including migration details users need when upgrading. CLI inspect, integration guides, and agent-readable Markdown display this same history. Historical artifacts without the optional field remain valid. Older strict clients reject unknown metadata fields; current templates using `changelog` require a supporting CLI version.
+
 Declare npm dependencies as `package@semver-range`. Every item must include `@chkit/core` and `@chkit/plugin-ingest`. Git URLs, local dependencies, and package-manager aliases are outside this format.
 
 Use blank values for secrets in `env`. Never include credentials in metadata or source artifacts. State resource limitations in the item's description and copied README, including deletion behavior and inaccessible API families.
@@ -203,19 +226,42 @@ registry/
 
 Each `sources/` module keeps a resource's reader and schema together. Shared request behavior stays in `client.ts`; selection and destination settings stay in `config.ts`.
 
+Recommend normalized raw sync by default: sync provider resources as directly as possible into separate raw collections, preserve their fields and structure, and store source and parent keys for relationships. Readers retrieve and checkpoint data with minimal identity/envelope mapping. Perform field transformations, business mappings, enrichment, joins, and denormalization afterward in ClickHouse SQL views, materialized views, or derived tables. Use a shaped ingestion schema or projected/embedded document model when explicitly requested; retain inseparable bounded provider objects as returned.
+
+Use one pipeline per installation or account, with independent streams per resource type or configured collection. Prefer a raw destination per resource type; share one when resource types have the same provider representation and retain an explicit resource discriminator. Attio People and Companies are separate streams sharing a raw records table; individual people remain records. A child reader may enumerate parents to reach a parent-scoped endpoint, but it owns that discovery and its checkpoints; parent publication does not wait for it. GitHub issues, PRs, comments, reviews, and commits follow this model. Pipeline order cannot become a discovery dependency.
+
+Prefer `paginate()` and the bundled incremental strategies. An ordinary full read uses `fullSync()` and the executor's journaled completion, including empty reads; add provider state only for a justified contract such as sync-token promotion, delayed children, or expensive acknowledged parent traversal. Pipeline factories bind supplied configuration to both readers and strategies. Raw table exports remain setup-time schema definitions. Verify installed modular templates at relocated paths so missing transitive files cannot pass source-only tests.
+
+`paginate()` yields full `{ items, next, metadata? }` pages, including empty terminal pages. Readers use `page.items` for raw rows and explicitly map safe checkpoint metadata to chunk `state` with `cursorState`. A sync-token adapter retains the input token during pagination and promotes its terminal replacement only with acknowledged rows. Metadata needs no custom pagination wrapper; `paginate` owns each request attempt and validates continuation cycles before exposing a page. Provider-specific token recovery and parent discovery remain reader responsibilities.
+
+Prefer coarse page or parent checkpoints when rereading unfinished work is affordable. Yield a unit's raw child rows without advancing discovery, then emit a state-only completion boundary with the next parent-page cursor. The executor commits that boundary after the previous rows land; an interrupted unit replays from its saved input under the same bounds. Keep pages small enough to reach a checkpoint within the execution budget. Add child positions only for units whose replay cost prevents progress.
+
+Choose recent lookback and reconciliation from the required freshness and source volume. A small recent window can replace a retained-parent catalog when later changes on older parents are outside the intended coverage. Document that limit explicitly; parent creation or end times are not modification filters for their children. Stable raw IDs and `ReplacingMergeTree(_chkit_ingested_at)` already allow later observations to replace earlier payloads. A body hash or insert-only staging step is not required for ordinary raw updates.
+
 `manifest.json` contains one registry item. Its source paths are relative to the provider directory (for example, `sources/notes.ts`); target paths still use the full consumer path such as `src/integrations/attio/sources/notes.ts`. The repository's catalog loader discovers these provider-local manifests and aggregates them for the build, CLI artifacts, and documentation. `bun scripts/build-registry.ts` builds the official catalog; it does not require a handwritten catalog at the registry root.
 
-Released artifacts are committed under `registry/<name>/releases/<version>.json`. The official CLI reads provider directories and manifests from GitHub and installs those committed release artifacts directly. The documentation build also copies that history into `apps/docs/public/r/<name>/` before building the current catalog and latest aliases. History and the source are colocated without installing release files into consumer projects.
+Released artifacts are committed under `registry/<name>/releases/<version>.json`. The official CLI reads provider directories and manifests from GitHub's `main` branch and installs those release artifacts directly. The documentation build also copies that history into `apps/docs/public/r/<name>/` before building the current catalog and latest aliases. History and the source are colocated without installing release files into consumer projects.
+
+An artifact already present in the PR's merged base is immutable: preserve its exact bytes and path. Each integration contributes at most one new version artifact per PR. Choose its version above the latest merged release when first changing distributed source or metadata; subsequent edits in the same unmerged PR update that draft's source and current changelog entry without another version bump. Intermediate PR revisions do not become separate release artifacts or changelog entries.
+
+Regenerate the draft at the same version with the repository's release command:
+
+```sh
+bun run registry:release -- --base origin/main attio
+bun run check:registry-releases -- --base origin/main
+```
+
+The base defaults to `origin/main`; use the actual PR base when it differs. Pass provider names to refresh selected integrations, or omit names to refresh all current drafts. The release command regenerates artifacts from source and refuses to replace versions already in the base. The check rejects changed or deleted published artifacts, multiple new versions for one integration, and a current artifact that does not match its source and manifest. The same draft can be regenerated after every edit, including after it has been committed or pushed to the PR branch. Once merged, further template changes require a new version and changelog entry in another PR.
 
-After validating a new release artifact, copy its immutable file into the provider's `releases/` directory and commit it with the corresponding source and version change. Do not hand-edit the artifact or commit generated latest aliases. Adding a provider or template version does not require an npm package release; changes to CLI behavior do. The docs build also publishes a static catalog at `https://chkit.obsessiondb.com/r/registry.json` for web and custom-registry use.
+Commit the generated draft with its source, manifest, and changelog updates. Do not hand-edit artifact content or commit generated latest aliases. Adding a provider or template version does not require an npm package release; changes to CLI behavior do. The docs build also publishes a static catalog at `https://chkit.obsessiondb.com/r/registry.json` for web and custom-registry use.
 
 ## Add an app to the official documentation
 
-Each provider declared in `registry/<name>/manifest.json` has a guide at `apps/docs/src/content/docs/integrations/<name>.md` or `.mdx`. Set its title to `Integrating ClickHouse with <App title>` and write a specific one-sentence description. Give the sidebar a short app label.
+Each provider declared in `registry/<name>/manifest.json` has an MDX guide at `apps/docs/src/content/docs/integrations/<name>.mdx` so the shared resource and changelog components render. Set its title to `Integrating ClickHouse with <App title>` and write a specific one-sentence description. Give the sidebar a short app label.
 
 Set `meta.chkit.documentation` to `https://chkit.obsessiondb.com/integrations/<name>/`. Every official app requires a provider logo: store the official asset in `apps/docs/public/logos/`, record its source in that directory's `README.md`, and set `meta.chkit.logo` to its full HTTPS URL on the docs site. Preserve the asset's proportions and brand colors.
 
-Every official manifest includes authentication setup steps, resource titles and destination tables, provider endpoint references, derived views, and sync/deletion metadata. Credential setup must explain where an administrator creates a token in the source system, which permissions it requires, and how the execution environment receives it. Link to the provider's current instructions and verify the UI path before publishing.
+Every official manifest includes authentication setup steps, resource titles and destination tables, provider endpoint references, derived views, sync/deletion metadata, and an integration changelog. Credential setup must explain where an administrator creates a token in the source system, which permissions it requires, and how the execution environment receives it. Link to the provider's current instructions and verify the UI path before publishing.
 
 Every guide also explains installation, migrations, raw and projected fields, pagination, repeat runs, failure recovery, unsupported data, and scheduling. Verify the claims against the installed readers and schema. A name-swapped introduction alone is not a complete integration guide.
 
@@ -227,9 +273,10 @@ import RegistryReference from '../../../components/RegistryReference.astro';
 <RegistryReference name="attio" section="authentication" />
 <RegistryReference name="attio" section="scopes" />
 <RegistryReference name="attio" section="resources" />
+<RegistryReference name="attio" section="changelog" />
 ```
 
-The other sections are `overview`, `views`, and `sync`. The raw-Markdown build expands the same components for agents. The `resources` section documents every declared resource; handwritten guides must include each exact resource name in backticks. Keep the explanation of provider-specific behavior as prose alongside the generated reference tables.
+The other sections are `overview`, `views`, and `sync`. The raw-Markdown build expands the same components for agents. The `resources` section documents every declared resource; handwritten guides must include each exact resource name in backticks. Include `changelog` under a Changelog heading in each official integration guide. Keep the explanation of provider-specific behavior as prose alongside the generated reference tables.
 
 The [integration list](/integrations/), its agent-readable Markdown, CLI discovery, and search structured data read the same manifest. The docs build checks that every official item has its guide, description, resource coverage, and required local logo asset. New guides also enter site search, the sitemap, and `llms.txt` automatically.
 
@@ -238,7 +285,7 @@ bun run scripts/check-registry-docs.ts
 bun run --cwd apps/docs build
 ```
 
-Preview the app listing and guide in both themes, check the rendered resource tables, and verify the guide appears in `apps/docs/dist/_raw/index.md` and `apps/docs/dist/llms.txt`. Metadata changes require a new immutable registry version just like source changes.
+Preview the app listing and guide in both themes, check the rendered resource tables and changelog, and verify the guide appears in `apps/docs/dist/_raw/index.md` and `apps/docs/dist/llms.txt`. Changes to released template metadata require a new version just like source changes; edits to an unmerged draft update its one version artifact.
 
 ## Related pages
 
diff --git a/apps/docs/src/content/docs/cli/ingest.md b/apps/docs/src/content/docs/cli/ingest.md
index afcd178f..f16ab2bd 100644
--- a/apps/docs/src/content/docs/cli/ingest.md
+++ b/apps/docs/src/content/docs/cli/ingest.md
@@ -62,7 +62,7 @@ Run at most one ingestion process per project and target at a time. See [Schedul
 
 `--backfill <id>` runs the selected streams under the checkpoint namespace `<stream id>#backfill:<id>`, so it never moves the scheduled checkpoint. Reusing an ID resumes that backfill's state. The ID must start with a letter or digit and contain only letters, digits, `_`, `.`, and `-`.
 
-`--from` and `--to` set explicit bounds for `timestampWindow` streams and take precedence over the backfill's watermark. Full-sync and cursor strategies ignore them. Passing `--from` or `--to` without `--backfill` fails with exit code 2.
+`--from` and `--to` set explicit bounds for `timestampWindow` streams and take precedence over the backfill's watermark. The bundled `fullSync()` and `cursorState()` strategies do not interpret them. Custom provider strategies may honor or reject date bounds; see the source's documentation. Passing `--from` or `--to` without `--backfill` fails with exit code 2.
 
 ### `list`
 
diff --git a/apps/docs/src/content/docs/cli/registry.md b/apps/docs/src/content/docs/cli/registry.md
index 1c3805a9..3a8f6305 100644
--- a/apps/docs/src/content/docs/cli/registry.md
+++ b/apps/docs/src/content/docs/cli/registry.md
@@ -37,6 +37,8 @@ Loads and validates a built item. In the official GitHub registry, a bare name r
 
 Inspection exposes the version, copied files, optional test set, dependency requirements, environment examples, resource coverage, scopes, and compatibility metadata. Rich provider metadata also includes credential setup steps, destination tables, API references, derived views, schedules, and deletion behavior. When declared, documentation and logo URLs are included. Human output labels environment values as `.env.example` defaults, shows each resource's scopes and strategy, and prints an install command preserving the selected registry. It does not install files or execute the provider.
 
+When declared, the changelog lists release versions and their changes, newest first. The CLI and integration guide use the same `meta.chkit.changelog` history. Inspecting a pinned version shows the history bundled with that release; older or custom items without changelog metadata remain readable.
+
 ### Build
 
 Reads the source catalog and each declared source file relative to the manifest directory. Validation covers the supported item format, safe paths, unique targets, required dependencies, and explicit entry exports. The builder embeds source content, computes file hashes, and emits:
@@ -114,7 +116,7 @@ chkit registry list --json | jq '{command, schemaVersion, ok, action, items: [.i
 }
 ```
 
-The `resources` array preserves the manifest's resource descriptions, scopes, strategies, and optional titles, destination tables, and API endpoints. `inspect --json` includes provider authentication, derived views, and sync behavior under `item.meta.chkit` when declared. `documentation` and `logo` are omitted for older or custom items without those optional fields.
+The `resources` array preserves the manifest's resource descriptions, scopes, strategies, and optional titles, destination tables, and API endpoints. `inspect --json` includes provider authentication, derived views, sync behavior, and versioned `changelog` entries under `item.meta.chkit` when declared. `documentation`, `logo`, and `changelog` are omitted for older or custom items without those optional fields.
 
 **Inspect:** returns `action: "inspect"`, the resolved `origin`, and the full built `item`, including source contents and `meta.chkit`. To extract only the item identity:
 
@@ -167,7 +169,7 @@ chkit registry inspect attio --json | jq '{command, schemaVersion, ok, action, o
 
 ## Related commands
 
-- [Apps & integrations](/integrations/): browse logos, integration guides, and full sync coverage.
+- [Apps & integrations](/integrations/): browse logos, integration guides, and sync coverage.
 - [`chkit add`](/cli/add/): install a built template into a project.
 - [Provider templates](/api-sync/templates/): source ownership and customization.
 - [Publish a registry](/api-sync/registry-authoring/): format and release guidance.
diff --git a/apps/docs/src/content/docs/integrations/attio.mdx b/apps/docs/src/content/docs/integrations/attio.mdx
index 87f6f730..8e8fb361 100644
--- a/apps/docs/src/content/docs/integrations/attio.mdx
+++ b/apps/docs/src/content/docs/integrations/attio.mdx
@@ -12,7 +12,7 @@ import RegistryReference from '../../../components/RegistryReference.astro';
 
 <img src="/logos/attio.svg" alt="Attio logo" width="37" height="30" style="box-sizing: content-box; padding: 12px; background: white; border-radius: 8px;" />
 
-The [app registry](/integrations/) installs the Attio integration as editable TypeScript source. It includes nine raw tables, nine full-read streams, and three SQL views for people, companies, and deals. Each run reads the selected resources through the Attio REST API and updates their latest observed versions in ClickHouse.
+The [app registry](/integrations/) installs the Attio integration as editable TypeScript source. It includes nine raw tables, separate streams for each configured object type or list, workspace-wide resource streams, and three SQL views for people, companies, and deals. The default configuration creates nine streams writing to seven resource tables; entries and list-attribute readers require configured lists. Every run performs full reads through the Attio REST API and updates the latest observed versions in ClickHouse.
 
 <RegistryReference name="attio" section="overview" />
 
@@ -61,7 +61,7 @@ A workspace admin creates a single-workspace access token in Attio. The followin
 
 <RegistryReference name="attio" section="authentication" />
 
-Grant read access to the categories required by the enabled streams. The full default integration uses all the scopes below. No write scopes are needed.
+Grant read access to the categories required by the enabled streams. The scope table covers all supported resources; list-entry and list-attribute readers run only when `lists` is configured. No write scopes are needed.
 
 <RegistryReference name="attio" section="scopes" />
 
@@ -81,6 +81,8 @@ A token's permissions also determine which data the API returns. A `401` or `403
 
 ## Choose objects, lists, and destination names
 
+One installation pipeline groups the independently selectable resource streams. `createAttioPipeline(config, deps)` snapshots reader settings and configured collections; raw table placement comes from the installation's setup-time `attioConfig` before schema discovery.
+
 The installed `src/integrations/attio/config.ts` starts with:
 
 ```ts
@@ -88,8 +90,8 @@ export interface AttioConfig {
   sourceId: string
   database: string
   tablePrefix: string
-  objects: readonly string[] | undefined
-  lists: readonly string[] | undefined
+  objects: readonly string[]
+  lists: readonly string[]
   pageSize: number
   notesPageSize: number
 }
@@ -98,8 +100,8 @@ export const attioConfig: AttioConfig = {
   sourceId: 'attio.primary',
   database: 'default',
   tablePrefix: 'attio',
-  objects: undefined,
-  lists: undefined,
+  objects: ['people', 'companies'],
+  lists: [],
   pageSize: 500,
   notesPageSize: 50,
 }
@@ -110,12 +112,14 @@ export const attioConfig: AttioConfig = {
 | `sourceId` | Stable, non-secret identity used in stream IDs and row IDs |
 | `database` | Database containing the nine raw tables and three views |
 | `tablePrefix` | Prefix used before `_records_raw`, `_people`, and the other suffixes |
-| `objects` | Object API slugs or UUIDs; `undefined` discovers all accessible objects; `[]` selects none |
-| `lists` | List API slugs or UUIDs; `undefined` discovers all accessible lists; `[]` selects none |
+| `objects` | Explicit object API slugs or UUIDs; default `['people', 'companies']`; creates records and attribute streams per type |
+| `lists` | Explicit list API slugs or UUIDs; default `[]`; creates entries and attribute streams per list |
 | `pageSize` | Positive integer, default `500`, for attributes, records, entries, and tasks |
 | `notesPageSize` | Positive integer up to `50`, default `50`, for notes |
 
-For example, set `objects: ['people', 'companies']` to restrict object metadata, object attributes, and records. List selection similarly controls lists, list attributes, and entries. An unknown or inaccessible configured slug or ID fails visibly. Notes, tasks, and members remain workspace-wide; their readers need separate changes to narrow their coverage.
+Add `deals` or a custom slug to `objects` to collect that type, and add list slugs or IDs to `lists` to collect their entries. Empty arrays disable the corresponding child streams. The objects and lists catalog streams retain all accessible metadata independently of these selections. An unknown or inaccessible configured slug or ID fails its stream visibly. Notes, tasks, and members remain workspace-wide; their readers need separate changes to narrow their coverage.
+
+The pipeline creates its stream graph from these explicit arrays without API discovery. People and Companies have independent readers and journal progress, while both write to `attio_records_raw`. An object stream's ID ends in `.records.<ref>` or `.object_attributes.<ref>`; a list stream's ID ends in `.entries.<ref>` or `.list_attributes.<ref>`. Keep each configured reference stable: switching a slug to an equivalent UUID changes the stream ID.
 
 Keep `sourceId` stable after ingestion starts. For a second workspace, use a distinct source identity and a separate table prefix or database. Copying the directory alone does not isolate pipeline IDs or destination tables.
 
@@ -141,11 +145,11 @@ Queries in this guide use the default database and prefix. Substitute the config
 
 ## All synced resources and records
 
-Each resource has its own stream and raw table. This table lists the returned entity data retained in `raw.data`; the complete API entity is preserved, including additional fields returned by Attio. Fields may be absent or null depending on the resource and workspace configuration.
+Each object type has its own records and attribute streams, and each configured list has its own entries and attribute streams. Catalogs, notes, tasks, and members have workspace-wide streams. Streams for the same resource share a raw table. This table lists the returned entity data retained in `raw.data`; the complete API entity is preserved, including additional fields returned by Attio. Fields may be absent or null depending on the resource and workspace configuration.
 
 <RegistryReference name="attio" section="resources" />
 
-The records stream discovers objects through the [objects API](https://docs.attio.com/rest-api/endpoint-reference/objects/list-objects). It is not restricted to the three objects with packaged views. People, companies, deals, and custom objects all land in the same records table when accessible and selected. A `users` object, when present, contains CRM records; workspace members are collected separately.
+The default records streams read People and Companies separately. Deals and custom objects require explicit slugs or IDs in `objects`; configured types all land in the same records table. A `users` object, when configured, contains CRM records; workspace members are collected separately. The object catalog exposes accessible types without automatically adding readers for them.
 
 Record and entry attributes remain arrays, including multivalued custom fields and relationship references. Returned attribute values keep their accompanying metadata. The integration does not issue separate requests for historical attribute values, select-option catalogs, or status catalogs. See the [record API](https://docs.attio.com/rest-api/endpoint-reference/records/list-records), [entry API](https://docs.attio.com/rest-api/endpoint-reference/entries/list-entries), and [attribute API](https://docs.attio.com/rest-api/endpoint-reference/attributes/list-attributes) for the provider's response shapes.
 
@@ -153,36 +157,40 @@ Notes retain the content and references in the [notes response](https://docs.att
 
 ### API requests and pagination
 
-Every API path in the resource table is relative to `https://api.attio.com/v2`. Object and list placeholders are resolved to IDs by discovery before the child request runs.
+Every API path in the resource table is relative to `https://api.attio.com/v2`. An object/list child reader first resolves its single configured slug or ID with an individual parent request, then fetches that parent's collection.
 
 | Resource | Pagination and filters |
 |---|---|
-| `objects` | Single collection request, then configured object selection |
+| `objects` | Single collection request retaining all accessible objects |
 | `object_attributes` | `limit` and `offset` query parameters; `show_archived=true` |
 | `records` | `limit` and `offset` in JSON body; no record filter or custom sort |
-| `lists` | Single collection request, then configured list selection |
+| `lists` | Single collection request retaining all accessible lists |
 | `list_attributes` | `limit` and `offset` query parameters; `show_archived=true` |
 | `entries` | `limit` and `offset` in JSON body; no entry filter or custom sort |
 | `notes` | `limit` and `offset` query parameters; no parent filter |
 | `tasks` | `limit` and `offset` query parameters; `sort=created_at:asc`; no completion filter |
 | `members` | Single collection request |
 
-Paginated reads start at offset zero, advance by the number of returned entities, and stop when a page is shorter than the requested limit. Each stream discovers its own parents, so running records alone does not depend on the objects stream having run first. The pipeline's stream array does not establish dependencies.
+Paginated reads use the ingestion plugin's `paginate()` helper: they start at offset zero, advance by the number of returned entities, and stop when a page is shorter than the requested limit. Each reader resolves only its configured object/list, so running People records does not depend on the objects catalog having run first. The pipeline's stream array does not establish dependencies.
 
 ## How the sync works
 
 <RegistryReference name="attio" section="sync" />
 
 1. The CLI loads the installed pipeline and selects streams by their tags.
-2. Each reader discovers accessible parents where needed, applies the configured selection, and fetches the collection pages.
+2. Each selected reader resolves its one configured object/list where needed and fetches that collection's pages.
 3. The client validates the response's `data` array and required entity IDs. Record `values` and entry `entry_values` must contain arrays.
 4. The reader wraps each entity with its source identity and relevant parent slug, then assigns a stable composite row ID.
 5. The runtime batches rows and writes them to ClickHouse. The journal records execution and load progress.
 6. SQL views project the raw records and reconcile repeated row IDs at query time with `FINAL`.
 
-### Full reads and freshness
+### Full reads and independent recovery
+
+Every stream uses `fullSync()` and begins its next execution at offset zero. Attio's offsets describe positions in mutable collections and are not durable change cursors. A failed Companies reader therefore replays Companies independently of People; it does not maintain an outer loop over object types or a completed-parent ledger. The executor journal records execution and load completion, including successful empty reads, without custom provider checkpoint state.
 
-All nine streams use full sync. Every run reads from the beginning, including a rerun after failure. The readers do not save pagination offsets or use an incremental modification cursor. A successful run can therefore show no checkpoint in `ingest status`; use the run outcome and destination queries to verify success.
+Child response workspace and parent IDs are checked against the reader's resolved object/list before rows are published. Adding a configured type creates a new stream; removing it stops future reads without removing existing rows. Every scheduled run rereads the selected collections, so edits remain observable.
+
+Upgrading from `0.1.2` to `0.2.0` changes the former combined records, object-attributes, entries, and list-attributes stream IDs to per-type/per-list IDs. Those streams begin with fresh journal progress; the raw table schemas, row IDs for the same `sourceId`, and views are unchanged. Installed files are not automatically overwritten by a newer registry release.
 
 The destination stores the latest **observed** entity. New observations replace earlier observations for the same row identity when ClickHouse reconciles versions. Freshness depends on the external schedule, scan duration, and successful API responses. There are no webhooks or continuous change capture in this integration.
 
@@ -263,7 +271,7 @@ The original entity lives under `data`, so custom provider fields cannot overwri
 
 ## Included people, company, and deal views
 
-The integration creates ordinary SQL views over `attio_records_raw FINAL`, filtered by `object_slug`. These views reuse the records stream; they do not make additional API requests.
+The integration creates ordinary SQL views over `attio_records_raw FINAL`, filtered by `object_slug`. These views project the collected record rows; they do not make additional API requests.
 
 <RegistryReference name="attio" section="views" />
 
@@ -366,7 +374,7 @@ bunx chkit ingest run --tag provider:attio --max-duration 3600 --json
 
 The scheduler supplies the project directory, credentials, runtime, cadence, and concurrency control. Run at most one ingestion process per project and ClickHouse target at a time, including runs that select different tags. Pipeline limits apply within one process and do not lock out another process.
 
-For a narrower run, select the records stream:
+For a narrower run, select all configured records streams:
 
 ```sh
 bunx chkit ingest list --tag provider:attio --tag resource:records
@@ -374,11 +382,11 @@ bunx chkit ingest run --tag provider:attio --tag resource:records --json
 bunx chkit ingest status --tag provider:attio --json
 ```
 
-Repeated tags use AND matching. With the default source ID, `--tag stream:attio.primary.records` selects the same records stream; a custom `sourceId` changes that derived tag.
+Repeated tags use AND matching. Add `--tag object:people` to select only People records. Its record stream carries `resource:records` and `object:people`; its attribute stream carries `resource:object_attributes` and `object:people`. With the default source ID, `--tag stream:attio.primary.records.people` selects the People record stream. List readers carry `list:<ref>` together with `resource:entries` or `resource:list_attributes`.
 
-Inspect the run's per-stream outcomes and error messages. `status` reports committed checkpoints rather than complete run history; full reads have no incremental bookmark. Keep the ingestion journal as durable operational state. After fixing a token, permission, or destination issue, rerun `ingest run`; the Attio reader starts its collection scan again.
+Inspect the run's per-stream outcomes and error messages. `status` reports committed execution state rather than complete run history. Keep the ingestion journal as durable operational state. After fixing a token, permission, or destination issue, rerun the affected stream; its collection starts at offset zero.
 
-Verify a known Attio record against its retained `raw.data`, update that record in a test workspace, rerun the sync, and confirm its view reflects the new observation. A row count alone does not establish full API coverage. Date-range backfill flags do not turn these full-read readers into historical or incremental readers; implementing those behaviors requires a source-specific strategy.
+Verify a known Attio record against its retained `raw.data`, update that record in a test workspace, rerun the sync, and confirm its view reflects the new observation. A row count alone does not establish full API coverage. These full-sync readers ignore date bounds and do not support date-range backfills; implementing historical selection requires a source-specific strategy.
 
 ## Coverage and consistency limits
 
@@ -387,7 +395,7 @@ Verify a known Attio record against its retained `raw.data`, update that record
 | Source record deleted or merged | Previously observed row remains; no deletion or merge reconciliation |
 | Token loses access or a parent is deselected | Existing rows remain in ClickHouse |
 | Source changes during offset pagination | A scan may miss or repeat entities; it is not a provider snapshot |
-| Run stops after some batches | Loaded batches remain visible; the next run scans again |
+| Run stops after some batches | Loaded batches remain visible; the affected stream restarts its collection at offset zero |
 | Older source data loaded later | Later ingestion time wins; no source-version ordering |
 | Complete change history needed | Raw tables reconcile observations and do not form a permanent change log |
 | Meetings, call recordings, transcripts, emails, files, comments, or sequences needed | No readers are included for these resources |
@@ -400,14 +408,14 @@ Deleting or deselecting a source entity does not remove it from a view. Applicat
 
 | File | Responsibility |
 |---|---|
-| `config.ts` | Source identity, destination names, parent selection, page sizes |
-| `client.ts` | Authentication, response validation, pagination, row identity, request pacing |
+| `config.ts` | Source identity, destination names, explicit object/list references, page sizes |
+| `client.ts` | Authentication, response validation, single-parent lookup, pagination, row identity, request pacing |
 | `sources/objects.ts`, `sources/object-attributes.ts` | Object and attribute readers with their raw table schemas |
 | `sources/records.ts` | Record reader, raw records table, people/company/deal views |
 | `sources/lists.ts`, `sources/list-attributes.ts`, `sources/entries.ts` | List resource readers with their raw table schemas |
 | `sources/notes.ts`, `sources/tasks.ts`, `sources/members.ts` | One reader and raw table schema per resource |
 | `tests/attio.test.ts`, `tests/fixtures.ts` | Optional installed tests and mocked API responses |
-| `pipeline.ts` | Enabled streams, resource tags, retries, batching, concurrency |
+| `pipeline.ts` | Per-type/per-list streams, resource tags, retries, batching, concurrency |
 | `index.ts` | Exports that make the pipeline and schema objects discoverable |
 
 Remove a stream entry from `pipeline.ts` to stop collecting a resource. Keep its schema export to preserve existing tables under migration management. Removing a schema export changes the desired database schema and can generate a drop operation; review that migration separately.
@@ -429,6 +437,10 @@ The tests use fixture responses, a mocked HTTP client, and an in-memory destinat
 
 Repository-only packaging and live-database tests remain outside the installed test set. The manifest selects the portable tests explicitly.
 
+## Changelog
+
+<RegistryReference name="attio" section="changelog" />
+
 ## Related pages
 
 - [Integration list](/integrations/): available apps with dedicated ClickHouse integration guides.
diff --git a/apps/docs/src/content/docs/integrations/circleback.mdx b/apps/docs/src/content/docs/integrations/circleback.mdx
index 238c5f44..240ef0d7 100644
--- a/apps/docs/src/content/docs/integrations/circleback.mdx
+++ b/apps/docs/src/content/docs/integrations/circleback.mdx
@@ -1,9 +1,9 @@
 ---
 title: Integrating ClickHouse with Circleback
-description: Install the editable Circleback raw ingestion example.
+description: Sync Circleback meetings, transcripts, action items, people, and companies into independent raw tables.
 ---
 
-The Circleback registry item copies a small API reader and raw ClickHouse tables into a chkit project.
+The Circleback integration runs five independently selectable raw resource streams within one account pipeline.
 
 import RegistryReference from '../../../components/RegistryReference.astro';
 
@@ -17,15 +17,90 @@ bunx chkit migrate --apply
 bunx chkit ingest run --tag provider:circleback
 ```
 
-Set `CIRCLEBACK_API_KEY` in the runtime environment before the ingestion run. Edit `src/integrations/circleback/index.ts` to select meetings or skip transcript requests.
+Set `CIRCLEBACK_API_KEY` in the runtime environment. Create a key through Circleback **Settings → API keys**; see the [authentication reference](https://circleback.ai/docs/api). Native JSON requires ClickHouse 25.3 or later.
+
+Edit `src/integrations/circleback/config.ts` for a stable `sourceId`, meeting ownership, and setup-time database. `ownership: 'All'` includes shared meetings accessible to the authenticated user. People, companies, and action items use the provider's own authenticated-user collections; these endpoints do not promise a full organization export.
+
+`pipeline.ts` composes the five resources, `sources/` owns raw schemas and readers, and `client.ts` handles requests and Link pagination. The factory `createCirclebackPipeline(config, deps)` binds reader configuration and optional HTTP dependencies. Runtime factories use existing exported schemas; storage changes belong before schema discovery and migration generation.
 
 <RegistryReference name="circleback" section="resources" />
 
-## Sync behavior
+## Raw resource boundaries
+
+Meetings, meeting transcripts, action items, people, and companies have separate streams, tables, and journal completion. Each runs alone and owns any required discovery. The transcript reader lists its own eligible meetings; selecting transcripts does not depend on a prior meetings run, and transcript failure does not block raw meeting publication.
+
+Raw provider fields remain under `data` with `source_id` metadata. Provider-returned meeting attendee/action-item summaries and recording URLs remain intact; readers do not assemble a meeting by fetching its child streams. The requested tag projection stores all returned tag names as `string[]`, without a tag-definition stream. No calendar-event or binary-download reader is included.
+
+People fetch one [same-person detail](https://circleback.ai/docs/api/people/get-person) per listed profile and validate the native ID, preserving `externalLinks` and all other returned fields. Companies likewise fetch one detail per domain. These same-resource requests add to full-read cost and require matching access.
+
+```sh
+bunx chkit ingest run --tag provider:circleback --tag resource:meeting_transcripts
+bunx chkit ingest status --tag provider:circleback --json
+```
+
+## Full sync and recovery
+
+Circleback exposes [paginated full collections](https://circleback.ai/docs/api) without a reliable modification feed. Every resource uses native `fullSync()` completion and `paginate()`. Each run exhausts its own provider pages; failed or interrupted reads restart from the first page, and empty successful reads still record completion. Progress never declares successful completion before destination acknowledgement. Loaded rows may remain visible after a later failure.
+
+Link pagination preserves ownership, assignee and completion filters even on cursor-only continuations. Conflicting filters, repeated/unsafe links and malformed provider responses fail visibly. Requests forward cancellation and time out after 30 seconds; executor retries honor HTTP 429 `Retry-After`.
+
+Transcripts are rechecked for every listed meeting, including unchanged old meetings. A meeting's `updatedAt` is not treated as transcript readiness. The [action-item listing](https://circleback.ai/docs/api/action-items/list-action-items) explicitly uses `assigneeType=Anyone` and separately exhausts `PENDING` and `DONE`, the native statuses verified in the [official OpenAPI](https://circleback.ai/docs/api/openapi.json) and [update contract](https://circleback.ai/docs/api/action-items/update-action-item). Unexpected statuses fail instead of silently producing a partial export.
+
+Full reads and status partitions are mutable, not atomic snapshots. A subsequent full run reconciles late availability, edits and status changes. Absent resources remain stored, and inaccessible transcripts do not prove deletion. Full-sync readers ignore date backfill bounds and provide no date-range backfill. Use an external scheduler and one ingestion process per ClickHouse target.
+
+## Identities and joins
+
+Row IDs are `[sourceId, nativeId]` for meetings, action items and people; companies always use `[sourceId, domain]`. Native provider IDs and references remain unchanged in `data`. Keep `source_id` in every cross-resource join.
+
+Company responses preserve listing and [same-company detail](https://circleback.ai/docs/api/companies/get-company) fields. The `company_id` envelope metadata preserves a native list/detail ID or a consistent non-null company ID from returned people. Conflicting numeric IDs fail. Empty companies without a numeric ID remain valid domain-keyed rows with `company_id: null`; no numeric mapping is invented. Join person `data.companyId` to company `company_id` only when known.
+
+Account or filter changes require a new `sourceId` and deliberately configured destinations. Version 0.1.0 used direct meeting JSON and unscoped keys. The 0.2.0 source envelopes, scoped IDs, string tags and additional tables require deliberate migration or reingestion; earlier rows are not automatically rewritten.
+
+## Transcript content and read outcomes
+
+Each transcript has one stable full-content key `[sourceId, meetingId]` and one read-outcome key `[sourceId, meetingId, 'availability']`. The envelope discriminator is `kind: 'transcript'` or `kind: 'availability'`.
+
+HTTP 200 writes the complete raw segment array and an `available` outcome. HTTP 403 or 404 updates only the outcome to `forbidden` or `not_found`, preserving earlier successful text. A successful empty array replaces the prior content with `[]`. Malformed transcript data fails without marking availability successful. Segments have no synthetic IDs.
+
+Select successful snapshots with `raw.kind::String = 'transcript'`; join the latest outcome separately:
+
+```sql
+WITH snapshots AS (
+  SELECT raw.source_id::String AS source_id,
+    raw.meeting_id::String AS meeting_id,
+    JSONExtractRaw(toJSONString(raw), 'data') AS transcript
+  FROM default.circleback_meeting_transcripts_raw FINAL
+  WHERE raw.kind::String = 'transcript'
+), outcomes AS (
+  SELECT raw.source_id::String AS source_id,
+    raw.meeting_id::String AS meeting_id,
+    raw.status::String AS latest_status
+  FROM default.circleback_meeting_transcripts_raw FINAL
+  WHERE raw.kind::String = 'availability'
+)
+SELECT s.source_id, s.meeting_id, s.transcript, o.latest_status
+FROM snapshots AS s
+LEFT JOIN outcomes AS o
+  ON s.source_id = o.source_id AND s.meeting_id = o.meeting_id;
+```
+
+An unavailable latest outcome can coexist with a retained successful snapshot. Neither unavailable status is assumed to mean temporary processing or deletion.
+
+## Test the readers
+
+```sh
+bunx chkit add circleback --with-tests
+bun test src/integrations/circleback/tests/basic.test.ts
+```
+
+The installed fixture suite requires no credentials or live database and verifies independently selected resources, complete status partitions, source/sink replay, late transcripts, retained content, native joins and pagination failures.
+
+## Changelog
 
-The meetings endpoint is scanned on every run. Missing transcripts remain null; removed meetings remain stored. The raw tables preserve provider fields and require ClickHouse 25.3 or later. See the installed README for configuration and [registry installation](/cli/add/).
+<RegistryReference name="circleback" section="changelog" />
 
 ## Related pages
 
 - [App registry](/integrations/)
+- [Registry installation](/cli/add/)
 - [Ingestion plugin](/plugins/ingest/)
diff --git a/apps/docs/src/content/docs/integrations/github.mdx b/apps/docs/src/content/docs/integrations/github.mdx
index 7ff4f74a..bfd10b6c 100644
--- a/apps/docs/src/content/docs/integrations/github.mdx
+++ b/apps/docs/src/content/docs/integrations/github.mdx
@@ -1,31 +1,80 @@
 ---
 title: Integrating ClickHouse with GitHub
-description: Install the editable GitHub raw ingestion example.
+description: Install independent GitHub issue, pull-request, discussion, review, commit, and stargazer streams into raw ClickHouse tables.
 ---
 
-The GitHub registry item copies a small API reader and raw ClickHouse tables into a chkit project.
+The GitHub registry item installs one pipeline with independently selected resource streams and separate raw ClickHouse destinations.
 
 import RegistryReference from '../../../components/RegistryReference.astro';
 
 ## Install
 
 ```sh
-bunx chkit add github
+bunx chkit add github --with-tests
 bunx chkit check
 bunx chkit generate --name add_github
 bunx chkit migrate --apply
 bunx chkit ingest run --tag provider:github
 ```
 
-Set `GITHUB_TOKEN` in the runtime environment before the ingestion run. Edit `repositories` in `src/integrations/github/index.ts` to select repositories, then remove either stream if it is not needed.
+Set `GITHUB_TOKEN` before the ingestion run. For private repositories, the supported setup grants repository access with **Issues: read**, **Pull requests: read**, and **Contents: read**, including GraphQL commit reads. A field-level permission minimum has not been verified. Edit `githubConfig.repositories`, source identity, and reader settings in `src/integrations/github/config.ts`. Raw tables are declared in their `sources/` modules before schema discovery and migration. Native JSON requires ClickHouse 25.3 or later; schema imports do not call GitHub.
 
 <RegistryReference name="github" section="resources" />
 
+## Pipeline and streams
+
+Each configured repository contributes independent streams for issues, issue comments, pull requests, PR conversation comments, PR review comments, PR reviews, PR commits, and stargazers. Issues exclude pull requests. The streams share one installation pipeline and retain their own journal progress; stream order creates no dependency.
+
+Child-resource streams discover their own parents through the API. Selecting PR comments or commits works even when the pull-requests stream has never run. Individual PRs and issues remain records within those resource streams.
+
+```sh
+bunx chkit ingest run --tag provider:github --tag repository:obsessiondb/chkit --tag resource:pull_requests
+bunx chkit ingest run --tag provider:github --tag repository:obsessiondb/chkit --tag resource:pull_request_commits
+```
+
+Repeated tags use AND matching. The default pipeline runs streams sequentially with `maxStreams: 1`; filtered runs give each resource its own schedule and execution budget. `createGitHubPipeline(config, deps)` snapshots reader settings and injectable HTTP dependencies. Changing `sourceId` creates new stream identities; runtime reader settings do not redefine the exported raw tables.
+
+## Raw data and joins
+
+Raw payloads use `{ repository, data }`. Issue comments add `issue_number`; PR child rows add `pull_number`. Provider response fields stay under `data`. PR commits retain only `data.sha` and `data.message`, with repository/PR join keys. Their reader paginates the [GraphQL commit connection](https://docs.github.com/en/graphql/reference/pulls#pullrequest), rejects repeated SHAs, and checks stable totals and distinct terminal counts before completing the stream. Changed files and patches are not fetched.
+
+Join resources in ClickHouse through repository and issue/PR number. PR metadata lives in its own destination, and comments, reviews, and commits are separate rows. Conversation comments and diff-review comments remain distinct collections. Existing issue/stargazer provider-ID formats are preserved.
+
 ## Sync behavior
 
-Each run scans configured repositories. Removed issues or stars remain stored. The raw tables preserve provider fields and require ClickHouse 25.3 or later. See the installed README for configuration and [registry installation](/cli/add/).
+Issues and comments use independent updated-time windows with five minutes of overlap and a fixed local upper cutoff. Child comments on old issues and PRs remain eligible because parent discovery does not filter by parent update times. Review comments use the repository-wide update feed and retain their PR number. The checkpoint advances only after the selected stream's complete window and destination writes succeed; failed windows replay from their lower bound. See [issue filtering](https://docs.github.com/en/rest/issues/issues#list-repository-issues), [issue comments](https://docs.github.com/en/rest/issues/comments#list-issue-comments), and [review comments](https://docs.github.com/en/rest/pulls/comments#list-review-comments-in-a-repository).
+
+Pull requests, reviews, commits, and stargazers use `fullSync()`. Each invocation reads its selected collection from the beginning, and the library journals successful completion, including empty results. REST Link continuations and GraphQL cursors use `paginate()` for request retries and cycle detection; no mutable page offset or parent scan ledger is saved.
+
+Deleted records, removed stars, and commits removed from PRs remain stored. Live pagination does not guarantee a source snapshot. Historical replay refreshes current observations outside the timestamp overlap:
+
+```sh
+bunx chkit ingest run --tag provider:github --tag resource:issue_comments --backfill reconcile-2026-10-05 --from 2008-01-01
+bunx chkit ingest status --tag provider:github --json
+```
+
+Use a new backfill ID for each reconciliation. Full-sync resources ignore date bounds. A failed stream does not advance another stream's progress. Schedule finite ingestion runs externally, with one process per ClickHouse target at a time.
+
+## Existing datasets
+
+Version `0.2.0` adds six raw destinations and changes payloads to `{ repository, data }`. Existing issue and stargazer row IDs stay unchanged. Retained flat payloads may coexist with new envelopes until they are reread or migrated.
+
+Existing combined-reader datasets may include PR rows in `github_issues_raw` and child arrays inside parent payloads. Those rows remain after the new streams run. Archive the legacy dataset or deliberately migrate classifications and child records into the separate destinations. Normal ingestion does not remove legacy PR rows from the issues table; application queries must account for retained shapes during migration.
+
+## Test the readers
+
+```sh
+bun test src/integrations/github/tests/basic.test.ts
+```
+
+Fixtures cover isolated resource selection, join keys, narrow commit data, recent comments on old parents, pagination, failures, and journal completion without GitHub credentials.
+
+## Changelog
+
+<RegistryReference name="github" section="changelog" />
 
 ## Related pages
 
 - [App registry](/integrations/)
 - [Ingestion plugin](/plugins/ingest/)
+- [Ingestion CLI](/cli/ingest/)
diff --git a/apps/docs/src/content/docs/integrations/google-calendar.mdx b/apps/docs/src/content/docs/integrations/google-calendar.mdx
index bb3e2068..480a2607 100644
--- a/apps/docs/src/content/docs/integrations/google-calendar.mdx
+++ b/apps/docs/src/content/docs/integrations/google-calendar.mdx
@@ -1,31 +1,67 @@
 ---
 title: Integrating ClickHouse with Google Calendar
-description: Install the editable Google Calendar raw ingestion example.
+description: Install canonical Google Calendar ingestion with resumable pages and sync-token checkpoints.
 ---
 
-The Google Calendar registry item copies a small API reader and raw ClickHouse tables into a chkit project.
+The Google Calendar registry item copies a canonical event reader with journaled page and sync-token progress into a chkit project.
 
 import RegistryReference from '../../../components/RegistryReference.astro';
 
 ## Install
 
 ```sh
-bunx chkit add google-calendar
+bunx chkit add google-calendar --with-tests
 bunx chkit check
 bunx chkit generate --name add_google_calendar
 bunx chkit migrate --apply
 bunx chkit ingest run --tag provider:google-calendar
+bunx chkit ingest status --tag provider:google-calendar
 ```
 
-Set `GOOGLE_CALENDAR_ACCESS_TOKEN` in the runtime environment before the ingestion run. Edit `calendarId`, `pastDays`, and `futureDays` in `src/integrations/google-calendar/index.ts` to select the calendar and time range.
+Set `GOOGLE_CALENDAR_ACCESS_TOKEN` with `calendar.readonly` access before ingestion. Review installation settings and chunk limits in `src/integrations/google-calendar/config.ts`. `primary` is resolved through calendar metadata to detect a different account reusing the checkpoint. Schema imports do not request credentials or call Google.
 
 <RegistryReference name="google-calendar" section="resources" />
 
+## Pipeline and stream
+
+One installation exports one pipeline with a canonical `events` stream. `pipeline.ts` defines its destination and strategy; `sources/events.ts` handles acknowledged sync-token progress, and `client.ts` handles HTTP requests.
+
+`sourceId` identifies the installation in raw rows and checkpoint scope. `streamPrefix` determines journal IDs; defaults preserve `google-calendar.events`. A separate installation needs both a distinct source label and stream prefix. The pipeline factory binds configuration and injectable request dependencies while using the exported destination. Edit `database` in `config.ts` before schema imports to change table placement.
+
 ## Sync behavior
 
-Each run reads a configured time range. Events outside the range and deleted records are not reconciled. The raw tables preserve provider fields and require ClickHouse 25.3 or later. See the installed README for configuration and [registry installation](/cli/add/).
+The first run reads canonical events with recurring masters and exceptions, using `singleEvents=false` and `showDeleted=true`. Later runs request changes through Google's `syncToken`. Cancellation payloads remain unmodified. Recurring occurrences require a separate bounded instances reader or application projection.
+
+Events are the only synced resource. Attendees, organizer, recurrence, reminders, attachments, and `conferenceData` stay inside the native [event payload](https://developers.google.com/workspace/calendar/api/v3/reference/events). Calendar metadata resolves identity without creating another raw table. Build projections and joins with other integrations in ClickHouse; retain source and calendar keys in those joins. A sparse cancellation replaces the previous observation of the same event without copying fields from its old payload or recurring master.
+
+Each acknowledged page stores its next-page position and retains the same input sync token. Only a loaded terminal page promotes `nextSyncToken`, including an empty page. Rerun after interruption to resume; failed loads leave the previous checkpoint. Requests use fixed parameters, and validation rejects changed source scope or malformed pagination. Native JSON requires ClickHouse 25.3 or later.
+
+The reader uses `paginate()` for requests and continuation validation. Each full page includes raw events and a complete checkpoint candidate in metadata; the reader explicitly yields that candidate as chunk state. A rejected token becomes an empty reset page with a fresh continuation and retained recovery debt, using the same pagination loop. The existing checkpoint format is preserved.
+
+Google forbids `timeMin`, `timeMax`, `updatedMin`, and `orderBy` on sync-token requests. This canonical reader rejects explicit `--from`/`--to` bounds. A named backfill without bounds runs an independent canonical sync. See [Google synchronization](https://developers.google.com/workspace/calendar/api/guides/sync) and [events.list parameters](https://developers.google.com/workspace/calendar/api/v3/reference/events/list).
+
+## Expiry and stored data
+
+`410 Gone` resets provider progress and starts a new baseline without deleting raw rows. A rejected page token replays its collection once. The destination keeps the latest observed payload per `[sourceId, resolvedCalendarId, event.id]`; absent records are not reconciled after a reset. A current-calendar view requires completed-baseline generations or explicit reconciliation before treating absence as removal.
+
+The checkpoint retains the recovery count until the terminal sync page is acknowledged. Pauses and successful nonterminal replay pages keep that count; a second token rejection for the unfinished sync fails across executions. Adjust `maxChunks` in `config.ts`, execution duration, or polling frequency so the sync finishes while tokens remain valid. After reviewing coverage and correcting those conditions, migrate saved state explicitly or use a new stream identity for a fresh sync.
+
+Version 0.2.0 changes the former rolling occurrence-window semantics and row identities. Keep old tables as archives and start a new canonical dataset, or migrate identities explicitly; old expanded occurrences are not removed automatically. The installed README describes upgrade and recovery details.
+
+## Fixture verification
+
+```sh
+bun test src/integrations/google-calendar/tests/basic.test.ts
+```
+
+Fixtures cover page resumption, empty deltas, sink failures before token promotion, cancellation payloads, expired tokens, and calendar-account changes. Schedule repeat runs externally with one ingestion process per destination at a time.
+
+## Changelog
+
+<RegistryReference name="google-calendar" section="changelog" />
 
 ## Related pages
 
 - [App registry](/integrations/)
 - [Ingestion plugin](/plugins/ingest/)
+- [Ingestion CLI](/cli/ingest/)
diff --git a/apps/docs/src/content/docs/integrations/google-meet.mdx b/apps/docs/src/content/docs/integrations/google-meet.mdx
index f6c66bbc..8779c914 100644
--- a/apps/docs/src/content/docs/integrations/google-meet.mdx
+++ b/apps/docs/src/content/docs/integrations/google-meet.mdx
@@ -1,31 +1,82 @@
 ---
 title: Integrating ClickHouse with Google Meet
-description: Install the editable Google Meet raw ingestion example.
+description: Install six independent raw Google Meet streams with recent discovery and coarse page replay.
 ---
 
-The Google Meet registry item copies a small API reader and raw ClickHouse tables into a chkit project.
+The Google Meet registry item copies raw resource readers with a 24-hour lookback and independently journaled discovery-page checkpoints into a chkit project.
 
 import RegistryReference from '../../../components/RegistryReference.astro';
 
 ## Install
 
 ```sh
-bunx chkit add google-meet
+bunx chkit add google-meet --with-tests
 bunx chkit check
 bunx chkit generate --name add_google_meet
 bunx chkit migrate --apply
 bunx chkit ingest run --tag provider:google-meet
+bunx chkit ingest status --tag provider:google-meet
 ```
 
-Set `GOOGLE_MEET_ACCESS_TOKEN` in the runtime environment before the ingestion run. Edit `lookbackDays` in `src/integrations/google-meet/index.ts` to select the conference window.
+Set `GOOGLE_MEET_ACCESS_TOKEN` with `meetings.space.readonly` access. Review identity, lookback, schema placement and budgets in `src/integrations/google-meet/config.ts`. Keep identity tied to one Google account; these list responses do not identify the authenticated account. Coverage depends on that user's access. The reader does not refresh tokens or export an entire workspace automatically. Schema imports do not call Google. See [authorization](https://developers.google.com/workspace/meet/api/guides/authenticate-authorize).
 
 <RegistryReference name="google-meet" section="resources" />
 
+## Pipeline and streams
+
+One installation pipeline contains six independent streams: `conferences`, `participants`, `participant-sessions`, `recordings`, `transcripts`, and `transcript-entries`. Each owns its raw destination and journal progress. Every child stream discovers its own conference IDs; entries discover transcripts and sessions discover participants. Resources run independently in any order.
+
+```sh
+bunx chkit ingest run --tag provider:google-meet --tag resource:transcript-entries
+bunx chkit ingest run --tag provider:google-meet --tag resource:participant-sessions
+```
+
+`sourceId` scopes raw identities and queries; `streamPrefix` determines journal IDs. Another installation needs separate values. The factory snapshots supplied configuration and injectable request dependencies. Edit `database` before schema imports to change setup-time table placement. The default pipeline runs one stream and request at a time.
+
 ## Sync behavior
 
-Each run reads a configured time range. Transcripts generated later require another scan of that range. The raw tables preserve provider fields and require ClickHouse 25.3 or later. See the installed README for configuration and [registry installation](/cli/add/).
+Initial discovery covers the preceding 24 hours by conference end time. Later windows start at the completed watermark minus `lookbackHours` (24 by default), rereading recent calls and catching up after missed runs. Ongoing calls are discovered separately using `end_time IS NULL`, including long-running calls started before the lookback.
+
+Children of selected conferences are read completely with ordinary pagination. No conference catalog or child queue survives a completed window. Changes that appear after their conference leaves that window require a wider configured lookback or explicit backfill. There is no automatic historical reconciliation. Conference end times are not child update times; this is bounded recent polling. See [conference filters](https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords/list) and [artifact behavior](https://developers.google.com/workspace/meet/api/guides/artifacts).
+
+## Checkpoints and recovery
+
+The saved state contains scope, watermark, optional historical bounds, and the unfinished discovery window/phase/page token. Bounds are saved before the first request. A discovery page's children finish before a state-only marker advances the parent-page cursor. The executor commits it after all preceding rows land.
+
+An interrupted page repeats its child reads from the beginning under the same bounds; completed discovery pages remain skipped. No child cursor, cached page, or child completion index is persisted. Configure small discovery pages and enough budget to finish one page's children plus the checkpoint marker. Defaults are `pageSize: 1` and `maxChunks: 200`; increase the cap or `--max-duration` for unusually large conferences. Native JSON requires ClickHouse 25.3 or later.
+
+Rejected tokens restart their collection once. Discovery recovery debt persists across resumed executions until the phase finishes. Child collections restart naturally when their parent page replays. Repeated rejection and cyclic/malformed pagination fail visibly. Strategy version 2 rejects incompatible saved state; scope changes require deliberate migration or a new `streamPrefix`. Schedule externally with one ingestion process per target.
+
+## Raw updates and historical ranges
+
+Raw identity is `[sourceId, provider.name]`. Children add `conference_name`; sessions add `participant_name`, and entries add `transcript_name`. Join native resource names and derive attendance/transcript views later in ClickHouse.
+
+Participants and sessions preserve attendance identities and join/leave records. Recordings preserve metadata and Drive references without downloading media. Transcripts preserve metadata/document references, and entries preserve speech segments. API entries do not capture later edits to the separate Google Docs transcript.
+
+Each observation inserts under its stable identity into `ReplacingMergeTree(_chkit_ingested_at)`. A later transcript state replaces an earlier state; an empty list creates no placeholder that could block a generated transcript. A body hash or insert-only staging is unnecessary. Query with `FINAL` for latest observations. Missing or expired records are not inferred deletions; archived raw rows remain. See [conference retention](https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords).
+
+Backfills select conference end times and skip ongoing calls. Child lists are complete for selected conferences. Use the same ID and bounds to resume; changed bounds require a new ID, and expired API history is unavailable.
+
+```sh
+bunx chkit ingest run --tag provider:google-meet --backfill october --from 2026-10-01T00:00:00Z --to 2026-10-05T00:00:00Z
+```
+
+Version 0.2.0 adds participant, session, recording and entry destinations while preserving conference/transcript tables. Entries become separate rows. Source-scoped row IDs do not replace legacy provider-name IDs; archive or migrate legacy rows deliberately. The installed README explains this upgrade.
+
+## Fixture verification
+
+```sh
+bun test src/integrations/google-meet/tests/basic.test.ts
+```
+
+Fixtures cover independent resources, coarse replay/resume, lost sink acknowledgement, changed transcript content under stable IDs, recent late artifacts, empty pages, bounded recovery, fixed windows, scope and backfill isolation.
+
+## Changelog
+
+<RegistryReference name="google-meet" section="changelog" />
 
 ## Related pages
 
 - [App registry](/integrations/)
 - [Ingestion plugin](/plugins/ingest/)
+- [Ingestion CLI](/cli/ingest/)
diff --git a/apps/docs/src/content/docs/integrations/lemlist.mdx b/apps/docs/src/content/docs/integrations/lemlist.mdx
index 086b6516..97f15a1c 100644
--- a/apps/docs/src/content/docs/integrations/lemlist.mdx
+++ b/apps/docs/src/content/docs/integrations/lemlist.mdx
@@ -1,9 +1,9 @@
 ---
 title: Integrating ClickHouse with Lemlist
-description: Install the editable Lemlist raw ingestion example.
+description: Sync seven independent Lemlist resource streams into raw ClickHouse tables.
 ---
 
-The Lemlist registry item copies a small API reader and raw ClickHouse tables into a chkit project.
+The Lemlist registry item syncs campaigns, contacts, companies, campaign leads, activities, inbox conversations, and inbox messages into separate raw ClickHouse tables.
 
 import RegistryReference from '../../../components/RegistryReference.astro';
 
@@ -17,13 +17,47 @@ bunx chkit migrate --apply
 bunx chkit ingest run --tag provider:lemlist
 ```
 
-Set `LEMLIST_API_KEY` in the runtime environment before the ingestion run. Edit `src/integrations/lemlist/index.ts` to select activities, campaigns, or both.
+Set `LEMLIST_API_KEY` in the runtime environment before the ingestion run. Edit `src/integrations/lemlist/config.ts` for the account namespace, page size (1–100), initial activity date, overlap, interval length, and optional conversation user IDs. `pipeline.ts` groups seven independent streams in one account pipeline; select resources with tags. `sources/` contains the readers and `client.ts` uses `paginate()` for authenticated requests. `index.ts` exports the pipeline and raw schema. Child readers discover their own campaigns, contacts, or users; they do not depend on other streams running first.
+
+`createLemlistPipeline(config, deps)` binds reader settings and optional HTTP dependencies. Configure storage in the installation's `lemlistConfig` before schema discovery; factories use the exported raw tables.
+
+Keep each stream ID and destination tied to one account. The reader does not resolve the key's account identity; switching accounts requires new stream IDs and destinations so previous watermarks cannot skip history.
 
 <RegistryReference name="lemlist" section="resources" />
 
 ## Sync behavior
 
-Both streams scan all accessible pages each run. Removed campaigns or activity records remain stored. The raw tables preserve provider fields and require ClickHouse 25.3 or later. See the installed README for configuration and [registry installation](/cli/add/).
+Activities use inclusive `minDate`/`maxDate` filters on `createdAt`, thirty-day intervals, and one day of overlap. Each completed interval checkpoints only after its pages have destination acknowledgement. A failed interval starts at offset zero; an explicit backfill resumes its completed interval frontier in an isolated namespace. Empty intervals also commit progress. Offset pages remain mutable, so their offsets are never persisted as change cursors.
+
+The [activities API](https://developer.lemlist.com/api-reference/endpoints/activities/get-many-activities) includes sent, replied, and bounced email events and can backfill metadata on older activities. Periodic historical replay refreshes such changes and late arrivals beyond the overlap.
+
+All six other resources use `fullSync()` because their list/export endpoints do not document reliable modification filters. Empty reads record completion; failures replay the selected stream's complete discovery from the beginning. Campaigns use creation-time ordering, while child streams revisit all current parents, including old campaigns and contacts. Full reads ignore date bounds and do not provide date-range backfills.
+
+The [contacts reader](https://developer.lemlist.com/api-reference/endpoints/contacts/get-many-contacts) hydrates full same-resource records in batches of at most 100 IDs, preserving custom fields and native campaign references. [Companies](https://developer.lemlist.com/api-reference/endpoints/companies/get-many-companies) use their paginated list. Campaign leads are distinct campaign membership records; the reader uses [the complete JSON export](https://developer.lemlist.com/api-reference/endpoints/campaigns/export-campaign-leads-v2) with `state=all` instead of the ordinary 500-record list without continuation. Exports do not guarantee `contactId`; join native lead IDs against contacts' `campaigns[].leadId` in ClickHouse.
+
+[Conversations](https://developer.lemlist.com/api-reference/endpoints/inbox/get-many-inboxes) discover all current team member IDs by default; set `inboxUserIds` to a nonempty list to restrict this stream. Empty or omitted means team-wide discovery. [Messages](https://developer.lemlist.com/api-reference/endpoints/inbox/get-contact-messages) independently discover every accessible contact and paginate complete history with `skip/limit`, including late replies on old contacts. The user list scopes only conversations. Message requests explicitly set `markAsRead=false`; retrieval uses GET requests without inbox actions.
+
+All five new resource envelopes contain `source_id` and untouched provider records under `data`; campaign leads, conversations, and messages also retain their parent IDs. Contacts/companies row IDs encode `[sourceId, providerId]`, and the three child resources encode `[sourceId, parentId, providerId]`; conversations retain distinct user inbox views. Existing campaign/activity keys remain native `_id` and their original tables remain installation-specific. Perform joins, field transformations, and denormalization afterward in ClickHouse.
+
+```sh
+bunx chkit ingest run --tag provider:lemlist --tag resource:activities --backfill reconcile-2026-10-04 --from 2000-01-01
+bunx chkit ingest status --tag provider:lemlist --json
+```
+
+Use a new backfill ID for each complete activity reconciliation; reusing an ID resumes that backfill. Narrowing a reused backfill's upper bound below its committed frontier is rejected. Full reads do not infer deletions; removed records remain stored. Pagination totals and continuations are validated, but live lists can change during retrieval and require replay. Lead exports require memory for one complete campaign response before bounded publication. Coverage remains limited to records accessible to the API key.
+
+Version 0.2.0 adds five tables; generate and review additive migrations. The two original tables, stream IDs and activity checkpoint state remain compatible. Keep one installation per account; changing accounts requires new stream namespaces and destinations. The raw tables require ClickHouse 25.3 or later. See the installed README and [registry installation](/cli/add/).
+
+## Test the reader
+
+```sh
+bunx chkit add lemlist --with-tests
+bun test src/integrations/lemlist/tests
+```
+
+## Changelog
+
+<RegistryReference name="lemlist" section="changelog" />
 
 ## Related pages
 
diff --git a/apps/docs/src/content/docs/integrations/linear.mdx b/apps/docs/src/content/docs/integrations/linear.mdx
index d1c10ea5..93c34275 100644
--- a/apps/docs/src/content/docs/integrations/linear.mdx
+++ b/apps/docs/src/content/docs/integrations/linear.mdx
@@ -1,9 +1,9 @@
 ---
 title: Integrating ClickHouse with Linear
-description: Install the editable Linear raw ingestion example.
+description: Install nine independent Linear raw resource streams with recoverable checkpoints.
 ---
 
-The Linear registry item copies a small API reader and raw ClickHouse tables into a chkit project.
+The Linear registry item copies independent raw resource readers and ClickHouse destinations into a chkit project.
 
 import RegistryReference from '../../../components/RegistryReference.astro';
 
@@ -17,13 +17,58 @@ bunx chkit migrate --apply
 bunx chkit ingest run --tag provider:linear
 ```
 
-Set `LINEAR_API_KEY` in the runtime environment before the ingestion run. Edit the GraphQL query in `src/integrations/linear/index.ts` to select the fields needed by the project.
+Set `LINEAR_API_KEY` in the runtime environment before ingestion. Edit queries and raw destinations in `src/integrations/linear/sources/` to select fields and configure tables. `config.ts` supplies source identity and timestamp selection; `client.ts` handles authenticated requests, and `pipeline.ts` groups nine independent streams in one workspace pipeline.
+
+`createLinearPipeline(config, deps)` snapshots configuration and binds injectable HTTP dependencies. The pipeline and all nine table exports remain in `index.ts`. Destination schemas stay in source modules rather than runtime configuration.
+
+Keep stream IDs and destinations tied to one workspace. The reader does not resolve the token's workspace identity, so switching workspaces requires new IDs and destinations. Reconcile older observations after adding requested fields.
 
 <RegistryReference name="linear" section="resources" />
 
+## Raw data and resource selection
+
+Issues, comments, projects, project updates, cycles, users, teams, issue relations, and issue history each have their own raw table and checkpoint. Relationships retain provider-shaped ID references. Join resources and calculate metrics later in ClickHouse. Issues retain fully paginated label names as strings; label definitions, workflow states, and project statuses have no separate streams. Bounded inline state/status metadata remains provider fields.
+
+Comments use their own collection, including nullable references for issue and other parent types. History independently discovers all accessible issues before paging their events. Neither reader depends on the issues stream's execution or checkpoint. Paginated project memberships and other associations are outside the selected resource scope.
+
+```sh
+bunx chkit ingest run --tag provider:linear --tag resource:comments
+bunx chkit ingest run --tag provider:linear --tag resource:issue_history
+```
+
+Repeated tags use AND matching. The default pipeline executes streams sequentially to limit API usage; ordering does not establish a discovery dependency. Expensive history reads can have their own schedule and execution budget.
+
 ## Sync behavior
 
-Every run reads all accessible issues. The example requests the first 100 comments per issue; extend the query for complete discussions. The raw tables preserve provider fields and require ClickHouse 25.3 or later. See the installed README for configuration and [registry installation](/cli/add/).
+Seven root resources use server-side bounded `updatedAt` windows, Relay cursors, five minutes of overlap, and explicit archive inclusion. Users also include disabled accounts. Comments and project updates use their own update times, independently of their parents. [Linear pagination](https://linear.app/developers/pagination) and [date filtering](https://linear.app/developers/filtering) document these selection controls.
+
+`paginate()` owns request retries and continuation cycle detection. Readers validate GraphQL errors and reject partial success. Each timestamp checkpoint advances only after the complete window and destination writes succeed, including an empty window. Failed windows replay from their lower bound. Issues complete all label pages before publishing their label strings.
+
+Issue relations lack a reliable root change filter. History is only exposed through each issue's history connection, with no timestamp filter. These streams use `fullSync()`: discover their complete accessible scope on each run and journal success after destination acknowledgement, including empty results. Interrupted full reads restart from the beginning. They ignore date bounds and provide no date-range backfill. See [Linear's API schema](https://github.com/linear/linear/blob/master/packages/sdk/src/schema.graphql).
+
+Deleted records and removed relations remain stored. The API does not promise atomic snapshots, and label renames are not assumed to update issue timestamps. Periodic reconciliation refreshes older timestamp-selected observations:
+
+```sh
+bunx chkit ingest run --tag provider:linear --tag resource:issues --backfill reconcile-2026-10-05 --from 1970-01-01
+bunx chkit ingest status --tag provider:linear --json
+```
+
+Use a new backfill ID for each reconciliation. Timestamp replay reads current observations; the history stream preserves accessible provider events. The raw tables require ClickHouse 25.3 or later. See the installed README for configuration and [registry installation](/cli/add/).
+
+## Upgrading existing data
+
+Version `0.2.0` adds eight raw destinations while retaining issue row IDs and the `linear.issues` stream ID. Existing nested comments in old issue observations remain until those rows are refreshed or migrated deliberately. Initial reads populate the new resource tables; application queries should join those destinations rather than use retained nested comments.
+
+## Test the readers
+
+```sh
+bunx chkit add linear --with-tests
+bun test src/integrations/linear/tests/basic.test.ts
+```
+
+## Changelog
+
+<RegistryReference name="linear" section="changelog" />
 
 ## Related pages
 
diff --git a/apps/docs/src/content/docs/integrations/slack.mdx b/apps/docs/src/content/docs/integrations/slack.mdx
index 2d93a762..c85e575e 100644
--- a/apps/docs/src/content/docs/integrations/slack.mdx
+++ b/apps/docs/src/content/docs/integrations/slack.mdx
@@ -10,7 +10,7 @@ Sync Slack into ClickHouse to query conversation metadata, users, messages, and
 
 import RegistryReference from '../../../components/RegistryReference.astro';
 
-The [app registry](/integrations/) installs three raw tables and three full-read streams as editable TypeScript source. The integration preserves the complete objects returned by Slack; add SQL views for the fields and relationships needed by the project.
+The [app registry](/integrations/) installs three raw tables, full scans for users and conversations, and checkpointed message history and threads as editable TypeScript source. The integration preserves the complete objects returned by Slack; add SQL views for the fields and relationships needed by the project.
 
 <RegistryReference name="slack" section="overview" />
 
@@ -72,6 +72,8 @@ Add scopes for each additional conversation type selected in `config.ts`:
 
 The users stream needs `users:read`. Add `users:read.email` when email addresses should appear in returned profiles; missing email fields are retained as missing. See [Slack scopes](https://docs.slack.dev/reference/scopes/) and [`users.list`](https://docs.slack.dev/reference/methods/users.list/).
 
+The three raw streams are channels, users, and messages. [Thread replies](https://docs.slack.dev/reference/methods/conversations.replies/) are individual messages with their own `ts` and a `thread_ts` parent reference; they share the messages table. The messages reader discovers conversation IDs independently and can run before or without the metadata streams. Each resource owns its progress. Preserve returned nested message fields and join channel, user, and thread-parent records later in ClickHouse using source, workspace, channel, and native IDs.
+
 ### Token type and conversation access
 
 User tokens with the appropriate history scope read public channels and private conversations the user can access. Bot history access requires the bot to belong to the conversation. A bot may list public channels it has not joined, so the default `channels: undefined` can fail on history access. For a bot token, select IDs of conversations the bot has joined. See [`conversations.history`](https://docs.slack.dev/reference/methods/conversations.history/).
@@ -104,6 +106,8 @@ export const slackConfig: SlackConfig = {
   messagePageSize: 15,
   requestIntervalMs: 3000,
   messageIntervalMs: 60000,
+  historyFrom: undefined,
+  overlapMs: 86400000,
 }
 ```
 
@@ -119,6 +123,8 @@ export const slackConfig: SlackConfig = {
 | `messagePageSize` | History and reply page size, integer `1`–`999` subject to Slack's app-specific limit; conservative default `15` |
 | `requestIntervalMs` | Delay before each authentication, conversation, and user request; default `3000` ms |
 | `messageIntervalMs` | Delay before each history and reply request; default `60000` ms |
+| `historyFrom` | Optional exact bootstrap lower bound; default `undefined` selects the recent overlap window |
+| `overlapMs` | Recent root overlap after the completed watermark; default one day |
 
 Set `channels: ['C012EXAMPLE', 'C034EXAMPLE']` to restrict conversation metadata and messages. Selection uses Slack IDs, not channel names. Unknown IDs, inaccessible conversations, or IDs excluded by `conversationTypes` fail visibly. User collection remains workspace-wide.
 
@@ -145,7 +151,7 @@ Queries in this guide use the default database and table prefix. Substitute conf
 
 ## Included resources
 
-Each resource has its own stream and raw table. The `data` field in every row retains the complete returned provider object, including fields not listed here and fields introduced by Slack later.
+One installation pipeline contains independent streams for channels, users, and messages, each with its own raw table, resource tag, and journal progress. A channel or thread is an individual entity traversed within the messages resource. The `data` field in every row retains the complete returned provider object, including fields not listed here and fields introduced by Slack later.
 
 <RegistryReference name="slack" section="resources" />
 
@@ -163,25 +169,29 @@ Every API URL is relative to `https://slack.com/api/`. Each reader calls [`POST
 | `users` | `users.list` across the accessible workspace |
 | `messages` | Independent conversation discovery, then `conversations.history` for each selected conversation; `conversations.replies` for roots with `reply_count > 0` when replies are enabled |
 
-The client follows `response_metadata.next_cursor` until it is absent, null, or empty. A short or empty page with a next cursor does not end the scan. Repeated cursors and `has_more: true` without a cursor fail explicitly rather than silently ending an incomplete scan. Each stream discovers its own workspace and parents, so the messages stream runs without first running the channels stream.
+All three readers use the ingestion plugin's `paginate` helper. Channels and users yield selected pages as they arrive, following `response_metadata.next_cursor` until absent, null, or empty. Configured conversation IDs are validated when discovery finishes; a missing ID fails the stream while any loaded pages remain visible. Messages use exact `oldest` and `latest` time boundaries, preserving progress independently of temporary cursors. Their paginator crosses empty or parent-only pages and retains native `has_more` in metadata; a page with timestamp progress returns control to the message reader. Cursor expiration restarts the unfinished interval once. Repeated cursors and responses without a safe continuation fail visibly. Each stream discovers its workspace and parents independently.
 
-For each channel, the reader finishes history pagination before fetching its discovered threads, avoiding an idle history cursor during long thread scans. History has no date bounds or subtype filtering. Each thread read includes every reply page and the parent returned by the replies endpoint. The parent keeps its history row identity; replies use their own timestamps and retain `thread_ts` as the root reference.
+For each channel, history advances newest first. Read every selected reply for one history page before committing its history timestamp boundary and requesting older history. Replies advance oldest first with temporary local timestamp boundaries. Threads retain the parent returned by Slack under its history identity. Incomplete history pages replay with their replies, and no temporary cursor or thread frontier enters durable state.
 
 ## How the sync works
 
 <RegistryReference name="slack" section="sync" />
 
-Every run starts from the beginning of each selected resource. The readers do not save cursors, use incremental checkpoints, or bound message history by time. Re-reading old roots finds late replies to old threads when Slack still returns those roots and replies. It also refreshes returned message edits and reaction fields. Coverage remains limited by Slack retention, API visibility, scopes, and conversation access.
+Channels and users remain full metadata reads. Messages initially read the recent 24 hours to a fixed cutoff; an explicit `historyFrom` expands that first bootstrap. Later runs select the completed watermark minus `overlapMs` (24 hours by default) through the new cutoff, preserving catch-up coverage between runs. Newly discovered channels use that same selected range. There is no periodic historical reconciliation. Old edits and late replies on roots outside the selected history range are outside normal coverage. Coverage depends on retention, API visibility, scopes, and access.
+
+Message checkpoints retain workspace/query scope, fixed bounds, channel position, and the exact completed history frontier. Child rows carry no advanced state. An empty progress marker flushes rows and advances history only after the entire page and its replies have destination acknowledgement. Failed or budget-limited runs keep the original bounds and replay the unfinished page, including previously loaded replies. The completed watermark moves only after all selected channels and their selected child work finish.
+
+Keep source identity, selection, reply policy, and time configuration stable. Changing them fails against saved state instead of reinterpreting progress. The message strategy uses version 2; incompatible checkpoints require explicit migration or a new stream identity. Earlier released templates had no message checkpoint: upgrading to version 0.2.0 bootstraps once while preserving raw tables and identities.
 
 ### Rate limits and scan duration
 
-The default pipeline runs one stream, one fetch, and one load at a time, with a destination batch threshold of 500 rows. Requests wait before each attempt: metadata uses `requestIntervalMs: 3000`; history and replies use `messageIntervalMs: 60000` with pages of `15` messages.
+The default pipeline runs one stream, one fetch, and one load at a time. Metadata batches use a 500-row threshold; messages publish source pages individually and commit history progress after the page and all its replies finish. Requests wait before each attempt: metadata uses `requestIntervalMs: 3000`; history and replies use `messageIntervalMs: 60000` with pages of `15` messages.
 
 Slack documents a one-request-per-minute limit and a 15-object page limit for new commercially distributed applications outside the Slack Marketplace. Marketplace and internal customer-built apps retain Tier 3 limits. See the current [`conversations.history` reference](https://docs.slack.dev/reference/methods/conversations.history/), [`conversations.replies` reference](https://docs.slack.dev/reference/methods/conversations.replies/), and [rate-limit clarification](https://docs.slack.dev/changelog/2025/06/03/rate-limits-clarity/).
 
 For an internal app entitled to Tier 3, edit the copied config to use `messagePageSize: 200` and `messageIntervalMs: 1200`. Confirm the app's actual limits before changing these settings. Slack may still return fewer objects than requested or apply `429` responses.
 
-A full history read with many threads can take hours or days at the conservative defaults. Restrict conversation IDs and select only the necessary streams before scheduling runs. The CLI's default duration is `3600` seconds; set `--max-duration` for the expected scan. Increasing the duration does not add a resume cursor: a rerun after interruption reads from the beginning.
+A full history read with many threads can take hours or days at the conservative defaults. Restrict conversation IDs and select only the necessary streams before scheduling runs. The CLI's default duration is `3600` seconds; set `--max-duration` for the expected scan. An interrupted message read resumes the completed history timestamp frontier and replays its incomplete page with its replies. That complete unit, including its checkpoint marker, must fit the duration and chunk budget. Otherwise every run can replay the same unit without moving its checkpoint. Reduce `messagePageSize`, increase the execution budget, or narrow the workload.
 
 ### Retries and failures
 
@@ -247,9 +257,11 @@ bunx chkit ingest run --tag provider:slack --tag resource:messages --max-duratio
 bunx chkit ingest status --tag provider:slack --json
 ```
 
-Repeated tags use AND matching. With the default source ID, `--tag stream:slack.primary.messages` selects the same stream. `status` reports committed checkpoints; a successful full read may have no incremental bookmark. Verify the execution's stream outcomes and query known retained messages rather than relying only on a row count.
+Repeated tags use AND matching. With the default source ID, `--tag stream:slack.primary.messages` selects the same stream. `status` reports message checkpoints; full metadata reads have no incremental bookmark. Verify the execution's stream outcomes and query known retained messages rather than relying only on a row count.
+
+After the first run, compare a known message and a reply in an old thread with their retained `raw.data`. Add a reply to that old thread, then run a messages-only backfill with a new ID and `--from` before the root's timestamp to confirm it is collected. Normal incremental runs revisit roots within the selected overlap; an old root outside that range needs an explicit backfill.
 
-After the first run, compare a known message and a reply in an old thread with their retained `raw.data`. Add a reply to that test thread, rerun, and confirm it is collected. After fixing credentials, permissions, or destination failures, rerun ingestion; scans start again. Date-range backfill flags do not turn these full readers into bounded or incremental readers.
+After fixing credentials, permissions, or destination failures, rerun ingestion; messages resume saved work and metadata scans restart. Messages support isolated bounded backfills through `--backfill <id> --from <date> --to <date>`. Bounds select root/history timestamps, and their replies are read up to the upper cutoff. Unfinished bounds must match the saved backfill; use another ID for a different range. An omitted upper bound retains its original execution cutoff on resume. Channels and users do not interpret date bounds. Historical observations loaded later can replace newer raw payloads because versioning uses ingestion time.
 
 ### Coverage and consistency limits
 
@@ -263,24 +275,31 @@ Slack retention and access restrictions limit historical coverage. Changes durin
 |---|---|
 | `config.ts` | Source identity, destination names, conversation selection, replies, page sizes, pacing |
 | `client.ts` | Authentication, payload validation, pagination, request pacing, and row identity |
+| `state.ts` | Validated message windows, exact timestamp arithmetic, and source binding |
 | `sources/channels.ts` | Conversation reader and raw table |
 | `sources/users.ts` | User reader and raw table |
 | `sources/messages.ts` | History and thread reader and raw messages table |
 | `pipeline.ts` | Enabled streams, tags, batching, retries, and concurrency |
 | `index.ts` | Discoverable pipeline and schema exports |
-| `tests/slack.test.ts`, `tests/fixtures.ts` | Optional portable tests and sanitized mocked responses |
+| `tests/slack.test.ts`, `tests/checkpoints.test.ts`, `tests/fixtures.ts` | Portable payload, page replay, boundary, scope, and recent-coverage tests |
 
 Remove a stream from `pipeline.ts` to stop collecting a resource. Keep its schema export to preserve the existing table under migration management. Removing a schema export can generate a drop operation; review that migration. Revisit pacing when changing concurrency or page sizes and run fixture tests for customized readers.
 
+`createSlackPipeline` binds source identity, conversation selection, page sizes, pacing, and message checkpoint settings when it creates the pipeline. Later config edits do not change an existing pipeline. Its runtime settings exclude `database` and `tablePrefix`: those names belong to the raw schemas declared from the installed `config.ts` during module loading. Change destination names before loading schemas and generating migrations.
+
 ### Install and run fixture tests
 
 ```sh
 bunx chkit add slack --with-tests
-bun test src/integrations/slack/tests/slack.test.ts
+bun test src/integrations/slack/tests/slack.test.ts src/integrations/slack/tests/checkpoints.test.ts
 ```
 
 The optional tests mock Slack responses and use an in-memory destination. They need Bun, with no Slack token or ClickHouse server. Adjust the test path for a custom `--path`. Installed files belong to the project; reinstalling does not overwrite local edits or merge newer integration versions automatically.
 
+## Changelog
+
+<RegistryReference name="slack" section="changelog" />
+
 ## Related pages
 
 - [Integration list](/integrations/): available apps and dedicated sync guides.
diff --git a/apps/docs/src/content/docs/plugins/ingest.md b/apps/docs/src/content/docs/plugins/ingest.md
index 82d28585..b7fab176 100644
--- a/apps/docs/src/content/docs/plugins/ingest.md
+++ b/apps/docs/src/content/docs/plugins/ingest.md
@@ -81,12 +81,15 @@ const ticketStream = defineStream({
         if (cursor) url.searchParams.set('cursor', cursor)
         const response = await fetch(url, { signal, headers: { Authorization: `Bearer ${process.env.HELPDESK_TOKEN}` } })
         if (!response.ok) throw await HttpError.fromResponse(response)
-        const body = await response.json()
+        const body = await response.json() as {
+          data: Array<{ id: string; updated_at: string }>
+          next_cursor: string | null
+        }
         return { items: body.data, next: body.next_cursor ?? undefined }
       },
     })
-    for await (const items of pages) {
-      yield { rows: items.map((item) => ({ id: item.id, updated_at: item.updated_at, raw: JSON.stringify(item) })) }
+    for await (const page of pages) {
+      yield { rows: page.items.map((item) => ({ id: item.id, updated_at: item.updated_at, raw: JSON.stringify(item) })) }
     }
   },
 })
@@ -96,6 +99,8 @@ export const helpdesk = definePipeline({ id: 'helpdesk', streams: [ticketStream]
 
 Add `ingestionColumns` to custom destination tables. The loader fills `_chkit_batch_id` and `_chkit_run_id`; ClickHouse sets `_chkit_ingested_at` at the physical insert.
 
+`paginate` returns complete pages shaped as `{ items, next, metadata? }`, including empty and terminal pages. Use `page.items` for rows. Pass checkpoint candidates from metadata explicitly to a yielded chunk's `state` when using `cursorState`; metadata itself is not persisted. See [Readers and pagination](/api-sync/readers/#pages-and-checkpoint-metadata).
+
 Batch identity decides whether a retry is deduplicated. By default it includes a content hash of the rows, which prefers a possible duplicate over suppressing rows that changed between attempts; a field like `synced_at: new Date()` therefore defeats retry deduplication. When a chunk covers a stable source interval, declare it with `id` (for example `yield { rows, id: \`page:${cursor}\` }`): the chunk then becomes its own write unit and its identity ignores row content.
 
 ## Landing raw objects
@@ -104,7 +109,7 @@ Retain raw objects when the query shape may change and storage is affordable. Ma
 
 ```ts
 import { view } from '@chkit/core'
-import { defineStream, rawRows, rawTable } from '@chkit/plugin-ingest'
+import { HttpError, defineStream, paginate, rawRows, rawTable } from '@chkit/plugin-ingest'
 
 export const rawTickets = rawTable({ database: 'crm', name: 'tickets_raw' })
 
@@ -124,7 +129,24 @@ const ticketStream = defineStream({
   id: 'helpdesk.tickets',
   destination: rawTickets,
   async *read(context) {
-    for await (const page of listTickets(context)) yield { rows: rawRows(page, (ticket) => ticket.id) }
+    const pages = paginate({
+      context,
+      fetchPage: async (cursor: string | undefined, signal) => {
+        const url = new URL('https://api.example.com/tickets')
+        if (cursor) url.searchParams.set('cursor', cursor)
+        const response = await fetch(url, {
+          signal,
+          headers: { Authorization: `Bearer ${process.env.HELPDESK_TOKEN}` },
+        })
+        if (!response.ok) throw await HttpError.fromResponse(response)
+        const body = await response.json() as {
+          data: Array<{ id: string; [key: string]: unknown }>
+          next_cursor: string | null
+        }
+        return { items: body.data, next: body.next_cursor ?? undefined }
+      },
+    })
+    for await (const page of pages) yield { rows: rawRows(page.items, (ticket) => ticket.id) }
   },
 })
 ```
@@ -168,7 +190,7 @@ chkit ingest run --backfill jan --from 2026-01-01 --to 2026-02-01
 
 Every stream also carries the derived tags `pipeline:<id>` and `stream:<id>`. `schedule:<cadence>` is a convention only: chkit never interprets it. A `--tag` filter that matches nothing fails before any work runs.
 
-A backfill uses its own checkpoint namespace, so it never moves the scheduled bookmark. Reusing its ID reuses that state, but resumption depends on the strategy: explicit timestamp bounds take precedence over the watermark and reread that range. Full-sync and cursor strategies do not interpret date bounds. See [Backfill source data](/api-sync/operations/#backfill-source-data).
+A backfill uses its own checkpoint namespace, so it never moves the scheduled bookmark. Reusing its ID reuses that state, but resumption depends on the strategy: explicit timestamp bounds take precedence over the watermark and reread that range. The bundled `fullSync()` and `cursorState()` strategies do not interpret date bounds; custom provider strategies may honor or reject them. See the source's documentation and [Backfill source data](/api-sync/operations/#backfill-source-data).
 
 `chkit check` verifies that every stream destination carries the ingestion metadata columns. See [`chkit ingest`](/cli/ingest/) for the full flag reference, exit codes, and JSON output.
 
diff --git a/apps/docs/src/data/registry.ts b/apps/docs/src/data/registry.ts
index 7a1dd529..2d876a15 100644
--- a/apps/docs/src/data/registry.ts
+++ b/apps/docs/src/data/registry.ts
@@ -6,7 +6,11 @@ import type { RegistryCatalog } from '../../../../packages/cli/src/registry/mode
 // Read it as build-time data so source analysis does not require generated files.
 const registry: RegistryCatalog = JSON.parse(readFileSync(resolve('public/r/registry.json'), 'utf8'));
 
-export type RegistryReferenceSection = 'overview' | 'authentication' | 'scopes' | 'resources' | 'views' | 'sync';
+export type RegistryReferenceSection = 'overview' | 'authentication' | 'scopes' | 'resources' | 'views' | 'sync' | 'changelog';
+
+export function registryStrategyLabel(strategy: 'full' | 'timestamp' | 'cursor'): string {
+	return { full: 'Full scans', timestamp: 'Timestamp windows', cursor: 'Cursor checkpoints' }[strategy];
+}
 
 // The build validates and aggregates provider-local manifests before Astro loads this catalog.
 // HTML, raw Markdown, and structured data share the resulting metadata without CLI runtime dependencies.
@@ -23,6 +27,7 @@ export const registryApps = registry.items.map((item) => ({
 	authentication: item.meta.chkit.authentication,
 	views: item.meta.chkit.views,
 	sync: item.meta.chkit.sync,
+	changelog: item.meta.chkit.changelog,
 	clickhouse: item.meta.chkit.clickhouse,
 	language: item.meta.chkit.language,
 	strategies: [...new Set(item.meta.chkit.resources.map((resource) => resource.strategy))],
@@ -56,7 +61,7 @@ export function registryReferenceMarkdown(name: string, section: RegistryReferen
 				['Environment variables', app.authentication?.env.map((env) => `\`${env}\``).join(', ') ?? 'See provider setup'],
 				['ClickHouse', `\`${app.clickhouse}\``],
 				['Coverage', `${app.resources.length} synced resources, ${app.views?.length ?? 0} derived views`],
-				['Sync strategy', app.strategies.map((strategy) => strategy === 'full' ? 'Full read on every run' : strategy).join(', ')],
+				['Sync strategy', app.strategies.map(registryStrategyLabel).join(', ')],
 			]);
 		case 'authentication':
 			return app.authentication ? [
@@ -86,6 +91,12 @@ export function registryReferenceMarkdown(name: string, section: RegistryReferen
 				['Schedule', app.sync.schedule],
 				['Deletions', app.sync.deletions],
 			]) : '';
+		case 'changelog':
+			return (app.changelog ?? []).map((release) => [
+				`### Version ${release.version}`,
+				'',
+				...release.changes.map((change) => `- ${change}`),
+			].join('\n')).join('\n\n');
 	}
 }
 
diff --git a/apps/docs/src/integrations/raw-markdown.ts b/apps/docs/src/integrations/raw-markdown.ts
index 2a30a6a8..9870f84a 100644
--- a/apps/docs/src/integrations/raw-markdown.ts
+++ b/apps/docs/src/integrations/raw-markdown.ts
@@ -74,7 +74,7 @@ function expandRegistryReferences(source: string): string {
 		.map((part, index) => index % 2 === 1 ? part : part
 			.replace(/^import Registry(?:Apps|Reference) from .+;\n/gm, '')
 			.replace('<RegistryApps />', () => registryMarkdown())
-			.replace(/<RegistryReference name="([^"]+)" section="(overview|authentication|scopes|resources|views|sync)" \/>/g, (_match, name: string, section: RegistryReferenceSection) => registryReferenceMarkdown(name, section)))
+			.replace(/<RegistryReference name="([^"]+)" section="(overview|authentication|scopes|resources|views|sync|changelog)" \/>/g, (_match, name: string, section: RegistryReferenceSection) => registryReferenceMarkdown(name, section)))
 		.join('');
 }
 
diff --git a/package.json b/package.json
index 41438d80..81e5c44e 100644
--- a/package.json
+++ b/package.json
@@ -24,6 +24,7 @@
     "docs:dev": "bun run --cwd apps/docs dev",
     "docs:build": "bun run --cwd apps/docs build",
     "registry:build": "bun run scripts/build-registry.ts",
+    "registry:release": "bun run scripts/registry-releases.ts refresh",
     "typecheck": "turbo run typecheck",
     "lint": "turbo run lint",
     "test": "turbo run test",
@@ -42,11 +43,12 @@
     "fallow:dead-code": "bunx fallow --only dead-code",
     "fallow:pr": "bunx fallow --changed-since main --summary || true",
     "fallow:ci": "bunx fallow --fail-on-issues",
-    "verify": "bun run check:workspace-deps && turbo run typecheck lint test build && bun run check:packed-deps",
+    "verify": "bun run check:workspace-deps && bun run check:registry-releases && turbo run typecheck lint test build && bun run check:packed-deps",
     "changeset": "changeset",
     "version-packages": "changeset version",
     "check:examples": "bun run scripts/check-examples-manifest.ts",
     "check:workspace-deps": "bun run scripts/check-workspace-deps.ts",
+    "check:registry-releases": "bun run scripts/registry-releases.ts check",
     "check:packed-deps": "bun run scripts/check-packed-deps.ts",
     "clean": "turbo run clean",
     "chkit": "bun run ./packages/cli/src/bin/chkit.ts",
diff --git a/packages/cli/src/commands/registry.ts b/packages/cli/src/commands/registry.ts
index 26e785df..d93150d4 100644
--- a/packages/cli/src/commands/registry.ts
+++ b/packages/cli/src/commands/registry.ts
@@ -79,7 +79,7 @@ export async function cmdRegistry(command: 'add' | 'registry', argv: string[]):
       console.log(`Apps in ${catalog.name} (${items.length}):`)
       for (const item of items) {
         console.log(`\n${item.title} (${item.name}@${item.version})\n  ${item.description}`)
-        console.log(`  ${item.resourceCount} resource${item.resourceCount === 1 ? '' : 's'}; sync strategies: ${item.strategies.join(', ')}`)
+        console.log(`  ${item.resourceCount} resource${item.resourceCount === 1 ? '' : 's'}; sync strategies: ${item.strategies.map(describeStrategy).join(', ')}`)
         if (item.documentation) console.log(`  Guide: ${item.documentation}`)
         console.log(`  Install: ${installCommand(`${item.name}@${item.version}`, values.registry)}`)
       }
@@ -115,7 +115,7 @@ export async function cmdRegistry(command: 'add' | 'registry', argv: string[]):
         console.log(`  ${resource.name}: ${resource.description}`)
         if (resource.title) console.log(`    Title: ${resource.title}`)
         console.log(resource.table ? `    Default table: ${resource.table}` : '    Table: see source schema')
-        console.log(`    Strategy: ${resource.strategy}; scopes: ${resource.scopes.join(', ') || 'none declared'}`)
+        console.log(`    Strategy: ${describeStrategy(resource.strategy)}; scopes: ${resource.scopes.join(', ') || 'none declared'}`)
         for (const endpoint of resource.endpoints ?? []) console.log(`    ${endpoint.method} ${endpoint.path} (${endpoint.documentation})`)
       }
       if (item.meta.chkit.views?.length) {
@@ -128,6 +128,13 @@ export async function cmdRegistry(command: 'add' | 'registry', argv: string[]):
         console.log(`  Schedule: ${sync.schedule}`)
         console.log(`  Deletions: ${sync.deletions}`)
       }
+      if (item.meta.chkit.changelog?.length) {
+        console.log('\nChangelog:')
+        for (const release of item.meta.chkit.changelog) {
+          console.log(`  ${release.version}`)
+          for (const change of release.changes) console.log(`    - ${change}`)
+        }
+      }
       console.log('\nFiles:')
       for (const file of item.files) console.log(`  ${file.target}${file.role === 'test' ? ' (optional; --with-tests)' : ''}`)
     }
@@ -140,6 +147,11 @@ export async function cmdRegistry(command: 'add' | 'registry', argv: string[]):
   else console.log(`Built ${result.items.length} template(s) into ${resolve(values.output ?? 'public/r')}`)
 }
 
+function describeStrategy(strategy: 'full' | 'timestamp' | 'cursor'): string {
+  const labels = { full: 'full scans', timestamp: 'timestamp windows', cursor: 'cursor checkpoints' }
+  return `${strategy} (${labels[strategy]})`
+}
+
 function onePositional(positionals: string[], usage: string): string {
   const reference = positionals[0]
   if (!reference || positionals.length !== 1) throw new Error(`Usage: ${usage}`)
@@ -158,7 +170,7 @@ function registryHelp(command: 'add' | 'registry'): string {
   if (command === 'registry') return `chkit registry <command> [options]
 
   list                       Browse apps, sync resources, and integration guides
-  inspect <template>         Show records, scopes, environment, files, and install command
+  inspect <template>         Show records, scopes, environment, changelog, files, and install command
   build [manifest]           Build a registry/registry.json manifest
 
 Options:
diff --git a/packages/cli/src/registry/model.ts b/packages/cli/src/registry/model.ts
index 2698a51a..c1a9897f 100644
--- a/packages/cli/src/registry/model.ts
+++ b/packages/cli/src/registry/model.ts
@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto'
 import { posix } from 'node:path'
-import { valid, validRange } from 'semver'
+import { compare, valid, validRange } from 'semver'
 import { z } from 'zod'
 
 export const ITEM_SCHEMA_URL = 'https://ui.shadcn.com/schema/registry-item.json'
@@ -18,6 +18,10 @@ const webUrl = z.url({ protocol: /^https?$/ })
 const metadataSchema = z.object({
   formatVersion: z.literal(1),
   version,
+  changelog: z.array(z.object({
+    version,
+    changes: z.array(z.string().refine((value) => value.trim().length > 0, 'Expected a non-empty change')).min(1),
+  }).strict()).min(1).optional(),
   language: z.literal('typescript'),
   license: z.string().min(1),
   documentation: webUrl.optional(),
@@ -40,7 +44,7 @@ const metadataSchema = z.object({
     table: z.string().min(1).optional(),
     description: z.string().min(1),
     scopes: z.array(z.string()),
-    strategy: z.literal('full'),
+    strategy: z.enum(['full', 'timestamp', 'cursor']),
     endpoints: z.array(z.object({
       method: z.enum(['GET', 'POST']),
       path: z.string().startsWith('/'),
@@ -89,6 +93,16 @@ export type RegistryCatalog = z.infer<typeof registryCatalogSchema>
 export function parseRegistryItem(value: unknown, built = true): RegistryItem {
   const item = registryItemSchema.parse(value)
   const meta = item.meta.chkit
+  if (meta.changelog) {
+    if (meta.changelog[0]?.version !== meta.version) throw new Error('Changelog must start with the current version')
+    for (let index = 1; index < meta.changelog.length; index++) {
+      const previous = meta.changelog[index - 1]
+      const entry = meta.changelog[index]
+      if (previous && entry && compare(previous.version, entry.version) <= 0) {
+        throw new Error('Changelog versions must be unique and newest first')
+      }
+    }
+  }
   const targets = new Set<string>()
   for (const file of item.files) {
     if (!file.target.startsWith(`${meta.root}/`)) throw new Error(`File target ${file.target} must be inside ${meta.root}/`)
diff --git a/packages/cli/src/test/registry/artifact.test.ts b/packages/cli/src/test/registry/artifact.test.ts
index 2860956b..4d00da1e 100644
--- a/packages/cli/src/test/registry/artifact.test.ts
+++ b/packages/cli/src/test/registry/artifact.test.ts
@@ -52,6 +52,59 @@ test.serial('immutable versions reject changed source until the version is bumpe
   expect((await resolveRegistryItem('fixture', fixture.output)).item.meta.chkit.version).toBe('1.0.1')
 })
 
+test.serial('changelogs roundtrip through artifacts and catalogs while legacy versions remain readable', async () => {
+  const fixture = await fixtures.create()
+  const changelog = [
+    { version: '1.1.0', changes: ['Resume interrupted syncs from saved cursors.', 'Keep provider payloads unchanged.'] },
+    { version: '1.0.0', changes: ['Add the initial integration.'] },
+    { version: '1.0.0-rc.10', changes: ['Fix cursor recovery.'] },
+    { version: '1.0.0-rc.2', changes: ['Preview cursor recovery.'] },
+  ]
+  await writeManifest(fixture.manifest, {
+    ...fixture.sourceItem,
+    meta: { chkit: { ...fixture.sourceItem.meta.chkit, version: '1.1.0', changelog } },
+  })
+  await buildRegistry({ manifestPath: fixture.manifest, outputDir: fixture.output })
+  const [latest, pinned, legacy, catalog] = await Promise.all([
+    resolveRegistryItem('fixture', fixture.output),
+    resolveRegistryItem('fixture@1.1.0', fixture.output),
+    resolveRegistryItem('fixture@1.0.0', fixture.output),
+    readRegistryCatalog(fixture.output),
+  ])
+  expect(latest.item.meta.chkit.changelog).toEqual(changelog)
+  expect(pinned.item).toEqual(latest.item)
+  expect(catalog.items[0]?.meta.chkit.changelog).toEqual(changelog)
+  expect(legacy.item).toEqual(fixture.item)
+  expect(legacy.item.meta.chkit).not.toHaveProperty('changelog')
+})
+
+test.serial('changelogs require a current entry and unique versions in semantic newest-first order', async () => {
+  const fixture = await fixtures.create()
+  const change = ['Improve sync recovery.']
+  const withChangelog = (changelog: unknown) => ({
+    ...fixture.item, meta: { chkit: { ...fixture.item.meta.chkit, changelog } },
+  })
+  expect(() => parseRegistryItem(withChangelog([{ version: '0.9.0', changes: change }]))).toThrow('Changelog must start with the current version')
+  for (const versions of [
+    ['1.0.0', '1.0.0'],
+    ['1.0.0', '0.8.0', '0.9.0'],
+    ['1.0.0', '1.1.0'],
+    ['1.0.0', '1.0.0-rc.2', '1.0.0-rc.10'],
+  ]) {
+    expect(() => parseRegistryItem(withChangelog(versions.map((version) => ({ version, changes: change }))))).toThrow('Changelog versions must be unique and newest first')
+  }
+  for (const changelog of [
+    [],
+    [{ version: '1.0.0', changes: [] }],
+    [{ version: '1.0.0', changes: [''] }],
+    [{ version: '1.0.0', changes: [' \n\t'] }],
+    [{ version: '1.0.0', changes: change }, { version: 'latest', changes: change }],
+    [{ version: '1.0.0', changes: change }, { version: '1.0.0+previous', changes: change }],
+  ]) {
+    expect(() => parseRegistryItem(withChangelog(changelog))).toThrow()
+  }
+})
+
 test.serial('named references reject a registry response with a different name or pinned version', async () => {
   const fixture = await fixtures.create()
   await write(fixture.origin, JSON.stringify({ ...fixture.item, name: 'unexpected' }))
@@ -114,6 +167,19 @@ test.serial('presentation metadata is optional and accepts only HTTP or HTTPS UR
   }
 })
 
+test.serial('resource strategies preserve full metadata and accept timestamp and cursor checkpoints', async () => {
+  const fixture = await fixtures.create()
+  for (const strategy of ['full', 'timestamp', 'cursor']) {
+    const resources = fixture.item.meta.chkit.resources.map((resource) => ({ ...resource, strategy }))
+    const item = { ...fixture.item, meta: { chkit: { ...fixture.item.meta.chkit, resources } } }
+    expect(parseRegistryItem(item).meta.chkit.resources[0]?.strategy).toBe(strategy)
+  }
+  for (const strategy of ['offset', '', undefined]) {
+    const resources = fixture.item.meta.chkit.resources.map((resource) => ({ ...resource, strategy }))
+    expect(() => parseRegistryItem({ ...fixture.item, meta: { chkit: { ...fixture.item.meta.chkit, resources } } })).toThrow()
+  }
+})
+
 test.serial('optional test roles and dependencies preserve legacy items and reject invalid entries', async () => {
   const fixture = await fixtures.create(true)
   expect(parseRegistryItem(fixture.item)).toEqual(fixture.item)
diff --git a/packages/cli/src/test/registry/cli.test.ts b/packages/cli/src/test/registry/cli.test.ts
index 0ff4f2b9..a5750b08 100644
--- a/packages/cli/src/test/registry/cli.test.ts
+++ b/packages/cli/src/test/registry/cli.test.ts
@@ -94,9 +94,35 @@ test.serial('build, list and inspect roundtrip through the CLI without importing
   expect(inspectText.stdout).toContain('records: Fixture records')
   expect(inspectText.stdout).toContain('Table: see source schema')
   expect(inspectText.stdout).not.toContain('Table: records')
-  expect(inspectText.stdout).toContain('Strategy: full; scopes: record:read')
+  expect(inspectText.stdout).toContain('Strategy: full (full scans); scopes: record:read')
   expect(inspectText.stdout).not.toContain('Guide:')
   expect(inspectText.stdout).not.toContain('Logo:')
+  expect(inspectText.stdout).not.toContain('Changelog:')
+})
+
+test.serial('inspect shows the integration changelog in human and JSON output', async () => {
+  const fixture = await fixtures.create()
+  const changelog = [
+    { version: '1.0.1', changes: ['Resume interrupted syncs from saved cursors.', 'Keep provider payloads unchanged.'] },
+    { version: '1.0.0', changes: ['Add the initial integration.'] },
+  ]
+  await writeManifest(fixture.manifest, {
+    ...fixture.sourceItem,
+    meta: { chkit: { ...fixture.sourceItem.meta.chkit, version: '1.0.1', changelog } },
+  })
+  await buildRegistry({ manifestPath: fixture.manifest, outputDir: fixture.output })
+  const [human, json, legacy] = await Promise.all([
+    runCli(fixture.project, ['registry', 'inspect', 'fixture@1.0.1', '--registry', fixture.output]),
+    runCli(fixture.project, ['registry', 'inspect', 'fixture@1.0.1', '--registry', fixture.output, '--json']),
+    runCli(fixture.project, ['registry', 'inspect', 'fixture@1.0.0', '--registry', fixture.output]),
+  ])
+  expect(human.exitCode).toBe(0)
+  expect(human.stdout).toContain('Changelog:\n  1.0.1\n    - Resume interrupted syncs from saved cursors.\n    - Keep provider payloads unchanged.\n  1.0.0\n    - Add the initial integration.')
+  expect(json.exitCode).toBe(0)
+  expect(JSON.parse(json.stdout).item.meta.chkit.changelog).toEqual(changelog)
+  expect(legacy.exitCode).toBe(0)
+  expect(legacy.stdout).not.toContain('Changelog:')
+  expect(await readdir(fixture.project)).toEqual([])
 })
 
 test.serial('list and inspect expose integration guides, logos, complete resources and environment defaults', async () => {
@@ -104,8 +130,8 @@ test.serial('list and inspect expose integration guides, logos, complete resourc
   const documentation = 'https://example.com/registry/fixture/'
   const logo = 'https://example.com/logos/fixture.svg'
   const resources = [
-    ...fixture.sourceItem.meta.chkit.resources,
-    { name: 'members', description: 'Workspace members', scopes: ['members:read', 'workspace:read'], strategy: 'full' as const },
+    ...fixture.sourceItem.meta.chkit.resources.map((resource) => ({ ...resource, strategy: 'timestamp' as const })),
+    { name: 'members', description: 'Workspace members', scopes: ['members:read', 'workspace:read'], strategy: 'cursor' as const },
   ]
   await writeManifest(fixture.manifest, {
     ...fixture.sourceItem,
@@ -128,7 +154,7 @@ test.serial('list and inspect expose integration guides, logos, complete resourc
     command: 'registry', schemaVersion: 1, ok: true, action: 'list',
     items: [{
       name: 'fixture', title: 'Fixture', description: 'A provider fixture', version: '1.0.1',
-      resourceCount: 2, resources, strategies: ['full'], documentation, logo,
+      resourceCount: 2, resources, strategies: ['timestamp', 'cursor'], documentation, logo,
     }],
   })
   expect(inspectJson.exitCode).toBe(0)
@@ -139,7 +165,7 @@ test.serial('list and inspect expose integration guides, logos, complete resourc
   })
   expect(listText.exitCode).toBe(0)
   expect(listText.stdout).toContain('Fixture (fixture@1.0.1)')
-  expect(listText.stdout).toContain('2 resources; sync strategies: full')
+  expect(listText.stdout).toContain('2 resources; sync strategies: timestamp (timestamp windows), cursor (cursor checkpoints)')
   expect(listText.stdout).toContain(`Guide: ${documentation}`)
   expect(listText.stdout).toContain(`Install: chkit add fixture@1.0.1 --registry ${fixture.output}`)
   expect(inspectText.exitCode).toBe(0)
@@ -147,7 +173,7 @@ test.serial('list and inspect expose integration guides, logos, complete resourc
   expect(inspectText.stdout).toContain(`Logo: ${logo}`)
   expect(inspectText.stdout).toContain(`Install: chkit add fixture@1.0.1 --registry ${fixture.output}`)
   expect(inspectText.stdout).toContain('members: Workspace members')
-  expect(inspectText.stdout).toContain('Strategy: full; scopes: members:read, workspace:read')
+  expect(inspectText.stdout).toContain('Strategy: cursor (cursor checkpoints); scopes: members:read, workspace:read')
   expect(inspectText.stdout).toContain('FIXTURE_REGION: "eu"')
   expect(await readdir(fixture.project)).toEqual([])
 
diff --git a/packages/plugin-ingest/README.md b/packages/plugin-ingest/README.md
index 702bbb81..16737738 100644
--- a/packages/plugin-ingest/README.md
+++ b/packages/plugin-ingest/README.md
@@ -4,6 +4,8 @@ Write TypeScript readers to load application API data into ClickHouse with [chki
 
 The executor records progress after writes succeed. A retry can reread rows from the last committed checkpoint.
 
+`paginate()` yields complete `{ items, next, metadata? }` pages, including empty terminal pages. Read rows from `page.items`; use `next` for request continuation and explicitly map checkpoint metadata into a chunk's `state` with `cursorState`. The executor commits that state after the rows are saved. This replaces the previous item-array return type; existing readers must use `page.items`.
+
 ```ts
 import { defineConfig } from '@chkit/core'
 import { ingest } from '@chkit/plugin-ingest'
diff --git a/packages/plugin-ingest/src/executor.test.ts b/packages/plugin-ingest/src/executor.test.ts
index 4bc82651..c93e7317 100644
--- a/packages/plugin-ingest/src/executor.test.ts
+++ b/packages/plugin-ingest/src/executor.test.ts
@@ -834,4 +834,30 @@ describe('paginate', () => {
     }
     await expect(iterate()).rejects.toThrow('repeated continuation')
   })
+
+  test('a cyclic provider cursor fails permanently without replaying the reader under its retry policy', async () => {
+    const cursors: Array<string | undefined> = []
+    const stream = defineStream({
+      id: 'app.cyclic', destination: events,
+      retry: { retries: 2, minTimeout: 1, maxTimeout: 1, randomize: false },
+      async *read(context) {
+        for await (const page of paginate({
+          context,
+          fetchPage: async (cursor: string | undefined) => {
+            cursors.push(cursor)
+            return { items: [], next: 'same' }
+          },
+        })) yield { rows: page.items }
+      },
+    })
+    const journal = createMemoryJournal()
+    const result = await runIngestion({ selected: selectStreams([definePipeline({ id: 'app', streams: [stream] })], []), backfill: undefined }, {
+      journal, destination: createMemoryDestination(),
+    })
+    expect(result.ok).toBe(false)
+    expect(result.streams[0]?.error).toContain('repeated continuation')
+    expect(cursors).toEqual([undefined, 'same'])
+    expect(journal.events.filter((event) => event.eventKind === 'retry_scheduled')).toHaveLength(0)
+    expect((await journal.readCheckpoint('app.cyclic')).lastSuccessSeq).toBe(0)
+  })
 })
diff --git a/packages/plugin-ingest/src/paginate.test.ts b/packages/plugin-ingest/src/paginate.test.ts
new file mode 100644
index 00000000..e42ca895
--- /dev/null
+++ b/packages/plugin-ingest/src/paginate.test.ts
@@ -0,0 +1,216 @@
+import { expect, expectTypeOf, test } from 'bun:test'
+
+import { rawRows, rawTable } from './destination.js'
+import { IngestConfigError } from './errors.js'
+import { runIngestion } from './executor.js'
+import { cursorState } from './incremental.js'
+import { paginate, type Page } from './paginate.js'
+import { definePipeline, defineStream, selectStreams } from './registry.js'
+import { createMemoryDestination, createMemoryJournal } from './testing.js'
+import type { AttemptOptions, DestinationAdapter, FetchContext } from './types.js'
+
+interface Progress {
+  syncToken: string
+  pageToken?: string
+}
+
+test('yields full typed pages and unchanged metadata, including empty continuation and terminal pages', async () => {
+  const controller = new AbortController()
+  const attempts: AttemptOptions[] = []
+  const requested: Array<string | undefined> = []
+  const metadata = [
+    { syncToken: 'S0', pageToken: 'P1' },
+    { syncToken: 'S0', pageToken: 'P2' },
+    { syncToken: 'S1' },
+  ]
+  const source: Page<{ id: number }, string, Progress>[] = [
+    { items: [{ id: 1 }], next: 'P1', metadata: metadata[0] },
+    { items: [], next: 'P2', metadata: metadata[1] },
+    { items: [], next: undefined, metadata: metadata[2] },
+  ]
+  const context: FetchContext = {
+    signal: controller.signal,
+    attempt: async (operation, options = {}) => {
+      attempts.push(options)
+      return operation(controller.signal)
+    },
+  }
+  const iterator = paginate({
+    context, initial: 'P0', label: 'GET /changes',
+    fetchPage: async (cursor, signal) => {
+      requested.push(cursor)
+      expect(signal).toBe(controller.signal)
+      const page = source[requested.length - 1]
+      if (!page) throw new Error('Unexpected page request.')
+      return page
+    },
+  })
+  expectTypeOf(iterator).toEqualTypeOf<AsyncGenerator<Page<{ id: number }, string, Progress>, void, void>>()
+  const received = await Array.fromAsync(iterator)
+
+  expect(received).toEqual(source)
+  for (const [index, page] of received.entries()) {
+    expect(page).toBe(source[index])
+    expect(page.metadata).toBe(metadata[index])
+  }
+  expect(requested).toEqual(['P0', 'P1', 'P2'])
+  expect(attempts).toEqual(Array.from({ length: 3 }, () => ({ label: 'GET /changes' })))
+})
+
+test('supports compound continuations without interpreting their fields', async () => {
+  const requested: Array<{ offset: number; scope: string } | undefined> = []
+  const received = await Array.fromAsync(paginate({
+    context: fetchContext(), initial: { offset: 0, scope: 'workspace-a' },
+    fetchPage: async (cursor) => {
+      requested.push(cursor)
+      return {
+        items: [{ id: cursor?.offset }],
+        next: cursor?.offset === 0 ? { scope: 'workspace-a', offset: 10 } : undefined,
+      }
+    },
+  }))
+
+  expect(requested).toEqual([{ offset: 0, scope: 'workspace-a' }, { offset: 10, scope: 'workspace-a' }])
+  expect(received.map((page) => page.items)).toEqual([[{ id: 0 }], [{ id: 10 }]])
+})
+
+test('rejects a repeated initial compound continuation before exposing its candidate metadata', async () => {
+  let requests = 0
+  const iterator = paginate({
+    context: fetchContext(), initial: { offset: 0, scope: 'workspace-a' },
+    fetchPage: async () => {
+      requests += 1
+      return { items: [{ id: 1 }], next: { scope: 'workspace-a', offset: 0 }, metadata: { unsafe: true } }
+    },
+  })
+
+  await expect(iterator.next()).rejects.toThrow('repeated continuation')
+  expect(requests).toBe(1)
+  expect(await iterator.next()).toEqual({ done: true, value: undefined })
+})
+
+test('rejects a later cursor cycle before yielding the page that would checkpoint it', async () => {
+  const iterator = paginate({
+    context: fetchContext(), initial: 'A',
+    fetchPage: async (cursor) => ({ items: [], next: cursor === 'A' ? 'B' : 'A', metadata: { page: cursor } }),
+  })
+
+  expect(await iterator.next()).toEqual({ done: false, value: { items: [], next: 'B', metadata: { page: 'A' } } })
+  await expect(iterator.next()).rejects.toThrow('repeated continuation')
+  expect(await iterator.next()).toEqual({ done: true, value: undefined })
+})
+
+test('retains null terminal continuation tolerance and its empty page metadata', async () => {
+  const iterator = paginate<number, string | null, string>({
+    context: fetchContext(), fetchPage: async () => ({ items: [], next: null, metadata: 'completed' }),
+  })
+
+  expect(await Array.fromAsync(iterator)).toEqual([{ items: [], next: null, metadata: 'completed' }])
+})
+
+test.each(['before', 'during'] as const)('cancellation %s a request prevents exposing its page', async (when) => {
+  const controller = new AbortController()
+  let requests = 0
+  if (when === 'before') controller.abort()
+  const iterator = paginate({
+    context: fetchContext(controller.signal),
+    fetchPage: async () => {
+      requests += 1
+      controller.abort()
+      return { items: [], next: undefined, metadata: 'uncommitted' }
+    },
+  })
+
+  await expect(iterator.next()).rejects.toThrow('aborted')
+  expect(requests).toBe(when === 'before' ? 0 : 1)
+})
+
+test('page metadata advances durable progress only through explicitly yielded chunk state', async () => {
+  const journal = createMemoryJournal()
+  const stream = defineStream({
+    id: 'test.metadata', destination: rawTable({ database: 'test', name: 'metadata' }),
+    async *read(context) {
+      for await (const page of paginate({
+        context, fetchPage: async () => ({ items: [], next: undefined, metadata: { syncToken: 'S1' } }),
+      })) yield { rows: page.items }
+    },
+  })
+  const pipeline = definePipeline({ id: 'test', streams: [stream] })
+  const result = await runIngestion({ selected: selectStreams([pipeline], []), backfill: undefined }, {
+    journal, destination: createMemoryDestination(),
+  })
+
+  expect(result.ok).toBe(true)
+  expect((await journal.readCheckpoint(stream.id)).envelope).toBeUndefined()
+  expect((await journal.readCheckpoint(stream.id)).lastSuccessSeq).toBeGreaterThan(0)
+})
+
+test('cursorState resumes pages and commits an empty terminal bookmark only after covering rows succeed', async () => {
+  const journal = createMemoryJournal()
+  const destination = createMemoryDestination()
+  const requested: Array<{ syncToken: string; pageToken: string | undefined }> = []
+  const target = rawTable({ database: 'test', name: 'changes' })
+  const pipeline = (maxChunks?: number) => definePipeline({
+    id: 'test', streams: [defineStream({
+      id: 'test.changes', destination: target, batchSize: 2, retry: { retries: 0 },
+      budget: maxChunks === undefined ? undefined : { maxChunks },
+      incremental: cursorState({ id: 'test.changes.progress', version: 1, parse: parseProgress }),
+      async *read(context) {
+        const syncToken = context.state?.syncToken ?? 'S0'
+        for await (const page of paginate<{ id: number }, string, Progress>({
+          context, initial: context.state?.pageToken,
+          fetchPage: async (pageToken) => {
+            requested.push({ syncToken, pageToken })
+            if (syncToken === 'S1') return { items: [], next: undefined, metadata: { syncToken: 'S2' } }
+            if (pageToken === 'P3') return { items: [], next: undefined, metadata: { syncToken: 'S1' } }
+            const next = pageToken === undefined ? 'P2' : 'P3'
+            return { items: [{ id: pageToken === undefined ? 1 : 2 }], next, metadata: { syncToken, pageToken: next } }
+          },
+        })) yield { rows: rawRows(page.items, (item) => String(item.id)), state: page.metadata }
+      },
+    })],
+  })
+  const run = (maxChunks?: number, sink: DestinationAdapter = destination) => runIngestion({
+    selected: selectStreams([pipeline(maxChunks)], []), backfill: undefined,
+  }, { journal, destination: sink })
+
+  const paused = await run(1)
+  expect(paused.streams[0]?.outcome).toBe('budget_exhausted')
+  expect((await journal.readCheckpoint('test.changes')).envelope?.state).toEqual({ syncToken: 'S0', pageToken: 'P2' })
+  expect(destination.tables.get('test.changes')?.map((row) => row.id)).toEqual(['1'])
+
+  const failed = await run(undefined, { async insert() { throw new TypeError('destination write failed') } })
+  expect(failed.streams[0]?.outcome).toBe('failed')
+  expect(failed.streams[0]?.error).toContain('destination write failed')
+  expect((await journal.readCheckpoint('test.changes')).envelope?.state).toEqual({ syncToken: 'S0', pageToken: 'P2' })
+
+  expect((await run()).ok).toBe(true)
+  expect((await journal.readCheckpoint('test.changes')).envelope?.state).toEqual({ syncToken: 'S1' })
+  expect(destination.tables.get('test.changes')?.map((row) => row.id)).toEqual(['1', '2'])
+
+  expect((await run()).ok).toBe(true)
+  expect((await journal.readCheckpoint('test.changes')).envelope?.state).toEqual({ syncToken: 'S2' })
+  expect(journal.events.filter((event) => event.eventKind === 'batch_committed').at(-1)?.sinkEvidence).toBe('none_required')
+  expect(destination.tables.get('test.changes')?.map((row) => row.id)).toEqual(['1', '2'])
+  expect(requested).toEqual([
+    { syncToken: 'S0', pageToken: undefined },
+    { syncToken: 'S0', pageToken: 'P2' }, { syncToken: 'S0', pageToken: 'P3' },
+    { syncToken: 'S0', pageToken: 'P2' }, { syncToken: 'S0', pageToken: 'P3' },
+    { syncToken: 'S1', pageToken: undefined },
+  ])
+})
+
+function fetchContext(signal = new AbortController().signal): FetchContext {
+  return { signal, attempt: (operation) => operation(signal) }
+}
+
+function parseProgress(raw: unknown): Progress {
+  if (typeof raw !== 'object' || raw === null || !('syncToken' in raw) || typeof raw.syncToken !== 'string') {
+    throw new IngestConfigError('Progress has no sync token.')
+  }
+  if ('pageToken' in raw && raw.pageToken !== undefined) {
+    if (typeof raw.pageToken !== 'string') throw new IngestConfigError('Progress has an invalid page token.')
+    return { syncToken: raw.syncToken, pageToken: raw.pageToken }
+  }
+  return { syncToken: raw.syncToken }
+}
diff --git a/packages/plugin-ingest/src/paginate.ts b/packages/plugin-ingest/src/paginate.ts
index cfa8ff1f..03ab0a8e 100644
--- a/packages/plugin-ingest/src/paginate.ts
+++ b/packages/plugin-ingest/src/paginate.ts
@@ -1,15 +1,18 @@
+import { IngestConfigError } from './errors.js'
 import { canonicalJson } from './journal.js'
 import type { AttemptOptions, FetchContext } from './types.js'
 
-export interface Page<TItem, TCursor> {
+export interface Page<TItem, TCursor, TMetadata = undefined> {
   items: readonly TItem[]
   /** Continuation for the next request; `undefined` ends the sequence. */
   next: TCursor | undefined
+  /** Provider metadata passed through unchanged; readers explicitly map it to candidate state. */
+  metadata?: TMetadata
 }
 
-export interface PaginateOptions<TItem, TCursor> {
+export interface PaginateOptions<TItem, TCursor, TMetadata = undefined> {
   context: FetchContext
-  fetchPage(cursor: TCursor | undefined, signal: AbortSignal): Promise<Page<TItem, TCursor>>
+  fetchPage(cursor: TCursor | undefined, signal: AbortSignal): Promise<Page<TItem, TCursor, TMetadata>>
   initial?: TCursor
   label?: AttemptOptions['label']
 }
@@ -19,12 +22,15 @@ export interface PaginateOptions<TItem, TCursor> {
  * runs through the executor attempt capability. A continuation that was already
  * seen (compared by canonical serialization) is rejected, so a cyclic provider
  * cursor cannot loop forever; other non-progress is bounded by execution budgets.
+ * Every complete page is yielded, including empty and terminal pages. Metadata
+ * does not advance checkpoints unless the reader includes it in SourceChunk.state.
  */
-export async function* paginate<TItem, TCursor>(
-  options: PaginateOptions<TItem, TCursor>
-): AsyncGenerator<readonly TItem[], void, void> {
+export async function* paginate<TItem, TCursor, TMetadata = undefined>(
+  options: PaginateOptions<TItem, TCursor, TMetadata>
+): AsyncGenerator<Page<TItem, TCursor, TMetadata>, void, void> {
   const seen = new Set<string>()
   let cursor = options.initial
+  if (cursor !== undefined) seen.add(canonicalJson(cursor))
 
   while (true) {
     options.context.signal.throwIfAborted()
@@ -32,14 +38,17 @@ export async function* paginate<TItem, TCursor>(
     const page = await options.context.attempt((signal) => options.fetchPage(current, signal), {
       label: options.label,
     })
-    if (page.items.length > 0) yield page.items
-    if (page.next === undefined || page.next === null) return
-
-    const key = canonicalJson(page.next)
-    if (seen.has(key)) {
-      throw new Error(`paginate: provider returned a repeated continuation ${key}; refusing to loop.`)
+    options.context.signal.throwIfAborted()
+    const next = page.next
+    if (next !== undefined && next !== null) {
+      const key = canonicalJson(next)
+      if (seen.has(key)) {
+        throw new IngestConfigError(`paginate: provider returned a repeated continuation ${key}; refusing to loop.`)
+      }
+      seen.add(key)
     }
-    seen.add(key)
-    cursor = page.next
+    yield page
+    if (next === undefined || next === null) return
+    cursor = next
   }
 }
diff --git a/registry/attio/README.md b/registry/attio/README.md
index 155f47cf..787b4d76 100644
--- a/registry/attio/README.md
+++ b/registry/attio/README.md
@@ -30,9 +30,13 @@ bunx chkit ingest run --tag provider:attio
 
 The schema uses native JSON (ClickHouse 25.3 or newer). A direct ClickHouse connection is required; workbench-only execution is not supported. Use an external scheduler to repeat the run command, with one ingestion process per project/target at a time.
 
+`createAttioPipeline(config, deps)` snapshots reader settings and configured collections for one installation. Database and table prefix belong to setup-time `attioConfig`: the factory uses the exported raw tables and does not redefine storage.
+
 ## Included resources
 
-All nine streams perform full reads on each run. Every stream can run alone and discovers its own parent objects/lists; it does not rely on another stream having run first.
+Each configured object type has its own records and object-attributes streams. The defaults create separate People and Companies readers; tasks, notes, members, and the object/list catalogs have workspace-wide streams. Each configured list similarly gets independent entries and list-attributes streams. The number of streams depends on `objects` and `lists`; the default configuration has nine streams writing to seven resource tables. All nine raw tables are defined, including entries and list attributes, whose readers are enabled by configuring `lists`.
+
+Every stream uses `fullSync()` and the existing pagination helper. A records reader fetches one configured object type, such as People, rather than looping over all object types. An interrupted stream restarts its collection at offset zero because Attio's mutable offsets are not durable cursors. Each stream has its own execution journal; no parent-completion ledger or custom scan state is needed.
 
 | Stream tag | Raw table | Required Attio scopes |
 | --- | --- | --- |
@@ -46,7 +50,7 @@ All nine streams perform full reads on each run. Every stream can run alone and
 | `resource:tasks` | `attio_tasks_raw` | `task:read`, `object_configuration:read`, `record_permission:read`, `user_management:read` |
 | `resource:members` | `attio_members_raw` | `user_management:read` |
 
-Records include all accessible standard and custom objects returned by the [objects API](https://docs.attio.com/rest-api/endpoint-reference/objects/list-objects). Standard `users` records are distinct from [workspace members](https://docs.attio.com/rest-api/endpoint-reference/workspace-members/list-workspace-members). Attribute streams include archived attribute definitions; separate select-option/status catalogs and historical attribute values are not fetched. Active record/entry payloads retain their returned select/status values.
+The objects and lists catalog streams retain all accessible metadata. Records and attributes are fetched only for the object types configured in `objects`; entries and list attributes require configured `lists`. Standard `users` records, when explicitly configured, are distinct from [workspace members](https://docs.attio.com/rest-api/endpoint-reference/workspace-members/list-workspace-members). Attribute streams include archived attribute definitions; separate select-option/status catalogs and historical attribute values are not fetched. Active record/entry payloads retain their returned select/status values.
 
 The template does not collect meetings, call recordings, transcripts, emails, files, comments, or historical attribute values. It does not receive webhooks or detect source deletions/merges. Coverage is limited to data the token can access. A permission error fails that stream with a diagnostic; it is never treated as an empty dataset.
 
@@ -54,18 +58,28 @@ API references: [attributes](https://docs.attio.com/rest-api/endpoint-reference/
 
 ## Customize the source
 
-Each file in `sources/` contains one resource's raw table and reader, such as `sources/notes.ts`, `sources/tasks.ts`, or `sources/members.ts`. `sources/records.ts` also defines the people, company, and deal views. `client.ts` shares HTTP and pagination logic; `pipeline.ts` composes the nine streams.
+Each file in `sources/` contains one resource's raw table and reader, such as `sources/notes.ts`, `sources/tasks.ts`, or `sources/members.ts`. `sources/records.ts` also defines the people, company, and deal views. `client.ts` shares HTTP, validation, and pagination logic; `pipeline.ts` creates streams from the explicit object/list configuration.
 
 Remove an entry from `pipeline.ts` to stop collecting that resource. Keep its schema export in `index.ts` to preserve already collected data. Removing schema exports can generate destructive migration operations, which should be reviewed. After removing a resource's stream and schema export, its local files can also be deleted.
 
-Set `objects` and `lists` in `config.ts` to arrays of API slugs or IDs to restrict discovery. `undefined` means all accessible parents; `[]` means none. Unknown configured parents fail visibly. Object selection affects objects, object attributes, and records. List selection affects lists, list attributes, and entries. Notes, tasks, and members remain workspace-wide; customize their readers separately if narrower scope is needed.
+Set `objects` and `lists` in `config.ts` to explicit arrays of API slugs or IDs. Defaults are `objects: ['people', 'companies']` and `lists: []`. Add `deals` or a custom object slug to collect that type; add list slugs or IDs to collect entries. `[]` disables the corresponding object/list child streams. The stream graph is built from these arrays without API discovery, so schema imports and `ingest list` remain offline. A reader resolves its one configured slug or ID through Attio and fails visibly if it is unknown or inaccessible. The objects/lists catalogs still collect all accessible metadata; notes, tasks, and members remain workspace-wide.
+
+Object streams use `<sourceId>.records.<ref>` and `<sourceId>.object_attributes.<ref>`. List streams use `<sourceId>.entries.<ref>` and `<sourceId>.list_attributes.<ref>`. Each has independent journal progress even though streams of the same resource write to the same raw table. Keep configured references stable: changing from a slug to its equivalent ID changes the stream ID.
 
-To run only records:
+To run all configured records streams:
 
 ```sh
 bunx chkit ingest run --tag provider:attio --tag resource:records
 ```
 
+To run only People records:
+
+```sh
+bunx chkit ingest run --tag provider:attio --tag resource:records --tag object:people
+```
+
+Record streams carry `resource:records` and `object:<ref>`. Object-attribute streams carry `resource:object_attributes` and `object:<ref>`; entries/list-attribute streams carry their resource tag and `list:<ref>`.
+
 `pageSize` defaults to 500. Notes have a separate `notesPageSize` of 50, the documented maximum. Requests go through the ingestion executor's retry/cancellation context, with a 30-second request timeout. The serial pipeline leaves a 25ms gap before each request and a 125ms gap for notes; raising concurrency requires revisiting rate control. `429` responses retain `Retry-After` for executor backoff. Attio also limits query complexity; a permanently expensive query may need simpler filters/sorts rather than repeated retries. See [rate limits](https://docs.attio.com/rest-api/guides/rate-limiting).
 
 ## Stored data and editable views
@@ -87,9 +101,13 @@ FROM default.attio_records_raw FINAL;
 | `attio_companies` | name, domain array, description |
 | `attio_deals` | name, stage, nullable numeric value, currency code, company/people record ID arrays |
 
-All include the stable row `id`, `source_id`, `workspace_id`, `object_id`, `record_id`, nullable `created_at`, `web_url`, and `_chkit_ingested_at`. Missing optional strings yield empty strings, absent arrays yield empty arrays, and absent/unparseable dates or deal amounts yield null. A workspace without deals simply has an empty deals view. Edit these SQL projections to expose your custom fields, then generate and review a migration. The original payload remains available for further projections.
+All include the stable row `id`, `source_id`, `workspace_id`, `object_id`, `record_id`, nullable `created_at`, `web_url`, and `_chkit_ingested_at`. Missing optional strings yield empty strings, absent arrays yield empty arrays, and absent/unparseable dates or deal amounts yield null. The deals view remains empty until `deals` is configured and observed; previously loaded deal rows remain when it is later deselected. Edit these SQL projections to expose your custom fields, then generate and review a migration. The original payload remains available for further projections.
+
+The executor journal records per-stream execution and load completion, including successful empty reads. Every scheduled run reads each selected stream from the beginning. An interruption in Companies affects that stream's completion independently of People; the next Companies attempt starts at offset zero. The reader validates returned child workspace and parent IDs against its resolved object/list before publishing rows. The journal stores no Attio-specific cycle, parent inventory, or offset checkpoint. These full-sync readers ignore date bounds; date-range backfills are not supported.
+
+Upgrading from `0.1.2` to `0.2.0` changes records, object-attributes, entries, and list-attributes stream IDs to the per-type/per-list forms above. Those new stream IDs begin with fresh journal progress. Raw table schemas, row identities for the same `sourceId`, and all three views remain unchanged. Installed source is editable and is not automatically replaced by a registry update.
 
-These views show the latest **observed** version per ID, not a guaranteed snapshot of Attio now. Full reads update returned IDs without clearing tables. Deleted, merged, inaccessible, or deselected entities remain until you implement reconciliation. Data is published batch by batch, so a failed run may have loaded some updates. Offset pagination over changing source data can miss or duplicate entities within a scan. There is no universal modification cursor, atomic snapshot replacement, source-version ordering, or complete change history in this template.
+These views show the latest **observed** version per ID, not a guaranteed snapshot of Attio now. Full reads update returned IDs without clearing tables. Deleted, merged, inaccessible, or deselected entities remain until you implement reconciliation. Data is published batch by batch, so a failed run may have loaded some updates. Offset pagination over changing source data can miss or duplicate entities within a read. There is no universal modification cursor, atomic snapshot replacement, source-version ordering, or complete change history in this template. No data-bearing chunk uses a page offset as its identity.
 
 ## Fixture tests
 
@@ -99,7 +117,7 @@ Install the optional test suite with `bunx chkit add attio --with-tests`, then r
 bun test src/integrations/attio/tests/attio.test.ts
 ```
 
-For a custom install path, point the command at that folder's `tests/attio.test.ts`. Tests mock Attio HTTP responses and use in-memory ingestion destinations and journals. They require Bun but no Attio credentials or ClickHouse server. The fixture suite checks resource coverage, pagination, preserved custom fields, repeat runs, cancellation, and error handling. Adjust the fixtures and expectations when customizing the source.
+For a custom install path, point the command at that folder's `tests/attio.test.ts`. Tests mock Attio HTTP responses and use in-memory ingestion destinations and journals. They require Bun but no Attio credentials or ClickHouse server. The fixture suite checks per-type stream selection, independent pagination, preserved custom fields, repeat runs, cancellation, errors, safe offset-zero restart, successful empty reads, and rows loaded before a journal failure. Adjust the fixtures and expectations when customizing the source.
 
 ## Smoke check
 
diff --git a/registry/attio/client.ts b/registry/attio/client.ts
index f704936b..05d0d882 100644
--- a/registry/attio/client.ts
+++ b/registry/attio/client.ts
@@ -1,12 +1,13 @@
 import { setTimeout as sleep } from 'node:timers/promises'
 
-import { HttpError, IngestConfigError, rawRows, type ErrorClassifier, type FetchContext } from '@chkit/plugin-ingest'
+import { HttpError, IngestConfigError, paginate, rawRows, type ErrorClassifier, type FetchContext } from '@chkit/plugin-ingest'
 
-import { attioConfig } from './config.js'
+import { attioConfig, type AttioReaderConfig } from './config.js'
 
 export type AttioEntity = Record<string, unknown> & { id: Record<string, string> }
 
 export interface AttioClientDeps {
+  config: AttioReaderConfig
   fetch: (url: string, init: RequestInit) => Promise<Response>
   token: () => string | undefined
   wait: (milliseconds: number, signal: AbortSignal) => Promise<void>
@@ -21,62 +22,96 @@ interface CollectionRequest {
   /** Omit for the unpaginated objects, lists, and workspace_members endpoints. */
   pageSize?: number
   valuesField?: 'values' | 'entry_values'
+  parent?: { field: 'object_id' | 'list_id'; id: string; workspaceId: string }
 }
 
-const defaultDeps: AttioClientDeps = {
+export const defaultAttioClientDeps: AttioClientDeps = {
+  config: attioConfig,
   fetch: (url, init) => fetch(url, init),
   token: () => process.env.ATTIO_API_TOKEN,
   wait: async (milliseconds, signal) => { await sleep(milliseconds, undefined, { signal }) },
 }
 
-/** Each page is validated inside attempt, so executor retry/cancellation owns every request. */
-export async function* readCollection(
+/** Resolve one configured object/list; each stream owns one collection. */
+export async function* readParentCollection(
   context: FetchContext,
-  request: CollectionRequest,
-  deps: AttioClientDeps = defaultDeps,
-): AsyncGenerator<AttioEntity[]> {
-  if (request.pageSize !== undefined && (!Number.isSafeInteger(request.pageSize) || request.pageSize <= 0)) {
-    throw new IngestConfigError('Attio pageSize must be a positive safe integer.')
-  }
-  let offset = 0
-  while (true) {
-    context.signal.throwIfAborted()
-    const currentOffset = offset
-    const page = await context.attempt(
-      (signal) => requestPage(request, currentOffset, signal, deps),
-      { label: `${request.method ?? 'GET'} /v2${request.path}` },
-    )
-    if (page.length > 0) yield page
-    if (request.pageSize === undefined || page.length < request.pageSize) return
-    offset += page.length
-    if (!Number.isSafeInteger(offset)) throw new IngestConfigError('Attio pagination offset exceeded the safe integer range.')
-  }
+  input: {
+    resource: string
+    parent: { kind: 'objects' | 'lists'; ref: string }
+    request: (parent: AttioEntity) => CollectionRequest
+  },
+  deps: AttioClientDeps = defaultAttioClientDeps,
+) {
+  const idField = input.parent.kind === 'objects' ? 'object_id' : 'list_id'
+  const path = `/${input.parent.kind}/${encodeURIComponent(input.parent.ref)}`
+  const parent = await context.attempt(async (signal) => {
+    const entity = parseEntity(await requestData({ path, idFields: ['workspace_id', idField] }, 0, signal, deps), {
+      path, idFields: ['workspace_id', idField],
+    })
+    entitySlug(entity)
+    if (input.parent.ref !== entityId(entity, idField) && input.parent.ref !== entitySlug(entity)) {
+      throw new IngestConfigError(`Attio ${path} returned a different configured parent.`)
+    }
+    return entity
+  }, { label: `GET /v2${path}` })
+  const request = { ...input.request(parent), parent: {
+    field: input.parent.kind === 'objects' || input.resource === 'list_attributes' ? 'object_id' as const : 'list_id' as const,
+    id: entityId(parent, idField), workspaceId: entityId(parent, 'workspace_id'),
+  } }
+  yield* readRows(context, {
+    resource: input.resource, request,
+    metadata: input.parent.kind === 'objects' ? { object_slug: entitySlug(parent) } : { list_slug: entitySlug(parent) },
+  }, deps)
 }
 
-export async function discoverObjects(context: FetchContext, deps?: AttioClientDeps): Promise<AttioEntity[]> {
-  for await (const objects of readCollection(context, { path: '/objects', idFields: ['workspace_id', 'object_id'] }, deps)) {
-    return selectEntities(objects, attioConfig.objects, 'object_id')
+export async function* readRows(
+  context: FetchContext,
+  input: { resource: string; request: CollectionRequest; metadata?: { object_slug?: string; list_slug?: string } },
+  deps: AttioClientDeps = defaultAttioClientDeps,
+) {
+  for await (const page of readCollection(context, input.request, deps)) {
+    yield { rows: toAttioRows(page.items, input.resource, input.request.idFields, input.metadata, deps.config.sourceId) }
   }
-  return selectEntities([], attioConfig.objects, 'object_id')
 }
 
-export async function discoverLists(context: FetchContext, deps?: AttioClientDeps): Promise<AttioEntity[]> {
-  for await (const lists of readCollection(context, { path: '/lists', idFields: ['workspace_id', 'list_id'] }, deps)) {
-    return selectEntities(lists, attioConfig.lists, 'list_id')
+/** Each page is validated inside attempt, so executor retry/cancellation owns every request. */
+export function readCollection(
+  context: FetchContext,
+  request: CollectionRequest,
+  deps: AttioClientDeps = defaultAttioClientDeps,
+) {
+  if (request.pageSize !== undefined && (!Number.isSafeInteger(request.pageSize) || request.pageSize <= 0)) {
+    throw new IngestConfigError('Attio pageSize must be a positive safe integer.')
   }
-  return selectEntities([], attioConfig.lists, 'list_id')
+  return paginate({
+    context, initial: 0, label: `${request.method ?? 'GET'} /v2${request.path}`,
+    fetchPage: async (offset = 0, signal) => {
+      const data = await requestData(request, offset, signal, deps)
+      if (!Array.isArray(data)) throw new IngestConfigError(`Attio ${request.path} returned no data array.`)
+      const items = data.map((value: unknown) => parseEntity(value, request))
+      if (request.pageSize !== undefined && items.length > request.pageSize) {
+        throw new IngestConfigError(`Attio ${request.path} returned more rows than the requested page size.`)
+      }
+      const next = request.pageSize !== undefined && items.length === request.pageSize ? offset + items.length : undefined
+      if (next !== undefined && !Number.isSafeInteger(next)) {
+        throw new IngestConfigError('Attio pagination offset exceeded the safe integer range.')
+      }
+      return { items, next }
+    },
+  })
 }
 
 /** Original provider fields stay under data; metadata does not overwrite custom attributes. */
-export function toAttioRows(
+function toAttioRows(
   items: readonly AttioEntity[],
   resource: string,
   idFields: readonly string[],
   metadata: { object_slug?: string; list_slug?: string } = {},
+  sourceId = attioConfig.sourceId,
 ) {
   return rawRows(
-    items.map((data) => ({ source_id: attioConfig.sourceId, ...metadata, data })),
-    ({ data }) => JSON.stringify([attioConfig.sourceId, resource, ...idFields.map((field) => entityId(data, field))]),
+    items.map((data) => ({ source_id: sourceId, ...metadata, data })),
+    ({ data }) => JSON.stringify([sourceId, resource, ...idFields.map((field) => entityId(data, field))]),
   )
 }
 
@@ -86,7 +121,7 @@ export function entityId(entity: AttioEntity, field: string): string {
   return value
 }
 
-export function entitySlug(entity: AttioEntity): string {
+function entitySlug(entity: AttioEntity): string {
   if (typeof entity.api_slug !== 'string' || entity.api_slug.length === 0) {
     throw new IngestConfigError('Attio object/list is missing api_slug.')
   }
@@ -100,12 +135,12 @@ export const classifyAttioError: ErrorClassifier = (cause) => {
   return undefined
 }
 
-async function requestPage(
+async function requestData(
   request: CollectionRequest,
   offset: number,
   signal: AbortSignal,
   deps: AttioClientDeps,
-): Promise<AttioEntity[]> {
+): Promise<unknown> {
   const token = deps.token()?.trim()
   if (!token) throw new IngestConfigError('Set ATTIO_API_TOKEN before running Attio ingestion. Schema imports do not need credentials.')
   const url = new URL(`https://api.attio.com/v2${request.path}`)
@@ -134,27 +169,19 @@ async function requestPage(
     throw error
   }
   const payload: unknown = await response.json()
-  if (!isObject(payload) || !Array.isArray(payload.data)) {
-    throw new IngestConfigError(`Attio ${request.path} returned no data array.`)
+  if (!isObject(payload) || !('data' in payload)) {
+    throw new IngestConfigError(`Attio ${request.path} returned no data field.`)
   }
-  return payload.data.map((value: unknown) => parseEntity(value, request))
-}
-
-function selectEntities(entities: AttioEntity[], selection: readonly string[] | undefined, idField: string): AttioEntity[] {
-  // Validate slugs even when all resources are selected: records/views rely on this metadata.
-  for (const entity of entities) entitySlug(entity)
-  if (selection === undefined) return entities
-  for (const wanted of selection) {
-    if (!entities.some((entity) => entityId(entity, idField) === wanted || entitySlug(entity) === wanted)) {
-      throw new IngestConfigError(`Configured Attio ${idField} or slug "${wanted}" was not found or is not accessible.`)
-    }
-  }
-  return entities.filter((entity) => selection.includes(entityId(entity, idField)) || selection.includes(entitySlug(entity)))
+  return payload.data
 }
 
 function parseEntity(value: unknown, request: CollectionRequest): AttioEntity {
   if (!isEntity(value)) throw new IngestConfigError(`Attio ${request.path} returned an entity without a valid id object.`)
   for (const field of request.idFields) entityId(value, field)
+  if (request.parent && (entityId(value, 'workspace_id') !== request.parent.workspaceId
+    || entityId(value, request.parent.field) !== request.parent.id)) {
+    throw new IngestConfigError(`Attio ${request.path} returned an entity from a different workspace or parent than the resolved collection.`)
+  }
   if (request.valuesField !== undefined) {
     const values = value[request.valuesField]
     if (!isObject(values) || !Object.values(values).every(Array.isArray)) {
diff --git a/registry/attio/config.ts b/registry/attio/config.ts
index 24dda4f6..ddca68be 100644
--- a/registry/attio/config.ts
+++ b/registry/attio/config.ts
@@ -3,20 +3,23 @@ export interface AttioConfig {
   sourceId: string
   database: string
   tablePrefix: string
-  /** Undefined reads every accessible object/list; otherwise use UUIDs or API slugs. */
-  objects: readonly string[] | undefined
-  lists: readonly string[] | undefined
+  /** Each UUID or API slug creates its own records and attributes streams. */
+  objects: readonly string[]
+  /** Each UUID or API slug creates its own entries and attributes streams. */
+  lists: readonly string[]
   pageSize: number
   notesPageSize: number
 }
 
+export type AttioReaderConfig = Omit<AttioConfig, 'database' | 'tablePrefix'>
+
 // Keep these values stable across runs. Credentials are read only in client.ts at request time.
 export const attioConfig: AttioConfig = {
   sourceId: 'attio.primary',
   database: 'default',
   tablePrefix: 'attio',
-  objects: undefined,
-  lists: undefined,
+  objects: ['people', 'companies'],
+  lists: [],
   pageSize: 500,
   notesPageSize: 50,
 }
diff --git a/registry/attio/index.ts b/registry/attio/index.ts
index 360bffcf..d5171bfb 100644
--- a/registry/attio/index.ts
+++ b/registry/attio/index.ts
@@ -1,4 +1,4 @@
-export { attio } from './pipeline.js'
+export { attio, createAttioPipeline } from './pipeline.js'
 export { attioObjectsRaw } from './sources/objects.js'
 export { attioObjectAttributesRaw } from './sources/object-attributes.js'
 export { attioRecordsRaw, attioPeople, attioCompanies, attioDeals } from './sources/records.js'
diff --git a/registry/attio/manifest.json b/registry/attio/manifest.json
index 6db63bfc..f6fe6634 100644
--- a/registry/attio/manifest.json
+++ b/registry/attio/manifest.json
@@ -3,10 +3,10 @@
   "name": "attio",
   "type": "registry:item",
   "title": "Attio",
-  "description": "Editable Attio CRM schemas, raw data readers, typed views, and full-read ingestion pipelines.",
+  "description": "Editable Attio CRM schemas, raw data readers, typed views, and independent streams for People, Companies, configured custom types, and workspace resources.",
   "dependencies": [
-    "@chkit/core@^0.2.0-beta.8",
-    "@chkit/plugin-ingest@^0.2.0-beta.8"
+    "@chkit/core@^0.2.0-beta.10",
+    "@chkit/plugin-ingest@^0.2.0-beta.10"
   ],
   "files": [
     {
@@ -95,18 +95,49 @@
   "meta": {
     "chkit": {
       "formatVersion": 1,
-      "version": "0.1.2",
+      "version": "0.2.0",
+      "changelog": [
+        {
+          "version": "0.2.0",
+          "changes": [
+            "Give People, Companies, each configured object type, and each configured list independent ingestion streams using chkit pagination.",
+            "Group those resource streams in one installation pipeline and bind factory reader settings independently of setup-time storage definitions.",
+            "Make object and list selection explicit, with People and Companies enabled by default; replay interrupted mutable offset reads from the beginning of that stream.",
+            "Preserve raw tables, scoped row identities, and typed views while changing child stream IDs; include fixtures for stream independence and failure recovery.",
+            "Consume the ingestion plugin's full pagination pages, preserving continuations and empty terminal pages with independent resource checkpoints."
+          ]
+        },
+        {
+          "version": "0.1.2",
+          "changes": [
+            "Consolidate schemas and readers into resource modules, include portable fixture tests, and document authentication, resources, views, and sync behavior."
+          ]
+        },
+        {
+          "version": "0.1.1",
+          "changes": [
+            "Add integration guide and logo metadata; distributed source is unchanged."
+          ]
+        },
+        {
+          "version": "0.1.0",
+          "changes": [
+            "Introduce raw CRM objects, attributes, records, lists, entries, notes, tasks, and workspace members, with People, Companies, and Deals views."
+          ]
+        }
+      ],
       "documentation": "https://chkit.obsessiondb.com/integrations/attio/",
       "logo": "https://chkit.obsessiondb.com/logos/attio.svg",
       "language": "typescript",
       "license": "MIT",
-      "chkit": "^0.2.0-beta.8",
-      "ingest": "^0.2.0-beta.8",
+      "chkit": "^0.2.0-beta.10",
+      "ingest": "^0.2.0-beta.10",
       "clickhouse": ">=25.3.0",
       "root": "src/integrations/attio",
       "entry": "index.ts",
       "exports": [
         "attio",
+        "createAttioPipeline",
         "attioObjectsRaw",
         "attioObjectAttributesRaw",
         "attioRecordsRaw",
@@ -152,12 +183,17 @@
               "method": "GET",
               "path": "/objects/{object_id}/attributes",
               "documentation": "https://docs.attio.com/rest-api/endpoint-reference/attributes/list-attributes"
+            },
+            {
+              "method": "GET",
+              "path": "/objects/{object_id}",
+              "documentation": "https://docs.attio.com/rest-api/endpoint-reference/objects/get-an-object"
             }
           ]
         },
         {
           "name": "records",
-          "description": "Current records for every selected object, IDs, creation time, Attio URL, and the complete values object with all returned attribute arrays",
+          "description": "Independent records streams for configured object types (People and Companies by default), IDs, creation time, Attio URL, and the complete values object with all returned attribute arrays",
           "scopes": [
             "object_configuration:read",
             "record_permission:read"
@@ -170,6 +206,11 @@
               "method": "POST",
               "path": "/objects/{object_id}/records/query",
               "documentation": "https://docs.attio.com/rest-api/endpoint-reference/records/list-records"
+            },
+            {
+              "method": "GET",
+              "path": "/objects/{object_id}",
+              "documentation": "https://docs.attio.com/rest-api/endpoint-reference/objects/get-an-object"
             }
           ]
         },
@@ -204,6 +245,11 @@
               "method": "GET",
               "path": "/lists/{list_id}/attributes",
               "documentation": "https://docs.attio.com/rest-api/endpoint-reference/attributes/list-attributes"
+            },
+            {
+              "method": "GET",
+              "path": "/lists/{list_id}",
+              "documentation": "https://docs.attio.com/rest-api/endpoint-reference/lists/get-a-list"
             }
           ]
         },
@@ -222,6 +268,11 @@
               "method": "POST",
               "path": "/lists/{list_id}/entries/query",
               "documentation": "https://docs.attio.com/rest-api/endpoint-reference/entries/list-entries"
+            },
+            {
+              "method": "GET",
+              "path": "/lists/{list_id}",
+              "documentation": "https://docs.attio.com/rest-api/endpoint-reference/lists/get-a-list"
             }
           ]
         },
@@ -316,7 +367,7 @@
         }
       ],
       "sync": {
-        "description": "Every run discovers the selected objects and lists and reads every page of each enabled resource. Stable row IDs retain the latest observed version in ClickHouse.",
+        "description": "People, Companies, each configured custom object/list, and workspace resources have independent full-sync streams. Each reader paginates one collection through chkit-ingest; interrupted mutable offset reads replay that collection from zero. Completed and empty reads are recorded by the executor journal without a custom scan checkpoint. Custom types and lists must be configured explicitly.",
         "schedule": "Run chkit ingest run through cron, CI, or an existing scheduler; the template does not start a background worker.",
         "deletions": "Records absent from a later API response remain in ClickHouse. The template does not propagate deletions or consume webhooks."
       }
diff --git a/registry/attio/pipeline.ts b/registry/attio/pipeline.ts
index 002a9c84..bc7da7d1 100644
--- a/registry/attio/pipeline.ts
+++ b/registry/attio/pipeline.ts
@@ -1,7 +1,7 @@
 import { definePipeline, defineStream } from '@chkit/plugin-ingest'
 
-import { classifyAttioError } from './client.js'
-import { attioConfig } from './config.js'
+import { classifyAttioError, defaultAttioClientDeps, type AttioClientDeps } from './client.js'
+import { attioConfig, type AttioReaderConfig } from './config.js'
 import { attioObjectsRaw, readObjects } from './sources/objects.js'
 import { attioObjectAttributesRaw, readObjectAttributes } from './sources/object-attributes.js'
 import { attioRecordsRaw, readRecords } from './sources/records.js'
@@ -14,24 +14,33 @@ import { attioMembersRaw, readMembers } from './sources/members.js'
 
 const streamOptions = { classifyError: classifyAttioError, batchSize: 500 }
 
-// Delete a stream entry to stop collecting it. Keep its schema export to retain existing data.
-// Every reader discovers its own parents; this array does not establish execution dependencies.
-export const attio = definePipeline({
-  id: attioConfig.sourceId,
-  tags: ['provider:attio'],
-  maxStreams: 1,
-  maxFetches: 1,
-  maxLoads: 1,
-  retry: { retries: 5, minTimeout: 1_000, maxTimeout: 30_000, randomize: true },
-  streams: [
-    defineStream({ ...streamOptions, id: `${attioConfig.sourceId}.objects`, tags: ['resource:objects'], destination: attioObjectsRaw, read: readObjects }),
-    defineStream({ ...streamOptions, id: `${attioConfig.sourceId}.object_attributes`, tags: ['resource:object_attributes'], destination: attioObjectAttributesRaw, read: readObjectAttributes }),
-    defineStream({ ...streamOptions, id: `${attioConfig.sourceId}.records`, tags: ['resource:records'], destination: attioRecordsRaw, read: readRecords }),
-    defineStream({ ...streamOptions, id: `${attioConfig.sourceId}.lists`, tags: ['resource:lists'], destination: attioListsRaw, read: readLists }),
-    defineStream({ ...streamOptions, id: `${attioConfig.sourceId}.list_attributes`, tags: ['resource:list_attributes'], destination: attioListAttributesRaw, read: readListAttributes }),
-    defineStream({ ...streamOptions, id: `${attioConfig.sourceId}.entries`, tags: ['resource:entries'], destination: attioEntriesRaw, read: readEntries }),
-    defineStream({ ...streamOptions, id: `${attioConfig.sourceId}.notes`, tags: ['resource:notes'], destination: attioNotesRaw, read: readNotes }),
-    defineStream({ ...streamOptions, id: `${attioConfig.sourceId}.tasks`, tags: ['resource:tasks'], destination: attioTasksRaw, read: readTasks }),
-    defineStream({ ...streamOptions, id: `${attioConfig.sourceId}.members`, tags: ['resource:members'], destination: attioMembersRaw, read: readMembers }),
-  ],
-})
+// One records stream per object type; no reader traverses other objects.
+// Keep schema exports when removing streams to retain existing stored data.
+export function createAttioPipeline(config: AttioReaderConfig = attioConfig, deps: AttioClientDeps = defaultAttioClientDeps) {
+  const client = { ...deps, config: { ...config, objects: [...config.objects], lists: [...config.lists] } }
+  return definePipeline({
+    id: config.sourceId,
+    tags: ['provider:attio'],
+    maxStreams: 1,
+    maxFetches: 1,
+    maxLoads: 1,
+    retry: { retries: 5, minTimeout: 1_000, maxTimeout: 30_000, randomize: true },
+    streams: [
+      defineStream({ ...streamOptions, id: `${config.sourceId}.objects`, tags: ['resource:objects'], destination: attioObjectsRaw, read: (context) => readObjects(context, client) }),
+      ...config.objects.flatMap((object) => [
+        defineStream({ ...streamOptions, id: `${config.sourceId}.records.${object}`, tags: ['resource:records', `object:${object}`], destination: attioRecordsRaw, read: (context) => readRecords(context, object, client) }),
+        defineStream({ ...streamOptions, id: `${config.sourceId}.object_attributes.${object}`, tags: ['resource:object_attributes', `object:${object}`], destination: attioObjectAttributesRaw, read: (context) => readObjectAttributes(context, object, client) }),
+      ]),
+      defineStream({ ...streamOptions, id: `${config.sourceId}.lists`, tags: ['resource:lists'], destination: attioListsRaw, read: (context) => readLists(context, client) }),
+      ...config.lists.flatMap((list) => [
+        defineStream({ ...streamOptions, id: `${config.sourceId}.entries.${list}`, tags: ['resource:entries', `list:${list}`], destination: attioEntriesRaw, read: (context) => readEntries(context, list, client) }),
+        defineStream({ ...streamOptions, id: `${config.sourceId}.list_attributes.${list}`, tags: ['resource:list_attributes', `list:${list}`], destination: attioListAttributesRaw, read: (context) => readListAttributes(context, list, client) }),
+      ]),
+      defineStream({ ...streamOptions, id: `${config.sourceId}.notes`, tags: ['resource:notes'], destination: attioNotesRaw, read: (context) => readNotes(context, client) }),
+      defineStream({ ...streamOptions, id: `${config.sourceId}.tasks`, tags: ['resource:tasks'], destination: attioTasksRaw, read: (context) => readTasks(context, client) }),
+      defineStream({ ...streamOptions, id: `${config.sourceId}.members`, tags: ['resource:members'], destination: attioMembersRaw, read: (context) => readMembers(context, client) }),
+    ],
+  })
+}
+
+export const attio = createAttioPipeline()
diff --git a/registry/attio/releases/0.2.0.json b/registry/attio/releases/0.2.0.json
new file mode 100644
index 00000000..ac931297
--- /dev/null
+++ b/registry/attio/releases/0.2.0.json
@@ -0,0 +1,413 @@
+{
+  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
+  "name": "attio",
+  "type": "registry:item",
+  "title": "Attio",
+  "description": "Editable Attio CRM schemas, raw data readers, typed views, and independent streams for People, Companies, configured custom types, and workspace resources.",
+  "dependencies": [
+    "@chkit/core@^0.2.0-beta.10",
+    "@chkit/plugin-ingest@^0.2.0-beta.10"
+  ],
+  "devDependencies": [
+    "@types/bun@^1.2.0"
+  ],
+  "files": [
+    {
+      "path": "attio/README.md",
+      "type": "registry:file",
+      "target": "src/integrations/attio/README.md",
+      "content": "# Attio CRM ingestion\n\nThis is your source code: edit the API readers, schemas, views, and `pipeline.ts` directly. It uses the [chkit CLI](https://www.npmjs.com/package/chkit), `@chkit/core`, and `@chkit/plugin-ingest`; there is no runtime connection to the template registry.\n\n## First run\n\nSet `ATTIO_API_TOKEN` in your execution environment and configure the project's direct ClickHouse connection. A single-workspace API token works; an OAuth access token also works, but this template does not implement OAuth issuance or refresh. See [Attio authentication](https://docs.attio.com/rest-api/guides/authentication).\n\n### Create an Attio API key\n\n1. As a workspace admin, open the workspace-name dropdown in Attio and select **Workspace settings**.\n2. Open **Developers**, select **+ New access token**, and name the token, for example **chkit ClickHouse**.\n3. Grant the read scopes in the resource table below for the streams to run.\n4. Click the token on the Developers page to copy it. Set `ATTIO_API_TOKEN` in the project's `.env` file or the scheduler's secret environment.\n\nSee Attio's [API key instructions](https://attio.com/help/reference/apps/generating-an-api-key). Use a single-workspace API token for this setup; OAuth token creation and refresh require a separate application flow.\n\nBun loads a project `.env` automatically. With Node or a scheduler, explicitly supply environment variables using that runtime's environment-loading mechanism. `.env.example` only lists required variable names; it does not load values. Schema imports, `check`, and `ingest list` do not read the token or make API requests.\n\nReview `config.ts` before the first migration. The default target database is `default`; raw table and view names begin with `attio_`. Use a stable, non-secret `sourceId` for this source instance. For another installation, give it a distinct source ID and table prefix or database before exporting its pipeline. Changing these after ingestion changes stream/storage identities and requires a deliberate migration.\n\n```sh\nbunx chkit check\nbunx chkit ingest list --tag provider:attio\nbunx chkit generate --name add_attio\n# Review the generated SQL.\nbunx chkit migrate --apply\nbunx chkit ingest run --tag provider:attio\n```\n\nThe schema uses native JSON (ClickHouse 25.3 or newer). A direct ClickHouse connection is required; workbench-only execution is not supported. Use an external scheduler to repeat the run command, with one ingestion process per project/target at a time.\n\n`createAttioPipeline(config, deps)` snapshots reader settings and configured collections for one installation. Database and table prefix belong to setup-time `attioConfig`: the factory uses the exported raw tables and does not redefine storage.\n\n## Included resources\n\nEach configured object type has its own records and object-attributes streams. The defaults create separate People and Companies readers; tasks, notes, members, and the object/list catalogs have workspace-wide streams. Each configured list similarly gets independent entries and list-attributes streams. The number of streams depends on `objects` and `lists`; the default configuration has nine streams writing to seven resource tables. All nine raw tables are defined, including entries and list attributes, whose readers are enabled by configuring `lists`.\n\nEvery stream uses `fullSync()` and the existing pagination helper. A records reader fetches one configured object type, such as People, rather than looping over all object types. An interrupted stream restarts its collection at offset zero because Attio's mutable offsets are not durable cursors. Each stream has its own execution journal; no parent-completion ledger or custom scan state is needed.\n\n| Stream tag | Raw table | Required Attio scopes |\n| --- | --- | --- |\n| `resource:objects` | `attio_objects_raw` | `object_configuration:read` |\n| `resource:object_attributes` | `attio_object_attributes_raw` | `object_configuration:read` |\n| `resource:records` | `attio_records_raw` | `object_configuration:read`, `record_permission:read` |\n| `resource:lists` | `attio_lists_raw` | `list_configuration:read` |\n| `resource:list_attributes` | `attio_list_attributes_raw` | `list_configuration:read` |\n| `resource:entries` | `attio_entries_raw` | `list_configuration:read`, `list_entry:read` |\n| `resource:notes` | `attio_notes_raw` | `note:read`, `object_configuration:read`, `record_permission:read` |\n| `resource:tasks` | `attio_tasks_raw` | `task:read`, `object_configuration:read`, `record_permission:read`, `user_management:read` |\n| `resource:members` | `attio_members_raw` | `user_management:read` |\n\nThe objects and lists catalog streams retain all accessible metadata. Records and attributes are fetched only for the object types configured in `objects`; entries and list attributes require configured `lists`. Standard `users` records, when explicitly configured, are distinct from [workspace members](https://docs.attio.com/rest-api/endpoint-reference/workspace-members/list-workspace-members). Attribute streams include archived attribute definitions; separate select-option/status catalogs and historical attribute values are not fetched. Active record/entry payloads retain their returned select/status values.\n\nThe template does not collect meetings, call recordings, transcripts, emails, files, comments, or historical attribute values. It does not receive webhooks or detect source deletions/merges. Coverage is limited to data the token can access. A permission error fails that stream with a diagnostic; it is never treated as an empty dataset.\n\nAPI references: [attributes](https://docs.attio.com/rest-api/endpoint-reference/attributes/list-attributes), [records](https://docs.attio.com/rest-api/endpoint-reference/records/list-records), [lists](https://docs.attio.com/rest-api/endpoint-reference/lists/list-all-lists), [entries](https://docs.attio.com/rest-api/endpoint-reference/entries/list-entries), [notes](https://docs.attio.com/rest-api/endpoint-reference/notes/list-notes), [tasks](https://docs.attio.com/rest-api/endpoint-reference/tasks/list-tasks).\n\n## Customize the source\n\nEach file in `sources/` contains one resource's raw table and reader, such as `sources/notes.ts`, `sources/tasks.ts`, or `sources/members.ts`. `sources/records.ts` also defines the people, company, and deal views. `client.ts` shares HTTP, validation, and pagination logic; `pipeline.ts` creates streams from the explicit object/list configuration.\n\nRemove an entry from `pipeline.ts` to stop collecting that resource. Keep its schema export in `index.ts` to preserve already collected data. Removing schema exports can generate destructive migration operations, which should be reviewed. After removing a resource's stream and schema export, its local files can also be deleted.\n\nSet `objects` and `lists` in `config.ts` to explicit arrays of API slugs or IDs. Defaults are `objects: ['people', 'companies']` and `lists: []`. Add `deals` or a custom object slug to collect that type; add list slugs or IDs to collect entries. `[]` disables the corresponding object/list child streams. The stream graph is built from these arrays without API discovery, so schema imports and `ingest list` remain offline. A reader resolves its one configured slug or ID through Attio and fails visibly if it is unknown or inaccessible. The objects/lists catalogs still collect all accessible metadata; notes, tasks, and members remain workspace-wide.\n\nObject streams use `<sourceId>.records.<ref>` and `<sourceId>.object_attributes.<ref>`. List streams use `<sourceId>.entries.<ref>` and `<sourceId>.list_attributes.<ref>`. Each has independent journal progress even though streams of the same resource write to the same raw table. Keep configured references stable: changing from a slug to its equivalent ID changes the stream ID.\n\nTo run all configured records streams:\n\n```sh\nbunx chkit ingest run --tag provider:attio --tag resource:records\n```\n\nTo run only People records:\n\n```sh\nbunx chkit ingest run --tag provider:attio --tag resource:records --tag object:people\n```\n\nRecord streams carry `resource:records` and `object:<ref>`. Object-attribute streams carry `resource:object_attributes` and `object:<ref>`; entries/list-attribute streams carry their resource tag and `list:<ref>`.\n\n`pageSize` defaults to 500. Notes have a separate `notesPageSize` of 50, the documented maximum. Requests go through the ingestion executor's retry/cancellation context, with a 30-second request timeout. The serial pipeline leaves a 25ms gap before each request and a 125ms gap for notes; raising concurrency requires revisiting rate control. `429` responses retain `Retry-After` for executor backoff. Attio also limits query complexity; a permanently expensive query may need simpler filters/sorts rather than repeated retries. See [rate limits](https://docs.attio.com/rest-api/guides/rate-limiting).\n\n## Stored data and editable views\n\nEach raw table contains a stable `id`, native JSON `raw`, and chkit batch/run/ingestion-time metadata. The key includes source identity, resource kind, workspace ID, and every relevant object/list/entity ID. Names, emails, and domains are never keys.\n\nThe complete returned entity is retained under `raw.data`. The envelope adds `source_id`; record and object-attribute rows also include `object_slug`, and list-entry/list-attribute rows include `list_slug`. No custom attributes or multivalued arrays are flattened away. For example:\n\n```sql\nSELECT id, raw.data, _chkit_ingested_at\nFROM default.attio_records_raw FINAL;\n```\n\n`sources/records.ts` defines three ordinary `FINAL` views:\n\n| View | Editable projection |\n| --- | --- |\n| `attio_people` | name, email address array, company record ID array |\n| `attio_companies` | name, domain array, description |\n| `attio_deals` | name, stage, nullable numeric value, currency code, company/people record ID arrays |\n\nAll include the stable row `id`, `source_id`, `workspace_id`, `object_id`, `record_id`, nullable `created_at`, `web_url`, and `_chkit_ingested_at`. Missing optional strings yield empty strings, absent arrays yield empty arrays, and absent/unparseable dates or deal amounts yield null. The deals view remains empty until `deals` is configured and observed; previously loaded deal rows remain when it is later deselected. Edit these SQL projections to expose your custom fields, then generate and review a migration. The original payload remains available for further projections.\n\nThe executor journal records per-stream execution and load completion, including successful empty reads. Every scheduled run reads each selected stream from the beginning. An interruption in Companies affects that stream's completion independently of People; the next Companies attempt starts at offset zero. The reader validates returned child workspace and parent IDs against its resolved object/list before publishing rows. The journal stores no Attio-specific cycle, parent inventory, or offset checkpoint. These full-sync readers ignore date bounds; date-range backfills are not supported.\n\nUpgrading from `0.1.2` to `0.2.0` changes records, object-attributes, entries, and list-attributes stream IDs to the per-type/per-list forms above. Those new stream IDs begin with fresh journal progress. Raw table schemas, row identities for the same `sourceId`, and all three views remain unchanged. Installed source is editable and is not automatically replaced by a registry update.\n\nThese views show the latest **observed** version per ID, not a guaranteed snapshot of Attio now. Full reads update returned IDs without clearing tables. Deleted, merged, inaccessible, or deselected entities remain until you implement reconciliation. Data is published batch by batch, so a failed run may have loaded some updates. Offset pagination over changing source data can miss or duplicate entities within a read. There is no universal modification cursor, atomic snapshot replacement, source-version ordering, or complete change history in this template. No data-bearing chunk uses a page offset as its identity.\n\n## Fixture tests\n\nInstall the optional test suite with `bunx chkit add attio --with-tests`, then run:\n\n```sh\nbun test src/integrations/attio/tests/attio.test.ts\n```\n\nFor a custom install path, point the command at that folder's `tests/attio.test.ts`. Tests mock Attio HTTP responses and use in-memory ingestion destinations and journals. They require Bun but no Attio credentials or ClickHouse server. The fixture suite checks per-type stream selection, independent pagination, preserved custom fields, repeat runs, cancellation, errors, safe offset-zero restart, successful empty reads, and rows loaded before a journal failure. Adjust the fixtures and expectations when customizing the source.\n\n## Smoke check\n\nAfter a migration and one successful run, inspect `chkit ingest status --tag provider:attio` and query `SELECT count() FROM default.attio_records_raw FINAL`. Compare a known record's retained `raw.data` with its Attio API response. Run again after changing that record and verify its view reflects the new observation. This smoke check needs a real test workspace and database; the registry's sanitized fixture tests do not assert complete live API coverage.\n"
+    },
+    {
+      "path": "attio/client.ts",
+      "type": "registry:file",
+      "target": "src/integrations/attio/client.ts",
+      "content": "import { setTimeout as sleep } from 'node:timers/promises'\n\nimport { HttpError, IngestConfigError, paginate, rawRows, type ErrorClassifier, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { attioConfig, type AttioReaderConfig } from './config.js'\n\nexport type AttioEntity = Record<string, unknown> & { id: Record<string, string> }\n\nexport interface AttioClientDeps {\n  config: AttioReaderConfig\n  fetch: (url: string, init: RequestInit) => Promise<Response>\n  token: () => string | undefined\n  wait: (milliseconds: number, signal: AbortSignal) => Promise<void>\n}\n\ninterface CollectionRequest {\n  path: string\n  idFields: readonly string[]\n  method?: 'GET' | 'POST'\n  body?: Record<string, unknown>\n  query?: Record<string, string>\n  /** Omit for the unpaginated objects, lists, and workspace_members endpoints. */\n  pageSize?: number\n  valuesField?: 'values' | 'entry_values'\n  parent?: { field: 'object_id' | 'list_id'; id: string; workspaceId: string }\n}\n\nexport const defaultAttioClientDeps: AttioClientDeps = {\n  config: attioConfig,\n  fetch: (url, init) => fetch(url, init),\n  token: () => process.env.ATTIO_API_TOKEN,\n  wait: async (milliseconds, signal) => { await sleep(milliseconds, undefined, { signal }) },\n}\n\n/** Resolve one configured object/list; each stream owns one collection. */\nexport async function* readParentCollection(\n  context: FetchContext,\n  input: {\n    resource: string\n    parent: { kind: 'objects' | 'lists'; ref: string }\n    request: (parent: AttioEntity) => CollectionRequest\n  },\n  deps: AttioClientDeps = defaultAttioClientDeps,\n) {\n  const idField = input.parent.kind === 'objects' ? 'object_id' : 'list_id'\n  const path = `/${input.parent.kind}/${encodeURIComponent(input.parent.ref)}`\n  const parent = await context.attempt(async (signal) => {\n    const entity = parseEntity(await requestData({ path, idFields: ['workspace_id', idField] }, 0, signal, deps), {\n      path, idFields: ['workspace_id', idField],\n    })\n    entitySlug(entity)\n    if (input.parent.ref !== entityId(entity, idField) && input.parent.ref !== entitySlug(entity)) {\n      throw new IngestConfigError(`Attio ${path} returned a different configured parent.`)\n    }\n    return entity\n  }, { label: `GET /v2${path}` })\n  const request = { ...input.request(parent), parent: {\n    field: input.parent.kind === 'objects' || input.resource === 'list_attributes' ? 'object_id' as const : 'list_id' as const,\n    id: entityId(parent, idField), workspaceId: entityId(parent, 'workspace_id'),\n  } }\n  yield* readRows(context, {\n    resource: input.resource, request,\n    metadata: input.parent.kind === 'objects' ? { object_slug: entitySlug(parent) } : { list_slug: entitySlug(parent) },\n  }, deps)\n}\n\nexport async function* readRows(\n  context: FetchContext,\n  input: { resource: string; request: CollectionRequest; metadata?: { object_slug?: string; list_slug?: string } },\n  deps: AttioClientDeps = defaultAttioClientDeps,\n) {\n  for await (const page of readCollection(context, input.request, deps)) {\n    yield { rows: toAttioRows(page.items, input.resource, input.request.idFields, input.metadata, deps.config.sourceId) }\n  }\n}\n\n/** Each page is validated inside attempt, so executor retry/cancellation owns every request. */\nexport function readCollection(\n  context: FetchContext,\n  request: CollectionRequest,\n  deps: AttioClientDeps = defaultAttioClientDeps,\n) {\n  if (request.pageSize !== undefined && (!Number.isSafeInteger(request.pageSize) || request.pageSize <= 0)) {\n    throw new IngestConfigError('Attio pageSize must be a positive safe integer.')\n  }\n  return paginate({\n    context, initial: 0, label: `${request.method ?? 'GET'} /v2${request.path}`,\n    fetchPage: async (offset = 0, signal) => {\n      const data = await requestData(request, offset, signal, deps)\n      if (!Array.isArray(data)) throw new IngestConfigError(`Attio ${request.path} returned no data array.`)\n      const items = data.map((value: unknown) => parseEntity(value, request))\n      if (request.pageSize !== undefined && items.length > request.pageSize) {\n        throw new IngestConfigError(`Attio ${request.path} returned more rows than the requested page size.`)\n      }\n      const next = request.pageSize !== undefined && items.length === request.pageSize ? offset + items.length : undefined\n      if (next !== undefined && !Number.isSafeInteger(next)) {\n        throw new IngestConfigError('Attio pagination offset exceeded the safe integer range.')\n      }\n      return { items, next }\n    },\n  })\n}\n\n/** Original provider fields stay under data; metadata does not overwrite custom attributes. */\nfunction toAttioRows(\n  items: readonly AttioEntity[],\n  resource: string,\n  idFields: readonly string[],\n  metadata: { object_slug?: string; list_slug?: string } = {},\n  sourceId = attioConfig.sourceId,\n) {\n  return rawRows(\n    items.map((data) => ({ source_id: sourceId, ...metadata, data })),\n    ({ data }) => JSON.stringify([sourceId, resource, ...idFields.map((field) => entityId(data, field))]),\n  )\n}\n\nexport function entityId(entity: AttioEntity, field: string): string {\n  const value = entity.id[field]\n  if (!value) throw new IngestConfigError(`Attio entity is missing id.${field}.`)\n  return value\n}\n\nfunction entitySlug(entity: AttioEntity): string {\n  if (typeof entity.api_slug !== 'string' || entity.api_slug.length === 0) {\n    throw new IngestConfigError('Attio object/list is missing api_slug.')\n  }\n  return entity.api_slug\n}\n\n/** Invalid successful responses/configurations cannot be fixed by retrying. */\nexport const classifyAttioError: ErrorClassifier = (cause) => {\n  if (cause instanceof IngestConfigError || cause instanceof SyntaxError) return { kind: 'permanent' }\n  // HttpError preserves 429 Retry-After dates, 5xx retries, and permanent 4xx semantics.\n  return undefined\n}\n\nasync function requestData(\n  request: CollectionRequest,\n  offset: number,\n  signal: AbortSignal,\n  deps: AttioClientDeps,\n): Promise<unknown> {\n  const token = deps.token()?.trim()\n  if (!token) throw new IngestConfigError('Set ATTIO_API_TOKEN before running Attio ingestion. Schema imports do not need credentials.')\n  const url = new URL(`https://api.attio.com/v2${request.path}`)\n  for (const [key, value] of Object.entries(request.query ?? {})) url.searchParams.set(key, value)\n  const method = request.method ?? 'GET'\n  const pagination = request.pageSize === undefined ? {} : { limit: request.pageSize, offset }\n  if (method === 'GET') {\n    for (const [key, value] of Object.entries(pagination)) url.searchParams.set(key, String(value))\n  }\n  // The default pipeline runs one request at a time: <=40 reads/s and <=8 notes/s.\n  // Attio may lower limits and applies query-complexity limits; 429s still use executor backoff.\n  await deps.wait(request.path === '/notes' ? 125 : 25, signal)\n  signal.throwIfAborted()\n  const response = await deps.fetch(url.toString(), {\n    method,\n    headers: { Authorization: `Bearer ${token}`, Accept: 'application/json', 'Content-Type': 'application/json' },\n    ...(method === 'POST' ? { body: JSON.stringify({ ...request.body, ...pagination }) } : {}),\n    signal: AbortSignal.any([signal, AbortSignal.timeout(30_000)]),\n    redirect: 'error',\n  })\n  if (!response.ok) {\n    const error = await HttpError.fromResponse(response)\n    if (response.status === 401 || response.status === 403) {\n      error.message += ' Check ATTIO_API_TOKEN and the resource scopes in the Attio README, or disable this stream.'\n    }\n    throw error\n  }\n  const payload: unknown = await response.json()\n  if (!isObject(payload) || !('data' in payload)) {\n    throw new IngestConfigError(`Attio ${request.path} returned no data field.`)\n  }\n  return payload.data\n}\n\nfunction parseEntity(value: unknown, request: CollectionRequest): AttioEntity {\n  if (!isEntity(value)) throw new IngestConfigError(`Attio ${request.path} returned an entity without a valid id object.`)\n  for (const field of request.idFields) entityId(value, field)\n  if (request.parent && (entityId(value, 'workspace_id') !== request.parent.workspaceId\n    || entityId(value, request.parent.field) !== request.parent.id)) {\n    throw new IngestConfigError(`Attio ${request.path} returned an entity from a different workspace or parent than the resolved collection.`)\n  }\n  if (request.valuesField !== undefined) {\n    const values = value[request.valuesField]\n    if (!isObject(values) || !Object.values(values).every(Array.isArray)) {\n      throw new IngestConfigError(`Attio ${request.path} returned invalid ${request.valuesField}; expected arrays of attribute values.`)\n    }\n  }\n  return value\n}\n\nfunction isEntity(value: unknown): value is AttioEntity {\n  return isObject(value) && isObject(value.id) && Object.values(value.id).every((part) => typeof part === 'string')\n}\n\nfunction isObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value)\n}\n"
+    },
+    {
+      "path": "attio/config.ts",
+      "type": "registry:file",
+      "target": "src/integrations/attio/config.ts",
+      "content": "export interface AttioConfig {\n  /** Stable, non-secret name for this installation. Changing it creates new stream identities. */\n  sourceId: string\n  database: string\n  tablePrefix: string\n  /** Each UUID or API slug creates its own records and attributes streams. */\n  objects: readonly string[]\n  /** Each UUID or API slug creates its own entries and attributes streams. */\n  lists: readonly string[]\n  pageSize: number\n  notesPageSize: number\n}\n\nexport type AttioReaderConfig = Omit<AttioConfig, 'database' | 'tablePrefix'>\n\n// Keep these values stable across runs. Credentials are read only in client.ts at request time.\nexport const attioConfig: AttioConfig = {\n  sourceId: 'attio.primary',\n  database: 'default',\n  tablePrefix: 'attio',\n  objects: ['people', 'companies'],\n  lists: [],\n  pageSize: 500,\n  notesPageSize: 50,\n}\n"
+    },
+    {
+      "path": "attio/index.ts",
+      "type": "registry:file",
+      "target": "src/integrations/attio/index.ts",
+      "content": "export { attio, createAttioPipeline } from './pipeline.js'\nexport { attioObjectsRaw } from './sources/objects.js'\nexport { attioObjectAttributesRaw } from './sources/object-attributes.js'\nexport { attioRecordsRaw, attioPeople, attioCompanies, attioDeals } from './sources/records.js'\nexport { attioListsRaw } from './sources/lists.js'\nexport { attioListAttributesRaw } from './sources/list-attributes.js'\nexport { attioEntriesRaw } from './sources/entries.js'\nexport { attioNotesRaw } from './sources/notes.js'\nexport { attioTasksRaw } from './sources/tasks.js'\nexport { attioMembersRaw } from './sources/members.js'\n"
+    },
+    {
+      "path": "attio/pipeline.ts",
+      "type": "registry:file",
+      "target": "src/integrations/attio/pipeline.ts",
+      "content": "import { definePipeline, defineStream } from '@chkit/plugin-ingest'\n\nimport { classifyAttioError, defaultAttioClientDeps, type AttioClientDeps } from './client.js'\nimport { attioConfig, type AttioReaderConfig } from './config.js'\nimport { attioObjectsRaw, readObjects } from './sources/objects.js'\nimport { attioObjectAttributesRaw, readObjectAttributes } from './sources/object-attributes.js'\nimport { attioRecordsRaw, readRecords } from './sources/records.js'\nimport { attioListsRaw, readLists } from './sources/lists.js'\nimport { attioListAttributesRaw, readListAttributes } from './sources/list-attributes.js'\nimport { attioEntriesRaw, readEntries } from './sources/entries.js'\nimport { attioNotesRaw, readNotes } from './sources/notes.js'\nimport { attioTasksRaw, readTasks } from './sources/tasks.js'\nimport { attioMembersRaw, readMembers } from './sources/members.js'\n\nconst streamOptions = { classifyError: classifyAttioError, batchSize: 500 }\n\n// One records stream per object type; no reader traverses other objects.\n// Keep schema exports when removing streams to retain existing stored data.\nexport function createAttioPipeline(config: AttioReaderConfig = attioConfig, deps: AttioClientDeps = defaultAttioClientDeps) {\n  const client = { ...deps, config: { ...config, objects: [...config.objects], lists: [...config.lists] } }\n  return definePipeline({\n    id: config.sourceId,\n    tags: ['provider:attio'],\n    maxStreams: 1,\n    maxFetches: 1,\n    maxLoads: 1,\n    retry: { retries: 5, minTimeout: 1_000, maxTimeout: 30_000, randomize: true },\n    streams: [\n      defineStream({ ...streamOptions, id: `${config.sourceId}.objects`, tags: ['resource:objects'], destination: attioObjectsRaw, read: (context) => readObjects(context, client) }),\n      ...config.objects.flatMap((object) => [\n        defineStream({ ...streamOptions, id: `${config.sourceId}.records.${object}`, tags: ['resource:records', `object:${object}`], destination: attioRecordsRaw, read: (context) => readRecords(context, object, client) }),\n        defineStream({ ...streamOptions, id: `${config.sourceId}.object_attributes.${object}`, tags: ['resource:object_attributes', `object:${object}`], destination: attioObjectAttributesRaw, read: (context) => readObjectAttributes(context, object, client) }),\n      ]),\n      defineStream({ ...streamOptions, id: `${config.sourceId}.lists`, tags: ['resource:lists'], destination: attioListsRaw, read: (context) => readLists(context, client) }),\n      ...config.lists.flatMap((list) => [\n        defineStream({ ...streamOptions, id: `${config.sourceId}.entries.${list}`, tags: ['resource:entries', `list:${list}`], destination: attioEntriesRaw, read: (context) => readEntries(context, list, client) }),\n        defineStream({ ...streamOptions, id: `${config.sourceId}.list_attributes.${list}`, tags: ['resource:list_attributes', `list:${list}`], destination: attioListAttributesRaw, read: (context) => readListAttributes(context, list, client) }),\n      ]),\n      defineStream({ ...streamOptions, id: `${config.sourceId}.notes`, tags: ['resource:notes'], destination: attioNotesRaw, read: (context) => readNotes(context, client) }),\n      defineStream({ ...streamOptions, id: `${config.sourceId}.tasks`, tags: ['resource:tasks'], destination: attioTasksRaw, read: (context) => readTasks(context, client) }),\n      defineStream({ ...streamOptions, id: `${config.sourceId}.members`, tags: ['resource:members'], destination: attioMembersRaw, read: (context) => readMembers(context, client) }),\n    ],\n  })\n}\n\nexport const attio = createAttioPipeline()\n"
+    },
+    {
+      "path": "attio/sources/objects.ts",
+      "type": "registry:file",
+      "target": "src/integrations/attio/sources/objects.ts",
+      "content": "import { rawTable, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { readRows, type AttioClientDeps } from '../client.js'\nimport { attioConfig } from '../config.js'\n\nexport const attioObjectsRaw = rawTable({ database: attioConfig.database, name: `${attioConfig.tablePrefix}_objects_raw` })\n\nexport function readObjects(context: FetchContext, deps?: AttioClientDeps) {\n  return readRows(context, {\n    resource: 'objects', request: { path: '/objects', idFields: ['workspace_id', 'object_id'] },\n  }, deps)\n}\n"
+    },
+    {
+      "path": "attio/sources/object-attributes.ts",
+      "type": "registry:file",
+      "target": "src/integrations/attio/sources/object-attributes.ts",
+      "content": "import { rawTable, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { defaultAttioClientDeps, entityId, readParentCollection, type AttioClientDeps } from '../client.js'\nimport { attioConfig } from '../config.js'\n\nexport const attioObjectAttributesRaw = rawTable({ database: attioConfig.database, name: `${attioConfig.tablePrefix}_object_attributes_raw` })\n\nexport function readObjectAttributes(context: FetchContext, object: string, deps: AttioClientDeps = defaultAttioClientDeps) {\n  return readParentCollection(context, {\n    resource: 'object_attributes', parent: { kind: 'objects', ref: object },\n    request: (parent) => ({\n      path: `/objects/${encodeURIComponent(entityId(parent, 'object_id'))}/attributes`,\n      idFields: ['workspace_id', 'object_id', 'attribute_id'],\n      query: { show_archived: 'true' },\n      pageSize: deps.config.pageSize,\n    }),\n  }, deps)\n}\n"
+    },
+    {
+      "path": "attio/sources/records.ts",
+      "type": "registry:file",
+      "target": "src/integrations/attio/sources/records.ts",
+      "content": "import { view } from '@chkit/core'\nimport { rawTable, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { defaultAttioClientDeps, entityId, readParentCollection, type AttioClientDeps } from '../client.js'\nimport { attioConfig } from '../config.js'\n\nexport const attioRecordsRaw = rawTable({ database: attioConfig.database, name: `${attioConfig.tablePrefix}_records_raw` })\n\n// Each view depends only on records. JSON extraction tolerates absent optional attributes.\nexport const attioPeople = recordView('people', `\n  JSONExtractString(values, 'name', 1, 'full_name') AS name,\n  arrayMap(value -> JSONExtractString(value, 'email_address'), JSONExtractArrayRaw(values, 'email_addresses')) AS email_addresses,\n  arrayMap(value -> JSONExtractString(value, 'target_record_id'), JSONExtractArrayRaw(values, 'company')) AS company_record_ids`)\n\nexport const attioCompanies = recordView('companies', `\n  JSONExtractString(values, 'name', 1, 'value') AS name,\n  arrayMap(value -> JSONExtractString(value, 'domain'), JSONExtractArrayRaw(values, 'domains')) AS domains,\n  JSONExtractString(values, 'description', 1, 'value') AS description`)\n\nexport const attioDeals = recordView('deals', `\n  JSONExtractString(values, 'name', 1, 'value') AS name,\n  JSONExtractString(values, 'stage', 1, 'status', 'title') AS stage,\n  JSONExtract(values, 'value', 1, 'currency_value', 'Nullable(Float64)') AS value,\n  JSONExtractString(values, 'value', 1, 'currency_code') AS currency_code,\n  arrayMap(value -> JSONExtractString(value, 'target_record_id'), JSONExtractArrayRaw(values, 'associated_company')) AS company_record_ids,\n  arrayMap(value -> JSONExtractString(value, 'target_record_id'), JSONExtractArrayRaw(values, 'associated_people')) AS people_record_ids`)\n\nexport function readRecords(context: FetchContext, object: string, deps: AttioClientDeps = defaultAttioClientDeps) {\n  return readParentCollection(context, {\n    resource: 'records', parent: { kind: 'objects', ref: object },\n    request: (parent) => ({\n      path: `/objects/${encodeURIComponent(entityId(parent, 'object_id'))}/records/query`,\n      idFields: ['workspace_id', 'object_id', 'record_id'],\n      method: 'POST',\n      valuesField: 'values',\n      pageSize: deps.config.pageSize,\n    }),\n  }, deps)\n}\n\nfunction recordView(objectSlug: string, columns: string) {\n  return view({\n    database: attioConfig.database,\n    name: `${attioConfig.tablePrefix}_${objectSlug}`,\n    as: `WITH toJSONString(raw) AS payload,\n  JSONExtractRaw(payload, 'data') AS record,\n  JSONExtractRaw(record, 'values') AS values\nSELECT id,\n  JSONExtractString(payload, 'source_id') AS source_id,\n  JSONExtractString(record, 'id', 'workspace_id') AS workspace_id,\n  JSONExtractString(record, 'id', 'object_id') AS object_id,\n  JSONExtractString(record, 'id', 'record_id') AS record_id,\n  parseDateTime64BestEffortOrNull(JSONExtractString(record, 'created_at'), 6, 'UTC') AS created_at,\n  JSONExtractString(record, 'web_url') AS web_url,${columns},\n  _chkit_ingested_at\nFROM ${quoteIdentifier(attioRecordsRaw.database)}.${quoteIdentifier(attioRecordsRaw.name)} FINAL\nWHERE JSONExtractString(payload, 'object_slug') = '${objectSlug}'`,\n  })\n}\n\nfunction quoteIdentifier(value: string): string {\n  return `\\`${value.replaceAll('\\\\', '\\\\\\\\').replaceAll('`', '\\\\`')}\\``\n}\n"
+    },
+    {
+      "path": "attio/sources/lists.ts",
+      "type": "registry:file",
+      "target": "src/integrations/attio/sources/lists.ts",
+      "content": "import { rawTable, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { readRows, type AttioClientDeps } from '../client.js'\nimport { attioConfig } from '../config.js'\n\nexport const attioListsRaw = rawTable({ database: attioConfig.database, name: `${attioConfig.tablePrefix}_lists_raw` })\n\nexport function readLists(context: FetchContext, deps?: AttioClientDeps) {\n  return readRows(context, {\n    resource: 'lists', request: { path: '/lists', idFields: ['workspace_id', 'list_id'] },\n  }, deps)\n}\n"
+    },
+    {
+      "path": "attio/sources/list-attributes.ts",
+      "type": "registry:file",
+      "target": "src/integrations/attio/sources/list-attributes.ts",
+      "content": "import { rawTable, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { defaultAttioClientDeps, entityId, readParentCollection, type AttioClientDeps } from '../client.js'\nimport { attioConfig } from '../config.js'\n\nexport const attioListAttributesRaw = rawTable({ database: attioConfig.database, name: `${attioConfig.tablePrefix}_list_attributes_raw` })\n\nexport function readListAttributes(context: FetchContext, list: string, deps: AttioClientDeps = defaultAttioClientDeps) {\n  return readParentCollection(context, {\n    resource: 'list_attributes', parent: { kind: 'lists', ref: list },\n    request: (parent) => ({\n      path: `/lists/${encodeURIComponent(entityId(parent, 'list_id'))}/attributes`,\n      idFields: ['workspace_id', 'object_id', 'attribute_id'],\n      // Attio's shared attribute schema calls the parent list ID object_id too.\n      query: { show_archived: 'true' },\n      pageSize: deps.config.pageSize,\n    }),\n  }, deps)\n}\n"
+    },
+    {
+      "path": "attio/sources/entries.ts",
+      "type": "registry:file",
+      "target": "src/integrations/attio/sources/entries.ts",
+      "content": "import { rawTable, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { defaultAttioClientDeps, entityId, readParentCollection, type AttioClientDeps } from '../client.js'\nimport { attioConfig } from '../config.js'\n\nexport const attioEntriesRaw = rawTable({ database: attioConfig.database, name: `${attioConfig.tablePrefix}_entries_raw` })\n\nexport function readEntries(context: FetchContext, list: string, deps: AttioClientDeps = defaultAttioClientDeps) {\n  return readParentCollection(context, {\n    resource: 'entries', parent: { kind: 'lists', ref: list },\n    request: (parent) => ({\n      path: `/lists/${encodeURIComponent(entityId(parent, 'list_id'))}/entries/query`,\n      idFields: ['workspace_id', 'list_id', 'entry_id'],\n      method: 'POST',\n      valuesField: 'entry_values',\n      pageSize: deps.config.pageSize,\n    }),\n  }, deps)\n}\n"
+    },
+    {
+      "path": "attio/sources/notes.ts",
+      "type": "registry:file",
+      "target": "src/integrations/attio/sources/notes.ts",
+      "content": "import { IngestConfigError, rawTable, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { defaultAttioClientDeps, readRows, type AttioClientDeps } from '../client.js'\nimport { attioConfig } from '../config.js'\n\nexport const attioNotesRaw = rawTable({ database: attioConfig.database, name: `${attioConfig.tablePrefix}_notes_raw` })\n\nexport function readNotes(context: FetchContext, deps: AttioClientDeps = defaultAttioClientDeps) {\n  if (deps.config.notesPageSize > 50) throw new IngestConfigError('Attio notesPageSize cannot exceed 50.')\n  return readRows(context, {\n    resource: 'notes', request: {\n      path: '/notes', idFields: ['workspace_id', 'note_id'], pageSize: deps.config.notesPageSize,\n    },\n  }, deps)\n}\n"
+    },
+    {
+      "path": "attio/sources/tasks.ts",
+      "type": "registry:file",
+      "target": "src/integrations/attio/sources/tasks.ts",
+      "content": "import { rawTable, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { defaultAttioClientDeps, readRows, type AttioClientDeps } from '../client.js'\nimport { attioConfig } from '../config.js'\n\nexport const attioTasksRaw = rawTable({ database: attioConfig.database, name: `${attioConfig.tablePrefix}_tasks_raw` })\n\nexport function readTasks(context: FetchContext, deps: AttioClientDeps = defaultAttioClientDeps) {\n  return readRows(context, {\n    resource: 'tasks', request: {\n      path: '/tasks', idFields: ['workspace_id', 'task_id'], pageSize: deps.config.pageSize,\n      query: { sort: 'created_at:asc' },\n    },\n  }, deps)\n}\n"
+    },
+    {
+      "path": "attio/sources/members.ts",
+      "type": "registry:file",
+      "target": "src/integrations/attio/sources/members.ts",
+      "content": "import { rawTable, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { readRows, type AttioClientDeps } from '../client.js'\nimport { attioConfig } from '../config.js'\n\nexport const attioMembersRaw = rawTable({ database: attioConfig.database, name: `${attioConfig.tablePrefix}_members_raw` })\n\nexport function readMembers(context: FetchContext, deps?: AttioClientDeps) {\n  return readRows(context, {\n    resource: 'members', request: {\n      path: '/workspace_members', idFields: ['workspace_id', 'workspace_member_id'],\n    },\n  }, deps)\n}\n"
+    },
+    {
+      "path": "attio/tests/attio.test.ts",
+      "type": "registry:file",
+      "target": "src/integrations/attio/tests/attio.test.ts",
+      "role": "test",
+      "content": "import { describe, expect, test } from 'bun:test'\n\nimport { HttpError, definePipeline, runIngestion, selectStreams, type FetchContext } from '@chkit/plugin-ingest'\nimport { createMemoryDestination, createMemoryJournal } from '@chkit/plugin-ingest/testing'\n\nimport { classifyAttioError, readCollection, type AttioClientDeps } from '../client.js'\nimport { attioConfig } from '../config.js'\nimport * as definitions from '../index.js'\nimport { attio, createAttioPipeline } from '../pipeline.js'\nimport { readEntries } from '../sources/entries.js'\nimport { readMembers } from '../sources/members.js'\nimport { readNotes } from '../sources/notes.js'\nimport { readRecords } from '../sources/records.js'\nimport { readTasks } from '../sources/tasks.js'\nimport { fixtureDeps, fixtureResponse, peopleObject, person } from './fixtures.js'\n\ndescribe('Attio template', () => {\n  test('exports independently selectable object streams and raw destinations without credentials', () => {\n    const exported = Object.values(definitions)\n    expect(exported).toContain(attio)\n    expect(attio.streams).toHaveLength(9)\n    expect(attio.streams.filter((stream) => stream.tags.includes('resource:records')).map((stream) => stream.id))\n      .toEqual(['attio.primary.records.people', 'attio.primary.records.companies'])\n    expect(selectStreams([attio], ['resource:records', 'object:people']).map(({ stream }) => stream.id)).toEqual(['attio.primary.records.people'])\n    expect(selectStreams([attio], ['resource:records', 'object:companies']).map(({ stream }) => stream.id))\n      .toEqual(['attio.primary.records.companies'])\n    for (const stream of attio.streams) {\n      expect(exported).toContain(stream.destination)\n      expect(stream.incremental.id).toBe('chkit.full_sync')\n    }\n    expect([definitions.attioPeople, definitions.attioCompanies, definitions.attioDeals].map((view) => view.name))\n      .toEqual(['attio_people', 'attio_companies', 'attio_deals'])\n  })\n\n  test('an object named tasks does not overlap the workspace tasks resource tag', () => {\n    const pipeline = createAttioPipeline({ ...attioConfig, objects: ['tasks'], lists: [] }, fixtureDeps())\n    expect(selectStreams([pipeline], ['resource:tasks']).map(({ stream }) => stream.id)).toEqual(['attio.primary.tasks'])\n    expect(selectStreams([pipeline], ['resource:records', 'object:tasks']).map(({ stream }) => stream.id))\n      .toEqual(['attio.primary.records.tasks'])\n  })\n\n  test('configured custom objects and lists have their own streams sharing raw tables', async () => {\n    const pipeline = fixturePipeline(fixtureDeps())\n    const journal = createMemoryJournal()\n    const destination = createMemoryDestination()\n    const result = await runIngestion({ selected: selectStreams([pipeline], []), backfill: undefined }, { journal, destination })\n    expect(result.ok, JSON.stringify(result)).toBe(true)\n    expect(pipeline.streams).toHaveLength(11)\n    expect(result.streams.filter((stream) => stream.streamId.includes('.records.')).map((stream) => stream.rows)).toEqual([1, 1])\n    expect(destination.tables.size).toBe(9)\n    expect(destination.tables.get('default.attio_records_raw')?.map((row) => row.raw)).toContainEqual({\n      source_id: 'attio.primary', object_slug: 'people', data: person,\n    })\n    expect(destination.tables.get('default.attio_entries_raw')?.[0]?.raw).toMatchObject({ list_slug: 'sales' })\n    expect(selectStreams([pipeline], ['resource:records', 'object:subscriptions']).map(({ stream }) => stream.id))\n      .toEqual(['attio.primary.records.subscriptions'])\n    expect(selectStreams([pipeline], ['resource:entries']).map(({ stream }) => stream.id))\n      .toEqual(['attio.primary.entries.sales'])\n  })\n\n  test('one object reader paginates only that object and preserves raw custom values and IDs', async () => {\n    const requests: Array<{ path: string; body: unknown }> = []\n    const firstPage = Array.from({ length: 500 }, (_, index) => ({ ...person, id: { ...person.id, record_id: `record-${index}` } }))\n    const deps = fixtureDeps((url, init) => {\n      const body = typeof init.body === 'string' ? JSON.parse(init.body) : undefined\n      requests.push({ path: url.pathname, body })\n      if (url.pathname === '/v2/objects/people') return Response.json({ data: peopleObject })\n      if (url.pathname === '/v2/objects/object-people/records/query') {\n        return Response.json({ data: body.offset === 0 ? firstPage : [{ ...person, id: { ...person.id, record_id: 'last' } }] })\n      }\n      throw new Error(`Unexpected URL ${url.pathname}`)\n    })\n    const chunks = await collect(readRecords(context(), 'people', deps))\n    expect(chunks.map((chunk) => chunk.rows.length)).toEqual([500, 1])\n    expect(requests).toEqual([\n      { path: '/v2/objects/people', body: undefined },\n      { path: '/v2/objects/object-people/records/query', body: { limit: 500, offset: 0 } },\n      { path: '/v2/objects/object-people/records/query', body: { limit: 500, offset: 500 } },\n    ])\n    expect(chunks.every((chunk) => !('state' in chunk) && !('id' in chunk))).toBe(true)\n    expect(chunks[0]?.rows[0]?.id).toBe(JSON.stringify(['attio.primary', 'records', 'workspace-1', 'object-people', 'record-0']))\n    expect(chunks[0]?.rows[0]?.raw).toMatchObject({ data: { values: { custom_multi: [{ value: 'one' }, { value: 'two' }] } } })\n    const custom = await collect(readRecords(context(), 'subscriptions', fixtureDeps()))\n    expect(custom[0]?.rows[0]?.raw).toMatchObject({ object_slug: 'subscriptions' })\n    expect(custom[0]?.rows[0]?.id).not.toBe(chunks[0]?.rows[0]?.id)\n  })\n\n  test('a source identity supplied to the pipeline owns stream IDs and raw row IDs', async () => {\n    const config = { ...attioConfig, sourceId: 'attio.secondary', objects: ['people'], lists: [], pageSize: 2 }\n    const queries: unknown[] = []\n    const pipeline = createAttioPipeline(config, fixtureDeps((url, init) => {\n      if (url.pathname.endsWith('/records/query')) queries.push(JSON.parse(String(init.body)))\n      return fixtureResponse(url)\n    }))\n    config.sourceId = 'changed-after-construction'\n    config.pageSize = 500\n    config.objects.push('companies')\n    const destination = createMemoryDestination()\n    const result = await runIngestion({ selected: selectStreams([pipeline], ['resource:records', 'object:people']), backfill: undefined }, {\n      journal: createMemoryJournal(), destination,\n    })\n    expect(result.ok).toBe(true)\n    expect(result.streams[0]?.streamId).toBe('attio.secondary.records.people')\n    const row = destination.tables.get('default.attio_records_raw')?.[0]\n    expect(row?.id).toBe(JSON.stringify(['attio.secondary', 'records', 'workspace-1', 'object-people', 'record-1']))\n    expect(row?.raw).toMatchObject({ source_id: 'attio.secondary' })\n    expect(queries).toEqual([{ limit: 2, offset: 0 }])\n    expect(selectStreams([pipeline], ['resource:records']).map(({ stream }) => stream.id)).toEqual(['attio.secondary.records.people'])\n  })\n\n  test('notes use their 50-item limit and stop fetching after cancellation', async () => {\n    const controller = new AbortController()\n    const waits: number[] = []\n    const urls: string[] = []\n    const page = Array.from({ length: 50 }, (_, index) => ({ id: { workspace_id: 'workspace-1', note_id: `note-${index}` } }))\n    const deps = fixtureDeps((url) => { urls.push(url.toString()); return Response.json({ data: page }) })\n    deps.wait = async (milliseconds, signal) => { waits.push(milliseconds); signal.throwIfAborted() }\n    const iterator = readNotes(context(controller.signal), deps)\n    expect((await iterator.next()).value?.rows).toHaveLength(50)\n    controller.abort(new Error('fixture cancelled'))\n    await expect(iterator.next()).rejects.toThrow('fixture cancelled')\n    expect(urls).toHaveLength(1)\n    expect(new URL(urls[0] ?? '').searchParams.get('limit')).toBe('50')\n    expect(waits).toEqual([125])\n  })\n\n  test('GET offset pagination requests the terminating empty page for an exact multiple', async () => {\n    const offsets: string[] = []\n    const deps = fixtureDeps((url) => {\n      const offset = url.searchParams.get('offset') ?? ''\n      offsets.push(offset)\n      return Response.json({ data: offset === '0' ? [{ id: { task_id: 'a' } }, { id: { task_id: 'b' } }] : [] })\n    })\n    const pages = await collect(readCollection(context(), { path: '/tasks', idFields: ['task_id'], pageSize: 2 }, deps))\n    expect(pages.map((page) => page.items.length)).toEqual([2, 0])\n    expect(pages.map((page) => page.next)).toEqual([2, undefined])\n    expect(offsets).toEqual(['0', '2'])\n  })\n\n  test('malformed successful responses and missing identities fail visibly', async () => {\n    for (const payload of [{}, { data: null }, { data: [{ id: { task_id: 'task-1' } }] }]) {\n      await expect(collect(readTasks(context(), fixtureDeps(() => Response.json(payload))))).rejects.toThrow('Attio')\n    }\n    const malformed = fixtureDeps((url) => url.pathname === '/v2/objects/people'\n      ? fixtureResponse(url) : Response.json({ data: [{ ...person, values: { name: 'not-an-array' } }] }))\n    await expect(collect(readRecords(context(), 'people', malformed))).rejects.toThrow('invalid values')\n    await expect(collect(readRecords(context(), 'people', fixtureDeps(() => Response.json({ data: [peopleObject] }))))).rejects.toThrow('Attio')\n  })\n\n  test.each(['workspace_id', 'object_id'])('object readers reject children with a different %s', async (field) => {\n    const deps = fixtureDeps((url) => url.pathname === '/v2/objects/people'\n      ? fixtureResponse(url) : Response.json({ data: [{ ...person, id: { ...person.id, [field]: 'foreign' } }] }))\n    await expect(collect(readRecords(context(), 'people', deps))).rejects.toThrow('different workspace or parent')\n  })\n\n  test('list readers resolve one list and reject entries belonging to another list', async () => {\n    const requests: string[] = []\n    const deps = fixtureDeps((url) => {\n      requests.push(url.pathname)\n      return fixtureResponse(url)\n    })\n    const chunks = await collect(readEntries(context(), 'sales', deps))\n    expect(requests).toEqual(['/v2/lists/sales', '/v2/lists/list-sales/entries/query'])\n    expect(chunks[0]?.rows[0]?.raw).toMatchObject({ list_slug: 'sales' })\n    const invalid = fixtureDeps((url) => url.pathname === '/v2/lists/sales'\n      ? fixtureResponse(url) : Response.json({ data: [{ id: { workspace_id: 'workspace-1', list_id: 'foreign', entry_id: 'one' }, entry_values: {} }] }))\n    await expect(collect(readEntries(context(), 'sales', invalid))).rejects.toThrow('different workspace or parent')\n  })\n\n  test('permission failures fail one object stream while another remains independent', async () => {\n    const requests: string[] = []\n    const deps = fixtureDeps((url) => {\n      requests.push(url.pathname)\n      return url.pathname === '/v2/objects/object-custom/records/query'\n        ? Response.json({ code: 'insufficient_scope' }, { status: 403 }) : fixtureResponse(url)\n    })\n    const pipeline = fixturePipeline(deps)\n    const destination = createMemoryDestination()\n    const journal = createMemoryJournal()\n    const result = await runIngestion({ selected: selectStreams([pipeline], ['resource:records']), backfill: undefined }, { journal, destination })\n    expect(result.ok).toBe(false)\n    expect(result.streams.map((stream) => [stream.streamId, stream.outcome, stream.rows])).toEqual([\n      ['attio.primary.records.people', 'succeeded', 1], ['attio.primary.records.subscriptions', 'failed', 0],\n    ])\n    expect(result.streams[1]?.error).toContain('resource scopes')\n    expect(requests.filter((path) => path === '/v2/objects/object-custom/records/query')).toHaveLength(1)\n    expect(destination.tables.get('default.attio_records_raw')).toHaveLength(1)\n    expect((await journal.readCheckpoint('attio.primary.records.people')).lastSuccessSeq).toBeGreaterThan(0)\n    expect((await journal.readCheckpoint('attio.primary.records.subscriptions')).lastSuccessSeq).toBe(0)\n  })\n\n  test('429 retries remain under executor authority and retain Retry-After', async () => {\n    let calls = 0\n    const deps = fixtureDeps((url) => {\n      calls += 1\n      return calls === 1 ? Response.json({ code: 'rate_limit_exceeded' }, { status: 429, headers: { 'Retry-After': '0' } }) : fixtureResponse(url)\n    })\n    const journal = createMemoryJournal()\n    const result = await runIngestion({ selected: selectStreams([fixturePipeline(deps)], ['resource:notes']), backfill: undefined }, {\n      journal, destination: createMemoryDestination(),\n    })\n    expect(result.ok).toBe(true)\n    expect(calls).toBe(2)\n    expect(journal.events.some((event) => event.eventKind === 'retry_scheduled' && event.errorClass === 'rate_limited')).toBe(true)\n    const http = await HttpError.fromResponse(new Response(null, { status: 429, headers: { 'Retry-After': '2' } }))\n    expect(http.retryAfterMs).toBe(2_000)\n    expect(classifyAttioError(http, { kind: 'rate_limited', retryAfterMs: 2_000 })).toBeUndefined()\n  })\n\n  test('a missing token fails only when a reader runs', async () => {\n    const deps = fixtureDeps(() => { throw new Error('must not fetch') })\n    deps.token = () => undefined\n    expect(attio.streams).toHaveLength(9)\n    await expect(collect(readMembers(context(), deps))).rejects.toThrow('Set ATTIO_API_TOKEN')\n  })\n\n  test('an interrupted object restarts offset zero without requesting other objects', async () => {\n    let fail = true\n    const requests: string[] = []\n    const offsets: number[] = []\n    const page = Array.from({ length: 500 }, (_, index) => ({ ...person, id: { ...person.id, record_id: `record-${index}` } }))\n    const deps = fixtureDeps((url, init) => {\n      requests.push(url.pathname)\n      if (url.pathname === '/v2/objects/people') return fixtureResponse(url)\n      if (url.pathname !== '/v2/objects/object-people/records/query') throw new Error(`Unexpected object request ${url.pathname}`)\n      const { offset } = JSON.parse(String(init.body))\n      offsets.push(offset)\n      if (offset === 0) return Response.json({ data: page })\n      return fail ? Response.json({ code: 'insufficient_scope' }, { status: 403 }) : Response.json({ data: [] })\n    })\n    const journal = createMemoryJournal()\n    const destination = createMemoryDestination()\n    const first = await runIngestion({ selected: selectStreams([fixturePipeline(deps)], ['resource:records', 'object:people']), backfill: undefined }, { journal, destination })\n    expect(first.ok).toBe(false)\n    expect((await journal.readCheckpoint('attio.primary.records.people')).envelope).toBeUndefined()\n    fail = false\n    const restored = await restoredJournal(journal)\n    const resumed = await runIngestion({ selected: selectStreams([fixturePipeline(deps)], ['resource:records', 'object:people']), backfill: undefined }, { journal: restored, destination })\n    expect(resumed.ok).toBe(true)\n    expect(offsets).toEqual([0, 500, 0, 500])\n    expect(requests).not.toContain('/v2/objects')\n    expect(destination.tables.get('default.attio_records_raw')).toHaveLength(500)\n  })\n\n  test('reruns publish changed observations with the same stable raw ID', async () => {\n    let changed = false\n    const deps = fixtureDeps((url) => url.pathname === '/v2/objects/object-people/records/query'\n      ? Response.json({ data: [{ ...person, values: { ...person.values, name: [{ full_name: changed ? 'Ada Updated' : 'Ada Example' }] } }] }) : fixtureResponse(url))\n    const journal = createMemoryJournal()\n    const destination = createMemoryDestination()\n    const request = { selected: selectStreams([fixturePipeline(deps)], ['resource:records', 'object:people']), backfill: undefined }\n    expect((await runIngestion(request, { journal, destination })).ok).toBe(true)\n    changed = true\n    expect((await runIngestion(request, { journal, destination })).ok).toBe(true)\n    const rows = destination.tables.get('default.attio_records_raw') ?? []\n    expect(rows).toHaveLength(2)\n    expect(rows[0]?.id).toBe(rows[1]?.id)\n    expect(rows[1]?.raw).toMatchObject({ data: { values: { name: [{ full_name: 'Ada Updated' }] } } })\n  })\n\n  test('a fresh runtime after a lost journal acknowledgement replays changed rows safely', async () => {\n    let changed = false\n    const deps = fixtureDeps((url) => url.pathname === '/v2/objects/object-people/records/query'\n      ? Response.json({ data: [{ ...person, values: { ...person.values, revision: [{ value: changed ? 'new' : 'old' }] } }] }) : fixtureResponse(url))\n    const journal = createMemoryJournal()\n    const destination = createMemoryDestination()\n    const failingJournal = {\n      ...journal,\n      async append(events: Parameters<typeof journal.append>[0]) {\n        if (events.some((event) => event.eventKind === 'batch_committed' && Number(event.detail.rows) > 0)) {\n          throw new Error('fixture journal unavailable after rows loaded')\n        }\n        await journal.append(events)\n      },\n    }\n    const failed = await runIngestion({ selected: selectStreams([fixturePipeline(deps)], ['resource:records', 'object:people']), backfill: undefined }, {\n      journal: failingJournal, destination,\n    })\n    expect(failed.ok).toBe(false)\n    expect(destination.tables.get('default.attio_records_raw')).toHaveLength(1)\n    changed = true\n    const resumed = await runIngestion({ selected: selectStreams([fixturePipeline(deps)], ['resource:records', 'object:people']), backfill: undefined }, {\n      journal: await restoredJournal(journal), destination,\n    })\n    expect(resumed.ok).toBe(true)\n    const rows = destination.tables.get('default.attio_records_raw') ?? []\n    expect(rows).toHaveLength(2)\n    expect(rows[0]?.id).toBe(rows[1]?.id)\n    expect(rows[1]?.raw).toMatchObject({ data: { values: { revision: [{ value: 'new' }] } } })\n  }, 10_000)\n})\n\nfunction fixturePipeline(deps: AttioClientDeps) {\n  return definePipeline({\n    ...createAttioPipeline({ ...attioConfig, objects: ['people', 'subscriptions'], lists: ['sales'] }, deps),\n    retry: { retries: 1, minTimeout: 0, maxTimeout: 0, randomize: false },\n  })\n}\n\nfunction context(signal = new AbortController().signal): FetchContext {\n  return { signal, attempt: async (operation) => operation(signal) }\n}\n\nasync function collect<T>(items: AsyncIterable<T>): Promise<T[]> {\n  const result: T[] = []\n  for await (const item of items) result.push(item)\n  return result\n}\n\nasync function restoredJournal(previous: ReturnType<typeof createMemoryJournal>) {\n  const journal = createMemoryJournal()\n  await journal.append(previous.events.map((event) => ({\n    ...event, checkpoint: event.checkpoint === undefined ? undefined : JSON.parse(JSON.stringify(event.checkpoint)),\n  })))\n  return journal\n}\n"
+    },
+    {
+      "path": "attio/tests/fixtures.ts",
+      "type": "registry:file",
+      "target": "src/integrations/attio/tests/fixtures.ts",
+      "role": "test",
+      "content": "import type { AttioClientDeps } from '../client.js'\nimport { attioConfig } from '../config.js'\n\nexport const peopleObject = { id: { workspace_id: 'workspace-1', object_id: 'object-people' }, api_slug: 'people' }\nconst companiesObject = { id: { workspace_id: 'workspace-1', object_id: 'object-companies' }, api_slug: 'companies' }\nconst customObject = { id: { workspace_id: 'workspace-1', object_id: 'object-custom' }, api_slug: 'subscriptions' }\nconst salesList = { id: { workspace_id: 'workspace-1', list_id: 'list-sales' }, api_slug: 'sales' }\n\nconst fixtureParents: Record<string, unknown> = {\n  '/v2/objects/people': peopleObject,\n  '/v2/objects/object-people': peopleObject,\n  '/v2/objects/companies': companiesObject,\n  '/v2/objects/object-companies': companiesObject,\n  '/v2/objects/subscriptions': customObject,\n  '/v2/objects/object-custom': customObject,\n  '/v2/lists/sales': salesList,\n  '/v2/lists/list-sales': salesList,\n}\n\nexport const person = {\n  id: { workspace_id: 'workspace-1', object_id: 'object-people', record_id: 'record-1' },\n  created_at: '2026-01-01T00:00:00Z',\n  web_url: 'https://app.attio.com/example/person/record-1',\n  values: {\n    name: [{ full_name: 'Ada Example', first_name: 'Ada', last_name: 'Example', attribute_type: 'personal-name', active_until: null }],\n    email_addresses: [{ email_address: 'ada@example.test', attribute_type: 'email-address' }],\n    custom_multi: [{ value: 'one' }, { value: 'two' }],\n  },\n}\n\nconst fixtureCollections: Record<string, readonly unknown[]> = {\n  '/v2/objects': [peopleObject, customObject],\n  '/v2/objects/object-people/records/query': [person],\n  '/v2/objects/object-custom/records/query': [{ id: { ...person.id, object_id: 'object-custom' }, values: { custom_number: [{ value: 7 }] } }],\n  '/v2/objects/object-companies/records/query': [],\n  '/v2/objects/object-people/attributes': [{ id: { ...peopleObject.id, attribute_id: 'attribute-1' }, api_slug: 'name', type: 'personal-name' }],\n  '/v2/objects/object-custom/attributes': [{ id: { ...customObject.id, attribute_id: 'attribute-1' }, api_slug: 'custom_number', type: 'number' }],\n  '/v2/objects/object-companies/attributes': [],\n  '/v2/lists': [salesList],\n  '/v2/lists/list-sales/attributes': [{ id: { workspace_id: 'workspace-1', object_id: 'list-sales', attribute_id: 'attribute-1' }, api_slug: 'stage', type: 'status' }],\n  '/v2/lists/list-sales/entries/query': [{ id: { ...salesList.id, entry_id: 'entry-1' }, parent_object: 'people', parent_record_id: 'record-1', entry_values: { stage: [{ status: { title: 'Prospect' } }] } }],\n  '/v2/notes': [{ id: { workspace_id: 'workspace-1', note_id: 'note-1' }, parent_object: 'people', parent_record_id: 'record-1', content_markdown: '# First call' }],\n  '/v2/tasks': [{ id: { workspace_id: 'workspace-1', task_id: 'task-1' }, content_plaintext: 'Follow up', is_completed: false }],\n  '/v2/workspace_members': [{ id: { workspace_id: 'workspace-1', workspace_member_id: 'member-1' }, first_name: 'Grace' }],\n}\n\nexport function fixtureDeps(\n  respond: (url: URL, init: RequestInit) => Response | Promise<Response> = fixtureResponse,\n): AttioClientDeps {\n  return {\n    config: attioConfig,\n    token: () => 'fixture-token',\n    wait: async () => {},\n    fetch: (url, init) => Promise.resolve(respond(new URL(url), init)),\n  }\n}\n\nexport function fixtureResponse(url: URL): Response {\n  const data = fixtureParents[url.pathname] ?? fixtureCollections[url.pathname]\n  if (data === undefined) throw new Error(`Unexpected fixture URL: ${url.pathname}`)\n  return Response.json({ data })\n}\n"
+    }
+  ],
+  "meta": {
+    "chkit": {
+      "formatVersion": 1,
+      "version": "0.2.0",
+      "changelog": [
+        {
+          "version": "0.2.0",
+          "changes": [
+            "Give People, Companies, each configured object type, and each configured list independent ingestion streams using chkit pagination.",
+            "Group those resource streams in one installation pipeline and bind factory reader settings independently of setup-time storage definitions.",
+            "Make object and list selection explicit, with People and Companies enabled by default; replay interrupted mutable offset reads from the beginning of that stream.",
+            "Preserve raw tables, scoped row identities, and typed views while changing child stream IDs; include fixtures for stream independence and failure recovery.",
+            "Consume the ingestion plugin's full pagination pages, preserving continuations and empty terminal pages with independent resource checkpoints."
+          ]
+        },
+        {
+          "version": "0.1.2",
+          "changes": [
+            "Consolidate schemas and readers into resource modules, include portable fixture tests, and document authentication, resources, views, and sync behavior."
+          ]
+        },
+        {
+          "version": "0.1.1",
+          "changes": [
+            "Add integration guide and logo metadata; distributed source is unchanged."
+          ]
+        },
+        {
+          "version": "0.1.0",
+          "changes": [
+            "Introduce raw CRM objects, attributes, records, lists, entries, notes, tasks, and workspace members, with People, Companies, and Deals views."
+          ]
+        }
+      ],
+      "language": "typescript",
+      "license": "MIT",
+      "documentation": "https://chkit.obsessiondb.com/integrations/attio/",
+      "logo": "https://chkit.obsessiondb.com/logos/attio.svg",
+      "authentication": {
+        "method": "Bearer token",
+        "env": [
+          "ATTIO_API_TOKEN"
+        ],
+        "setup": [
+          "As a workspace admin, open the workspace-name dropdown in Attio and select Workspace settings.",
+          "Open Developers, select + New access token, and name the token (for example, chkit ClickHouse).",
+          "Grant the read scopes listed for the resources to sync.",
+          "Click the token on the Developers page to copy it. Set ATTIO_API_TOKEN in the project .env file or the scheduler secret environment."
+        ],
+        "documentation": "https://attio.com/help/reference/apps/generating-an-api-key"
+      },
+      "chkit": "^0.2.0-beta.10",
+      "ingest": "^0.2.0-beta.10",
+      "clickhouse": ">=25.3.0",
+      "root": "src/integrations/attio",
+      "entry": "index.ts",
+      "exports": [
+        "attio",
+        "createAttioPipeline",
+        "attioObjectsRaw",
+        "attioObjectAttributesRaw",
+        "attioRecordsRaw",
+        "attioPeople",
+        "attioCompanies",
+        "attioDeals",
+        "attioListsRaw",
+        "attioListAttributesRaw",
+        "attioEntriesRaw",
+        "attioNotesRaw",
+        "attioTasksRaw",
+        "attioMembersRaw"
+      ],
+      "resources": [
+        {
+          "name": "objects",
+          "title": "Objects",
+          "table": "attio_objects_raw",
+          "description": "Accessible standard and custom object definitions, IDs, API slug, singular and plural names, creation time",
+          "scopes": [
+            "object_configuration:read"
+          ],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/objects",
+              "documentation": "https://docs.attio.com/rest-api/endpoint-reference/objects/list-objects"
+            }
+          ]
+        },
+        {
+          "name": "object_attributes",
+          "title": "Object attributes",
+          "table": "attio_object_attributes_raw",
+          "description": "Attribute IDs, slug, title, description, type, flags, defaults, relationship definitions, configuration, creation time; includes archived definitions",
+          "scopes": [
+            "object_configuration:read"
+          ],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/objects/{object_id}/attributes",
+              "documentation": "https://docs.attio.com/rest-api/endpoint-reference/attributes/list-attributes"
+            },
+            {
+              "method": "GET",
+              "path": "/objects/{object_id}",
+              "documentation": "https://docs.attio.com/rest-api/endpoint-reference/objects/get-an-object"
+            }
+          ]
+        },
+        {
+          "name": "records",
+          "title": "Records",
+          "table": "attio_records_raw",
+          "description": "Independent records streams for configured object types (People and Companies by default), IDs, creation time, Attio URL, and the complete values object with all returned attribute arrays",
+          "scopes": [
+            "object_configuration:read",
+            "record_permission:read"
+          ],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "POST",
+              "path": "/objects/{object_id}/records/query",
+              "documentation": "https://docs.attio.com/rest-api/endpoint-reference/records/list-records"
+            },
+            {
+              "method": "GET",
+              "path": "/objects/{object_id}",
+              "documentation": "https://docs.attio.com/rest-api/endpoint-reference/objects/get-an-object"
+            }
+          ]
+        },
+        {
+          "name": "lists",
+          "title": "Lists",
+          "table": "attio_lists_raw",
+          "description": "List IDs, slug, name, parent objects, workspace and member access configuration, creator, creation time",
+          "scopes": [
+            "list_configuration:read"
+          ],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/lists",
+              "documentation": "https://docs.attio.com/rest-api/endpoint-reference/lists/list-all-lists"
+            }
+          ]
+        },
+        {
+          "name": "list_attributes",
+          "title": "List attributes",
+          "table": "attio_list_attributes_raw",
+          "description": "Attribute definitions for selected lists, including types, configuration, flags, defaults, relationships, and archived definitions",
+          "scopes": [
+            "list_configuration:read"
+          ],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/lists/{list_id}/attributes",
+              "documentation": "https://docs.attio.com/rest-api/endpoint-reference/attributes/list-attributes"
+            },
+            {
+              "method": "GET",
+              "path": "/lists/{list_id}",
+              "documentation": "https://docs.attio.com/rest-api/endpoint-reference/lists/get-a-list"
+            }
+          ]
+        },
+        {
+          "name": "entries",
+          "title": "List entries",
+          "table": "attio_entries_raw",
+          "description": "Entry IDs, parent object and record ID, creation time, and the complete entry_values object",
+          "scopes": [
+            "list_configuration:read",
+            "list_entry:read"
+          ],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "POST",
+              "path": "/lists/{list_id}/entries/query",
+              "documentation": "https://docs.attio.com/rest-api/endpoint-reference/entries/list-entries"
+            },
+            {
+              "method": "GET",
+              "path": "/lists/{list_id}",
+              "documentation": "https://docs.attio.com/rest-api/endpoint-reference/lists/get-a-list"
+            }
+          ]
+        },
+        {
+          "name": "notes",
+          "title": "Notes",
+          "table": "attio_notes_raw",
+          "description": "Note IDs, parent record links, title, plaintext and Markdown content, tags, creator, creation time, and meeting reference when returned",
+          "scopes": [
+            "note:read",
+            "object_configuration:read",
+            "record_permission:read"
+          ],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/notes",
+              "documentation": "https://docs.attio.com/rest-api/endpoint-reference/notes/list-notes"
+            }
+          ]
+        },
+        {
+          "name": "tasks",
+          "title": "Tasks",
+          "table": "attio_tasks_raw",
+          "description": "Task IDs, plaintext content, deadline, completion state and time, linked records, assignees, creator, creation time",
+          "scopes": [
+            "task:read",
+            "object_configuration:read",
+            "record_permission:read",
+            "user_management:read"
+          ],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/tasks",
+              "documentation": "https://docs.attio.com/rest-api/endpoint-reference/tasks/list-tasks"
+            }
+          ]
+        },
+        {
+          "name": "members",
+          "title": "Workspace members",
+          "table": "attio_members_raw",
+          "description": "Member IDs, first and last name, email address, avatar URL, access level, creation time",
+          "scopes": [
+            "user_management:read"
+          ],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/workspace_members",
+              "documentation": "https://docs.attio.com/rest-api/endpoint-reference/workspace-members/list-workspace-members"
+            }
+          ]
+        }
+      ],
+      "views": [
+        {
+          "name": "attio_people",
+          "source": "records",
+          "description": "Names, email addresses, and linked companies for people records."
+        },
+        {
+          "name": "attio_companies",
+          "source": "records",
+          "description": "Names, domains, and descriptions for company records."
+        },
+        {
+          "name": "attio_deals",
+          "source": "records",
+          "description": "Deal names, stages, values, currencies, and linked people and companies."
+        }
+      ],
+      "sync": {
+        "description": "People, Companies, each configured custom object/list, and workspace resources have independent full-sync streams. Each reader paginates one collection through chkit-ingest; interrupted mutable offset reads replay that collection from zero. Completed and empty reads are recorded by the executor journal without a custom scan checkpoint. Custom types and lists must be configured explicitly.",
+        "schedule": "Run chkit ingest run through cron, CI, or an existing scheduler; the template does not start a background worker.",
+        "deletions": "Records absent from a later API response remain in ClickHouse. The template does not propagate deletions or consume webhooks."
+      },
+      "env": {
+        "ATTIO_API_TOKEN": ""
+      },
+      "fileHashes": {
+        "src/integrations/attio/README.md": "814a3e4a0e2b74595e81356e302608deacabc4832caf0c5b4b47d3fbfe02b5ed",
+        "src/integrations/attio/client.ts": "73a89084519cae5cc545c6cc83045046399941cf7a1b74781f92814c6a1ebb3c",
+        "src/integrations/attio/config.ts": "806dced94ca7bf5e766c3cbc4be0c1e7435a51bcefb3d428f6ebb28f796ed278",
+        "src/integrations/attio/index.ts": "592dfcfbb5be89bea43b75c5042be9537a745c64065895feab0ee3ecdc7d19d1",
+        "src/integrations/attio/pipeline.ts": "7466c4d8162c39f3424c1d05169c0f7619a7ae5d75e97665baa4581535d5f549",
+        "src/integrations/attio/sources/objects.ts": "3262f82c51f3367b169548af28e6e98ca859fb85dc60cfe20816a0352365293d",
+        "src/integrations/attio/sources/object-attributes.ts": "4c6e543f1f13a1ac9afb10e10be8524efbc817df23f5dab6c3ba47742f3b7178",
+        "src/integrations/attio/sources/records.ts": "2dd116f2ea2e3476c278153e762adbeecbf6d61952c2e5f69332ab3674fe75b7",
+        "src/integrations/attio/sources/lists.ts": "89cd338931fb8959fb16c88b872b02229be9737cbf9987ee9d0aa025ea647a88",
+        "src/integrations/attio/sources/list-attributes.ts": "95f4e2aaac531e05115916c26d8b97973daa358e7679970aec6ac1db16060d93",
+        "src/integrations/attio/sources/entries.ts": "9329630f494d8cdc0ea2711a49845f09cfc9ab1775a7e39cb381a85e4c5960aa",
+        "src/integrations/attio/sources/notes.ts": "ca5b71bf24d432ff1967eefa9a1b5feef938ee6b102a06c6a2cc8058d23fb743",
+        "src/integrations/attio/sources/tasks.ts": "a2d64a19efe7bdeedf0925d7883feb6e931b1b62264f83532c1932c893625e97",
+        "src/integrations/attio/sources/members.ts": "7ed50b334465e4060ab3ecc4d47c6863c1c03b9940026f8e7089603504b72462",
+        "src/integrations/attio/tests/attio.test.ts": "36d5e2661e26d06b749ac51e093df3a0b7a2e79047dc4224a64ba6cd5b63ba42",
+        "src/integrations/attio/tests/fixtures.ts": "7144c0e6113464a0e5354ee4fde0e599f0e3db7dc6172f94330af847a4a5332f"
+      }
+    }
+  }
+}
diff --git a/registry/attio/sources/entries.ts b/registry/attio/sources/entries.ts
index de7af6de..dfc3893e 100644
--- a/registry/attio/sources/entries.ts
+++ b/registry/attio/sources/entries.ts
@@ -1,20 +1,19 @@
 import { rawTable, type FetchContext } from '@chkit/plugin-ingest'
 
-import { discoverLists, entityId, entitySlug, readCollection, toAttioRows, type AttioClientDeps } from '../client.js'
+import { defaultAttioClientDeps, entityId, readParentCollection, type AttioClientDeps } from '../client.js'
 import { attioConfig } from '../config.js'
 
 export const attioEntriesRaw = rawTable({ database: attioConfig.database, name: `${attioConfig.tablePrefix}_entries_raw` })
 
-export async function* readEntries(context: FetchContext, deps?: AttioClientDeps) {
-  for (const list of await discoverLists(context, deps)) {
-    for await (const page of readCollection(context, {
-      path: `/lists/${encodeURIComponent(entityId(list, 'list_id'))}/entries/query`,
-      method: 'POST',
+export function readEntries(context: FetchContext, list: string, deps: AttioClientDeps = defaultAttioClientDeps) {
+  return readParentCollection(context, {
+    resource: 'entries', parent: { kind: 'lists', ref: list },
+    request: (parent) => ({
+      path: `/lists/${encodeURIComponent(entityId(parent, 'list_id'))}/entries/query`,
       idFields: ['workspace_id', 'list_id', 'entry_id'],
+      method: 'POST',
       valuesField: 'entry_values',
-      pageSize: attioConfig.pageSize,
-    }, deps)) {
-      yield { rows: toAttioRows(page, 'entries', ['workspace_id', 'list_id', 'entry_id'], { list_slug: entitySlug(list) }) }
-    }
-  }
+      pageSize: deps.config.pageSize,
+    }),
+  }, deps)
 }
diff --git a/registry/attio/sources/list-attributes.ts b/registry/attio/sources/list-attributes.ts
index c1c0ef21..f113d6c4 100644
--- a/registry/attio/sources/list-attributes.ts
+++ b/registry/attio/sources/list-attributes.ts
@@ -1,20 +1,19 @@
 import { rawTable, type FetchContext } from '@chkit/plugin-ingest'
 
-import { discoverLists, entityId, entitySlug, readCollection, toAttioRows, type AttioClientDeps } from '../client.js'
+import { defaultAttioClientDeps, entityId, readParentCollection, type AttioClientDeps } from '../client.js'
 import { attioConfig } from '../config.js'
 
 export const attioListAttributesRaw = rawTable({ database: attioConfig.database, name: `${attioConfig.tablePrefix}_list_attributes_raw` })
 
-export async function* readListAttributes(context: FetchContext, deps?: AttioClientDeps) {
-  for (const list of await discoverLists(context, deps)) {
-    for await (const page of readCollection(context, {
-      path: `/lists/${encodeURIComponent(entityId(list, 'list_id'))}/attributes`,
-      // Attio's shared attribute schema calls the parent list ID "object_id" too.
+export function readListAttributes(context: FetchContext, list: string, deps: AttioClientDeps = defaultAttioClientDeps) {
+  return readParentCollection(context, {
+    resource: 'list_attributes', parent: { kind: 'lists', ref: list },
+    request: (parent) => ({
+      path: `/lists/${encodeURIComponent(entityId(parent, 'list_id'))}/attributes`,
       idFields: ['workspace_id', 'object_id', 'attribute_id'],
+      // Attio's shared attribute schema calls the parent list ID object_id too.
       query: { show_archived: 'true' },
-      pageSize: attioConfig.pageSize,
-    }, deps)) {
-      yield { rows: toAttioRows(page, 'list_attributes', ['workspace_id', 'object_id', 'attribute_id'], { list_slug: entitySlug(list) }) }
-    }
-  }
+      pageSize: deps.config.pageSize,
+    }),
+  }, deps)
 }
diff --git a/registry/attio/sources/lists.ts b/registry/attio/sources/lists.ts
index 6f8b5227..80c9017f 100644
--- a/registry/attio/sources/lists.ts
+++ b/registry/attio/sources/lists.ts
@@ -1,10 +1,12 @@
 import { rawTable, type FetchContext } from '@chkit/plugin-ingest'
 
-import { discoverLists, toAttioRows, type AttioClientDeps } from '../client.js'
+import { readRows, type AttioClientDeps } from '../client.js'
 import { attioConfig } from '../config.js'
 
 export const attioListsRaw = rawTable({ database: attioConfig.database, name: `${attioConfig.tablePrefix}_lists_raw` })
 
-export async function* readLists(context: FetchContext, deps?: AttioClientDeps) {
-  yield { rows: toAttioRows(await discoverLists(context, deps), 'lists', ['workspace_id', 'list_id']) }
+export function readLists(context: FetchContext, deps?: AttioClientDeps) {
+  return readRows(context, {
+    resource: 'lists', request: { path: '/lists', idFields: ['workspace_id', 'list_id'] },
+  }, deps)
 }
diff --git a/registry/attio/sources/members.ts b/registry/attio/sources/members.ts
index fa0eaf87..c3b1b970 100644
--- a/registry/attio/sources/members.ts
+++ b/registry/attio/sources/members.ts
@@ -1,14 +1,14 @@
 import { rawTable, type FetchContext } from '@chkit/plugin-ingest'
 
-import { readCollection, toAttioRows, type AttioClientDeps } from '../client.js'
+import { readRows, type AttioClientDeps } from '../client.js'
 import { attioConfig } from '../config.js'
 
 export const attioMembersRaw = rawTable({ database: attioConfig.database, name: `${attioConfig.tablePrefix}_members_raw` })
 
-export async function* readMembers(context: FetchContext, deps?: AttioClientDeps) {
-  for await (const page of readCollection(context, {
-    path: '/workspace_members', idFields: ['workspace_id', 'workspace_member_id'],
-  }, deps)) {
-    yield { rows: toAttioRows(page, 'members', ['workspace_id', 'workspace_member_id']) }
-  }
+export function readMembers(context: FetchContext, deps?: AttioClientDeps) {
+  return readRows(context, {
+    resource: 'members', request: {
+      path: '/workspace_members', idFields: ['workspace_id', 'workspace_member_id'],
+    },
+  }, deps)
 }
diff --git a/registry/attio/sources/notes.ts b/registry/attio/sources/notes.ts
index 69380748..9e54c497 100644
--- a/registry/attio/sources/notes.ts
+++ b/registry/attio/sources/notes.ts
@@ -1,15 +1,15 @@
 import { IngestConfigError, rawTable, type FetchContext } from '@chkit/plugin-ingest'
 
-import { readCollection, toAttioRows, type AttioClientDeps } from '../client.js'
+import { defaultAttioClientDeps, readRows, type AttioClientDeps } from '../client.js'
 import { attioConfig } from '../config.js'
 
 export const attioNotesRaw = rawTable({ database: attioConfig.database, name: `${attioConfig.tablePrefix}_notes_raw` })
 
-export async function* readNotes(context: FetchContext, deps?: AttioClientDeps) {
-  if (attioConfig.notesPageSize > 50) throw new IngestConfigError('Attio notesPageSize cannot exceed 50.')
-  for await (const page of readCollection(context, {
-    path: '/notes', idFields: ['workspace_id', 'note_id'], pageSize: attioConfig.notesPageSize,
-  }, deps)) {
-    yield { rows: toAttioRows(page, 'notes', ['workspace_id', 'note_id']) }
-  }
+export function readNotes(context: FetchContext, deps: AttioClientDeps = defaultAttioClientDeps) {
+  if (deps.config.notesPageSize > 50) throw new IngestConfigError('Attio notesPageSize cannot exceed 50.')
+  return readRows(context, {
+    resource: 'notes', request: {
+      path: '/notes', idFields: ['workspace_id', 'note_id'], pageSize: deps.config.notesPageSize,
+    },
+  }, deps)
 }
diff --git a/registry/attio/sources/object-attributes.ts b/registry/attio/sources/object-attributes.ts
index 343e8bda..08458061 100644
--- a/registry/attio/sources/object-attributes.ts
+++ b/registry/attio/sources/object-attributes.ts
@@ -1,19 +1,18 @@
 import { rawTable, type FetchContext } from '@chkit/plugin-ingest'
 
-import { discoverObjects, entityId, entitySlug, readCollection, toAttioRows, type AttioClientDeps } from '../client.js'
+import { defaultAttioClientDeps, entityId, readParentCollection, type AttioClientDeps } from '../client.js'
 import { attioConfig } from '../config.js'
 
 export const attioObjectAttributesRaw = rawTable({ database: attioConfig.database, name: `${attioConfig.tablePrefix}_object_attributes_raw` })
 
-export async function* readObjectAttributes(context: FetchContext, deps?: AttioClientDeps) {
-  for (const object of await discoverObjects(context, deps)) {
-    for await (const page of readCollection(context, {
-      path: `/objects/${encodeURIComponent(entityId(object, 'object_id'))}/attributes`,
+export function readObjectAttributes(context: FetchContext, object: string, deps: AttioClientDeps = defaultAttioClientDeps) {
+  return readParentCollection(context, {
+    resource: 'object_attributes', parent: { kind: 'objects', ref: object },
+    request: (parent) => ({
+      path: `/objects/${encodeURIComponent(entityId(parent, 'object_id'))}/attributes`,
       idFields: ['workspace_id', 'object_id', 'attribute_id'],
       query: { show_archived: 'true' },
-      pageSize: attioConfig.pageSize,
-    }, deps)) {
-      yield { rows: toAttioRows(page, 'object_attributes', ['workspace_id', 'object_id', 'attribute_id'], { object_slug: entitySlug(object) }) }
-    }
-  }
+      pageSize: deps.config.pageSize,
+    }),
+  }, deps)
 }
diff --git a/registry/attio/sources/objects.ts b/registry/attio/sources/objects.ts
index 6cbf8d7e..0491cce1 100644
--- a/registry/attio/sources/objects.ts
+++ b/registry/attio/sources/objects.ts
@@ -1,10 +1,12 @@
 import { rawTable, type FetchContext } from '@chkit/plugin-ingest'
 
-import { discoverObjects, toAttioRows, type AttioClientDeps } from '../client.js'
+import { readRows, type AttioClientDeps } from '../client.js'
 import { attioConfig } from '../config.js'
 
 export const attioObjectsRaw = rawTable({ database: attioConfig.database, name: `${attioConfig.tablePrefix}_objects_raw` })
 
-export async function* readObjects(context: FetchContext, deps?: AttioClientDeps) {
-  yield { rows: toAttioRows(await discoverObjects(context, deps), 'objects', ['workspace_id', 'object_id']) }
+export function readObjects(context: FetchContext, deps?: AttioClientDeps) {
+  return readRows(context, {
+    resource: 'objects', request: { path: '/objects', idFields: ['workspace_id', 'object_id'] },
+  }, deps)
 }
diff --git a/registry/attio/sources/records.ts b/registry/attio/sources/records.ts
index a4d4e887..142a5885 100644
--- a/registry/attio/sources/records.ts
+++ b/registry/attio/sources/records.ts
@@ -1,7 +1,7 @@
 import { view } from '@chkit/core'
 import { rawTable, type FetchContext } from '@chkit/plugin-ingest'
 
-import { discoverObjects, entityId, entitySlug, readCollection, toAttioRows, type AttioClientDeps } from '../client.js'
+import { defaultAttioClientDeps, entityId, readParentCollection, type AttioClientDeps } from '../client.js'
 import { attioConfig } from '../config.js'
 
 export const attioRecordsRaw = rawTable({ database: attioConfig.database, name: `${attioConfig.tablePrefix}_records_raw` })
@@ -25,20 +25,17 @@ export const attioDeals = recordView('deals', `
   arrayMap(value -> JSONExtractString(value, 'target_record_id'), JSONExtractArrayRaw(values, 'associated_company')) AS company_record_ids,
   arrayMap(value -> JSONExtractString(value, 'target_record_id'), JSONExtractArrayRaw(values, 'associated_people')) AS people_record_ids`)
 
-export async function* readRecords(context: FetchContext, deps?: AttioClientDeps) {
-  // Discovery is local to this reader; the metadata stream need not have run.
-  for (const object of await discoverObjects(context, deps)) {
-    for await (const page of readCollection(context, {
-      path: `/objects/${encodeURIComponent(entityId(object, 'object_id'))}/records/query`,
-      method: 'POST',
+export function readRecords(context: FetchContext, object: string, deps: AttioClientDeps = defaultAttioClientDeps) {
+  return readParentCollection(context, {
+    resource: 'records', parent: { kind: 'objects', ref: object },
+    request: (parent) => ({
+      path: `/objects/${encodeURIComponent(entityId(parent, 'object_id'))}/records/query`,
       idFields: ['workspace_id', 'object_id', 'record_id'],
+      method: 'POST',
       valuesField: 'values',
-      pageSize: attioConfig.pageSize,
-    }, deps)) {
-      // No checkpoint or page identity: offsets are not change cursors, and pages can mutate.
-      yield { rows: toAttioRows(page, 'records', ['workspace_id', 'object_id', 'record_id'], { object_slug: entitySlug(object) }) }
-    }
-  }
+      pageSize: deps.config.pageSize,
+    }),
+  }, deps)
 }
 
 function recordView(objectSlug: string, columns: string) {
diff --git a/registry/attio/sources/tasks.ts b/registry/attio/sources/tasks.ts
index 862dd561..b8b80ac8 100644
--- a/registry/attio/sources/tasks.ts
+++ b/registry/attio/sources/tasks.ts
@@ -1,15 +1,15 @@
 import { rawTable, type FetchContext } from '@chkit/plugin-ingest'
 
-import { readCollection, toAttioRows, type AttioClientDeps } from '../client.js'
+import { defaultAttioClientDeps, readRows, type AttioClientDeps } from '../client.js'
 import { attioConfig } from '../config.js'
 
 export const attioTasksRaw = rawTable({ database: attioConfig.database, name: `${attioConfig.tablePrefix}_tasks_raw` })
 
-export async function* readTasks(context: FetchContext, deps?: AttioClientDeps) {
-  for await (const page of readCollection(context, {
-    path: '/tasks', idFields: ['workspace_id', 'task_id'], pageSize: attioConfig.pageSize,
-    query: { sort: 'created_at:asc' },
-  }, deps)) {
-    yield { rows: toAttioRows(page, 'tasks', ['workspace_id', 'task_id']) }
-  }
+export function readTasks(context: FetchContext, deps: AttioClientDeps = defaultAttioClientDeps) {
+  return readRows(context, {
+    resource: 'tasks', request: {
+      path: '/tasks', idFields: ['workspace_id', 'task_id'], pageSize: deps.config.pageSize,
+      query: { sort: 'created_at:asc' },
+    },
+  }, deps)
 }
diff --git a/registry/attio/tests/attio.test.ts b/registry/attio/tests/attio.test.ts
index 609430cf..d3c2d770 100644
--- a/registry/attio/tests/attio.test.ts
+++ b/registry/attio/tests/attio.test.ts
@@ -1,33 +1,29 @@
 import { describe, expect, test } from 'bun:test'
 
-import { HttpError, definePipeline, runIngestion, selectStreams, type FetchContext, type SourceChunk } from '@chkit/plugin-ingest'
+import { HttpError, definePipeline, runIngestion, selectStreams, type FetchContext } from '@chkit/plugin-ingest'
 import { createMemoryDestination, createMemoryJournal } from '@chkit/plugin-ingest/testing'
 
 import { classifyAttioError, readCollection, type AttioClientDeps } from '../client.js'
+import { attioConfig } from '../config.js'
 import * as definitions from '../index.js'
-import { attio } from '../pipeline.js'
-import { readObjects } from '../sources/objects.js'
-import { readObjectAttributes } from '../sources/object-attributes.js'
-import { readRecords } from '../sources/records.js'
-import { readLists } from '../sources/lists.js'
-import { readListAttributes } from '../sources/list-attributes.js'
+import { attio, createAttioPipeline } from '../pipeline.js'
 import { readEntries } from '../sources/entries.js'
+import { readMembers } from '../sources/members.js'
 import { readNotes } from '../sources/notes.js'
+import { readRecords } from '../sources/records.js'
 import { readTasks } from '../sources/tasks.js'
-import { readMembers } from '../sources/members.js'
-import { customObject, fixtureCollections, fixtureDeps, peopleObject, person } from './fixtures.js'
-
-const readers: Record<string, (context: FetchContext, deps: AttioClientDeps) => AsyncIterable<SourceChunk>> = {
-  objects: readObjects, object_attributes: readObjectAttributes, records: readRecords,
-  lists: readLists, list_attributes: readListAttributes, entries: readEntries,
-  notes: readNotes, tasks: readTasks, members: readMembers,
-}
+import { fixtureDeps, fixtureResponse, peopleObject, person } from './fixtures.js'
 
 describe('Attio template', () => {
-  test('exports every stream destination and all three views without reading credentials', () => {
+  test('exports independently selectable object streams and raw destinations without credentials', () => {
     const exported = Object.values(definitions)
     expect(exported).toContain(attio)
     expect(attio.streams).toHaveLength(9)
+    expect(attio.streams.filter((stream) => stream.tags.includes('resource:records')).map((stream) => stream.id))
+      .toEqual(['attio.primary.records.people', 'attio.primary.records.companies'])
+    expect(selectStreams([attio], ['resource:records', 'object:people']).map(({ stream }) => stream.id)).toEqual(['attio.primary.records.people'])
+    expect(selectStreams([attio], ['resource:records', 'object:companies']).map(({ stream }) => stream.id))
+      .toEqual(['attio.primary.records.companies'])
     for (const stream of attio.streams) {
       expect(exported).toContain(stream.destination)
       expect(stream.incremental.id).toBe('chkit.full_sync')
@@ -36,58 +32,83 @@ describe('Attio template', () => {
       .toEqual(['attio_people', 'attio_companies', 'attio_deals'])
   })
 
-  test('all streams ingest sanitized fixtures and reruns publish changed observations', async () => {
-    let changed = false
-    const deps = fixtureDeps((url) => {
-      const data = fixtureCollections[url.pathname]
-      if (data === undefined) throw new Error(`Unexpected fixture URL: ${url.pathname}`)
-      return Response.json({ data: changed && url.pathname === '/v2/notes'
-        ? [{ id: { workspace_id: 'workspace-1', note_id: 'note-1' }, content_markdown: '# Revised call' }]
-        : data })
-    })
-    const pipeline = fixturePipeline(deps)
+  test('an object named tasks does not overlap the workspace tasks resource tag', () => {
+    const pipeline = createAttioPipeline({ ...attioConfig, objects: ['tasks'], lists: [] }, fixtureDeps())
+    expect(selectStreams([pipeline], ['resource:tasks']).map(({ stream }) => stream.id)).toEqual(['attio.primary.tasks'])
+    expect(selectStreams([pipeline], ['resource:records', 'object:tasks']).map(({ stream }) => stream.id))
+      .toEqual(['attio.primary.records.tasks'])
+  })
+
+  test('configured custom objects and lists have their own streams sharing raw tables', async () => {
+    const pipeline = fixturePipeline(fixtureDeps())
     const journal = createMemoryJournal()
     const destination = createMemoryDestination()
-    const request = { selected: selectStreams([pipeline], []), backfill: undefined }
-    const first = await runIngestion(request, { journal, destination })
-    expect(first.ok).toBe(true)
-    expect(first.streams.map((stream) => stream.rows)).toEqual([2, 2, 2, 1, 1, 1, 1, 1, 1])
+    const result = await runIngestion({ selected: selectStreams([pipeline], []), backfill: undefined }, { journal, destination })
+    expect(result.ok, JSON.stringify(result)).toBe(true)
+    expect(pipeline.streams).toHaveLength(11)
+    expect(result.streams.filter((stream) => stream.streamId.includes('.records.')).map((stream) => stream.rows)).toEqual([1, 1])
     expect(destination.tables.size).toBe(9)
     expect(destination.tables.get('default.attio_records_raw')?.map((row) => row.raw)).toContainEqual({
       source_id: 'attio.primary', object_slug: 'people', data: person,
     })
-    changed = true
-    const second = await runIngestion(request, { journal, destination })
-    expect(second.ok).toBe(true)
-    const notes = destination.tables.get('default.attio_notes_raw') ?? []
-    expect(notes).toHaveLength(2)
-    expect(notes[0]?.id).toBe(notes[1]?.id)
-    expect(notes[1]?.raw).toMatchObject({ data: { content_markdown: '# Revised call' } })
+    expect(destination.tables.get('default.attio_entries_raw')?.[0]?.raw).toMatchObject({ list_slug: 'sales' })
+    expect(selectStreams([pipeline], ['resource:records', 'object:subscriptions']).map(({ stream }) => stream.id))
+      .toEqual(['attio.primary.records.subscriptions'])
+    expect(selectStreams([pipeline], ['resource:entries']).map(({ stream }) => stream.id))
+      .toEqual(['attio.primary.entries.sales'])
   })
 
-  test('records discover parents independently and read all offset pages including custom objects', async () => {
+  test('one object reader paginates only that object and preserves raw custom values and IDs', async () => {
     const requests: Array<{ path: string; body: unknown }> = []
     const firstPage = Array.from({ length: 500 }, (_, index) => ({ ...person, id: { ...person.id, record_id: `record-${index}` } }))
     const deps = fixtureDeps((url, init) => {
       const body = typeof init.body === 'string' ? JSON.parse(init.body) : undefined
       requests.push({ path: url.pathname, body })
-      if (url.pathname === '/v2/objects') return Response.json({ data: [peopleObject, customObject] })
+      if (url.pathname === '/v2/objects/people') return Response.json({ data: peopleObject })
       if (url.pathname === '/v2/objects/object-people/records/query') {
         return Response.json({ data: body.offset === 0 ? firstPage : [{ ...person, id: { ...person.id, record_id: 'last' } }] })
       }
-      if (url.pathname === '/v2/objects/object-custom/records/query') {
-        return Response.json({ data: [{ id: { ...person.id, object_id: 'object-custom' }, values: {} }] })
-      }
       throw new Error(`Unexpected URL ${url.pathname}`)
     })
-    const chunks = await collect(readRecords(context(), deps))
-    expect(chunks.map((chunk) => chunk.rows.length)).toEqual([500, 1, 1])
-    expect(requests.map((request) => request.body)).toEqual([undefined, { limit: 500, offset: 0 }, { limit: 500, offset: 500 }, { limit: 500, offset: 0 }])
+    const chunks = await collect(readRecords(context(), 'people', deps))
+    expect(chunks.map((chunk) => chunk.rows.length)).toEqual([500, 1])
+    expect(requests).toEqual([
+      { path: '/v2/objects/people', body: undefined },
+      { path: '/v2/objects/object-people/records/query', body: { limit: 500, offset: 0 } },
+      { path: '/v2/objects/object-people/records/query', body: { limit: 500, offset: 500 } },
+    ])
     expect(chunks.every((chunk) => !('state' in chunk) && !('id' in chunk))).toBe(true)
-    expect(chunks[0]?.rows[1]?.id).not.toBe(chunks[2]?.rows[0]?.id)
+    expect(chunks[0]?.rows[0]?.id).toBe(JSON.stringify(['attio.primary', 'records', 'workspace-1', 'object-people', 'record-0']))
+    expect(chunks[0]?.rows[0]?.raw).toMatchObject({ data: { values: { custom_multi: [{ value: 'one' }, { value: 'two' }] } } })
+    const custom = await collect(readRecords(context(), 'subscriptions', fixtureDeps()))
+    expect(custom[0]?.rows[0]?.raw).toMatchObject({ object_slug: 'subscriptions' })
+    expect(custom[0]?.rows[0]?.id).not.toBe(chunks[0]?.rows[0]?.id)
   })
 
-  test('notes use their 50-item page limit, honor cancellation, and never fetch a second page after abort', async () => {
+  test('a source identity supplied to the pipeline owns stream IDs and raw row IDs', async () => {
+    const config = { ...attioConfig, sourceId: 'attio.secondary', objects: ['people'], lists: [], pageSize: 2 }
+    const queries: unknown[] = []
+    const pipeline = createAttioPipeline(config, fixtureDeps((url, init) => {
+      if (url.pathname.endsWith('/records/query')) queries.push(JSON.parse(String(init.body)))
+      return fixtureResponse(url)
+    }))
+    config.sourceId = 'changed-after-construction'
+    config.pageSize = 500
+    config.objects.push('companies')
+    const destination = createMemoryDestination()
+    const result = await runIngestion({ selected: selectStreams([pipeline], ['resource:records', 'object:people']), backfill: undefined }, {
+      journal: createMemoryJournal(), destination,
+    })
+    expect(result.ok).toBe(true)
+    expect(result.streams[0]?.streamId).toBe('attio.secondary.records.people')
+    const row = destination.tables.get('default.attio_records_raw')?.[0]
+    expect(row?.id).toBe(JSON.stringify(['attio.secondary', 'records', 'workspace-1', 'object-people', 'record-1']))
+    expect(row?.raw).toMatchObject({ source_id: 'attio.secondary' })
+    expect(queries).toEqual([{ limit: 2, offset: 0 }])
+    expect(selectStreams([pipeline], ['resource:records']).map(({ stream }) => stream.id)).toEqual(['attio.secondary.records.people'])
+  })
+
+  test('notes use their 50-item limit and stop fetching after cancellation', async () => {
     const controller = new AbortController()
     const waits: number[] = []
     const urls: string[] = []
@@ -95,8 +116,7 @@ describe('Attio template', () => {
     const deps = fixtureDeps((url) => { urls.push(url.toString()); return Response.json({ data: page }) })
     deps.wait = async (milliseconds, signal) => { waits.push(milliseconds); signal.throwIfAborted() }
     const iterator = readNotes(context(controller.signal), deps)
-    const first = await iterator.next()
-    expect(first.value?.rows).toHaveLength(50)
+    expect((await iterator.next()).value?.rows).toHaveLength(50)
     controller.abort(new Error('fixture cancelled'))
     await expect(iterator.next()).rejects.toThrow('fixture cancelled')
     expect(urls).toHaveLength(1)
@@ -104,7 +124,7 @@ describe('Attio template', () => {
     expect(waits).toEqual([125])
   })
 
-  test('GET pagination includes the terminating empty page for an exact multiple', async () => {
+  test('GET offset pagination requests the terminating empty page for an exact multiple', async () => {
     const offsets: string[] = []
     const deps = fixtureDeps((url) => {
       const offset = url.searchParams.get('offset') ?? ''
@@ -112,46 +132,71 @@ describe('Attio template', () => {
       return Response.json({ data: offset === '0' ? [{ id: { task_id: 'a' } }, { id: { task_id: 'b' } }] : [] })
     })
     const pages = await collect(readCollection(context(), { path: '/tasks', idFields: ['task_id'], pageSize: 2 }, deps))
-    expect(pages.map((page) => page.length)).toEqual([2])
+    expect(pages.map((page) => page.items.length)).toEqual([2, 0])
+    expect(pages.map((page) => page.next)).toEqual([2, undefined])
     expect(offsets).toEqual(['0', '2'])
   })
 
-  test('malformed successful responses and missing identity fail rather than become empty data', async () => {
+  test('malformed successful responses and missing identities fail visibly', async () => {
     for (const payload of [{}, { data: null }, { data: [{ id: { task_id: 'task-1' } }] }]) {
-      const deps = fixtureDeps(() => Response.json(payload))
-      await expect(collect(readTasks(context(), deps))).rejects.toThrow('Attio')
+      await expect(collect(readTasks(context(), fixtureDeps(() => Response.json(payload))))).rejects.toThrow('Attio')
     }
-    const malformedRecord = fixtureDeps((url) => Response.json({ data: url.pathname === '/v2/objects'
-      ? [peopleObject] : [{ ...person, values: { name: 'not-an-array' } }] }))
-    await expect(collect(readRecords(context(), malformedRecord))).rejects.toThrow('invalid values')
+    const malformed = fixtureDeps((url) => url.pathname === '/v2/objects/people'
+      ? fixtureResponse(url) : Response.json({ data: [{ ...person, values: { name: 'not-an-array' } }] }))
+    await expect(collect(readRecords(context(), 'people', malformed))).rejects.toThrow('invalid values')
+    await expect(collect(readRecords(context(), 'people', fixtureDeps(() => Response.json({ data: [peopleObject] }))))).rejects.toThrow('Attio')
   })
 
-  test('permission failures are permanent, actionable, and produce no rows', async () => {
-    let calls = 0
-    const deps = fixtureDeps(() => { calls += 1; return Response.json({ code: 'insufficient_scope' }, { status: 403 }) })
-    const pipeline = fixturePipeline(deps, ['notes'])
-    const destination = createMemoryDestination()
-    const result = await runIngestion({ selected: selectStreams([pipeline], []), backfill: undefined }, {
-      journal: createMemoryJournal(), destination,
+  test.each(['workspace_id', 'object_id'])('object readers reject children with a different %s', async (field) => {
+    const deps = fixtureDeps((url) => url.pathname === '/v2/objects/people'
+      ? fixtureResponse(url) : Response.json({ data: [{ ...person, id: { ...person.id, [field]: 'foreign' } }] }))
+    await expect(collect(readRecords(context(), 'people', deps))).rejects.toThrow('different workspace or parent')
+  })
+
+  test('list readers resolve one list and reject entries belonging to another list', async () => {
+    const requests: string[] = []
+    const deps = fixtureDeps((url) => {
+      requests.push(url.pathname)
+      return fixtureResponse(url)
     })
+    const chunks = await collect(readEntries(context(), 'sales', deps))
+    expect(requests).toEqual(['/v2/lists/sales', '/v2/lists/list-sales/entries/query'])
+    expect(chunks[0]?.rows[0]?.raw).toMatchObject({ list_slug: 'sales' })
+    const invalid = fixtureDeps((url) => url.pathname === '/v2/lists/sales'
+      ? fixtureResponse(url) : Response.json({ data: [{ id: { workspace_id: 'workspace-1', list_id: 'foreign', entry_id: 'one' }, entry_values: {} }] }))
+    await expect(collect(readEntries(context(), 'sales', invalid))).rejects.toThrow('different workspace or parent')
+  })
+
+  test('permission failures fail one object stream while another remains independent', async () => {
+    const requests: string[] = []
+    const deps = fixtureDeps((url) => {
+      requests.push(url.pathname)
+      return url.pathname === '/v2/objects/object-custom/records/query'
+        ? Response.json({ code: 'insufficient_scope' }, { status: 403 }) : fixtureResponse(url)
+    })
+    const pipeline = fixturePipeline(deps)
+    const destination = createMemoryDestination()
+    const journal = createMemoryJournal()
+    const result = await runIngestion({ selected: selectStreams([pipeline], ['resource:records']), backfill: undefined }, { journal, destination })
     expect(result.ok).toBe(false)
-    expect(result.streams[0]?.error).toContain('resource scopes')
-    expect(result.streams[0]?.rows).toBe(0)
-    expect(calls).toBe(1)
-    expect(destination.tables.size).toBe(0)
+    expect(result.streams.map((stream) => [stream.streamId, stream.outcome, stream.rows])).toEqual([
+      ['attio.primary.records.people', 'succeeded', 1], ['attio.primary.records.subscriptions', 'failed', 0],
+    ])
+    expect(result.streams[1]?.error).toContain('resource scopes')
+    expect(requests.filter((path) => path === '/v2/objects/object-custom/records/query')).toHaveLength(1)
+    expect(destination.tables.get('default.attio_records_raw')).toHaveLength(1)
+    expect((await journal.readCheckpoint('attio.primary.records.people')).lastSuccessSeq).toBeGreaterThan(0)
+    expect((await journal.readCheckpoint('attio.primary.records.subscriptions')).lastSuccessSeq).toBe(0)
   })
 
-  test('429 requests retry under executor authority and preserve Retry-After', async () => {
+  test('429 retries remain under executor authority and retain Retry-After', async () => {
     let calls = 0
-    const deps = fixtureDeps(() => {
+    const deps = fixtureDeps((url) => {
       calls += 1
-      return calls === 1
-        ? Response.json({ code: 'rate_limit_exceeded' }, { status: 429, headers: { 'Retry-After': '0' } })
-        : Response.json({ data: fixtureCollections['/v2/notes'] })
+      return calls === 1 ? Response.json({ code: 'rate_limit_exceeded' }, { status: 429, headers: { 'Retry-After': '0' } }) : fixtureResponse(url)
     })
-    const pipeline = fixturePipeline(deps, ['notes'])
     const journal = createMemoryJournal()
-    const result = await runIngestion({ selected: selectStreams([pipeline], []), backfill: undefined }, {
+    const result = await runIngestion({ selected: selectStreams([fixturePipeline(deps)], ['resource:notes']), backfill: undefined }, {
       journal, destination: createMemoryDestination(),
     })
     expect(result.ok).toBe(true)
@@ -162,23 +207,93 @@ describe('Attio template', () => {
     expect(classifyAttioError(http, { kind: 'rate_limited', retryAfterMs: 2_000 })).toBeUndefined()
   })
 
-  test('a missing token fails only when the reader runs', async () => {
+  test('a missing token fails only when a reader runs', async () => {
     const deps = fixtureDeps(() => { throw new Error('must not fetch') })
     deps.token = () => undefined
     expect(attio.streams).toHaveLength(9)
     await expect(collect(readMembers(context(), deps))).rejects.toThrow('Set ATTIO_API_TOKEN')
   })
+
+  test('an interrupted object restarts offset zero without requesting other objects', async () => {
+    let fail = true
+    const requests: string[] = []
+    const offsets: number[] = []
+    const page = Array.from({ length: 500 }, (_, index) => ({ ...person, id: { ...person.id, record_id: `record-${index}` } }))
+    const deps = fixtureDeps((url, init) => {
+      requests.push(url.pathname)
+      if (url.pathname === '/v2/objects/people') return fixtureResponse(url)
+      if (url.pathname !== '/v2/objects/object-people/records/query') throw new Error(`Unexpected object request ${url.pathname}`)
+      const { offset } = JSON.parse(String(init.body))
+      offsets.push(offset)
+      if (offset === 0) return Response.json({ data: page })
+      return fail ? Response.json({ code: 'insufficient_scope' }, { status: 403 }) : Response.json({ data: [] })
+    })
+    const journal = createMemoryJournal()
+    const destination = createMemoryDestination()
+    const first = await runIngestion({ selected: selectStreams([fixturePipeline(deps)], ['resource:records', 'object:people']), backfill: undefined }, { journal, destination })
+    expect(first.ok).toBe(false)
+    expect((await journal.readCheckpoint('attio.primary.records.people')).envelope).toBeUndefined()
+    fail = false
+    const restored = await restoredJournal(journal)
+    const resumed = await runIngestion({ selected: selectStreams([fixturePipeline(deps)], ['resource:records', 'object:people']), backfill: undefined }, { journal: restored, destination })
+    expect(resumed.ok).toBe(true)
+    expect(offsets).toEqual([0, 500, 0, 500])
+    expect(requests).not.toContain('/v2/objects')
+    expect(destination.tables.get('default.attio_records_raw')).toHaveLength(500)
+  })
+
+  test('reruns publish changed observations with the same stable raw ID', async () => {
+    let changed = false
+    const deps = fixtureDeps((url) => url.pathname === '/v2/objects/object-people/records/query'
+      ? Response.json({ data: [{ ...person, values: { ...person.values, name: [{ full_name: changed ? 'Ada Updated' : 'Ada Example' }] } }] }) : fixtureResponse(url))
+    const journal = createMemoryJournal()
+    const destination = createMemoryDestination()
+    const request = { selected: selectStreams([fixturePipeline(deps)], ['resource:records', 'object:people']), backfill: undefined }
+    expect((await runIngestion(request, { journal, destination })).ok).toBe(true)
+    changed = true
+    expect((await runIngestion(request, { journal, destination })).ok).toBe(true)
+    const rows = destination.tables.get('default.attio_records_raw') ?? []
+    expect(rows).toHaveLength(2)
+    expect(rows[0]?.id).toBe(rows[1]?.id)
+    expect(rows[1]?.raw).toMatchObject({ data: { values: { name: [{ full_name: 'Ada Updated' }] } } })
+  })
+
+  test('a fresh runtime after a lost journal acknowledgement replays changed rows safely', async () => {
+    let changed = false
+    const deps = fixtureDeps((url) => url.pathname === '/v2/objects/object-people/records/query'
+      ? Response.json({ data: [{ ...person, values: { ...person.values, revision: [{ value: changed ? 'new' : 'old' }] } }] }) : fixtureResponse(url))
+    const journal = createMemoryJournal()
+    const destination = createMemoryDestination()
+    const failingJournal = {
+      ...journal,
+      async append(events: Parameters<typeof journal.append>[0]) {
+        if (events.some((event) => event.eventKind === 'batch_committed' && Number(event.detail.rows) > 0)) {
+          throw new Error('fixture journal unavailable after rows loaded')
+        }
+        await journal.append(events)
+      },
+    }
+    const failed = await runIngestion({ selected: selectStreams([fixturePipeline(deps)], ['resource:records', 'object:people']), backfill: undefined }, {
+      journal: failingJournal, destination,
+    })
+    expect(failed.ok).toBe(false)
+    expect(destination.tables.get('default.attio_records_raw')).toHaveLength(1)
+    changed = true
+    const resumed = await runIngestion({ selected: selectStreams([fixturePipeline(deps)], ['resource:records', 'object:people']), backfill: undefined }, {
+      journal: await restoredJournal(journal), destination,
+    })
+    expect(resumed.ok).toBe(true)
+    const rows = destination.tables.get('default.attio_records_raw') ?? []
+    expect(rows).toHaveLength(2)
+    expect(rows[0]?.id).toBe(rows[1]?.id)
+    expect(rows[1]?.raw).toMatchObject({ data: { values: { revision: [{ value: 'new' }] } } })
+  }, 10_000)
 })
 
-function fixturePipeline(deps: AttioClientDeps, selectedResources?: readonly string[]) {
+function fixturePipeline(deps: AttioClientDeps) {
   return definePipeline({
-    ...attio,
+    ...createAttioPipeline({ ...attioConfig, objects: ['people', 'subscriptions'], lists: ['sales'] }, deps),
     retry: { retries: 1, minTimeout: 0, maxTimeout: 0, randomize: false },
-    streams: attio.streams.filter((stream) => selectedResources === undefined || selectedResources.includes(stream.id.split('.').at(-1) ?? '')).map((stream) => {
-      const read = readers[stream.id.split('.').at(-1) ?? '']
-      if (!read) throw new Error(`No fixture reader for ${stream.id}`)
-      return { ...stream, read: (context: FetchContext) => read(context, deps) }
-    }),
   })
 }
 
@@ -191,3 +306,11 @@ async function collect<T>(items: AsyncIterable<T>): Promise<T[]> {
   for await (const item of items) result.push(item)
   return result
 }
+
+async function restoredJournal(previous: ReturnType<typeof createMemoryJournal>) {
+  const journal = createMemoryJournal()
+  await journal.append(previous.events.map((event) => ({
+    ...event, checkpoint: event.checkpoint === undefined ? undefined : JSON.parse(JSON.stringify(event.checkpoint)),
+  })))
+  return journal
+}
diff --git a/registry/attio/tests/fixtures.ts b/registry/attio/tests/fixtures.ts
index 984ee044..fc67aedc 100644
--- a/registry/attio/tests/fixtures.ts
+++ b/registry/attio/tests/fixtures.ts
@@ -1,9 +1,22 @@
 import type { AttioClientDeps } from '../client.js'
+import { attioConfig } from '../config.js'
 
 export const peopleObject = { id: { workspace_id: 'workspace-1', object_id: 'object-people' }, api_slug: 'people' }
-export const customObject = { id: { workspace_id: 'workspace-1', object_id: 'object-custom' }, api_slug: 'subscriptions' }
+const companiesObject = { id: { workspace_id: 'workspace-1', object_id: 'object-companies' }, api_slug: 'companies' }
+const customObject = { id: { workspace_id: 'workspace-1', object_id: 'object-custom' }, api_slug: 'subscriptions' }
 const salesList = { id: { workspace_id: 'workspace-1', list_id: 'list-sales' }, api_slug: 'sales' }
 
+const fixtureParents: Record<string, unknown> = {
+  '/v2/objects/people': peopleObject,
+  '/v2/objects/object-people': peopleObject,
+  '/v2/objects/companies': companiesObject,
+  '/v2/objects/object-companies': companiesObject,
+  '/v2/objects/subscriptions': customObject,
+  '/v2/objects/object-custom': customObject,
+  '/v2/lists/sales': salesList,
+  '/v2/lists/list-sales': salesList,
+}
+
 export const person = {
   id: { workspace_id: 'workspace-1', object_id: 'object-people', record_id: 'record-1' },
   created_at: '2026-01-01T00:00:00Z',
@@ -15,12 +28,14 @@ export const person = {
   },
 }
 
-export const fixtureCollections: Record<string, readonly unknown[]> = {
+const fixtureCollections: Record<string, readonly unknown[]> = {
   '/v2/objects': [peopleObject, customObject],
   '/v2/objects/object-people/records/query': [person],
   '/v2/objects/object-custom/records/query': [{ id: { ...person.id, object_id: 'object-custom' }, values: { custom_number: [{ value: 7 }] } }],
+  '/v2/objects/object-companies/records/query': [],
   '/v2/objects/object-people/attributes': [{ id: { ...peopleObject.id, attribute_id: 'attribute-1' }, api_slug: 'name', type: 'personal-name' }],
   '/v2/objects/object-custom/attributes': [{ id: { ...customObject.id, attribute_id: 'attribute-1' }, api_slug: 'custom_number', type: 'number' }],
+  '/v2/objects/object-companies/attributes': [],
   '/v2/lists': [salesList],
   '/v2/lists/list-sales/attributes': [{ id: { workspace_id: 'workspace-1', object_id: 'list-sales', attribute_id: 'attribute-1' }, api_slug: 'stage', type: 'status' }],
   '/v2/lists/list-sales/entries/query': [{ id: { ...salesList.id, entry_id: 'entry-1' }, parent_object: 'people', parent_record_id: 'record-1', entry_values: { stage: [{ status: { title: 'Prospect' } }] } }],
@@ -30,15 +45,18 @@ export const fixtureCollections: Record<string, readonly unknown[]> = {
 }
 
 export function fixtureDeps(
-  respond: (url: URL, init: RequestInit) => Response | Promise<Response> = (url) => {
-    const data = fixtureCollections[url.pathname]
-    if (data === undefined) throw new Error(`Unexpected fixture URL: ${url.pathname}`)
-    return Response.json({ data })
-  },
+  respond: (url: URL, init: RequestInit) => Response | Promise<Response> = fixtureResponse,
 ): AttioClientDeps {
   return {
+    config: attioConfig,
     token: () => 'fixture-token',
     wait: async () => {},
     fetch: (url, init) => Promise.resolve(respond(new URL(url), init)),
   }
 }
+
+export function fixtureResponse(url: URL): Response {
+  const data = fixtureParents[url.pathname] ?? fixtureCollections[url.pathname]
+  if (data === undefined) throw new Error(`Unexpected fixture URL: ${url.pathname}`)
+  return Response.json({ data })
+}
diff --git a/registry/attio/tests/install.e2e.test.ts b/registry/attio/tests/install.e2e.test.ts
index 313c442d..07600ed8 100644
--- a/registry/attio/tests/install.e2e.test.ts
+++ b/registry/attio/tests/install.e2e.test.ts
@@ -9,6 +9,7 @@ import { createClickHouseDestination, definePipeline, runIngestion, selectStream
 import { createMemoryJournal } from '@chkit/plugin-ingest/testing'
 
 import { buildRegistryCatalog } from '../../../packages/cli/src/registry/build.js'
+import { CLI_VERSION } from '../../../packages/cli/src/runtime/version.js'
 import { formatTestDiagnostic, runCli } from '../../../packages/cli/src/test/e2e-testkit.js'
 import { readRegistrySourceCatalog } from '../../../scripts/registry-catalog.js'
 import { fixtureDeps, person } from './fixtures.js'
@@ -33,7 +34,14 @@ describe.serial('built Attio template installed into a consumer', () => {
     const directory = await mkdtemp(join(tmpdir(), 'chkit-attio-installed-'))
     temporary.push(directory)
     const outputDir = join(directory, 'registry')
-    await buildRegistryCatalog({ catalog: await readRegistrySourceCatalog(), sourceRoot: join(root, 'registry'), outputDir })
+    const catalog = await readRegistrySourceCatalog()
+    // Exercise source with workspace packages, retaining the template version and changelog.
+    const workspaceCatalog = { ...catalog, items: catalog.items.map((item) => item.name === 'attio' ? {
+      ...item,
+      dependencies: [`@chkit/core@${CLI_VERSION}`, `@chkit/plugin-ingest@${CLI_VERSION}`],
+      meta: { chkit: { ...item.meta.chkit, chkit: CLI_VERSION, ingest: CLI_VERSION } },
+    } : item) }
+    await buildRegistryCatalog({ catalog: workspaceCatalog, sourceRoot: join(root, 'registry'), outputDir })
     const project = join(directory, 'project')
     await writeProject(project, root, env.clickhouseDatabase, prefix)
     const cliEnv = {
@@ -62,11 +70,16 @@ describe.serial('built Attio template installed into a consumer', () => {
     expect(await Bun.file(join(project, 'src/integrations/attio/tests/install.e2e.test.ts')).exists()).toBe(false)
     const configPath = join(project, 'src/integrations/attio/config.ts')
     const config = await readFile(configPath, 'utf8')
-    await writeFile(configPath, config.replace("database: 'default'", `database: ${JSON.stringify(env.clickhouseDatabase)}`).replace("tablePrefix: 'attio'", `tablePrefix: '${prefix}'`))
+    await writeFile(configPath, config.replace("database: 'default'", `database: ${JSON.stringify(env.clickhouseDatabase)}`)
+      .replace("tablePrefix: 'attio'", `tablePrefix: '${prefix}'`)
+      .replace("objects: ['people', 'companies']", "objects: ['people', 'subscriptions']"))
 
     const list = cli(['ingest', 'list', '--tag', 'provider:attio', '--json'])
     expect(list.exitCode, formatTestDiagnostic('list without token', list)).toBe(0)
     expect(JSON.parse(list.stdout).streams).toHaveLength(9)
+    const peopleOnly = cli(['ingest', 'list', '--tag', 'provider:attio', '--tag', 'resource:records', '--tag', 'object:people', '--json'])
+    expect(peopleOnly.exitCode, formatTestDiagnostic('one object stream', peopleOnly)).toBe(0)
+    expect(JSON.parse(peopleOnly.stdout).streams.map((stream: { streamId: string }) => stream.streamId)).toEqual(['attio.primary.records.people'])
     const generate = cli(['generate', '--name', 'attio_fixture', '--json'])
     expect(generate.exitCode, formatTestDiagnostic('generate', generate)).toBe(0)
     const migrate = cli(['migrate', '--apply', '--json'])
@@ -75,24 +88,27 @@ describe.serial('built Attio template installed into a consumer', () => {
     await waitForView(executor, env.clickhouseDatabase, `${prefix}_people`)
 
     const installed: typeof import('../index.js') = await import(pathToFileURL(join(project, 'src/integrations/attio/index.ts')).href)
-    const readers: typeof import('../sources/records.js') = await import(pathToFileURL(join(project, 'src/integrations/attio/sources/records.ts')).href)
-    const recordStream = installed.attio.streams.find((stream) => stream.id.endsWith('.records'))
-    expect(recordStream).toBeDefined()
-    if (!recordStream) throw new Error('Installed records stream is missing')
+    const factory: typeof import('../pipeline.js') = await import(pathToFileURL(join(project, 'src/integrations/attio/pipeline.ts')).href)
+    const installedConfig: typeof import('../config.js') = await import(pathToFileURL(join(project, 'src/integrations/attio/config.ts')).href)
+    expect(installed.attio.streams.filter((stream) => stream.tags.includes('resource:records')).map((stream) => stream.id))
+      .toEqual(['attio.primary.records.people', 'attio.primary.records.subscriptions'])
     let revision = 1
     const deps = fixtureDeps((url) => {
-      if (url.pathname === '/v2/objects') return Response.json({ data: [
+      if (url.pathname === '/v2/objects/people') return Response.json({ data:
         { id: { workspace_id: 'workspace-1', object_id: 'people' }, api_slug: 'people' },
+      })
+      if (url.pathname === '/v2/objects/subscriptions') return Response.json({ data:
         { id: { workspace_id: 'workspace-1', object_id: 'custom' }, api_slug: 'subscriptions' },
-      ] })
+      })
       if (url.pathname === '/v2/objects/people/records/query') return Response.json({ data: [
-        { ...person, values: { ...person.values, name: [{ full_name: revision === 1 ? 'Ada Example' : 'Ada Updated' }], email_addresses: [{ email_address: 'one@example.test' }, { email_address: 'two@example.test' }] } },
-        { id: { ...person.id, record_id: 'empty-attributes' }, values: {} },
+        { ...person, id: { ...person.id, object_id: 'people' }, values: { ...person.values, name: [{ full_name: revision === 1 ? 'Ada Example' : 'Ada Updated' }], email_addresses: [{ email_address: 'one@example.test' }, { email_address: 'two@example.test' }] } },
+        { id: { ...person.id, object_id: 'people', record_id: 'empty-attributes' }, values: {} },
       ] })
       if (url.pathname === '/v2/objects/custom/records/query') return Response.json({ data: [{ id: { workspace_id: 'workspace-1', object_id: 'custom', record_id: 'custom-1' }, values: { unmodeled: [{ value: 'retained' }] } }] })
       throw new Error(`Unexpected provider fixture request: ${url.pathname}`)
     })
-    const pipeline = definePipeline({ id: 'fixture', streams: [{ ...recordStream, read: (context) => readers.readRecords(context, deps) }], retry: { retries: 0 } })
+    const configured = factory.createAttioPipeline(installedConfig.attioConfig, deps)
+    const pipeline = definePipeline({ id: 'fixture', streams: configured.streams.filter((stream) => stream.tags.includes('resource:records')), retry: { retries: 0 } })
     const journal = createMemoryJournal()
     for (const next of [1, 2]) {
       revision = next
diff --git a/registry/circleback/README.md b/registry/circleback/README.md
index 72a53a7a..0702d359 100644
--- a/registry/circleback/README.md
+++ b/registry/circleback/README.md
@@ -1,8 +1,10 @@
-# Circleback raw ingestion example
+# Circleback raw ingestion
 
-This is a small editable starting point based on the Circleback source in [obsessiondb/brain](https://github.com/obsessiondb/brain/tree/main/scripts/brain-sync). It stores provider responses as native JSON without Brain's memory or sales projections.
+This editable integration stores Circleback provider objects in five independent raw resource streams within one account pipeline.
 
-Set `CIRCLEBACK_API_KEY` in the runtime environment and configure a direct ClickHouse connection. Edit the reader in `index.ts` to select meetings and decide whether to fetch transcripts. Native JSON requires ClickHouse 25.3 or later.
+Set `CIRCLEBACK_API_KEY` in the runtime environment. Create a key in Circleback **Settings → API keys** and configure the project's direct ClickHouse connection. Native JSON requires ClickHouse 25.3 or later. The [official API reference](https://circleback.ai/docs/api) describes authentication, access and account rate limits.
+
+Edit `config.ts` for the stable `sourceId`, meeting `ownership`, and setup-time `database`. `ownership: 'All'` includes meetings shared with the authenticated user. People, companies, and action items use their own authenticated-user API collections; these APIs do not promise an organization-wide export.
 
 ```sh
 bunx chkit check
@@ -14,6 +16,85 @@ bunx chkit ingest run --tag provider:circleback
 
 ## Resources
 
-- `meetings` → `circleback_meetings_raw`
+| Resource tag | Raw table | Retrieval |
+|---|---|---|
+| `resource:meetings` | `circleback_meetings_raw` | All accessible meeting pages with configured ownership. |
+| `resource:meeting_transcripts` | `circleback_meeting_transcripts_raw` | Own complete meeting discovery, then a whole transcript snapshot per meeting. |
+| `resource:action_items` | `circleback_action_items_raw` | All pages of both `PENDING` and `DONE`, with `assigneeType=Anyone`. |
+| `resource:people` | `circleback_people_raw` | All attendee person pages and their same-person detail responses. |
+| `resource:companies` | `circleback_companies_raw` | All company pages and their same-company detail responses. |
+
+`pipeline.ts` composes the streams; `sources/` contains each raw schema and reader. `client.ts` owns authenticated requests, validation, scoped row mapping, and native `paginate()` Link traversal. `index.ts` exports the pipeline and all five tables. Selecting one resource or reversing stream order requires no other stream to run. Meeting publication does not depend on transcript retrieval.
+
+Provider fields stay under `raw.data`; meeting objects retain provider-returned notes, attendee and action-item summaries, insights, and recording links. Transcripts and independently listed action items are not fetched to assemble a meeting document. The requested projection is `tags: string[]`: every returned tag name is retained, while tag definitions have no separate stream. Recordings and other binary links are preserved without downloading their content.
+
+People perform one [detail GET per listed profile](https://circleback.ai/docs/api/people/get-person), preserving native fields and `externalLinks`; returned IDs must match discovery. Companies similarly request one detail per listed domain. These same-resource reads add to each full run's request cost and require matching access.
+
+```sh
+bunx chkit ingest run --tag provider:circleback --tag resource:meeting_transcripts
+bunx chkit ingest status --tag provider:circleback --json
+```
+
+## Full reads and recovery
+
+The [provider's list endpoints](https://circleback.ai/docs/api) return arrays with RFC 8288 `Link` continuations. They expose no reliable modification feed or durable sync token. Each stream uses `fullSync()` and ordinary pagination, revisiting its complete accessible collection on every run. Cursor-only next links retain the stream's fixed ownership, assignee and status filters; conflicting filters, malformed pages, unsafe URLs and cyclic continuations fail visibly.
+
+Successful completion follows destination acknowledgement and includes empty reads. A failed or interrupted stream replays from its first page on the next run. Loaded rows may remain visible after a later failure; other streams keep their own successful completion. There is no custom parent ledger or scan checkpoint. Full reads ignore date backfill bounds and provide no date-range backfill.
+
+Transcript discovery has its own full meeting listing. It rechecks old meetings without relying on a meeting's `updatedAt`, capturing transcripts that become available later. IDs absent from the current listing are not an executable retry queue. A changed or inaccessible source cannot establish deletion; absent records stay stored.
+
+The [action-item listing](https://circleback.ai/docs/api/action-items/list-action-items) defaults to the authenticated assignee and incomplete items. The integration explicitly reads any assignee across both native completion statuses. `PENDING` and `DONE` are the exhaustive statuses in the [official OpenAPI](https://circleback.ai/docs/api/openapi.json), also documented by the [update endpoint](https://circleback.ai/docs/api/action-items/update-action-item). An unexpected status or ignored partition fails visibly. Mutable lists and status partitions are not atomic snapshots; a later full run reconciles edits and moves between partitions.
+
+Requests forward cancellation, time out after 30 seconds, and use one executor-owned retry wrapper. HTTP failures retain provider responses; `429` honors `Retry-After`. Authentication and listing permission failures fail their resource. Run one ingestion process per ClickHouse target at a time and repeat runs with an external scheduler.
+
+## Identities and company joins
+
+Every row keeps `raw.source_id`. Stable row IDs are JSON-encoded arrays:
+
+| Resource | Row identity |
+|---|---|
+| Meetings | `[sourceId, meeting.id]` |
+| Transcript snapshot | `[sourceId, meetingId]` |
+| Transcript read outcome | `[sourceId, meetingId, 'availability']` |
+| Action items | `[sourceId, actionItem.id]` |
+| People | `[sourceId, person.id]` |
+| Companies | `[sourceId, company.domain]` |
+
+Numeric provider IDs such as `assignee.profileId` and `person.companyId` remain numbers in `data`; `meetingIds` retain their native strings. Keep source identity in joins. Company identity always uses the provider domain, so a numeric ID appearing later does not change its row key.
+
+The [company list](https://circleback.ai/docs/api/companies/list-companies) permits an optional native numeric `id`; [company detail](https://circleback.ai/docs/api/companies/get-company) includes people and external links. The companies stream preserves both listing and detail fields under `data`. Its `company_id` envelope field is the listed/detail native ID or a consistent non-null `people[].companyId`; conflicting native IDs fail. A valid empty company without a numeric ID still syncs with `company_id: null`. No numeric ID is synthesized. Join `person.data.companyId` to `company.company_id` only when present, together with `source_id`; unknown numeric identity is a documented join gap.
+
+Keep `sourceId` stable. Switching accounts or meeting filters requires a distinct source ID and deliberately configured destination. `createCirclebackPipeline(config, deps)` binds a snapshot of reader configuration and optional HTTP dependencies. Its runtime config does not redefine exported tables; change `database` or installed raw table definitions before schema discovery and migration generation.
+
+Version 0.1.0 used direct meeting JSON and unscoped meeting row IDs. The 0.2.0 layout introduces source envelopes, scoped row keys, string tags and four additional tables. Reingest into a fresh configured destination or migrate earlier observations deliberately; old unscoped rows are not automatically rewritten or deleted.
+
+## Transcript snapshots and availability
+
+The transcript table contains two explicitly distinguished observations per meeting:
+
+- `kind: 'transcript'`: the last successfully retrieved full segment array under `data`, with `status: 'available'`.
+- `kind: 'availability'`: the latest read outcome, `available`, `forbidden` for HTTP 403, or `not_found` for HTTP 404.
+
+A 403/404 updates the outcome key and preserves earlier successful text. It proves neither deletion nor temporary processing. A valid HTTP 200 empty array replaces the prior snapshot with `[]`; malformed HTTP 200 content fails without publishing success. Segment speaker, text, timestamps and additional fields stay intact, with no synthetic segment IDs.
+
+Use `FINAL` for latest observations and filter successful snapshots explicitly:
+
+```sql
+SELECT
+  raw.source_id::String AS source_id,
+  raw.meeting_id::String AS meeting_id,
+  JSONExtractRaw(toJSONString(raw), 'data') AS transcript
+FROM default.circleback_meeting_transcripts_raw FINAL
+WHERE raw.kind::String = 'transcript';
+```
+
+Latest outcomes are the `kind = 'availability'` rows in the same table. Join them to snapshots on `source_id` and `meeting_id`; an outcome can be forbidden while a previous successful snapshot remains readable. The [integration guide](https://chkit.obsessiondb.com/integrations/circleback/) shows that query.
+
+## Fixture tests
+
+```sh
+bunx chkit add circleback --with-tests
+bun test src/integrations/circleback/tests/basic.test.ts
+```
 
-The meetings endpoint is scanned on every run. Missing transcripts remain null; removed meetings remain stored. A failed API request fails the stream. Raw rows use provider IDs and keep the last observed value; there is no deletion reconciliation. Edit the readers, select fewer streams, or add SQL views for a specific use case. Run one ingestion process per ClickHouse target at a time.
+Portable fixtures use injected HTTP and in-memory ingestion adapters without credentials or a live database. They cover five isolated and reordered resources, full-sync failure/replay, empty completion, scoped identities, tag names, all action statuses, company joins, late transcripts, permission-loss retention, malformed responses, and pagination safety.
diff --git a/registry/circleback/client.ts b/registry/circleback/client.ts
new file mode 100644
index 00000000..7dcfe24c
--- /dev/null
+++ b/registry/circleback/client.ts
@@ -0,0 +1,118 @@
+import { HttpError, IngestConfigError, paginate, rawRows, type ErrorClassifier, type FetchContext } from '@chkit/plugin-ingest'
+
+import { circlebackConfig, type CirclebackReaderConfig } from './config.js'
+
+const baseUrl = 'https://circleback.ai/api'
+export type CirclebackObject = Record<string, unknown>
+
+export interface CirclebackClientDeps {
+  config: CirclebackReaderConfig
+  fetch: (url: string, init: RequestInit) => Promise<Response>
+  token: () => string | undefined
+}
+
+export const defaultCirclebackClientDeps: CirclebackClientDeps = {
+  config: circlebackConfig,
+  fetch: (url, init) => fetch(url, init),
+  token: () => process.env.CIRCLEBACK_API_KEY,
+}
+
+/** The executor owns one request attempt per page; Link cursors remain local to the full read. */
+export function readCirclebackPages(context: FetchContext, collection: {
+  path: '/meetings' | '/action-items' | '/people' | '/companies'
+  query?: Record<string, string>
+}, deps: CirclebackClientDeps) {
+  const initial = new URL(`${baseUrl}${collection.path}`)
+  for (const [key, value] of Object.entries(collection.query ?? {})) initial.searchParams.set(key, value)
+  return paginate<CirclebackObject, string>({
+    context, initial: initial.toString(), label: `GET ${collection.path}`,
+    fetchPage: async (url, signal) => {
+      if (!url) throw new IngestConfigError('Circleback collection URL is missing.')
+      const response = await requestCircleback(url, signal, deps)
+      const body: unknown = await response.json()
+      if (!Array.isArray(body)) throw new IngestConfigError(`Circleback ${collection.path} is not an array.`)
+      return { items: body.map((item: unknown) => requireCirclebackObject(item, collection.path)),
+        next: nextLink(response.headers.get('link'), url, collection.query ?? {}) }
+    },
+  })
+}
+
+export async function requestCircleback(pathOrUrl: string, signal: AbortSignal, deps: CirclebackClientDeps, allowUnavailable = false): Promise<Response> {
+  const token = deps.token()?.trim()
+  if (!token) throw new IngestConfigError('Set CIRCLEBACK_API_KEY.')
+  const response = await deps.fetch(pathOrUrl.startsWith('/') ? `${baseUrl}${pathOrUrl}` : pathOrUrl, {
+    signal: AbortSignal.any([signal, AbortSignal.timeout(30_000)]), redirect: 'error',
+    headers: { Authorization: `Bearer ${token}`, Accept: 'application/json' },
+  })
+  if (allowUnavailable && (response.status === 403 || response.status === 404)) return response
+  if (!response.ok) throw await HttpError.fromResponse(response)
+  return response
+}
+
+export function classifyCirclebackError(cause: unknown): ReturnType<ErrorClassifier> {
+  return cause instanceof SyntaxError ? { kind: 'permanent' } : undefined
+}
+
+export function toCirclebackRows(items: readonly CirclebackObject[], id: (item: CirclebackObject) => string | number, sourceId: string) {
+  return rawRows(items.map((data) => ({ source_id: sourceId, data })), (item) => JSON.stringify([sourceId, id(item.data)]))
+}
+
+/** Tag names are the requested projection; provider objects otherwise stay intact. */
+export function tagNames(item: CirclebackObject): CirclebackObject {
+  if (item.tags === undefined) return item
+  if (!Array.isArray(item.tags)) throw new IngestConfigError('Circleback tags is not an array.')
+  return { ...item, tags: item.tags.map((tag: unknown) => {
+    const name = requireCirclebackObject(tag, 'tag').name
+    if (typeof name !== 'string' || !name.trim()) throw new IngestConfigError('Circleback tag has no name.')
+    return name
+  }) }
+}
+
+export function requireCirclebackObject(value: unknown, label: string): CirclebackObject {
+  if (!isCirclebackObject(value)) throw new IngestConfigError(`Circleback ${label} is not an object.`)
+  return value
+}
+
+export function meetingId(item: CirclebackObject): string {
+  if (typeof item.id !== 'string' || !item.id.trim()) throw new IngestConfigError('Circleback meeting has no valid ID.')
+  return item.id
+}
+
+export function numericId(value: unknown, label: string): number {
+  if (typeof value !== 'number' || !Number.isSafeInteger(value) || value <= 0) throw new IngestConfigError(`Circleback ${label} has no valid numeric ID.`)
+  return value
+}
+
+function isCirclebackObject(value: unknown): value is CirclebackObject {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function nextLink(header: string | null, current: string, query: Record<string, string>): string | undefined {
+  if (!header?.trim()) return undefined
+  const candidates: string[] = []
+  for (const part of header.split(/,(?=\s*<)/)) {
+    const link = /^\s*<([^>]+)>\s*(.*)$/.exec(part)
+    if (!link) throw new IngestConfigError('Circleback returned a malformed Link header.')
+    const relation = /;\s*rel\s*=\s*(?:"([^"]+)"|([^;\s]+))/.exec(link[2] ?? '')
+    if (!(relation?.[1] ?? relation?.[2])?.split(/\s+/).includes('next')) continue
+    if (!link[1]) throw new IngestConfigError('Circleback next page URL is missing.')
+    candidates.push(link[1])
+  }
+  if (candidates.length > 1) throw new IngestConfigError('Circleback returned multiple next pages.')
+  const value = candidates[0]
+  if (!value) return undefined
+  let next: URL
+  try { next = new URL(value, current) }
+  catch { throw new IngestConfigError('Circleback returned an invalid next page URL.') }
+  if (next.origin !== 'https://circleback.ai' || next.pathname !== new URL(current).pathname || next.username || next.password || next.hash) {
+    throw new IngestConfigError('Circleback next page changed the collection or origin.')
+  }
+  for (const [key, value] of Object.entries(query)) {
+    const values = next.searchParams.getAll(key)
+    if (values.length > 1 || values.some((nextValue) => nextValue !== value)) {
+      throw new IngestConfigError(`Circleback next page changed the ${key} filter.`)
+    }
+    next.searchParams.set(key, value)
+  }
+  return next.toString()
+}
diff --git a/registry/circleback/config.ts b/registry/circleback/config.ts
new file mode 100644
index 00000000..915d1292
--- /dev/null
+++ b/registry/circleback/config.ts
@@ -0,0 +1,16 @@
+export interface CirclebackConfig {
+  /** Stable account/installation namespace. Use a new sourceId when changing accounts or filters. */
+  sourceId: string
+  /** Schema setup only; runtime pipeline factories do not change raw tables. */
+  database: string
+  ownership: 'All' | 'Mine' | 'Shared'
+}
+
+export type CirclebackReaderConfig = Omit<CirclebackConfig, 'database'>
+
+// Credentials are read at request time; collections are fully revisited on every run.
+export const circlebackConfig: CirclebackConfig = {
+  sourceId: 'circleback',
+  database: 'default',
+  ownership: 'All',
+}
diff --git a/registry/circleback/index.ts b/registry/circleback/index.ts
index 4e60b1a4..2cefc0d8 100644
--- a/registry/circleback/index.ts
+++ b/registry/circleback/index.ts
@@ -1,49 +1,6 @@
-import { definePipeline, defineStream, HttpError, rawRows, rawTable } from '@chkit/plugin-ingest'
-
-const database = 'default'
-const baseUrl = 'https://circleback.ai/api'
-
-interface Meeting { id: string; [key: string]: unknown }
-
-export const circleback_meetingsRaw = rawTable({ database, name: 'circleback_meetings_raw' })
-
-export const circlebackPipeline = definePipeline({
-  id: 'circleback', tags: ['provider:circleback'], maxFetches: 1,
-  streams: [defineStream({
-    id: 'circleback.meetings', tags: ['resource:meetings'], destination: circleback_meetingsRaw,
-    async *read(context) {
-      let next: string | undefined = `${baseUrl}/meetings?ownership=All`
-      const seen = new Set<string>()
-      while (next) {
-        if (seen.has(next)) throw new Error('Circleback repeated a page URL')
-        seen.add(next)
-        const current: string = next
-        const response = await context.attempt((signal) => request(current, signal), { label: 'GET /meetings' })
-        if (!response) throw new Error('Circleback returned no meetings response')
-        const meetings = await response.json() as Meeting[]
-        if (!Array.isArray(meetings)) throw new Error('Circleback meetings response is not an array')
-        const rows = []
-        for (const meeting of meetings) {
-          if (!meeting.id) throw new Error('Circleback meeting has no ID')
-          const transcript = await context.attempt(async (signal) => {
-            const result = await request(`${baseUrl}/meeting/${encodeURIComponent(meeting.id)}/transcript`, signal, true)
-            return result ? await result.json() : null
-          }, { label: 'GET meeting transcript' })
-          rows.push({ ...meeting, transcript })
-        }
-        if (rows.length) yield { rows: rawRows(rows, (meeting) => meeting.id) }
-        next = response.headers.get('link')?.split(',').map((part) => /<([^>]+)>\s*;.*rel="?next"?/.exec(part)?.[1]).find(Boolean)
-        if (next) next = new URL(next, current).toString()
-      }
-    },
-  })],
-})
-
-async function request(url: string, signal: AbortSignal, optional = false): Promise<Response | null> {
-  const token = process.env.CIRCLEBACK_API_KEY
-  if (!token) throw new Error('Set CIRCLEBACK_API_KEY')
-  const response = await fetch(url, { signal, headers: { Authorization: `Bearer ${token}`, Accept: 'application/json' } })
-  if (optional && (response.status === 403 || response.status === 404)) return null
-  if (!response.ok) throw await HttpError.fromResponse(response)
-  return response
-}
+export { circlebackPipeline, createCirclebackPipeline } from './pipeline.js'
+export { circleback_meetingsRaw } from './sources/meetings.js'
+export { circleback_meetingTranscriptsRaw } from './sources/meeting-transcripts.js'
+export { circleback_actionItemsRaw } from './sources/action-items.js'
+export { circleback_peopleRaw } from './sources/people.js'
+export { circleback_companiesRaw } from './sources/companies.js'
diff --git a/registry/circleback/manifest.json b/registry/circleback/manifest.json
index 110b1b1d..83075452 100644
--- a/registry/circleback/manifest.json
+++ b/registry/circleback/manifest.json
@@ -3,10 +3,10 @@
   "name": "circleback",
   "type": "registry:item",
   "title": "Circleback",
-  "description": "Small, editable Circleback API ingestion example with raw ClickHouse tables.",
+  "description": "Five independent Circleback raw resource streams with complete full reads, transcript availability evidence, and native relationships.",
   "dependencies": [
-    "@chkit/core@^0.2.0-beta.8",
-    "@chkit/plugin-ingest@^0.2.0-beta.8"
+    "@chkit/core@^0.2.0-beta.10",
+    "@chkit/plugin-ingest@^0.2.0-beta.10"
   ],
   "files": [
     {
@@ -19,6 +19,14 @@
       "type": "registry:file",
       "target": "src/integrations/circleback/index.ts"
     },
+    { "path": "config.ts", "type": "registry:file", "target": "src/integrations/circleback/config.ts" },
+    { "path": "client.ts", "type": "registry:file", "target": "src/integrations/circleback/client.ts" },
+    { "path": "pipeline.ts", "type": "registry:file", "target": "src/integrations/circleback/pipeline.ts" },
+    { "path": "sources/meetings.ts", "type": "registry:file", "target": "src/integrations/circleback/sources/meetings.ts" },
+    { "path": "sources/meeting-transcripts.ts", "type": "registry:file", "target": "src/integrations/circleback/sources/meeting-transcripts.ts" },
+    { "path": "sources/action-items.ts", "type": "registry:file", "target": "src/integrations/circleback/sources/action-items.ts" },
+    { "path": "sources/people.ts", "type": "registry:file", "target": "src/integrations/circleback/sources/people.ts" },
+    { "path": "sources/companies.ts", "type": "registry:file", "target": "src/integrations/circleback/sources/companies.ts" },
     {
       "path": "tests/basic.test.ts",
       "type": "registry:file",
@@ -29,26 +37,66 @@
   "meta": {
     "chkit": {
       "formatVersion": 1,
-      "version": "0.1.0",
+      "version": "0.2.0",
+      "changelog": [
+        {
+          "version": "0.2.0",
+          "changes": [
+            "Provide one configurable account pipeline with independent meetings, meeting transcripts, action items, people, and companies raw streams.",
+            "Use native full-sync completion and safe first-page replay with scoped identities and validated Link pagination that preserves query filters.",
+            "Revisit every eligible meeting for late transcripts; retain successful snapshots separately from forbidden/not-found read outcomes.",
+            "Read action items for anyone across both native PENDING and DONE statuses; preserve people and company relationships without inventing numeric company IDs.",
+            "Store complete tag names as string arrays and raw provider payloads in source-scoped envelopes; adopting this layout requires reingestion or migration of earlier unscoped meeting observations.",
+            "Add portable fixtures for independently selected resources, reversed stream order, malformed responses, pagination, late transcripts, and source/destination recovery.",
+            "Consume full pagination pages and use shared continuation-cycle detection while preserving independent resource checkpoints and provider Link validation."
+          ]
+        },
+        {
+          "version": "0.1.0",
+          "changes": [
+            "Introduce raw meeting ingestion with transcript enrichment."
+          ]
+        }
+      ],
       "documentation": "https://chkit.obsessiondb.com/integrations/circleback/",
       "logo": "https://chkit.obsessiondb.com/logos/circleback.svg",
       "language": "typescript",
       "license": "MIT",
-      "chkit": "^0.2.0-beta.8",
-      "ingest": "^0.2.0-beta.8",
+      "chkit": "^0.2.0-beta.10",
+      "ingest": "^0.2.0-beta.10",
       "clickhouse": ">=25.3.0",
       "root": "src/integrations/circleback",
       "entry": "index.ts",
       "exports": [
         "circlebackPipeline",
-        "circleback_meetingsRaw"
+        "createCirclebackPipeline",
+        "circleback_meetingsRaw",
+        "circleback_meetingTranscriptsRaw",
+        "circleback_actionItemsRaw",
+        "circleback_peopleRaw",
+        "circleback_companiesRaw"
       ],
       "resources": [
         {
           "name": "meetings",
           "title": "Meetings",
           "table": "circleback_meetings_raw",
-          "description": "Meeting metadata and notes, with a transcript where access permits it.",
+          "description": "Accessible meeting provider objects and notes, with tag names as string arrays.",
+          "scopes": [],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/meetings",
+              "documentation": "https://circleback.ai/docs/api/meetings/list-meetings"
+            }
+          ]
+        },
+        {
+          "name": "meeting_transcripts",
+          "title": "Meeting transcripts",
+          "table": "circleback_meeting_transcripts_raw",
+          "description": "Whole transcript snapshots per meeting and separate latest read outcomes; availability failures preserve earlier successful text.",
           "scopes": [],
           "strategy": "full",
           "endpoints": [
@@ -63,6 +111,39 @@
               "documentation": "https://circleback.ai/docs/api/meetings/get-meeting-transcript"
             }
           ]
+        },
+        {
+          "name": "action_items",
+          "title": "Action items",
+          "table": "circleback_action_items_raw",
+          "description": "Raw action items for any assignee, fully paginated across PENDING and DONE completion statuses.",
+          "scopes": [],
+          "strategy": "full",
+          "endpoints": [{ "method": "GET", "path": "/action-items", "documentation": "https://circleback.ai/docs/api/action-items/list-action-items" }]
+        },
+        {
+          "name": "people",
+          "title": "People",
+          "table": "circleback_people_raw",
+          "description": "Complete same-person listing and detail fields, preserving external references and native person/company IDs.",
+          "scopes": [],
+          "strategy": "full",
+          "endpoints": [
+            { "method": "GET", "path": "/people", "documentation": "https://circleback.ai/docs/api/people/list-people" },
+            { "method": "GET", "path": "/person/{profileId}", "documentation": "https://circleback.ai/docs/api/people/get-person" }
+          ]
+        },
+        {
+          "name": "companies",
+          "title": "Companies",
+          "table": "circleback_companies_raw",
+          "description": "Domain-keyed company listing and detail fields with a nullable, corroborated native numeric company ID for joins.",
+          "scopes": [],
+          "strategy": "full",
+          "endpoints": [
+            { "method": "GET", "path": "/companies", "documentation": "https://circleback.ai/docs/api/companies/list-companies" },
+            { "method": "GET", "path": "/company/{domain}", "documentation": "https://circleback.ai/docs/api/companies/get-company" }
+          ]
         }
       ],
       "env": {
@@ -81,10 +162,13 @@
       },
       "views": [],
       "sync": {
-        "description": "A full read runs for each enabled stream. Stable IDs keep the latest observed record.",
+        "description": "Each resource fully reads its own provider collection and records independent successful completion after writes. Interrupted reads restart at the first page. Transcripts own complete meeting discovery and revisit late availability on unchanged old meetings.",
         "schedule": "Run bunx chkit ingest run --tag provider:circleback from a scheduler.",
-        "deletions": "The meetings endpoint is scanned on every run. Missing transcripts remain null; removed meetings remain stored."
+        "deletions": "Absent resources remain stored. Transcript 403 and 404 responses update explicit read outcomes without deleting prior successful content; neither proves deletion or temporary processing."
       }
     }
-  }
+  },
+  "devDependencies": [
+    "@types/bun@^1.2.0"
+  ]
 }
diff --git a/registry/circleback/pipeline.ts b/registry/circleback/pipeline.ts
new file mode 100644
index 00000000..f496b80d
--- /dev/null
+++ b/registry/circleback/pipeline.ts
@@ -0,0 +1,34 @@
+import { definePipeline, defineStream, fullSync, IngestConfigError } from '@chkit/plugin-ingest'
+
+import { classifyCirclebackError, defaultCirclebackClientDeps, type CirclebackClientDeps } from './client.js'
+import { circlebackConfig, type CirclebackReaderConfig } from './config.js'
+import { circleback_meetingsRaw, readMeetings } from './sources/meetings.js'
+import { circleback_meetingTranscriptsRaw, readMeetingTranscripts } from './sources/meeting-transcripts.js'
+import { circleback_actionItemsRaw, readActionItems } from './sources/action-items.js'
+import { circleback_peopleRaw, readPeople } from './sources/people.js'
+import { circleback_companiesRaw, readCompanies } from './sources/companies.js'
+
+export function createCirclebackPipeline(config: CirclebackReaderConfig = circlebackConfig, deps: CirclebackClientDeps = defaultCirclebackClientDeps) {
+  if (!config.sourceId.trim() || !['All', 'Mine', 'Shared'].includes(config.ownership)) {
+    throw new IngestConfigError('Circleback needs a sourceId and valid meeting ownership.')
+  }
+  const source = { ...config }, client = { ...deps, config: source }
+  const options = { incremental: fullSync(), classifyError: classifyCirclebackError }
+  return definePipeline({
+    id: source.sourceId, tags: ['provider:circleback'], maxStreams: 1, maxFetches: 1,
+    streams: [
+      defineStream({ ...options, id: `${source.sourceId}.meetings`, tags: ['resource:meetings'], destination: circleback_meetingsRaw,
+        read: (context) => readMeetings(context, client) }),
+      defineStream({ ...options, id: `${source.sourceId}.meeting_transcripts`, tags: ['resource:meeting_transcripts'], destination: circleback_meetingTranscriptsRaw,
+        read: (context) => readMeetingTranscripts(context, client) }),
+      defineStream({ ...options, id: `${source.sourceId}.action_items`, tags: ['resource:action_items'], destination: circleback_actionItemsRaw,
+        read: (context) => readActionItems(context, client) }),
+      defineStream({ ...options, id: `${source.sourceId}.people`, tags: ['resource:people'], destination: circleback_peopleRaw,
+        read: (context) => readPeople(context, client) }),
+      defineStream({ ...options, id: `${source.sourceId}.companies`, tags: ['resource:companies'], destination: circleback_companiesRaw,
+        read: (context) => readCompanies(context, client) }),
+    ],
+  })
+}
+
+export const circlebackPipeline = createCirclebackPipeline()
diff --git a/registry/circleback/releases/0.2.0.json b/registry/circleback/releases/0.2.0.json
new file mode 100644
index 00000000..70a866eb
--- /dev/null
+++ b/registry/circleback/releases/0.2.0.json
@@ -0,0 +1,252 @@
+{
+  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
+  "name": "circleback",
+  "type": "registry:item",
+  "title": "Circleback",
+  "description": "Five independent Circleback raw resource streams with complete full reads, transcript availability evidence, and native relationships.",
+  "dependencies": [
+    "@chkit/core@^0.2.0-beta.10",
+    "@chkit/plugin-ingest@^0.2.0-beta.10"
+  ],
+  "devDependencies": [
+    "@types/bun@^1.2.0"
+  ],
+  "files": [
+    {
+      "path": "circleback/README.md",
+      "type": "registry:file",
+      "target": "src/integrations/circleback/README.md",
+      "content": "# Circleback raw ingestion\n\nThis editable integration stores Circleback provider objects in five independent raw resource streams within one account pipeline.\n\nSet `CIRCLEBACK_API_KEY` in the runtime environment. Create a key in Circleback **Settings → API keys** and configure the project's direct ClickHouse connection. Native JSON requires ClickHouse 25.3 or later. The [official API reference](https://circleback.ai/docs/api) describes authentication, access and account rate limits.\n\nEdit `config.ts` for the stable `sourceId`, meeting `ownership`, and setup-time `database`. `ownership: 'All'` includes meetings shared with the authenticated user. People, companies, and action items use their own authenticated-user API collections; these APIs do not promise an organization-wide export.\n\n```sh\nbunx chkit check\nbunx chkit generate --name add_circleback\n# Review the migration before applying it.\nbunx chkit migrate --apply\nbunx chkit ingest run --tag provider:circleback\n```\n\n## Resources\n\n| Resource tag | Raw table | Retrieval |\n|---|---|---|\n| `resource:meetings` | `circleback_meetings_raw` | All accessible meeting pages with configured ownership. |\n| `resource:meeting_transcripts` | `circleback_meeting_transcripts_raw` | Own complete meeting discovery, then a whole transcript snapshot per meeting. |\n| `resource:action_items` | `circleback_action_items_raw` | All pages of both `PENDING` and `DONE`, with `assigneeType=Anyone`. |\n| `resource:people` | `circleback_people_raw` | All attendee person pages and their same-person detail responses. |\n| `resource:companies` | `circleback_companies_raw` | All company pages and their same-company detail responses. |\n\n`pipeline.ts` composes the streams; `sources/` contains each raw schema and reader. `client.ts` owns authenticated requests, validation, scoped row mapping, and native `paginate()` Link traversal. `index.ts` exports the pipeline and all five tables. Selecting one resource or reversing stream order requires no other stream to run. Meeting publication does not depend on transcript retrieval.\n\nProvider fields stay under `raw.data`; meeting objects retain provider-returned notes, attendee and action-item summaries, insights, and recording links. Transcripts and independently listed action items are not fetched to assemble a meeting document. The requested projection is `tags: string[]`: every returned tag name is retained, while tag definitions have no separate stream. Recordings and other binary links are preserved without downloading their content.\n\nPeople perform one [detail GET per listed profile](https://circleback.ai/docs/api/people/get-person), preserving native fields and `externalLinks`; returned IDs must match discovery. Companies similarly request one detail per listed domain. These same-resource reads add to each full run's request cost and require matching access.\n\n```sh\nbunx chkit ingest run --tag provider:circleback --tag resource:meeting_transcripts\nbunx chkit ingest status --tag provider:circleback --json\n```\n\n## Full reads and recovery\n\nThe [provider's list endpoints](https://circleback.ai/docs/api) return arrays with RFC 8288 `Link` continuations. They expose no reliable modification feed or durable sync token. Each stream uses `fullSync()` and ordinary pagination, revisiting its complete accessible collection on every run. Cursor-only next links retain the stream's fixed ownership, assignee and status filters; conflicting filters, malformed pages, unsafe URLs and cyclic continuations fail visibly.\n\nSuccessful completion follows destination acknowledgement and includes empty reads. A failed or interrupted stream replays from its first page on the next run. Loaded rows may remain visible after a later failure; other streams keep their own successful completion. There is no custom parent ledger or scan checkpoint. Full reads ignore date backfill bounds and provide no date-range backfill.\n\nTranscript discovery has its own full meeting listing. It rechecks old meetings without relying on a meeting's `updatedAt`, capturing transcripts that become available later. IDs absent from the current listing are not an executable retry queue. A changed or inaccessible source cannot establish deletion; absent records stay stored.\n\nThe [action-item listing](https://circleback.ai/docs/api/action-items/list-action-items) defaults to the authenticated assignee and incomplete items. The integration explicitly reads any assignee across both native completion statuses. `PENDING` and `DONE` are the exhaustive statuses in the [official OpenAPI](https://circleback.ai/docs/api/openapi.json), also documented by the [update endpoint](https://circleback.ai/docs/api/action-items/update-action-item). An unexpected status or ignored partition fails visibly. Mutable lists and status partitions are not atomic snapshots; a later full run reconciles edits and moves between partitions.\n\nRequests forward cancellation, time out after 30 seconds, and use one executor-owned retry wrapper. HTTP failures retain provider responses; `429` honors `Retry-After`. Authentication and listing permission failures fail their resource. Run one ingestion process per ClickHouse target at a time and repeat runs with an external scheduler.\n\n## Identities and company joins\n\nEvery row keeps `raw.source_id`. Stable row IDs are JSON-encoded arrays:\n\n| Resource | Row identity |\n|---|---|\n| Meetings | `[sourceId, meeting.id]` |\n| Transcript snapshot | `[sourceId, meetingId]` |\n| Transcript read outcome | `[sourceId, meetingId, 'availability']` |\n| Action items | `[sourceId, actionItem.id]` |\n| People | `[sourceId, person.id]` |\n| Companies | `[sourceId, company.domain]` |\n\nNumeric provider IDs such as `assignee.profileId` and `person.companyId` remain numbers in `data`; `meetingIds` retain their native strings. Keep source identity in joins. Company identity always uses the provider domain, so a numeric ID appearing later does not change its row key.\n\nThe [company list](https://circleback.ai/docs/api/companies/list-companies) permits an optional native numeric `id`; [company detail](https://circleback.ai/docs/api/companies/get-company) includes people and external links. The companies stream preserves both listing and detail fields under `data`. Its `company_id` envelope field is the listed/detail native ID or a consistent non-null `people[].companyId`; conflicting native IDs fail. A valid empty company without a numeric ID still syncs with `company_id: null`. No numeric ID is synthesized. Join `person.data.companyId` to `company.company_id` only when present, together with `source_id`; unknown numeric identity is a documented join gap.\n\nKeep `sourceId` stable. Switching accounts or meeting filters requires a distinct source ID and deliberately configured destination. `createCirclebackPipeline(config, deps)` binds a snapshot of reader configuration and optional HTTP dependencies. Its runtime config does not redefine exported tables; change `database` or installed raw table definitions before schema discovery and migration generation.\n\nVersion 0.1.0 used direct meeting JSON and unscoped meeting row IDs. The 0.2.0 layout introduces source envelopes, scoped row keys, string tags and four additional tables. Reingest into a fresh configured destination or migrate earlier observations deliberately; old unscoped rows are not automatically rewritten or deleted.\n\n## Transcript snapshots and availability\n\nThe transcript table contains two explicitly distinguished observations per meeting:\n\n- `kind: 'transcript'`: the last successfully retrieved full segment array under `data`, with `status: 'available'`.\n- `kind: 'availability'`: the latest read outcome, `available`, `forbidden` for HTTP 403, or `not_found` for HTTP 404.\n\nA 403/404 updates the outcome key and preserves earlier successful text. It proves neither deletion nor temporary processing. A valid HTTP 200 empty array replaces the prior snapshot with `[]`; malformed HTTP 200 content fails without publishing success. Segment speaker, text, timestamps and additional fields stay intact, with no synthetic segment IDs.\n\nUse `FINAL` for latest observations and filter successful snapshots explicitly:\n\n```sql\nSELECT\n  raw.source_id::String AS source_id,\n  raw.meeting_id::String AS meeting_id,\n  JSONExtractRaw(toJSONString(raw), 'data') AS transcript\nFROM default.circleback_meeting_transcripts_raw FINAL\nWHERE raw.kind::String = 'transcript';\n```\n\nLatest outcomes are the `kind = 'availability'` rows in the same table. Join them to snapshots on `source_id` and `meeting_id`; an outcome can be forbidden while a previous successful snapshot remains readable. The [integration guide](https://chkit.obsessiondb.com/integrations/circleback/) shows that query.\n\n## Fixture tests\n\n```sh\nbunx chkit add circleback --with-tests\nbun test src/integrations/circleback/tests/basic.test.ts\n```\n\nPortable fixtures use injected HTTP and in-memory ingestion adapters without credentials or a live database. They cover five isolated and reordered resources, full-sync failure/replay, empty completion, scoped identities, tag names, all action statuses, company joins, late transcripts, permission-loss retention, malformed responses, and pagination safety.\n"
+    },
+    {
+      "path": "circleback/index.ts",
+      "type": "registry:file",
+      "target": "src/integrations/circleback/index.ts",
+      "content": "export { circlebackPipeline, createCirclebackPipeline } from './pipeline.js'\nexport { circleback_meetingsRaw } from './sources/meetings.js'\nexport { circleback_meetingTranscriptsRaw } from './sources/meeting-transcripts.js'\nexport { circleback_actionItemsRaw } from './sources/action-items.js'\nexport { circleback_peopleRaw } from './sources/people.js'\nexport { circleback_companiesRaw } from './sources/companies.js'\n"
+    },
+    {
+      "path": "circleback/config.ts",
+      "type": "registry:file",
+      "target": "src/integrations/circleback/config.ts",
+      "content": "export interface CirclebackConfig {\n  /** Stable account/installation namespace. Use a new sourceId when changing accounts or filters. */\n  sourceId: string\n  /** Schema setup only; runtime pipeline factories do not change raw tables. */\n  database: string\n  ownership: 'All' | 'Mine' | 'Shared'\n}\n\nexport type CirclebackReaderConfig = Omit<CirclebackConfig, 'database'>\n\n// Credentials are read at request time; collections are fully revisited on every run.\nexport const circlebackConfig: CirclebackConfig = {\n  sourceId: 'circleback',\n  database: 'default',\n  ownership: 'All',\n}\n"
+    },
+    {
+      "path": "circleback/client.ts",
+      "type": "registry:file",
+      "target": "src/integrations/circleback/client.ts",
+      "content": "import { HttpError, IngestConfigError, paginate, rawRows, type ErrorClassifier, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { circlebackConfig, type CirclebackReaderConfig } from './config.js'\n\nconst baseUrl = 'https://circleback.ai/api'\nexport type CirclebackObject = Record<string, unknown>\n\nexport interface CirclebackClientDeps {\n  config: CirclebackReaderConfig\n  fetch: (url: string, init: RequestInit) => Promise<Response>\n  token: () => string | undefined\n}\n\nexport const defaultCirclebackClientDeps: CirclebackClientDeps = {\n  config: circlebackConfig,\n  fetch: (url, init) => fetch(url, init),\n  token: () => process.env.CIRCLEBACK_API_KEY,\n}\n\n/** The executor owns one request attempt per page; Link cursors remain local to the full read. */\nexport function readCirclebackPages(context: FetchContext, collection: {\n  path: '/meetings' | '/action-items' | '/people' | '/companies'\n  query?: Record<string, string>\n}, deps: CirclebackClientDeps) {\n  const initial = new URL(`${baseUrl}${collection.path}`)\n  for (const [key, value] of Object.entries(collection.query ?? {})) initial.searchParams.set(key, value)\n  return paginate<CirclebackObject, string>({\n    context, initial: initial.toString(), label: `GET ${collection.path}`,\n    fetchPage: async (url, signal) => {\n      if (!url) throw new IngestConfigError('Circleback collection URL is missing.')\n      const response = await requestCircleback(url, signal, deps)\n      const body: unknown = await response.json()\n      if (!Array.isArray(body)) throw new IngestConfigError(`Circleback ${collection.path} is not an array.`)\n      return { items: body.map((item: unknown) => requireCirclebackObject(item, collection.path)),\n        next: nextLink(response.headers.get('link'), url, collection.query ?? {}) }\n    },\n  })\n}\n\nexport async function requestCircleback(pathOrUrl: string, signal: AbortSignal, deps: CirclebackClientDeps, allowUnavailable = false): Promise<Response> {\n  const token = deps.token()?.trim()\n  if (!token) throw new IngestConfigError('Set CIRCLEBACK_API_KEY.')\n  const response = await deps.fetch(pathOrUrl.startsWith('/') ? `${baseUrl}${pathOrUrl}` : pathOrUrl, {\n    signal: AbortSignal.any([signal, AbortSignal.timeout(30_000)]), redirect: 'error',\n    headers: { Authorization: `Bearer ${token}`, Accept: 'application/json' },\n  })\n  if (allowUnavailable && (response.status === 403 || response.status === 404)) return response\n  if (!response.ok) throw await HttpError.fromResponse(response)\n  return response\n}\n\nexport function classifyCirclebackError(cause: unknown): ReturnType<ErrorClassifier> {\n  return cause instanceof SyntaxError ? { kind: 'permanent' } : undefined\n}\n\nexport function toCirclebackRows(items: readonly CirclebackObject[], id: (item: CirclebackObject) => string | number, sourceId: string) {\n  return rawRows(items.map((data) => ({ source_id: sourceId, data })), (item) => JSON.stringify([sourceId, id(item.data)]))\n}\n\n/** Tag names are the requested projection; provider objects otherwise stay intact. */\nexport function tagNames(item: CirclebackObject): CirclebackObject {\n  if (item.tags === undefined) return item\n  if (!Array.isArray(item.tags)) throw new IngestConfigError('Circleback tags is not an array.')\n  return { ...item, tags: item.tags.map((tag: unknown) => {\n    const name = requireCirclebackObject(tag, 'tag').name\n    if (typeof name !== 'string' || !name.trim()) throw new IngestConfigError('Circleback tag has no name.')\n    return name\n  }) }\n}\n\nexport function requireCirclebackObject(value: unknown, label: string): CirclebackObject {\n  if (!isCirclebackObject(value)) throw new IngestConfigError(`Circleback ${label} is not an object.`)\n  return value\n}\n\nexport function meetingId(item: CirclebackObject): string {\n  if (typeof item.id !== 'string' || !item.id.trim()) throw new IngestConfigError('Circleback meeting has no valid ID.')\n  return item.id\n}\n\nexport function numericId(value: unknown, label: string): number {\n  if (typeof value !== 'number' || !Number.isSafeInteger(value) || value <= 0) throw new IngestConfigError(`Circleback ${label} has no valid numeric ID.`)\n  return value\n}\n\nfunction isCirclebackObject(value: unknown): value is CirclebackObject {\n  return typeof value === 'object' && value !== null && !Array.isArray(value)\n}\n\nfunction nextLink(header: string | null, current: string, query: Record<string, string>): string | undefined {\n  if (!header?.trim()) return undefined\n  const candidates: string[] = []\n  for (const part of header.split(/,(?=\\s*<)/)) {\n    const link = /^\\s*<([^>]+)>\\s*(.*)$/.exec(part)\n    if (!link) throw new IngestConfigError('Circleback returned a malformed Link header.')\n    const relation = /;\\s*rel\\s*=\\s*(?:\"([^\"]+)\"|([^;\\s]+))/.exec(link[2] ?? '')\n    if (!(relation?.[1] ?? relation?.[2])?.split(/\\s+/).includes('next')) continue\n    if (!link[1]) throw new IngestConfigError('Circleback next page URL is missing.')\n    candidates.push(link[1])\n  }\n  if (candidates.length > 1) throw new IngestConfigError('Circleback returned multiple next pages.')\n  const value = candidates[0]\n  if (!value) return undefined\n  let next: URL\n  try { next = new URL(value, current) }\n  catch { throw new IngestConfigError('Circleback returned an invalid next page URL.') }\n  if (next.origin !== 'https://circleback.ai' || next.pathname !== new URL(current).pathname || next.username || next.password || next.hash) {\n    throw new IngestConfigError('Circleback next page changed the collection or origin.')\n  }\n  for (const [key, value] of Object.entries(query)) {\n    const values = next.searchParams.getAll(key)\n    if (values.length > 1 || values.some((nextValue) => nextValue !== value)) {\n      throw new IngestConfigError(`Circleback next page changed the ${key} filter.`)\n    }\n    next.searchParams.set(key, value)\n  }\n  return next.toString()\n}\n"
+    },
+    {
+      "path": "circleback/pipeline.ts",
+      "type": "registry:file",
+      "target": "src/integrations/circleback/pipeline.ts",
+      "content": "import { definePipeline, defineStream, fullSync, IngestConfigError } from '@chkit/plugin-ingest'\n\nimport { classifyCirclebackError, defaultCirclebackClientDeps, type CirclebackClientDeps } from './client.js'\nimport { circlebackConfig, type CirclebackReaderConfig } from './config.js'\nimport { circleback_meetingsRaw, readMeetings } from './sources/meetings.js'\nimport { circleback_meetingTranscriptsRaw, readMeetingTranscripts } from './sources/meeting-transcripts.js'\nimport { circleback_actionItemsRaw, readActionItems } from './sources/action-items.js'\nimport { circleback_peopleRaw, readPeople } from './sources/people.js'\nimport { circleback_companiesRaw, readCompanies } from './sources/companies.js'\n\nexport function createCirclebackPipeline(config: CirclebackReaderConfig = circlebackConfig, deps: CirclebackClientDeps = defaultCirclebackClientDeps) {\n  if (!config.sourceId.trim() || !['All', 'Mine', 'Shared'].includes(config.ownership)) {\n    throw new IngestConfigError('Circleback needs a sourceId and valid meeting ownership.')\n  }\n  const source = { ...config }, client = { ...deps, config: source }\n  const options = { incremental: fullSync(), classifyError: classifyCirclebackError }\n  return definePipeline({\n    id: source.sourceId, tags: ['provider:circleback'], maxStreams: 1, maxFetches: 1,\n    streams: [\n      defineStream({ ...options, id: `${source.sourceId}.meetings`, tags: ['resource:meetings'], destination: circleback_meetingsRaw,\n        read: (context) => readMeetings(context, client) }),\n      defineStream({ ...options, id: `${source.sourceId}.meeting_transcripts`, tags: ['resource:meeting_transcripts'], destination: circleback_meetingTranscriptsRaw,\n        read: (context) => readMeetingTranscripts(context, client) }),\n      defineStream({ ...options, id: `${source.sourceId}.action_items`, tags: ['resource:action_items'], destination: circleback_actionItemsRaw,\n        read: (context) => readActionItems(context, client) }),\n      defineStream({ ...options, id: `${source.sourceId}.people`, tags: ['resource:people'], destination: circleback_peopleRaw,\n        read: (context) => readPeople(context, client) }),\n      defineStream({ ...options, id: `${source.sourceId}.companies`, tags: ['resource:companies'], destination: circleback_companiesRaw,\n        read: (context) => readCompanies(context, client) }),\n    ],\n  })\n}\n\nexport const circlebackPipeline = createCirclebackPipeline()\n"
+    },
+    {
+      "path": "circleback/sources/meetings.ts",
+      "type": "registry:file",
+      "target": "src/integrations/circleback/sources/meetings.ts",
+      "content": "import { rawTable, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { meetingId, readCirclebackPages, tagNames, toCirclebackRows, type CirclebackClientDeps } from '../client.js'\nimport { circlebackConfig } from '../config.js'\n\nexport const circleback_meetingsRaw = rawTable({ database: circlebackConfig.database, name: 'circleback_meetings_raw' })\n\nexport async function* readMeetings(context: FetchContext, deps: CirclebackClientDeps) {\n  for await (const page of readCirclebackPages(context, { path: '/meetings', query: { ownership: deps.config.ownership } }, deps)) {\n    yield { rows: toCirclebackRows(page.items.map(tagNames), meetingId, deps.config.sourceId) }\n  }\n}\n"
+    },
+    {
+      "path": "circleback/sources/meeting-transcripts.ts",
+      "type": "registry:file",
+      "target": "src/integrations/circleback/sources/meeting-transcripts.ts",
+      "content": "import { IngestConfigError, rawRows, rawTable, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { meetingId, readCirclebackPages, requestCircleback, requireCirclebackObject, type CirclebackClientDeps, type CirclebackObject } from '../client.js'\nimport { circlebackConfig } from '../config.js'\n\nexport const circleback_meetingTranscriptsRaw = rawTable({ database: circlebackConfig.database, name: 'circleback_meeting_transcripts_raw' })\n\n/** Discover every eligible meeting here: old meetings can gain transcripts without metadata changes. */\nexport async function* readMeetingTranscripts(context: FetchContext, deps: CirclebackClientDeps) {\n  for await (const page of readCirclebackPages(context, { path: '/meetings', query: { ownership: deps.config.ownership } }, deps)) {\n    for (const meeting of page.items) {\n      const id = meetingId(meeting)\n      const snapshot = await context.attempt(async (signal) => {\n        const response = await requestCircleback(`/meeting/${encodeURIComponent(id)}/transcript`, signal, deps, true)\n        if (response.status === 403) return { meeting_id: id, status: 'forbidden', data: null }\n        if (response.status === 404) return { meeting_id: id, status: 'not_found', data: null }\n        const transcript: unknown = await response.json()\n        if (!Array.isArray(transcript)) throw new IngestConfigError('Circleback transcript is not an array.')\n        const data = transcript.map((value: unknown) => {\n          const segment = requireCirclebackObject(value, 'transcript segment')\n          if ((segment.speaker !== null && typeof segment.speaker !== 'string') || typeof segment.text !== 'string' ||\n            typeof segment.timestamp !== 'number' || !Number.isFinite(segment.timestamp)) {\n            throw new IngestConfigError('Circleback returned an invalid transcript segment.')\n          }\n          return segment\n        })\n        return { meeting_id: id, status: 'available', data }\n      }, { label: 'GET /meeting/{meetingId}/transcript' })\n      const observations: CirclebackObject[] = [{ source_id: deps.config.sourceId, meeting_id: id, kind: 'availability', status: snapshot.status }]\n      if (snapshot.status === 'available') observations.unshift({ source_id: deps.config.sourceId, kind: 'transcript', ...snapshot })\n      // Unavailability changes read evidence, not the last successful transcript snapshot.\n      yield { rows: rawRows(observations, (item) => JSON.stringify(item.kind === 'transcript'\n        ? [deps.config.sourceId, id] : [deps.config.sourceId, id, 'availability'])) }\n    }\n  }\n}\n"
+    },
+    {
+      "path": "circleback/sources/action-items.ts",
+      "type": "registry:file",
+      "target": "src/integrations/circleback/sources/action-items.ts",
+      "content": "import { IngestConfigError, rawTable, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { numericId, readCirclebackPages, tagNames, toCirclebackRows, type CirclebackClientDeps } from '../client.js'\nimport { circlebackConfig } from '../config.js'\n\n// The official OpenAPI and Circleback CLI enumerate exactly these native completion statuses.\nconst statuses = ['PENDING', 'DONE']\n\nexport const circleback_actionItemsRaw = rawTable({ database: circlebackConfig.database, name: 'circleback_action_items_raw' })\n\nexport async function* readActionItems(context: FetchContext, deps: CirclebackClientDeps) {\n  for (const status of statuses) {\n    for await (const page of readCirclebackPages(context, { path: '/action-items', query: { assigneeType: 'Anyone', status } }, deps)) {\n      for (const item of page.items) {\n        if (item.status !== status || !Array.isArray(item.meetingIds) ||\n          !item.meetingIds.every((id: unknown) => typeof id === 'string' && id.trim())) {\n          throw new IngestConfigError('Circleback action item has an unexpected status or invalid meeting IDs.')\n        }\n      }\n      yield { rows: toCirclebackRows(page.items.map(tagNames), (item) => numericId(item.id, 'action item'), deps.config.sourceId) }\n    }\n  }\n}\n"
+    },
+    {
+      "path": "circleback/sources/people.ts",
+      "type": "registry:file",
+      "target": "src/integrations/circleback/sources/people.ts",
+      "content": "import { IngestConfigError, rawTable, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { numericId, readCirclebackPages, requestCircleback, requireCirclebackObject, tagNames, toCirclebackRows, type CirclebackClientDeps } from '../client.js'\nimport { circlebackConfig } from '../config.js'\n\nexport const circleback_peopleRaw = rawTable({ database: circlebackConfig.database, name: 'circleback_people_raw' })\n\nexport async function* readPeople(context: FetchContext, deps: CirclebackClientDeps) {\n  for await (const page of readCirclebackPages(context, { path: '/people' }, deps)) {\n    for (const listed of page.items) {\n      const id = numericId(listed.id, 'person')\n      const detail = await context.attempt(async (signal) => {\n        const response = await requestCircleback(`/person/${id}`, signal, deps)\n        const person = requireCirclebackObject(await response.json(), 'person detail')\n        if (numericId(person.id, 'person detail') !== id || !Array.isArray(person.externalLinks)) {\n          throw new IngestConfigError('Circleback person detail changed its ID or omitted external links.')\n        }\n        return person\n      }, { label: 'GET /person/{profileId}' })\n      yield { rows: toCirclebackRows([tagNames({ ...listed, ...detail })], (item) => numericId(item.id, 'person'), deps.config.sourceId) }\n    }\n  }\n}\n"
+    },
+    {
+      "path": "circleback/sources/companies.ts",
+      "type": "registry:file",
+      "target": "src/integrations/circleback/sources/companies.ts",
+      "content": "import { IngestConfigError, rawRows, rawTable, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { numericId, readCirclebackPages, requestCircleback, requireCirclebackObject, tagNames, type CirclebackClientDeps, type CirclebackObject } from '../client.js'\nimport { circlebackConfig } from '../config.js'\n\nexport const circleback_companiesRaw = rawTable({ database: circlebackConfig.database, name: 'circleback_companies_raw' })\n\nexport async function* readCompanies(context: FetchContext, deps: CirclebackClientDeps) {\n  for await (const page of readCirclebackPages(context, { path: '/companies' }, deps)) {\n    for (const listed of page.items) {\n      const domain = companyDomain(listed)\n      const detail = await context.attempt(async (signal) => {\n        const response = await requestCircleback(`/company/${encodeURIComponent(domain)}`, signal, deps)\n        return requireCirclebackObject(await response.json(), 'company detail')\n      }, { label: 'GET /company/{domain}' })\n      if (companyDomain(detail) !== domain || !Array.isArray(detail.people) || !Array.isArray(detail.externalLinks)) {\n        throw new IngestConfigError('Circleback company detail changed its domain or omitted people/external links.')\n      }\n      const companyIds = new Set<number>()\n      for (const item of [listed, detail]) {\n        if (item.id !== undefined) companyIds.add(numericId(item.id, 'company'))\n      }\n      for (const value of detail.people) {\n        const person = requireCirclebackObject(value, 'company person')\n        numericId(person.id, 'company person')\n        if (person.companyId !== null) companyIds.add(numericId(person.companyId, 'person company'))\n      }\n      if (companyIds.size > 1) throw new IngestConfigError('Circleback company returned conflicting numeric company IDs.')\n      const snapshot = { source_id: deps.config.sourceId, company_id: [...companyIds][0] ?? null, data: tagNames({ ...listed, ...detail }) }\n      // The provider domain is always the identity, even when an optional numeric ID appears later.\n      yield { rows: rawRows([snapshot], () => JSON.stringify([deps.config.sourceId, domain])) }\n    }\n  }\n}\n\nfunction companyDomain(item: CirclebackObject): string {\n  if (typeof item.domain !== 'string' || !item.domain.trim()) throw new IngestConfigError('Circleback company has no domain.')\n  return item.domain\n}\n"
+    },
+    {
+      "path": "circleback/tests/basic.test.ts",
+      "type": "registry:file",
+      "target": "src/integrations/circleback/tests/basic.test.ts",
+      "role": "test",
+      "content": "import { expect, test } from 'bun:test'\nimport { IngestConfigError, runIngestion, selectStreams } from '@chkit/plugin-ingest'\nimport { createMemoryDestination, createMemoryJournal } from '@chkit/plugin-ingest/testing'\n\nimport { createCirclebackPipeline, circlebackPipeline } from '../index.js'\nimport { circlebackConfig, type CirclebackConfig } from '../config.js'\nimport { defaultCirclebackClientDeps } from '../client.js'\n\nconst cutoff = new Date('2026-01-02T00:00:00Z')\nconst resources = ['meetings', 'meeting_transcripts', 'action_items', 'people', 'companies']\nconst meeting = { id: 'meeting-a', name: 'Old meeting', updatedAt: '2020-01-01T00:00:00Z', notes: 'Provider notes',\n  tags: [{ id: 10, name: 'Customer' }, { id: 11, name: 'Follow up' }], attendees: [{ profileId: 1 }],\n  actionItems: [{ id: 252, status: 'PENDING' }], custom: { retained: true } }\nconst transcript = [{ speaker: null, text: 'Full transcript\\nwith another line', timestamp: 0.25, custom: true }]\nconst pending = { id: 252, title: 'Follow up', status: 'PENDING', completedAt: null, assignee: { profileId: 1 }, meetingIds: ['meeting-a'], custom: true }\nconst done = { id: 253, title: 'Completed work', status: 'DONE', completedAt: '2020-01-01T00:00:00Z', assignee: null, meetingIds: [], custom: true }\nconst person = { id: 1, companyId: 3, firstName: 'John', lastName: 'Appleseed', email: 'john@initech.com', companyName: 'Initech', title: 'Operations', custom: true }\nconst personDetail = { ...person, externalLinks: [{ type: 'linkedin', objectType: 'person', url: 'https://www.linkedin.com/in/john-appleseed' }] }\nconst company = { domain: 'initech.com', name: 'Initech', avatarUrl: null, custom: true }\nconst companyDetail = { ...company, people: [person], externalLinks: [{ type: 'website', objectType: 'company', url: 'https://initech.com' }] }\n\ntype Pipeline = ReturnType<typeof createCirclebackPipeline>\ntype Responder = (url: URL, init: RequestInit) => Response | Promise<Response>\n\ntest('Circleback publishes five raw resources with scoped native IDs and string tag names', async () => {\n  const calls: URL[] = [], pipeline = fixturePipeline((url, init) => { calls.push(url); return fixtureResponse(url, init) })\n  expect(circlebackPipeline.streams).toHaveLength(5)\n  expect(pipeline.streams.map((stream) => stream.id).sort()).toEqual(resources.map((resource) => `circleback.${resource}`).sort())\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  const result = await runIngestion(request(pipeline), { journal, destination, now: () => cutoff })\n  expect(result.ok, JSON.stringify(result)).toBe(true)\n  const expected = {\n    meetings: [{ id: rowId('meeting-a'), raw: envelope({ ...meeting, tags: ['Customer', 'Follow up'] }) }],\n    meeting_transcripts: [\n      { id: rowId('meeting-a'), raw: { source_id: 'circleback', kind: 'transcript', meeting_id: 'meeting-a', status: 'available', data: transcript } },\n      { id: JSON.stringify(['circleback', 'meeting-a', 'availability']), raw: { source_id: 'circleback', meeting_id: 'meeting-a', kind: 'availability', status: 'available' } },\n    ],\n    action_items: [pending, done].map((data) => ({ id: rowId(data.id), raw: envelope(data) })),\n    people: [{ id: rowId(person.id), raw: envelope(personDetail) }],\n    companies: [{ id: rowId(company.domain), raw: { source_id: 'circleback', company_id: 3, data: companyDetail } }],\n  }\n  expect(destination.tables.size).toBe(5)\n  for (const [resource, rows] of Object.entries(expected)) {\n    expect(destination.tables.get(`default.circleback_${resource}_raw`)?.map(({ id, raw }) => ({ id, raw }))).toEqual(rows)\n    expect((await journal.readCheckpoint(`circleback.${resource}`)).envelope).toBeUndefined()\n    expect((await journal.readCheckpoint(`circleback.${resource}`)).lastSuccessSeq).toBeGreaterThan(0)\n  }\n  expect(calls.some((url) => url.pathname.includes('/calendar') || url.pathname.includes('/tags') || url.hostname !== 'circleback.ai')).toBe(false)\n})\n\ntest('all resources run alone and reversing stream order preserves their raw observations', async () => {\n  const pipeline = fixturePipeline(), combined = createMemoryDestination()\n  expect((await runIngestion(request({ ...pipeline, streams: [...pipeline.streams].reverse() }),\n    { journal: createMemoryJournal(), destination: combined, now: () => cutoff })).ok).toBe(true)\n  for (const resource of resources) {\n    const calls: URL[] = [], destination = createMemoryDestination()\n    const isolated = fixturePipeline((url, init) => { calls.push(url); return fixtureResponse(url, init) })\n    const selected = request(isolated, resource)\n    expect(selected.selected.map((entry) => entry.stream.id)).toEqual([`circleback.${resource}`])\n    expect((await runIngestion(selected, { journal: createMemoryJournal(), destination, now: () => cutoff })).ok).toBe(true)\n    expect(destination.tables.size).toBe(1)\n    expect(destination.tables.get(`default.circleback_${resource}_raw`)?.map(({ id, raw }) => ({ id, raw })))\n      .toEqual(combined.tables.get(`default.circleback_${resource}_raw`)?.map(({ id, raw }) => ({ id, raw })))\n    expect(calls).toHaveLength(resource === 'meetings' ? 1 : 2)\n    if (resource === 'meetings') expect(calls.map((url) => url.pathname)).toEqual(['/api/meetings'])\n    if (resource === 'action_items') expect(calls.every((url) => url.pathname === '/api/action-items')).toBe(true)\n    if (resource === 'companies') expect(calls.map((url) => url.pathname)).toEqual(['/api/companies', '/api/company/initech.com'])\n    if (resource === 'people') expect(calls.map((url) => url.pathname)).toEqual(['/api/people', '/api/person/1'])\n  }\n})\n\ntest('action items enumerate both native completion statuses for anyone and follow each partition to exhaustion', async () => {\n  const calls: URL[] = []\n  const pipeline = fixturePipeline((url) => {\n    calls.push(url)\n    expect(url.searchParams.get('assigneeType')).toBe('Anyone')\n    const status = url.searchParams.get('status')\n    expect(status === 'PENDING' || status === 'DONE').toBe(true)\n    const item = status === 'PENDING' ? pending : done\n    if (url.searchParams.has('cursor')) return Response.json([{ ...item, id: item.id + 10 }])\n    return Response.json([item], { headers: { Link: `</api/action-items?assigneeType=Anyone&status=${status}&cursor=next>; rel=\"next\"` } })\n  })\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  expect((await runIngestion(request(pipeline, 'action_items'), { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect(calls.map((url) => [url.searchParams.get('status'), url.searchParams.get('cursor')])).toEqual([\n    ['PENDING', null], ['PENDING', 'next'], ['DONE', null], ['DONE', 'next'],\n  ])\n  expect(destination.tables.get('default.circleback_action_items_raw')?.map((row) => row.id)).toEqual([252, 262, 253, 263].map((id) => rowId(id)))\n  expect((await journal.readCheckpoint('circleback.action_items')).lastSuccessSeq).toBeGreaterThan(0)\n})\n\ntest('cursor-only continuations retain ownership and completion filters and conflicting links fail visibly', async () => {\n  for (const resource of ['meetings', 'action_items']) {\n    const calls: URL[] = []\n    const pipeline = fixturePipeline((url) => {\n      calls.push(url)\n      if (resource === 'action_items' && url.searchParams.get('status') === 'PENDING') return Response.json([])\n      if (url.searchParams.has('cursor')) return Response.json(resource === 'meetings' ? [meeting] : [done])\n      return Response.json([], { headers: { Link: `<${url.pathname}?cursor=next>; rel=\"next\"` } })\n    })\n    expect((await runIngestion(request(pipeline, resource), { journal: createMemoryJournal(), destination: createMemoryDestination(), now: () => cutoff })).ok).toBe(true)\n    const continued = calls.at(-1)\n    expect(continued?.searchParams.get('cursor')).toBe('next')\n    if (resource === 'meetings') expect(continued?.searchParams.get('ownership')).toBe('All')\n    else {\n      expect(continued?.searchParams.get('status')).toBe('DONE')\n      expect(continued?.searchParams.get('assigneeType')).toBe('Anyone')\n    }\n  }\n  for (const [resource, conflict] of [['meetings', 'ownership=Mine'], ['action_items', 'status=DONE'], ['action_items', 'assigneeType=Me']] satisfies [string, string][]) {\n    let calls = 0\n    const pipeline = fixturePipeline((url) => {\n      calls++\n      return Response.json([], { headers: { Link: `<${url.pathname}?cursor=next&${conflict}>; rel=\"next\"` } })\n    })\n    const journal = createMemoryJournal()\n    expect((await runIngestion(request(pipeline, resource), { journal, destination: createMemoryDestination(), now: () => cutoff })).ok).toBe(false)\n    expect(calls).toBe(1)\n    expect((await journal.readCheckpoint(`circleback.${resource}`)).lastSuccessSeq).toBe(0)\n  }\n})\n\ntest('late transcripts on unchanged old meetings are revisited without running the meetings stream', async () => {\n  let available = false\n  const starts: string[] = [], calls: string[] = []\n  const pipeline = fixturePipeline((url) => {\n    calls.push(url.pathname)\n    if (url.pathname.endsWith('/transcript')) {\n      if (!available) return new Response('unavailable', { status: url.pathname.includes('/meeting-a/') ? 403 : 404 })\n      return Response.json(url.pathname.includes('/meeting-a/') ? transcript : [])\n    }\n    starts.push(url.search)\n    return Response.json([meeting, { ...meeting, id: 'meeting-b' }])\n  })\n  const journal = createMemoryJournal(), destination = createMemoryDestination(), selected = request(pipeline, 'meeting_transcripts')\n  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect(destination.tables.get('default.circleback_meeting_transcripts_raw')?.map((row) => row.raw)).toEqual([\n    { source_id: 'circleback', meeting_id: 'meeting-a', kind: 'availability', status: 'forbidden' },\n    { source_id: 'circleback', meeting_id: 'meeting-b', kind: 'availability', status: 'not_found' },\n  ])\n  available = true\n  expect((await runIngestion(selected, { journal, destination, now: () => new Date('2026-01-03') })).ok).toBe(true)\n  expect(starts).toEqual(['?ownership=All', '?ownership=All'])\n  expect(calls.filter((path) => path.endsWith('/transcript'))).toHaveLength(4)\n  expect(destination.tables.get('default.circleback_meeting_transcripts_raw')?.slice(-4).map((row) => row.raw)).toEqual([\n    { source_id: 'circleback', kind: 'transcript', meeting_id: 'meeting-a', status: 'available', data: transcript },\n    { source_id: 'circleback', meeting_id: 'meeting-a', kind: 'availability', status: 'available' },\n    { source_id: 'circleback', kind: 'transcript', meeting_id: 'meeting-b', status: 'available', data: [] },\n    { source_id: 'circleback', meeting_id: 'meeting-b', kind: 'availability', status: 'available' },\n  ])\n  expect((await journal.readCheckpoint('circleback.meetings')).lastSuccessSeq).toBe(0)\n  expect((await journal.readCheckpoint('circleback.meeting_transcripts')).envelope).toBeUndefined()\n})\n\ntest('forbidden and not-found observations preserve prior transcript content while a successful empty transcript replaces it', async () => {\n  let status = 200, empty = false\n  const pipeline = fixturePipeline((url) => url.pathname === '/api/meetings' ? Response.json([meeting])\n    : status === 200 ? Response.json(empty ? [] : transcript) : new Response('unavailable', { status }))\n  const journal = createMemoryJournal(), destination = createMemoryDestination(), selected = request(pipeline, 'meeting_transcripts')\n  for (const nextStatus of [200, 403, 404, 200]) {\n    status = nextStatus\n    expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(true)\n    const snapshots = destination.tables.get('default.circleback_meeting_transcripts_raw')?.filter((row) => row.id === rowId(meeting.id)) ?? []\n    expect(snapshots.at(-1)?.raw).toMatchObject({ kind: 'transcript', status: 'available', data: empty ? [] : transcript })\n    if (status === 404) empty = true\n  }\n  const rows = destination.tables.get('default.circleback_meeting_transcripts_raw') ?? []\n  expect(rows.filter((row) => row.id === rowId(meeting.id))).toHaveLength(2)\n  expect(rows.filter((row) => row.id !== rowId(meeting.id)).map((row) => row.raw)).toEqual(\n    ['available', 'forbidden', 'not_found', 'available'].map((status) => ({ source_id: 'circleback', meeting_id: meeting.id, kind: 'availability', status })))\n  expect(new Set(rows.map((row) => row.id)).size).toBe(2)\n})\n\ntest('a transcript source failure leaves its full sync incomplete while all other resource streams succeed', async () => {\n  let fail = true\n  const transcriptCalls: string[] = []\n  const pipeline = fixturePipeline((url, init) => {\n    if (url.pathname.endsWith('/transcript')) {\n      transcriptCalls.push(url.pathname)\n      if (fail) return new Response('unavailable', { status: 500 })\n    }\n    return fixtureResponse(url, init)\n  })\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  const failed = await runIngestion(request(pipeline), { journal, destination, now: () => cutoff })\n  expect(failed.ok).toBe(false)\n  expect(failed.streams.filter((stream) => stream.outcome === 'failed').map((stream) => stream.streamId)).toEqual(['circleback.meeting_transcripts'])\n  expect(destination.tables.get('default.circleback_meetings_raw')?.[0]?.raw).toEqual(envelope({ ...meeting, tags: ['Customer', 'Follow up'] }))\n  expect((await journal.readCheckpoint('circleback.meeting_transcripts')).lastSuccessSeq).toBe(0)\n  for (const resource of resources.filter((resource) => resource !== 'meeting_transcripts')) {\n    expect((await journal.readCheckpoint(`circleback.${resource}`)).lastSuccessSeq).toBeGreaterThan(0)\n  }\n  fail = false\n  expect((await runIngestion(request(pipeline, 'meeting_transcripts'), { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect(transcriptCalls).toEqual(['/api/meeting/meeting-a/transcript', '/api/meeting/meeting-a/transcript'])\n})\n\ntest('a failed transcript write replays its own parent discovery before recording successful completion', async () => {\n  const starts: string[] = []\n  const pipeline = fixturePipeline((url, init) => {\n    if (url.pathname === '/api/meetings') starts.push(url.search)\n    return fixtureResponse(url, init)\n  })\n  const journal = createMemoryJournal(), destination = createMemoryDestination(), selected = request(pipeline, 'meeting_transcripts')\n  expect((await runIngestion(selected, { journal, destination: { insert: async () => { throw new IngestConfigError('sink rejected') } }, now: () => cutoff })).ok).toBe(false)\n  expect((await journal.readCheckpoint('circleback.meeting_transcripts')).lastSuccessSeq).toBe(0)\n  expect((await journal.readCheckpoint('circleback.meeting_transcripts')).envelope).toBeUndefined()\n  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect(starts).toEqual(['?ownership=All', '?ownership=All'])\n  expect(destination.tables.get('default.circleback_meeting_transcripts_raw')).toHaveLength(2)\n})\n\ntest('full meeting reads replay from page one after source and sink failures and retain changed observations', async () => {\n  let fail = true, changed = false\n  const starts: string[] = [], second = { ...meeting, id: 'meeting-b' }\n  const pipeline = fixturePipeline((url) => {\n    if (url.searchParams.has('cursor')) return fail ? new Response('denied', { status: 403 }) : Response.json([second])\n    starts.push(url.search)\n    return Response.json([{ ...meeting, notes: changed ? 'Edited without an updatedAt change' : meeting.notes }],\n      { headers: { Link: '</api/meetings?cursor=next>; rel=\"next\"' } })\n  })\n  const journal = createMemoryJournal(), destination = createMemoryDestination(), selected = request(pipeline, 'meetings')\n  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(false)\n  expect((await journal.readCheckpoint('circleback.meetings')).lastSuccessSeq).toBe(0)\n  fail = false\n  expect((await runIngestion(selected, { journal, destination: { insert: async () => { throw new IngestConfigError('sink rejected') } }, now: () => cutoff })).ok).toBe(false)\n  expect((await journal.readCheckpoint('circleback.meetings')).lastSuccessSeq).toBe(0)\n  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(true)\n  changed = true\n  expect((await runIngestion(selected, { journal, destination, now: () => new Date('2026-01-03') })).ok).toBe(true)\n  expect(starts).toEqual(Array(4).fill('?ownership=All'))\n  expect((await journal.readCheckpoint('circleback.meetings')).envelope).toBeUndefined()\n  expect(destination.tables.get('default.circleback_meetings_raw')?.filter((row) => row.id === rowId('meeting-a')).map((row) => row.raw)).toEqual([\n    envelope({ ...meeting, tags: ['Customer', 'Follow up'] }),\n    envelope({ ...meeting, notes: 'Edited without an updatedAt change', tags: ['Customer', 'Follow up'] }),\n  ])\n})\n\ntest('empty full resources record completion and scan again without custom provider state', async () => {\n  const calls: string[] = [], pipeline = fixturePipeline((url) => { calls.push(url.pathname); return Response.json([]) })\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  for (const now of [cutoff, new Date('2026-01-03')]) {\n    expect((await runIngestion(request(pipeline), { journal, destination, now: () => now })).ok).toBe(true)\n  }\n  expect(destination.tables.size).toBe(0)\n  for (const resource of resources) {\n    expect((await journal.readCheckpoint(`circleback.${resource}`)).envelope).toBeUndefined()\n    expect(journal.events.filter((event) => event.namespaceId === `circleback.${resource}` && event.eventKind === 'work_finished' && event.workState === 'succeeded')).toHaveLength(2)\n  }\n  expect(calls.filter((path) => path === '/api/meetings')).toHaveLength(4)\n  expect(calls.filter((path) => path === '/api/action-items')).toHaveLength(4)\n})\n\ntest('company domains stay stable while optional native numeric IDs preserve downstream joins', async () => {\n  let identified = false\n  const pipeline = fixturePipeline((url) => url.pathname === '/api/companies'\n    ? Response.json([{ ...company, ...(identified ? { id: 3 } : {}) }])\n    : Response.json({ ...company, externalLinks: [], people: [] }))\n  const journal = createMemoryJournal(), destination = createMemoryDestination(), selected = request(pipeline, 'companies')\n  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(true)\n  identified = true\n  expect((await runIngestion(selected, { journal, destination, now: () => new Date('2026-01-03') })).ok).toBe(true)\n  const rows = destination.tables.get('default.circleback_companies_raw') ?? []\n  expect(rows.map((row) => row.id)).toEqual([rowId('initech.com'), rowId('initech.com')])\n  expect(rows.map((row) => row.raw)).toEqual([\n    { source_id: 'circleback', company_id: null, data: { ...company, externalLinks: [], people: [] } },\n    { source_id: 'circleback', company_id: 3, data: { ...company, id: 3, externalLinks: [], people: [] } },\n  ])\n  expect(new Set(rows.map((row) => row.id)).size).toBe(1)\n})\n\ntest('company detail failures and conflicting native IDs cannot complete or fabricate company joins', async () => {\n  for (const mode of ['forbidden', 'conflicting', 'different-domain']) {\n    const pipeline = fixturePipeline((url) => {\n      if (url.pathname === '/api/companies') return Response.json([{ ...company, id: 3 }])\n      if (mode === 'forbidden') return new Response('denied', { status: 403 })\n      return Response.json({ ...companyDetail, ...(mode === 'different-domain' ? { domain: 'other.example' } : { people: [{ ...person, companyId: 4 }] }) })\n    })\n    const journal = createMemoryJournal(), destination = createMemoryDestination()\n    expect((await runIngestion(request(pipeline, 'companies'), { journal, destination, now: () => cutoff })).ok).toBe(false)\n    expect(destination.tables.size).toBe(0)\n    expect((await journal.readCheckpoint('circleback.companies')).lastSuccessSeq).toBe(0)\n  }\n})\n\ntest('same-person detail retains raw external references and cannot publish a different or inaccessible person', async () => {\n  for (const mode of ['denied', 'mismatched-id', 'missing-links']) {\n    const calls: string[] = []\n    const pipeline = fixturePipeline((url) => {\n      calls.push(url.pathname)\n      if (url.pathname === '/api/people') return Response.json([person])\n      if (mode === 'denied') return new Response('denied', { status: 403 })\n      return Response.json({ ...personDetail, ...(mode === 'mismatched-id' ? { id: 2 } : { externalLinks: null }) })\n    })\n    const journal = createMemoryJournal(), destination = createMemoryDestination()\n    expect((await runIngestion(request(pipeline, 'people'), { journal, destination, now: () => cutoff })).ok).toBe(false)\n    expect(calls).toEqual(['/api/people', '/api/person/1'])\n    expect(destination.tables.size).toBe(0)\n    expect((await journal.readCheckpoint('circleback.people')).lastSuccessSeq).toBe(0)\n  }\n})\n\ntest('factory configuration, tokens and selected resource progress stay independent between installations', async () => {\n  const config: CirclebackConfig = { ...circlebackConfig, sourceId: 'circleback.team', ownership: 'Shared' }\n  const calls: URL[] = []\n  const pipeline = createCirclebackPipeline(config, { ...defaultCirclebackClientDeps, token: () => 'team-key', fetch: async (url, init) => {\n    expect(new Headers(init.headers).get('authorization')).toBe('Bearer team-key')\n    calls.push(new URL(url))\n    return Response.json([meeting])\n  } })\n  config.sourceId = 'changed'\n  config.ownership = 'Mine'\n  const failing = createCirclebackPipeline({ ...circlebackConfig, sourceId: 'circleback.denied' }, {\n    ...defaultCirclebackClientDeps, token: () => 'denied', fetch: async () => new Response('denied', { status: 403 }),\n  })\n  const selected = selectStreams([failing, pipeline], ['resource:meetings']).map((entry) => ({ ...entry, stream: { ...entry.stream, retry: { retries: 0 } } }))\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  const result = await runIngestion({ selected, backfill: undefined }, { journal, destination, now: () => cutoff })\n  expect(result.streams.map((stream) => stream.outcome)).toEqual(['failed', 'succeeded'])\n  expect(calls.map((url) => url.searchParams.get('ownership'))).toEqual(['Shared'])\n  expect(destination.tables.get('default.circleback_meetings_raw')?.[0]?.id).toBe(rowId(meeting.id, 'circleback.team'))\n  expect(destination.tables.get('default.circleback_meetings_raw')?.[0]?.raw).toEqual(envelope({ ...meeting, tags: ['Customer', 'Follow up'] }, 'circleback.team'))\n  expect((await journal.readCheckpoint('circleback.denied.meetings')).lastSuccessSeq).toBe(0)\n  expect((await journal.readCheckpoint('circleback.team.meetings')).lastSuccessSeq).toBeGreaterThan(0)\n  const onlyTeam = selectStreams([failing, pipeline], ['stream:circleback.team.meetings'])\n  expect(onlyTeam.map((entry) => entry.stream.id)).toEqual(['circleback.team.meetings'])\n  expect((await journal.readCheckpoint('circleback.meetings')).lastSuccessSeq).toBe(0)\n})\n\ntest('empty Link pages continue while cyclic, cross-collection, foreign and malformed next links fail permanently', async () => {\n  for (const mode of ['empty-first', 'same-initial', 'cyclic', 'cross-collection', 'foreign', 'malformed', 'multiple-next']) {\n    const calls: string[] = []\n    let details = 0\n    const pipeline = fixturePipeline((url) => {\n      if (url.pathname.startsWith('/api/person/')) { details++; return Response.json(personDetail) }\n      calls.push(url.toString())\n      if (mode === 'empty-first' && url.searchParams.has('cursor')) return Response.json([person])\n      if (mode === 'same-initial') return Response.json([person], { headers: { Link: `<${url.toString()}>; rel=\"next\"` } })\n      const next = mode === 'foreign' ? 'https://untrusted.example/people' : mode === 'cross-collection' ? '/api/companies?cursor=next' : '/api/people?cursor=next'\n      const link = mode === 'malformed' ? 'not-a-link; rel=\"next\"' : mode === 'multiple-next' ? `<${next}>; rel=\"next\", </api/people?cursor=another>; rel=\"next\"` : `<${next}>; rel=\"next\"`\n      return Response.json([], { headers: { Link: link } })\n    })\n    const selected = request(pipeline, 'people').selected.map((entry) => ({ ...entry, stream: { ...entry.stream, retry: { retries: 1, minTimeout: 0, maxTimeout: 0 } } }))\n    const journal = createMemoryJournal(), destination = createMemoryDestination()\n    const result = await runIngestion({ selected, backfill: undefined }, { journal, destination, now: () => cutoff })\n    expect(result.ok).toBe(mode === 'empty-first')\n    expect(calls).toHaveLength(['empty-first', 'cyclic'].includes(mode) ? 2 : 1)\n    expect(details).toBe(mode === 'empty-first' ? 1 : 0)\n    expect(destination.tables.size).toBe(mode === 'empty-first' ? 1 : 0)\n    expect((await journal.readCheckpoint('circleback.people')).lastSuccessSeq > 0).toBe(mode === 'empty-first')\n    expect(journal.events.filter((event) => event.eventKind === 'retry_scheduled')).toHaveLength(0)\n  }\n})\n\ntest('malformed collections, identities, tag names and unsupported action status cannot become successful full syncs', async () => {\n  for (const [resource, payload] of [\n    ['meetings', { error: 'bad payload' }], ['meetings', [{ ...meeting, id: '' }]], ['meetings', [{ ...meeting, tags: [{ id: 10 }] }]],\n    ['people', [{ ...person, id: 1.5 }]], ['action_items', [{ ...pending, status: 'UNKNOWN' }]],\n    ['action_items', [{ ...pending, status: 'DONE' }]], ['action_items', [{ ...pending, meetingIds: null }]],\n  ] satisfies [string, unknown][]) {\n    let calls = 0\n    const pipeline = fixturePipeline(() => { calls++; return Response.json(payload) })\n    const journal = createMemoryJournal()\n    expect((await runIngestion(request(pipeline, resource), { journal, destination: createMemoryDestination(), now: () => cutoff })).ok).toBe(false)\n    expect(calls).toBe(1)\n    expect((await journal.readCheckpoint(`circleback.${resource}`)).lastSuccessSeq).toBe(0)\n  }\n})\n\ntest('HTTP200 malformed transcripts fail without publishing an availability snapshot or completing the stream', async () => {\n  for (const payload of [null, { error: 'denied' }, [{ speaker: null, text: 'Words' }], [{ speaker: 3, text: 'Words', timestamp: 1 }], [{ speaker: null, text: {}, timestamp: 1 }]]) {\n    let calls = 0\n    const pipeline = fixturePipeline((url) => {\n      if (url.pathname === '/api/meetings') return Response.json([meeting])\n      calls++\n      return Response.json(payload)\n    })\n    const journal = createMemoryJournal(), destination = createMemoryDestination()\n    expect((await runIngestion(request(pipeline, 'meeting_transcripts'), { journal, destination, now: () => cutoff })).ok).toBe(false)\n    expect(calls).toBe(1)\n    expect(destination.tables.size).toBe(0)\n    expect((await journal.readCheckpoint('circleback.meeting_transcripts')).lastSuccessSeq).toBe(0)\n  }\n})\n\ntest('rate exhaustion consumes exactly one executor-owned page retry and malformed JSON remains permanent', async () => {\n  for (const mode of ['rate', 'malformed-json']) {\n    let calls = 0\n    const pipeline = fixturePipeline((url) => {\n      if (url.pathname.startsWith('/api/person/')) return Response.json(personDetail)\n      calls++\n      if (mode === 'malformed-json') return new Response('{', { headers: { 'Content-Type': 'application/json' } })\n      return calls === 1 ? new Response('rate limited', { status: 429, headers: { 'Retry-After': '0' } }) : Response.json([person])\n    })\n    const selected = request(pipeline, 'people').selected.map((entry) => ({ ...entry, stream: { ...entry.stream, retry: { retries: 1, minTimeout: 0, maxTimeout: 0 } } }))\n    const journal = createMemoryJournal()\n    expect((await runIngestion({ selected, backfill: undefined }, { journal, destination: createMemoryDestination(), now: () => cutoff })).ok).toBe(mode === 'rate')\n    expect(calls).toBe(mode === 'rate' ? 2 : 1)\n    expect(journal.events.filter((event) => event.eventKind === 'retry_scheduled')).toHaveLength(mode === 'rate' ? 1 : 0)\n  }\n})\n\nfunction fixturePipeline(respond: Responder = fixtureResponse): Pipeline {\n  return createCirclebackPipeline(circlebackConfig, { ...defaultCirclebackClientDeps, token: () => 'fixture',\n    fetch: (url, init) => Promise.resolve(respond(new URL(url), init)) })\n}\n\nfunction request(pipeline: Pipeline, resource?: string) {\n  return { selected: selectStreams([pipeline], resource ? [`resource:${resource}`] : []).map((entry) => ({\n    ...entry, stream: { ...entry.stream, batchSize: 1, retry: { retries: 0 } },\n  })), backfill: undefined }\n}\n\nfunction fixtureResponse(url: URL, _init: RequestInit): Response {\n  if (url.pathname === '/api/meetings') return Response.json([meeting])\n  if (url.pathname.endsWith('/transcript')) return Response.json(transcript)\n  if (url.pathname === '/api/action-items') return Response.json(url.searchParams.get('status') === 'DONE' ? [done] : [pending])\n  if (url.pathname === '/api/people') return Response.json([person])\n  if (url.pathname === '/api/person/1') return Response.json(personDetail)\n  if (url.pathname === '/api/companies') return Response.json([company])\n  if (url.pathname === '/api/company/initech.com') return Response.json(companyDetail)\n  throw new IngestConfigError(`Unexpected Circleback fixture request: ${url}`)\n}\n\nfunction rowId(id: string | number, sourceId = 'circleback'): string { return JSON.stringify([sourceId, id]) }\nfunction envelope(data: unknown, sourceId = 'circleback') { return { source_id: sourceId, data } }\n"
+    }
+  ],
+  "meta": {
+    "chkit": {
+      "formatVersion": 1,
+      "version": "0.2.0",
+      "changelog": [
+        {
+          "version": "0.2.0",
+          "changes": [
+            "Provide one configurable account pipeline with independent meetings, meeting transcripts, action items, people, and companies raw streams.",
+            "Use native full-sync completion and safe first-page replay with scoped identities and validated Link pagination that preserves query filters.",
+            "Revisit every eligible meeting for late transcripts; retain successful snapshots separately from forbidden/not-found read outcomes.",
+            "Read action items for anyone across both native PENDING and DONE statuses; preserve people and company relationships without inventing numeric company IDs.",
+            "Store complete tag names as string arrays and raw provider payloads in source-scoped envelopes; adopting this layout requires reingestion or migration of earlier unscoped meeting observations.",
+            "Add portable fixtures for independently selected resources, reversed stream order, malformed responses, pagination, late transcripts, and source/destination recovery.",
+            "Consume full pagination pages and use shared continuation-cycle detection while preserving independent resource checkpoints and provider Link validation."
+          ]
+        },
+        {
+          "version": "0.1.0",
+          "changes": [
+            "Introduce raw meeting ingestion with transcript enrichment."
+          ]
+        }
+      ],
+      "language": "typescript",
+      "license": "MIT",
+      "documentation": "https://chkit.obsessiondb.com/integrations/circleback/",
+      "logo": "https://chkit.obsessiondb.com/logos/circleback.svg",
+      "authentication": {
+        "method": "Bearer API key",
+        "env": [
+          "CIRCLEBACK_API_KEY"
+        ],
+        "setup": [
+          "Provide CIRCLEBACK_API_KEY with read access to the selected resources.",
+          "Keep the API key in the runtime environment and rotate it according to the provider policy."
+        ],
+        "documentation": "https://circleback.ai/docs/api"
+      },
+      "chkit": "^0.2.0-beta.10",
+      "ingest": "^0.2.0-beta.10",
+      "clickhouse": ">=25.3.0",
+      "root": "src/integrations/circleback",
+      "entry": "index.ts",
+      "exports": [
+        "circlebackPipeline",
+        "createCirclebackPipeline",
+        "circleback_meetingsRaw",
+        "circleback_meetingTranscriptsRaw",
+        "circleback_actionItemsRaw",
+        "circleback_peopleRaw",
+        "circleback_companiesRaw"
+      ],
+      "resources": [
+        {
+          "name": "meetings",
+          "title": "Meetings",
+          "table": "circleback_meetings_raw",
+          "description": "Accessible meeting provider objects and notes, with tag names as string arrays.",
+          "scopes": [],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/meetings",
+              "documentation": "https://circleback.ai/docs/api/meetings/list-meetings"
+            }
+          ]
+        },
+        {
+          "name": "meeting_transcripts",
+          "title": "Meeting transcripts",
+          "table": "circleback_meeting_transcripts_raw",
+          "description": "Whole transcript snapshots per meeting and separate latest read outcomes; availability failures preserve earlier successful text.",
+          "scopes": [],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/meetings",
+              "documentation": "https://circleback.ai/docs/api/meetings/list-meetings"
+            },
+            {
+              "method": "GET",
+              "path": "/meeting/{meetingId}/transcript",
+              "documentation": "https://circleback.ai/docs/api/meetings/get-meeting-transcript"
+            }
+          ]
+        },
+        {
+          "name": "action_items",
+          "title": "Action items",
+          "table": "circleback_action_items_raw",
+          "description": "Raw action items for any assignee, fully paginated across PENDING and DONE completion statuses.",
+          "scopes": [],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/action-items",
+              "documentation": "https://circleback.ai/docs/api/action-items/list-action-items"
+            }
+          ]
+        },
+        {
+          "name": "people",
+          "title": "People",
+          "table": "circleback_people_raw",
+          "description": "Complete same-person listing and detail fields, preserving external references and native person/company IDs.",
+          "scopes": [],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/people",
+              "documentation": "https://circleback.ai/docs/api/people/list-people"
+            },
+            {
+              "method": "GET",
+              "path": "/person/{profileId}",
+              "documentation": "https://circleback.ai/docs/api/people/get-person"
+            }
+          ]
+        },
+        {
+          "name": "companies",
+          "title": "Companies",
+          "table": "circleback_companies_raw",
+          "description": "Domain-keyed company listing and detail fields with a nullable, corroborated native numeric company ID for joins.",
+          "scopes": [],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/companies",
+              "documentation": "https://circleback.ai/docs/api/companies/list-companies"
+            },
+            {
+              "method": "GET",
+              "path": "/company/{domain}",
+              "documentation": "https://circleback.ai/docs/api/companies/get-company"
+            }
+          ]
+        }
+      ],
+      "views": [],
+      "sync": {
+        "description": "Each resource fully reads its own provider collection and records independent successful completion after writes. Interrupted reads restart at the first page. Transcripts own complete meeting discovery and revisit late availability on unchanged old meetings.",
+        "schedule": "Run bunx chkit ingest run --tag provider:circleback from a scheduler.",
+        "deletions": "Absent resources remain stored. Transcript 403 and 404 responses update explicit read outcomes without deleting prior successful content; neither proves deletion or temporary processing."
+      },
+      "env": {
+        "CIRCLEBACK_API_KEY": ""
+      },
+      "fileHashes": {
+        "src/integrations/circleback/README.md": "3005c04c9db90f68c4565c075a07a1b1aeed0a0bd34058a2c4605fe2d671f470",
+        "src/integrations/circleback/index.ts": "dbab97785e5fb11775ad7062076237e2e6af2c8bbdafd8c7e71e92b957b81a5c",
+        "src/integrations/circleback/config.ts": "3db0dc6cdeb932b245ca5cf9bd70afb2084cf82221c4c124c4ce530836ba1460",
+        "src/integrations/circleback/client.ts": "676e066426e6a714f6d34280b2eec731b6482fb11f4991db09f50072df736b0f",
+        "src/integrations/circleback/pipeline.ts": "246de2bf96bb0db21d3da9bc3d8e109e3acc483cf2f95a89812ab0691558f431",
+        "src/integrations/circleback/sources/meetings.ts": "5e31bd1fbea70aad912c514873684809928e7cefda179efda3bb0199717e1ea4",
+        "src/integrations/circleback/sources/meeting-transcripts.ts": "be4eca331e3531ff64cb1531fb3d00d8792d380ed52806a24fcee19f007c0287",
+        "src/integrations/circleback/sources/action-items.ts": "bd0509814921871eca3a41523075e04e99fe899f2ace499ceab22bd174cc9b5b",
+        "src/integrations/circleback/sources/people.ts": "efe209025b4d4b0ae0b4b832b44a29fac8fde1543fca54a12453f75d5113a1ee",
+        "src/integrations/circleback/sources/companies.ts": "daf0f1534090d19f2733b2ce60e8c7e77babe5f36639fba67db996b00203b6e2",
+        "src/integrations/circleback/tests/basic.test.ts": "eb6d5683289834567edc8b87a3225fff699f9a7f4480d3e7fc37dd6fdee070fb"
+      }
+    }
+  }
+}
diff --git a/registry/circleback/sources/action-items.ts b/registry/circleback/sources/action-items.ts
new file mode 100644
index 00000000..315a9e85
--- /dev/null
+++ b/registry/circleback/sources/action-items.ts
@@ -0,0 +1,23 @@
+import { IngestConfigError, rawTable, type FetchContext } from '@chkit/plugin-ingest'
+
+import { numericId, readCirclebackPages, tagNames, toCirclebackRows, type CirclebackClientDeps } from '../client.js'
+import { circlebackConfig } from '../config.js'
+
+// The official OpenAPI and Circleback CLI enumerate exactly these native completion statuses.
+const statuses = ['PENDING', 'DONE']
+
+export const circleback_actionItemsRaw = rawTable({ database: circlebackConfig.database, name: 'circleback_action_items_raw' })
+
+export async function* readActionItems(context: FetchContext, deps: CirclebackClientDeps) {
+  for (const status of statuses) {
+    for await (const page of readCirclebackPages(context, { path: '/action-items', query: { assigneeType: 'Anyone', status } }, deps)) {
+      for (const item of page.items) {
+        if (item.status !== status || !Array.isArray(item.meetingIds) ||
+          !item.meetingIds.every((id: unknown) => typeof id === 'string' && id.trim())) {
+          throw new IngestConfigError('Circleback action item has an unexpected status or invalid meeting IDs.')
+        }
+      }
+      yield { rows: toCirclebackRows(page.items.map(tagNames), (item) => numericId(item.id, 'action item'), deps.config.sourceId) }
+    }
+  }
+}
diff --git a/registry/circleback/sources/companies.ts b/registry/circleback/sources/companies.ts
new file mode 100644
index 00000000..fe45f442
--- /dev/null
+++ b/registry/circleback/sources/companies.ts
@@ -0,0 +1,39 @@
+import { IngestConfigError, rawRows, rawTable, type FetchContext } from '@chkit/plugin-ingest'
+
+import { numericId, readCirclebackPages, requestCircleback, requireCirclebackObject, tagNames, type CirclebackClientDeps, type CirclebackObject } from '../client.js'
+import { circlebackConfig } from '../config.js'
+
+export const circleback_companiesRaw = rawTable({ database: circlebackConfig.database, name: 'circleback_companies_raw' })
+
+export async function* readCompanies(context: FetchContext, deps: CirclebackClientDeps) {
+  for await (const page of readCirclebackPages(context, { path: '/companies' }, deps)) {
+    for (const listed of page.items) {
+      const domain = companyDomain(listed)
+      const detail = await context.attempt(async (signal) => {
+        const response = await requestCircleback(`/company/${encodeURIComponent(domain)}`, signal, deps)
+        return requireCirclebackObject(await response.json(), 'company detail')
+      }, { label: 'GET /company/{domain}' })
+      if (companyDomain(detail) !== domain || !Array.isArray(detail.people) || !Array.isArray(detail.externalLinks)) {
+        throw new IngestConfigError('Circleback company detail changed its domain or omitted people/external links.')
+      }
+      const companyIds = new Set<number>()
+      for (const item of [listed, detail]) {
+        if (item.id !== undefined) companyIds.add(numericId(item.id, 'company'))
+      }
+      for (const value of detail.people) {
+        const person = requireCirclebackObject(value, 'company person')
+        numericId(person.id, 'company person')
+        if (person.companyId !== null) companyIds.add(numericId(person.companyId, 'person company'))
+      }
+      if (companyIds.size > 1) throw new IngestConfigError('Circleback company returned conflicting numeric company IDs.')
+      const snapshot = { source_id: deps.config.sourceId, company_id: [...companyIds][0] ?? null, data: tagNames({ ...listed, ...detail }) }
+      // The provider domain is always the identity, even when an optional numeric ID appears later.
+      yield { rows: rawRows([snapshot], () => JSON.stringify([deps.config.sourceId, domain])) }
+    }
+  }
+}
+
+function companyDomain(item: CirclebackObject): string {
+  if (typeof item.domain !== 'string' || !item.domain.trim()) throw new IngestConfigError('Circleback company has no domain.')
+  return item.domain
+}
diff --git a/registry/circleback/sources/meeting-transcripts.ts b/registry/circleback/sources/meeting-transcripts.ts
new file mode 100644
index 00000000..4062f1fd
--- /dev/null
+++ b/registry/circleback/sources/meeting-transcripts.ts
@@ -0,0 +1,36 @@
+import { IngestConfigError, rawRows, rawTable, type FetchContext } from '@chkit/plugin-ingest'
+
+import { meetingId, readCirclebackPages, requestCircleback, requireCirclebackObject, type CirclebackClientDeps, type CirclebackObject } from '../client.js'
+import { circlebackConfig } from '../config.js'
+
+export const circleback_meetingTranscriptsRaw = rawTable({ database: circlebackConfig.database, name: 'circleback_meeting_transcripts_raw' })
+
+/** Discover every eligible meeting here: old meetings can gain transcripts without metadata changes. */
+export async function* readMeetingTranscripts(context: FetchContext, deps: CirclebackClientDeps) {
+  for await (const page of readCirclebackPages(context, { path: '/meetings', query: { ownership: deps.config.ownership } }, deps)) {
+    for (const meeting of page.items) {
+      const id = meetingId(meeting)
+      const snapshot = await context.attempt(async (signal) => {
+        const response = await requestCircleback(`/meeting/${encodeURIComponent(id)}/transcript`, signal, deps, true)
+        if (response.status === 403) return { meeting_id: id, status: 'forbidden', data: null }
+        if (response.status === 404) return { meeting_id: id, status: 'not_found', data: null }
+        const transcript: unknown = await response.json()
+        if (!Array.isArray(transcript)) throw new IngestConfigError('Circleback transcript is not an array.')
+        const data = transcript.map((value: unknown) => {
+          const segment = requireCirclebackObject(value, 'transcript segment')
+          if ((segment.speaker !== null && typeof segment.speaker !== 'string') || typeof segment.text !== 'string' ||
+            typeof segment.timestamp !== 'number' || !Number.isFinite(segment.timestamp)) {
+            throw new IngestConfigError('Circleback returned an invalid transcript segment.')
+          }
+          return segment
+        })
+        return { meeting_id: id, status: 'available', data }
+      }, { label: 'GET /meeting/{meetingId}/transcript' })
+      const observations: CirclebackObject[] = [{ source_id: deps.config.sourceId, meeting_id: id, kind: 'availability', status: snapshot.status }]
+      if (snapshot.status === 'available') observations.unshift({ source_id: deps.config.sourceId, kind: 'transcript', ...snapshot })
+      // Unavailability changes read evidence, not the last successful transcript snapshot.
+      yield { rows: rawRows(observations, (item) => JSON.stringify(item.kind === 'transcript'
+        ? [deps.config.sourceId, id] : [deps.config.sourceId, id, 'availability'])) }
+    }
+  }
+}
diff --git a/registry/circleback/sources/meetings.ts b/registry/circleback/sources/meetings.ts
new file mode 100644
index 00000000..73255ce9
--- /dev/null
+++ b/registry/circleback/sources/meetings.ts
@@ -0,0 +1,12 @@
+import { rawTable, type FetchContext } from '@chkit/plugin-ingest'
+
+import { meetingId, readCirclebackPages, tagNames, toCirclebackRows, type CirclebackClientDeps } from '../client.js'
+import { circlebackConfig } from '../config.js'
+
+export const circleback_meetingsRaw = rawTable({ database: circlebackConfig.database, name: 'circleback_meetings_raw' })
+
+export async function* readMeetings(context: FetchContext, deps: CirclebackClientDeps) {
+  for await (const page of readCirclebackPages(context, { path: '/meetings', query: { ownership: deps.config.ownership } }, deps)) {
+    yield { rows: toCirclebackRows(page.items.map(tagNames), meetingId, deps.config.sourceId) }
+  }
+}
diff --git a/registry/circleback/sources/people.ts b/registry/circleback/sources/people.ts
new file mode 100644
index 00000000..2bf6fcbb
--- /dev/null
+++ b/registry/circleback/sources/people.ts
@@ -0,0 +1,23 @@
+import { IngestConfigError, rawTable, type FetchContext } from '@chkit/plugin-ingest'
+
+import { numericId, readCirclebackPages, requestCircleback, requireCirclebackObject, tagNames, toCirclebackRows, type CirclebackClientDeps } from '../client.js'
+import { circlebackConfig } from '../config.js'
+
+export const circleback_peopleRaw = rawTable({ database: circlebackConfig.database, name: 'circleback_people_raw' })
+
+export async function* readPeople(context: FetchContext, deps: CirclebackClientDeps) {
+  for await (const page of readCirclebackPages(context, { path: '/people' }, deps)) {
+    for (const listed of page.items) {
+      const id = numericId(listed.id, 'person')
+      const detail = await context.attempt(async (signal) => {
+        const response = await requestCircleback(`/person/${id}`, signal, deps)
+        const person = requireCirclebackObject(await response.json(), 'person detail')
+        if (numericId(person.id, 'person detail') !== id || !Array.isArray(person.externalLinks)) {
+          throw new IngestConfigError('Circleback person detail changed its ID or omitted external links.')
+        }
+        return person
+      }, { label: 'GET /person/{profileId}' })
+      yield { rows: toCirclebackRows([tagNames({ ...listed, ...detail })], (item) => numericId(item.id, 'person'), deps.config.sourceId) }
+    }
+  }
+}
diff --git a/registry/circleback/tests/basic.test.ts b/registry/circleback/tests/basic.test.ts
index bc7f2682..9de617cf 100644
--- a/registry/circleback/tests/basic.test.ts
+++ b/registry/circleback/tests/basic.test.ts
@@ -1,38 +1,426 @@
-import { afterEach, expect, test } from 'bun:test'
-import { runIngestion, selectStreams } from '@chkit/plugin-ingest'
+import { expect, test } from 'bun:test'
+import { IngestConfigError, runIngestion, selectStreams } from '@chkit/plugin-ingest'
 import { createMemoryDestination, createMemoryJournal } from '@chkit/plugin-ingest/testing'
 
-import { circlebackPipeline } from '../index.js'
+import { createCirclebackPipeline, circlebackPipeline } from '../index.js'
+import { circlebackConfig, type CirclebackConfig } from '../config.js'
+import { defaultCirclebackClientDeps } from '../client.js'
 
-const originalFetch = globalThis.fetch
-const originalToken = process.env.CIRCLEBACK_API_KEY
+const cutoff = new Date('2026-01-02T00:00:00Z')
+const resources = ['meetings', 'meeting_transcripts', 'action_items', 'people', 'companies']
+const meeting = { id: 'meeting-a', name: 'Old meeting', updatedAt: '2020-01-01T00:00:00Z', notes: 'Provider notes',
+  tags: [{ id: 10, name: 'Customer' }, { id: 11, name: 'Follow up' }], attendees: [{ profileId: 1 }],
+  actionItems: [{ id: 252, status: 'PENDING' }], custom: { retained: true } }
+const transcript = [{ speaker: null, text: 'Full transcript\nwith another line', timestamp: 0.25, custom: true }]
+const pending = { id: 252, title: 'Follow up', status: 'PENDING', completedAt: null, assignee: { profileId: 1 }, meetingIds: ['meeting-a'], custom: true }
+const done = { id: 253, title: 'Completed work', status: 'DONE', completedAt: '2020-01-01T00:00:00Z', assignee: null, meetingIds: [], custom: true }
+const person = { id: 1, companyId: 3, firstName: 'John', lastName: 'Appleseed', email: 'john@initech.com', companyName: 'Initech', title: 'Operations', custom: true }
+const personDetail = { ...person, externalLinks: [{ type: 'linkedin', objectType: 'person', url: 'https://www.linkedin.com/in/john-appleseed' }] }
+const company = { domain: 'initech.com', name: 'Initech', avatarUrl: null, custom: true }
+const companyDetail = { ...company, people: [person], externalLinks: [{ type: 'website', objectType: 'company', url: 'https://initech.com' }] }
 
-function setFetch(handler: (...args: Parameters<typeof fetch>) => Promise<Response>): void {
-  globalThis.fetch = Object.assign(handler, { preconnect: originalFetch.preconnect })
-}
+type Pipeline = ReturnType<typeof createCirclebackPipeline>
+type Responder = (url: URL, init: RequestInit) => Response | Promise<Response>
+
+test('Circleback publishes five raw resources with scoped native IDs and string tag names', async () => {
+  const calls: URL[] = [], pipeline = fixturePipeline((url, init) => { calls.push(url); return fixtureResponse(url, init) })
+  expect(circlebackPipeline.streams).toHaveLength(5)
+  expect(pipeline.streams.map((stream) => stream.id).sort()).toEqual(resources.map((resource) => `circleback.${resource}`).sort())
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  const result = await runIngestion(request(pipeline), { journal, destination, now: () => cutoff })
+  expect(result.ok, JSON.stringify(result)).toBe(true)
+  const expected = {
+    meetings: [{ id: rowId('meeting-a'), raw: envelope({ ...meeting, tags: ['Customer', 'Follow up'] }) }],
+    meeting_transcripts: [
+      { id: rowId('meeting-a'), raw: { source_id: 'circleback', kind: 'transcript', meeting_id: 'meeting-a', status: 'available', data: transcript } },
+      { id: JSON.stringify(['circleback', 'meeting-a', 'availability']), raw: { source_id: 'circleback', meeting_id: 'meeting-a', kind: 'availability', status: 'available' } },
+    ],
+    action_items: [pending, done].map((data) => ({ id: rowId(data.id), raw: envelope(data) })),
+    people: [{ id: rowId(person.id), raw: envelope(personDetail) }],
+    companies: [{ id: rowId(company.domain), raw: { source_id: 'circleback', company_id: 3, data: companyDetail } }],
+  }
+  expect(destination.tables.size).toBe(5)
+  for (const [resource, rows] of Object.entries(expected)) {
+    expect(destination.tables.get(`default.circleback_${resource}_raw`)?.map(({ id, raw }) => ({ id, raw }))).toEqual(rows)
+    expect((await journal.readCheckpoint(`circleback.${resource}`)).envelope).toBeUndefined()
+    expect((await journal.readCheckpoint(`circleback.${resource}`)).lastSuccessSeq).toBeGreaterThan(0)
+  }
+  expect(calls.some((url) => url.pathname.includes('/calendar') || url.pathname.includes('/tags') || url.hostname !== 'circleback.ai')).toBe(false)
+})
+
+test('all resources run alone and reversing stream order preserves their raw observations', async () => {
+  const pipeline = fixturePipeline(), combined = createMemoryDestination()
+  expect((await runIngestion(request({ ...pipeline, streams: [...pipeline.streams].reverse() }),
+    { journal: createMemoryJournal(), destination: combined, now: () => cutoff })).ok).toBe(true)
+  for (const resource of resources) {
+    const calls: URL[] = [], destination = createMemoryDestination()
+    const isolated = fixturePipeline((url, init) => { calls.push(url); return fixtureResponse(url, init) })
+    const selected = request(isolated, resource)
+    expect(selected.selected.map((entry) => entry.stream.id)).toEqual([`circleback.${resource}`])
+    expect((await runIngestion(selected, { journal: createMemoryJournal(), destination, now: () => cutoff })).ok).toBe(true)
+    expect(destination.tables.size).toBe(1)
+    expect(destination.tables.get(`default.circleback_${resource}_raw`)?.map(({ id, raw }) => ({ id, raw })))
+      .toEqual(combined.tables.get(`default.circleback_${resource}_raw`)?.map(({ id, raw }) => ({ id, raw })))
+    expect(calls).toHaveLength(resource === 'meetings' ? 1 : 2)
+    if (resource === 'meetings') expect(calls.map((url) => url.pathname)).toEqual(['/api/meetings'])
+    if (resource === 'action_items') expect(calls.every((url) => url.pathname === '/api/action-items')).toBe(true)
+    if (resource === 'companies') expect(calls.map((url) => url.pathname)).toEqual(['/api/companies', '/api/company/initech.com'])
+    if (resource === 'people') expect(calls.map((url) => url.pathname)).toEqual(['/api/people', '/api/person/1'])
+  }
+})
+
+test('action items enumerate both native completion statuses for anyone and follow each partition to exhaustion', async () => {
+  const calls: URL[] = []
+  const pipeline = fixturePipeline((url) => {
+    calls.push(url)
+    expect(url.searchParams.get('assigneeType')).toBe('Anyone')
+    const status = url.searchParams.get('status')
+    expect(status === 'PENDING' || status === 'DONE').toBe(true)
+    const item = status === 'PENDING' ? pending : done
+    if (url.searchParams.has('cursor')) return Response.json([{ ...item, id: item.id + 10 }])
+    return Response.json([item], { headers: { Link: `</api/action-items?assigneeType=Anyone&status=${status}&cursor=next>; rel="next"` } })
+  })
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  expect((await runIngestion(request(pipeline, 'action_items'), { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect(calls.map((url) => [url.searchParams.get('status'), url.searchParams.get('cursor')])).toEqual([
+    ['PENDING', null], ['PENDING', 'next'], ['DONE', null], ['DONE', 'next'],
+  ])
+  expect(destination.tables.get('default.circleback_action_items_raw')?.map((row) => row.id)).toEqual([252, 262, 253, 263].map((id) => rowId(id)))
+  expect((await journal.readCheckpoint('circleback.action_items')).lastSuccessSeq).toBeGreaterThan(0)
+})
+
+test('cursor-only continuations retain ownership and completion filters and conflicting links fail visibly', async () => {
+  for (const resource of ['meetings', 'action_items']) {
+    const calls: URL[] = []
+    const pipeline = fixturePipeline((url) => {
+      calls.push(url)
+      if (resource === 'action_items' && url.searchParams.get('status') === 'PENDING') return Response.json([])
+      if (url.searchParams.has('cursor')) return Response.json(resource === 'meetings' ? [meeting] : [done])
+      return Response.json([], { headers: { Link: `<${url.pathname}?cursor=next>; rel="next"` } })
+    })
+    expect((await runIngestion(request(pipeline, resource), { journal: createMemoryJournal(), destination: createMemoryDestination(), now: () => cutoff })).ok).toBe(true)
+    const continued = calls.at(-1)
+    expect(continued?.searchParams.get('cursor')).toBe('next')
+    if (resource === 'meetings') expect(continued?.searchParams.get('ownership')).toBe('All')
+    else {
+      expect(continued?.searchParams.get('status')).toBe('DONE')
+      expect(continued?.searchParams.get('assigneeType')).toBe('Anyone')
+    }
+  }
+  for (const [resource, conflict] of [['meetings', 'ownership=Mine'], ['action_items', 'status=DONE'], ['action_items', 'assigneeType=Me']] satisfies [string, string][]) {
+    let calls = 0
+    const pipeline = fixturePipeline((url) => {
+      calls++
+      return Response.json([], { headers: { Link: `<${url.pathname}?cursor=next&${conflict}>; rel="next"` } })
+    })
+    const journal = createMemoryJournal()
+    expect((await runIngestion(request(pipeline, resource), { journal, destination: createMemoryDestination(), now: () => cutoff })).ok).toBe(false)
+    expect(calls).toBe(1)
+    expect((await journal.readCheckpoint(`circleback.${resource}`)).lastSuccessSeq).toBe(0)
+  }
+})
+
+test('late transcripts on unchanged old meetings are revisited without running the meetings stream', async () => {
+  let available = false
+  const starts: string[] = [], calls: string[] = []
+  const pipeline = fixturePipeline((url) => {
+    calls.push(url.pathname)
+    if (url.pathname.endsWith('/transcript')) {
+      if (!available) return new Response('unavailable', { status: url.pathname.includes('/meeting-a/') ? 403 : 404 })
+      return Response.json(url.pathname.includes('/meeting-a/') ? transcript : [])
+    }
+    starts.push(url.search)
+    return Response.json([meeting, { ...meeting, id: 'meeting-b' }])
+  })
+  const journal = createMemoryJournal(), destination = createMemoryDestination(), selected = request(pipeline, 'meeting_transcripts')
+  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect(destination.tables.get('default.circleback_meeting_transcripts_raw')?.map((row) => row.raw)).toEqual([
+    { source_id: 'circleback', meeting_id: 'meeting-a', kind: 'availability', status: 'forbidden' },
+    { source_id: 'circleback', meeting_id: 'meeting-b', kind: 'availability', status: 'not_found' },
+  ])
+  available = true
+  expect((await runIngestion(selected, { journal, destination, now: () => new Date('2026-01-03') })).ok).toBe(true)
+  expect(starts).toEqual(['?ownership=All', '?ownership=All'])
+  expect(calls.filter((path) => path.endsWith('/transcript'))).toHaveLength(4)
+  expect(destination.tables.get('default.circleback_meeting_transcripts_raw')?.slice(-4).map((row) => row.raw)).toEqual([
+    { source_id: 'circleback', kind: 'transcript', meeting_id: 'meeting-a', status: 'available', data: transcript },
+    { source_id: 'circleback', meeting_id: 'meeting-a', kind: 'availability', status: 'available' },
+    { source_id: 'circleback', kind: 'transcript', meeting_id: 'meeting-b', status: 'available', data: [] },
+    { source_id: 'circleback', meeting_id: 'meeting-b', kind: 'availability', status: 'available' },
+  ])
+  expect((await journal.readCheckpoint('circleback.meetings')).lastSuccessSeq).toBe(0)
+  expect((await journal.readCheckpoint('circleback.meeting_transcripts')).envelope).toBeUndefined()
+})
+
+test('forbidden and not-found observations preserve prior transcript content while a successful empty transcript replaces it', async () => {
+  let status = 200, empty = false
+  const pipeline = fixturePipeline((url) => url.pathname === '/api/meetings' ? Response.json([meeting])
+    : status === 200 ? Response.json(empty ? [] : transcript) : new Response('unavailable', { status }))
+  const journal = createMemoryJournal(), destination = createMemoryDestination(), selected = request(pipeline, 'meeting_transcripts')
+  for (const nextStatus of [200, 403, 404, 200]) {
+    status = nextStatus
+    expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(true)
+    const snapshots = destination.tables.get('default.circleback_meeting_transcripts_raw')?.filter((row) => row.id === rowId(meeting.id)) ?? []
+    expect(snapshots.at(-1)?.raw).toMatchObject({ kind: 'transcript', status: 'available', data: empty ? [] : transcript })
+    if (status === 404) empty = true
+  }
+  const rows = destination.tables.get('default.circleback_meeting_transcripts_raw') ?? []
+  expect(rows.filter((row) => row.id === rowId(meeting.id))).toHaveLength(2)
+  expect(rows.filter((row) => row.id !== rowId(meeting.id)).map((row) => row.raw)).toEqual(
+    ['available', 'forbidden', 'not_found', 'available'].map((status) => ({ source_id: 'circleback', meeting_id: meeting.id, kind: 'availability', status })))
+  expect(new Set(rows.map((row) => row.id)).size).toBe(2)
+})
+
+test('a transcript source failure leaves its full sync incomplete while all other resource streams succeed', async () => {
+  let fail = true
+  const transcriptCalls: string[] = []
+  const pipeline = fixturePipeline((url, init) => {
+    if (url.pathname.endsWith('/transcript')) {
+      transcriptCalls.push(url.pathname)
+      if (fail) return new Response('unavailable', { status: 500 })
+    }
+    return fixtureResponse(url, init)
+  })
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  const failed = await runIngestion(request(pipeline), { journal, destination, now: () => cutoff })
+  expect(failed.ok).toBe(false)
+  expect(failed.streams.filter((stream) => stream.outcome === 'failed').map((stream) => stream.streamId)).toEqual(['circleback.meeting_transcripts'])
+  expect(destination.tables.get('default.circleback_meetings_raw')?.[0]?.raw).toEqual(envelope({ ...meeting, tags: ['Customer', 'Follow up'] }))
+  expect((await journal.readCheckpoint('circleback.meeting_transcripts')).lastSuccessSeq).toBe(0)
+  for (const resource of resources.filter((resource) => resource !== 'meeting_transcripts')) {
+    expect((await journal.readCheckpoint(`circleback.${resource}`)).lastSuccessSeq).toBeGreaterThan(0)
+  }
+  fail = false
+  expect((await runIngestion(request(pipeline, 'meeting_transcripts'), { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect(transcriptCalls).toEqual(['/api/meeting/meeting-a/transcript', '/api/meeting/meeting-a/transcript'])
+})
 
-afterEach(() => {
-  globalThis.fetch = originalFetch
-  if (originalToken === undefined) delete process.env.CIRCLEBACK_API_KEY
-  else process.env.CIRCLEBACK_API_KEY = originalToken
-})
-
-test.serial('Circleback follows the Link cursor and joins available transcripts', async () => {
-  process.env.CIRCLEBACK_API_KEY = 'fixture'
-  const paths: string[] = []
-  setFetch(async (input) => {
-    const url = new URL(String(input))
-    paths.push(url.pathname + url.search)
-    if (url.pathname.endsWith('/transcript')) return url.pathname.includes('/b/') ? new Response('', { status: 404 }) : Response.json([{ text: 'Hello' }])
-    if (url.searchParams.has('cursor')) return Response.json([{ id: 'b', name: 'Second' }])
-    return Response.json([{ id: 'a', name: 'First' }], { headers: { Link: '</api/meetings?cursor=next>; rel="next"' } })
+test('a failed transcript write replays its own parent discovery before recording successful completion', async () => {
+  const starts: string[] = []
+  const pipeline = fixturePipeline((url, init) => {
+    if (url.pathname === '/api/meetings') starts.push(url.search)
+    return fixtureResponse(url, init)
   })
-  const destination = createMemoryDestination()
-  const result = await runIngestion({ selected: selectStreams([circlebackPipeline], []), backfill: undefined }, { journal: createMemoryJournal(), destination })
-  expect(result.ok).toBe(true)
-  expect(paths).toEqual(['/api/meetings?ownership=All', '/api/meeting/a/transcript', '/api/meetings?cursor=next', '/api/meeting/b/transcript'])
-  const rows = destination.tables.get('default.circleback_meetings_raw') ?? []
-  expect(rows.map((row) => row.id)).toEqual(['a', 'b'])
-  expect(rows[0]?.raw).toMatchObject({ transcript: [{ text: 'Hello' }] })
-  expect(rows[1]?.raw).toMatchObject({ transcript: null })
+  const journal = createMemoryJournal(), destination = createMemoryDestination(), selected = request(pipeline, 'meeting_transcripts')
+  expect((await runIngestion(selected, { journal, destination: { insert: async () => { throw new IngestConfigError('sink rejected') } }, now: () => cutoff })).ok).toBe(false)
+  expect((await journal.readCheckpoint('circleback.meeting_transcripts')).lastSuccessSeq).toBe(0)
+  expect((await journal.readCheckpoint('circleback.meeting_transcripts')).envelope).toBeUndefined()
+  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect(starts).toEqual(['?ownership=All', '?ownership=All'])
+  expect(destination.tables.get('default.circleback_meeting_transcripts_raw')).toHaveLength(2)
 })
+
+test('full meeting reads replay from page one after source and sink failures and retain changed observations', async () => {
+  let fail = true, changed = false
+  const starts: string[] = [], second = { ...meeting, id: 'meeting-b' }
+  const pipeline = fixturePipeline((url) => {
+    if (url.searchParams.has('cursor')) return fail ? new Response('denied', { status: 403 }) : Response.json([second])
+    starts.push(url.search)
+    return Response.json([{ ...meeting, notes: changed ? 'Edited without an updatedAt change' : meeting.notes }],
+      { headers: { Link: '</api/meetings?cursor=next>; rel="next"' } })
+  })
+  const journal = createMemoryJournal(), destination = createMemoryDestination(), selected = request(pipeline, 'meetings')
+  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(false)
+  expect((await journal.readCheckpoint('circleback.meetings')).lastSuccessSeq).toBe(0)
+  fail = false
+  expect((await runIngestion(selected, { journal, destination: { insert: async () => { throw new IngestConfigError('sink rejected') } }, now: () => cutoff })).ok).toBe(false)
+  expect((await journal.readCheckpoint('circleback.meetings')).lastSuccessSeq).toBe(0)
+  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(true)
+  changed = true
+  expect((await runIngestion(selected, { journal, destination, now: () => new Date('2026-01-03') })).ok).toBe(true)
+  expect(starts).toEqual(Array(4).fill('?ownership=All'))
+  expect((await journal.readCheckpoint('circleback.meetings')).envelope).toBeUndefined()
+  expect(destination.tables.get('default.circleback_meetings_raw')?.filter((row) => row.id === rowId('meeting-a')).map((row) => row.raw)).toEqual([
+    envelope({ ...meeting, tags: ['Customer', 'Follow up'] }),
+    envelope({ ...meeting, notes: 'Edited without an updatedAt change', tags: ['Customer', 'Follow up'] }),
+  ])
+})
+
+test('empty full resources record completion and scan again without custom provider state', async () => {
+  const calls: string[] = [], pipeline = fixturePipeline((url) => { calls.push(url.pathname); return Response.json([]) })
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  for (const now of [cutoff, new Date('2026-01-03')]) {
+    expect((await runIngestion(request(pipeline), { journal, destination, now: () => now })).ok).toBe(true)
+  }
+  expect(destination.tables.size).toBe(0)
+  for (const resource of resources) {
+    expect((await journal.readCheckpoint(`circleback.${resource}`)).envelope).toBeUndefined()
+    expect(journal.events.filter((event) => event.namespaceId === `circleback.${resource}` && event.eventKind === 'work_finished' && event.workState === 'succeeded')).toHaveLength(2)
+  }
+  expect(calls.filter((path) => path === '/api/meetings')).toHaveLength(4)
+  expect(calls.filter((path) => path === '/api/action-items')).toHaveLength(4)
+})
+
+test('company domains stay stable while optional native numeric IDs preserve downstream joins', async () => {
+  let identified = false
+  const pipeline = fixturePipeline((url) => url.pathname === '/api/companies'
+    ? Response.json([{ ...company, ...(identified ? { id: 3 } : {}) }])
+    : Response.json({ ...company, externalLinks: [], people: [] }))
+  const journal = createMemoryJournal(), destination = createMemoryDestination(), selected = request(pipeline, 'companies')
+  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(true)
+  identified = true
+  expect((await runIngestion(selected, { journal, destination, now: () => new Date('2026-01-03') })).ok).toBe(true)
+  const rows = destination.tables.get('default.circleback_companies_raw') ?? []
+  expect(rows.map((row) => row.id)).toEqual([rowId('initech.com'), rowId('initech.com')])
+  expect(rows.map((row) => row.raw)).toEqual([
+    { source_id: 'circleback', company_id: null, data: { ...company, externalLinks: [], people: [] } },
+    { source_id: 'circleback', company_id: 3, data: { ...company, id: 3, externalLinks: [], people: [] } },
+  ])
+  expect(new Set(rows.map((row) => row.id)).size).toBe(1)
+})
+
+test('company detail failures and conflicting native IDs cannot complete or fabricate company joins', async () => {
+  for (const mode of ['forbidden', 'conflicting', 'different-domain']) {
+    const pipeline = fixturePipeline((url) => {
+      if (url.pathname === '/api/companies') return Response.json([{ ...company, id: 3 }])
+      if (mode === 'forbidden') return new Response('denied', { status: 403 })
+      return Response.json({ ...companyDetail, ...(mode === 'different-domain' ? { domain: 'other.example' } : { people: [{ ...person, companyId: 4 }] }) })
+    })
+    const journal = createMemoryJournal(), destination = createMemoryDestination()
+    expect((await runIngestion(request(pipeline, 'companies'), { journal, destination, now: () => cutoff })).ok).toBe(false)
+    expect(destination.tables.size).toBe(0)
+    expect((await journal.readCheckpoint('circleback.companies')).lastSuccessSeq).toBe(0)
+  }
+})
+
+test('same-person detail retains raw external references and cannot publish a different or inaccessible person', async () => {
+  for (const mode of ['denied', 'mismatched-id', 'missing-links']) {
+    const calls: string[] = []
+    const pipeline = fixturePipeline((url) => {
+      calls.push(url.pathname)
+      if (url.pathname === '/api/people') return Response.json([person])
+      if (mode === 'denied') return new Response('denied', { status: 403 })
+      return Response.json({ ...personDetail, ...(mode === 'mismatched-id' ? { id: 2 } : { externalLinks: null }) })
+    })
+    const journal = createMemoryJournal(), destination = createMemoryDestination()
+    expect((await runIngestion(request(pipeline, 'people'), { journal, destination, now: () => cutoff })).ok).toBe(false)
+    expect(calls).toEqual(['/api/people', '/api/person/1'])
+    expect(destination.tables.size).toBe(0)
+    expect((await journal.readCheckpoint('circleback.people')).lastSuccessSeq).toBe(0)
+  }
+})
+
+test('factory configuration, tokens and selected resource progress stay independent between installations', async () => {
+  const config: CirclebackConfig = { ...circlebackConfig, sourceId: 'circleback.team', ownership: 'Shared' }
+  const calls: URL[] = []
+  const pipeline = createCirclebackPipeline(config, { ...defaultCirclebackClientDeps, token: () => 'team-key', fetch: async (url, init) => {
+    expect(new Headers(init.headers).get('authorization')).toBe('Bearer team-key')
+    calls.push(new URL(url))
+    return Response.json([meeting])
+  } })
+  config.sourceId = 'changed'
+  config.ownership = 'Mine'
+  const failing = createCirclebackPipeline({ ...circlebackConfig, sourceId: 'circleback.denied' }, {
+    ...defaultCirclebackClientDeps, token: () => 'denied', fetch: async () => new Response('denied', { status: 403 }),
+  })
+  const selected = selectStreams([failing, pipeline], ['resource:meetings']).map((entry) => ({ ...entry, stream: { ...entry.stream, retry: { retries: 0 } } }))
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  const result = await runIngestion({ selected, backfill: undefined }, { journal, destination, now: () => cutoff })
+  expect(result.streams.map((stream) => stream.outcome)).toEqual(['failed', 'succeeded'])
+  expect(calls.map((url) => url.searchParams.get('ownership'))).toEqual(['Shared'])
+  expect(destination.tables.get('default.circleback_meetings_raw')?.[0]?.id).toBe(rowId(meeting.id, 'circleback.team'))
+  expect(destination.tables.get('default.circleback_meetings_raw')?.[0]?.raw).toEqual(envelope({ ...meeting, tags: ['Customer', 'Follow up'] }, 'circleback.team'))
+  expect((await journal.readCheckpoint('circleback.denied.meetings')).lastSuccessSeq).toBe(0)
+  expect((await journal.readCheckpoint('circleback.team.meetings')).lastSuccessSeq).toBeGreaterThan(0)
+  const onlyTeam = selectStreams([failing, pipeline], ['stream:circleback.team.meetings'])
+  expect(onlyTeam.map((entry) => entry.stream.id)).toEqual(['circleback.team.meetings'])
+  expect((await journal.readCheckpoint('circleback.meetings')).lastSuccessSeq).toBe(0)
+})
+
+test('empty Link pages continue while cyclic, cross-collection, foreign and malformed next links fail permanently', async () => {
+  for (const mode of ['empty-first', 'same-initial', 'cyclic', 'cross-collection', 'foreign', 'malformed', 'multiple-next']) {
+    const calls: string[] = []
+    let details = 0
+    const pipeline = fixturePipeline((url) => {
+      if (url.pathname.startsWith('/api/person/')) { details++; return Response.json(personDetail) }
+      calls.push(url.toString())
+      if (mode === 'empty-first' && url.searchParams.has('cursor')) return Response.json([person])
+      if (mode === 'same-initial') return Response.json([person], { headers: { Link: `<${url.toString()}>; rel="next"` } })
+      const next = mode === 'foreign' ? 'https://untrusted.example/people' : mode === 'cross-collection' ? '/api/companies?cursor=next' : '/api/people?cursor=next'
+      const link = mode === 'malformed' ? 'not-a-link; rel="next"' : mode === 'multiple-next' ? `<${next}>; rel="next", </api/people?cursor=another>; rel="next"` : `<${next}>; rel="next"`
+      return Response.json([], { headers: { Link: link } })
+    })
+    const selected = request(pipeline, 'people').selected.map((entry) => ({ ...entry, stream: { ...entry.stream, retry: { retries: 1, minTimeout: 0, maxTimeout: 0 } } }))
+    const journal = createMemoryJournal(), destination = createMemoryDestination()
+    const result = await runIngestion({ selected, backfill: undefined }, { journal, destination, now: () => cutoff })
+    expect(result.ok).toBe(mode === 'empty-first')
+    expect(calls).toHaveLength(['empty-first', 'cyclic'].includes(mode) ? 2 : 1)
+    expect(details).toBe(mode === 'empty-first' ? 1 : 0)
+    expect(destination.tables.size).toBe(mode === 'empty-first' ? 1 : 0)
+    expect((await journal.readCheckpoint('circleback.people')).lastSuccessSeq > 0).toBe(mode === 'empty-first')
+    expect(journal.events.filter((event) => event.eventKind === 'retry_scheduled')).toHaveLength(0)
+  }
+})
+
+test('malformed collections, identities, tag names and unsupported action status cannot become successful full syncs', async () => {
+  for (const [resource, payload] of [
+    ['meetings', { error: 'bad payload' }], ['meetings', [{ ...meeting, id: '' }]], ['meetings', [{ ...meeting, tags: [{ id: 10 }] }]],
+    ['people', [{ ...person, id: 1.5 }]], ['action_items', [{ ...pending, status: 'UNKNOWN' }]],
+    ['action_items', [{ ...pending, status: 'DONE' }]], ['action_items', [{ ...pending, meetingIds: null }]],
+  ] satisfies [string, unknown][]) {
+    let calls = 0
+    const pipeline = fixturePipeline(() => { calls++; return Response.json(payload) })
+    const journal = createMemoryJournal()
+    expect((await runIngestion(request(pipeline, resource), { journal, destination: createMemoryDestination(), now: () => cutoff })).ok).toBe(false)
+    expect(calls).toBe(1)
+    expect((await journal.readCheckpoint(`circleback.${resource}`)).lastSuccessSeq).toBe(0)
+  }
+})
+
+test('HTTP200 malformed transcripts fail without publishing an availability snapshot or completing the stream', async () => {
+  for (const payload of [null, { error: 'denied' }, [{ speaker: null, text: 'Words' }], [{ speaker: 3, text: 'Words', timestamp: 1 }], [{ speaker: null, text: {}, timestamp: 1 }]]) {
+    let calls = 0
+    const pipeline = fixturePipeline((url) => {
+      if (url.pathname === '/api/meetings') return Response.json([meeting])
+      calls++
+      return Response.json(payload)
+    })
+    const journal = createMemoryJournal(), destination = createMemoryDestination()
+    expect((await runIngestion(request(pipeline, 'meeting_transcripts'), { journal, destination, now: () => cutoff })).ok).toBe(false)
+    expect(calls).toBe(1)
+    expect(destination.tables.size).toBe(0)
+    expect((await journal.readCheckpoint('circleback.meeting_transcripts')).lastSuccessSeq).toBe(0)
+  }
+})
+
+test('rate exhaustion consumes exactly one executor-owned page retry and malformed JSON remains permanent', async () => {
+  for (const mode of ['rate', 'malformed-json']) {
+    let calls = 0
+    const pipeline = fixturePipeline((url) => {
+      if (url.pathname.startsWith('/api/person/')) return Response.json(personDetail)
+      calls++
+      if (mode === 'malformed-json') return new Response('{', { headers: { 'Content-Type': 'application/json' } })
+      return calls === 1 ? new Response('rate limited', { status: 429, headers: { 'Retry-After': '0' } }) : Response.json([person])
+    })
+    const selected = request(pipeline, 'people').selected.map((entry) => ({ ...entry, stream: { ...entry.stream, retry: { retries: 1, minTimeout: 0, maxTimeout: 0 } } }))
+    const journal = createMemoryJournal()
+    expect((await runIngestion({ selected, backfill: undefined }, { journal, destination: createMemoryDestination(), now: () => cutoff })).ok).toBe(mode === 'rate')
+    expect(calls).toBe(mode === 'rate' ? 2 : 1)
+    expect(journal.events.filter((event) => event.eventKind === 'retry_scheduled')).toHaveLength(mode === 'rate' ? 1 : 0)
+  }
+})
+
+function fixturePipeline(respond: Responder = fixtureResponse): Pipeline {
+  return createCirclebackPipeline(circlebackConfig, { ...defaultCirclebackClientDeps, token: () => 'fixture',
+    fetch: (url, init) => Promise.resolve(respond(new URL(url), init)) })
+}
+
+function request(pipeline: Pipeline, resource?: string) {
+  return { selected: selectStreams([pipeline], resource ? [`resource:${resource}`] : []).map((entry) => ({
+    ...entry, stream: { ...entry.stream, batchSize: 1, retry: { retries: 0 } },
+  })), backfill: undefined }
+}
+
+function fixtureResponse(url: URL, _init: RequestInit): Response {
+  if (url.pathname === '/api/meetings') return Response.json([meeting])
+  if (url.pathname.endsWith('/transcript')) return Response.json(transcript)
+  if (url.pathname === '/api/action-items') return Response.json(url.searchParams.get('status') === 'DONE' ? [done] : [pending])
+  if (url.pathname === '/api/people') return Response.json([person])
+  if (url.pathname === '/api/person/1') return Response.json(personDetail)
+  if (url.pathname === '/api/companies') return Response.json([company])
+  if (url.pathname === '/api/company/initech.com') return Response.json(companyDetail)
+  throw new IngestConfigError(`Unexpected Circleback fixture request: ${url}`)
+}
+
+function rowId(id: string | number, sourceId = 'circleback'): string { return JSON.stringify([sourceId, id]) }
+function envelope(data: unknown, sourceId = 'circleback') { return { source_id: sourceId, data } }
diff --git a/registry/circleback/tests/retention.e2e.test.ts b/registry/circleback/tests/retention.e2e.test.ts
new file mode 100644
index 00000000..80e5ae8b
--- /dev/null
+++ b/registry/circleback/tests/retention.e2e.test.ts
@@ -0,0 +1,61 @@
+import { afterAll, expect, test } from 'bun:test'
+import { createLiveExecutor, createPrefix, getLiveEnv, quoteIdent } from '@chkit/clickhouse/e2e-testkit'
+import { toCreateSQL } from '@chkit/core'
+import { createClickHouseDestination, rawTable, runIngestion, selectStreams } from '@chkit/plugin-ingest'
+import { createMemoryJournal } from '@chkit/plugin-ingest/testing'
+
+import { circlebackConfig } from '../config.js'
+import { createCirclebackPipeline } from '../pipeline.js'
+
+const env = getLiveEnv()
+const executor = createLiveExecutor(env)
+const destination = rawTable({ database: env.clickhouseDatabase, name: `${createPrefix('circleback_retention')}transcripts_raw` })
+const qualified = `${quoteIdent(destination.database)}.${quoteIdent(destination.name)}`
+
+afterAll(async () => {
+  await executor.command(`DROP TABLE IF EXISTS ${qualified}`)
+  await executor.close()
+})
+
+test('ClickHouse retains successful transcript content through permission loss and replaces it after a successful empty read', async () => {
+  await executor.command(toCreateSQL(destination))
+  let responseStatus = 200
+  let segments = [{ speaker: 'Fixture speaker', text: 'Retained speech', timestamp: 1.5 }]
+  const source = createCirclebackPipeline({ ...circlebackConfig, sourceId: 'circleback.retention' }, {
+    config: circlebackConfig, token: () => 'fixture',
+    fetch: async (input) => new URL(input).pathname === '/api/meetings'
+      ? Response.json([{ id: 'meeting-1' }])
+      : responseStatus === 200 ? Response.json(segments) : new Response('unavailable', { status: responseStatus }),
+  })
+  const pipeline = { ...source, retry: { retries: 0 }, streams: source.streams.map((stream) => ({ ...stream, destination })) }
+  const request = { selected: selectStreams([pipeline], ['resource:meeting_transcripts']), backfill: undefined }
+  const journal = createMemoryJournal()
+  for (const [httpStatus, status] of [[200, 'available'], [403, 'forbidden'], [404, 'not_found']] as const) {
+    responseStatus = httpStatus
+    expect((await runIngestion(request, { journal, destination: createClickHouseDestination(executor) })).ok).toBe(true)
+    await executor.command(`OPTIMIZE TABLE ${qualified} FINAL`)
+    const rows = await executor.query<{ payload: string }>(`SELECT toJSONString(raw) AS payload FROM ${qualified} FINAL`)
+    const raw = rows.map(({ payload }) => JSON.parse(payload))
+    expect(raw).toHaveLength(2)
+    expect(raw.find((item) => item.kind === 'transcript')?.data).toEqual(segments)
+    expect(raw.find((item) => item.kind === 'availability')?.status).toBe(status)
+  }
+  responseStatus = 200
+  segments = []
+  expect((await runIngestion(request, { journal, destination: createClickHouseDestination(executor) })).ok).toBe(true)
+  await executor.command(`OPTIMIZE TABLE ${qualified} FINAL`)
+  const rows = await executor.query<{ payload: string }>(`SELECT toJSONString(raw) AS payload FROM ${qualified} FINAL`)
+  const raw = rows.map(({ payload }) => JSON.parse(payload))
+  expect(raw).toHaveLength(2)
+  expect(raw.find((item) => item.kind === 'transcript')?.data).toEqual([])
+  expect(raw.find((item) => item.kind === 'availability')?.status).toBe('available')
+  const joined = await executor.query<{ meeting_id: string; status: string }>(`
+    SELECT snapshot.raw.meeting_id::String AS meeting_id, outcome.raw.status::String AS status
+    FROM ${qualified} AS snapshot FINAL
+    INNER JOIN ${qualified} AS outcome FINAL
+      ON snapshot.raw.source_id::String = outcome.raw.source_id::String
+      AND snapshot.raw.meeting_id::String = outcome.raw.meeting_id::String
+    WHERE snapshot.raw.kind::String = 'transcript' AND outcome.raw.kind::String = 'availability'
+  `)
+  expect(joined).toEqual([{ meeting_id: 'meeting-1', status: 'available' }])
+})
diff --git a/registry/github/README.md b/registry/github/README.md
index 15699e22..57634437 100644
--- a/registry/github/README.md
+++ b/registry/github/README.md
@@ -1,8 +1,12 @@
-# GitHub raw ingestion example
+# GitHub raw ingestion
 
-This is a small editable starting point based on the GitHub source in [obsessiondb/brain](https://github.com/obsessiondb/brain/tree/main/scripts/brain-sync). It stores provider responses as native JSON without Brain's memory or sales projections.
+This editable integration syncs eight GitHub resource collections into separate raw ClickHouse tables. One installation pipeline groups the streams; each resource owns its selection and journal progress.
 
-Set `GITHUB_TOKEN` in the runtime environment and configure a direct ClickHouse connection. Edit `repositories` in `index.ts` before the first migration. Native JSON requires ClickHouse 25.3 or later.
+## First run
+
+Set `GITHUB_TOKEN` in the runtime environment and configure a direct ClickHouse connection. For private repositories, the supported setup grants repository access with **Issues: read**, **Pull requests: read**, and **Contents: read** permissions, including GraphQL commit reads. These permissions describe the supported setup; field-level minimum permissions depend on the selected endpoints and GraphQL fields. Requests read credentials at execution time; schema imports do not call GitHub. Native JSON requires ClickHouse 25.3 or later.
+
+Edit `githubConfig.repositories`, `sourceId`, timestamp settings, and `pageSize` in `config.ts`. Raw table names and database are declared in their `sources/` modules; edit those definitions before the first migration. `createGitHubPipeline(config, deps)` snapshots reader settings and binds an injectable fetch/token reader. Destination schemas remain setup-time module exports.
 
 ```sh
 bunx chkit check
@@ -12,9 +16,70 @@ bunx chkit migrate --apply
 bunx chkit ingest run --tag provider:github
 ```
 
-## Resources
+## Pipeline and resources
+
+Each configured repository contributes eight independently selectable streams to `githubPipeline`:
+
+| Resource tag | Raw destination | Selection |
+| --- | --- | --- |
+| `resource:issues` | `github_issues_raw` | Updated-time window; excludes pull requests |
+| `resource:issue_comments` | `github_issue_comments_raw` | Comment updated-time window, with its own issue discovery |
+| `resource:pull_requests` | `github_pull_requests_raw` | Full pull-request collection |
+| `resource:pull_request_comments` | `github_pull_request_comments_raw` | Conversation-comment updated-time window, with its own PR discovery |
+| `resource:pull_request_review_comments` | `github_pull_request_review_comments_raw` | Repository-wide diff-comment updated-time window |
+| `resource:pull_request_reviews` | `github_pull_request_reviews_raw` | Full reviews collection, with its own PR discovery |
+| `resource:pull_request_commits` | `github_pull_request_commits_raw` | Full PR commit connections, with its own PR discovery |
+| `resource:stargazers` | `github_stargazers_raw` | Full stargazer collection |
+
+The default repository is `obsessiondb/chkit`, so its stream IDs use `github.<resource>.obsessiondb.chkit`. Existing issues and stargazers stream IDs remain unchanged. Another repository gets independent stream identities and checkpoints. Keep `sourceId` stable for one installation; changing it creates new stream identities.
+
+Select a resource without running any other stream:
+
+```sh
+bunx chkit ingest run --tag provider:github --tag repository:obsessiondb/chkit --tag resource:pull_request_commits
+bunx chkit ingest run --tag provider:github --tag repository:obsessiondb/chkit --tag resource:pull_request_comments
+```
+
+Repeated tags use AND matching. The default `maxStreams: 1` executes selected streams sequentially; filtered runs give resources separate schedules and execution budgets. Stream order does not establish dependencies. A child reader discovers its own accessible parents through GitHub, even when the issues or pull-requests stream has never run. Individual issues and PRs are records inside their resource stream.
+
+## Stored data and joins
+
+Every raw payload has the envelope `{ repository, data }`. Issue comments add `issue_number`; PR conversation comments, review comments, reviews, and commits add `pull_number`. Provider response fields remain under `data`. Issues and PRs contain their own metadata, while comments and reviews occupy individual rows in their respective tables.
+
+PR commits retain exactly `data.sha` and `data.message`, plus the repository and PR join keys. The reader requests the paginated [GraphQL PR commit connection](https://docs.github.com/en/graphql/reference/pulls#pullrequest) and maps the provider commit object ID to `sha`. Repeated SHAs, changes in `totalCount`, or a mismatched distinct terminal count fail the commit stream rather than completing a truncated collection. It does not request changed files or patches.
+
+Join resources later in ClickHouse using `repository` plus `data.number` on issues/PRs and `issue_number` or `pull_number` on child rows. Review comments also retain their provider review ID for joining to reviews. A commit's SHA is scoped to its repository/PR membership, so a commit appearing in several PRs remains joinable to each one.
+
+Raw IDs retain provider identities and parent context. Existing issue and stargazer ID formats stay `[repository, issue.number]` and `[repository, user.id]`. The tables retain the latest observed payload per identity, with ingestion metadata added by chkit.
+
+## Sync and recovery
+
+Issues use `since`, update-time ordering, and a fixed local upper cutoff. Issue comments and PR conversation comments use their own `since` filters; their parent discovery reads the entire accessible issue or PR collection without restricting parent modification times. A recent comment on an old issue or PR stays eligible. Repository-wide review comments use their own update-time filter and recover the PR number from `pull_request_url`. See [issue comments](https://docs.github.com/en/rest/issues/comments#list-issue-comments) and [review comments](https://docs.github.com/en/rest/pulls/comments#list-review-comments-in-a-repository).
+
+The initial timestamp window starts at `2008-01-01`; later windows replay five minutes before the committed watermark. GitHub has no server-side upper timestamp filter for these REST reads, so each timestamp reader discards observations newer than the fixed execution cutoff. A stream advances its watermark only after its complete window and destination writes succeed, including empty windows. Failed or interrupted windows replay from their lower bound.
+
+Pull-request metadata, reviews, PR commits, and stargazers use the library's `fullSync()` strategy. Every run reads that selected resource again; the journal records successful completion, including empty reads. Interrupted reads start the selected collection from its beginning. There are no saved mutable page offsets or per-parent scan ledgers. REST `Link` URLs and GraphQL cursors are request continuations within the read; `paginate()` owns retryable requests and rejects cycles.
+
+Deleted records, removed stars, and commits no longer present after force-pushes remain stored. Pagination over live results is not a source snapshot; periodic historical replay refreshes older timestamp-selected observations and changes beyond overlap:
+
+```sh
+bunx chkit ingest run --tag provider:github --tag resource:issue_comments --backfill reconcile-2026-10-05 --from 2008-01-01
+bunx chkit ingest status --tag provider:github --json
+```
+
+Use a new backfill ID for each reconciliation. Historical replay reads current observations rather than reconstructing old versions. Full-sync resources ignore date bounds. A failed stream can have published some rows without completing its journal progress; it does not move another stream's checkpoint. Run one ingestion process per ClickHouse target at a time.
+
+## Upgrading existing data
+
+Version `0.2.0` adds six raw destinations and separates issues from pull requests. The raw envelope changes to `{ repository, data }` while existing issue/stargazer row IDs stay stable. Previously stored flat payloads may coexist with new envelopes until their IDs are observed again or migrated explicitly.
+
+Combined-reader installations may also have PR rows in `github_issues_raw` and child arrays embedded in parent JSON. Those observations remain stored; running the new streams does not remove or move them. Keep the previous dataset as an archive, or deliberately migrate issue/PR classifications and child payloads into their separate destinations. In particular, old PR rows remain in the issues table until an explicit data migration or reconciliation removes them. Application queries need to account for both retained legacy shapes and the new envelope during that transition.
 
-- `issues` → `github_issues_raw`
-- `stargazers` → `github_stargazers_raw`
+## Fixture tests
+
+```sh
+bunx chkit add github --with-tests
+bun test src/integrations/github/tests/basic.test.ts
+```
 
-Each run scans configured repositories. Removed issues or stars remain stored. A failed API request fails the stream. Raw rows use provider IDs and keep the last observed value; there is no deletion reconciliation. Edit the readers, select fewer streams, or add SQL views for a specific use case. Run one ingestion process per ClickHouse target at a time.
+Portable fixtures verify resource selection and failure isolation, raw payloads and join keys, commit field selection, old-parent child updates, pagination continuations, source/sink failure recovery, configuration snapshots, and empty completion without live credentials.
diff --git a/registry/github/client.ts b/registry/github/client.ts
new file mode 100644
index 00000000..7b8e499c
--- /dev/null
+++ b/registry/github/client.ts
@@ -0,0 +1,158 @@
+import { HttpError, IngestConfigError, paginate, rawRows, type ErrorClassifier, type FetchContext, type RawRow, type TimestampRange } from '@chkit/plugin-ingest'
+
+import type { GitHubConfig } from './config.js'
+
+export type GitHubObject = Record<string, unknown>
+
+export interface GitHubClientDeps {
+  fetch: (url: string, init: RequestInit) => Promise<Response>
+  token: () => string | undefined
+}
+
+export const defaultGitHubClientDeps: GitHubClientDeps = {
+  fetch: (url, init) => fetch(url, init),
+  token: () => process.env.GITHUB_TOKEN,
+}
+
+/** Each page has one executor-owned request attempt; cursors remain local to this read. */
+export function readGitHubPages(
+  context: FetchContext,
+  input: { path: string; accept?: string; params?: Record<string, string> },
+  config: GitHubConfig,
+  deps: GitHubClientDeps,
+) {
+  const first = new URL(`https://api.github.com${input.path}`)
+  for (const [key, value] of Object.entries({ ...input.params, per_page: String(config.pageSize) })) first.searchParams.set(key, value)
+  return paginate<GitHubObject, string>({
+    context, initial: first.toString(), label: `GET ${input.path}`,
+    fetchPage: async (cursor = first.toString(), signal) => {
+      const response = await requestGitHub(cursor, input.accept, signal, deps)
+      const payload: unknown = await response.json()
+      if (!Array.isArray(payload)) throw new IngestConfigError(`GitHub ${input.path} response is not an array.`)
+      const items = payload.map((item: unknown) => requireGitHubObject(item, input.path))
+      const next = nextLink(response.headers.get('link'), cursor)
+      return { items, next }
+    },
+  })
+}
+
+/** An omitted window means complete parent discovery, independent of another stream's progress. */
+export async function* readIssuePages(context: FetchContext, repo: string, config: GitHubConfig, deps: GitHubClientDeps, window?: TimestampRange) {
+  for await (const page of readGitHubPages(context, { path: `/repos/${repo}/issues`, params: {
+    state: 'all', sort: 'updated', direction: 'asc', ...(window ? { since: window.from.toISOString() } : {}),
+  } }, config, deps)) {
+    const issues = page.items.filter((item) => {
+      githubNumber(item, 'number')
+      if (item.pull_request !== undefined) return false
+      return window === undefined || updatedItems([item], window).length > 0
+    })
+    yield { ...page, items: issues }
+  }
+}
+
+/** GitHub has no since filter for PR metadata: list the current collection in full. */
+export async function* readPullPages(context: FetchContext, repo: string, config: GitHubConfig, deps: GitHubClientDeps) {
+  for await (const page of readGitHubPages(context, { path: `/repos/${repo}/pulls`, params: { state: 'all', sort: 'updated', direction: 'asc' } }, config, deps)) {
+    for (const pull of page.items) githubNumber(pull, 'number')
+    yield page
+  }
+}
+
+/** Provider data stays intact; repository and parent keys live outside it for warehouse joins. */
+export function toGitHubRows<T extends GitHubObject>(
+  items: readonly T[], repo: string, identify: (item: T) => string | number,
+  parent?: { issue_number: number } | { pull_number: number },
+): RawRow[] {
+  const number = parent && ('pull_number' in parent ? parent.pull_number : parent.issue_number)
+  return rawRows(items.map((data) => ({ repository: repo, ...parent, data })), ({ data }) =>
+    JSON.stringify([repo, ...(number === undefined ? [] : [number]), identify(data)]))
+}
+
+export function updatedItems(items: readonly GitHubObject[], window: TimestampRange): GitHubObject[] {
+  return items.filter((item) => {
+    if (typeof item.updated_at !== 'string' || !Number.isFinite(Date.parse(item.updated_at))) throw new IngestConfigError('GitHub object has no valid updated_at.')
+    const updated = Date.parse(item.updated_at)
+    return updated >= window.from.getTime() && updated <= window.to.getTime()
+  })
+}
+
+export function githubNumber(item: GitHubObject, field: string): number {
+  const value = item[field]
+  if (typeof value !== 'number' || !Number.isSafeInteger(value) || value <= 0) throw new IngestConfigError(`GitHub object has no valid ${field}.`)
+  return value
+}
+
+export function pullNumber(item: GitHubObject, repo: string): number {
+  if (typeof item.pull_request_url !== 'string') throw new IngestConfigError('GitHub review comment has no pull_request_url.')
+  if (!URL.canParse(item.pull_request_url)) throw new IngestConfigError('GitHub review comment has an invalid pull_request_url.')
+  const url = new URL(item.pull_request_url)
+  const prefix = `/repos/${repo}/pulls/`
+  const value = url.pathname.slice(prefix.length)
+  if (url.origin !== 'https://api.github.com' || !url.pathname.toLowerCase().startsWith(prefix.toLowerCase()) || !/^[1-9]\d*$/.test(value)) {
+    throw new IngestConfigError('GitHub review comment belongs to an unexpected repository or pull request.')
+  }
+  return githubNumber({ number: Number(value) }, 'number')
+}
+
+export function requireGitHubObject(value: unknown, label: string): GitHubObject {
+  if (!isGitHubObject(value)) throw new IngestConfigError(`GitHub ${label} is not an object.`)
+  return value
+}
+
+/** paginate wraps each GraphQL page; never nest another executor attempt here. */
+export async function requestGitHubGraphql(query: string, variables: Record<string, unknown>, signal: AbortSignal, deps: GitHubClientDeps): Promise<GitHubObject> {
+  const response = await deps.fetch('https://api.github.com/graphql', {
+    method: 'POST', headers: { ...authorization(deps), 'Content-Type': 'application/json' },
+    body: JSON.stringify({ query, variables }),
+    signal: AbortSignal.any([signal, AbortSignal.timeout(30_000)]), redirect: 'error',
+  })
+  if (!response.ok) throw await HttpError.fromResponse(response)
+  const body = requireGitHubObject(await response.clone().json(), 'GraphQL response')
+  if (Array.isArray(body.errors) && body.errors.length > 0) {
+    const rateLimited = response.headers.get('x-ratelimit-remaining') === '0' || response.headers.has('retry-after') ||
+      body.errors.some((error: unknown) => isGitHubObject(error) &&
+        (error.type === 'RATE_LIMITED' || (typeof error.message === 'string' && /secondary rate limit/i.test(error.message))))
+    if (rateLimited) throw await HttpError.fromResponse(response)
+    throw new IngestConfigError(`GitHub GraphQL returned errors: ${JSON.stringify(body.errors)}`)
+  }
+  if (body.errors !== undefined && !Array.isArray(body.errors)) throw new IngestConfigError('GitHub GraphQL errors is not an array.')
+  return requireGitHubObject(body.data, 'GraphQL data')
+}
+
+/** REST 403 and GraphQL 200 can both signal rate exhaustion. */
+export function classifyGitHubError(cause: unknown): ReturnType<ErrorClassifier> {
+  if (cause instanceof SyntaxError) return { kind: 'permanent' }
+  if (!(cause instanceof HttpError) || ![200, 403, 429].includes(cause.status)) return undefined
+  const headers = cause.response.headers
+  const reportedRateLimit = /secondary rate limit/i.test(cause.body) ||
+    (cause.status === 200 && /"type"\s*:\s*"RATE_LIMITED"/.test(cause.body))
+  if (headers.get('x-ratelimit-remaining') !== '0' && !headers.has('retry-after') && !reportedRateLimit) return undefined
+  const resetSeconds = Number(headers.get('x-ratelimit-reset'))
+  const untilReset = Number.isFinite(resetSeconds) && resetSeconds > 0 ? Math.max(0, resetSeconds * 1000 - Date.now()) : undefined
+  return { kind: 'rate_limited', retryAfterMs: cause.retryAfterMs ?? untilReset ?? 60_000 }
+}
+
+async function requestGitHub(url: string, accept = 'application/vnd.github+json', signal: AbortSignal, deps: GitHubClientDeps): Promise<Response> {
+  const response = await deps.fetch(url, { signal: AbortSignal.any([signal, AbortSignal.timeout(30_000)]), redirect: 'error',
+    headers: { ...authorization(deps), Accept: accept, 'X-GitHub-Api-Version': '2022-11-28' } })
+  if (!response.ok) throw await HttpError.fromResponse(response)
+  return response
+}
+
+function authorization(deps: GitHubClientDeps): { Authorization: string } {
+  const token = deps.token()?.trim()
+  if (!token) throw new IngestConfigError('Set GITHUB_TOKEN.')
+  return { Authorization: `Bearer ${token}` }
+}
+
+function isGitHubObject(value: unknown): value is GitHubObject {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function nextLink(header: string | null, current: string): string | undefined {
+  const value = header?.split(',').map((part) => /<([^>]+)>\s*;.*rel="?next"?/.exec(part)?.[1]).find(Boolean)
+  if (!value) return undefined
+  const next = new URL(value, current)
+  if (next.origin !== 'https://api.github.com') throw new IngestConfigError('GitHub next page has an unexpected origin.')
+  return next.toString()
+}
diff --git a/registry/github/config.ts b/registry/github/config.ts
new file mode 100644
index 00000000..151eac58
--- /dev/null
+++ b/registry/github/config.ts
@@ -0,0 +1,18 @@
+export interface GitHubConfig {
+  /** Stable, non-secret stream prefix for this installation. */
+  sourceId: string
+  /** Each repository creates eight independent resource streams with separate raw tables. */
+  repositories: readonly string[]
+  start: Date
+  overlapMs: number
+  pageSize: number
+}
+
+// Set source selection here; raw destinations are declared in sources/.
+export const githubConfig: GitHubConfig = {
+  sourceId: 'github',
+  repositories: ['obsessiondb/chkit'],
+  start: new Date('2008-01-01T00:00:00Z'),
+  overlapMs: 5 * 60 * 1000,
+  pageSize: 100,
+}
diff --git a/registry/github/index.ts b/registry/github/index.ts
index ddd8291c..1daef9ee 100644
--- a/registry/github/index.ts
+++ b/registry/github/index.ts
@@ -1,54 +1,9 @@
-import { definePipeline, defineStream, HttpError, rawRows, rawTable, type FetchContext } from '@chkit/plugin-ingest'
-
-const database = 'default'
-// Supply owner/repo names; one stable stream per repository.
-const repositories = ['obsessiondb/chkit']
-
-interface Issue { number: number; [key: string]: unknown }
-interface Stargazer { user: { id: number }; [key: string]: unknown }
-
-export const github_issuesRaw = rawTable({ database, name: 'github_issues_raw' })
-export const github_stargazersRaw = rawTable({ database, name: 'github_stargazers_raw' })
-
-export const githubPipeline = definePipeline({
-  id: 'github', tags: ['provider:github'], maxFetches: 1,
-  streams: repositories.flatMap((repo) => [
-    defineStream({
-      id: `github.issues.${repo.replace('/', '.')}`, tags: ['resource:issues'], destination: github_issuesRaw,
-      async *read(context) {
-        for await (const page of pages<Issue>(context, repo, 'issues', 'application/vnd.github+json')) {
-          yield { rows: rawRows(page, (issue) => JSON.stringify([repo, issue.number])) }
-        }
-      },
-    }),
-    defineStream({
-      id: `github.stargazers.${repo.replace('/', '.')}`, tags: ['resource:stargazers'], destination: github_stargazersRaw,
-      async *read(context) {
-        for await (const page of pages<Stargazer>(context, repo, 'stargazers', 'application/vnd.github.star+json')) {
-          yield { rows: rawRows(page, (star) => JSON.stringify([repo, star.user.id])) }
-        }
-      },
-    }),
-  ]),
-})
-
-async function* pages<T>(context: FetchContext, repo: string, resource: string, accept: string): AsyncGenerator<T[]> {
-  let page = 1
-  while (true) {
-    const url = new URL(`https://api.github.com/repos/${repo}/${resource}`)
-    url.searchParams.set('per_page', '100')
-    url.searchParams.set('page', String(page))
-    if (resource === 'issues') url.searchParams.set('state', 'all')
-    const items = await context.attempt(async (signal) => {
-      const token = process.env.GITHUB_TOKEN
-      if (!token) throw new Error('Set GITHUB_TOKEN')
-      const response = await fetch(url, { signal, headers: { Authorization: `Bearer ${token}`, Accept: accept, 'X-GitHub-Api-Version': '2022-11-28' } })
-      if (!response.ok) throw await HttpError.fromResponse(response)
-      return await response.json() as T[]
-    }, { label: `GET /repos/{owner}/{repo}/${resource}` })
-    if (!Array.isArray(items)) throw new Error(`GitHub ${resource} response is not an array`)
-    if (items.length) yield items
-    if (items.length < 100) return
-    page++
-  }
-}
+export { githubPipeline, createGitHubPipeline } from './pipeline.js'
+export { github_issuesRaw } from './sources/issues.js'
+export { github_issueCommentsRaw } from './sources/issue-comments.js'
+export { github_pullRequestsRaw } from './sources/pull-requests.js'
+export { github_pullRequestCommentsRaw } from './sources/pull-request-comments.js'
+export { github_pullRequestReviewCommentsRaw } from './sources/pull-request-review-comments.js'
+export { github_pullRequestReviewsRaw } from './sources/pull-request-reviews.js'
+export { github_pullRequestCommitsRaw } from './sources/pull-request-commits.js'
+export { github_stargazersRaw } from './sources/stargazers.js'
diff --git a/registry/github/manifest.json b/registry/github/manifest.json
index 1d27fe1a..b7778140 100644
--- a/registry/github/manifest.json
+++ b/registry/github/manifest.json
@@ -3,10 +3,10 @@
   "name": "github",
   "type": "registry:item",
   "title": "GitHub",
-  "description": "Small, editable GitHub API ingestion example with raw ClickHouse tables.",
+  "description": "Editable GitHub ingestion with independent issue, pull-request, discussion, review, commit, and stargazer streams and raw ClickHouse tables.",
   "dependencies": [
-    "@chkit/core@^0.2.0-beta.8",
-    "@chkit/plugin-ingest@^0.2.0-beta.8"
+    "@chkit/core@^0.2.0-beta.10",
+    "@chkit/plugin-ingest@^0.2.0-beta.10"
   ],
   "files": [
     {
@@ -18,34 +18,122 @@
       "path": "index.ts",
       "type": "registry:file",
       "target": "src/integrations/github/index.ts"
+    },
+    {
+      "path": "config.ts",
+      "type": "registry:file",
+      "target": "src/integrations/github/config.ts"
+    },
+    {
+      "path": "client.ts",
+      "type": "registry:file",
+      "target": "src/integrations/github/client.ts"
+    },
+    {
+      "path": "pipeline.ts",
+      "type": "registry:file",
+      "target": "src/integrations/github/pipeline.ts"
+    },
+    {
+      "path": "sources/issues.ts",
+      "type": "registry:file",
+      "target": "src/integrations/github/sources/issues.ts"
+    },
+    {
+      "path": "sources/stargazers.ts",
+      "type": "registry:file",
+      "target": "src/integrations/github/sources/stargazers.ts"
+    },
+    {
+      "path": "sources/issue-comments.ts",
+      "type": "registry:file",
+      "target": "src/integrations/github/sources/issue-comments.ts"
+    },
+    {
+      "path": "sources/pull-requests.ts",
+      "type": "registry:file",
+      "target": "src/integrations/github/sources/pull-requests.ts"
+    },
+    {
+      "path": "sources/pull-request-comments.ts",
+      "type": "registry:file",
+      "target": "src/integrations/github/sources/pull-request-comments.ts"
+    },
+    {
+      "path": "sources/pull-request-review-comments.ts",
+      "type": "registry:file",
+      "target": "src/integrations/github/sources/pull-request-review-comments.ts"
+    },
+    {
+      "path": "sources/pull-request-reviews.ts",
+      "type": "registry:file",
+      "target": "src/integrations/github/sources/pull-request-reviews.ts"
+    },
+    {
+      "path": "sources/pull-request-commits.ts",
+      "type": "registry:file",
+      "target": "src/integrations/github/sources/pull-request-commits.ts"
+    },
+    {
+      "path": "tests/basic.test.ts",
+      "type": "registry:file",
+      "target": "src/integrations/github/tests/basic.test.ts",
+      "role": "test"
     }
   ],
   "meta": {
     "chkit": {
       "formatVersion": 1,
-      "version": "0.1.0",
+      "version": "0.2.0",
+      "changelog": [
+        {
+          "version": "0.2.0",
+          "changes": [
+            "Sync issues and editable comments through overlapping updated-time windows; advance each stream watermark only after its destination acknowledgement.",
+            "Separate issues, issue comments, pull requests, PR conversation comments, review comments, reviews, commits, and stargazers into independently selectable raw streams for every configured repository.",
+            "Store repository and parent join keys beside provider data; retain only commit SHA and message through paginated GraphQL commit connections, and leave joins to ClickHouse.",
+            "Use one installation pipeline with configuration snapshots, injectable requests, shared pagination, and fullSync where no reliable change filter exists; existing mixed or combined observations require deliberate data migration.",
+            "Consume full pagination pages and use shared continuation-cycle detection while preserving raw resource checkpoints and PR commit completeness checks."
+          ]
+        },
+        {
+          "version": "0.1.0",
+          "changes": [
+            "Introduce raw repository issues and stargazers ingestion."
+          ]
+        }
+      ],
       "documentation": "https://chkit.obsessiondb.com/integrations/github/",
       "logo": "https://chkit.obsessiondb.com/logos/github.svg",
       "language": "typescript",
       "license": "MIT",
-      "chkit": "^0.2.0-beta.8",
-      "ingest": "^0.2.0-beta.8",
+      "chkit": "^0.2.0-beta.10",
+      "ingest": "^0.2.0-beta.10",
       "clickhouse": ">=25.3.0",
       "root": "src/integrations/github",
       "entry": "index.ts",
       "exports": [
         "githubPipeline",
+        "createGitHubPipeline",
         "github_issuesRaw",
+        "github_issueCommentsRaw",
+        "github_pullRequestsRaw",
+        "github_pullRequestCommentsRaw",
+        "github_pullRequestReviewCommentsRaw",
+        "github_pullRequestReviewsRaw",
+        "github_pullRequestCommitsRaw",
         "github_stargazersRaw"
       ],
       "resources": [
         {
           "name": "issues",
-          "title": "Issues and pull requests",
+          "title": "Issues",
           "table": "github_issues_raw",
-          "description": "Issue and pull request summaries for the configured repositories",
-          "scopes": [],
-          "strategy": "full",
+          "description": "Only ordinary issues, with complete provider issue fields and repository context",
+          "scopes": [
+            "Issues:read"
+          ],
+          "strategy": "timestamp",
           "endpoints": [
             {
               "method": "GET",
@@ -54,11 +142,134 @@
             }
           ]
         },
+        {
+          "name": "issue_comments",
+          "title": "Issue comments",
+          "table": "github_issue_comments_raw",
+          "description": "One raw comment per row for ordinary issues; independently discovers all issue parents and filters child updates",
+          "scopes": [
+            "Issues:read"
+          ],
+          "strategy": "timestamp",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/repos/{owner}/{repo}/issues",
+              "documentation": "https://docs.github.com/en/rest/issues/issues#list-repository-issues"
+            },
+            {
+              "method": "GET",
+              "path": "/repos/{owner}/{repo}/issues/{issue_number}/comments",
+              "documentation": "https://docs.github.com/en/rest/issues/comments#list-issue-comments"
+            }
+          ]
+        },
+        {
+          "name": "pull_requests",
+          "title": "Pull requests",
+          "table": "github_pull_requests_raw",
+          "description": "Pull-request metadata from its own collection, with repository context",
+          "scopes": [
+            "Pull requests:read"
+          ],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/repos/{owner}/{repo}/pulls",
+              "documentation": "https://docs.github.com/en/rest/pulls/pulls#list-pull-requests"
+            }
+          ]
+        },
+        {
+          "name": "pull_request_comments",
+          "title": "Pull request conversation comments",
+          "table": "github_pull_request_comments_raw",
+          "description": "One raw conversation comment per row with its pull number; independently discovers all pull-request parents and filters child updates",
+          "scopes": [
+            "Pull requests:read"
+          ],
+          "strategy": "timestamp",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/repos/{owner}/{repo}/pulls",
+              "documentation": "https://docs.github.com/en/rest/pulls/pulls#list-pull-requests"
+            },
+            {
+              "method": "GET",
+              "path": "/repos/{owner}/{repo}/issues/{pull_number}/comments",
+              "documentation": "https://docs.github.com/en/rest/issues/comments#list-issue-comments"
+            }
+          ]
+        },
+        {
+          "name": "pull_request_review_comments",
+          "title": "Pull request review comments",
+          "table": "github_pull_request_review_comments_raw",
+          "description": "Raw diff-review comments with repository and pull-number context, selected by their own update times",
+          "scopes": [
+            "Pull requests:read"
+          ],
+          "strategy": "timestamp",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/repos/{owner}/{repo}/pulls/comments",
+              "documentation": "https://docs.github.com/en/rest/pulls/comments#list-review-comments-in-a-repository"
+            }
+          ]
+        },
+        {
+          "name": "pull_request_reviews",
+          "title": "Pull request reviews",
+          "table": "github_pull_request_reviews_raw",
+          "description": "One raw review per row with repository and pull number; discovers its own pull-request parents",
+          "scopes": [
+            "Pull requests:read"
+          ],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/repos/{owner}/{repo}/pulls",
+              "documentation": "https://docs.github.com/en/rest/pulls/pulls#list-pull-requests"
+            },
+            {
+              "method": "GET",
+              "path": "/repos/{owner}/{repo}/pulls/{pull_number}/reviews",
+              "documentation": "https://docs.github.com/en/rest/pulls/reviews#list-reviews-for-a-pull-request"
+            }
+          ]
+        },
+        {
+          "name": "pull_request_commits",
+          "title": "Pull request commits",
+          "table": "github_pull_request_commits_raw",
+          "description": "Commit SHA and message only, with repository and pull number; paginates GraphQL commits after independent pull-request discovery",
+          "scopes": [
+            "Pull requests:read",
+            "Contents:read"
+          ],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/repos/{owner}/{repo}/pulls",
+              "documentation": "https://docs.github.com/en/rest/pulls/pulls#list-pull-requests"
+            },
+            {
+              "method": "POST",
+              "path": "/graphql",
+              "documentation": "https://docs.github.com/en/graphql/reference/pulls#pullrequest"
+            }
+          ]
+        },
         {
           "name": "stargazers",
           "title": "Stargazers",
           "table": "github_stargazers_raw",
-          "description": "Repository stargazers with starred_at when the token permits it",
+          "description": "Repository stargazers with starred_at and repository context",
           "scopes": [],
           "strategy": "full",
           "endpoints": [
@@ -80,16 +291,19 @@
         ],
         "documentation": "https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens",
         "setup": [
-          "Provide GITHUB_TOKEN with read access to the selected resources.",
+          "For private repositories, the supported setup grants GITHUB_TOKEN repository access with Issues:read, Pull requests:read, and Contents:read, including GraphQL commit reads; this is not a verified field-level permission minimum.",
           "Supply a new access token when the existing token expires."
         ]
       },
       "views": [],
       "sync": {
-        "description": "A full read runs for each enabled stream. Stable IDs keep the latest observed record.",
+        "description": "One installation pipeline groups eight independent resource streams per configured repository. Issues and comments use completed updated-time windows; pull requests, reviews, commits, and stargazers use fullSync. Each child stream discovers its own parent collection, independently of parent-stream execution or parent update times.",
         "schedule": "Run bunx chkit ingest run --tag provider:github from a scheduler.",
-        "deletions": "Each run scans configured repositories. Removed issues or stars remain stored."
+        "deletions": "Deleted records, removed stars, and commits no longer present after a force-push remain stored. Missing observations do not generate tombstones; legacy mixed issue/PR rows and nested child payloads require deliberate migration."
       }
     }
-  }
+  },
+  "devDependencies": [
+    "@types/bun@^1.2.0"
+  ]
 }
diff --git a/registry/github/pipeline.ts b/registry/github/pipeline.ts
new file mode 100644
index 00000000..bb0b237d
--- /dev/null
+++ b/registry/github/pipeline.ts
@@ -0,0 +1,69 @@
+import { definePipeline, defineStream, IngestConfigError, timestampWindow } from '@chkit/plugin-ingest'
+
+import { classifyGitHubError, defaultGitHubClientDeps, type GitHubClientDeps } from './client.js'
+import { githubConfig, type GitHubConfig } from './config.js'
+import { github_issuesRaw, readIssues } from './sources/issues.js'
+import { github_issueCommentsRaw, readIssueComments } from './sources/issue-comments.js'
+import { github_pullRequestsRaw, readPullRequests } from './sources/pull-requests.js'
+import { github_pullRequestCommentsRaw, readPullRequestComments } from './sources/pull-request-comments.js'
+import { github_pullRequestReviewCommentsRaw, readPullRequestReviewComments } from './sources/pull-request-review-comments.js'
+import { github_pullRequestReviewsRaw, readPullRequestReviews } from './sources/pull-request-reviews.js'
+import { github_pullRequestCommitsRaw, readPullRequestCommits } from './sources/pull-request-commits.js'
+import { github_stargazersRaw, readStargazers } from './sources/stargazers.js'
+
+export function createGitHubPipeline(config: GitHubConfig = githubConfig, deps: GitHubClientDeps = defaultGitHubClientDeps) {
+  const source = { ...config, repositories: [...config.repositories], start: new Date(config.start) }
+  if (!Number.isSafeInteger(config.pageSize) || config.pageSize < 1 || config.pageSize > 100) {
+    throw new IngestConfigError('GitHub pageSize must be an integer between 1 and 100.')
+  }
+  if (config.repositories.some((repo) => !/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(repo))) {
+    throw new IngestConfigError('GitHub repositories must use owner/repository names.')
+  }
+  return definePipeline({
+    id: source.sourceId, tags: ['provider:github'], maxStreams: 1, maxFetches: 1,
+    streams: source.repositories.flatMap((repo) => {
+      const suffix = repo.replace('/', '.')
+      const options = { classifyError: classifyGitHubError, tags: [`repository:${repo}`] }
+      return [
+        defineStream({
+          ...options, id: `${source.sourceId}.issues.${suffix}`, tags: [...options.tags, 'resource:issues'], destination: github_issuesRaw,
+          incremental: timestampWindow({ start: source.start, overlapMs: source.overlapMs }),
+          read: (context) => readIssues(context, repo, source, deps),
+        }),
+        defineStream({
+          ...options, id: `${source.sourceId}.issue_comments.${suffix}`, tags: [...options.tags, 'resource:issue_comments'], destination: github_issueCommentsRaw,
+          incremental: timestampWindow({ start: source.start, overlapMs: source.overlapMs }),
+          read: (context) => readIssueComments(context, repo, source, deps),
+        }),
+        defineStream({
+          ...options, id: `${source.sourceId}.pull_requests.${suffix}`, tags: [...options.tags, 'resource:pull_requests'], destination: github_pullRequestsRaw,
+          read: (context) => readPullRequests(context, repo, source, deps),
+        }),
+        defineStream({
+          ...options, id: `${source.sourceId}.pull_request_comments.${suffix}`, tags: [...options.tags, 'resource:pull_request_comments'], destination: github_pullRequestCommentsRaw,
+          incremental: timestampWindow({ start: source.start, overlapMs: source.overlapMs }),
+          read: (context) => readPullRequestComments(context, repo, source, deps),
+        }),
+        defineStream({
+          ...options, id: `${source.sourceId}.pull_request_review_comments.${suffix}`, tags: [...options.tags, 'resource:pull_request_review_comments'], destination: github_pullRequestReviewCommentsRaw,
+          incremental: timestampWindow({ start: source.start, overlapMs: source.overlapMs }),
+          read: (context) => readPullRequestReviewComments(context, repo, source, deps),
+        }),
+        defineStream({
+          ...options, id: `${source.sourceId}.pull_request_reviews.${suffix}`, tags: [...options.tags, 'resource:pull_request_reviews'], destination: github_pullRequestReviewsRaw,
+          read: (context) => readPullRequestReviews(context, repo, source, deps),
+        }),
+        defineStream({
+          ...options, id: `${source.sourceId}.pull_request_commits.${suffix}`, tags: [...options.tags, 'resource:pull_request_commits'], destination: github_pullRequestCommitsRaw,
+          read: (context) => readPullRequestCommits(context, repo, source, deps),
+        }),
+        defineStream({
+          ...options, id: `${source.sourceId}.stargazers.${suffix}`, tags: [...options.tags, 'resource:stargazers'], destination: github_stargazersRaw,
+          read: (context) => readStargazers(context, repo, source, deps),
+        }),
+      ]
+    }),
+  })
+}
+
+export const githubPipeline = createGitHubPipeline()
diff --git a/registry/github/releases/0.2.0.json b/registry/github/releases/0.2.0.json
new file mode 100644
index 00000000..ee52b153
--- /dev/null
+++ b/registry/github/releases/0.2.0.json
@@ -0,0 +1,339 @@
+{
+  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
+  "name": "github",
+  "type": "registry:item",
+  "title": "GitHub",
+  "description": "Editable GitHub ingestion with independent issue, pull-request, discussion, review, commit, and stargazer streams and raw ClickHouse tables.",
+  "dependencies": [
+    "@chkit/core@^0.2.0-beta.10",
+    "@chkit/plugin-ingest@^0.2.0-beta.10"
+  ],
+  "devDependencies": [
+    "@types/bun@^1.2.0"
+  ],
+  "files": [
+    {
+      "path": "github/README.md",
+      "type": "registry:file",
+      "target": "src/integrations/github/README.md",
+      "content": "# GitHub raw ingestion\n\nThis editable integration syncs eight GitHub resource collections into separate raw ClickHouse tables. One installation pipeline groups the streams; each resource owns its selection and journal progress.\n\n## First run\n\nSet `GITHUB_TOKEN` in the runtime environment and configure a direct ClickHouse connection. For private repositories, the supported setup grants repository access with **Issues: read**, **Pull requests: read**, and **Contents: read** permissions, including GraphQL commit reads. These permissions describe the supported setup; field-level minimum permissions depend on the selected endpoints and GraphQL fields. Requests read credentials at execution time; schema imports do not call GitHub. Native JSON requires ClickHouse 25.3 or later.\n\nEdit `githubConfig.repositories`, `sourceId`, timestamp settings, and `pageSize` in `config.ts`. Raw table names and database are declared in their `sources/` modules; edit those definitions before the first migration. `createGitHubPipeline(config, deps)` snapshots reader settings and binds an injectable fetch/token reader. Destination schemas remain setup-time module exports.\n\n```sh\nbunx chkit check\nbunx chkit generate --name add_github\n# Review the migration before applying it.\nbunx chkit migrate --apply\nbunx chkit ingest run --tag provider:github\n```\n\n## Pipeline and resources\n\nEach configured repository contributes eight independently selectable streams to `githubPipeline`:\n\n| Resource tag | Raw destination | Selection |\n| --- | --- | --- |\n| `resource:issues` | `github_issues_raw` | Updated-time window; excludes pull requests |\n| `resource:issue_comments` | `github_issue_comments_raw` | Comment updated-time window, with its own issue discovery |\n| `resource:pull_requests` | `github_pull_requests_raw` | Full pull-request collection |\n| `resource:pull_request_comments` | `github_pull_request_comments_raw` | Conversation-comment updated-time window, with its own PR discovery |\n| `resource:pull_request_review_comments` | `github_pull_request_review_comments_raw` | Repository-wide diff-comment updated-time window |\n| `resource:pull_request_reviews` | `github_pull_request_reviews_raw` | Full reviews collection, with its own PR discovery |\n| `resource:pull_request_commits` | `github_pull_request_commits_raw` | Full PR commit connections, with its own PR discovery |\n| `resource:stargazers` | `github_stargazers_raw` | Full stargazer collection |\n\nThe default repository is `obsessiondb/chkit`, so its stream IDs use `github.<resource>.obsessiondb.chkit`. Existing issues and stargazers stream IDs remain unchanged. Another repository gets independent stream identities and checkpoints. Keep `sourceId` stable for one installation; changing it creates new stream identities.\n\nSelect a resource without running any other stream:\n\n```sh\nbunx chkit ingest run --tag provider:github --tag repository:obsessiondb/chkit --tag resource:pull_request_commits\nbunx chkit ingest run --tag provider:github --tag repository:obsessiondb/chkit --tag resource:pull_request_comments\n```\n\nRepeated tags use AND matching. The default `maxStreams: 1` executes selected streams sequentially; filtered runs give resources separate schedules and execution budgets. Stream order does not establish dependencies. A child reader discovers its own accessible parents through GitHub, even when the issues or pull-requests stream has never run. Individual issues and PRs are records inside their resource stream.\n\n## Stored data and joins\n\nEvery raw payload has the envelope `{ repository, data }`. Issue comments add `issue_number`; PR conversation comments, review comments, reviews, and commits add `pull_number`. Provider response fields remain under `data`. Issues and PRs contain their own metadata, while comments and reviews occupy individual rows in their respective tables.\n\nPR commits retain exactly `data.sha` and `data.message`, plus the repository and PR join keys. The reader requests the paginated [GraphQL PR commit connection](https://docs.github.com/en/graphql/reference/pulls#pullrequest) and maps the provider commit object ID to `sha`. Repeated SHAs, changes in `totalCount`, or a mismatched distinct terminal count fail the commit stream rather than completing a truncated collection. It does not request changed files or patches.\n\nJoin resources later in ClickHouse using `repository` plus `data.number` on issues/PRs and `issue_number` or `pull_number` on child rows. Review comments also retain their provider review ID for joining to reviews. A commit's SHA is scoped to its repository/PR membership, so a commit appearing in several PRs remains joinable to each one.\n\nRaw IDs retain provider identities and parent context. Existing issue and stargazer ID formats stay `[repository, issue.number]` and `[repository, user.id]`. The tables retain the latest observed payload per identity, with ingestion metadata added by chkit.\n\n## Sync and recovery\n\nIssues use `since`, update-time ordering, and a fixed local upper cutoff. Issue comments and PR conversation comments use their own `since` filters; their parent discovery reads the entire accessible issue or PR collection without restricting parent modification times. A recent comment on an old issue or PR stays eligible. Repository-wide review comments use their own update-time filter and recover the PR number from `pull_request_url`. See [issue comments](https://docs.github.com/en/rest/issues/comments#list-issue-comments) and [review comments](https://docs.github.com/en/rest/pulls/comments#list-review-comments-in-a-repository).\n\nThe initial timestamp window starts at `2008-01-01`; later windows replay five minutes before the committed watermark. GitHub has no server-side upper timestamp filter for these REST reads, so each timestamp reader discards observations newer than the fixed execution cutoff. A stream advances its watermark only after its complete window and destination writes succeed, including empty windows. Failed or interrupted windows replay from their lower bound.\n\nPull-request metadata, reviews, PR commits, and stargazers use the library's `fullSync()` strategy. Every run reads that selected resource again; the journal records successful completion, including empty reads. Interrupted reads start the selected collection from its beginning. There are no saved mutable page offsets or per-parent scan ledgers. REST `Link` URLs and GraphQL cursors are request continuations within the read; `paginate()` owns retryable requests and rejects cycles.\n\nDeleted records, removed stars, and commits no longer present after force-pushes remain stored. Pagination over live results is not a source snapshot; periodic historical replay refreshes older timestamp-selected observations and changes beyond overlap:\n\n```sh\nbunx chkit ingest run --tag provider:github --tag resource:issue_comments --backfill reconcile-2026-10-05 --from 2008-01-01\nbunx chkit ingest status --tag provider:github --json\n```\n\nUse a new backfill ID for each reconciliation. Historical replay reads current observations rather than reconstructing old versions. Full-sync resources ignore date bounds. A failed stream can have published some rows without completing its journal progress; it does not move another stream's checkpoint. Run one ingestion process per ClickHouse target at a time.\n\n## Upgrading existing data\n\nVersion `0.2.0` adds six raw destinations and separates issues from pull requests. The raw envelope changes to `{ repository, data }` while existing issue/stargazer row IDs stay stable. Previously stored flat payloads may coexist with new envelopes until their IDs are observed again or migrated explicitly.\n\nCombined-reader installations may also have PR rows in `github_issues_raw` and child arrays embedded in parent JSON. Those observations remain stored; running the new streams does not remove or move them. Keep the previous dataset as an archive, or deliberately migrate issue/PR classifications and child payloads into their separate destinations. In particular, old PR rows remain in the issues table until an explicit data migration or reconciliation removes them. Application queries need to account for both retained legacy shapes and the new envelope during that transition.\n\n## Fixture tests\n\n```sh\nbunx chkit add github --with-tests\nbun test src/integrations/github/tests/basic.test.ts\n```\n\nPortable fixtures verify resource selection and failure isolation, raw payloads and join keys, commit field selection, old-parent child updates, pagination continuations, source/sink failure recovery, configuration snapshots, and empty completion without live credentials.\n"
+    },
+    {
+      "path": "github/index.ts",
+      "type": "registry:file",
+      "target": "src/integrations/github/index.ts",
+      "content": "export { githubPipeline, createGitHubPipeline } from './pipeline.js'\nexport { github_issuesRaw } from './sources/issues.js'\nexport { github_issueCommentsRaw } from './sources/issue-comments.js'\nexport { github_pullRequestsRaw } from './sources/pull-requests.js'\nexport { github_pullRequestCommentsRaw } from './sources/pull-request-comments.js'\nexport { github_pullRequestReviewCommentsRaw } from './sources/pull-request-review-comments.js'\nexport { github_pullRequestReviewsRaw } from './sources/pull-request-reviews.js'\nexport { github_pullRequestCommitsRaw } from './sources/pull-request-commits.js'\nexport { github_stargazersRaw } from './sources/stargazers.js'\n"
+    },
+    {
+      "path": "github/config.ts",
+      "type": "registry:file",
+      "target": "src/integrations/github/config.ts",
+      "content": "export interface GitHubConfig {\n  /** Stable, non-secret stream prefix for this installation. */\n  sourceId: string\n  /** Each repository creates eight independent resource streams with separate raw tables. */\n  repositories: readonly string[]\n  start: Date\n  overlapMs: number\n  pageSize: number\n}\n\n// Set source selection here; raw destinations are declared in sources/.\nexport const githubConfig: GitHubConfig = {\n  sourceId: 'github',\n  repositories: ['obsessiondb/chkit'],\n  start: new Date('2008-01-01T00:00:00Z'),\n  overlapMs: 5 * 60 * 1000,\n  pageSize: 100,\n}\n"
+    },
+    {
+      "path": "github/client.ts",
+      "type": "registry:file",
+      "target": "src/integrations/github/client.ts",
+      "content": "import { HttpError, IngestConfigError, paginate, rawRows, type ErrorClassifier, type FetchContext, type RawRow, type TimestampRange } from '@chkit/plugin-ingest'\n\nimport type { GitHubConfig } from './config.js'\n\nexport type GitHubObject = Record<string, unknown>\n\nexport interface GitHubClientDeps {\n  fetch: (url: string, init: RequestInit) => Promise<Response>\n  token: () => string | undefined\n}\n\nexport const defaultGitHubClientDeps: GitHubClientDeps = {\n  fetch: (url, init) => fetch(url, init),\n  token: () => process.env.GITHUB_TOKEN,\n}\n\n/** Each page has one executor-owned request attempt; cursors remain local to this read. */\nexport function readGitHubPages(\n  context: FetchContext,\n  input: { path: string; accept?: string; params?: Record<string, string> },\n  config: GitHubConfig,\n  deps: GitHubClientDeps,\n) {\n  const first = new URL(`https://api.github.com${input.path}`)\n  for (const [key, value] of Object.entries({ ...input.params, per_page: String(config.pageSize) })) first.searchParams.set(key, value)\n  return paginate<GitHubObject, string>({\n    context, initial: first.toString(), label: `GET ${input.path}`,\n    fetchPage: async (cursor = first.toString(), signal) => {\n      const response = await requestGitHub(cursor, input.accept, signal, deps)\n      const payload: unknown = await response.json()\n      if (!Array.isArray(payload)) throw new IngestConfigError(`GitHub ${input.path} response is not an array.`)\n      const items = payload.map((item: unknown) => requireGitHubObject(item, input.path))\n      const next = nextLink(response.headers.get('link'), cursor)\n      return { items, next }\n    },\n  })\n}\n\n/** An omitted window means complete parent discovery, independent of another stream's progress. */\nexport async function* readIssuePages(context: FetchContext, repo: string, config: GitHubConfig, deps: GitHubClientDeps, window?: TimestampRange) {\n  for await (const page of readGitHubPages(context, { path: `/repos/${repo}/issues`, params: {\n    state: 'all', sort: 'updated', direction: 'asc', ...(window ? { since: window.from.toISOString() } : {}),\n  } }, config, deps)) {\n    const issues = page.items.filter((item) => {\n      githubNumber(item, 'number')\n      if (item.pull_request !== undefined) return false\n      return window === undefined || updatedItems([item], window).length > 0\n    })\n    yield { ...page, items: issues }\n  }\n}\n\n/** GitHub has no since filter for PR metadata: list the current collection in full. */\nexport async function* readPullPages(context: FetchContext, repo: string, config: GitHubConfig, deps: GitHubClientDeps) {\n  for await (const page of readGitHubPages(context, { path: `/repos/${repo}/pulls`, params: { state: 'all', sort: 'updated', direction: 'asc' } }, config, deps)) {\n    for (const pull of page.items) githubNumber(pull, 'number')\n    yield page\n  }\n}\n\n/** Provider data stays intact; repository and parent keys live outside it for warehouse joins. */\nexport function toGitHubRows<T extends GitHubObject>(\n  items: readonly T[], repo: string, identify: (item: T) => string | number,\n  parent?: { issue_number: number } | { pull_number: number },\n): RawRow[] {\n  const number = parent && ('pull_number' in parent ? parent.pull_number : parent.issue_number)\n  return rawRows(items.map((data) => ({ repository: repo, ...parent, data })), ({ data }) =>\n    JSON.stringify([repo, ...(number === undefined ? [] : [number]), identify(data)]))\n}\n\nexport function updatedItems(items: readonly GitHubObject[], window: TimestampRange): GitHubObject[] {\n  return items.filter((item) => {\n    if (typeof item.updated_at !== 'string' || !Number.isFinite(Date.parse(item.updated_at))) throw new IngestConfigError('GitHub object has no valid updated_at.')\n    const updated = Date.parse(item.updated_at)\n    return updated >= window.from.getTime() && updated <= window.to.getTime()\n  })\n}\n\nexport function githubNumber(item: GitHubObject, field: string): number {\n  const value = item[field]\n  if (typeof value !== 'number' || !Number.isSafeInteger(value) || value <= 0) throw new IngestConfigError(`GitHub object has no valid ${field}.`)\n  return value\n}\n\nexport function pullNumber(item: GitHubObject, repo: string): number {\n  if (typeof item.pull_request_url !== 'string') throw new IngestConfigError('GitHub review comment has no pull_request_url.')\n  if (!URL.canParse(item.pull_request_url)) throw new IngestConfigError('GitHub review comment has an invalid pull_request_url.')\n  const url = new URL(item.pull_request_url)\n  const prefix = `/repos/${repo}/pulls/`\n  const value = url.pathname.slice(prefix.length)\n  if (url.origin !== 'https://api.github.com' || !url.pathname.toLowerCase().startsWith(prefix.toLowerCase()) || !/^[1-9]\\d*$/.test(value)) {\n    throw new IngestConfigError('GitHub review comment belongs to an unexpected repository or pull request.')\n  }\n  return githubNumber({ number: Number(value) }, 'number')\n}\n\nexport function requireGitHubObject(value: unknown, label: string): GitHubObject {\n  if (!isGitHubObject(value)) throw new IngestConfigError(`GitHub ${label} is not an object.`)\n  return value\n}\n\n/** paginate wraps each GraphQL page; never nest another executor attempt here. */\nexport async function requestGitHubGraphql(query: string, variables: Record<string, unknown>, signal: AbortSignal, deps: GitHubClientDeps): Promise<GitHubObject> {\n  const response = await deps.fetch('https://api.github.com/graphql', {\n    method: 'POST', headers: { ...authorization(deps), 'Content-Type': 'application/json' },\n    body: JSON.stringify({ query, variables }),\n    signal: AbortSignal.any([signal, AbortSignal.timeout(30_000)]), redirect: 'error',\n  })\n  if (!response.ok) throw await HttpError.fromResponse(response)\n  const body = requireGitHubObject(await response.clone().json(), 'GraphQL response')\n  if (Array.isArray(body.errors) && body.errors.length > 0) {\n    const rateLimited = response.headers.get('x-ratelimit-remaining') === '0' || response.headers.has('retry-after') ||\n      body.errors.some((error: unknown) => isGitHubObject(error) &&\n        (error.type === 'RATE_LIMITED' || (typeof error.message === 'string' && /secondary rate limit/i.test(error.message))))\n    if (rateLimited) throw await HttpError.fromResponse(response)\n    throw new IngestConfigError(`GitHub GraphQL returned errors: ${JSON.stringify(body.errors)}`)\n  }\n  if (body.errors !== undefined && !Array.isArray(body.errors)) throw new IngestConfigError('GitHub GraphQL errors is not an array.')\n  return requireGitHubObject(body.data, 'GraphQL data')\n}\n\n/** REST 403 and GraphQL 200 can both signal rate exhaustion. */\nexport function classifyGitHubError(cause: unknown): ReturnType<ErrorClassifier> {\n  if (cause instanceof SyntaxError) return { kind: 'permanent' }\n  if (!(cause instanceof HttpError) || ![200, 403, 429].includes(cause.status)) return undefined\n  const headers = cause.response.headers\n  const reportedRateLimit = /secondary rate limit/i.test(cause.body) ||\n    (cause.status === 200 && /\"type\"\\s*:\\s*\"RATE_LIMITED\"/.test(cause.body))\n  if (headers.get('x-ratelimit-remaining') !== '0' && !headers.has('retry-after') && !reportedRateLimit) return undefined\n  const resetSeconds = Number(headers.get('x-ratelimit-reset'))\n  const untilReset = Number.isFinite(resetSeconds) && resetSeconds > 0 ? Math.max(0, resetSeconds * 1000 - Date.now()) : undefined\n  return { kind: 'rate_limited', retryAfterMs: cause.retryAfterMs ?? untilReset ?? 60_000 }\n}\n\nasync function requestGitHub(url: string, accept = 'application/vnd.github+json', signal: AbortSignal, deps: GitHubClientDeps): Promise<Response> {\n  const response = await deps.fetch(url, { signal: AbortSignal.any([signal, AbortSignal.timeout(30_000)]), redirect: 'error',\n    headers: { ...authorization(deps), Accept: accept, 'X-GitHub-Api-Version': '2022-11-28' } })\n  if (!response.ok) throw await HttpError.fromResponse(response)\n  return response\n}\n\nfunction authorization(deps: GitHubClientDeps): { Authorization: string } {\n  const token = deps.token()?.trim()\n  if (!token) throw new IngestConfigError('Set GITHUB_TOKEN.')\n  return { Authorization: `Bearer ${token}` }\n}\n\nfunction isGitHubObject(value: unknown): value is GitHubObject {\n  return typeof value === 'object' && value !== null && !Array.isArray(value)\n}\n\nfunction nextLink(header: string | null, current: string): string | undefined {\n  const value = header?.split(',').map((part) => /<([^>]+)>\\s*;.*rel=\"?next\"?/.exec(part)?.[1]).find(Boolean)\n  if (!value) return undefined\n  const next = new URL(value, current)\n  if (next.origin !== 'https://api.github.com') throw new IngestConfigError('GitHub next page has an unexpected origin.')\n  return next.toString()\n}\n"
+    },
+    {
+      "path": "github/pipeline.ts",
+      "type": "registry:file",
+      "target": "src/integrations/github/pipeline.ts",
+      "content": "import { definePipeline, defineStream, IngestConfigError, timestampWindow } from '@chkit/plugin-ingest'\n\nimport { classifyGitHubError, defaultGitHubClientDeps, type GitHubClientDeps } from './client.js'\nimport { githubConfig, type GitHubConfig } from './config.js'\nimport { github_issuesRaw, readIssues } from './sources/issues.js'\nimport { github_issueCommentsRaw, readIssueComments } from './sources/issue-comments.js'\nimport { github_pullRequestsRaw, readPullRequests } from './sources/pull-requests.js'\nimport { github_pullRequestCommentsRaw, readPullRequestComments } from './sources/pull-request-comments.js'\nimport { github_pullRequestReviewCommentsRaw, readPullRequestReviewComments } from './sources/pull-request-review-comments.js'\nimport { github_pullRequestReviewsRaw, readPullRequestReviews } from './sources/pull-request-reviews.js'\nimport { github_pullRequestCommitsRaw, readPullRequestCommits } from './sources/pull-request-commits.js'\nimport { github_stargazersRaw, readStargazers } from './sources/stargazers.js'\n\nexport function createGitHubPipeline(config: GitHubConfig = githubConfig, deps: GitHubClientDeps = defaultGitHubClientDeps) {\n  const source = { ...config, repositories: [...config.repositories], start: new Date(config.start) }\n  if (!Number.isSafeInteger(config.pageSize) || config.pageSize < 1 || config.pageSize > 100) {\n    throw new IngestConfigError('GitHub pageSize must be an integer between 1 and 100.')\n  }\n  if (config.repositories.some((repo) => !/^[A-Za-z0-9_.-]+\\/[A-Za-z0-9_.-]+$/.test(repo))) {\n    throw new IngestConfigError('GitHub repositories must use owner/repository names.')\n  }\n  return definePipeline({\n    id: source.sourceId, tags: ['provider:github'], maxStreams: 1, maxFetches: 1,\n    streams: source.repositories.flatMap((repo) => {\n      const suffix = repo.replace('/', '.')\n      const options = { classifyError: classifyGitHubError, tags: [`repository:${repo}`] }\n      return [\n        defineStream({\n          ...options, id: `${source.sourceId}.issues.${suffix}`, tags: [...options.tags, 'resource:issues'], destination: github_issuesRaw,\n          incremental: timestampWindow({ start: source.start, overlapMs: source.overlapMs }),\n          read: (context) => readIssues(context, repo, source, deps),\n        }),\n        defineStream({\n          ...options, id: `${source.sourceId}.issue_comments.${suffix}`, tags: [...options.tags, 'resource:issue_comments'], destination: github_issueCommentsRaw,\n          incremental: timestampWindow({ start: source.start, overlapMs: source.overlapMs }),\n          read: (context) => readIssueComments(context, repo, source, deps),\n        }),\n        defineStream({\n          ...options, id: `${source.sourceId}.pull_requests.${suffix}`, tags: [...options.tags, 'resource:pull_requests'], destination: github_pullRequestsRaw,\n          read: (context) => readPullRequests(context, repo, source, deps),\n        }),\n        defineStream({\n          ...options, id: `${source.sourceId}.pull_request_comments.${suffix}`, tags: [...options.tags, 'resource:pull_request_comments'], destination: github_pullRequestCommentsRaw,\n          incremental: timestampWindow({ start: source.start, overlapMs: source.overlapMs }),\n          read: (context) => readPullRequestComments(context, repo, source, deps),\n        }),\n        defineStream({\n          ...options, id: `${source.sourceId}.pull_request_review_comments.${suffix}`, tags: [...options.tags, 'resource:pull_request_review_comments'], destination: github_pullRequestReviewCommentsRaw,\n          incremental: timestampWindow({ start: source.start, overlapMs: source.overlapMs }),\n          read: (context) => readPullRequestReviewComments(context, repo, source, deps),\n        }),\n        defineStream({\n          ...options, id: `${source.sourceId}.pull_request_reviews.${suffix}`, tags: [...options.tags, 'resource:pull_request_reviews'], destination: github_pullRequestReviewsRaw,\n          read: (context) => readPullRequestReviews(context, repo, source, deps),\n        }),\n        defineStream({\n          ...options, id: `${source.sourceId}.pull_request_commits.${suffix}`, tags: [...options.tags, 'resource:pull_request_commits'], destination: github_pullRequestCommitsRaw,\n          read: (context) => readPullRequestCommits(context, repo, source, deps),\n        }),\n        defineStream({\n          ...options, id: `${source.sourceId}.stargazers.${suffix}`, tags: [...options.tags, 'resource:stargazers'], destination: github_stargazersRaw,\n          read: (context) => readStargazers(context, repo, source, deps),\n        }),\n      ]\n    }),\n  })\n}\n\nexport const githubPipeline = createGitHubPipeline()\n"
+    },
+    {
+      "path": "github/sources/issues.ts",
+      "type": "registry:file",
+      "target": "src/integrations/github/sources/issues.ts",
+      "content": "import { rawTable, type ReadContext, type TimestampRange, type TimestampWindowState } from '@chkit/plugin-ingest'\n\nimport { githubNumber, readIssuePages, toGitHubRows, type GitHubClientDeps } from '../client.js'\nimport type { GitHubConfig } from '../config.js'\n\nexport const github_issuesRaw = rawTable({ database: 'default', name: 'github_issues_raw' })\n\nexport async function* readIssues(context: ReadContext<TimestampRange, TimestampWindowState>, repo: string, config: GitHubConfig, deps: GitHubClientDeps) {\n  for await (const page of readIssuePages(context, repo, config, deps, context.selection)) {\n    yield { rows: toGitHubRows(page.items, repo, (issue) => githubNumber(issue, 'number')) }\n  }\n}\n"
+    },
+    {
+      "path": "github/sources/stargazers.ts",
+      "type": "registry:file",
+      "target": "src/integrations/github/sources/stargazers.ts",
+      "content": "import { rawTable, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { githubNumber, readGitHubPages, requireGitHubObject, toGitHubRows, type GitHubClientDeps } from '../client.js'\nimport type { GitHubConfig } from '../config.js'\n\nexport const github_stargazersRaw = rawTable({ database: 'default', name: 'github_stargazers_raw' })\n\nexport async function* readStargazers(context: FetchContext, repo: string, config: GitHubConfig, deps: GitHubClientDeps) {\n  for await (const page of readGitHubPages(context, { path: `/repos/${repo}/stargazers`, accept: 'application/vnd.github.star+json' }, config, deps)) {\n    yield { rows: toGitHubRows(page.items, repo, (star) => githubNumber(requireGitHubObject(star.user, 'stargazer user'), 'id')) }\n  }\n}\n"
+    },
+    {
+      "path": "github/sources/issue-comments.ts",
+      "type": "registry:file",
+      "target": "src/integrations/github/sources/issue-comments.ts",
+      "content": "import { rawTable, type ReadContext, type TimestampRange, type TimestampWindowState } from '@chkit/plugin-ingest'\n\nimport { githubNumber, readGitHubPages, readIssuePages, toGitHubRows, updatedItems, type GitHubClientDeps } from '../client.js'\nimport type { GitHubConfig } from '../config.js'\n\nexport const github_issueCommentsRaw = rawTable({ database: 'default', name: 'github_issue_comments_raw' })\n\nexport async function* readIssueComments(context: ReadContext<TimestampRange, TimestampWindowState>, repo: string, config: GitHubConfig, deps: GitHubClientDeps) {\n  // Discover all issue parents: a recent comment need not imply a recent parent update.\n  for await (const issues of readIssuePages(context, repo, config, deps)) {\n    for (const issue of issues.items) {\n      const number = githubNumber(issue, 'number')\n      for await (const page of readGitHubPages(context, { path: `/repos/${repo}/issues/${number}/comments`, params: { since: context.selection.from.toISOString() } }, config, deps)) {\n        yield { rows: toGitHubRows(updatedItems(page.items, context.selection), repo, (comment) => githubNumber(comment, 'id'), { issue_number: number }) }\n      }\n    }\n  }\n}\n"
+    },
+    {
+      "path": "github/sources/pull-requests.ts",
+      "type": "registry:file",
+      "target": "src/integrations/github/sources/pull-requests.ts",
+      "content": "import { rawTable, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { githubNumber, readPullPages, toGitHubRows, type GitHubClientDeps } from '../client.js'\nimport type { GitHubConfig } from '../config.js'\n\nexport const github_pullRequestsRaw = rawTable({ database: 'default', name: 'github_pull_requests_raw' })\n\nexport async function* readPullRequests(context: FetchContext, repo: string, config: GitHubConfig, deps: GitHubClientDeps) {\n  for await (const page of readPullPages(context, repo, config, deps)) {\n    yield { rows: toGitHubRows(page.items, repo, (pull) => githubNumber(pull, 'number')) }\n  }\n}\n"
+    },
+    {
+      "path": "github/sources/pull-request-comments.ts",
+      "type": "registry:file",
+      "target": "src/integrations/github/sources/pull-request-comments.ts",
+      "content": "import { rawTable, type ReadContext, type TimestampRange, type TimestampWindowState } from '@chkit/plugin-ingest'\n\nimport { githubNumber, readGitHubPages, readPullPages, toGitHubRows, updatedItems, type GitHubClientDeps } from '../client.js'\nimport type { GitHubConfig } from '../config.js'\n\nexport const github_pullRequestCommentsRaw = rawTable({ database: 'default', name: 'github_pull_request_comments_raw' })\n\nexport async function* readPullRequestComments(context: ReadContext<TimestampRange, TimestampWindowState>, repo: string, config: GitHubConfig, deps: GitHubClientDeps) {\n  // This reader owns its discovery and window; the PR metadata stream need not have run.\n  for await (const pulls of readPullPages(context, repo, config, deps)) {\n    for (const pull of pulls.items) {\n      const number = githubNumber(pull, 'number')\n      for await (const page of readGitHubPages(context, { path: `/repos/${repo}/issues/${number}/comments`, params: { since: context.selection.from.toISOString() } }, config, deps)) {\n        yield { rows: toGitHubRows(updatedItems(page.items, context.selection), repo, (comment) => githubNumber(comment, 'id'), { pull_number: number }) }\n      }\n    }\n  }\n}\n"
+    },
+    {
+      "path": "github/sources/pull-request-review-comments.ts",
+      "type": "registry:file",
+      "target": "src/integrations/github/sources/pull-request-review-comments.ts",
+      "content": "import { rawTable, type ReadContext, type TimestampRange, type TimestampWindowState } from '@chkit/plugin-ingest'\n\nimport { githubNumber, pullNumber, readGitHubPages, toGitHubRows, updatedItems, type GitHubClientDeps } from '../client.js'\nimport type { GitHubConfig } from '../config.js'\n\nexport const github_pullRequestReviewCommentsRaw = rawTable({ database: 'default', name: 'github_pull_request_review_comments_raw' })\n\nexport async function* readPullRequestReviewComments(context: ReadContext<TimestampRange, TimestampWindowState>, repo: string, config: GitHubConfig, deps: GitHubClientDeps) {\n  for await (const page of readGitHubPages(context, { path: `/repos/${repo}/pulls/comments`, params: {\n    since: context.selection.from.toISOString(), sort: 'updated', direction: 'asc',\n  } }, config, deps)) {\n    for (const comment of updatedItems(page.items, context.selection)) {\n      yield { rows: toGitHubRows([comment], repo, (item) => githubNumber(item, 'id'), { pull_number: pullNumber(comment, repo) }) }\n    }\n  }\n}\n"
+    },
+    {
+      "path": "github/sources/pull-request-reviews.ts",
+      "type": "registry:file",
+      "target": "src/integrations/github/sources/pull-request-reviews.ts",
+      "content": "import { rawTable, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { githubNumber, readGitHubPages, readPullPages, toGitHubRows, type GitHubClientDeps } from '../client.js'\nimport type { GitHubConfig } from '../config.js'\n\nexport const github_pullRequestReviewsRaw = rawTable({ database: 'default', name: 'github_pull_request_reviews_raw' })\n\nexport async function* readPullRequestReviews(context: FetchContext, repo: string, config: GitHubConfig, deps: GitHubClientDeps) {\n  for await (const pulls of readPullPages(context, repo, config, deps)) {\n    for (const pull of pulls.items) {\n      const number = githubNumber(pull, 'number')\n      for await (const page of readGitHubPages(context, { path: `/repos/${repo}/pulls/${number}/reviews` }, config, deps)) {\n        yield { rows: toGitHubRows(page.items, repo, (review) => githubNumber(review, 'id'), { pull_number: number }) }\n      }\n    }\n  }\n}\n"
+    },
+    {
+      "path": "github/sources/pull-request-commits.ts",
+      "type": "registry:file",
+      "target": "src/integrations/github/sources/pull-request-commits.ts",
+      "content": "import { IngestConfigError, paginate, rawTable, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { githubNumber, readPullPages, requestGitHubGraphql, requireGitHubObject, toGitHubRows, type GitHubClientDeps } from '../client.js'\nimport type { GitHubConfig } from '../config.js'\n\nexport const github_pullRequestCommitsRaw = rawTable({ database: 'default', name: 'github_pull_request_commits_raw' })\n\n// The REST PR commits endpoint caps results at 250. Request only the two desired fields through GraphQL.\nconst commitsQuery = `query PullRequestCommits($owner: String!, $repo: String!, $number: Int!, $first: Int!, $after: String) {\n  repository(owner: $owner, name: $repo) {\n    pullRequest(number: $number) {\n      commits(first: $first, after: $after) {\n        totalCount\n        nodes { commit { oid message } }\n        pageInfo { hasNextPage endCursor }\n      }\n    }\n  }\n}`\n\nexport async function* readPullRequestCommits(context: FetchContext, repo: string, config: GitHubConfig, deps: GitHubClientDeps) {\n  const [owner, name] = repo.split('/')\n  for await (const pulls of readPullPages(context, repo, config, deps)) {\n    for (const pull of pulls.items) {\n      const number = githubNumber(pull, 'number')\n      let expectedCount: number | undefined\n      const seenShas = new Set<string>()\n      const pages = paginate<{ sha: string; message: string }, string>({\n        context, label: `POST /graphql PR ${repo}#${number} commits`,\n        fetchPage: async (after, signal) => {\n          const data = await requestGitHubGraphql(commitsQuery, { owner, repo: name, number, first: config.pageSize, after: after ?? null }, signal, deps)\n          const repository = requireGitHubObject(data.repository, 'GraphQL repository')\n          const parent = requireGitHubObject(repository.pullRequest, 'GraphQL pull request')\n          const connection = requireGitHubObject(parent.commits, 'GraphQL commits connection')\n          const total = connection.totalCount\n          if (typeof total !== 'number' || !Number.isSafeInteger(total) || total < 0) throw new IngestConfigError('GitHub commits have no valid totalCount.')\n          if (expectedCount !== undefined && total !== expectedCount) throw new IngestConfigError('GitHub PR commit count changed during pagination; replay this stream.')\n          if (!Array.isArray(connection.nodes)) throw new IngestConfigError('GitHub commits nodes is not an array.')\n          const items = connection.nodes.map((node: unknown) => {\n            const commit = requireGitHubObject(requireGitHubObject(node, 'GraphQL commit node').commit, 'GraphQL commit')\n            if (typeof commit.oid !== 'string' || !commit.oid.trim() || typeof commit.message !== 'string') throw new IngestConfigError('GitHub commit has no SHA or message.')\n            return { sha: commit.oid, message: commit.message }\n          })\n          const pageInfo = requireGitHubObject(connection.pageInfo, 'GraphQL commit pageInfo')\n          if (typeof pageInfo.hasNextPage !== 'boolean') throw new IngestConfigError('GitHub commits have no hasNextPage flag.')\n          if (pageInfo.hasNextPage && (typeof pageInfo.endCursor !== 'string' || !pageInfo.endCursor.trim())) throw new IngestConfigError('GitHub commits have no continuation cursor.')\n          const next = pageInfo.hasNextPage && typeof pageInfo.endCursor === 'string' ? pageInfo.endCursor : undefined\n          const pageShas = new Set<string>()\n          for (const commit of items) {\n            if (seenShas.has(commit.sha) || pageShas.has(commit.sha)) throw new IngestConfigError('GitHub PR commits repeated a SHA; replay this stream.')\n            pageShas.add(commit.sha)\n          }\n          const count = seenShas.size + pageShas.size\n          if (count > total || (next === undefined && count !== total)) throw new IngestConfigError('GitHub PR commits ended without the advertised complete collection.')\n          expectedCount = total\n          for (const sha of pageShas) seenShas.add(sha)\n          return { items, next }\n        },\n      })\n      for await (const page of pages) {\n        yield { rows: toGitHubRows(page.items, repo, (commit) => commit.sha, { pull_number: number }) }\n      }\n    }\n  }\n}\n"
+    },
+    {
+      "path": "github/tests/basic.test.ts",
+      "type": "registry:file",
+      "target": "src/integrations/github/tests/basic.test.ts",
+      "role": "test",
+      "content": "import { expect, test } from 'bun:test'\nimport { HttpError, IngestConfigError, runIngestion, selectStreams, type FetchContext, type Page } from '@chkit/plugin-ingest'\nimport { createMemoryDestination, createMemoryJournal } from '@chkit/plugin-ingest/testing'\n\nimport { createGitHubPipeline, githubPipeline } from '../index.js'\nimport { githubConfig, type GitHubConfig } from '../config.js'\nimport { classifyGitHubError, readIssuePages, requestGitHubGraphql, type GitHubObject } from '../client.js'\n\nconst repository = 'obsessiondb/chkit'\nconst cutoff = new Date('2026-01-02T00:00:00Z')\nconst resources = ['issues', 'issue_comments', 'pull_requests', 'pull_request_comments', 'pull_request_review_comments', 'pull_request_reviews', 'pull_request_commits', 'stargazers']\nconst issue = { number: 1, id: 1001, title: 'Issue', updated_at: '2026-01-01T12:00:00Z', labels: [{ name: 'bug' }] }\nconst pull = { number: 2, id: 1002, title: 'Pull request', state: 'closed', updated_at: '2026-01-01T12:00:00Z', merged_at: '2026-01-01T00:00:00Z' }\nconst pullIssue = { ...pull, pull_request: { url: `https://api.github.com/repos/${repository}/pulls/2` } }\nconst issueComment = { id: 101, body: 'Issue discussion', updated_at: issue.updated_at, custom: ['retained'] }\nconst pullComment = { id: 201, body: 'Pull request discussion', updated_at: issue.updated_at }\nconst reviewComment = { id: 301, body: 'Review discussion', updated_at: issue.updated_at, pull_request_url: `https://api.github.com/repos/${repository}/pulls/2` }\nconst review = { id: 401, body: 'Review', state: 'APPROVED', submitted_at: '2020-01-01T00:00:00Z' }\nconst commit = { sha: '0123456789012345678901234567890123456789', message: 'Subject\\n\\nFull commit message\\nwith another line.' }\nconst stargazer = { starred_at: '2026-01-01T00:00:00Z', user: { id: 501, login: 'example' }, custom: true }\n\ntype Responder = (url: URL, init: RequestInit) => Response | Promise<Response>\ntype Pipeline = ReturnType<typeof createGitHubPipeline>\n\ntest('GitHub resource streams retain flat provider payloads and parent join identities', async () => {\n  const requests: URL[] = []\n  const pipeline = fixturePipeline((url, init) => { requests.push(url); return fixtureResponse(url, init) })\n  expect(pipeline.streams.map((stream) => stream.id).sort()).toEqual(resources.map((resource) => `github.${resource}.obsessiondb.chkit`).sort())\n  expect(githubPipeline.streams).toHaveLength(8)\n  const destination = createMemoryDestination(), journal = createMemoryJournal()\n  const result = await runIngestion(request(pipeline), { journal, destination, now: () => cutoff })\n  expect(result.ok, JSON.stringify(result)).toBe(true)\n  const expected: Record<string, { id: string; raw: unknown }> = {\n    issues: { id: JSON.stringify([repository, 1]), raw: { repository, data: issue } },\n    issue_comments: { id: JSON.stringify([repository, 1, 101]), raw: { repository, issue_number: 1, data: issueComment } },\n    pull_requests: { id: JSON.stringify([repository, 2]), raw: { repository, data: pull } },\n    pull_request_comments: { id: JSON.stringify([repository, 2, 201]), raw: { repository, pull_number: 2, data: pullComment } },\n    pull_request_review_comments: { id: JSON.stringify([repository, 2, 301]), raw: { repository, pull_number: 2, data: reviewComment } },\n    pull_request_reviews: { id: JSON.stringify([repository, 2, 401]), raw: { repository, pull_number: 2, data: review } },\n    pull_request_commits: { id: JSON.stringify([repository, 2, commit.sha]), raw: { repository, pull_number: 2, data: commit } },\n    stargazers: { id: JSON.stringify([repository, 501]), raw: { repository, data: stargazer } },\n  }\n  for (const [resource, expectedRow] of Object.entries(expected)) {\n    expect(destination.tables.get(`default.github_${resource}_raw`)?.map(({ id, raw }) => ({ id, raw }))).toEqual([expectedRow])\n  }\n  expect(requests.some((url) => url.pathname.endsWith('/files') || /\\/pulls\\/\\d+\\/commits$/.test(url.pathname))).toBe(false)\n  expect((await journal.readCheckpoint('github.issues.obsessiondb.chkit')).envelope?.state).toEqual({ watermark: cutoff.toISOString() })\n})\n\ntest('every resource runs alone and reversing stream order preserves the same observations', async () => {\n  const pipeline = fixturePipeline()\n  const combined = createMemoryDestination()\n  const reversed = { ...pipeline, streams: [...pipeline.streams].reverse() }\n  expect((await runIngestion(request(reversed), { journal: createMemoryJournal(), destination: combined, now: () => cutoff })).ok).toBe(true)\n  for (const resource of resources) {\n    const destination = createMemoryDestination()\n    const selected = request(pipeline, resource)\n    expect(selected.selected.map((entry) => entry.stream.id)).toEqual([`github.${resource}.obsessiondb.chkit`])\n    const result = await runIngestion(selected, { journal: createMemoryJournal(), destination, now: () => cutoff })\n    expect(result.ok, `${resource}: ${JSON.stringify(result)}`).toBe(true)\n    expect(destination.tables.size).toBe(1)\n    expect(destination.tables.get(`default.github_${resource}_raw`)?.map(({ id, raw }) => ({ id, raw })))\n      .toEqual(combined.tables.get(`default.github_${resource}_raw`)?.map(({ id, raw }) => ({ id, raw })))\n  }\n})\n\ntest('selecting parents requests no children and separates issue and pull request responses', async () => {\n  for (const resource of ['issues', 'pull_requests']) {\n    const requests: URL[] = []\n    const pipeline = fixturePipeline((url, init) => { requests.push(url); return fixtureResponse(url, init) })\n    const destination = createMemoryDestination()\n    expect((await runIngestion(request(pipeline, resource), { journal: createMemoryJournal(), destination, now: () => cutoff })).ok).toBe(true)\n    expect(requests.map((url) => url.pathname)).toEqual([`/repos/${repository}/${resource === 'issues' ? 'issues' : 'pulls'}`])\n    expect(requests[0]?.searchParams.get('state')).toBe('all')\n    expect(requests[0]?.searchParams.get('sort')).toBe('updated')\n    expect(requests[0]?.searchParams.get('direction')).toBe('asc')\n    expect(requests[0]?.searchParams.has('since')).toBe(resource === 'issues')\n    expect(destination.tables.get(`default.github_${resource}_raw`)?.map((row) => row.raw)).toEqual([{ repository, data: resource === 'issues' ? issue : pull }])\n  }\n})\n\ntest('short issue pages follow Link continuations while excluding PRs and updates beyond the cutoff', async () => {\n  const requests: URL[] = []\n  const nextIssue = { ...issue, number: 3, id: 1003 }\n  const futureIssue = { ...issue, number: 4, updated_at: '2026-01-03T00:00:00Z' }\n  const pipeline = fixturePipeline((url) => {\n    requests.push(url)\n    if (url.searchParams.has('page')) return Response.json([pullIssue, nextIssue, futureIssue])\n    return Response.json([issue], { headers: { Link: `<${url}&page=2>; rel=\"next\"` } })\n  })\n  const destination = createMemoryDestination(), journal = createMemoryJournal()\n  const result = await runIngestion(request(pipeline, 'issues'), { journal, destination, now: () => cutoff })\n  expect(result.ok).toBe(true)\n  expect(requests).toHaveLength(2)\n  expect(requests.every((url) => url.searchParams.get('since') === '2008-01-01T00:00:00.000Z')).toBe(true)\n  expect(destination.tables.get('default.github_issues_raw')?.map((row) => row.raw)).toEqual([{ repository, data: issue }, { repository, data: nextIssue }])\n  expect((await journal.readCheckpoint('github.issues.obsessiondb.chkit')).envelope?.state).toEqual({ watermark: cutoff.toISOString() })\n})\n\ntest('issue page filtering preserves continuations and empty terminal pages', async () => {\n  const signal = new AbortController().signal\n  const context: FetchContext = { signal, attempt: (operation) => operation(signal) }\n  const pages: Page<GitHubObject, string>[] = []\n  const requests: URL[] = []\n  for await (const page of readIssuePages(context, repository, githubConfig, {\n    token: () => 'fixture', fetch: async (input) => {\n      const url = new URL(input)\n      requests.push(url)\n      const number = Number(url.searchParams.get('page') ?? '1')\n      const next = new URL(url)\n      next.searchParams.set('page', String(number + 1))\n      return Response.json(number === 1 ? [pullIssue] : number === 2 ? [issue] : [],\n        { headers: number < 3 ? { Link: `<${next}>; rel=\"next\"` } : {} })\n    },\n  })) pages.push(page)\n  expect(requests).toHaveLength(3)\n  expect(pages.map((page) => page.items)).toEqual([[], [issue], []])\n  expect(pages.map((page) => page.next)).toEqual([requests[1]?.toString(), requests[2]?.toString(), undefined])\n})\n\ntest('a failed child stream does not block its parents or the other resource checkpoints', async () => {\n  const pipeline = fixturePipeline((url, init) => url.pathname.endsWith('/issues/1/comments')\n    ? new Response('denied', { status: 403 }) : fixtureResponse(url, init))\n  const destination = createMemoryDestination(), journal = createMemoryJournal()\n  const result = await runIngestion(request(pipeline), { journal, destination, now: () => cutoff })\n  expect(result.ok).toBe(false)\n  expect(result.streams.filter((stream) => stream.outcome === 'failed').map((stream) => stream.streamId)).toEqual(['github.issue_comments.obsessiondb.chkit'])\n  expect(result.streams.filter((stream) => stream.outcome === 'succeeded')).toHaveLength(7)\n  expect(destination.tables.has('default.github_issues_raw')).toBe(true)\n  expect(destination.tables.has('default.github_pull_requests_raw')).toBe(true)\n  expect((await journal.readCheckpoint('github.issue_comments.obsessiondb.chkit')).envelope).toBeUndefined()\n  for (const resource of ['issues', 'pull_request_comments', 'pull_request_review_comments']) {\n    expect((await journal.readCheckpoint(`github.${resource}.obsessiondb.chkit`)).envelope?.state).toEqual({ watermark: cutoff.toISOString() })\n  }\n  expect((await journal.readCheckpoint('github.pull_requests.obsessiondb.chkit')).lastSuccessSeq).toBeGreaterThan(0)\n})\n\ntest('comment streams capture edits on old parents using their own overlapping since windows', async () => {\n  const oldIssue = { ...issue, number: 3, updated_at: '2020-01-01T00:00:00Z' }\n  const oldPull = { ...pull, number: 4, updated_at: '2020-01-01T00:00:00Z' }\n  for (const resource of ['issue_comments', 'pull_request_comments', 'pull_request_review_comments']) {\n    let edited = false\n    const requests: URL[] = []\n    const pipeline = fixturePipeline((url) => {\n      requests.push(url)\n      if (url.pathname.endsWith('/issues')) return Response.json([oldIssue, { ...oldPull, pull_request: pullIssue.pull_request }])\n      if (url.pathname.endsWith('/pulls')) return Response.json([oldPull])\n      const comment = resource === 'issue_comments' ? issueComment : resource === 'pull_request_comments' ? pullComment : reviewComment\n      const data = { ...comment, body: edited ? 'Edited old discussion' : 'Original discussion', updated_at: edited ? '2026-01-02T12:00:00Z' : '2026-01-01T12:00:00Z',\n        ...(resource === 'pull_request_review_comments' ? { pull_request_url: `https://api.github.com/repos/${repository}/pulls/4` } : {}) }\n      return Response.json([data, { ...data, id: 999, updated_at: '2026-01-04T00:00:00Z' }])\n    })\n    const journal = createMemoryJournal(), destination = createMemoryDestination()\n    expect((await runIngestion(request(pipeline, resource), { journal, destination, now: () => cutoff })).ok).toBe(true)\n    edited = true\n    expect((await runIngestion(request(pipeline, resource), { journal, destination, now: () => new Date('2026-01-03') })).ok).toBe(true)\n    const children = requests.filter((url) => url.pathname.endsWith('/comments'))\n    expect(children.map((url) => url.searchParams.get('since'))).toEqual(['2008-01-01T00:00:00.000Z', '2026-01-01T23:55:00.000Z'])\n    expect(requests.filter((url) => url.pathname.endsWith('/issues') || url.pathname.endsWith('/pulls')).every((url) => !url.searchParams.has('since'))).toBe(true)\n    const rows = destination.tables.get(`default.github_${resource}_raw`) ?? []\n    expect(rows).toHaveLength(2)\n    expect(new Set(rows.map((row) => row.id)).size).toBe(1)\n    expect(rows.at(-1)?.raw).toMatchObject({ repository, data: { body: 'Edited old discussion' } })\n    expect((await journal.readCheckpoint(`github.${resource}.obsessiondb.chkit`)).envelope?.state).toEqual({ watermark: '2026-01-03T00:00:00.000Z' })\n  }\n})\n\ntest('a rejected child write cannot advance its timestamp watermark and the next run replays the window', async () => {\n  const starts: string[] = []\n  const pipeline = fixturePipeline((url, init) => {\n    if (url.pathname.endsWith('/comments')) starts.push(url.searchParams.get('since') ?? '')\n    return fixtureResponse(url, init)\n  })\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  const selected = request(pipeline, 'issue_comments')\n  const failed = await runIngestion(selected, { journal, destination: { insert: async () => { throw new IngestConfigError('sink rejected') } }, now: () => cutoff })\n  expect(failed.ok).toBe(false)\n  expect((await journal.readCheckpoint('github.issue_comments.obsessiondb.chkit')).envelope).toBeUndefined()\n  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect(starts).toEqual(['2008-01-01T00:00:00.000Z', '2008-01-01T00:00:00.000Z'])\n  expect(destination.tables.get('default.github_issue_comments_raw')).toHaveLength(1)\n})\n\ntest('empty resource runs complete independently and full readers scan again without provider state', async () => {\n  const calls: string[] = []\n  const pipeline = fixturePipeline((url) => { calls.push(url.pathname); return Response.json([]) })\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  for (const now of [cutoff, new Date('2026-01-03')]) expect((await runIngestion(request(pipeline), { journal, destination, now: () => now })).ok).toBe(true)\n  expect(destination.tables.size).toBe(0)\n  for (const resource of ['pull_requests', 'pull_request_reviews', 'pull_request_commits', 'stargazers']) {\n    const checkpoint = await journal.readCheckpoint(`github.${resource}.obsessiondb.chkit`)\n    expect(checkpoint.envelope).toBeUndefined()\n    expect(checkpoint.lastSuccessSeq).toBeGreaterThan(0)\n    expect(journal.events.filter((event) => event.namespaceId === `github.${resource}.obsessiondb.chkit` && event.eventKind === 'work_finished' && event.workState === 'succeeded')).toHaveLength(2)\n  }\n  expect(calls.filter((path) => path.endsWith('/stargazers'))).toHaveLength(2)\n  expect((await journal.readCheckpoint('github.issue_comments.obsessiondb.chkit')).envelope?.state).toEqual({ watermark: '2026-01-03T00:00:00.000Z' })\n})\n\ntest('stargazer full sync replays from its first page after page or destination failures before completing', async () => {\n  let failSecondPage = true\n  const starts: string[] = []\n  const second = { ...stargazer, user: { id: 502, login: 'another-example' } }\n  const pipeline = fixturePipeline((url) => {\n    if (url.searchParams.get('page') === '2') return failSecondPage ? new Response('denied', { status: 403 }) : Response.json([second])\n    starts.push(url.search)\n    return Response.json([stargazer], { headers: { Link: `<${url}&page=2>; rel=\"next\"` } })\n  })\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  const selected = request(pipeline, 'stargazers')\n  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(false)\n  expect((await journal.readCheckpoint('github.stargazers.obsessiondb.chkit')).lastSuccessSeq).toBe(0)\n  expect((await journal.readCheckpoint('github.stargazers.obsessiondb.chkit')).envelope).toBeUndefined()\n  failSecondPage = false\n  const rejected = await runIngestion(selected, { journal, now: () => cutoff,\n    destination: { insert: async () => { throw new IngestConfigError('sink rejected') } } })\n  expect(rejected.ok).toBe(false)\n  expect((await journal.readCheckpoint('github.stargazers.obsessiondb.chkit')).lastSuccessSeq).toBe(0)\n  expect((await journal.readCheckpoint('github.stargazers.obsessiondb.chkit')).envelope).toBeUndefined()\n  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(true)\n  const completed = await journal.readCheckpoint('github.stargazers.obsessiondb.chkit')\n  expect(completed.lastSuccessSeq).toBeGreaterThan(0)\n  expect(completed.envelope).toBeUndefined()\n  expect(starts).toEqual(Array(3).fill('?per_page=100'))\n  expect(destination.tables.get('default.github_stargazers_raw')?.map(({ id, raw }) => ({ id, raw }))).toEqual([\n    { id: JSON.stringify([repository, 501]), raw: { repository, data: stargazer } },\n    { id: JSON.stringify([repository, 502]), raw: { repository, data: second } },\n  ])\n})\n\ntest('GraphQL commits collect more than 250 entries and retain only SHA and the full multiline message', async () => {\n  const commits = Array.from({ length: 275 }, (_, index) => ({ sha: (index + 1).toString(16).padStart(40, '0'), message: `Subject ${index}\\n\\nFull body ${index}\\nLast line.` }))\n  const afters: unknown[] = [], requests: URL[] = []\n  const pipeline = fixturePipeline((url, init) => {\n    requests.push(url)\n    if (url.pathname !== '/graphql') return fixtureResponse(url, init)\n    expect(init.method).toBe('POST')\n    const body = JSON.parse(String(init.body))\n    const after = body.variables.after ?? null\n    afters.push(after)\n    const offset = after === 'page-100' ? 100 : after === 'page-200' ? 200 : 0\n    const items = commits.slice(offset, offset + 100)\n    return commitPage(items, commits.length, offset + items.length < commits.length ? `page-${offset + items.length}` : null)\n  })\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  expect((await runIngestion(request(pipeline, 'pull_request_commits'), { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect(afters).toEqual([null, 'page-100', 'page-200'])\n  const rows = destination.tables.get('default.github_pull_request_commits_raw') ?? []\n  expect(rows).toHaveLength(275)\n  expect(rows.map((row) => row.raw)).toEqual(commits.map((data) => ({ repository, pull_number: 2, data })))\n  expect(rows.at(-1)?.id).toBe(JSON.stringify([repository, 2, commits.at(-1)?.sha]))\n  expect(requests.filter((url) => url.pathname !== '/graphql').map((url) => url.pathname)).toEqual([`/repos/${repository}/pulls`])\n  expect((await journal.readCheckpoint('github.pull_request_commits.obsessiondb.chkit')).envelope).toBeUndefined()\n  expect((await journal.readCheckpoint('github.pull_request_commits.obsessiondb.chkit')).lastSuccessSeq).toBeGreaterThan(0)\n})\n\ntest('GraphQL commit totals reject truncated collections and changes during pagination', async () => {\n  for (const changed of [false, true]) {\n    let calls = 0\n    const pipeline = fixturePipeline((url, init) => {\n      if (url.pathname !== '/graphql') return fixtureResponse(url, init)\n      calls++\n      return commitPage([{ ...commit, sha: String(calls).padStart(40, '0') }], changed && calls === 2 ? 3 : 2, changed && calls === 1 ? 'next' : null)\n    })\n    const journal = createMemoryJournal()\n    const result = await runIngestion(request(pipeline, 'pull_request_commits'), { journal, destination: createMemoryDestination(), now: () => cutoff })\n    expect(result.ok).toBe(false)\n    expect(calls).toBe(changed ? 2 : 1)\n    expect((await journal.readCheckpoint('github.pull_request_commits.obsessiondb.chkit')).lastSuccessSeq).toBe(0)\n  }\n})\n\ntest('GraphQL commits validate complete counts on empty terminal pages', async () => {\n  for (const total of [0, 1, 2]) {\n    let calls = 0\n    const pipeline = fixturePipeline((url, init) => {\n      if (url.pathname !== '/graphql') return fixtureResponse(url, init)\n      calls++\n      return commitPage(total > 0 && calls === 1 ? [commit] : [], total, total > 0 && calls === 1 ? 'terminal' : null)\n    })\n    const journal = createMemoryJournal(), destination = createMemoryDestination()\n    const result = await runIngestion(request(pipeline, 'pull_request_commits'), { journal, destination, now: () => cutoff })\n    expect(result.ok).toBe(total < 2)\n    expect(calls).toBe(total === 0 ? 1 : 2)\n    expect((await journal.readCheckpoint('github.pull_request_commits.obsessiondb.chkit')).lastSuccessSeq > 0).toBe(total < 2)\n    if (total < 2) expect(destination.tables.get('default.github_pull_request_commits_raw') ?? []).toHaveLength(total)\n  }\n})\n\ntest('GraphQL commit pagination rejects duplicate SHAs within or across pages despite a matching total', async () => {\n  for (const acrossPages of [true, false]) {\n    let calls = 0\n    const pipeline = fixturePipeline((url, init) => {\n      if (url.pathname !== '/graphql') return fixtureResponse(url, init)\n      calls++\n      return acrossPages ? commitPage([commit], 2, calls === 1 ? 'next' : null) : commitPage([commit, commit], 2, null)\n    })\n    const journal = createMemoryJournal()\n    const result = await runIngestion(request(pipeline, 'pull_request_commits'), { journal, destination: createMemoryDestination(), now: () => cutoff })\n    expect(result.ok).toBe(false)\n    expect(calls).toBe(acrossPages ? 2 : 1)\n    expect((await journal.readCheckpoint('github.pull_request_commits.obsessiondb.chkit')).lastSuccessSeq).toBe(0)\n  }\n})\n\ntest('GitHub binds configuration and preserves independently selected installation and repository progress', async () => {\n  const requests: URL[] = []\n  const config = { ...githubConfig, sourceId: 'github.fixture', repositories: ['first/repo', 'second/repo'], pageSize: 25, start: new Date('2025-01-01'), overlapMs: 60_000 }\n  const pipeline = createGitHubPipeline(config, { token: () => 'bound-token', fetch: async (input, init) => {\n    const url = new URL(input)\n    requests.push(url)\n    expect(new Headers(init.headers).get('authorization')).toBe('Bearer bound-token')\n    expect(url.searchParams.get('per_page')).toBe('25')\n    return Response.json([])\n  } })\n  config.pageSize = 100\n  config.repositories.push('third/repo')\n  config.start.setUTCFullYear(2000)\n  config.overlapMs = 3_600_000\n  expect(pipeline.streams.map((stream) => stream.id).sort()).toEqual(['first.repo', 'second.repo'].flatMap((repo) => resources.map((resource) => `github.fixture.${resource}.${repo}`)).sort())\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  expect((await runIngestion(request(pipeline), { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect(requests.filter((url) => url.searchParams.has('since')).every((url) => url.searchParams.get('since') === '2025-01-01T00:00:00.000Z')).toBe(true)\n  requests.length = 0\n  const selected = selectStreams([pipeline], ['repository:second/repo', 'resource:issues'])\n  expect(selected.map((entry) => entry.stream.id)).toEqual(['github.fixture.issues.second.repo'])\n  expect((await runIngestion({ selected, backfill: undefined }, { journal, destination, now: () => new Date('2026-01-03') })).ok).toBe(true)\n  expect(requests.map((url) => url.pathname)).toEqual(['/repos/second/repo/issues'])\n  expect(requests[0]?.searchParams.get('since')).toBe('2026-01-01T23:59:00.000Z')\n  expect((await journal.readCheckpoint('github.issues.obsessiondb.chkit')).envelope).toBeUndefined()\n})\n\ntest('GitHub paginated HTTP rate limits consume exactly one request retry budget', async () => {\n  let attempts = 0\n  const pipeline = fixturePipeline(() => ++attempts === 1\n    ? new Response('rate limited', { status: 403, headers: { 'x-ratelimit-remaining': '0', 'retry-after': '0' } }) : Response.json([]))\n  const selected = request(pipeline, 'stargazers').selected.map((entry) => ({ ...entry, stream: { ...entry.stream, retry: { retries: 1, minTimeout: 0, maxTimeout: 0 } } }))\n  const journal = createMemoryJournal()\n  expect((await runIngestion({ selected, backfill: undefined }, { journal, destination: createMemoryDestination(), now: () => cutoff })).ok).toBe(true)\n  expect(attempts).toBe(2)\n  expect(journal.events.filter((event) => event.eventKind === 'retry_scheduled' && event.errorClass === 'rate_limited')).toHaveLength(1)\n})\n\ntest('GraphQL HTTP200 rate errors honor Retry-After while partial data fails permanently', async () => {\n  for (const retryable of [true, false]) {\n    let attempts = 0\n    const pipeline = fixturePipeline((url, init) => {\n      if (url.pathname !== '/graphql') return fixtureResponse(url, init)\n      attempts++\n      if (retryable && attempts > 1) return commitPage([commit], 1, null)\n      return Response.json({ data: { repository: null }, errors: [{ type: retryable ? 'RATE_LIMITED' : 'NOT_FOUND', message: 'query rejected' }] },\n        { headers: retryable ? { 'Retry-After': '0', 'x-ratelimit-remaining': '0' } : {} })\n    })\n    const selected = request(pipeline, 'pull_request_commits').selected.map((entry) => ({ ...entry, stream: { ...entry.stream, retry: { retries: 1, minTimeout: 0, maxTimeout: 0 } } }))\n    const journal = createMemoryJournal()\n    const result = await runIngestion({ selected, backfill: undefined }, { journal, destination: createMemoryDestination(), now: () => cutoff })\n    expect(result.ok).toBe(retryable)\n    expect(attempts).toBe(retryable ? 2 : 1)\n    expect(journal.events.filter((event) => event.eventKind === 'retry_scheduled')).toHaveLength(retryable ? 1 : 0)\n  }\n})\n\ntest('secondary REST rate limits and headerless GraphQL rate errors retain provider diagnostics', async () => {\n  const rest = await HttpError.fromResponse(Response.json({ message: 'You have exceeded a secondary rate limit.' },\n    { status: 403, headers: { 'x-ratelimit-remaining': '19' } }))\n  expect(rest.status).toBe(403)\n  expect(rest.body).toContain('secondary rate limit')\n  expect(classifyGitHubError(rest)).toEqual({ kind: 'rate_limited', retryAfterMs: 60_000 })\n  const payload = { data: { repository: null }, errors: [{ type: 'RATE_LIMITED', message: 'API rate limit exceeded' }] }\n  const failure: unknown = await requestGitHubGraphql('query { viewer { login } }', {}, new AbortController().signal,\n    { token: () => 'fixture', fetch: async () => Response.json(payload) }).catch((cause: unknown) => cause)\n  expect(failure).toBeInstanceOf(HttpError)\n  expect(failure).toMatchObject({ status: 200, body: JSON.stringify(payload) })\n  expect(classifyGitHubError(failure)).toEqual({ kind: 'rate_limited', retryAfterMs: 60_000 })\n})\n\ntest('invalid REST continuations and payloads fail without completing or replaying the resource', async () => {\n  for (const mode of ['repeated', 'foreign', 'malformed']) {\n    let calls = 0\n    const pipeline = fixturePipeline((url) => {\n      calls++\n      return mode === 'malformed' ? Response.json({ not: 'an array' })\n        : Response.json([stargazer], { headers: { Link: `<${mode === 'foreign' ? 'https://example.com/steal' : url.toString()}>; rel=\"next\"` } })\n    })\n    const journal = createMemoryJournal(), destination = createMemoryDestination()\n    const result = await runIngestion(request(pipeline, 'stargazers'), { journal, destination, now: () => cutoff })\n    expect(result.ok).toBe(false)\n    expect(calls).toBe(1)\n    expect(destination.tables.size).toBe(0)\n    expect((await journal.readCheckpoint('github.stargazers.obsessiondb.chkit')).lastSuccessSeq).toBe(0)\n  }\n})\n\ntest('GraphQL malformed or cyclic cursors and invalid commit nodes never record successful completion', async () => {\n  for (const mode of ['missing-cursor', 'repeated', 'missing-message']) {\n    let calls = 0\n    const pipeline = fixturePipeline((url, init) => {\n      if (url.pathname !== '/graphql') return fixtureResponse(url, init)\n      calls++\n      const page = { totalCount: mode === 'repeated' ? 3 : 1,\n        nodes: [{ commit: mode === 'missing-message' ? { oid: commit.sha }\n          : { oid: mode === 'repeated' ? String(calls).padStart(40, '0') : commit.sha, message: commit.message } }],\n        pageInfo: { hasNextPage: mode !== 'missing-message', endCursor: mode === 'missing-cursor' ? null : 'same' } }\n      return Response.json({ data: { repository: { pullRequest: { commits: page } } } })\n    })\n    const journal = createMemoryJournal()\n    const result = await runIngestion(request(pipeline, 'pull_request_commits'), { journal, destination: createMemoryDestination(), now: () => cutoff })\n    expect(result.ok).toBe(false)\n    expect(calls).toBe(mode === 'repeated' ? 2 : 1)\n    if (mode === 'repeated') expect(result.streams[0]?.error).toContain('repeated continuation')\n    expect((await journal.readCheckpoint('github.pull_request_commits.obsessiondb.chkit')).lastSuccessSeq).toBe(0)\n  }\n})\n\ntest('review comments reject a parent URL from another repository before claiming a watermark', async () => {\n  const pipeline = fixturePipeline(() => Response.json([{ ...reviewComment, pull_request_url: 'https://api.github.com/repos/another/project/pulls/2' }]))\n  const journal = createMemoryJournal()\n  const result = await runIngestion(request(pipeline, 'pull_request_review_comments'), { journal, destination: createMemoryDestination(), now: () => cutoff })\n  expect(result.ok).toBe(false)\n  expect((await journal.readCheckpoint('github.pull_request_review_comments.obsessiondb.chkit')).envelope).toBeUndefined()\n})\n\nfunction fixturePipeline(respond: Responder = fixtureResponse, config: GitHubConfig = githubConfig): Pipeline {\n  return createGitHubPipeline(config, { token: () => 'fixture', fetch: (url, init) => Promise.resolve(respond(new URL(url), init)) })\n}\n\nfunction request(pipeline: Pipeline, resource?: string) {\n  return { selected: selectStreams([pipeline], resource ? [`resource:${resource}`] : []).map((entry) => ({\n    ...entry, stream: { ...entry.stream, batchSize: 1, retry: { retries: 0 } },\n  })), backfill: undefined }\n}\n\nfunction fixtureResponse(url: URL, _init: RequestInit): Response {\n  if (url.pathname === `/repos/${repository}/issues`) return Response.json([issue, pullIssue])\n  if (url.pathname === `/repos/${repository}/pulls`) return Response.json([pull])\n  if (url.pathname.endsWith('/issues/1/comments')) return Response.json([issueComment])\n  if (url.pathname.endsWith('/issues/2/comments')) return Response.json([pullComment])\n  if (url.pathname.endsWith('/pulls/comments')) return Response.json([reviewComment])\n  if (url.pathname.endsWith('/pulls/2/reviews')) return Response.json([review])\n  if (url.pathname.endsWith('/stargazers')) return Response.json([stargazer])\n  if (url.pathname === '/graphql') return commitPage([commit], 1, null)\n  throw new IngestConfigError(`Unexpected GitHub fixture request: ${url}`)\n}\n\nfunction commitPage(items: readonly { sha: string; message: string }[], totalCount: number, next: string | null): Response {\n  return Response.json({ data: { repository: { pullRequest: { commits: { totalCount,\n    nodes: items.map((item) => ({ commit: { oid: item.sha, message: item.message, author: { name: 'Do not retain expanded commit fields' } } })),\n    pageInfo: { hasNextPage: next !== null, endCursor: next },\n  } } } } })\n}\n"
+    }
+  ],
+  "meta": {
+    "chkit": {
+      "formatVersion": 1,
+      "version": "0.2.0",
+      "changelog": [
+        {
+          "version": "0.2.0",
+          "changes": [
+            "Sync issues and editable comments through overlapping updated-time windows; advance each stream watermark only after its destination acknowledgement.",
+            "Separate issues, issue comments, pull requests, PR conversation comments, review comments, reviews, commits, and stargazers into independently selectable raw streams for every configured repository.",
+            "Store repository and parent join keys beside provider data; retain only commit SHA and message through paginated GraphQL commit connections, and leave joins to ClickHouse.",
+            "Use one installation pipeline with configuration snapshots, injectable requests, shared pagination, and fullSync where no reliable change filter exists; existing mixed or combined observations require deliberate data migration.",
+            "Consume full pagination pages and use shared continuation-cycle detection while preserving raw resource checkpoints and PR commit completeness checks."
+          ]
+        },
+        {
+          "version": "0.1.0",
+          "changes": [
+            "Introduce raw repository issues and stargazers ingestion."
+          ]
+        }
+      ],
+      "language": "typescript",
+      "license": "MIT",
+      "documentation": "https://chkit.obsessiondb.com/integrations/github/",
+      "logo": "https://chkit.obsessiondb.com/logos/github.svg",
+      "authentication": {
+        "method": "Bearer token",
+        "env": [
+          "GITHUB_TOKEN"
+        ],
+        "setup": [
+          "For private repositories, the supported setup grants GITHUB_TOKEN repository access with Issues:read, Pull requests:read, and Contents:read, including GraphQL commit reads; this is not a verified field-level permission minimum.",
+          "Supply a new access token when the existing token expires."
+        ],
+        "documentation": "https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens"
+      },
+      "chkit": "^0.2.0-beta.10",
+      "ingest": "^0.2.0-beta.10",
+      "clickhouse": ">=25.3.0",
+      "root": "src/integrations/github",
+      "entry": "index.ts",
+      "exports": [
+        "githubPipeline",
+        "createGitHubPipeline",
+        "github_issuesRaw",
+        "github_issueCommentsRaw",
+        "github_pullRequestsRaw",
+        "github_pullRequestCommentsRaw",
+        "github_pullRequestReviewCommentsRaw",
+        "github_pullRequestReviewsRaw",
+        "github_pullRequestCommitsRaw",
+        "github_stargazersRaw"
+      ],
+      "resources": [
+        {
+          "name": "issues",
+          "title": "Issues",
+          "table": "github_issues_raw",
+          "description": "Only ordinary issues, with complete provider issue fields and repository context",
+          "scopes": [
+            "Issues:read"
+          ],
+          "strategy": "timestamp",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/repos/{owner}/{repo}/issues",
+              "documentation": "https://docs.github.com/en/rest/issues/issues#list-repository-issues"
+            }
+          ]
+        },
+        {
+          "name": "issue_comments",
+          "title": "Issue comments",
+          "table": "github_issue_comments_raw",
+          "description": "One raw comment per row for ordinary issues; independently discovers all issue parents and filters child updates",
+          "scopes": [
+            "Issues:read"
+          ],
+          "strategy": "timestamp",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/repos/{owner}/{repo}/issues",
+              "documentation": "https://docs.github.com/en/rest/issues/issues#list-repository-issues"
+            },
+            {
+              "method": "GET",
+              "path": "/repos/{owner}/{repo}/issues/{issue_number}/comments",
+              "documentation": "https://docs.github.com/en/rest/issues/comments#list-issue-comments"
+            }
+          ]
+        },
+        {
+          "name": "pull_requests",
+          "title": "Pull requests",
+          "table": "github_pull_requests_raw",
+          "description": "Pull-request metadata from its own collection, with repository context",
+          "scopes": [
+            "Pull requests:read"
+          ],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/repos/{owner}/{repo}/pulls",
+              "documentation": "https://docs.github.com/en/rest/pulls/pulls#list-pull-requests"
+            }
+          ]
+        },
+        {
+          "name": "pull_request_comments",
+          "title": "Pull request conversation comments",
+          "table": "github_pull_request_comments_raw",
+          "description": "One raw conversation comment per row with its pull number; independently discovers all pull-request parents and filters child updates",
+          "scopes": [
+            "Pull requests:read"
+          ],
+          "strategy": "timestamp",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/repos/{owner}/{repo}/pulls",
+              "documentation": "https://docs.github.com/en/rest/pulls/pulls#list-pull-requests"
+            },
+            {
+              "method": "GET",
+              "path": "/repos/{owner}/{repo}/issues/{pull_number}/comments",
+              "documentation": "https://docs.github.com/en/rest/issues/comments#list-issue-comments"
+            }
+          ]
+        },
+        {
+          "name": "pull_request_review_comments",
+          "title": "Pull request review comments",
+          "table": "github_pull_request_review_comments_raw",
+          "description": "Raw diff-review comments with repository and pull-number context, selected by their own update times",
+          "scopes": [
+            "Pull requests:read"
+          ],
+          "strategy": "timestamp",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/repos/{owner}/{repo}/pulls/comments",
+              "documentation": "https://docs.github.com/en/rest/pulls/comments#list-review-comments-in-a-repository"
+            }
+          ]
+        },
+        {
+          "name": "pull_request_reviews",
+          "title": "Pull request reviews",
+          "table": "github_pull_request_reviews_raw",
+          "description": "One raw review per row with repository and pull number; discovers its own pull-request parents",
+          "scopes": [
+            "Pull requests:read"
+          ],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/repos/{owner}/{repo}/pulls",
+              "documentation": "https://docs.github.com/en/rest/pulls/pulls#list-pull-requests"
+            },
+            {
+              "method": "GET",
+              "path": "/repos/{owner}/{repo}/pulls/{pull_number}/reviews",
+              "documentation": "https://docs.github.com/en/rest/pulls/reviews#list-reviews-for-a-pull-request"
+            }
+          ]
+        },
+        {
+          "name": "pull_request_commits",
+          "title": "Pull request commits",
+          "table": "github_pull_request_commits_raw",
+          "description": "Commit SHA and message only, with repository and pull number; paginates GraphQL commits after independent pull-request discovery",
+          "scopes": [
+            "Pull requests:read",
+            "Contents:read"
+          ],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/repos/{owner}/{repo}/pulls",
+              "documentation": "https://docs.github.com/en/rest/pulls/pulls#list-pull-requests"
+            },
+            {
+              "method": "POST",
+              "path": "/graphql",
+              "documentation": "https://docs.github.com/en/graphql/reference/pulls#pullrequest"
+            }
+          ]
+        },
+        {
+          "name": "stargazers",
+          "title": "Stargazers",
+          "table": "github_stargazers_raw",
+          "description": "Repository stargazers with starred_at and repository context",
+          "scopes": [],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/repos/{owner}/{repo}/stargazers",
+              "documentation": "https://docs.github.com/en/rest/activity/starring#list-stargazers"
+            }
+          ]
+        }
+      ],
+      "views": [],
+      "sync": {
+        "description": "One installation pipeline groups eight independent resource streams per configured repository. Issues and comments use completed updated-time windows; pull requests, reviews, commits, and stargazers use fullSync. Each child stream discovers its own parent collection, independently of parent-stream execution or parent update times.",
+        "schedule": "Run bunx chkit ingest run --tag provider:github from a scheduler.",
+        "deletions": "Deleted records, removed stars, and commits no longer present after a force-push remain stored. Missing observations do not generate tombstones; legacy mixed issue/PR rows and nested child payloads require deliberate migration."
+      },
+      "env": {
+        "GITHUB_TOKEN": ""
+      },
+      "fileHashes": {
+        "src/integrations/github/README.md": "693ac62853763b5e2c7216bcd3afc014fc93f6e5f9bca35192cac8b899eb3935",
+        "src/integrations/github/index.ts": "18cc6d48bcd79ca7855de185d15c3f245423571863e5f39deb031278640d7a9e",
+        "src/integrations/github/config.ts": "c6ee56c657acb19da8db5117e5c99bfbc56931d9d1b503f3c71d5f2b9fca0ca4",
+        "src/integrations/github/client.ts": "1289977bab8acc6ac0b59d31442469e4ff21645f1633c933addc22d9021366de",
+        "src/integrations/github/pipeline.ts": "8e32ebb37d40752677c3cecd36bd42c6b541b86d7fc78805923e7be1c3fa10b4",
+        "src/integrations/github/sources/issues.ts": "8bd8e313361aa08f238474155d041b5a3ba604058120fdea6e02b458c1775e98",
+        "src/integrations/github/sources/stargazers.ts": "d678998d14954df9f77f2f97b07933c7449b7e6fa2abde95311bdcda4f664dd6",
+        "src/integrations/github/sources/issue-comments.ts": "7fcb004c429c12cd766479255e79bd281d4e191ff8aa7adf5a7cffcb27761645",
+        "src/integrations/github/sources/pull-requests.ts": "5d5ed7331de17af89b33ab172c95bd1b71fd81ce22801c2a32f7c365a855c589",
+        "src/integrations/github/sources/pull-request-comments.ts": "461bd1b01cedbedeb6e2eebe3f8cf0de81cd89b3229f5ea298e2ef75bb652d5f",
+        "src/integrations/github/sources/pull-request-review-comments.ts": "911bea05e646a3c9e8e81c81a067836f8621cc7ff3a6b8798db4cd9293b72210",
+        "src/integrations/github/sources/pull-request-reviews.ts": "a0738d9f2b4cf5ce9df4edcaa0255cd306450593884fff28d374725ceae3902f",
+        "src/integrations/github/sources/pull-request-commits.ts": "4a091b39eb3e4653abe17480ab6119c7aed0375b2bbafdf636dd88a54c25adb3",
+        "src/integrations/github/tests/basic.test.ts": "a754bd2a1a0a27371df4ad3f8a5d830d0c0e7d13319d546b431c748de97bf746"
+      }
+    }
+  }
+}
diff --git a/registry/github/sources/issue-comments.ts b/registry/github/sources/issue-comments.ts
new file mode 100644
index 00000000..14f2e836
--- /dev/null
+++ b/registry/github/sources/issue-comments.ts
@@ -0,0 +1,18 @@
+import { rawTable, type ReadContext, type TimestampRange, type TimestampWindowState } from '@chkit/plugin-ingest'
+
+import { githubNumber, readGitHubPages, readIssuePages, toGitHubRows, updatedItems, type GitHubClientDeps } from '../client.js'
+import type { GitHubConfig } from '../config.js'
+
+export const github_issueCommentsRaw = rawTable({ database: 'default', name: 'github_issue_comments_raw' })
+
+export async function* readIssueComments(context: ReadContext<TimestampRange, TimestampWindowState>, repo: string, config: GitHubConfig, deps: GitHubClientDeps) {
+  // Discover all issue parents: a recent comment need not imply a recent parent update.
+  for await (const issues of readIssuePages(context, repo, config, deps)) {
+    for (const issue of issues.items) {
+      const number = githubNumber(issue, 'number')
+      for await (const page of readGitHubPages(context, { path: `/repos/${repo}/issues/${number}/comments`, params: { since: context.selection.from.toISOString() } }, config, deps)) {
+        yield { rows: toGitHubRows(updatedItems(page.items, context.selection), repo, (comment) => githubNumber(comment, 'id'), { issue_number: number }) }
+      }
+    }
+  }
+}
diff --git a/registry/github/sources/issues.ts b/registry/github/sources/issues.ts
new file mode 100644
index 00000000..e2aaeca0
--- /dev/null
+++ b/registry/github/sources/issues.ts
@@ -0,0 +1,12 @@
+import { rawTable, type ReadContext, type TimestampRange, type TimestampWindowState } from '@chkit/plugin-ingest'
+
+import { githubNumber, readIssuePages, toGitHubRows, type GitHubClientDeps } from '../client.js'
+import type { GitHubConfig } from '../config.js'
+
+export const github_issuesRaw = rawTable({ database: 'default', name: 'github_issues_raw' })
+
+export async function* readIssues(context: ReadContext<TimestampRange, TimestampWindowState>, repo: string, config: GitHubConfig, deps: GitHubClientDeps) {
+  for await (const page of readIssuePages(context, repo, config, deps, context.selection)) {
+    yield { rows: toGitHubRows(page.items, repo, (issue) => githubNumber(issue, 'number')) }
+  }
+}
diff --git a/registry/github/sources/pull-request-comments.ts b/registry/github/sources/pull-request-comments.ts
new file mode 100644
index 00000000..b2d68a69
--- /dev/null
+++ b/registry/github/sources/pull-request-comments.ts
@@ -0,0 +1,18 @@
+import { rawTable, type ReadContext, type TimestampRange, type TimestampWindowState } from '@chkit/plugin-ingest'
+
+import { githubNumber, readGitHubPages, readPullPages, toGitHubRows, updatedItems, type GitHubClientDeps } from '../client.js'
+import type { GitHubConfig } from '../config.js'
+
+export const github_pullRequestCommentsRaw = rawTable({ database: 'default', name: 'github_pull_request_comments_raw' })
+
+export async function* readPullRequestComments(context: ReadContext<TimestampRange, TimestampWindowState>, repo: string, config: GitHubConfig, deps: GitHubClientDeps) {
+  // This reader owns its discovery and window; the PR metadata stream need not have run.
+  for await (const pulls of readPullPages(context, repo, config, deps)) {
+    for (const pull of pulls.items) {
+      const number = githubNumber(pull, 'number')
+      for await (const page of readGitHubPages(context, { path: `/repos/${repo}/issues/${number}/comments`, params: { since: context.selection.from.toISOString() } }, config, deps)) {
+        yield { rows: toGitHubRows(updatedItems(page.items, context.selection), repo, (comment) => githubNumber(comment, 'id'), { pull_number: number }) }
+      }
+    }
+  }
+}
diff --git a/registry/github/sources/pull-request-commits.ts b/registry/github/sources/pull-request-commits.ts
new file mode 100644
index 00000000..ef4df8b1
--- /dev/null
+++ b/registry/github/sources/pull-request-commits.ts
@@ -0,0 +1,65 @@
+import { IngestConfigError, paginate, rawTable, type FetchContext } from '@chkit/plugin-ingest'
+
+import { githubNumber, readPullPages, requestGitHubGraphql, requireGitHubObject, toGitHubRows, type GitHubClientDeps } from '../client.js'
+import type { GitHubConfig } from '../config.js'
+
+export const github_pullRequestCommitsRaw = rawTable({ database: 'default', name: 'github_pull_request_commits_raw' })
+
+// The REST PR commits endpoint caps results at 250. Request only the two desired fields through GraphQL.
+const commitsQuery = `query PullRequestCommits($owner: String!, $repo: String!, $number: Int!, $first: Int!, $after: String) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $number) {
+      commits(first: $first, after: $after) {
+        totalCount
+        nodes { commit { oid message } }
+        pageInfo { hasNextPage endCursor }
+      }
+    }
+  }
+}`
+
+export async function* readPullRequestCommits(context: FetchContext, repo: string, config: GitHubConfig, deps: GitHubClientDeps) {
+  const [owner, name] = repo.split('/')
+  for await (const pulls of readPullPages(context, repo, config, deps)) {
+    for (const pull of pulls.items) {
+      const number = githubNumber(pull, 'number')
+      let expectedCount: number | undefined
+      const seenShas = new Set<string>()
+      const pages = paginate<{ sha: string; message: string }, string>({
+        context, label: `POST /graphql PR ${repo}#${number} commits`,
+        fetchPage: async (after, signal) => {
+          const data = await requestGitHubGraphql(commitsQuery, { owner, repo: name, number, first: config.pageSize, after: after ?? null }, signal, deps)
+          const repository = requireGitHubObject(data.repository, 'GraphQL repository')
+          const parent = requireGitHubObject(repository.pullRequest, 'GraphQL pull request')
+          const connection = requireGitHubObject(parent.commits, 'GraphQL commits connection')
+          const total = connection.totalCount
+          if (typeof total !== 'number' || !Number.isSafeInteger(total) || total < 0) throw new IngestConfigError('GitHub commits have no valid totalCount.')
+          if (expectedCount !== undefined && total !== expectedCount) throw new IngestConfigError('GitHub PR commit count changed during pagination; replay this stream.')
+          if (!Array.isArray(connection.nodes)) throw new IngestConfigError('GitHub commits nodes is not an array.')
+          const items = connection.nodes.map((node: unknown) => {
+            const commit = requireGitHubObject(requireGitHubObject(node, 'GraphQL commit node').commit, 'GraphQL commit')
+            if (typeof commit.oid !== 'string' || !commit.oid.trim() || typeof commit.message !== 'string') throw new IngestConfigError('GitHub commit has no SHA or message.')
+            return { sha: commit.oid, message: commit.message }
+          })
+          const pageInfo = requireGitHubObject(connection.pageInfo, 'GraphQL commit pageInfo')
+          if (typeof pageInfo.hasNextPage !== 'boolean') throw new IngestConfigError('GitHub commits have no hasNextPage flag.')
+          if (pageInfo.hasNextPage && (typeof pageInfo.endCursor !== 'string' || !pageInfo.endCursor.trim())) throw new IngestConfigError('GitHub commits have no continuation cursor.')
+          const next = pageInfo.hasNextPage && typeof pageInfo.endCursor === 'string' ? pageInfo.endCursor : undefined
+          const pageShas = new Set<string>()
+          for (const commit of items) {
+            if (seenShas.has(commit.sha) || pageShas.has(commit.sha)) throw new IngestConfigError('GitHub PR commits repeated a SHA; replay this stream.')
+            pageShas.add(commit.sha)
+          }
+          const count = seenShas.size + pageShas.size
+          if (count > total || (next === undefined && count !== total)) throw new IngestConfigError('GitHub PR commits ended without the advertised complete collection.')
+          expectedCount = total
+          for (const sha of pageShas) seenShas.add(sha)
+          return { items, next }
+        },
+      })
+      for await (const page of pages) {
+        yield { rows: toGitHubRows(page.items, repo, (commit) => commit.sha, { pull_number: number }) }
+      }
+    }
+  }
+}
diff --git a/registry/github/sources/pull-request-review-comments.ts b/registry/github/sources/pull-request-review-comments.ts
new file mode 100644
index 00000000..dac7c157
--- /dev/null
+++ b/registry/github/sources/pull-request-review-comments.ts
@@ -0,0 +1,16 @@
+import { rawTable, type ReadContext, type TimestampRange, type TimestampWindowState } from '@chkit/plugin-ingest'
+
+import { githubNumber, pullNumber, readGitHubPages, toGitHubRows, updatedItems, type GitHubClientDeps } from '../client.js'
+import type { GitHubConfig } from '../config.js'
+
+export const github_pullRequestReviewCommentsRaw = rawTable({ database: 'default', name: 'github_pull_request_review_comments_raw' })
+
+export async function* readPullRequestReviewComments(context: ReadContext<TimestampRange, TimestampWindowState>, repo: string, config: GitHubConfig, deps: GitHubClientDeps) {
+  for await (const page of readGitHubPages(context, { path: `/repos/${repo}/pulls/comments`, params: {
+    since: context.selection.from.toISOString(), sort: 'updated', direction: 'asc',
+  } }, config, deps)) {
+    for (const comment of updatedItems(page.items, context.selection)) {
+      yield { rows: toGitHubRows([comment], repo, (item) => githubNumber(item, 'id'), { pull_number: pullNumber(comment, repo) }) }
+    }
+  }
+}
diff --git a/registry/github/sources/pull-request-reviews.ts b/registry/github/sources/pull-request-reviews.ts
new file mode 100644
index 00000000..2ad2e431
--- /dev/null
+++ b/registry/github/sources/pull-request-reviews.ts
@@ -0,0 +1,17 @@
+import { rawTable, type FetchContext } from '@chkit/plugin-ingest'
+
+import { githubNumber, readGitHubPages, readPullPages, toGitHubRows, type GitHubClientDeps } from '../client.js'
+import type { GitHubConfig } from '../config.js'
+
+export const github_pullRequestReviewsRaw = rawTable({ database: 'default', name: 'github_pull_request_reviews_raw' })
+
+export async function* readPullRequestReviews(context: FetchContext, repo: string, config: GitHubConfig, deps: GitHubClientDeps) {
+  for await (const pulls of readPullPages(context, repo, config, deps)) {
+    for (const pull of pulls.items) {
+      const number = githubNumber(pull, 'number')
+      for await (const page of readGitHubPages(context, { path: `/repos/${repo}/pulls/${number}/reviews` }, config, deps)) {
+        yield { rows: toGitHubRows(page.items, repo, (review) => githubNumber(review, 'id'), { pull_number: number }) }
+      }
+    }
+  }
+}
diff --git a/registry/github/sources/pull-requests.ts b/registry/github/sources/pull-requests.ts
new file mode 100644
index 00000000..16793e94
--- /dev/null
+++ b/registry/github/sources/pull-requests.ts
@@ -0,0 +1,12 @@
+import { rawTable, type FetchContext } from '@chkit/plugin-ingest'
+
+import { githubNumber, readPullPages, toGitHubRows, type GitHubClientDeps } from '../client.js'
+import type { GitHubConfig } from '../config.js'
+
+export const github_pullRequestsRaw = rawTable({ database: 'default', name: 'github_pull_requests_raw' })
+
+export async function* readPullRequests(context: FetchContext, repo: string, config: GitHubConfig, deps: GitHubClientDeps) {
+  for await (const page of readPullPages(context, repo, config, deps)) {
+    yield { rows: toGitHubRows(page.items, repo, (pull) => githubNumber(pull, 'number')) }
+  }
+}
diff --git a/registry/github/sources/stargazers.ts b/registry/github/sources/stargazers.ts
new file mode 100644
index 00000000..815ea9c2
--- /dev/null
+++ b/registry/github/sources/stargazers.ts
@@ -0,0 +1,12 @@
+import { rawTable, type FetchContext } from '@chkit/plugin-ingest'
+
+import { githubNumber, readGitHubPages, requireGitHubObject, toGitHubRows, type GitHubClientDeps } from '../client.js'
+import type { GitHubConfig } from '../config.js'
+
+export const github_stargazersRaw = rawTable({ database: 'default', name: 'github_stargazers_raw' })
+
+export async function* readStargazers(context: FetchContext, repo: string, config: GitHubConfig, deps: GitHubClientDeps) {
+  for await (const page of readGitHubPages(context, { path: `/repos/${repo}/stargazers`, accept: 'application/vnd.github.star+json' }, config, deps)) {
+    yield { rows: toGitHubRows(page.items, repo, (star) => githubNumber(requireGitHubObject(star.user, 'stargazer user'), 'id')) }
+  }
+}
diff --git a/registry/github/tests/basic.test.ts b/registry/github/tests/basic.test.ts
new file mode 100644
index 00000000..367a44f4
--- /dev/null
+++ b/registry/github/tests/basic.test.ts
@@ -0,0 +1,450 @@
+import { expect, test } from 'bun:test'
+import { HttpError, IngestConfigError, runIngestion, selectStreams, type FetchContext, type Page } from '@chkit/plugin-ingest'
+import { createMemoryDestination, createMemoryJournal } from '@chkit/plugin-ingest/testing'
+
+import { createGitHubPipeline, githubPipeline } from '../index.js'
+import { githubConfig, type GitHubConfig } from '../config.js'
+import { classifyGitHubError, readIssuePages, requestGitHubGraphql, type GitHubObject } from '../client.js'
+
+const repository = 'obsessiondb/chkit'
+const cutoff = new Date('2026-01-02T00:00:00Z')
+const resources = ['issues', 'issue_comments', 'pull_requests', 'pull_request_comments', 'pull_request_review_comments', 'pull_request_reviews', 'pull_request_commits', 'stargazers']
+const issue = { number: 1, id: 1001, title: 'Issue', updated_at: '2026-01-01T12:00:00Z', labels: [{ name: 'bug' }] }
+const pull = { number: 2, id: 1002, title: 'Pull request', state: 'closed', updated_at: '2026-01-01T12:00:00Z', merged_at: '2026-01-01T00:00:00Z' }
+const pullIssue = { ...pull, pull_request: { url: `https://api.github.com/repos/${repository}/pulls/2` } }
+const issueComment = { id: 101, body: 'Issue discussion', updated_at: issue.updated_at, custom: ['retained'] }
+const pullComment = { id: 201, body: 'Pull request discussion', updated_at: issue.updated_at }
+const reviewComment = { id: 301, body: 'Review discussion', updated_at: issue.updated_at, pull_request_url: `https://api.github.com/repos/${repository}/pulls/2` }
+const review = { id: 401, body: 'Review', state: 'APPROVED', submitted_at: '2020-01-01T00:00:00Z' }
+const commit = { sha: '0123456789012345678901234567890123456789', message: 'Subject\n\nFull commit message\nwith another line.' }
+const stargazer = { starred_at: '2026-01-01T00:00:00Z', user: { id: 501, login: 'example' }, custom: true }
+
+type Responder = (url: URL, init: RequestInit) => Response | Promise<Response>
+type Pipeline = ReturnType<typeof createGitHubPipeline>
+
+test('GitHub resource streams retain flat provider payloads and parent join identities', async () => {
+  const requests: URL[] = []
+  const pipeline = fixturePipeline((url, init) => { requests.push(url); return fixtureResponse(url, init) })
+  expect(pipeline.streams.map((stream) => stream.id).sort()).toEqual(resources.map((resource) => `github.${resource}.obsessiondb.chkit`).sort())
+  expect(githubPipeline.streams).toHaveLength(8)
+  const destination = createMemoryDestination(), journal = createMemoryJournal()
+  const result = await runIngestion(request(pipeline), { journal, destination, now: () => cutoff })
+  expect(result.ok, JSON.stringify(result)).toBe(true)
+  const expected: Record<string, { id: string; raw: unknown }> = {
+    issues: { id: JSON.stringify([repository, 1]), raw: { repository, data: issue } },
+    issue_comments: { id: JSON.stringify([repository, 1, 101]), raw: { repository, issue_number: 1, data: issueComment } },
+    pull_requests: { id: JSON.stringify([repository, 2]), raw: { repository, data: pull } },
+    pull_request_comments: { id: JSON.stringify([repository, 2, 201]), raw: { repository, pull_number: 2, data: pullComment } },
+    pull_request_review_comments: { id: JSON.stringify([repository, 2, 301]), raw: { repository, pull_number: 2, data: reviewComment } },
+    pull_request_reviews: { id: JSON.stringify([repository, 2, 401]), raw: { repository, pull_number: 2, data: review } },
+    pull_request_commits: { id: JSON.stringify([repository, 2, commit.sha]), raw: { repository, pull_number: 2, data: commit } },
+    stargazers: { id: JSON.stringify([repository, 501]), raw: { repository, data: stargazer } },
+  }
+  for (const [resource, expectedRow] of Object.entries(expected)) {
+    expect(destination.tables.get(`default.github_${resource}_raw`)?.map(({ id, raw }) => ({ id, raw }))).toEqual([expectedRow])
+  }
+  expect(requests.some((url) => url.pathname.endsWith('/files') || /\/pulls\/\d+\/commits$/.test(url.pathname))).toBe(false)
+  expect((await journal.readCheckpoint('github.issues.obsessiondb.chkit')).envelope?.state).toEqual({ watermark: cutoff.toISOString() })
+})
+
+test('every resource runs alone and reversing stream order preserves the same observations', async () => {
+  const pipeline = fixturePipeline()
+  const combined = createMemoryDestination()
+  const reversed = { ...pipeline, streams: [...pipeline.streams].reverse() }
+  expect((await runIngestion(request(reversed), { journal: createMemoryJournal(), destination: combined, now: () => cutoff })).ok).toBe(true)
+  for (const resource of resources) {
+    const destination = createMemoryDestination()
+    const selected = request(pipeline, resource)
+    expect(selected.selected.map((entry) => entry.stream.id)).toEqual([`github.${resource}.obsessiondb.chkit`])
+    const result = await runIngestion(selected, { journal: createMemoryJournal(), destination, now: () => cutoff })
+    expect(result.ok, `${resource}: ${JSON.stringify(result)}`).toBe(true)
+    expect(destination.tables.size).toBe(1)
+    expect(destination.tables.get(`default.github_${resource}_raw`)?.map(({ id, raw }) => ({ id, raw })))
+      .toEqual(combined.tables.get(`default.github_${resource}_raw`)?.map(({ id, raw }) => ({ id, raw })))
+  }
+})
+
+test('selecting parents requests no children and separates issue and pull request responses', async () => {
+  for (const resource of ['issues', 'pull_requests']) {
+    const requests: URL[] = []
+    const pipeline = fixturePipeline((url, init) => { requests.push(url); return fixtureResponse(url, init) })
+    const destination = createMemoryDestination()
+    expect((await runIngestion(request(pipeline, resource), { journal: createMemoryJournal(), destination, now: () => cutoff })).ok).toBe(true)
+    expect(requests.map((url) => url.pathname)).toEqual([`/repos/${repository}/${resource === 'issues' ? 'issues' : 'pulls'}`])
+    expect(requests[0]?.searchParams.get('state')).toBe('all')
+    expect(requests[0]?.searchParams.get('sort')).toBe('updated')
+    expect(requests[0]?.searchParams.get('direction')).toBe('asc')
+    expect(requests[0]?.searchParams.has('since')).toBe(resource === 'issues')
+    expect(destination.tables.get(`default.github_${resource}_raw`)?.map((row) => row.raw)).toEqual([{ repository, data: resource === 'issues' ? issue : pull }])
+  }
+})
+
+test('short issue pages follow Link continuations while excluding PRs and updates beyond the cutoff', async () => {
+  const requests: URL[] = []
+  const nextIssue = { ...issue, number: 3, id: 1003 }
+  const futureIssue = { ...issue, number: 4, updated_at: '2026-01-03T00:00:00Z' }
+  const pipeline = fixturePipeline((url) => {
+    requests.push(url)
+    if (url.searchParams.has('page')) return Response.json([pullIssue, nextIssue, futureIssue])
+    return Response.json([issue], { headers: { Link: `<${url}&page=2>; rel="next"` } })
+  })
+  const destination = createMemoryDestination(), journal = createMemoryJournal()
+  const result = await runIngestion(request(pipeline, 'issues'), { journal, destination, now: () => cutoff })
+  expect(result.ok).toBe(true)
+  expect(requests).toHaveLength(2)
+  expect(requests.every((url) => url.searchParams.get('since') === '2008-01-01T00:00:00.000Z')).toBe(true)
+  expect(destination.tables.get('default.github_issues_raw')?.map((row) => row.raw)).toEqual([{ repository, data: issue }, { repository, data: nextIssue }])
+  expect((await journal.readCheckpoint('github.issues.obsessiondb.chkit')).envelope?.state).toEqual({ watermark: cutoff.toISOString() })
+})
+
+test('issue page filtering preserves continuations and empty terminal pages', async () => {
+  const signal = new AbortController().signal
+  const context: FetchContext = { signal, attempt: (operation) => operation(signal) }
+  const pages: Page<GitHubObject, string>[] = []
+  const requests: URL[] = []
+  for await (const page of readIssuePages(context, repository, githubConfig, {
+    token: () => 'fixture', fetch: async (input) => {
+      const url = new URL(input)
+      requests.push(url)
+      const number = Number(url.searchParams.get('page') ?? '1')
+      const next = new URL(url)
+      next.searchParams.set('page', String(number + 1))
+      return Response.json(number === 1 ? [pullIssue] : number === 2 ? [issue] : [],
+        { headers: number < 3 ? { Link: `<${next}>; rel="next"` } : {} })
+    },
+  })) pages.push(page)
+  expect(requests).toHaveLength(3)
+  expect(pages.map((page) => page.items)).toEqual([[], [issue], []])
+  expect(pages.map((page) => page.next)).toEqual([requests[1]?.toString(), requests[2]?.toString(), undefined])
+})
+
+test('a failed child stream does not block its parents or the other resource checkpoints', async () => {
+  const pipeline = fixturePipeline((url, init) => url.pathname.endsWith('/issues/1/comments')
+    ? new Response('denied', { status: 403 }) : fixtureResponse(url, init))
+  const destination = createMemoryDestination(), journal = createMemoryJournal()
+  const result = await runIngestion(request(pipeline), { journal, destination, now: () => cutoff })
+  expect(result.ok).toBe(false)
+  expect(result.streams.filter((stream) => stream.outcome === 'failed').map((stream) => stream.streamId)).toEqual(['github.issue_comments.obsessiondb.chkit'])
+  expect(result.streams.filter((stream) => stream.outcome === 'succeeded')).toHaveLength(7)
+  expect(destination.tables.has('default.github_issues_raw')).toBe(true)
+  expect(destination.tables.has('default.github_pull_requests_raw')).toBe(true)
+  expect((await journal.readCheckpoint('github.issue_comments.obsessiondb.chkit')).envelope).toBeUndefined()
+  for (const resource of ['issues', 'pull_request_comments', 'pull_request_review_comments']) {
+    expect((await journal.readCheckpoint(`github.${resource}.obsessiondb.chkit`)).envelope?.state).toEqual({ watermark: cutoff.toISOString() })
+  }
+  expect((await journal.readCheckpoint('github.pull_requests.obsessiondb.chkit')).lastSuccessSeq).toBeGreaterThan(0)
+})
+
+test('comment streams capture edits on old parents using their own overlapping since windows', async () => {
+  const oldIssue = { ...issue, number: 3, updated_at: '2020-01-01T00:00:00Z' }
+  const oldPull = { ...pull, number: 4, updated_at: '2020-01-01T00:00:00Z' }
+  for (const resource of ['issue_comments', 'pull_request_comments', 'pull_request_review_comments']) {
+    let edited = false
+    const requests: URL[] = []
+    const pipeline = fixturePipeline((url) => {
+      requests.push(url)
+      if (url.pathname.endsWith('/issues')) return Response.json([oldIssue, { ...oldPull, pull_request: pullIssue.pull_request }])
+      if (url.pathname.endsWith('/pulls')) return Response.json([oldPull])
+      const comment = resource === 'issue_comments' ? issueComment : resource === 'pull_request_comments' ? pullComment : reviewComment
+      const data = { ...comment, body: edited ? 'Edited old discussion' : 'Original discussion', updated_at: edited ? '2026-01-02T12:00:00Z' : '2026-01-01T12:00:00Z',
+        ...(resource === 'pull_request_review_comments' ? { pull_request_url: `https://api.github.com/repos/${repository}/pulls/4` } : {}) }
+      return Response.json([data, { ...data, id: 999, updated_at: '2026-01-04T00:00:00Z' }])
+    })
+    const journal = createMemoryJournal(), destination = createMemoryDestination()
+    expect((await runIngestion(request(pipeline, resource), { journal, destination, now: () => cutoff })).ok).toBe(true)
+    edited = true
+    expect((await runIngestion(request(pipeline, resource), { journal, destination, now: () => new Date('2026-01-03') })).ok).toBe(true)
+    const children = requests.filter((url) => url.pathname.endsWith('/comments'))
+    expect(children.map((url) => url.searchParams.get('since'))).toEqual(['2008-01-01T00:00:00.000Z', '2026-01-01T23:55:00.000Z'])
+    expect(requests.filter((url) => url.pathname.endsWith('/issues') || url.pathname.endsWith('/pulls')).every((url) => !url.searchParams.has('since'))).toBe(true)
+    const rows = destination.tables.get(`default.github_${resource}_raw`) ?? []
+    expect(rows).toHaveLength(2)
+    expect(new Set(rows.map((row) => row.id)).size).toBe(1)
+    expect(rows.at(-1)?.raw).toMatchObject({ repository, data: { body: 'Edited old discussion' } })
+    expect((await journal.readCheckpoint(`github.${resource}.obsessiondb.chkit`)).envelope?.state).toEqual({ watermark: '2026-01-03T00:00:00.000Z' })
+  }
+})
+
+test('a rejected child write cannot advance its timestamp watermark and the next run replays the window', async () => {
+  const starts: string[] = []
+  const pipeline = fixturePipeline((url, init) => {
+    if (url.pathname.endsWith('/comments')) starts.push(url.searchParams.get('since') ?? '')
+    return fixtureResponse(url, init)
+  })
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  const selected = request(pipeline, 'issue_comments')
+  const failed = await runIngestion(selected, { journal, destination: { insert: async () => { throw new IngestConfigError('sink rejected') } }, now: () => cutoff })
+  expect(failed.ok).toBe(false)
+  expect((await journal.readCheckpoint('github.issue_comments.obsessiondb.chkit')).envelope).toBeUndefined()
+  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect(starts).toEqual(['2008-01-01T00:00:00.000Z', '2008-01-01T00:00:00.000Z'])
+  expect(destination.tables.get('default.github_issue_comments_raw')).toHaveLength(1)
+})
+
+test('empty resource runs complete independently and full readers scan again without provider state', async () => {
+  const calls: string[] = []
+  const pipeline = fixturePipeline((url) => { calls.push(url.pathname); return Response.json([]) })
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  for (const now of [cutoff, new Date('2026-01-03')]) expect((await runIngestion(request(pipeline), { journal, destination, now: () => now })).ok).toBe(true)
+  expect(destination.tables.size).toBe(0)
+  for (const resource of ['pull_requests', 'pull_request_reviews', 'pull_request_commits', 'stargazers']) {
+    const checkpoint = await journal.readCheckpoint(`github.${resource}.obsessiondb.chkit`)
+    expect(checkpoint.envelope).toBeUndefined()
+    expect(checkpoint.lastSuccessSeq).toBeGreaterThan(0)
+    expect(journal.events.filter((event) => event.namespaceId === `github.${resource}.obsessiondb.chkit` && event.eventKind === 'work_finished' && event.workState === 'succeeded')).toHaveLength(2)
+  }
+  expect(calls.filter((path) => path.endsWith('/stargazers'))).toHaveLength(2)
+  expect((await journal.readCheckpoint('github.issue_comments.obsessiondb.chkit')).envelope?.state).toEqual({ watermark: '2026-01-03T00:00:00.000Z' })
+})
+
+test('stargazer full sync replays from its first page after page or destination failures before completing', async () => {
+  let failSecondPage = true
+  const starts: string[] = []
+  const second = { ...stargazer, user: { id: 502, login: 'another-example' } }
+  const pipeline = fixturePipeline((url) => {
+    if (url.searchParams.get('page') === '2') return failSecondPage ? new Response('denied', { status: 403 }) : Response.json([second])
+    starts.push(url.search)
+    return Response.json([stargazer], { headers: { Link: `<${url}&page=2>; rel="next"` } })
+  })
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  const selected = request(pipeline, 'stargazers')
+  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(false)
+  expect((await journal.readCheckpoint('github.stargazers.obsessiondb.chkit')).lastSuccessSeq).toBe(0)
+  expect((await journal.readCheckpoint('github.stargazers.obsessiondb.chkit')).envelope).toBeUndefined()
+  failSecondPage = false
+  const rejected = await runIngestion(selected, { journal, now: () => cutoff,
+    destination: { insert: async () => { throw new IngestConfigError('sink rejected') } } })
+  expect(rejected.ok).toBe(false)
+  expect((await journal.readCheckpoint('github.stargazers.obsessiondb.chkit')).lastSuccessSeq).toBe(0)
+  expect((await journal.readCheckpoint('github.stargazers.obsessiondb.chkit')).envelope).toBeUndefined()
+  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(true)
+  const completed = await journal.readCheckpoint('github.stargazers.obsessiondb.chkit')
+  expect(completed.lastSuccessSeq).toBeGreaterThan(0)
+  expect(completed.envelope).toBeUndefined()
+  expect(starts).toEqual(Array(3).fill('?per_page=100'))
+  expect(destination.tables.get('default.github_stargazers_raw')?.map(({ id, raw }) => ({ id, raw }))).toEqual([
+    { id: JSON.stringify([repository, 501]), raw: { repository, data: stargazer } },
+    { id: JSON.stringify([repository, 502]), raw: { repository, data: second } },
+  ])
+})
+
+test('GraphQL commits collect more than 250 entries and retain only SHA and the full multiline message', async () => {
+  const commits = Array.from({ length: 275 }, (_, index) => ({ sha: (index + 1).toString(16).padStart(40, '0'), message: `Subject ${index}\n\nFull body ${index}\nLast line.` }))
+  const afters: unknown[] = [], requests: URL[] = []
+  const pipeline = fixturePipeline((url, init) => {
+    requests.push(url)
+    if (url.pathname !== '/graphql') return fixtureResponse(url, init)
+    expect(init.method).toBe('POST')
+    const body = JSON.parse(String(init.body))
+    const after = body.variables.after ?? null
+    afters.push(after)
+    const offset = after === 'page-100' ? 100 : after === 'page-200' ? 200 : 0
+    const items = commits.slice(offset, offset + 100)
+    return commitPage(items, commits.length, offset + items.length < commits.length ? `page-${offset + items.length}` : null)
+  })
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  expect((await runIngestion(request(pipeline, 'pull_request_commits'), { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect(afters).toEqual([null, 'page-100', 'page-200'])
+  const rows = destination.tables.get('default.github_pull_request_commits_raw') ?? []
+  expect(rows).toHaveLength(275)
+  expect(rows.map((row) => row.raw)).toEqual(commits.map((data) => ({ repository, pull_number: 2, data })))
+  expect(rows.at(-1)?.id).toBe(JSON.stringify([repository, 2, commits.at(-1)?.sha]))
+  expect(requests.filter((url) => url.pathname !== '/graphql').map((url) => url.pathname)).toEqual([`/repos/${repository}/pulls`])
+  expect((await journal.readCheckpoint('github.pull_request_commits.obsessiondb.chkit')).envelope).toBeUndefined()
+  expect((await journal.readCheckpoint('github.pull_request_commits.obsessiondb.chkit')).lastSuccessSeq).toBeGreaterThan(0)
+})
+
+test('GraphQL commit totals reject truncated collections and changes during pagination', async () => {
+  for (const changed of [false, true]) {
+    let calls = 0
+    const pipeline = fixturePipeline((url, init) => {
+      if (url.pathname !== '/graphql') return fixtureResponse(url, init)
+      calls++
+      return commitPage([{ ...commit, sha: String(calls).padStart(40, '0') }], changed && calls === 2 ? 3 : 2, changed && calls === 1 ? 'next' : null)
+    })
+    const journal = createMemoryJournal()
+    const result = await runIngestion(request(pipeline, 'pull_request_commits'), { journal, destination: createMemoryDestination(), now: () => cutoff })
+    expect(result.ok).toBe(false)
+    expect(calls).toBe(changed ? 2 : 1)
+    expect((await journal.readCheckpoint('github.pull_request_commits.obsessiondb.chkit')).lastSuccessSeq).toBe(0)
+  }
+})
+
+test('GraphQL commits validate complete counts on empty terminal pages', async () => {
+  for (const total of [0, 1, 2]) {
+    let calls = 0
+    const pipeline = fixturePipeline((url, init) => {
+      if (url.pathname !== '/graphql') return fixtureResponse(url, init)
+      calls++
+      return commitPage(total > 0 && calls === 1 ? [commit] : [], total, total > 0 && calls === 1 ? 'terminal' : null)
+    })
+    const journal = createMemoryJournal(), destination = createMemoryDestination()
+    const result = await runIngestion(request(pipeline, 'pull_request_commits'), { journal, destination, now: () => cutoff })
+    expect(result.ok).toBe(total < 2)
+    expect(calls).toBe(total === 0 ? 1 : 2)
+    expect((await journal.readCheckpoint('github.pull_request_commits.obsessiondb.chkit')).lastSuccessSeq > 0).toBe(total < 2)
+    if (total < 2) expect(destination.tables.get('default.github_pull_request_commits_raw') ?? []).toHaveLength(total)
+  }
+})
+
+test('GraphQL commit pagination rejects duplicate SHAs within or across pages despite a matching total', async () => {
+  for (const acrossPages of [true, false]) {
+    let calls = 0
+    const pipeline = fixturePipeline((url, init) => {
+      if (url.pathname !== '/graphql') return fixtureResponse(url, init)
+      calls++
+      return acrossPages ? commitPage([commit], 2, calls === 1 ? 'next' : null) : commitPage([commit, commit], 2, null)
+    })
+    const journal = createMemoryJournal()
+    const result = await runIngestion(request(pipeline, 'pull_request_commits'), { journal, destination: createMemoryDestination(), now: () => cutoff })
+    expect(result.ok).toBe(false)
+    expect(calls).toBe(acrossPages ? 2 : 1)
+    expect((await journal.readCheckpoint('github.pull_request_commits.obsessiondb.chkit')).lastSuccessSeq).toBe(0)
+  }
+})
+
+test('GitHub binds configuration and preserves independently selected installation and repository progress', async () => {
+  const requests: URL[] = []
+  const config = { ...githubConfig, sourceId: 'github.fixture', repositories: ['first/repo', 'second/repo'], pageSize: 25, start: new Date('2025-01-01'), overlapMs: 60_000 }
+  const pipeline = createGitHubPipeline(config, { token: () => 'bound-token', fetch: async (input, init) => {
+    const url = new URL(input)
+    requests.push(url)
+    expect(new Headers(init.headers).get('authorization')).toBe('Bearer bound-token')
+    expect(url.searchParams.get('per_page')).toBe('25')
+    return Response.json([])
+  } })
+  config.pageSize = 100
+  config.repositories.push('third/repo')
+  config.start.setUTCFullYear(2000)
+  config.overlapMs = 3_600_000
+  expect(pipeline.streams.map((stream) => stream.id).sort()).toEqual(['first.repo', 'second.repo'].flatMap((repo) => resources.map((resource) => `github.fixture.${resource}.${repo}`)).sort())
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  expect((await runIngestion(request(pipeline), { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect(requests.filter((url) => url.searchParams.has('since')).every((url) => url.searchParams.get('since') === '2025-01-01T00:00:00.000Z')).toBe(true)
+  requests.length = 0
+  const selected = selectStreams([pipeline], ['repository:second/repo', 'resource:issues'])
+  expect(selected.map((entry) => entry.stream.id)).toEqual(['github.fixture.issues.second.repo'])
+  expect((await runIngestion({ selected, backfill: undefined }, { journal, destination, now: () => new Date('2026-01-03') })).ok).toBe(true)
+  expect(requests.map((url) => url.pathname)).toEqual(['/repos/second/repo/issues'])
+  expect(requests[0]?.searchParams.get('since')).toBe('2026-01-01T23:59:00.000Z')
+  expect((await journal.readCheckpoint('github.issues.obsessiondb.chkit')).envelope).toBeUndefined()
+})
+
+test('GitHub paginated HTTP rate limits consume exactly one request retry budget', async () => {
+  let attempts = 0
+  const pipeline = fixturePipeline(() => ++attempts === 1
+    ? new Response('rate limited', { status: 403, headers: { 'x-ratelimit-remaining': '0', 'retry-after': '0' } }) : Response.json([]))
+  const selected = request(pipeline, 'stargazers').selected.map((entry) => ({ ...entry, stream: { ...entry.stream, retry: { retries: 1, minTimeout: 0, maxTimeout: 0 } } }))
+  const journal = createMemoryJournal()
+  expect((await runIngestion({ selected, backfill: undefined }, { journal, destination: createMemoryDestination(), now: () => cutoff })).ok).toBe(true)
+  expect(attempts).toBe(2)
+  expect(journal.events.filter((event) => event.eventKind === 'retry_scheduled' && event.errorClass === 'rate_limited')).toHaveLength(1)
+})
+
+test('GraphQL HTTP200 rate errors honor Retry-After while partial data fails permanently', async () => {
+  for (const retryable of [true, false]) {
+    let attempts = 0
+    const pipeline = fixturePipeline((url, init) => {
+      if (url.pathname !== '/graphql') return fixtureResponse(url, init)
+      attempts++
+      if (retryable && attempts > 1) return commitPage([commit], 1, null)
+      return Response.json({ data: { repository: null }, errors: [{ type: retryable ? 'RATE_LIMITED' : 'NOT_FOUND', message: 'query rejected' }] },
+        { headers: retryable ? { 'Retry-After': '0', 'x-ratelimit-remaining': '0' } : {} })
+    })
+    const selected = request(pipeline, 'pull_request_commits').selected.map((entry) => ({ ...entry, stream: { ...entry.stream, retry: { retries: 1, minTimeout: 0, maxTimeout: 0 } } }))
+    const journal = createMemoryJournal()
+    const result = await runIngestion({ selected, backfill: undefined }, { journal, destination: createMemoryDestination(), now: () => cutoff })
+    expect(result.ok).toBe(retryable)
+    expect(attempts).toBe(retryable ? 2 : 1)
+    expect(journal.events.filter((event) => event.eventKind === 'retry_scheduled')).toHaveLength(retryable ? 1 : 0)
+  }
+})
+
+test('secondary REST rate limits and headerless GraphQL rate errors retain provider diagnostics', async () => {
+  const rest = await HttpError.fromResponse(Response.json({ message: 'You have exceeded a secondary rate limit.' },
+    { status: 403, headers: { 'x-ratelimit-remaining': '19' } }))
+  expect(rest.status).toBe(403)
+  expect(rest.body).toContain('secondary rate limit')
+  expect(classifyGitHubError(rest)).toEqual({ kind: 'rate_limited', retryAfterMs: 60_000 })
+  const payload = { data: { repository: null }, errors: [{ type: 'RATE_LIMITED', message: 'API rate limit exceeded' }] }
+  const failure: unknown = await requestGitHubGraphql('query { viewer { login } }', {}, new AbortController().signal,
+    { token: () => 'fixture', fetch: async () => Response.json(payload) }).catch((cause: unknown) => cause)
+  expect(failure).toBeInstanceOf(HttpError)
+  expect(failure).toMatchObject({ status: 200, body: JSON.stringify(payload) })
+  expect(classifyGitHubError(failure)).toEqual({ kind: 'rate_limited', retryAfterMs: 60_000 })
+})
+
+test('invalid REST continuations and payloads fail without completing or replaying the resource', async () => {
+  for (const mode of ['repeated', 'foreign', 'malformed']) {
+    let calls = 0
+    const pipeline = fixturePipeline((url) => {
+      calls++
+      return mode === 'malformed' ? Response.json({ not: 'an array' })
+        : Response.json([stargazer], { headers: { Link: `<${mode === 'foreign' ? 'https://example.com/steal' : url.toString()}>; rel="next"` } })
+    })
+    const journal = createMemoryJournal(), destination = createMemoryDestination()
+    const result = await runIngestion(request(pipeline, 'stargazers'), { journal, destination, now: () => cutoff })
+    expect(result.ok).toBe(false)
+    expect(calls).toBe(1)
+    expect(destination.tables.size).toBe(0)
+    expect((await journal.readCheckpoint('github.stargazers.obsessiondb.chkit')).lastSuccessSeq).toBe(0)
+  }
+})
+
+test('GraphQL malformed or cyclic cursors and invalid commit nodes never record successful completion', async () => {
+  for (const mode of ['missing-cursor', 'repeated', 'missing-message']) {
+    let calls = 0
+    const pipeline = fixturePipeline((url, init) => {
+      if (url.pathname !== '/graphql') return fixtureResponse(url, init)
+      calls++
+      const page = { totalCount: mode === 'repeated' ? 3 : 1,
+        nodes: [{ commit: mode === 'missing-message' ? { oid: commit.sha }
+          : { oid: mode === 'repeated' ? String(calls).padStart(40, '0') : commit.sha, message: commit.message } }],
+        pageInfo: { hasNextPage: mode !== 'missing-message', endCursor: mode === 'missing-cursor' ? null : 'same' } }
+      return Response.json({ data: { repository: { pullRequest: { commits: page } } } })
+    })
+    const journal = createMemoryJournal()
+    const result = await runIngestion(request(pipeline, 'pull_request_commits'), { journal, destination: createMemoryDestination(), now: () => cutoff })
+    expect(result.ok).toBe(false)
+    expect(calls).toBe(mode === 'repeated' ? 2 : 1)
+    if (mode === 'repeated') expect(result.streams[0]?.error).toContain('repeated continuation')
+    expect((await journal.readCheckpoint('github.pull_request_commits.obsessiondb.chkit')).lastSuccessSeq).toBe(0)
+  }
+})
+
+test('review comments reject a parent URL from another repository before claiming a watermark', async () => {
+  const pipeline = fixturePipeline(() => Response.json([{ ...reviewComment, pull_request_url: 'https://api.github.com/repos/another/project/pulls/2' }]))
+  const journal = createMemoryJournal()
+  const result = await runIngestion(request(pipeline, 'pull_request_review_comments'), { journal, destination: createMemoryDestination(), now: () => cutoff })
+  expect(result.ok).toBe(false)
+  expect((await journal.readCheckpoint('github.pull_request_review_comments.obsessiondb.chkit')).envelope).toBeUndefined()
+})
+
+function fixturePipeline(respond: Responder = fixtureResponse, config: GitHubConfig = githubConfig): Pipeline {
+  return createGitHubPipeline(config, { token: () => 'fixture', fetch: (url, init) => Promise.resolve(respond(new URL(url), init)) })
+}
+
+function request(pipeline: Pipeline, resource?: string) {
+  return { selected: selectStreams([pipeline], resource ? [`resource:${resource}`] : []).map((entry) => ({
+    ...entry, stream: { ...entry.stream, batchSize: 1, retry: { retries: 0 } },
+  })), backfill: undefined }
+}
+
+function fixtureResponse(url: URL, _init: RequestInit): Response {
+  if (url.pathname === `/repos/${repository}/issues`) return Response.json([issue, pullIssue])
+  if (url.pathname === `/repos/${repository}/pulls`) return Response.json([pull])
+  if (url.pathname.endsWith('/issues/1/comments')) return Response.json([issueComment])
+  if (url.pathname.endsWith('/issues/2/comments')) return Response.json([pullComment])
+  if (url.pathname.endsWith('/pulls/comments')) return Response.json([reviewComment])
+  if (url.pathname.endsWith('/pulls/2/reviews')) return Response.json([review])
+  if (url.pathname.endsWith('/stargazers')) return Response.json([stargazer])
+  if (url.pathname === '/graphql') return commitPage([commit], 1, null)
+  throw new IngestConfigError(`Unexpected GitHub fixture request: ${url}`)
+}
+
+function commitPage(items: readonly { sha: string; message: string }[], totalCount: number, next: string | null): Response {
+  return Response.json({ data: { repository: { pullRequest: { commits: { totalCount,
+    nodes: items.map((item) => ({ commit: { oid: item.sha, message: item.message, author: { name: 'Do not retain expanded commit fields' } } })),
+    pageInfo: { hasNextPage: next !== null, endCursor: next },
+  } } } } })
+}
diff --git a/registry/google-calendar/README.md b/registry/google-calendar/README.md
index 8f569696..8255d22f 100644
--- a/registry/google-calendar/README.md
+++ b/registry/google-calendar/README.md
@@ -1,8 +1,8 @@
-# Google Calendar raw ingestion example
+# Google Calendar raw ingestion
 
-This is a small editable starting point based on the Google-Calendar source in [obsessiondb/brain](https://github.com/obsessiondb/brain/tree/main/scripts/brain-sync). It stores provider responses as native JSON without Brain's memory or sales projections.
+This editable reader stores canonical Google Calendar responses as native JSON and checkpoints provider sync tokens in the chkit ingestion journal. It follows the recoverable ingestion patterns in [obsessiondb/brain](https://github.com/obsessiondb/brain/tree/main/scripts/brain-sync), using Google's change-token protocol for canonical events.
 
-Set `GOOGLE_CALENDAR_ACCESS_TOKEN` in the runtime environment and configure a direct ClickHouse connection. Edit `calendarId`, `pastDays`, and `futureDays` in `index.ts` before the first migration. Native JSON requires ClickHouse 25.3 or later.
+Set `GOOGLE_CALENDAR_ACCESS_TOKEN` in the runtime environment and configure a direct ClickHouse connection. Review `sourceId`, `streamPrefix`, `calendarId`, `database`, and `maxChunks` in `config.ts`. Native JSON requires ClickHouse 25.3 or later. Keep `sourceId` tied to one OAuth installation. Schema imports do not need credentials; requests read the token at runtime and do not refresh it.
 
 ```sh
 bunx chkit check
@@ -10,10 +10,50 @@ bunx chkit generate --name add_google_calendar
 # Review the migration before applying it.
 bunx chkit migrate --apply
 bunx chkit ingest run --tag provider:google-calendar
+bunx chkit ingest status --tag provider:google-calendar
 ```
 
-## Resources
+## Resources and identities
 
 - `events` → `google_calendar_events_raw`
 
-Each run reads a configured time range. Events outside the range and deleted records are not reconciled. A failed API request fails the stream. Raw rows use provider IDs and keep the last observed value; there is no deletion reconciliation. Edit the readers, select fewer streams, or add SQL views for a specific use case. Run one ingestion process per ClickHouse target at a time.
+The first run reads canonical events with `singleEvents=false` and `showDeleted=true`: one-off events, recurring series masters, exceptions, and cancellation payloads. It does not expand every occurrence of a recurring series. Raw row IDs are `[sourceId, resolvedCalendarId, event.id]`; calendar metadata resolves `primary` to a stable calendar ID and prevents a different account from silently reusing its checkpoint.
+
+The raw destination keeps the latest observed payload per identity. A recurring master contains recurrence rules; applications needing occurrences should add a separate bounded instances reader or derive an occurrence projection. A cancelled payload can be sparse and remains unmodified.
+
+Attendees, organizer, recurrence, reminders, attachments, and `conferenceData` remain native fields inside each event, as returned by Google. Calendar metadata is used only to resolve the calendar identity. This installation collects events only; it does not add attendee, calendar-directory, attachment, or Meet tables. Project fields and join other integrations later in ClickHouse, preserving source and calendar identity.
+
+## Pipeline and stream
+
+One installation exports one `google_calendarPipeline` with the canonical `events` stream. `pipeline.ts` wires the stream to its destination and sync-token strategy; `sources/events.ts` owns provider progress, and `client.ts` owns validated requests. The ingestion library owns retries, cancellation, budgets, and load acknowledgements.
+
+`sourceId` scopes raw identities and checkpoint query state. `streamPrefix` scopes pipeline and journal IDs; the defaults keep `google-calendar.events` and its existing checkpoint. Use a separate source label and stream prefix for another installation. `createGoogleCalendarPipeline` in `pipeline.ts` snapshots reader settings and binds injectable fetch/token dependencies. It uses the exported raw destination; edit `database` in the installation's `config.ts` before schema imports to change its placement. Database placement is a setup-time schema setting, excluded from runtime reader configuration.
+
+## Checkpoints and recovery
+
+Each acknowledged event page checkpoints its next page token while retaining the same input sync token. Only an acknowledged terminal page promotes `nextSyncToken`. Empty terminal pages also commit progress. A failed load leaves the preceding checkpoint, so rerunning resumes safely and may replay observations. Requests have a 30-second timeout. Each run permits 200 page chunks; budget exhaustion preserves progress for the next run. The executor owns retries, cancellation, and sink acknowledgements; run one ingestion process per ClickHouse target at a time.
+
+`paginate()` carries each page's raw events and complete checkpoint candidate in metadata, including empty terminal pages. The reader yields `page.items` as rows and the metadata checkpoint as chunk state; the library checks repeated continuations before exposing that candidate. A rejected token produces an empty reset page with a fresh continuation and checkpointed recovery debt, so recovery uses the same pagination loop. The saved checkpoint format is unchanged.
+
+Subsequent runs send the committed `syncToken` and ingest Google's changes, including cancelled events. All pages use fixed request parameters. `syncToken` cannot be combined with `timeMin`, `timeMax`, `updatedMin`, or `orderBy`, so this reader rejects explicit `--from`/`--to` bounds. A separately named backfill without date bounds has an isolated checkpoint and performs its own canonical sync. See [Google's synchronization guide](https://developers.google.com/workspace/calendar/api/guides/sync) and [events.list](https://developers.google.com/workspace/calendar/api/v3/reference/events/list).
+
+`410 Gone` on an incremental request clears provider progress and starts a full baseline. A rejected page token replays its current sync once; repeated rejection fails visibly. Neither recovery path drops stored raw rows. A record absent from the rebuilt baseline can remain in ClickHouse, so this table is a latest-observed archive, not a reconciled current calendar. A current-state projection needs completed-baseline generations or explicit reconciliation before treating absence as removal.
+
+The recovery count stays in the checkpoint until the terminal sync page has destination acknowledgement. Pausing immediately after recovery or successfully replaying a nonterminal page keeps that count. A second token rejection for the same unfinished sync fails across scheduled executions. Edit `maxChunks` in `config.ts` to change the stream chunk cap, choose sufficient `--max-duration`, and run frequently enough to finish while provider tokens remain valid. After correcting those conditions and reviewing coverage, migrate the saved state explicitly or use a new stream identity for a deliberate fresh sync.
+
+Checkpoint state validates source/query scope and resolved calendar identity. Changing source settings requires an explicit state migration or another stream ID; the reader never silently reinterprets old progress.
+
+## Upgrading from 0.1.x
+
+Version 0.2.0 replaces the rolling occurrence window with canonical change-token sync and changes row identities to include the resolved calendar and installation. Keep the existing raw table as an archive and use a new table/stream identity for a fresh canonical dataset, or deliberately migrate existing row identities. Existing expanded occurrences are not removed automatically.
+
+## Fixture tests
+
+```sh
+bunx chkit add google-calendar --with-tests
+bun test src/integrations/google-calendar/tests/basic.test.ts
+```
+
+Fixtures verify page resumption, empty deltas, terminal token promotion after loads, cancellation payloads, token expiry, scope changes, malformed pagination, isolated factory configuration, and request-time token rotation without live credentials.
+
+The [Google Calendar integration guide](https://chkit.obsessiondb.com/integrations/google-calendar/) covers installation and sync behavior.
diff --git a/registry/google-calendar/client.ts b/registry/google-calendar/client.ts
new file mode 100644
index 00000000..4e02c3a6
--- /dev/null
+++ b/registry/google-calendar/client.ts
@@ -0,0 +1,79 @@
+import { HttpError, IngestConfigError, type ErrorClassifier, type FetchContext } from '@chkit/plugin-ingest'
+
+import { googleCalendarConfig, type GoogleCalendarReaderConfig } from './config.js'
+import type { CalendarState } from './sources/events.js'
+
+export interface CalendarEvent { id: string; [key: string]: unknown }
+interface Page { items: CalendarEvent[]; nextPageToken?: string; nextSyncToken?: string }
+
+export interface GoogleCalendarClientDeps {
+  config: GoogleCalendarReaderConfig
+  fetch: (url: string, init: RequestInit) => Promise<Response>
+  token: () => string | undefined
+}
+
+export const defaultGoogleCalendarClientDeps: GoogleCalendarClientDeps = {
+  config: googleCalendarConfig,
+  fetch: (url, init) => fetch(url, init),
+  token: () => process.env.GOOGLE_CALENDAR_ACCESS_TOKEN,
+}
+
+export const classifyGoogleCalendarError: ErrorClassifier = (cause) =>
+  cause instanceof IngestConfigError || cause instanceof SyntaxError ? { kind: 'permanent' } : undefined
+
+export async function resolveCalendar(context: FetchContext, deps: GoogleCalendarClientDeps): Promise<string> {
+  return context.attempt(async (signal) => {
+    const payload = await request(`calendars/${encodeURIComponent(deps.config.calendarId)}`, signal, deps)
+    return requiredString(payload.id, 'calendar id')
+  }, { label: 'GET calendar metadata' })
+}
+
+/** paginate owns the single executor attempt around this page request. */
+export async function requestEvents(state: CalendarState, signal: AbortSignal, deps: GoogleCalendarClientDeps): Promise<Page | { reset: 'sync' | 'page' }> {
+  const url = new URL(`https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(state.calendarId)}/events`)
+  for (const [key, value] of Object.entries({ singleEvents: 'false', showDeleted: 'true', maxResults: '250' })) url.searchParams.set(key, value)
+  if (state.syncToken) url.searchParams.set('syncToken', state.syncToken)
+  if (state.pageToken) url.searchParams.set('pageToken', state.pageToken)
+  const response = await deps.fetch(url.toString(), { signal: AbortSignal.any([signal, AbortSignal.timeout(30_000)]), headers: authorization(deps), redirect: 'error' })
+  if (response.status === 410 && state.syncToken) return { reset: 'sync' }
+  if ((response.status === 400 || response.status === 410) && state.pageToken) return { reset: 'page' }
+  if (!response.ok) throw await HttpError.fromResponse(response)
+  const payload: unknown = await response.json()
+  if (!isObject(payload) || (payload.items !== undefined && !Array.isArray(payload.items))) throw new IngestConfigError('Calendar items are not an array.')
+  const items = (payload.items ?? []).map((item: unknown) => {
+    if (!isObject(item)) throw new IngestConfigError('Calendar returned an invalid event.')
+    return { ...item, id: requiredString(item.id, 'event id') }
+  })
+  const nextPageToken = optionalString(payload.nextPageToken, 'nextPageToken')
+  const nextSyncToken = optionalString(payload.nextSyncToken, 'nextSyncToken')
+  if (nextPageToken && nextSyncToken) throw new IngestConfigError('Calendar returned both a page and sync token.')
+  if (!nextPageToken && !nextSyncToken) throw new IngestConfigError('Calendar terminal page has no nextSyncToken.')
+  return { items, nextPageToken, nextSyncToken }
+}
+
+async function request(path: string, signal: AbortSignal, deps: GoogleCalendarClientDeps): Promise<Record<string, unknown>> {
+  const response = await deps.fetch(`https://www.googleapis.com/calendar/v3/${path}`, { signal: AbortSignal.any([signal, AbortSignal.timeout(30_000)]), headers: authorization(deps), redirect: 'error' })
+  if (!response.ok) throw await HttpError.fromResponse(response)
+  const payload: unknown = await response.json()
+  if (!isObject(payload)) throw new IngestConfigError('Calendar returned an invalid response.')
+  return payload
+}
+
+function authorization(deps: GoogleCalendarClientDeps): Record<string, string> {
+  const token = deps.token()?.trim()
+  if (!token) throw new IngestConfigError('Set GOOGLE_CALENDAR_ACCESS_TOKEN.')
+  return { Authorization: `Bearer ${token}` }
+}
+
+export function optionalString(value: unknown, field: string): string | undefined {
+  return value === undefined ? undefined : requiredString(value, field)
+}
+
+export function requiredString(value: unknown, field: string): string {
+  if (typeof value !== 'string' || value.trim().length === 0) throw new IngestConfigError(`Calendar ${field} must be a non-empty string.`)
+  return value
+}
+
+export function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
diff --git a/registry/google-calendar/config.ts b/registry/google-calendar/config.ts
new file mode 100644
index 00000000..c37dd7b7
--- /dev/null
+++ b/registry/google-calendar/config.ts
@@ -0,0 +1,21 @@
+export interface GoogleCalendarConfig {
+  /** Stable, non-secret label for one OAuth installation. */
+  sourceId: string
+  /** Journal identities use this prefix; change it for a separate installation. */
+  streamPrefix: string
+  calendarId: string
+  database: string
+  maxChunks: number
+}
+
+/** Runtime settings; the exported destination schemas use database at setup time. */
+export type GoogleCalendarReaderConfig = Omit<GoogleCalendarConfig, 'database'>
+
+// Set schema placement before importing index.ts. Credentials are read at request time.
+export const googleCalendarConfig: GoogleCalendarConfig = {
+  sourceId: 'google-calendar.primary',
+  streamPrefix: 'google-calendar',
+  calendarId: 'primary',
+  database: 'default',
+  maxChunks: 200,
+}
diff --git a/registry/google-calendar/index.ts b/registry/google-calendar/index.ts
index ffe7d2dd..690c3159 100644
--- a/registry/google-calendar/index.ts
+++ b/registry/google-calendar/index.ts
@@ -1,45 +1,2 @@
-import { definePipeline, defineStream, HttpError, rawRows, rawTable, type FetchContext } from '@chkit/plugin-ingest'
-
-const database = 'default'
-const calendarId = 'primary'
-// Change these bounds to the events relevant to the project.
-const pastDays = 365
-const futureDays = 180
-
-interface Event { id: string; [key: string]: unknown }
-interface Page { items?: Event[]; nextPageToken?: string }
-
-export const google_calendar_eventsRaw = rawTable({ database, name: 'google_calendar_events_raw' })
-
-export const google_calendarPipeline = definePipeline({
-  id: 'google-calendar', tags: ['provider:google-calendar'], maxFetches: 1,
-  streams: [defineStream({ id: 'google-calendar.events', tags: ['resource:events'], destination: google_calendar_eventsRaw,
-    async *read(context) {
-      let pageToken: string | undefined
-      const seen = new Set<string>()
-      do {
-        const page = await readPage(context, pageToken)
-        if (!Array.isArray(page.items ?? [])) throw new Error('Calendar items are not an array')
-        if (page.items?.length) yield { rows: rawRows(page.items, (event) => JSON.stringify([calendarId, event.id])) }
-        pageToken = page.nextPageToken
-        if (pageToken && seen.has(pageToken)) throw new Error('Calendar repeated a page token')
-        if (pageToken) seen.add(pageToken)
-      } while (pageToken)
-    },
-  })],
-})
-
-async function readPage(context: FetchContext, pageToken?: string): Promise<Page> {
-  return context.attempt(async (signal) => {
-    const token = process.env.GOOGLE_CALENDAR_ACCESS_TOKEN
-    if (!token) throw new Error('Set GOOGLE_CALENDAR_ACCESS_TOKEN')
-    const url = new URL(`https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(calendarId)}/events`)
-    const timeMin = new Date(Date.now() - pastDays * 86_400_000).toISOString()
-    const timeMax = new Date(Date.now() + futureDays * 86_400_000).toISOString()
-    for (const [key, value] of Object.entries({ singleEvents: 'true', showDeleted: 'true', maxResults: '250', timeMin, timeMax })) url.searchParams.set(key, value)
-    if (pageToken) url.searchParams.set('pageToken', pageToken)
-    const response = await fetch(url, { signal, headers: { Authorization: `Bearer ${token}` } })
-    if (!response.ok) throw await HttpError.fromResponse(response)
-    return await response.json() as Page
-  }, { label: 'GET calendar events' })
-}
+export { google_calendarPipeline } from './pipeline.js'
+export { google_calendar_eventsRaw } from './sources/events.js'
diff --git a/registry/google-calendar/manifest.json b/registry/google-calendar/manifest.json
index 0e05de09..15db1b4e 100644
--- a/registry/google-calendar/manifest.json
+++ b/registry/google-calendar/manifest.json
@@ -3,10 +3,10 @@
   "name": "google-calendar",
   "type": "registry:item",
   "title": "Google Calendar",
-  "description": "Small, editable Google Calendar API ingestion example with raw ClickHouse tables.",
+  "description": "Editable Google Calendar API ingestion with journaled checkpoints and raw ClickHouse tables.",
   "dependencies": [
-    "@chkit/core@^0.2.0-beta.8",
-    "@chkit/plugin-ingest@^0.2.0-beta.8"
+    "@chkit/core@^0.2.0-beta.10",
+    "@chkit/plugin-ingest@^0.2.0-beta.10"
   ],
   "files": [
     {
@@ -19,6 +19,26 @@
       "type": "registry:file",
       "target": "src/integrations/google-calendar/index.ts"
     },
+    {
+      "path": "config.ts",
+      "type": "registry:file",
+      "target": "src/integrations/google-calendar/config.ts"
+    },
+    {
+      "path": "client.ts",
+      "type": "registry:file",
+      "target": "src/integrations/google-calendar/client.ts"
+    },
+    {
+      "path": "pipeline.ts",
+      "type": "registry:file",
+      "target": "src/integrations/google-calendar/pipeline.ts"
+    },
+    {
+      "path": "sources/events.ts",
+      "type": "registry:file",
+      "target": "src/integrations/google-calendar/sources/events.ts"
+    },
     {
       "path": "tests/basic.test.ts",
       "type": "registry:file",
@@ -29,13 +49,32 @@
   "meta": {
     "chkit": {
       "formatVersion": 1,
-      "version": "0.1.0",
+      "version": "0.2.0",
+      "changelog": [
+        {
+          "version": "0.2.0",
+          "changes": [
+            "Replace the rolling occurrence window with canonical events and incremental provider sync tokens, including cancellation payloads.",
+            "Resume acknowledged pages, promote the terminal sync token after destination acknowledgement, and bound recovery from rejected or expired tokens.",
+            "Scope row IDs to the installation and resolved calendar; migrate legacy occurrence identities or use a fresh table and stream when upgrading.",
+            "Separate editable installation configuration, injectable HTTP clients, and resource readers from one pipeline; preserve independent stream identities and provider recovery.",
+            "Keep events as the sole raw resource with native nested fields and sparse cancellation observations; verify recurring-exception replacement without hydration.",
+            "Use full paginate pages and checkpoint metadata for canonical sync-token progress and bounded token recovery in one pagination loop, including empty terminal pages and the existing saved state format."
+          ]
+        },
+        {
+          "version": "0.1.0",
+          "changes": [
+            "Introduce raw events ingestion over a rolling occurrence window."
+          ]
+        }
+      ],
       "documentation": "https://chkit.obsessiondb.com/integrations/google-calendar/",
       "logo": "https://chkit.obsessiondb.com/logos/google-calendar.svg",
       "language": "typescript",
       "license": "MIT",
-      "chkit": "^0.2.0-beta.8",
-      "ingest": "^0.2.0-beta.8",
+      "chkit": "^0.2.0-beta.10",
+      "ingest": "^0.2.0-beta.10",
       "clickhouse": ">=25.3.0",
       "root": "src/integrations/google-calendar",
       "entry": "index.ts",
@@ -48,12 +87,17 @@
           "name": "events",
           "title": "Events",
           "table": "google_calendar_events_raw",
-          "description": "Events from the configured calendar, including cancelled events",
+          "description": "Canonical events, recurring masters, exceptions, and cancellation payloads from the configured calendar",
           "scopes": [
             "https://www.googleapis.com/auth/calendar.readonly"
           ],
-          "strategy": "full",
+          "strategy": "cursor",
           "endpoints": [
+            {
+              "method": "GET",
+              "path": "/calendars/{calendarId}",
+              "documentation": "https://developers.google.com/workspace/calendar/api/v3/reference/calendars/get"
+            },
             {
               "method": "GET",
               "path": "/calendars/{calendarId}/events",
@@ -78,10 +122,13 @@
       },
       "views": [],
       "sync": {
-        "description": "A full read runs for each enabled stream. Stable IDs keep the latest observed record.",
+        "description": "Initial canonical event read followed by Google sync-token deltas. Acknowledged pages resume from journaled state.",
         "schedule": "Run bunx chkit ingest run --tag provider:google-calendar from a scheduler.",
-        "deletions": "Each run reads a configured time range. Events outside the range and deleted records are not reconciled."
+        "deletions": "Cancellation payloads are retained. An expired token reboots provider progress without clearing raw observations; absent records are not reconciled."
       }
     }
-  }
+  },
+  "devDependencies": [
+    "@types/bun@^1.2.0"
+  ]
 }
diff --git a/registry/google-calendar/pipeline.ts b/registry/google-calendar/pipeline.ts
new file mode 100644
index 00000000..4c3a113b
--- /dev/null
+++ b/registry/google-calendar/pipeline.ts
@@ -0,0 +1,30 @@
+import { cursorState, definePipeline, defineStream, IngestConfigError } from '@chkit/plugin-ingest'
+
+import { classifyGoogleCalendarError, defaultGoogleCalendarClientDeps, type GoogleCalendarClientDeps } from './client.js'
+import { googleCalendarConfig, type GoogleCalendarReaderConfig } from './config.js'
+import { google_calendar_eventsRaw, parseCalendarState, readEvents, type CalendarState } from './sources/events.js'
+
+export function createGoogleCalendarPipeline(config: GoogleCalendarReaderConfig = googleCalendarConfig, deps: GoogleCalendarClientDeps = defaultGoogleCalendarClientDeps) {
+  const boundConfig = { ...config }
+  if (!boundConfig.sourceId.trim() || !boundConfig.streamPrefix.trim() || !boundConfig.calendarId.trim()) throw new IngestConfigError('Calendar sourceId, streamPrefix and calendarId must be non-empty strings.')
+  const client = { ...deps, config: boundConfig }
+  return definePipeline({
+    id: boundConfig.streamPrefix, tags: ['provider:google-calendar'], maxStreams: 1, maxFetches: 1,
+    streams: [defineStream({
+      id: `${boundConfig.streamPrefix}.events`, tags: ['resource:events'], destination: google_calendar_eventsRaw,
+      incremental: {
+        ...cursorState<CalendarState>({ id: `${boundConfig.streamPrefix}.sync-token`, version: 1, parse: (raw) => parseCalendarState(raw, boundConfig) }),
+        plan({ state, range }) {
+          if (range?.from || range?.to) throw new IngestConfigError('Calendar canonical sync does not accept date bounds. Use a separate bounded instances reader for an occurrence backfill.')
+          return state
+        },
+      },
+      batchSize: 1,
+      budget: { maxChunks: boundConfig.maxChunks, maxChunkRows: 250 },
+      classifyError: classifyGoogleCalendarError,
+      read: (context) => readEvents(context, client),
+    })],
+  })
+}
+
+export const google_calendarPipeline = createGoogleCalendarPipeline()
diff --git a/registry/google-calendar/releases/0.2.0.json b/registry/google-calendar/releases/0.2.0.json
new file mode 100644
index 00000000..42d22ebd
--- /dev/null
+++ b/registry/google-calendar/releases/0.2.0.json
@@ -0,0 +1,150 @@
+{
+  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
+  "name": "google-calendar",
+  "type": "registry:item",
+  "title": "Google Calendar",
+  "description": "Editable Google Calendar API ingestion with journaled checkpoints and raw ClickHouse tables.",
+  "dependencies": [
+    "@chkit/core@^0.2.0-beta.10",
+    "@chkit/plugin-ingest@^0.2.0-beta.10"
+  ],
+  "devDependencies": [
+    "@types/bun@^1.2.0"
+  ],
+  "files": [
+    {
+      "path": "google-calendar/README.md",
+      "type": "registry:file",
+      "target": "src/integrations/google-calendar/README.md",
+      "content": "# Google Calendar raw ingestion\n\nThis editable reader stores canonical Google Calendar responses as native JSON and checkpoints provider sync tokens in the chkit ingestion journal. It follows the recoverable ingestion patterns in [obsessiondb/brain](https://github.com/obsessiondb/brain/tree/main/scripts/brain-sync), using Google's change-token protocol for canonical events.\n\nSet `GOOGLE_CALENDAR_ACCESS_TOKEN` in the runtime environment and configure a direct ClickHouse connection. Review `sourceId`, `streamPrefix`, `calendarId`, `database`, and `maxChunks` in `config.ts`. Native JSON requires ClickHouse 25.3 or later. Keep `sourceId` tied to one OAuth installation. Schema imports do not need credentials; requests read the token at runtime and do not refresh it.\n\n```sh\nbunx chkit check\nbunx chkit generate --name add_google_calendar\n# Review the migration before applying it.\nbunx chkit migrate --apply\nbunx chkit ingest run --tag provider:google-calendar\nbunx chkit ingest status --tag provider:google-calendar\n```\n\n## Resources and identities\n\n- `events` → `google_calendar_events_raw`\n\nThe first run reads canonical events with `singleEvents=false` and `showDeleted=true`: one-off events, recurring series masters, exceptions, and cancellation payloads. It does not expand every occurrence of a recurring series. Raw row IDs are `[sourceId, resolvedCalendarId, event.id]`; calendar metadata resolves `primary` to a stable calendar ID and prevents a different account from silently reusing its checkpoint.\n\nThe raw destination keeps the latest observed payload per identity. A recurring master contains recurrence rules; applications needing occurrences should add a separate bounded instances reader or derive an occurrence projection. A cancelled payload can be sparse and remains unmodified.\n\nAttendees, organizer, recurrence, reminders, attachments, and `conferenceData` remain native fields inside each event, as returned by Google. Calendar metadata is used only to resolve the calendar identity. This installation collects events only; it does not add attendee, calendar-directory, attachment, or Meet tables. Project fields and join other integrations later in ClickHouse, preserving source and calendar identity.\n\n## Pipeline and stream\n\nOne installation exports one `google_calendarPipeline` with the canonical `events` stream. `pipeline.ts` wires the stream to its destination and sync-token strategy; `sources/events.ts` owns provider progress, and `client.ts` owns validated requests. The ingestion library owns retries, cancellation, budgets, and load acknowledgements.\n\n`sourceId` scopes raw identities and checkpoint query state. `streamPrefix` scopes pipeline and journal IDs; the defaults keep `google-calendar.events` and its existing checkpoint. Use a separate source label and stream prefix for another installation. `createGoogleCalendarPipeline` in `pipeline.ts` snapshots reader settings and binds injectable fetch/token dependencies. It uses the exported raw destination; edit `database` in the installation's `config.ts` before schema imports to change its placement. Database placement is a setup-time schema setting, excluded from runtime reader configuration.\n\n## Checkpoints and recovery\n\nEach acknowledged event page checkpoints its next page token while retaining the same input sync token. Only an acknowledged terminal page promotes `nextSyncToken`. Empty terminal pages also commit progress. A failed load leaves the preceding checkpoint, so rerunning resumes safely and may replay observations. Requests have a 30-second timeout. Each run permits 200 page chunks; budget exhaustion preserves progress for the next run. The executor owns retries, cancellation, and sink acknowledgements; run one ingestion process per ClickHouse target at a time.\n\n`paginate()` carries each page's raw events and complete checkpoint candidate in metadata, including empty terminal pages. The reader yields `page.items` as rows and the metadata checkpoint as chunk state; the library checks repeated continuations before exposing that candidate. A rejected token produces an empty reset page with a fresh continuation and checkpointed recovery debt, so recovery uses the same pagination loop. The saved checkpoint format is unchanged.\n\nSubsequent runs send the committed `syncToken` and ingest Google's changes, including cancelled events. All pages use fixed request parameters. `syncToken` cannot be combined with `timeMin`, `timeMax`, `updatedMin`, or `orderBy`, so this reader rejects explicit `--from`/`--to` bounds. A separately named backfill without date bounds has an isolated checkpoint and performs its own canonical sync. See [Google's synchronization guide](https://developers.google.com/workspace/calendar/api/guides/sync) and [events.list](https://developers.google.com/workspace/calendar/api/v3/reference/events/list).\n\n`410 Gone` on an incremental request clears provider progress and starts a full baseline. A rejected page token replays its current sync once; repeated rejection fails visibly. Neither recovery path drops stored raw rows. A record absent from the rebuilt baseline can remain in ClickHouse, so this table is a latest-observed archive, not a reconciled current calendar. A current-state projection needs completed-baseline generations or explicit reconciliation before treating absence as removal.\n\nThe recovery count stays in the checkpoint until the terminal sync page has destination acknowledgement. Pausing immediately after recovery or successfully replaying a nonterminal page keeps that count. A second token rejection for the same unfinished sync fails across scheduled executions. Edit `maxChunks` in `config.ts` to change the stream chunk cap, choose sufficient `--max-duration`, and run frequently enough to finish while provider tokens remain valid. After correcting those conditions and reviewing coverage, migrate the saved state explicitly or use a new stream identity for a deliberate fresh sync.\n\nCheckpoint state validates source/query scope and resolved calendar identity. Changing source settings requires an explicit state migration or another stream ID; the reader never silently reinterprets old progress.\n\n## Upgrading from 0.1.x\n\nVersion 0.2.0 replaces the rolling occurrence window with canonical change-token sync and changes row identities to include the resolved calendar and installation. Keep the existing raw table as an archive and use a new table/stream identity for a fresh canonical dataset, or deliberately migrate existing row identities. Existing expanded occurrences are not removed automatically.\n\n## Fixture tests\n\n```sh\nbunx chkit add google-calendar --with-tests\nbun test src/integrations/google-calendar/tests/basic.test.ts\n```\n\nFixtures verify page resumption, empty deltas, terminal token promotion after loads, cancellation payloads, token expiry, scope changes, malformed pagination, isolated factory configuration, and request-time token rotation without live credentials.\n\nThe [Google Calendar integration guide](https://chkit.obsessiondb.com/integrations/google-calendar/) covers installation and sync behavior.\n"
+    },
+    {
+      "path": "google-calendar/index.ts",
+      "type": "registry:file",
+      "target": "src/integrations/google-calendar/index.ts",
+      "content": "export { google_calendarPipeline } from './pipeline.js'\nexport { google_calendar_eventsRaw } from './sources/events.js'\n"
+    },
+    {
+      "path": "google-calendar/config.ts",
+      "type": "registry:file",
+      "target": "src/integrations/google-calendar/config.ts",
+      "content": "export interface GoogleCalendarConfig {\n  /** Stable, non-secret label for one OAuth installation. */\n  sourceId: string\n  /** Journal identities use this prefix; change it for a separate installation. */\n  streamPrefix: string\n  calendarId: string\n  database: string\n  maxChunks: number\n}\n\n/** Runtime settings; the exported destination schemas use database at setup time. */\nexport type GoogleCalendarReaderConfig = Omit<GoogleCalendarConfig, 'database'>\n\n// Set schema placement before importing index.ts. Credentials are read at request time.\nexport const googleCalendarConfig: GoogleCalendarConfig = {\n  sourceId: 'google-calendar.primary',\n  streamPrefix: 'google-calendar',\n  calendarId: 'primary',\n  database: 'default',\n  maxChunks: 200,\n}\n"
+    },
+    {
+      "path": "google-calendar/client.ts",
+      "type": "registry:file",
+      "target": "src/integrations/google-calendar/client.ts",
+      "content": "import { HttpError, IngestConfigError, type ErrorClassifier, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { googleCalendarConfig, type GoogleCalendarReaderConfig } from './config.js'\nimport type { CalendarState } from './sources/events.js'\n\nexport interface CalendarEvent { id: string; [key: string]: unknown }\ninterface Page { items: CalendarEvent[]; nextPageToken?: string; nextSyncToken?: string }\n\nexport interface GoogleCalendarClientDeps {\n  config: GoogleCalendarReaderConfig\n  fetch: (url: string, init: RequestInit) => Promise<Response>\n  token: () => string | undefined\n}\n\nexport const defaultGoogleCalendarClientDeps: GoogleCalendarClientDeps = {\n  config: googleCalendarConfig,\n  fetch: (url, init) => fetch(url, init),\n  token: () => process.env.GOOGLE_CALENDAR_ACCESS_TOKEN,\n}\n\nexport const classifyGoogleCalendarError: ErrorClassifier = (cause) =>\n  cause instanceof IngestConfigError || cause instanceof SyntaxError ? { kind: 'permanent' } : undefined\n\nexport async function resolveCalendar(context: FetchContext, deps: GoogleCalendarClientDeps): Promise<string> {\n  return context.attempt(async (signal) => {\n    const payload = await request(`calendars/${encodeURIComponent(deps.config.calendarId)}`, signal, deps)\n    return requiredString(payload.id, 'calendar id')\n  }, { label: 'GET calendar metadata' })\n}\n\n/** paginate owns the single executor attempt around this page request. */\nexport async function requestEvents(state: CalendarState, signal: AbortSignal, deps: GoogleCalendarClientDeps): Promise<Page | { reset: 'sync' | 'page' }> {\n  const url = new URL(`https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(state.calendarId)}/events`)\n  for (const [key, value] of Object.entries({ singleEvents: 'false', showDeleted: 'true', maxResults: '250' })) url.searchParams.set(key, value)\n  if (state.syncToken) url.searchParams.set('syncToken', state.syncToken)\n  if (state.pageToken) url.searchParams.set('pageToken', state.pageToken)\n  const response = await deps.fetch(url.toString(), { signal: AbortSignal.any([signal, AbortSignal.timeout(30_000)]), headers: authorization(deps), redirect: 'error' })\n  if (response.status === 410 && state.syncToken) return { reset: 'sync' }\n  if ((response.status === 400 || response.status === 410) && state.pageToken) return { reset: 'page' }\n  if (!response.ok) throw await HttpError.fromResponse(response)\n  const payload: unknown = await response.json()\n  if (!isObject(payload) || (payload.items !== undefined && !Array.isArray(payload.items))) throw new IngestConfigError('Calendar items are not an array.')\n  const items = (payload.items ?? []).map((item: unknown) => {\n    if (!isObject(item)) throw new IngestConfigError('Calendar returned an invalid event.')\n    return { ...item, id: requiredString(item.id, 'event id') }\n  })\n  const nextPageToken = optionalString(payload.nextPageToken, 'nextPageToken')\n  const nextSyncToken = optionalString(payload.nextSyncToken, 'nextSyncToken')\n  if (nextPageToken && nextSyncToken) throw new IngestConfigError('Calendar returned both a page and sync token.')\n  if (!nextPageToken && !nextSyncToken) throw new IngestConfigError('Calendar terminal page has no nextSyncToken.')\n  return { items, nextPageToken, nextSyncToken }\n}\n\nasync function request(path: string, signal: AbortSignal, deps: GoogleCalendarClientDeps): Promise<Record<string, unknown>> {\n  const response = await deps.fetch(`https://www.googleapis.com/calendar/v3/${path}`, { signal: AbortSignal.any([signal, AbortSignal.timeout(30_000)]), headers: authorization(deps), redirect: 'error' })\n  if (!response.ok) throw await HttpError.fromResponse(response)\n  const payload: unknown = await response.json()\n  if (!isObject(payload)) throw new IngestConfigError('Calendar returned an invalid response.')\n  return payload\n}\n\nfunction authorization(deps: GoogleCalendarClientDeps): Record<string, string> {\n  const token = deps.token()?.trim()\n  if (!token) throw new IngestConfigError('Set GOOGLE_CALENDAR_ACCESS_TOKEN.')\n  return { Authorization: `Bearer ${token}` }\n}\n\nexport function optionalString(value: unknown, field: string): string | undefined {\n  return value === undefined ? undefined : requiredString(value, field)\n}\n\nexport function requiredString(value: unknown, field: string): string {\n  if (typeof value !== 'string' || value.trim().length === 0) throw new IngestConfigError(`Calendar ${field} must be a non-empty string.`)\n  return value\n}\n\nexport function isObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value)\n}\n"
+    },
+    {
+      "path": "google-calendar/pipeline.ts",
+      "type": "registry:file",
+      "target": "src/integrations/google-calendar/pipeline.ts",
+      "content": "import { cursorState, definePipeline, defineStream, IngestConfigError } from '@chkit/plugin-ingest'\n\nimport { classifyGoogleCalendarError, defaultGoogleCalendarClientDeps, type GoogleCalendarClientDeps } from './client.js'\nimport { googleCalendarConfig, type GoogleCalendarReaderConfig } from './config.js'\nimport { google_calendar_eventsRaw, parseCalendarState, readEvents, type CalendarState } from './sources/events.js'\n\nexport function createGoogleCalendarPipeline(config: GoogleCalendarReaderConfig = googleCalendarConfig, deps: GoogleCalendarClientDeps = defaultGoogleCalendarClientDeps) {\n  const boundConfig = { ...config }\n  if (!boundConfig.sourceId.trim() || !boundConfig.streamPrefix.trim() || !boundConfig.calendarId.trim()) throw new IngestConfigError('Calendar sourceId, streamPrefix and calendarId must be non-empty strings.')\n  const client = { ...deps, config: boundConfig }\n  return definePipeline({\n    id: boundConfig.streamPrefix, tags: ['provider:google-calendar'], maxStreams: 1, maxFetches: 1,\n    streams: [defineStream({\n      id: `${boundConfig.streamPrefix}.events`, tags: ['resource:events'], destination: google_calendar_eventsRaw,\n      incremental: {\n        ...cursorState<CalendarState>({ id: `${boundConfig.streamPrefix}.sync-token`, version: 1, parse: (raw) => parseCalendarState(raw, boundConfig) }),\n        plan({ state, range }) {\n          if (range?.from || range?.to) throw new IngestConfigError('Calendar canonical sync does not accept date bounds. Use a separate bounded instances reader for an occurrence backfill.')\n          return state\n        },\n      },\n      batchSize: 1,\n      budget: { maxChunks: boundConfig.maxChunks, maxChunkRows: 250 },\n      classifyError: classifyGoogleCalendarError,\n      read: (context) => readEvents(context, client),\n    })],\n  })\n}\n\nexport const google_calendarPipeline = createGoogleCalendarPipeline()\n"
+    },
+    {
+      "path": "google-calendar/sources/events.ts",
+      "type": "registry:file",
+      "target": "src/integrations/google-calendar/sources/events.ts",
+      "content": "import { IngestConfigError, paginate, rawRows, rawTable, type Page, type ReadContext } from '@chkit/plugin-ingest'\n\nimport { isObject, optionalString, requestEvents, requiredString, resolveCalendar, type CalendarEvent, type GoogleCalendarClientDeps } from '../client.js'\nimport { googleCalendarConfig, type GoogleCalendarReaderConfig } from '../config.js'\n\nexport interface CalendarState {\n  scope: string\n  calendarId: string\n  syncToken?: string\n  pageToken?: string\n  /** Recovery attempts for this unfinished sync, including previous executions. */\n  recoveryCount?: number\n}\n\ninterface CalendarPageMetadata { checkpoint: CalendarState; id?: 'calendar-reset' | 'calendar-empty-page' }\n\nexport const google_calendar_eventsRaw = rawTable({ database: googleCalendarConfig.database, name: 'google_calendar_events_raw' })\n\n// Candidate page state is acknowledged with its rows, including empty terminal pages.\nexport async function* readEvents(context: ReadContext<CalendarState | undefined, CalendarState>, deps: GoogleCalendarClientDeps) {\n  const scope = calendarScope(deps.config)\n  const sourceId = deps.config.sourceId\n  const resolvedCalendarId = await resolveCalendar(context, deps)\n  if (context.state && context.state.calendarId !== resolvedCalendarId) {\n    throw new IngestConfigError('Calendar checkpoint belongs to a different authenticated calendar. Use a separate stream ID for the new source.')\n  }\n  const pages = paginate({\n    context, initial: context.state ?? { scope, calendarId: resolvedCalendarId }, label: 'GET calendar events',\n    fetchPage: async (cursor = { scope, calendarId: resolvedCalendarId }, signal): Promise<Page<CalendarEvent, CalendarState, CalendarPageMetadata>> => {\n      const page = await requestEvents(cursor, signal, deps)\n      if ('reset' in page) {\n        if ((cursor.recoveryCount ?? 0) >= 1) throw new IngestConfigError('Calendar unfinished sync repeatedly rejected a token across resumed runs. Adjust the editable stream chunk budget, run duration, or polling frequency, then explicitly migrate the saved state or use a new stream identity after reviewing coverage.')\n        // Reset debt distinguishes safe replay from cycling, and survives restarts.\n        const checkpoint: CalendarState = { scope, calendarId: resolvedCalendarId, recoveryCount: 1, ...(page.reset === 'page' && cursor.syncToken ? { syncToken: cursor.syncToken } : {}) }\n        return { items: [], next: checkpoint, metadata: { checkpoint, id: 'calendar-reset' } }\n      }\n      // Retain the input token on every continuation; only the terminal\n      // checkpoint promotes nextSyncToken and clears recovery debt.\n      const checkpoint: CalendarState = page.nextPageToken\n        ? { ...cursor, pageToken: page.nextPageToken }\n        : { scope, calendarId: resolvedCalendarId, syncToken: requiredString(page.nextSyncToken, 'nextSyncToken') }\n      return { items: page.items, next: page.nextPageToken ? checkpoint : undefined,\n        metadata: { checkpoint, ...(page.items.length === 0 ? { id: 'calendar-empty-page' } : {}) } }\n    },\n  })\n  for await (const page of pages) {\n    if (!page.metadata) throw new IngestConfigError('Calendar page has no checkpoint metadata.')\n    yield { rows: rawRows(page.items, (event) => JSON.stringify([sourceId, resolvedCalendarId, event.id])),\n      state: page.metadata.checkpoint, id: page.metadata.id }\n  }\n}\n\nexport function parseCalendarState(raw: unknown, config: GoogleCalendarReaderConfig): CalendarState {\n  const scope = calendarScope(config)\n  if (!isObject(raw) || raw.scope !== scope) throw new IngestConfigError('Calendar checkpoint scope changed. Migrate the state explicitly or use a new stream ID.')\n  if (raw.recoveryCount !== undefined && raw.recoveryCount !== 0 && raw.recoveryCount !== 1) throw new IngestConfigError('Calendar checkpoint recoveryCount must be zero or one.')\n  return { scope, calendarId: requiredString(raw.calendarId, 'checkpoint calendar id'), syncToken: optionalString(raw.syncToken, 'checkpoint syncToken'), pageToken: optionalString(raw.pageToken, 'checkpoint pageToken'), recoveryCount: raw.recoveryCount }\n}\n\nfunction calendarScope(config: GoogleCalendarReaderConfig): string {\n  return JSON.stringify([config.sourceId, config.calendarId, { singleEvents: false, showDeleted: true, maxResults: 250 }])\n}\n"
+    },
+    {
+      "path": "google-calendar/tests/basic.test.ts",
+      "type": "registry:file",
+      "target": "src/integrations/google-calendar/tests/basic.test.ts",
+      "role": "test",
+      "content": "import { afterEach, expect, test } from 'bun:test'\nimport { runIngestion, selectStreams } from '@chkit/plugin-ingest'\nimport { createMemoryDestination, createMemoryJournal } from '@chkit/plugin-ingest/testing'\n\nimport { google_calendarPipeline } from '../index.js'\nimport { googleCalendarConfig } from '../config.js'\nimport { createGoogleCalendarPipeline } from '../pipeline.js'\n\nconst originalFetch = globalThis.fetch\nconst originalToken = process.env.GOOGLE_CALENDAR_ACCESS_TOKEN\n\nfunction setFetch(handler: (url: URL) => Response | Promise<Response>, calendar = () => 'calendar@example.com'): void {\n  process.env.GOOGLE_CALENDAR_ACCESS_TOKEN = 'fixture'\n  globalThis.fetch = Object.assign(async (input: Parameters<typeof fetch>[0]) => {\n    const url = new URL(String(input))\n    return url.pathname.endsWith('/events') ? handler(url) : Response.json({ id: calendar() })\n  }, { preconnect: originalFetch.preconnect })\n}\n\nfunction request(maxChunks?: number) {\n  const pipeline = { ...google_calendarPipeline, retry: { retries: 0 }, streams: google_calendarPipeline.streams.map((stream) => ({ ...stream, ...(maxChunks === undefined ? {} : { budget: { maxChunks } }) })) }\n  return { selected: selectStreams([pipeline], []), backfill: undefined }\n}\n\nafterEach(() => {\n  globalThis.fetch = originalFetch\n  if (originalToken === undefined) delete process.env.GOOGLE_CALENDAR_ACCESS_TOKEN\n  else process.env.GOOGLE_CALENDAR_ACCESS_TOKEN = originalToken\n})\n\ntest.serial('Calendar resumes an acknowledged page and promotes only the terminal sync token', async () => {\n  const urls: URL[] = []\n  setFetch((url) => {\n    urls.push(url)\n    return Response.json(url.searchParams.has('pageToken')\n      ? { items: [{ id: 'cancelled', status: 'cancelled' }], nextSyncToken: 'sync-1' }\n      : { items: [{ id: 'series', recurrence: ['RRULE:FREQ=WEEKLY'] }], nextPageToken: 'next' })\n  })\n  const journal = createMemoryJournal()\n  const destination = createMemoryDestination()\n  const interrupted = await runIngestion(request(1), { journal, destination })\n  expect(interrupted.streams[0]?.outcome).toBe('budget_exhausted')\n  expect((await journal.readCheckpoint('google-calendar.events')).envelope?.state).toMatchObject({ pageToken: 'next' })\n  const resumed = await runIngestion(request(), { journal, destination })\n  expect(resumed.ok).toBe(true)\n  expect(urls.map((url) => url.searchParams.get('pageToken'))).toEqual([null, 'next'])\n  expect((await journal.readCheckpoint('google-calendar.events')).envelope?.state).toMatchObject({ syncToken: 'sync-1', calendarId: 'calendar@example.com' })\n  expect(destination.tables.get('default.google_calendar_events_raw')?.map((row) => row.raw)).toEqual([\n    { id: 'series', recurrence: ['RRULE:FREQ=WEEKLY'] }, { id: 'cancelled', status: 'cancelled' },\n  ])\n  for (const url of urls) {\n    expect(url.searchParams.get('singleEvents')).toBe('false')\n    expect(url.searchParams.get('showDeleted')).toBe('true')\n    expect(url.searchParams.has('timeMin')).toBe(false)\n    expect(url.searchParams.has('timeMax')).toBe(false)\n  }\n})\n\ntest.serial('Calendar keeps the input sync token across empty delta pages', async () => {\n  let bootstrap = true\n  const inputs: Array<string | null> = []\n  setFetch((url) => {\n    inputs.push(url.searchParams.get('syncToken'))\n    if (bootstrap) return Response.json({ items: [], nextSyncToken: 'sync-1' })\n    return Response.json(url.searchParams.has('pageToken')\n      ? { items: [], nextSyncToken: 'sync-2' }\n      : { items: [], nextPageToken: 'delta-next' })\n  })\n  const journal = createMemoryJournal()\n  const destination = createMemoryDestination()\n  expect((await runIngestion(request(), { journal, destination })).ok).toBe(true)\n  bootstrap = false\n  expect((await runIngestion(request(), { journal, destination })).ok).toBe(true)\n  expect(inputs).toEqual([null, 'sync-1', 'sync-1'])\n  expect((await journal.readCheckpoint('google-calendar.events')).envelope?.state).toMatchObject({ syncToken: 'sync-2' })\n})\n\ntest('Calendar preserves native event structure and replaces an exception with its sparse cancellation', async () => {\n  const series = {\n    id: 'series', status: 'confirmed', recurrence: ['RRULE:FREQ=WEEKLY'],\n    attendees: [{ email: 'guest@example.com', responseStatus: 'accepted' }],\n    organizer: { email: 'owner@example.com' }, reminders: { useDefault: false, overrides: [{ method: 'email', minutes: 30 }] },\n    conferenceData: { conferenceId: 'abc-defg-hij', entryPoints: [{ entryPointType: 'video', uri: 'https://meet.google.com/abc-defg-hij' }] },\n    attachments: [{ fileId: 'file-1', fileUrl: 'https://drive.google.com/file/d/file-1/view' }],\n    extendedProperties: { private: { custom: 'retained' } },\n  }\n  const exception = { id: 'exception', recurringEventId: series.id, originalStartTime: { dateTime: '2026-10-06T09:00:00Z' }, summary: 'Moved occurrence' }\n  const cancellation = { id: exception.id, status: 'cancelled', recurringEventId: series.id, originalStartTime: exception.originalStartTime }\n  const calls: URL[] = []\n  const pipeline = createGoogleCalendarPipeline(googleCalendarConfig, {\n    config: googleCalendarConfig,\n    token: () => 'fixture',\n    fetch: async (input) => {\n      const url = new URL(input)\n      calls.push(url)\n      return Response.json(url.pathname.endsWith('/events')\n        ? url.searchParams.has('syncToken') ? { items: [cancellation], nextSyncToken: 'sync-2' } : { items: [series, exception], nextSyncToken: 'sync-1' }\n        : { id: 'calendar@example.com' })\n    },\n  })\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  const input = { selected: selectStreams([pipeline], ['resource:events']), backfill: undefined }\n  expect((await runIngestion(input, { journal, destination })).ok).toBe(true)\n  expect(destination.tables.get('default.google_calendar_events_raw')?.map((row) => row.raw)).toEqual([series, exception])\n  expect((await runIngestion(input, { journal, destination })).ok).toBe(true)\n  const latest = new Map(destination.tables.get('default.google_calendar_events_raw')?.map((row) => [row.id, row.raw]))\n  expect(latest.size).toBe(2)\n  expect(latest.get(JSON.stringify(['google-calendar.primary', 'calendar@example.com', exception.id]))).toEqual(cancellation)\n  expect(calls.filter((url) => url.pathname.endsWith('/events')).map((url) => url.searchParams.get('syncToken'))).toEqual([null, 'sync-1'])\n  expect(calls).toHaveLength(4)\n})\n\ntest.serial('Calendar retains its page checkpoint after a lost terminal acknowledgement', async () => {\n  setFetch((url) => Response.json(url.searchParams.has('pageToken')\n    ? { items: [{ id: 'second' }], nextSyncToken: 'sync-1' }\n    : { items: [{ id: 'first' }], nextPageToken: 'next' }))\n  const journal = createMemoryJournal()\n  const destination = createMemoryDestination()\n  const first = await runIngestion(request(), { journal, destination: {\n    insert: async (input) => {\n      await destination.insert(input)\n      if (input.rows.some((row) => JSON.stringify(row.raw).includes('second'))) throw new Error('fixture acknowledgement lost')\n    },\n  } })\n  expect(first.ok).toBe(false)\n  expect(destination.tables.get('default.google_calendar_events_raw')).toHaveLength(2)\n  expect((await journal.readCheckpoint('google-calendar.events')).envelope?.state).toMatchObject({ pageToken: 'next' })\n  expect((await runIngestion(request(), { journal, destination })).ok).toBe(true)\n  expect((await journal.readCheckpoint('google-calendar.events')).envelope?.state).toMatchObject({ syncToken: 'sync-1' })\n  expect(destination.tables.get('default.google_calendar_events_raw')).toHaveLength(2)\n})\n\ntest.serial('Calendar reboots an expired sync without deleting raw observations', async () => {\n  let changed = false\n  const inputs: Array<string | null> = []\n  setFetch((url) => {\n    inputs.push(url.searchParams.get('syncToken'))\n    if (!changed) return Response.json({ items: [{ id: 'old' }], nextSyncToken: 'expired' })\n    return url.searchParams.has('syncToken') ? new Response('expired', { status: 410 }) : Response.json({ items: [], nextSyncToken: 'fresh' })\n  })\n  const journal = createMemoryJournal()\n  const destination = createMemoryDestination()\n  expect((await runIngestion(request(), { journal, destination })).ok).toBe(true)\n  changed = true\n  expect((await runIngestion(request(), { journal, destination })).ok).toBe(true)\n  expect(inputs).toEqual([null, 'expired', null])\n  expect(destination.tables.get('default.google_calendar_events_raw')).toHaveLength(1)\n  expect((await journal.readCheckpoint('google-calendar.events')).envelope?.state).toMatchObject({ syncToken: 'fresh' })\n})\n\ntest.serial('Calendar rejects malformed terminal pages and repeated page tokens', async () => {\n  setFetch(() => Response.json({ items: [] }))\n  expect((await runIngestion(request(), { journal: createMemoryJournal(), destination: createMemoryDestination() })).ok).toBe(false)\n  setFetch(() => Response.json({ items: [], nextPageToken: 'same' }))\n  expect((await runIngestion(request(), { journal: createMemoryJournal(), destination: createMemoryDestination() })).ok).toBe(false)\n  expect(() => google_calendarPipeline.streams[0]?.incremental.parseState({ scope: 'another source' })).toThrow('scope')\n})\n\ntest.serial('Calendar refuses to reuse a checkpoint after primary changes accounts', async () => {\n  let calendar = 'first@example.com'\n  let eventRequests = 0\n  setFetch(() => { eventRequests += 1; return Response.json({ items: [], nextSyncToken: 'sync-1' }) }, () => calendar)\n  const journal = createMemoryJournal()\n  const destination = createMemoryDestination()\n  expect((await runIngestion(request(), { journal, destination })).ok).toBe(true)\n  calendar = 'second@example.com'\n  const result = await runIngestion(request(), { journal, destination })\n  expect(result.ok).toBe(false)\n  expect(result.streams[0]?.error).toContain('different authenticated calendar')\n  expect(eventRequests).toBe(1)\n})\n\ntest.serial('Calendar safely restarts a rejected page token within the same sync', async () => {\n  let reject = true\n  const inputs: Array<string | null> = []\n  setFetch((url) => {\n    inputs.push(url.searchParams.get('pageToken'))\n    if (url.searchParams.has('pageToken') && reject) { reject = false; return new Response('invalid page token', { status: 400 }) }\n    return Response.json(url.searchParams.has('pageToken')\n      ? { items: [], nextSyncToken: 'sync-1' }\n      : { items: [{ id: 'first' }], nextPageToken: 'next' })\n  })\n  const journal = createMemoryJournal()\n  const destination = createMemoryDestination()\n  expect((await runIngestion(request(), { journal, destination })).ok).toBe(true)\n  expect(inputs).toEqual([null, 'next', null, 'next'])\n  expect(new Set(destination.tables.get('default.google_calendar_events_raw')?.map((row) => row.id)).size).toBe(1)\n  expect((await journal.readCheckpoint('google-calendar.events')).envelope?.state).toMatchObject({ syncToken: 'sync-1' })\n})\n\ntest.serial('Calendar rejects unsupported explicit occurrence backfill bounds before requesting Google', async () => {\n  let requested = false\n  setFetch(() => { requested = true; return Response.json({ items: [], nextSyncToken: 'sync-1' }) })\n  const result = await runIngestion({ ...request(), backfill: { id: 'dates', from: new Date('2026-10-01T00:00:00Z'), to: new Date('2026-10-05T00:00:00Z') } }, { journal: createMemoryJournal(), destination: createMemoryDestination() })\n  expect(result.ok).toBe(false)\n  expect(result.streams[0]?.error).toContain('does not accept date bounds')\n  expect(requested).toBe(false)\n})\n\ntest.serial('Calendar carries reset debt through serialized fresh runs and successful nonterminal replay', async () => {\n  let rejected = 0\n  setFetch((url) => {\n    if (url.searchParams.has('pageToken')) { rejected += 1; return new Response('expired page token', { status: 400 }) }\n    return Response.json({ items: [{ id: 'first' }], nextPageToken: 'next' })\n  })\n  const destination = createMemoryDestination()\n  const initial = createMemoryJournal()\n  expect((await runIngestion(request(1), { journal: initial, destination })).streams[0]?.outcome).toBe('budget_exhausted')\n  const afterInitial = restoredJournal(initial)\n  expect((await runIngestion(request(1), { journal: afterInitial, destination })).streams[0]?.outcome).toBe('budget_exhausted')\n  expect((await afterInitial.readCheckpoint('google-calendar.events')).envelope?.state).toMatchObject({ recoveryCount: 1 })\n  expect((await afterInitial.readCheckpoint('google-calendar.events')).envelope?.state).not.toHaveProperty('pageToken')\n  const afterReset = restoredJournal(afterInitial)\n  expect((await runIngestion(request(1), { journal: afterReset, destination })).streams[0]?.outcome).toBe('budget_exhausted')\n  const replayCheckpoint = await afterReset.readCheckpoint('google-calendar.events')\n  expect(replayCheckpoint.envelope?.state).toMatchObject({ recoveryCount: 1, pageToken: 'next' })\n  const afterReplay = restoredJournal(afterReset)\n  const stopped = await runIngestion(request(2), { journal: afterReplay, destination })\n  expect(stopped.ok).toBe(false)\n  expect(stopped.streams[0]?.error).toContain('across resumed runs')\n  expect(stopped.streams[0]?.error).toContain('editable stream chunk budget')\n  expect((await afterReplay.readCheckpoint('google-calendar.events')).version).toBe(replayCheckpoint.version)\n  expect(rejected).toBe(2)\n  expect(() => google_calendarPipeline.streams[0]?.incremental.parseState({ ...JSON.parse(JSON.stringify(replayCheckpoint.envelope?.state)), recoveryCount: 2 })).toThrow('recoveryCount')\n})\n\nfunction restoredJournal(previous: ReturnType<typeof createMemoryJournal>) {\n  const journal = createMemoryJournal()\n  journal.events.push(...previous.events.map((event) => ({ ...event, checkpoint: event.checkpoint === undefined ? undefined : JSON.parse(JSON.stringify(event.checkpoint)) })))\n  return journal\n}\n\ntest('Calendar factory snapshots installation settings and injected credentials while resuming an empty terminal page', async () => {\n  const config = { ...googleCalendarConfig, sourceId: 'calendar.work', streamPrefix: 'calendar.work', calendarId: 'work', maxChunks: 1 }\n  let token = 'initial'\n  const requests: Array<{ url: URL; authorization: string | null }> = []\n  const deps = {\n    config: googleCalendarConfig,\n    token: () => token,\n    fetch: async (input: string, init: RequestInit) => {\n      const url = new URL(input)\n      requests.push({ url, authorization: new Headers(init.headers).get('Authorization') })\n      return Response.json(url.pathname.endsWith('/events')\n        ? url.searchParams.has('pageToken')\n          ? { items: [], nextSyncToken: 'work-sync' }\n          : { items: [{ id: 'first', custom: { original: true } }], nextPageToken: 'work-next' }\n        : { id: 'work@example.com' })\n    },\n  }\n  const pipeline = createGoogleCalendarPipeline(config, deps)\n  config.sourceId = 'edited-after-construction'\n  config.streamPrefix = 'edited-after-construction'\n  config.calendarId = 'edited-after-construction'\n  const journal = createMemoryJournal()\n  const destination = createMemoryDestination()\n  expect(pipeline.id).toBe('calendar.work')\n  expect(pipeline.streams[0]?.incremental.id).toBe('calendar.work.sync-token')\n  expect((await runIngestion({ selected: selectStreams([pipeline], ['resource:events']), backfill: undefined }, { journal, destination })).streams[0]?.outcome).toBe('budget_exhausted')\n  expect((await journal.readCheckpoint('calendar.work.events')).envelope?.state).toMatchObject({ pageToken: 'work-next' })\n  token = 'rotated'\n  const resumed = { ...pipeline, streams: pipeline.streams.map((stream) => ({ ...stream, budget: { ...stream.budget, maxChunks: 20 } })) }\n  expect((await runIngestion({ selected: selectStreams([resumed], []), backfill: undefined }, { journal, destination })).ok).toBe(true)\n  expect(requests.map(({ authorization }) => authorization)).toEqual(['Bearer initial', 'Bearer initial', 'Bearer rotated', 'Bearer rotated'])\n  expect(requests.map(({ url }) => [url.pathname, url.searchParams.get('pageToken')])).toEqual([\n    ['/calendar/v3/calendars/work', null], ['/calendar/v3/calendars/work%40example.com/events', null],\n    ['/calendar/v3/calendars/work', null], ['/calendar/v3/calendars/work%40example.com/events', 'work-next'],\n  ])\n  expect((await journal.readCheckpoint('calendar.work.events')).envelope?.state).toMatchObject({ syncToken: 'work-sync' })\n  expect((await journal.readCheckpoint('google-calendar.events')).version).toBe(0)\n  expect(destination.tables.get('default.google_calendar_events_raw')?.[0]).toMatchObject({\n    id: JSON.stringify(['calendar.work', 'work@example.com', 'first']), raw: { id: 'first', custom: { original: true } },\n  })\n})\n\ntest('Calendar factory rejects source changes under an existing stream prefix before another request', async () => {\n  let requests = 0\n  const deps = {\n    config: googleCalendarConfig, token: () => 'fixture',\n    fetch: async (input: string) => {\n      requests += 1\n      return Response.json(new URL(input).pathname.endsWith('/events') ? { items: [], nextSyncToken: 'first' } : { id: 'calendar@example.com' })\n    },\n  }\n  const journal = createMemoryJournal()\n  const destination = createMemoryDestination()\n  const pipeline = createGoogleCalendarPipeline(googleCalendarConfig, deps)\n  expect((await runIngestion({ selected: selectStreams([pipeline], []), backfill: undefined }, { journal, destination })).ok).toBe(true)\n  const changed = createGoogleCalendarPipeline({ ...googleCalendarConfig, sourceId: 'different-installation' }, deps)\n  const result = await runIngestion({ selected: selectStreams([changed], []), backfill: undefined }, { journal, destination })\n  expect(result.ok).toBe(false)\n  expect(result.streams[0]?.error).toContain('scope changed')\n  expect(requests).toBe(2)\n})\n"
+    }
+  ],
+  "meta": {
+    "chkit": {
+      "formatVersion": 1,
+      "version": "0.2.0",
+      "changelog": [
+        {
+          "version": "0.2.0",
+          "changes": [
+            "Replace the rolling occurrence window with canonical events and incremental provider sync tokens, including cancellation payloads.",
+            "Resume acknowledged pages, promote the terminal sync token after destination acknowledgement, and bound recovery from rejected or expired tokens.",
+            "Scope row IDs to the installation and resolved calendar; migrate legacy occurrence identities or use a fresh table and stream when upgrading.",
+            "Separate editable installation configuration, injectable HTTP clients, and resource readers from one pipeline; preserve independent stream identities and provider recovery.",
+            "Keep events as the sole raw resource with native nested fields and sparse cancellation observations; verify recurring-exception replacement without hydration.",
+            "Use full paginate pages and checkpoint metadata for canonical sync-token progress and bounded token recovery in one pagination loop, including empty terminal pages and the existing saved state format."
+          ]
+        },
+        {
+          "version": "0.1.0",
+          "changes": [
+            "Introduce raw events ingestion over a rolling occurrence window."
+          ]
+        }
+      ],
+      "language": "typescript",
+      "license": "MIT",
+      "documentation": "https://chkit.obsessiondb.com/integrations/google-calendar/",
+      "logo": "https://chkit.obsessiondb.com/logos/google-calendar.svg",
+      "authentication": {
+        "method": "OAuth access token",
+        "env": [
+          "GOOGLE_CALENDAR_ACCESS_TOKEN"
+        ],
+        "setup": [
+          "Provide GOOGLE_CALENDAR_ACCESS_TOKEN with read access to the selected resources.",
+          "Supply a new access token when the existing token expires."
+        ],
+        "documentation": "https://developers.google.com/calendar/api/guides/auth"
+      },
+      "chkit": "^0.2.0-beta.10",
+      "ingest": "^0.2.0-beta.10",
+      "clickhouse": ">=25.3.0",
+      "root": "src/integrations/google-calendar",
+      "entry": "index.ts",
+      "exports": [
+        "google_calendarPipeline",
+        "google_calendar_eventsRaw"
+      ],
+      "resources": [
+        {
+          "name": "events",
+          "title": "Events",
+          "table": "google_calendar_events_raw",
+          "description": "Canonical events, recurring masters, exceptions, and cancellation payloads from the configured calendar",
+          "scopes": [
+            "https://www.googleapis.com/auth/calendar.readonly"
+          ],
+          "strategy": "cursor",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/calendars/{calendarId}",
+              "documentation": "https://developers.google.com/workspace/calendar/api/v3/reference/calendars/get"
+            },
+            {
+              "method": "GET",
+              "path": "/calendars/{calendarId}/events",
+              "documentation": "https://developers.google.com/workspace/calendar/api/v3/reference/events/list"
+            }
+          ]
+        }
+      ],
+      "views": [],
+      "sync": {
+        "description": "Initial canonical event read followed by Google sync-token deltas. Acknowledged pages resume from journaled state.",
+        "schedule": "Run bunx chkit ingest run --tag provider:google-calendar from a scheduler.",
+        "deletions": "Cancellation payloads are retained. An expired token reboots provider progress without clearing raw observations; absent records are not reconciled."
+      },
+      "env": {
+        "GOOGLE_CALENDAR_ACCESS_TOKEN": ""
+      },
+      "fileHashes": {
+        "src/integrations/google-calendar/README.md": "11e6e79d93155ee872c50a6c0d566dd55d035331484cd5c11fb58467eb0b6464",
+        "src/integrations/google-calendar/index.ts": "24fa15ba7a49abb72675606ff08d5a5d214855ee9698542f204a56618ee18c61",
+        "src/integrations/google-calendar/config.ts": "44f348fa0776067b0b934c8721b927830faf9e5eed36cfb9fa26d7df849bad1a",
+        "src/integrations/google-calendar/client.ts": "e5da4cd592c6d7efc3a5aeeb1bb0faed4e90e492ea6f12866823cbbc267398b7",
+        "src/integrations/google-calendar/pipeline.ts": "18a4300117cf86dc258932ad59a8c469ef087ea306ae0cf8cee7f13915a49657",
+        "src/integrations/google-calendar/sources/events.ts": "5500d36a2f16b467732cdd52ef06067189653aefebe2c419055a66efa8710693",
+        "src/integrations/google-calendar/tests/basic.test.ts": "6800f75689ab2bb5205da4e2ee01c6b5d8fe3aa0e2b97fba9290af49a621cf86"
+      }
+    }
+  }
+}
diff --git a/registry/google-calendar/sources/events.ts b/registry/google-calendar/sources/events.ts
new file mode 100644
index 00000000..c5a4a822
--- /dev/null
+++ b/registry/google-calendar/sources/events.ts
@@ -0,0 +1,62 @@
+import { IngestConfigError, paginate, rawRows, rawTable, type Page, type ReadContext } from '@chkit/plugin-ingest'
+
+import { isObject, optionalString, requestEvents, requiredString, resolveCalendar, type CalendarEvent, type GoogleCalendarClientDeps } from '../client.js'
+import { googleCalendarConfig, type GoogleCalendarReaderConfig } from '../config.js'
+
+export interface CalendarState {
+  scope: string
+  calendarId: string
+  syncToken?: string
+  pageToken?: string
+  /** Recovery attempts for this unfinished sync, including previous executions. */
+  recoveryCount?: number
+}
+
+interface CalendarPageMetadata { checkpoint: CalendarState; id?: 'calendar-reset' | 'calendar-empty-page' }
+
+export const google_calendar_eventsRaw = rawTable({ database: googleCalendarConfig.database, name: 'google_calendar_events_raw' })
+
+// Candidate page state is acknowledged with its rows, including empty terminal pages.
+export async function* readEvents(context: ReadContext<CalendarState | undefined, CalendarState>, deps: GoogleCalendarClientDeps) {
+  const scope = calendarScope(deps.config)
+  const sourceId = deps.config.sourceId
+  const resolvedCalendarId = await resolveCalendar(context, deps)
+  if (context.state && context.state.calendarId !== resolvedCalendarId) {
+    throw new IngestConfigError('Calendar checkpoint belongs to a different authenticated calendar. Use a separate stream ID for the new source.')
+  }
+  const pages = paginate({
+    context, initial: context.state ?? { scope, calendarId: resolvedCalendarId }, label: 'GET calendar events',
+    fetchPage: async (cursor = { scope, calendarId: resolvedCalendarId }, signal): Promise<Page<CalendarEvent, CalendarState, CalendarPageMetadata>> => {
+      const page = await requestEvents(cursor, signal, deps)
+      if ('reset' in page) {
+        if ((cursor.recoveryCount ?? 0) >= 1) throw new IngestConfigError('Calendar unfinished sync repeatedly rejected a token across resumed runs. Adjust the editable stream chunk budget, run duration, or polling frequency, then explicitly migrate the saved state or use a new stream identity after reviewing coverage.')
+        // Reset debt distinguishes safe replay from cycling, and survives restarts.
+        const checkpoint: CalendarState = { scope, calendarId: resolvedCalendarId, recoveryCount: 1, ...(page.reset === 'page' && cursor.syncToken ? { syncToken: cursor.syncToken } : {}) }
+        return { items: [], next: checkpoint, metadata: { checkpoint, id: 'calendar-reset' } }
+      }
+      // Retain the input token on every continuation; only the terminal
+      // checkpoint promotes nextSyncToken and clears recovery debt.
+      const checkpoint: CalendarState = page.nextPageToken
+        ? { ...cursor, pageToken: page.nextPageToken }
+        : { scope, calendarId: resolvedCalendarId, syncToken: requiredString(page.nextSyncToken, 'nextSyncToken') }
+      return { items: page.items, next: page.nextPageToken ? checkpoint : undefined,
+        metadata: { checkpoint, ...(page.items.length === 0 ? { id: 'calendar-empty-page' } : {}) } }
+    },
+  })
+  for await (const page of pages) {
+    if (!page.metadata) throw new IngestConfigError('Calendar page has no checkpoint metadata.')
+    yield { rows: rawRows(page.items, (event) => JSON.stringify([sourceId, resolvedCalendarId, event.id])),
+      state: page.metadata.checkpoint, id: page.metadata.id }
+  }
+}
+
+export function parseCalendarState(raw: unknown, config: GoogleCalendarReaderConfig): CalendarState {
+  const scope = calendarScope(config)
+  if (!isObject(raw) || raw.scope !== scope) throw new IngestConfigError('Calendar checkpoint scope changed. Migrate the state explicitly or use a new stream ID.')
+  if (raw.recoveryCount !== undefined && raw.recoveryCount !== 0 && raw.recoveryCount !== 1) throw new IngestConfigError('Calendar checkpoint recoveryCount must be zero or one.')
+  return { scope, calendarId: requiredString(raw.calendarId, 'checkpoint calendar id'), syncToken: optionalString(raw.syncToken, 'checkpoint syncToken'), pageToken: optionalString(raw.pageToken, 'checkpoint pageToken'), recoveryCount: raw.recoveryCount }
+}
+
+function calendarScope(config: GoogleCalendarReaderConfig): string {
+  return JSON.stringify([config.sourceId, config.calendarId, { singleEvents: false, showDeleted: true, maxResults: 250 }])
+}
diff --git a/registry/google-calendar/tests/basic.test.ts b/registry/google-calendar/tests/basic.test.ts
index 5aeb6bda..831e9c25 100644
--- a/registry/google-calendar/tests/basic.test.ts
+++ b/registry/google-calendar/tests/basic.test.ts
@@ -3,12 +3,23 @@ import { runIngestion, selectStreams } from '@chkit/plugin-ingest'
 import { createMemoryDestination, createMemoryJournal } from '@chkit/plugin-ingest/testing'
 
 import { google_calendarPipeline } from '../index.js'
+import { googleCalendarConfig } from '../config.js'
+import { createGoogleCalendarPipeline } from '../pipeline.js'
 
 const originalFetch = globalThis.fetch
 const originalToken = process.env.GOOGLE_CALENDAR_ACCESS_TOKEN
 
-function setFetch(handler: (...args: Parameters<typeof fetch>) => Promise<Response>): void {
-  globalThis.fetch = Object.assign(handler, { preconnect: originalFetch.preconnect })
+function setFetch(handler: (url: URL) => Response | Promise<Response>, calendar = () => 'calendar@example.com'): void {
+  process.env.GOOGLE_CALENDAR_ACCESS_TOKEN = 'fixture'
+  globalThis.fetch = Object.assign(async (input: Parameters<typeof fetch>[0]) => {
+    const url = new URL(String(input))
+    return url.pathname.endsWith('/events') ? handler(url) : Response.json({ id: calendar() })
+  }, { preconnect: originalFetch.preconnect })
+}
+
+function request(maxChunks?: number) {
+  const pipeline = { ...google_calendarPipeline, retry: { retries: 0 }, streams: google_calendarPipeline.streams.map((stream) => ({ ...stream, ...(maxChunks === undefined ? {} : { budget: { maxChunks } }) })) }
+  return { selected: selectStreams([pipeline], []), backfill: undefined }
 }
 
 afterEach(() => {
@@ -17,21 +28,266 @@ afterEach(() => {
   else process.env.GOOGLE_CALENDAR_ACCESS_TOKEN = originalToken
 })
 
-test.serial('Google Calendar follows page tokens and keeps cancellation payloads', async () => {
-  process.env.GOOGLE_CALENDAR_ACCESS_TOKEN = 'fixture'
-  const tokens: Array<string | null> = []
-  setFetch(async (input) => {
-    const url = new URL(String(input))
-    tokens.push(url.searchParams.get('pageToken'))
+test.serial('Calendar resumes an acknowledged page and promotes only the terminal sync token', async () => {
+  const urls: URL[] = []
+  setFetch((url) => {
+    urls.push(url)
     return Response.json(url.searchParams.has('pageToken')
-      ? { items: [{ id: 'cancelled', status: 'cancelled' }] }
-      : { items: [{ id: 'active', summary: 'Call' }], nextPageToken: 'next' })
+      ? { items: [{ id: 'cancelled', status: 'cancelled' }], nextSyncToken: 'sync-1' }
+      : { items: [{ id: 'series', recurrence: ['RRULE:FREQ=WEEKLY'] }], nextPageToken: 'next' })
   })
+  const journal = createMemoryJournal()
   const destination = createMemoryDestination()
-  const result = await runIngestion({ selected: selectStreams([google_calendarPipeline], []), backfill: undefined }, { journal: createMemoryJournal(), destination })
-  expect(result.ok).toBe(true)
-  expect(tokens).toEqual([null, 'next'])
+  const interrupted = await runIngestion(request(1), { journal, destination })
+  expect(interrupted.streams[0]?.outcome).toBe('budget_exhausted')
+  expect((await journal.readCheckpoint('google-calendar.events')).envelope?.state).toMatchObject({ pageToken: 'next' })
+  const resumed = await runIngestion(request(), { journal, destination })
+  expect(resumed.ok).toBe(true)
+  expect(urls.map((url) => url.searchParams.get('pageToken'))).toEqual([null, 'next'])
+  expect((await journal.readCheckpoint('google-calendar.events')).envelope?.state).toMatchObject({ syncToken: 'sync-1', calendarId: 'calendar@example.com' })
   expect(destination.tables.get('default.google_calendar_events_raw')?.map((row) => row.raw)).toEqual([
-    { id: 'active', summary: 'Call' }, { id: 'cancelled', status: 'cancelled' },
+    { id: 'series', recurrence: ['RRULE:FREQ=WEEKLY'] }, { id: 'cancelled', status: 'cancelled' },
   ])
+  for (const url of urls) {
+    expect(url.searchParams.get('singleEvents')).toBe('false')
+    expect(url.searchParams.get('showDeleted')).toBe('true')
+    expect(url.searchParams.has('timeMin')).toBe(false)
+    expect(url.searchParams.has('timeMax')).toBe(false)
+  }
+})
+
+test.serial('Calendar keeps the input sync token across empty delta pages', async () => {
+  let bootstrap = true
+  const inputs: Array<string | null> = []
+  setFetch((url) => {
+    inputs.push(url.searchParams.get('syncToken'))
+    if (bootstrap) return Response.json({ items: [], nextSyncToken: 'sync-1' })
+    return Response.json(url.searchParams.has('pageToken')
+      ? { items: [], nextSyncToken: 'sync-2' }
+      : { items: [], nextPageToken: 'delta-next' })
+  })
+  const journal = createMemoryJournal()
+  const destination = createMemoryDestination()
+  expect((await runIngestion(request(), { journal, destination })).ok).toBe(true)
+  bootstrap = false
+  expect((await runIngestion(request(), { journal, destination })).ok).toBe(true)
+  expect(inputs).toEqual([null, 'sync-1', 'sync-1'])
+  expect((await journal.readCheckpoint('google-calendar.events')).envelope?.state).toMatchObject({ syncToken: 'sync-2' })
+})
+
+test('Calendar preserves native event structure and replaces an exception with its sparse cancellation', async () => {
+  const series = {
+    id: 'series', status: 'confirmed', recurrence: ['RRULE:FREQ=WEEKLY'],
+    attendees: [{ email: 'guest@example.com', responseStatus: 'accepted' }],
+    organizer: { email: 'owner@example.com' }, reminders: { useDefault: false, overrides: [{ method: 'email', minutes: 30 }] },
+    conferenceData: { conferenceId: 'abc-defg-hij', entryPoints: [{ entryPointType: 'video', uri: 'https://meet.google.com/abc-defg-hij' }] },
+    attachments: [{ fileId: 'file-1', fileUrl: 'https://drive.google.com/file/d/file-1/view' }],
+    extendedProperties: { private: { custom: 'retained' } },
+  }
+  const exception = { id: 'exception', recurringEventId: series.id, originalStartTime: { dateTime: '2026-10-06T09:00:00Z' }, summary: 'Moved occurrence' }
+  const cancellation = { id: exception.id, status: 'cancelled', recurringEventId: series.id, originalStartTime: exception.originalStartTime }
+  const calls: URL[] = []
+  const pipeline = createGoogleCalendarPipeline(googleCalendarConfig, {
+    config: googleCalendarConfig,
+    token: () => 'fixture',
+    fetch: async (input) => {
+      const url = new URL(input)
+      calls.push(url)
+      return Response.json(url.pathname.endsWith('/events')
+        ? url.searchParams.has('syncToken') ? { items: [cancellation], nextSyncToken: 'sync-2' } : { items: [series, exception], nextSyncToken: 'sync-1' }
+        : { id: 'calendar@example.com' })
+    },
+  })
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  const input = { selected: selectStreams([pipeline], ['resource:events']), backfill: undefined }
+  expect((await runIngestion(input, { journal, destination })).ok).toBe(true)
+  expect(destination.tables.get('default.google_calendar_events_raw')?.map((row) => row.raw)).toEqual([series, exception])
+  expect((await runIngestion(input, { journal, destination })).ok).toBe(true)
+  const latest = new Map(destination.tables.get('default.google_calendar_events_raw')?.map((row) => [row.id, row.raw]))
+  expect(latest.size).toBe(2)
+  expect(latest.get(JSON.stringify(['google-calendar.primary', 'calendar@example.com', exception.id]))).toEqual(cancellation)
+  expect(calls.filter((url) => url.pathname.endsWith('/events')).map((url) => url.searchParams.get('syncToken'))).toEqual([null, 'sync-1'])
+  expect(calls).toHaveLength(4)
+})
+
+test.serial('Calendar retains its page checkpoint after a lost terminal acknowledgement', async () => {
+  setFetch((url) => Response.json(url.searchParams.has('pageToken')
+    ? { items: [{ id: 'second' }], nextSyncToken: 'sync-1' }
+    : { items: [{ id: 'first' }], nextPageToken: 'next' }))
+  const journal = createMemoryJournal()
+  const destination = createMemoryDestination()
+  const first = await runIngestion(request(), { journal, destination: {
+    insert: async (input) => {
+      await destination.insert(input)
+      if (input.rows.some((row) => JSON.stringify(row.raw).includes('second'))) throw new Error('fixture acknowledgement lost')
+    },
+  } })
+  expect(first.ok).toBe(false)
+  expect(destination.tables.get('default.google_calendar_events_raw')).toHaveLength(2)
+  expect((await journal.readCheckpoint('google-calendar.events')).envelope?.state).toMatchObject({ pageToken: 'next' })
+  expect((await runIngestion(request(), { journal, destination })).ok).toBe(true)
+  expect((await journal.readCheckpoint('google-calendar.events')).envelope?.state).toMatchObject({ syncToken: 'sync-1' })
+  expect(destination.tables.get('default.google_calendar_events_raw')).toHaveLength(2)
+})
+
+test.serial('Calendar reboots an expired sync without deleting raw observations', async () => {
+  let changed = false
+  const inputs: Array<string | null> = []
+  setFetch((url) => {
+    inputs.push(url.searchParams.get('syncToken'))
+    if (!changed) return Response.json({ items: [{ id: 'old' }], nextSyncToken: 'expired' })
+    return url.searchParams.has('syncToken') ? new Response('expired', { status: 410 }) : Response.json({ items: [], nextSyncToken: 'fresh' })
+  })
+  const journal = createMemoryJournal()
+  const destination = createMemoryDestination()
+  expect((await runIngestion(request(), { journal, destination })).ok).toBe(true)
+  changed = true
+  expect((await runIngestion(request(), { journal, destination })).ok).toBe(true)
+  expect(inputs).toEqual([null, 'expired', null])
+  expect(destination.tables.get('default.google_calendar_events_raw')).toHaveLength(1)
+  expect((await journal.readCheckpoint('google-calendar.events')).envelope?.state).toMatchObject({ syncToken: 'fresh' })
+})
+
+test.serial('Calendar rejects malformed terminal pages and repeated page tokens', async () => {
+  setFetch(() => Response.json({ items: [] }))
+  expect((await runIngestion(request(), { journal: createMemoryJournal(), destination: createMemoryDestination() })).ok).toBe(false)
+  setFetch(() => Response.json({ items: [], nextPageToken: 'same' }))
+  expect((await runIngestion(request(), { journal: createMemoryJournal(), destination: createMemoryDestination() })).ok).toBe(false)
+  expect(() => google_calendarPipeline.streams[0]?.incremental.parseState({ scope: 'another source' })).toThrow('scope')
+})
+
+test.serial('Calendar refuses to reuse a checkpoint after primary changes accounts', async () => {
+  let calendar = 'first@example.com'
+  let eventRequests = 0
+  setFetch(() => { eventRequests += 1; return Response.json({ items: [], nextSyncToken: 'sync-1' }) }, () => calendar)
+  const journal = createMemoryJournal()
+  const destination = createMemoryDestination()
+  expect((await runIngestion(request(), { journal, destination })).ok).toBe(true)
+  calendar = 'second@example.com'
+  const result = await runIngestion(request(), { journal, destination })
+  expect(result.ok).toBe(false)
+  expect(result.streams[0]?.error).toContain('different authenticated calendar')
+  expect(eventRequests).toBe(1)
+})
+
+test.serial('Calendar safely restarts a rejected page token within the same sync', async () => {
+  let reject = true
+  const inputs: Array<string | null> = []
+  setFetch((url) => {
+    inputs.push(url.searchParams.get('pageToken'))
+    if (url.searchParams.has('pageToken') && reject) { reject = false; return new Response('invalid page token', { status: 400 }) }
+    return Response.json(url.searchParams.has('pageToken')
+      ? { items: [], nextSyncToken: 'sync-1' }
+      : { items: [{ id: 'first' }], nextPageToken: 'next' })
+  })
+  const journal = createMemoryJournal()
+  const destination = createMemoryDestination()
+  expect((await runIngestion(request(), { journal, destination })).ok).toBe(true)
+  expect(inputs).toEqual([null, 'next', null, 'next'])
+  expect(new Set(destination.tables.get('default.google_calendar_events_raw')?.map((row) => row.id)).size).toBe(1)
+  expect((await journal.readCheckpoint('google-calendar.events')).envelope?.state).toMatchObject({ syncToken: 'sync-1' })
+})
+
+test.serial('Calendar rejects unsupported explicit occurrence backfill bounds before requesting Google', async () => {
+  let requested = false
+  setFetch(() => { requested = true; return Response.json({ items: [], nextSyncToken: 'sync-1' }) })
+  const result = await runIngestion({ ...request(), backfill: { id: 'dates', from: new Date('2026-10-01T00:00:00Z'), to: new Date('2026-10-05T00:00:00Z') } }, { journal: createMemoryJournal(), destination: createMemoryDestination() })
+  expect(result.ok).toBe(false)
+  expect(result.streams[0]?.error).toContain('does not accept date bounds')
+  expect(requested).toBe(false)
+})
+
+test.serial('Calendar carries reset debt through serialized fresh runs and successful nonterminal replay', async () => {
+  let rejected = 0
+  setFetch((url) => {
+    if (url.searchParams.has('pageToken')) { rejected += 1; return new Response('expired page token', { status: 400 }) }
+    return Response.json({ items: [{ id: 'first' }], nextPageToken: 'next' })
+  })
+  const destination = createMemoryDestination()
+  const initial = createMemoryJournal()
+  expect((await runIngestion(request(1), { journal: initial, destination })).streams[0]?.outcome).toBe('budget_exhausted')
+  const afterInitial = restoredJournal(initial)
+  expect((await runIngestion(request(1), { journal: afterInitial, destination })).streams[0]?.outcome).toBe('budget_exhausted')
+  expect((await afterInitial.readCheckpoint('google-calendar.events')).envelope?.state).toMatchObject({ recoveryCount: 1 })
+  expect((await afterInitial.readCheckpoint('google-calendar.events')).envelope?.state).not.toHaveProperty('pageToken')
+  const afterReset = restoredJournal(afterInitial)
+  expect((await runIngestion(request(1), { journal: afterReset, destination })).streams[0]?.outcome).toBe('budget_exhausted')
+  const replayCheckpoint = await afterReset.readCheckpoint('google-calendar.events')
+  expect(replayCheckpoint.envelope?.state).toMatchObject({ recoveryCount: 1, pageToken: 'next' })
+  const afterReplay = restoredJournal(afterReset)
+  const stopped = await runIngestion(request(2), { journal: afterReplay, destination })
+  expect(stopped.ok).toBe(false)
+  expect(stopped.streams[0]?.error).toContain('across resumed runs')
+  expect(stopped.streams[0]?.error).toContain('editable stream chunk budget')
+  expect((await afterReplay.readCheckpoint('google-calendar.events')).version).toBe(replayCheckpoint.version)
+  expect(rejected).toBe(2)
+  expect(() => google_calendarPipeline.streams[0]?.incremental.parseState({ ...JSON.parse(JSON.stringify(replayCheckpoint.envelope?.state)), recoveryCount: 2 })).toThrow('recoveryCount')
+})
+
+function restoredJournal(previous: ReturnType<typeof createMemoryJournal>) {
+  const journal = createMemoryJournal()
+  journal.events.push(...previous.events.map((event) => ({ ...event, checkpoint: event.checkpoint === undefined ? undefined : JSON.parse(JSON.stringify(event.checkpoint)) })))
+  return journal
+}
+
+test('Calendar factory snapshots installation settings and injected credentials while resuming an empty terminal page', async () => {
+  const config = { ...googleCalendarConfig, sourceId: 'calendar.work', streamPrefix: 'calendar.work', calendarId: 'work', maxChunks: 1 }
+  let token = 'initial'
+  const requests: Array<{ url: URL; authorization: string | null }> = []
+  const deps = {
+    config: googleCalendarConfig,
+    token: () => token,
+    fetch: async (input: string, init: RequestInit) => {
+      const url = new URL(input)
+      requests.push({ url, authorization: new Headers(init.headers).get('Authorization') })
+      return Response.json(url.pathname.endsWith('/events')
+        ? url.searchParams.has('pageToken')
+          ? { items: [], nextSyncToken: 'work-sync' }
+          : { items: [{ id: 'first', custom: { original: true } }], nextPageToken: 'work-next' }
+        : { id: 'work@example.com' })
+    },
+  }
+  const pipeline = createGoogleCalendarPipeline(config, deps)
+  config.sourceId = 'edited-after-construction'
+  config.streamPrefix = 'edited-after-construction'
+  config.calendarId = 'edited-after-construction'
+  const journal = createMemoryJournal()
+  const destination = createMemoryDestination()
+  expect(pipeline.id).toBe('calendar.work')
+  expect(pipeline.streams[0]?.incremental.id).toBe('calendar.work.sync-token')
+  expect((await runIngestion({ selected: selectStreams([pipeline], ['resource:events']), backfill: undefined }, { journal, destination })).streams[0]?.outcome).toBe('budget_exhausted')
+  expect((await journal.readCheckpoint('calendar.work.events')).envelope?.state).toMatchObject({ pageToken: 'work-next' })
+  token = 'rotated'
+  const resumed = { ...pipeline, streams: pipeline.streams.map((stream) => ({ ...stream, budget: { ...stream.budget, maxChunks: 20 } })) }
+  expect((await runIngestion({ selected: selectStreams([resumed], []), backfill: undefined }, { journal, destination })).ok).toBe(true)
+  expect(requests.map(({ authorization }) => authorization)).toEqual(['Bearer initial', 'Bearer initial', 'Bearer rotated', 'Bearer rotated'])
+  expect(requests.map(({ url }) => [url.pathname, url.searchParams.get('pageToken')])).toEqual([
+    ['/calendar/v3/calendars/work', null], ['/calendar/v3/calendars/work%40example.com/events', null],
+    ['/calendar/v3/calendars/work', null], ['/calendar/v3/calendars/work%40example.com/events', 'work-next'],
+  ])
+  expect((await journal.readCheckpoint('calendar.work.events')).envelope?.state).toMatchObject({ syncToken: 'work-sync' })
+  expect((await journal.readCheckpoint('google-calendar.events')).version).toBe(0)
+  expect(destination.tables.get('default.google_calendar_events_raw')?.[0]).toMatchObject({
+    id: JSON.stringify(['calendar.work', 'work@example.com', 'first']), raw: { id: 'first', custom: { original: true } },
+  })
+})
+
+test('Calendar factory rejects source changes under an existing stream prefix before another request', async () => {
+  let requests = 0
+  const deps = {
+    config: googleCalendarConfig, token: () => 'fixture',
+    fetch: async (input: string) => {
+      requests += 1
+      return Response.json(new URL(input).pathname.endsWith('/events') ? { items: [], nextSyncToken: 'first' } : { id: 'calendar@example.com' })
+    },
+  }
+  const journal = createMemoryJournal()
+  const destination = createMemoryDestination()
+  const pipeline = createGoogleCalendarPipeline(googleCalendarConfig, deps)
+  expect((await runIngestion({ selected: selectStreams([pipeline], []), backfill: undefined }, { journal, destination })).ok).toBe(true)
+  const changed = createGoogleCalendarPipeline({ ...googleCalendarConfig, sourceId: 'different-installation' }, deps)
+  const result = await runIngestion({ selected: selectStreams([changed], []), backfill: undefined }, { journal, destination })
+  expect(result.ok).toBe(false)
+  expect(result.streams[0]?.error).toContain('scope changed')
+  expect(requests).toBe(2)
 })
diff --git a/registry/google-meet/README.md b/registry/google-meet/README.md
index 002bf57e..da9ed0be 100644
--- a/registry/google-meet/README.md
+++ b/registry/google-meet/README.md
@@ -1,8 +1,8 @@
-# Google Meet raw ingestion example
+# Google Meet raw ingestion
 
-This is a small editable starting point based on the Google-Meet source in [obsessiondb/brain](https://github.com/obsessiondb/brain/tree/main/scripts/brain-sync). It stores provider responses as native JSON without Brain's memory or sales projections.
+This editable reader rereads recent conferences and their raw resources, using ordinary pagination and coarse discovery-page checkpoints.
 
-Set `GOOGLE_MEET_ACCESS_TOKEN` in the runtime environment and configure a direct ClickHouse connection. Edit `lookbackDays` in `index.ts` to select the conference window. Native JSON requires ClickHouse 25.3 or later.
+Set `GOOGLE_MEET_ACCESS_TOKEN` with `meetings.space.readonly` access and configure a direct ClickHouse connection. Review `sourceId`, `streamPrefix`, `lookbackHours`, `pageSize`, `maxChunks`, and `database` in `config.ts`. Keep source identity tied to one Google account; these list responses do not identify the authenticated account. Tokens are read at request time and are not refreshed by the reader. Meet requires user authentication and returns records accessible to that user. Native JSON requires ClickHouse 25.3 or later. See [authorization](https://developers.google.com/workspace/meet/api/guides/authenticate-authorize).
 
 ```sh
 bunx chkit check
@@ -10,11 +10,74 @@ bunx chkit generate --name add_google_meet
 # Review the migration before applying it.
 bunx chkit migrate --apply
 bunx chkit ingest run --tag provider:google-meet
+bunx chkit ingest status --tag provider:google-meet
 ```
 
-## Resources
+## Resources and streams
+
+One installation pipeline contains six independent streams and destinations:
 
 - `conferences` → `google_meet_conferences_raw`
+- `participants` → `google_meet_participants_raw`
+- `participant-sessions` → `google_meet_participant_sessions_raw`
+- `recordings` → `google_meet_recordings_raw`
 - `transcripts` → `google_meet_transcripts_raw`
+- `transcript-entries` → `google_meet_transcript_entries_raw`
+
+Every child stream discovers its own conferences. Sessions also discover participants; entries also discover transcripts. Select resources independently, in any order. Parent publication does not wait for children.
+
+```sh
+bunx chkit ingest run --tag provider:google-meet --tag resource:transcript-entries
+bunx chkit ingest run --tag provider:google-meet --tag resource:participant-sessions
+```
+
+`pipeline.ts` binds configuration, strategies and destinations. `sources/resources.ts` contains ordinary resource traversal; `client.ts` validates requests and uses `paginate`. The plugin owns request retries, cancellation, destination acknowledgement and checkpoint persistence.
+
+`sourceId` scopes raw identities and queries; `streamPrefix` determines journal IDs. Use separate values for another installation. `createGoogleMeetPipeline` snapshots configuration and injectable HTTP/token dependencies. Raw destinations are setup-time exports: edit `database` before schema imports to change placement. The default pipeline runs one stream and request at a time.
+
+## Recent coverage
+
+Initial discovery covers the preceding 24 hours by conference end time. Later runs begin at the last completed watermark minus `lookbackHours` (24 by default), so they reread recent calls and catch up after missed runs. Ongoing calls are discovered separately through `end_time IS NULL`, including calls that started before the lookback. Explicit historical bounds skip ongoing calls.
+
+Each selected conference's child collections are read completely. There is no retained-conference catalog, delayed-work queue, or automatic historical reconciliation. A transcript or recording that appears after its conference leaves the selected window requires a wider configured lookback or explicit backfill. Meet conference timestamps are not child modification timestamps. This is a deliberate recent polling policy. See [conference filters](https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords/list) and [artifacts](https://developers.google.com/workspace/meet/api/guides/artifacts).
+
+## Checkpoints and replay
+
+A checkpoint contains source scope, completed watermark, optional historical bounds, and an unfinished discovery window with phase/page token. The window is saved before discovery starts. Each discovery page and all its children finish before a state-only boundary advances its token; the executor commits that boundary only after the preceding rows land.
+
+A failed or interrupted page replays its child collections from their beginning under the original bounds. Completed discovery pages remain skipped. Child pages, indices and queues are not saved. The default discovery `pageSize` is one conference and `maxChunks` is 200. A page's children plus its completion marker must fit a run's chunk/time budget; increase `maxChunks` or `--max-duration` if one conference is too large. Requests have a 30-second timeout.
+
+A rejected page token restarts its collection once. Discovery reset debt is saved across executions and clears after the phase finishes. Child token recovery is bounded within its current read; a replayed parent starts fresh child collections. Repeated rejection and malformed/cyclic continuation fail visibly.
+
+Checkpoint strategy version 2 rejects incompatible state rather than reinterpreting it. Changing source or discovery settings requires deliberate state migration or a new `streamPrefix`. Run one ingestion process per target at a time.
+
+## Raw updates and relationships
+
+Raw identity is `[sourceId, provider.name]`. Children add `conference_name`; sessions add `participant_name`, and entries add `transcript_name`. All provider fields stay raw. Join resources and assemble transcripts later in ClickHouse.
+
+Participants represent attendance; sessions represent individual joins/leaves. Recordings preserve metadata and Drive references without downloading files. Transcripts preserve metadata and document references; entry rows preserve individual speech segments. API entries do not reflect later edits to the separate Google Docs document.
+
+Tables use `ReplacingMergeTree(_chkit_ingested_at)`. Every observed payload is inserted with the same stable resource ID; later ingestion wins. A transcript changing from `ENDED` to `FILE_GENERATED` therefore replaces its earlier observation. An empty transcript list emits no placeholder, so a later transcript inserts normally. No body hash or insert-only staging is needed. Use `FINAL` for latest observations.
+
+Missing, inaccessible or expired resources do not imply deletion. Google removes conference records and API entries after its retention period; expired history cannot be recovered, and stored raw observations remain. See [conference retention](https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords).
+
+## Historical ranges and upgrades
+
+Backfill bounds select conference end times, not child modification times. All children of selected conferences are read. Reuse the same backfill ID and bounds to resume; changed bounds require a new ID.
+
+```sh
+bunx chkit ingest run --tag provider:google-meet --backfill october --from 2026-10-01T00:00:00Z --to 2026-10-05T00:00:00Z
+```
+
+Version 0.2.0 preserves the existing conference/transcript destinations and adds participant, session, recording and entry tables. Entries are separate rows rather than embedded transcript arrays. New row IDs include `sourceId`; legacy provider-name IDs remain until an explicit identity/data migration. Keep old rows as archives or migrate them deliberately.
+
+## Fixture verification
+
+```sh
+bunx chkit add google-meet --with-tests
+bun test src/integrations/google-meet/tests/basic.test.ts
+```
+
+Fixtures cover independent resources, unfinished-page replay, completed-page resume, sink acknowledgement loss, changed bodies under stable IDs, recent late transcripts, empty pages, bounded token resets, fixed windows, scoped settings, historical isolation and request-time tokens.
 
-Each run reads a configured time range. Transcripts generated later require another scan of that range. A failed API request fails the stream. Raw rows use provider IDs and keep the last observed value; there is no deletion reconciliation. Edit the readers, select fewer streams, or add SQL views for a specific use case. Run one ingestion process per ClickHouse target at a time.
+The [Google Meet integration guide](https://chkit.obsessiondb.com/integrations/google-meet/) covers installation and sync behavior.
diff --git a/registry/google-meet/client.ts b/registry/google-meet/client.ts
new file mode 100644
index 00000000..f8bacefa
--- /dev/null
+++ b/registry/google-meet/client.ts
@@ -0,0 +1,83 @@
+import { HttpError, IngestConfigError, paginate, type ErrorClassifier, type FetchContext } from '@chkit/plugin-ingest'
+
+import { googleMeetConfig, type GoogleMeetReaderConfig } from './config.js'
+
+export interface Named { name: string; [key: string]: unknown }
+export interface CollectionCursor { pageToken?: string; recoveryCount?: number }
+interface CollectionOptions { filter?: string; initial?: CollectionCursor; pageSize?: number }
+
+export interface GoogleMeetClientDeps {
+  config: GoogleMeetReaderConfig
+  fetch: (url: string, init: RequestInit) => Promise<Response>
+  token: () => string | undefined
+}
+
+export const defaultGoogleMeetClientDeps: GoogleMeetClientDeps = {
+  config: googleMeetConfig,
+  fetch: (url, init) => fetch(url, init),
+  token: () => process.env.GOOGLE_MEET_ACCESS_TOKEN,
+}
+
+export const classifyGoogleMeetError: ErrorClassifier = (cause) =>
+  cause instanceof IngestConfigError || cause instanceof SyntaxError ? { kind: 'permanent' } : undefined
+
+export function readCollection(context: FetchContext, path: string, field: string, deps: GoogleMeetClientDeps, options: CollectionOptions = {}) {
+  return paginate<Named, CollectionCursor, { reset: true }>({
+    context, initial: options.initial ?? {}, label: `GET ${field}`,
+    fetchPage: async (cursor, signal) => {
+      const current = cursor ?? {}
+      const page = await requestPage(path, field, current.pageToken, options.filter, options.pageSize ?? 100, signal, deps)
+      if ('reset' in page) {
+        if (current.recoveryCount) throw new IngestConfigError(`Meet ${field} repeatedly rejected its page token. Increase the execution budget or migrate the checkpoint after reviewing coverage.`)
+        return { items: [], next: { recoveryCount: 1 }, metadata: { reset: true } }
+      }
+      return { items: page.items, next: page.nextPageToken ? { ...current, pageToken: page.nextPageToken } : undefined }
+    },
+  })
+}
+
+export function optionalString(value: unknown, field: string): string | undefined {
+  if (value === undefined) return undefined
+  if (typeof value !== 'string' || !value.trim()) throw new IngestConfigError(`Meet ${field} must be a non-empty string.`)
+  return value
+}
+
+export function optionalTimestamp(value: unknown, field: string): string | undefined {
+  return value === undefined ? undefined : timestamp(value, field)
+}
+
+export function timestamp(value: unknown, field: string): string {
+  const result = optionalString(value, field)
+  if (!result || !Number.isFinite(Date.parse(result))) throw new IngestConfigError(`Meet ${field} is not a timestamp.`)
+  return result
+}
+
+export function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+async function requestPage(path: string, field: string, pageToken: string | undefined, filter: string | undefined, pageSize: number, signal: AbortSignal, deps: GoogleMeetClientDeps): Promise<{ items: Named[]; nextPageToken?: string } | { reset: true }> {
+  const token = deps.token()?.trim()
+  if (!token) throw new IngestConfigError('Set GOOGLE_MEET_ACCESS_TOKEN.')
+  const url = new URL(`https://meet.googleapis.com/v2/${path}`)
+  url.searchParams.set('pageSize', String(pageSize))
+  if (filter) url.searchParams.set('filter', filter)
+  if (pageToken) url.searchParams.set('pageToken', pageToken)
+  const response = await deps.fetch(url.toString(), { signal: AbortSignal.any([signal, AbortSignal.timeout(30_000)]), headers: { Authorization: `Bearer ${token}` }, redirect: 'error' })
+  if (pageToken && (response.status === 400 || response.status === 410)) {
+    const detail = await response.clone().text()
+    if (/page[_\s-]*token/i.test(detail) && /invalid|expir/i.test(detail)) return { reset: true }
+  }
+  if (!response.ok) throw await HttpError.fromResponse(response)
+  const payload: unknown = await response.json()
+  if (!isObject(payload) || payload[field] !== undefined && !Array.isArray(payload[field])) throw new IngestConfigError(`Meet ${field} is not an array.`)
+  const values = payload[field] ?? []
+  if (!Array.isArray(values) || values.length > pageSize) throw new IngestConfigError(`Meet ${field} exceeded the requested page size.`)
+  const items = values.map((value: unknown): Named => {
+    if (!isObject(value)) throw new IngestConfigError('Meet returned an invalid resource.')
+    const name = optionalString(value.name, 'resource name')
+    if (!name || (field === 'conferenceRecords' ? !/^conferenceRecords\/[^/?#]+$/.test(name) : !name.startsWith(`${path}/`) || name.slice(path.length + 1).includes('/') || /[?#]/.test(name))) throw new IngestConfigError(`Meet ${field} returned a resource outside its requested parent.`)
+    return { ...value, name }
+  })
+  return { items, nextPageToken: optionalString(payload.nextPageToken, 'nextPageToken') }
+}
diff --git a/registry/google-meet/config.ts b/registry/google-meet/config.ts
new file mode 100644
index 00000000..53e50357
--- /dev/null
+++ b/registry/google-meet/config.ts
@@ -0,0 +1,25 @@
+export interface GoogleMeetConfig {
+  /** Stable, non-secret label for one authenticated Google account. */
+  sourceId: string
+  /** Journal identities use this prefix; change it for a separate installation. */
+  streamPrefix: string
+  database: string
+  /** Re-read recent completed calls and their children; defaults to 24 hours. */
+  lookbackHours: number
+  /** Small discovery pages bound how many conferences replay after interruption. */
+  pageSize: number
+  maxChunks: number
+}
+
+/** Runtime settings; the exported destination schemas use database at setup time. */
+export type GoogleMeetReaderConfig = Omit<GoogleMeetConfig, 'database'>
+
+// Set schema placement before importing index.ts. Credentials are read at request time.
+export const googleMeetConfig: GoogleMeetConfig = {
+  sourceId: 'google-meet.primary',
+  streamPrefix: 'google-meet',
+  database: 'default',
+  lookbackHours: 24,
+  pageSize: 1,
+  maxChunks: 200,
+}
diff --git a/registry/google-meet/index.ts b/registry/google-meet/index.ts
index d6c89111..1822f8ff 100644
--- a/registry/google-meet/index.ts
+++ b/registry/google-meet/index.ts
@@ -1,66 +1,2 @@
-import { definePipeline, defineStream, HttpError, rawRows, rawTable, type FetchContext } from '@chkit/plugin-ingest'
-
-const database = 'default'
-// Pick a range that includes conferences whose transcripts may still be processing.
-const lookbackDays = 30
-const baseUrl = 'https://meet.googleapis.com/v2'
-
-interface Named { name: string; [key: string]: unknown }
-
-export const google_meet_conferencesRaw = rawTable({ database, name: 'google_meet_conferences_raw' })
-export const google_meet_transcriptsRaw = rawTable({ database, name: 'google_meet_transcripts_raw' })
-
-export const google_meetPipeline = definePipeline({
-  id: 'google-meet', tags: ['provider:google-meet'], maxStreams: 1, maxFetches: 1,
-  streams: [
-    defineStream({ id: 'google-meet.conferences', tags: ['resource:conferences'], destination: google_meet_conferencesRaw,
-      async *read(context) {
-        for await (const page of conferences(context)) yield { rows: rawRows(page, (item) => item.name) }
-      },
-    }),
-    defineStream({ id: 'google-meet.transcripts', tags: ['resource:transcripts'], destination: google_meet_transcriptsRaw,
-      async *read(context) {
-        for await (const page of conferences(context)) {
-          for (const conference of page) {
-            for await (const transcripts of list<Named>(context, `${conference.name}/transcripts`, 'transcripts')) {
-              for (const transcript of transcripts) {
-                const entries: unknown[] = []
-                for await (const part of list<unknown>(context, `${transcript.name}/entries`, 'transcriptEntries')) entries.push(...part)
-                yield { rows: rawRows([{ ...transcript, conference_name: conference.name, entries }], (item) => item.name) }
-              }
-            }
-          }
-        }
-      },
-    }),
-  ],
-})
-
-function conferences(context: FetchContext): AsyncGenerator<Named[]> {
-  const from = new Date(Date.now() - lookbackDays * 86_400_000).toISOString()
-  const to = new Date().toISOString()
-  return list<Named>(context, `conferenceRecords?filter=${encodeURIComponent(`start_time>="${from}" AND start_time<="${to}"`)}`, 'conferenceRecords')
-}
-
-async function* list<T>(context: FetchContext, path: string, field: string): AsyncGenerator<T[]> {
-  let pageToken: string | undefined
-  const seen = new Set<string>()
-  do {
-    const page = await context.attempt(async (signal) => {
-      const token = process.env.GOOGLE_MEET_ACCESS_TOKEN
-      if (!token) throw new Error('Set GOOGLE_MEET_ACCESS_TOKEN')
-      const url = new URL(`${baseUrl}/${path}`)
-      url.searchParams.set('pageSize', '100')
-      if (pageToken) url.searchParams.set('pageToken', pageToken)
-      const response = await fetch(url, { signal, headers: { Authorization: `Bearer ${token}` } })
-      if (!response.ok) throw await HttpError.fromResponse(response)
-      return await response.json() as Record<string, unknown>
-    }, { label: `GET ${field}` })
-    const items = page[field]
-    if (items !== undefined && !Array.isArray(items)) throw new Error(`Meet ${field} is not an array`)
-    if (Array.isArray(items) && items.length) yield items as T[]
-    pageToken = typeof page.nextPageToken === 'string' ? page.nextPageToken : undefined
-    if (pageToken && seen.has(pageToken)) throw new Error(`Meet repeated ${field} page token`)
-    if (pageToken) seen.add(pageToken)
-  } while (pageToken)
-}
+export { google_meetPipeline, createGoogleMeetPipeline } from './pipeline.js'
+export { google_meet_conferencesRaw, google_meet_transcriptsRaw, google_meet_transcriptEntriesRaw, google_meet_participantsRaw, google_meet_participantSessionsRaw, google_meet_recordingsRaw } from './sources/resources.js'
diff --git a/registry/google-meet/manifest.json b/registry/google-meet/manifest.json
index 1afe46c8..5576a8ea 100644
--- a/registry/google-meet/manifest.json
+++ b/registry/google-meet/manifest.json
@@ -3,10 +3,10 @@
   "name": "google-meet",
   "type": "registry:item",
   "title": "Google Meet",
-  "description": "Small, editable Google Meet API ingestion example with raw ClickHouse tables.",
+  "description": "Editable Google Meet API ingestion with journaled checkpoints and raw ClickHouse tables.",
   "dependencies": [
-    "@chkit/core@^0.2.0-beta.8",
-    "@chkit/plugin-ingest@^0.2.0-beta.8"
+    "@chkit/core@^0.2.0-beta.10",
+    "@chkit/plugin-ingest@^0.2.0-beta.10"
   ],
   "files": [
     {
@@ -18,25 +18,74 @@
       "path": "index.ts",
       "type": "registry:file",
       "target": "src/integrations/google-meet/index.ts"
+    },
+    {
+      "path": "config.ts",
+      "type": "registry:file",
+      "target": "src/integrations/google-meet/config.ts"
+    },
+    {
+      "path": "client.ts",
+      "type": "registry:file",
+      "target": "src/integrations/google-meet/client.ts"
+    },
+    {
+      "path": "pipeline.ts",
+      "type": "registry:file",
+      "target": "src/integrations/google-meet/pipeline.ts"
+    },
+    {
+      "path": "sources/resources.ts",
+      "type": "registry:file",
+      "target": "src/integrations/google-meet/sources/resources.ts"
+    },
+    {
+      "path": "tests/basic.test.ts",
+      "type": "registry:file",
+      "target": "src/integrations/google-meet/tests/basic.test.ts",
+      "role": "test"
     }
   ],
   "meta": {
     "chkit": {
       "formatVersion": 1,
-      "version": "0.1.0",
+      "version": "0.2.0",
+      "changelog": [
+        {
+          "version": "0.2.0",
+          "changes": [
+            "Sync six independent raw resources in one installation pipeline: conferences, participants, participant sessions, recordings, transcript metadata, and individual transcript entries.",
+            "Default initial discovery and subsequent overlap to 24 hours, including ongoing calls; reread child collections without retaining conference catalogs or child work queues.",
+            "Checkpoint completed discovery pages after their child rows land. Replay unfinished pages with ordinary pagination, fixed bounds, source scope, and bounded token recovery.",
+            "Keep recording metadata and Drive references without downloading files; keep child rows separate with provider-name join keys and source-scoped row IDs. Migrate legacy transcript identities and embedded entries deliberately when upgrading.",
+            "Separate editable configuration, injectable requests, and resource readers. Broader artifact coverage uses an explicit lookback or isolated backfill rather than automatic historical reconciliation."
+          ]
+        },
+        {
+          "version": "0.1.0",
+          "changes": [
+            "Introduce raw conference and transcript ingestion with transcript entries nested in each transcript observation."
+          ]
+        }
+      ],
       "documentation": "https://chkit.obsessiondb.com/integrations/google-meet/",
       "logo": "https://chkit.obsessiondb.com/logos/google-meet.svg",
       "language": "typescript",
       "license": "MIT",
-      "chkit": "^0.2.0-beta.8",
-      "ingest": "^0.2.0-beta.8",
+      "chkit": "^0.2.0-beta.10",
+      "ingest": "^0.2.0-beta.10",
       "clickhouse": ">=25.3.0",
       "root": "src/integrations/google-meet",
       "entry": "index.ts",
       "exports": [
         "google_meetPipeline",
+        "createGoogleMeetPipeline",
         "google_meet_conferencesRaw",
-        "google_meet_transcriptsRaw"
+        "google_meet_transcriptsRaw",
+        "google_meet_transcriptEntriesRaw",
+        "google_meet_participantsRaw",
+        "google_meet_participantSessionsRaw",
+        "google_meet_recordingsRaw"
       ],
       "resources": [
         {
@@ -47,7 +96,7 @@
           "scopes": [
             "https://www.googleapis.com/auth/meetings.space.readonly"
           ],
-          "strategy": "full",
+          "strategy": "timestamp",
           "endpoints": [
             {
               "method": "GET",
@@ -60,12 +109,39 @@
           "name": "transcripts",
           "title": "Transcripts",
           "table": "google_meet_transcripts_raw",
-          "description": "Transcript metadata and paged entries for each visible conference",
+          "description": "Native transcript metadata for independently discovered recent and ongoing conferences",
+          "scopes": [
+            "https://www.googleapis.com/auth/meetings.space.readonly"
+          ],
+          "strategy": "timestamp",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/conferenceRecords",
+              "documentation": "https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords/list"
+            },
+            {
+              "method": "GET",
+              "path": "/conferenceRecords/{conferenceRecord}/transcripts",
+              "documentation": "https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords.transcripts/list"
+            }
+          ]
+        },
+        {
+          "name": "transcript-entries",
+          "title": "Transcript entries",
+          "table": "google_meet_transcript_entries_raw",
+          "description": "Individually keyed transcript entries for independently discovered recent and ongoing conferences",
           "scopes": [
             "https://www.googleapis.com/auth/meetings.space.readonly"
           ],
-          "strategy": "full",
+          "strategy": "timestamp",
           "endpoints": [
+            {
+              "method": "GET",
+              "path": "/conferenceRecords",
+              "documentation": "https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords/list"
+            },
             {
               "method": "GET",
               "path": "/conferenceRecords/{conferenceRecord}/transcripts",
@@ -77,6 +153,77 @@
               "documentation": "https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords.transcripts.entries/list"
             }
           ]
+        },
+        {
+          "name": "participants",
+          "title": "Participants",
+          "table": "google_meet_participants_raw",
+          "description": "Native attendance records, including signed-in, anonymous, and phone participants",
+          "scopes": [
+            "https://www.googleapis.com/auth/meetings.space.readonly"
+          ],
+          "strategy": "timestamp",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/conferenceRecords",
+              "documentation": "https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords/list"
+            },
+            {
+              "method": "GET",
+              "path": "/conferenceRecords/{conferenceRecord}/participants",
+              "documentation": "https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords.participants/list"
+            }
+          ]
+        },
+        {
+          "name": "participant-sessions",
+          "title": "Participant sessions",
+          "table": "google_meet_participant_sessions_raw",
+          "description": "Individually keyed join/leave sessions with conference and participant names",
+          "scopes": [
+            "https://www.googleapis.com/auth/meetings.space.readonly"
+          ],
+          "strategy": "timestamp",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/conferenceRecords",
+              "documentation": "https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords/list"
+            },
+            {
+              "method": "GET",
+              "path": "/conferenceRecords/{conferenceRecord}/participants",
+              "documentation": "https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords.participants/list"
+            },
+            {
+              "method": "GET",
+              "path": "/conferenceRecords/{conferenceRecord}/participants/{participant}/participantSessions",
+              "documentation": "https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords.participants.participantSessions/list"
+            }
+          ]
+        },
+        {
+          "name": "recordings",
+          "title": "Recordings",
+          "table": "google_meet_recordings_raw",
+          "description": "Recording metadata and native Drive destination references; no file downloads",
+          "scopes": [
+            "https://www.googleapis.com/auth/meetings.space.readonly"
+          ],
+          "strategy": "timestamp",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/conferenceRecords",
+              "documentation": "https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords/list"
+            },
+            {
+              "method": "GET",
+              "path": "/conferenceRecords/{conferenceRecord}/recordings",
+              "documentation": "https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords.recordings/list"
+            }
+          ]
         }
       ],
       "env": {
@@ -95,10 +242,13 @@
       },
       "views": [],
       "sync": {
-        "description": "A full read runs for each enabled stream. Stable IDs keep the latest observed record.",
+        "description": "Six independent raw streams rediscover recent conferences with a 24-hour lookback and ongoing calls, checkpoint completed discovery pages, and replay unfinished child reads.",
         "schedule": "Run bunx chkit ingest run --tag provider:google-meet from a scheduler.",
-        "deletions": "Each run reads a configured time range. Transcripts generated later require another scan of that range."
+        "deletions": "Missing, inaccessible, or expired resources do not delete archived raw observations. Changes on conferences outside the selected window require a wider lookback or explicit backfill."
       }
     }
-  }
+  },
+  "devDependencies": [
+    "@types/bun@^1.2.0"
+  ]
 }
diff --git a/registry/google-meet/pipeline.ts b/registry/google-meet/pipeline.ts
new file mode 100644
index 00000000..11d281a2
--- /dev/null
+++ b/registry/google-meet/pipeline.ts
@@ -0,0 +1,43 @@
+import { cursorState, definePipeline, defineStream, IngestConfigError } from '@chkit/plugin-ingest'
+
+import { classifyGoogleMeetError, defaultGoogleMeetClientDeps, type GoogleMeetClientDeps } from './client.js'
+import { googleMeetConfig, type GoogleMeetReaderConfig } from './config.js'
+import { google_meet_conferencesRaw, google_meet_transcriptsRaw, google_meet_transcriptEntriesRaw, google_meet_participantsRaw, google_meet_participantSessionsRaw, google_meet_recordingsRaw, parseMeetState, readResource, type MeetSelection, type MeetState, type Resource } from './sources/resources.js'
+
+export function createGoogleMeetPipeline(config: GoogleMeetReaderConfig = googleMeetConfig, deps: GoogleMeetClientDeps = defaultGoogleMeetClientDeps) {
+  const boundConfig = { ...config }
+  if (!boundConfig.sourceId.trim() || !boundConfig.streamPrefix.trim()) throw new IngestConfigError('Meet sourceId and streamPrefix must be non-empty strings.')
+  if (!Number.isFinite(boundConfig.lookbackHours) || boundConfig.lookbackHours <= 0) throw new IngestConfigError('Meet lookbackHours must be positive.')
+  if (!Number.isSafeInteger(boundConfig.pageSize) || boundConfig.pageSize <= 0 || boundConfig.pageSize > 100) throw new IngestConfigError('Meet pageSize must be an integer between one and 100.')
+  if (!Number.isSafeInteger(boundConfig.maxChunks) || boundConfig.maxChunks <= 0) throw new IngestConfigError('Meet maxChunks must be a positive safe integer.')
+  const client = { ...deps, config: boundConfig }
+  return definePipeline({
+    id: boundConfig.streamPrefix, tags: ['provider:google-meet'], maxStreams: 1, maxFetches: 1,
+    streams: [
+      resourceStream('conferences', google_meet_conferencesRaw, client),
+      resourceStream('transcripts', google_meet_transcriptsRaw, client),
+      resourceStream('transcript-entries', google_meet_transcriptEntriesRaw, client),
+      resourceStream('participants', google_meet_participantsRaw, client),
+      resourceStream('participant-sessions', google_meet_participantSessionsRaw, client),
+      resourceStream('recordings', google_meet_recordingsRaw, client),
+    ],
+  })
+}
+
+export const google_meetPipeline = createGoogleMeetPipeline()
+
+function resourceStream(resource: Resource, destination: typeof google_meet_conferencesRaw, deps: GoogleMeetClientDeps) {
+  const config = deps.config
+  const checkpoint = cursorState({ id: `${config.streamPrefix}.${resource}.pages`, version: 2, parse: (raw) => parseMeetState(raw, config) })
+  return defineStream<Record<string, unknown>, MeetState, MeetSelection>({
+    id: `${config.streamPrefix}.${resource}`, tags: [`resource:${resource}`], destination,
+    incremental: {
+      id: checkpoint.id, version: checkpoint.version, parseState: checkpoint.parseState,
+      plan: ({ range }) => range,
+    },
+    batchSize: 1,
+    budget: { maxChunks: config.maxChunks, maxChunkRows: 100 },
+    classifyError: classifyGoogleMeetError,
+    read: (context) => readResource(context, resource, deps),
+  })
+}
diff --git a/registry/google-meet/releases/0.2.0.json b/registry/google-meet/releases/0.2.0.json
new file mode 100644
index 00000000..b592a38e
--- /dev/null
+++ b/registry/google-meet/releases/0.2.0.json
@@ -0,0 +1,270 @@
+{
+  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
+  "name": "google-meet",
+  "type": "registry:item",
+  "title": "Google Meet",
+  "description": "Editable Google Meet API ingestion with journaled checkpoints and raw ClickHouse tables.",
+  "dependencies": [
+    "@chkit/core@^0.2.0-beta.10",
+    "@chkit/plugin-ingest@^0.2.0-beta.10"
+  ],
+  "devDependencies": [
+    "@types/bun@^1.2.0"
+  ],
+  "files": [
+    {
+      "path": "google-meet/README.md",
+      "type": "registry:file",
+      "target": "src/integrations/google-meet/README.md",
+      "content": "# Google Meet raw ingestion\n\nThis editable reader rereads recent conferences and their raw resources, using ordinary pagination and coarse discovery-page checkpoints.\n\nSet `GOOGLE_MEET_ACCESS_TOKEN` with `meetings.space.readonly` access and configure a direct ClickHouse connection. Review `sourceId`, `streamPrefix`, `lookbackHours`, `pageSize`, `maxChunks`, and `database` in `config.ts`. Keep source identity tied to one Google account; these list responses do not identify the authenticated account. Tokens are read at request time and are not refreshed by the reader. Meet requires user authentication and returns records accessible to that user. Native JSON requires ClickHouse 25.3 or later. See [authorization](https://developers.google.com/workspace/meet/api/guides/authenticate-authorize).\n\n```sh\nbunx chkit check\nbunx chkit generate --name add_google_meet\n# Review the migration before applying it.\nbunx chkit migrate --apply\nbunx chkit ingest run --tag provider:google-meet\nbunx chkit ingest status --tag provider:google-meet\n```\n\n## Resources and streams\n\nOne installation pipeline contains six independent streams and destinations:\n\n- `conferences` → `google_meet_conferences_raw`\n- `participants` → `google_meet_participants_raw`\n- `participant-sessions` → `google_meet_participant_sessions_raw`\n- `recordings` → `google_meet_recordings_raw`\n- `transcripts` → `google_meet_transcripts_raw`\n- `transcript-entries` → `google_meet_transcript_entries_raw`\n\nEvery child stream discovers its own conferences. Sessions also discover participants; entries also discover transcripts. Select resources independently, in any order. Parent publication does not wait for children.\n\n```sh\nbunx chkit ingest run --tag provider:google-meet --tag resource:transcript-entries\nbunx chkit ingest run --tag provider:google-meet --tag resource:participant-sessions\n```\n\n`pipeline.ts` binds configuration, strategies and destinations. `sources/resources.ts` contains ordinary resource traversal; `client.ts` validates requests and uses `paginate`. The plugin owns request retries, cancellation, destination acknowledgement and checkpoint persistence.\n\n`sourceId` scopes raw identities and queries; `streamPrefix` determines journal IDs. Use separate values for another installation. `createGoogleMeetPipeline` snapshots configuration and injectable HTTP/token dependencies. Raw destinations are setup-time exports: edit `database` before schema imports to change placement. The default pipeline runs one stream and request at a time.\n\n## Recent coverage\n\nInitial discovery covers the preceding 24 hours by conference end time. Later runs begin at the last completed watermark minus `lookbackHours` (24 by default), so they reread recent calls and catch up after missed runs. Ongoing calls are discovered separately through `end_time IS NULL`, including calls that started before the lookback. Explicit historical bounds skip ongoing calls.\n\nEach selected conference's child collections are read completely. There is no retained-conference catalog, delayed-work queue, or automatic historical reconciliation. A transcript or recording that appears after its conference leaves the selected window requires a wider configured lookback or explicit backfill. Meet conference timestamps are not child modification timestamps. This is a deliberate recent polling policy. See [conference filters](https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords/list) and [artifacts](https://developers.google.com/workspace/meet/api/guides/artifacts).\n\n## Checkpoints and replay\n\nA checkpoint contains source scope, completed watermark, optional historical bounds, and an unfinished discovery window with phase/page token. The window is saved before discovery starts. Each discovery page and all its children finish before a state-only boundary advances its token; the executor commits that boundary only after the preceding rows land.\n\nA failed or interrupted page replays its child collections from their beginning under the original bounds. Completed discovery pages remain skipped. Child pages, indices and queues are not saved. The default discovery `pageSize` is one conference and `maxChunks` is 200. A page's children plus its completion marker must fit a run's chunk/time budget; increase `maxChunks` or `--max-duration` if one conference is too large. Requests have a 30-second timeout.\n\nA rejected page token restarts its collection once. Discovery reset debt is saved across executions and clears after the phase finishes. Child token recovery is bounded within its current read; a replayed parent starts fresh child collections. Repeated rejection and malformed/cyclic continuation fail visibly.\n\nCheckpoint strategy version 2 rejects incompatible state rather than reinterpreting it. Changing source or discovery settings requires deliberate state migration or a new `streamPrefix`. Run one ingestion process per target at a time.\n\n## Raw updates and relationships\n\nRaw identity is `[sourceId, provider.name]`. Children add `conference_name`; sessions add `participant_name`, and entries add `transcript_name`. All provider fields stay raw. Join resources and assemble transcripts later in ClickHouse.\n\nParticipants represent attendance; sessions represent individual joins/leaves. Recordings preserve metadata and Drive references without downloading files. Transcripts preserve metadata and document references; entry rows preserve individual speech segments. API entries do not reflect later edits to the separate Google Docs document.\n\nTables use `ReplacingMergeTree(_chkit_ingested_at)`. Every observed payload is inserted with the same stable resource ID; later ingestion wins. A transcript changing from `ENDED` to `FILE_GENERATED` therefore replaces its earlier observation. An empty transcript list emits no placeholder, so a later transcript inserts normally. No body hash or insert-only staging is needed. Use `FINAL` for latest observations.\n\nMissing, inaccessible or expired resources do not imply deletion. Google removes conference records and API entries after its retention period; expired history cannot be recovered, and stored raw observations remain. See [conference retention](https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords).\n\n## Historical ranges and upgrades\n\nBackfill bounds select conference end times, not child modification times. All children of selected conferences are read. Reuse the same backfill ID and bounds to resume; changed bounds require a new ID.\n\n```sh\nbunx chkit ingest run --tag provider:google-meet --backfill october --from 2026-10-01T00:00:00Z --to 2026-10-05T00:00:00Z\n```\n\nVersion 0.2.0 preserves the existing conference/transcript destinations and adds participant, session, recording and entry tables. Entries are separate rows rather than embedded transcript arrays. New row IDs include `sourceId`; legacy provider-name IDs remain until an explicit identity/data migration. Keep old rows as archives or migrate them deliberately.\n\n## Fixture verification\n\n```sh\nbunx chkit add google-meet --with-tests\nbun test src/integrations/google-meet/tests/basic.test.ts\n```\n\nFixtures cover independent resources, unfinished-page replay, completed-page resume, sink acknowledgement loss, changed bodies under stable IDs, recent late transcripts, empty pages, bounded token resets, fixed windows, scoped settings, historical isolation and request-time tokens.\n\nThe [Google Meet integration guide](https://chkit.obsessiondb.com/integrations/google-meet/) covers installation and sync behavior.\n"
+    },
+    {
+      "path": "google-meet/index.ts",
+      "type": "registry:file",
+      "target": "src/integrations/google-meet/index.ts",
+      "content": "export { google_meetPipeline, createGoogleMeetPipeline } from './pipeline.js'\nexport { google_meet_conferencesRaw, google_meet_transcriptsRaw, google_meet_transcriptEntriesRaw, google_meet_participantsRaw, google_meet_participantSessionsRaw, google_meet_recordingsRaw } from './sources/resources.js'\n"
+    },
+    {
+      "path": "google-meet/config.ts",
+      "type": "registry:file",
+      "target": "src/integrations/google-meet/config.ts",
+      "content": "export interface GoogleMeetConfig {\n  /** Stable, non-secret label for one authenticated Google account. */\n  sourceId: string\n  /** Journal identities use this prefix; change it for a separate installation. */\n  streamPrefix: string\n  database: string\n  /** Re-read recent completed calls and their children; defaults to 24 hours. */\n  lookbackHours: number\n  /** Small discovery pages bound how many conferences replay after interruption. */\n  pageSize: number\n  maxChunks: number\n}\n\n/** Runtime settings; the exported destination schemas use database at setup time. */\nexport type GoogleMeetReaderConfig = Omit<GoogleMeetConfig, 'database'>\n\n// Set schema placement before importing index.ts. Credentials are read at request time.\nexport const googleMeetConfig: GoogleMeetConfig = {\n  sourceId: 'google-meet.primary',\n  streamPrefix: 'google-meet',\n  database: 'default',\n  lookbackHours: 24,\n  pageSize: 1,\n  maxChunks: 200,\n}\n"
+    },
+    {
+      "path": "google-meet/client.ts",
+      "type": "registry:file",
+      "target": "src/integrations/google-meet/client.ts",
+      "content": "import { HttpError, IngestConfigError, paginate, type ErrorClassifier, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { googleMeetConfig, type GoogleMeetReaderConfig } from './config.js'\n\nexport interface Named { name: string; [key: string]: unknown }\nexport interface CollectionCursor { pageToken?: string; recoveryCount?: number }\ninterface CollectionOptions { filter?: string; initial?: CollectionCursor; pageSize?: number }\n\nexport interface GoogleMeetClientDeps {\n  config: GoogleMeetReaderConfig\n  fetch: (url: string, init: RequestInit) => Promise<Response>\n  token: () => string | undefined\n}\n\nexport const defaultGoogleMeetClientDeps: GoogleMeetClientDeps = {\n  config: googleMeetConfig,\n  fetch: (url, init) => fetch(url, init),\n  token: () => process.env.GOOGLE_MEET_ACCESS_TOKEN,\n}\n\nexport const classifyGoogleMeetError: ErrorClassifier = (cause) =>\n  cause instanceof IngestConfigError || cause instanceof SyntaxError ? { kind: 'permanent' } : undefined\n\nexport function readCollection(context: FetchContext, path: string, field: string, deps: GoogleMeetClientDeps, options: CollectionOptions = {}) {\n  return paginate<Named, CollectionCursor, { reset: true }>({\n    context, initial: options.initial ?? {}, label: `GET ${field}`,\n    fetchPage: async (cursor, signal) => {\n      const current = cursor ?? {}\n      const page = await requestPage(path, field, current.pageToken, options.filter, options.pageSize ?? 100, signal, deps)\n      if ('reset' in page) {\n        if (current.recoveryCount) throw new IngestConfigError(`Meet ${field} repeatedly rejected its page token. Increase the execution budget or migrate the checkpoint after reviewing coverage.`)\n        return { items: [], next: { recoveryCount: 1 }, metadata: { reset: true } }\n      }\n      return { items: page.items, next: page.nextPageToken ? { ...current, pageToken: page.nextPageToken } : undefined }\n    },\n  })\n}\n\nexport function optionalString(value: unknown, field: string): string | undefined {\n  if (value === undefined) return undefined\n  if (typeof value !== 'string' || !value.trim()) throw new IngestConfigError(`Meet ${field} must be a non-empty string.`)\n  return value\n}\n\nexport function optionalTimestamp(value: unknown, field: string): string | undefined {\n  return value === undefined ? undefined : timestamp(value, field)\n}\n\nexport function timestamp(value: unknown, field: string): string {\n  const result = optionalString(value, field)\n  if (!result || !Number.isFinite(Date.parse(result))) throw new IngestConfigError(`Meet ${field} is not a timestamp.`)\n  return result\n}\n\nexport function isObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value)\n}\n\nasync function requestPage(path: string, field: string, pageToken: string | undefined, filter: string | undefined, pageSize: number, signal: AbortSignal, deps: GoogleMeetClientDeps): Promise<{ items: Named[]; nextPageToken?: string } | { reset: true }> {\n  const token = deps.token()?.trim()\n  if (!token) throw new IngestConfigError('Set GOOGLE_MEET_ACCESS_TOKEN.')\n  const url = new URL(`https://meet.googleapis.com/v2/${path}`)\n  url.searchParams.set('pageSize', String(pageSize))\n  if (filter) url.searchParams.set('filter', filter)\n  if (pageToken) url.searchParams.set('pageToken', pageToken)\n  const response = await deps.fetch(url.toString(), { signal: AbortSignal.any([signal, AbortSignal.timeout(30_000)]), headers: { Authorization: `Bearer ${token}` }, redirect: 'error' })\n  if (pageToken && (response.status === 400 || response.status === 410)) {\n    const detail = await response.clone().text()\n    if (/page[_\\s-]*token/i.test(detail) && /invalid|expir/i.test(detail)) return { reset: true }\n  }\n  if (!response.ok) throw await HttpError.fromResponse(response)\n  const payload: unknown = await response.json()\n  if (!isObject(payload) || payload[field] !== undefined && !Array.isArray(payload[field])) throw new IngestConfigError(`Meet ${field} is not an array.`)\n  const values = payload[field] ?? []\n  if (!Array.isArray(values) || values.length > pageSize) throw new IngestConfigError(`Meet ${field} exceeded the requested page size.`)\n  const items = values.map((value: unknown): Named => {\n    if (!isObject(value)) throw new IngestConfigError('Meet returned an invalid resource.')\n    const name = optionalString(value.name, 'resource name')\n    if (!name || (field === 'conferenceRecords' ? !/^conferenceRecords\\/[^/?#]+$/.test(name) : !name.startsWith(`${path}/`) || name.slice(path.length + 1).includes('/') || /[?#]/.test(name))) throw new IngestConfigError(`Meet ${field} returned a resource outside its requested parent.`)\n    return { ...value, name }\n  })\n  return { items, nextPageToken: optionalString(payload.nextPageToken, 'nextPageToken') }\n}\n"
+    },
+    {
+      "path": "google-meet/pipeline.ts",
+      "type": "registry:file",
+      "target": "src/integrations/google-meet/pipeline.ts",
+      "content": "import { cursorState, definePipeline, defineStream, IngestConfigError } from '@chkit/plugin-ingest'\n\nimport { classifyGoogleMeetError, defaultGoogleMeetClientDeps, type GoogleMeetClientDeps } from './client.js'\nimport { googleMeetConfig, type GoogleMeetReaderConfig } from './config.js'\nimport { google_meet_conferencesRaw, google_meet_transcriptsRaw, google_meet_transcriptEntriesRaw, google_meet_participantsRaw, google_meet_participantSessionsRaw, google_meet_recordingsRaw, parseMeetState, readResource, type MeetSelection, type MeetState, type Resource } from './sources/resources.js'\n\nexport function createGoogleMeetPipeline(config: GoogleMeetReaderConfig = googleMeetConfig, deps: GoogleMeetClientDeps = defaultGoogleMeetClientDeps) {\n  const boundConfig = { ...config }\n  if (!boundConfig.sourceId.trim() || !boundConfig.streamPrefix.trim()) throw new IngestConfigError('Meet sourceId and streamPrefix must be non-empty strings.')\n  if (!Number.isFinite(boundConfig.lookbackHours) || boundConfig.lookbackHours <= 0) throw new IngestConfigError('Meet lookbackHours must be positive.')\n  if (!Number.isSafeInteger(boundConfig.pageSize) || boundConfig.pageSize <= 0 || boundConfig.pageSize > 100) throw new IngestConfigError('Meet pageSize must be an integer between one and 100.')\n  if (!Number.isSafeInteger(boundConfig.maxChunks) || boundConfig.maxChunks <= 0) throw new IngestConfigError('Meet maxChunks must be a positive safe integer.')\n  const client = { ...deps, config: boundConfig }\n  return definePipeline({\n    id: boundConfig.streamPrefix, tags: ['provider:google-meet'], maxStreams: 1, maxFetches: 1,\n    streams: [\n      resourceStream('conferences', google_meet_conferencesRaw, client),\n      resourceStream('transcripts', google_meet_transcriptsRaw, client),\n      resourceStream('transcript-entries', google_meet_transcriptEntriesRaw, client),\n      resourceStream('participants', google_meet_participantsRaw, client),\n      resourceStream('participant-sessions', google_meet_participantSessionsRaw, client),\n      resourceStream('recordings', google_meet_recordingsRaw, client),\n    ],\n  })\n}\n\nexport const google_meetPipeline = createGoogleMeetPipeline()\n\nfunction resourceStream(resource: Resource, destination: typeof google_meet_conferencesRaw, deps: GoogleMeetClientDeps) {\n  const config = deps.config\n  const checkpoint = cursorState({ id: `${config.streamPrefix}.${resource}.pages`, version: 2, parse: (raw) => parseMeetState(raw, config) })\n  return defineStream<Record<string, unknown>, MeetState, MeetSelection>({\n    id: `${config.streamPrefix}.${resource}`, tags: [`resource:${resource}`], destination,\n    incremental: {\n      id: checkpoint.id, version: checkpoint.version, parseState: checkpoint.parseState,\n      plan: ({ range }) => range,\n    },\n    batchSize: 1,\n    budget: { maxChunks: config.maxChunks, maxChunkRows: 100 },\n    classifyError: classifyGoogleMeetError,\n    read: (context) => readResource(context, resource, deps),\n  })\n}\n"
+    },
+    {
+      "path": "google-meet/sources/resources.ts",
+      "type": "registry:file",
+      "target": "src/integrations/google-meet/sources/resources.ts",
+      "content": "import { IngestConfigError, rawRows, rawTable, type ReadContext, type SourceChunk } from '@chkit/plugin-ingest'\n\nimport { isObject, optionalString, optionalTimestamp, readCollection, timestamp, type CollectionCursor, type GoogleMeetClientDeps, type Named } from '../client.js'\nimport { googleMeetConfig, type GoogleMeetReaderConfig } from '../config.js'\n\nconst hourMs = 3_600_000\n\nexport type Resource = 'conferences' | 'transcripts' | 'transcript-entries' | 'participants' | 'participant-sessions' | 'recordings'\ninterface Bounds { from?: string; to?: string }\ninterface Window extends CollectionCursor { from: string; to: string; phase: 'ended' | 'ongoing' }\nexport interface MeetState { scope: string; watermark?: string; bounds?: Bounds; window?: Window }\nexport type MeetSelection = { from: Date | undefined; to: Date | undefined } | undefined\ntype MeetContext = ReadContext<MeetSelection, MeetState>\ntype MeetChunk = SourceChunk<Record<string, unknown>, MeetState>\n\nexport const google_meet_conferencesRaw = rawTable({ database: googleMeetConfig.database, name: 'google_meet_conferences_raw' })\nexport const google_meet_transcriptsRaw = rawTable({ database: googleMeetConfig.database, name: 'google_meet_transcripts_raw' })\nexport const google_meet_transcriptEntriesRaw = rawTable({ database: googleMeetConfig.database, name: 'google_meet_transcript_entries_raw' })\nexport const google_meet_participantsRaw = rawTable({ database: googleMeetConfig.database, name: 'google_meet_participants_raw' })\nexport const google_meet_participantSessionsRaw = rawTable({ database: googleMeetConfig.database, name: 'google_meet_participant_sessions_raw' })\nexport const google_meet_recordingsRaw = rawTable({ database: googleMeetConfig.database, name: 'google_meet_recordings_raw' })\n\n// Every resource independently discovers conferences and replays unfinished parent pages.\nexport async function* readResource(context: MeetContext, resource: Resource, deps: GoogleMeetClientDeps): AsyncGenerator<MeetChunk> {\n  const scope = meetScope(deps.config)\n  let state: MeetState = context.state ?? { scope }\n  const requestedBounds = context.selection?.from || context.selection?.to\n    ? { from: context.selection.from?.toISOString(), to: context.selection.to?.toISOString() }\n    : undefined\n  if (requestedBounds && state.bounds && JSON.stringify(requestedBounds) !== JSON.stringify(state.bounds)) throw new IngestConfigError('Meet backfill bounds changed. Use a new backfill ID.')\n  if (requestedBounds && state.watermark && !state.bounds) throw new IngestConfigError('Meet checkpoint was created without date bounds. Use a new backfill ID.')\n  state = { ...state, bounds: state.bounds ?? requestedBounds }\n  if (!state.window) {\n    const to = state.bounds?.to ?? context.cutoff.toISOString()\n    const anchor = state.watermark ?? to\n    const from = state.bounds?.from ?? new Date(Date.parse(anchor) - deps.config.lookbackHours * hourMs).toISOString()\n    if (Date.parse(from) > Date.parse(to) || state.watermark && Date.parse(state.watermark) > Date.parse(to)) throw new IngestConfigError('Meet cutoff precedes its committed range.')\n    state = { ...state, window: { from, to, phase: 'ended' } }\n    yield progress(state)\n  }\n  while (state.window) {\n    const window = state.window\n    const filter = window.phase === 'ended'\n      ? `end_time>=\"${window.from}\" AND end_time<=\"${window.to}\"`\n      : `end_time IS NULL AND start_time<=\"${window.to}\"`\n    for await (const page of readCollection(context, 'conferenceRecords', 'conferenceRecords', deps, { filter, initial: { pageToken: window.pageToken, recoveryCount: window.recoveryCount }, pageSize: deps.config.pageSize })) {\n      if (!page.metadata?.reset) {\n        for (const conference of page.items) {\n          if (resource === 'conferences') yield { rows: rawRows([conference], (item) => JSON.stringify([deps.config.sourceId, item.name])) }\n          else yield* readChildren(context, resource, conference, deps)\n        }\n      }\n      state = page.next\n        ? { ...state, window: { from: window.from, to: window.to, phase: window.phase, ...page.next } }\n        : window.phase === 'ended' && !state.bounds\n          ? { ...state, window: { from: window.from, to: window.to, phase: 'ongoing' } }\n          : { scope, bounds: state.bounds, watermark: window.to }\n      // Flush all child rows before advancing discovery. Partial pages replay on resume.\n      yield progress(state)\n    }\n  }\n}\n\nexport function parseMeetState(raw: unknown, config: GoogleMeetReaderConfig): MeetState {\n  const scope = meetScope(config)\n  if (!isObject(raw) || raw.scope !== scope || 'pending' in raw || 'cycle' in raw || 'active' in raw) throw new IngestConfigError('Meet checkpoint scope or format changed. Migrate the state explicitly or use a new stream ID.')\n  const state: MeetState = { scope, watermark: optionalTimestamp(raw.watermark, 'watermark') }\n  if (raw.bounds !== undefined) {\n    if (!isObject(raw.bounds)) throw new IngestConfigError('Meet backfill bounds are invalid.')\n    state.bounds = { from: optionalTimestamp(raw.bounds.from, 'backfill from'), to: optionalTimestamp(raw.bounds.to, 'backfill to') }\n    if (!state.bounds.from && !state.bounds.to || state.bounds.from && state.bounds.to && Date.parse(state.bounds.from) > Date.parse(state.bounds.to)) throw new IngestConfigError('Meet backfill bounds are invalid.')\n  }\n  if (raw.window !== undefined) {\n    const window = raw.window\n    if (!isObject(window) || window.phase !== 'ended' && window.phase !== 'ongoing' || state.bounds && window.phase === 'ongoing') throw new IngestConfigError('Meet discovery window is invalid.')\n    const from = timestamp(window.from, 'window from')\n    const to = timestamp(window.to, 'window to')\n    if (Date.parse(from) > Date.parse(to) || state.bounds?.from && from !== state.bounds.from || state.bounds?.to && to !== state.bounds.to) throw new IngestConfigError('Meet discovery bounds are invalid.')\n    if (window.recoveryCount !== undefined && window.recoveryCount !== 1) throw new IngestConfigError('Meet recovery count must be one.')\n    state.window = { from, to, phase: window.phase, pageToken: optionalString(window.pageToken, 'pageToken'), recoveryCount: window.recoveryCount }\n  }\n  if (!state.window && !state.watermark) throw new IngestConfigError('Meet checkpoint has no discovery progress.')\n  return state\n}\n\nasync function* readChildren(context: MeetContext, resource: Exclude<Resource, 'conferences'>, conference: Named, deps: GoogleMeetClientDeps): AsyncGenerator<MeetChunk> {\n  const collection = resource === 'transcript-entries' ? 'transcripts' : resource === 'participant-sessions' ? 'participants' : resource\n  for await (const page of readCollection(context, `${conference.name}/${collection}`, collection, deps)) {\n    if (resource === 'transcript-entries' || resource === 'participant-sessions') {\n      const child = resource === 'transcript-entries' ? 'entries' : 'participantSessions'\n      const field = resource === 'transcript-entries' ? 'transcriptEntries' : child\n      const parentField = resource === 'transcript-entries' ? 'transcript_name' : 'participant_name'\n      for (const parent of page.items) {\n        for await (const children of readCollection(context, `${parent.name}/${child}`, field, deps)) {\n          yield { rows: rawRows(children.items.map((item) => ({ ...item, conference_name: conference.name, [parentField]: parent.name })), (item) => JSON.stringify([deps.config.sourceId, item.name])) }\n        }\n      }\n      if (!page.items.length) yield { rows: [] }\n    } else {\n      yield { rows: rawRows(page.items.map((item) => ({ ...item, conference_name: conference.name })), (item) => JSON.stringify([deps.config.sourceId, item.name])) }\n    }\n  }\n}\n\nfunction progress(state: MeetState): MeetChunk {\n  return { rows: [], state, id: 'meet-discovery-progress' }\n}\n\nfunction meetScope(config: GoogleMeetReaderConfig): string {\n  return JSON.stringify([config.sourceId, config.lookbackHours, config.pageSize])\n}\n"
+    },
+    {
+      "path": "google-meet/tests/basic.test.ts",
+      "type": "registry:file",
+      "target": "src/integrations/google-meet/tests/basic.test.ts",
+      "role": "test",
+      "content": "import { expect, test } from 'bun:test'\nimport { runIngestion, selectStreams } from '@chkit/plugin-ingest'\nimport { createMemoryDestination, createMemoryJournal } from '@chkit/plugin-ingest/testing'\n\nimport { googleMeetConfig } from '../config.js'\nimport { createGoogleMeetPipeline } from '../pipeline.js'\nimport { parseMeetState, type Resource } from '../sources/resources.js'\n\nconst cutoff = new Date('2026-10-05T00:00:00Z')\nconst conference = { name: 'conferenceRecords/c1', startTime: '2026-10-02T00:00:00Z', endTime: '2026-10-04T12:00:00Z', expireTime: '2026-11-03T12:00:00Z' }\nconst transcript = { name: `${conference.name}/transcripts/t1`, state: 'FILE_GENERATED' }\nconst entry = { name: `${transcript.name}/entries/e1`, text: 'first' }\nconst participant = { name: `${conference.name}/participants/p1`, signedinUser: { user: 'users/u1' } }\nconst session = { name: `${participant.name}/participantSessions/s1`, startTime: conference.startTime }\nconst recording = { name: `${conference.name}/recordings/r1`, state: 'FILE_GENERATED', driveDestination: { file: 'drive-file-1' } }\nconst resources: readonly Resource[] = ['conferences', 'transcripts', 'transcript-entries', 'participants', 'participant-sessions', 'recordings']\n\ntest('Meet replays an unfinished discovery page and its entries under the original window', async () => {\n  const urls: URL[] = []\n  const pipeline = fixturePipeline((url) => { urls.push(url); return fixture(url) })\n  const initial = createMemoryJournal()\n  const destination = createMemoryDestination()\n  const first = await runIngestion(request(pipeline, 'transcript-entries', 2), { journal: initial, destination, now: () => cutoff })\n  expect(first.streams[0]?.outcome).toBe('budget_exhausted')\n  const checkpoint = await initial.readCheckpoint('google-meet.transcript-entries')\n  expect(checkpoint.envelope?.state).toMatchObject({ window: { from: '2026-10-04T00:00:00.000Z', to: cutoff.toISOString(), phase: 'ended' } })\n  expect(checkpoint.envelope?.state).not.toHaveProperty('watermark')\n  expect(checkpoint.envelope?.state).not.toHaveProperty('active')\n  const previous = urls.length\n  const journal = restoredJournal(initial)\n  const resumed = await runIngestion(request(pipeline), { journal, destination, now: () => new Date('2026-10-06T00:00:00Z') })\n  expect(resumed.ok, JSON.stringify(resumed)).toBe(true)\n  expect(urls[previous]?.pathname).toBe('/v2/conferenceRecords')\n  expect(urls[previous]?.searchParams.get('filter')).toBe(urls[0]?.searchParams.get('filter'))\n  expect(urls[previous + 1]?.pathname).toBe(`/v2/${conference.name}/transcripts`)\n  expect(urls[previous + 2]?.searchParams.has('pageToken')).toBe(false)\n  expect(new Set(destination.tables.get('default.google_meet_transcript_entries_raw')?.map((row) => row.id)).size).toBe(2)\n  expect((await journal.readCheckpoint('google-meet.transcript-entries')).envelope?.state).toMatchObject({ watermark: cutoff.toISOString() })\n})\n\ntest('Meet completes every parent on a discovery page before saving its continuation', async () => {\n  const other = { ...conference, name: 'conferenceRecords/c2' }\n  const urls: URL[] = []\n  const pipeline = fixturePipeline((url) => {\n    urls.push(url)\n    if (url.pathname === '/v2/conferenceRecords') return Response.json({ conferenceRecords: url.searchParams.get('filter')?.includes('IS NULL') ? [] : [conference, other] })\n    return fixture(url)\n  }, { ...googleMeetConfig, pageSize: 2 })\n  const journal = createMemoryJournal()\n  const destination = createMemoryDestination()\n  expect((await runIngestion(request(pipeline, 'transcript-entries', 3), { journal, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')\n  expect((await journal.readCheckpoint('google-meet.transcript-entries')).envelope?.state).toHaveProperty('window')\n  const previous = urls.length\n  expect((await runIngestion(request(pipeline), { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect(urls.slice(previous).some((url) => url.pathname === `/v2/${other.name}/transcripts`)).toBe(true)\n  expect(new Set(destination.tables.get('default.google_meet_transcript_entries_raw')?.map((row) => row.id)).size).toBe(4)\n})\n\ntest('Meet resumes at the next discovery page after completing an earlier parent', async () => {\n  const other = { ...conference, name: 'conferenceRecords/c2' }\n  const urls: URL[] = []\n  const pipeline = fixturePipeline((url) => {\n    urls.push(url)\n    if (url.pathname === '/v2/conferenceRecords') return Response.json(url.searchParams.get('filter')?.includes('IS NULL') ? { conferenceRecords: [] } : url.searchParams.has('pageToken')\n      ? { conferenceRecords: [other] } : { conferenceRecords: [conference], nextPageToken: 'parents-next' })\n    return fixture(url)\n  })\n  const journal = createMemoryJournal()\n  const destination = createMemoryDestination()\n  expect((await runIngestion(request(pipeline, 'transcript-entries', 4), { journal, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')\n  expect((await journal.readCheckpoint('google-meet.transcript-entries')).envelope?.state).toMatchObject({ window: { pageToken: 'parents-next' } })\n  const previous = urls.length\n  expect((await runIngestion(request(pipeline), { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect(urls[previous]?.searchParams.get('pageToken')).toBe('parents-next')\n  expect(urls.slice(previous).some((url) => url.pathname.startsWith(`/v2/${conference.name}/`))).toBe(false)\n  expect(new Set(destination.tables.get('default.google_meet_transcript_entries_raw')?.map((row) => row.id)).size).toBe(4)\n})\n\ntest('Meet replays child rows after lost destination acknowledgement without advancing discovery', async () => {\n  const pipeline = fixturePipeline()\n  const journal = createMemoryJournal()\n  const destination = createMemoryDestination()\n  const failed = await runIngestion(request(pipeline), { journal, destination: {\n    async insert(input) {\n      await destination.insert(input)\n      if (input.rows.some((row) => JSON.stringify(row.raw).includes('second'))) throw new Error('lost acknowledgement')\n    },\n  }, now: () => cutoff })\n  expect(failed.ok).toBe(false)\n  expect((await journal.readCheckpoint('google-meet.transcript-entries')).envelope?.state).toHaveProperty('window')\n  expect((await journal.readCheckpoint('google-meet.transcript-entries')).envelope?.state).not.toHaveProperty('watermark')\n  expect((await runIngestion(request(pipeline), { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect(new Set(destination.tables.get('default.google_meet_transcript_entries_raw')?.map((row) => row.id)).size).toBe(2)\n})\n\ntest('Meet replay publishes changed child content under the same raw identity', async () => {\n  let changed = false\n  const pipeline = fixturePipeline((url) => url.pathname.endsWith('/entries') && !url.searchParams.has('pageToken')\n    ? Response.json({ transcriptEntries: [{ ...entry, text: changed ? 'revised' : 'first' }], nextPageToken: 'entries-next' })\n    : fixture(url))\n  const journal = createMemoryJournal()\n  const destination = createMemoryDestination()\n  expect((await runIngestion(request(pipeline, 'transcript-entries', 2), { journal, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')\n  changed = true\n  expect((await runIngestion(request(pipeline), { journal, destination, now: () => cutoff })).ok).toBe(true)\n  const versions = destination.tables.get('default.google_meet_transcript_entries_raw')?.filter((row) => row.id === JSON.stringify([googleMeetConfig.sourceId, entry.name]))\n  expect(versions?.map((row) => row.raw)).toEqual([\n    { ...entry, conference_name: conference.name, transcript_name: transcript.name },\n    { ...entry, text: 'revised', conference_name: conference.name, transcript_name: transcript.name },\n  ])\n})\n\ntest('Meet discovers the preceding 24 hours by end time and also includes ongoing calls', async () => {\n  const urls: URL[] = []\n  const ongoing = { ...conference, name: 'conferenceRecords/ongoing', endTime: undefined }\n  const pipeline = fixturePipeline((url) => {\n    urls.push(url)\n    return Response.json({ conferenceRecords: url.searchParams.get('filter')?.includes('IS NULL') ? [ongoing] : [conference] })\n  })\n  const destination = createMemoryDestination()\n  expect((await runIngestion(request(pipeline, 'conferences'), { journal: createMemoryJournal(), destination, now: () => cutoff })).ok).toBe(true)\n  expect(urls.map((url) => url.searchParams.get('filter'))).toEqual([\n    'end_time>=\"2026-10-04T00:00:00.000Z\" AND end_time<=\"2026-10-05T00:00:00.000Z\"',\n    'end_time IS NULL AND start_time<=\"2026-10-05T00:00:00.000Z\"',\n  ])\n  expect(urls.map((url) => url.searchParams.get('pageSize'))).toEqual(['1', '1'])\n  expect(destination.tables.get('default.google_meet_conferences_raw')).toHaveLength(2)\n})\n\ntest('Meet catches up from its completed watermark while rereading a 24-hour overlap', async () => {\n  const filters: Array<string | null> = []\n  const pipeline = fixturePipeline((url) => { filters.push(url.searchParams.get('filter')); return Response.json({ conferenceRecords: [] }) })\n  const journal = createMemoryJournal()\n  const destination = createMemoryDestination()\n  expect((await runIngestion(request(pipeline, 'conferences'), { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect((await runIngestion(request(pipeline, 'conferences'), { journal, destination, now: () => new Date('2026-10-07T00:00:00Z') })).ok).toBe(true)\n  expect(filters[2]).toBe('end_time>=\"2026-10-04T00:00:00.000Z\" AND end_time<=\"2026-10-07T00:00:00.000Z\"')\n})\n\ntest('Meet discovers a late transcript within the lookback without a not-ready placeholder', async () => {\n  let ready = false\n  const pipeline = fixturePipeline((url) => url.pathname.endsWith('/transcripts') && !ready ? Response.json({ transcripts: [] }) : fixture(url))\n  const journal = createMemoryJournal()\n  const destination = createMemoryDestination()\n  expect((await runIngestion(request(pipeline), { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect(destination.tables.size).toBe(0)\n  ready = true\n  expect((await runIngestion(request(pipeline), { journal, destination, now: () => new Date('2026-10-05T06:00:00Z') })).ok).toBe(true)\n  expect(new Set(destination.tables.get('default.google_meet_transcript_entries_raw')?.map((row) => row.id)).size).toBe(2)\n})\n\ntest('Meet does not retain old conference IDs after they leave discovery', async () => {\n  let visible = true\n  let children = 0\n  const pipeline = fixturePipeline((url) => {\n    if (url.pathname === '/v2/conferenceRecords' && !visible) return Response.json({ conferenceRecords: [] })\n    if (url.pathname.endsWith('/transcripts')) children += 1\n    return fixture(url)\n  })\n  const journal = createMemoryJournal()\n  const destination = createMemoryDestination()\n  expect((await runIngestion(request(pipeline, 'transcripts'), { journal, destination, now: () => cutoff })).ok).toBe(true)\n  const previous = children\n  visible = false\n  expect((await runIngestion(request(pipeline, 'transcripts'), { journal, destination, now: () => new Date('2026-10-06T06:00:00Z') })).ok).toBe(true)\n  expect(children).toBe(previous)\n  expect((await journal.readCheckpoint('google-meet.transcripts')).envelope?.state).not.toHaveProperty('pending')\n})\n\ntest('Meet writes changed transcript state under one identity on later completed passes', async () => {\n  let ready = false\n  const pipeline = fixturePipeline((url) => url.pathname.endsWith('/transcripts')\n    ? Response.json({ transcripts: [{ ...transcript, state: ready ? 'FILE_GENERATED' : 'ENDED' }] })\n    : fixture(url))\n  const journal = createMemoryJournal()\n  const destination = createMemoryDestination()\n  expect((await runIngestion(request(pipeline, 'transcripts'), { journal, destination, now: () => cutoff })).ok).toBe(true)\n  ready = true\n  expect((await runIngestion(request(pipeline, 'transcripts'), { journal, destination, now: () => new Date('2026-10-05T01:00:00Z') })).ok).toBe(true)\n  const rows = destination.tables.get('default.google_meet_transcripts_raw')\n  expect(rows?.map((row) => row.id)).toEqual([JSON.stringify([googleMeetConfig.sourceId, transcript.name]), JSON.stringify([googleMeetConfig.sourceId, transcript.name])])\n  expect(rows?.map((row) => row.raw)).toEqual([\n    { ...transcript, state: 'ENDED', conference_name: conference.name },\n    { ...transcript, conference_name: conference.name },\n  ])\n})\n\ntest('Meet commits empty discovery pages and resumes their token with unchanged bounds', async () => {\n  const urls: URL[] = []\n  const pipeline = fixturePipeline((url) => {\n    urls.push(url)\n    return Response.json({ conferenceRecords: [], ...(!url.searchParams.has('pageToken') && !url.searchParams.get('filter')?.includes('IS NULL') ? { nextPageToken: 'discover-next' } : {}) })\n  })\n  const journal = createMemoryJournal()\n  const destination = createMemoryDestination()\n  expect((await runIngestion(request(pipeline, 'conferences', 2), { journal, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')\n  expect((await journal.readCheckpoint('google-meet.conferences')).envelope?.state).toMatchObject({ window: { pageToken: 'discover-next', to: cutoff.toISOString() } })\n  expect((await runIngestion(request(pipeline, 'conferences'), { journal, destination, now: () => new Date('2026-10-06T00:00:00Z') })).ok).toBe(true)\n  expect(urls[1]?.searchParams.get('pageToken')).toBe('discover-next')\n  expect(urls[1]?.searchParams.get('filter')).toBe(urls[0]?.searchParams.get('filter'))\n  expect((await journal.readCheckpoint('google-meet.conferences')).envelope?.state).toMatchObject({ watermark: cutoff.toISOString() })\n  expect(destination.tables.size).toBe(0)\n})\n\ntest('Meet discovery reset clears the rejected token and keeps recovery debt across fresh runs', async () => {\n  const pipeline = fixturePipeline((url) => url.searchParams.has('pageToken')\n    ? new Response('expired page token', { status: 400 })\n    : Response.json({ conferenceRecords: [], nextPageToken: 'discover-next' }))\n  const initial = createMemoryJournal()\n  const destination = createMemoryDestination()\n  expect((await runIngestion(request(pipeline, 'conferences', 2), { journal: initial, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')\n  const reset = restoredJournal(initial)\n  expect((await runIngestion(request(pipeline, 'conferences', 1), { journal: reset, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')\n  const state = (await reset.readCheckpoint('google-meet.conferences')).envelope?.state\n  expect(state).toMatchObject({ window: { recoveryCount: 1 } })\n  expect(state).not.toHaveProperty('window.pageToken')\n  const replay = restoredJournal(reset)\n  expect((await runIngestion(request(pipeline, 'conferences', 1), { journal: replay, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')\n  expect((await replay.readCheckpoint('google-meet.conferences')).envelope?.state).toMatchObject({ window: { pageToken: 'discover-next', recoveryCount: 1 } })\n  const fresh = restoredJournal(replay)\n  const before = await fresh.readCheckpoint('google-meet.conferences')\n  const stopped = await runIngestion(request(pipeline, 'conferences'), { journal: fresh, destination, now: () => cutoff })\n  expect(stopped.ok).toBe(false)\n  expect(stopped.streams[0]?.error).toContain('repeatedly rejected')\n  expect((await fresh.readCheckpoint('google-meet.conferences')).version).toBe(before.version)\n})\n\ntest('Meet can replay an expired child cursor within its unfinished parent page', async () => {\n  let rejected = false\n  const pipeline = fixturePipeline((url) => {\n    if (url.pathname.endsWith('/entries') && url.searchParams.has('pageToken') && !rejected) {\n      rejected = true\n      return new Response('page token expired', { status: 400 })\n    }\n    return fixture(url)\n  })\n  const destination = createMemoryDestination()\n  const result = await runIngestion(request(pipeline), { journal: createMemoryJournal(), destination, now: () => cutoff })\n  expect(result.ok, JSON.stringify(result)).toBe(true)\n  expect(rejected).toBe(true)\n  expect(new Set(destination.tables.get('default.google_meet_transcript_entries_raw')?.map((row) => row.id)).size).toBe(2)\n})\n\ntest('Meet rejects repeated child continuations without completing the parent page', async () => {\n  const pipeline = fixturePipeline((url) => url.pathname.endsWith('/entries') ? Response.json({ transcriptEntries: [entry], nextPageToken: 'same' }) : fixture(url))\n  const journal = createMemoryJournal()\n  const result = await runIngestion(request(pipeline), { journal, destination: createMemoryDestination(), now: () => cutoff })\n  expect(result.ok).toBe(false)\n  expect(result.streams[0]?.error).toContain('repeated')\n  expect((await journal.readCheckpoint('google-meet.transcript-entries')).envelope?.state).not.toHaveProperty('watermark')\n})\n\ntest('Meet bounded backfills are isolated, skip ongoing calls, and reject changed bounds', async () => {\n  const filters: Array<string | null> = []\n  const pipeline = fixturePipeline((url) => { filters.push(url.searchParams.get('filter')); return Response.json({ conferenceRecords: [] }) })\n  const journal = createMemoryJournal()\n  const destination = createMemoryDestination()\n  const backfill = { id: 'october', from: new Date('2026-10-01T00:00:00Z'), to: new Date('2026-10-03T00:00:00Z') }\n  expect((await runIngestion({ ...request(pipeline, 'conferences'), backfill }, { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect(filters).toEqual(['end_time>=\"2026-10-01T00:00:00.000Z\" AND end_time<=\"2026-10-03T00:00:00.000Z\"'])\n  expect((await journal.readCheckpoint('google-meet.conferences')).version).toBe(0)\n  const changed = await runIngestion({ ...request(pipeline, 'conferences'), backfill: { ...backfill, to: new Date('2026-10-04T00:00:00Z') } }, { journal, destination, now: () => cutoff })\n  expect(changed.ok).toBe(false)\n  expect(changed.streams[0]?.error).toContain('backfill bounds changed')\n})\n\ntest('Meet factory snapshots configuration and reads tokens at request time', async () => {\n  const config = { ...googleMeetConfig, sourceId: 'meet.work', streamPrefix: 'meet.work', lookbackHours: 12 }\n  let token = 'first'\n  const requests: Array<{ url: URL; authorization: string | null }> = []\n  const pipeline = createGoogleMeetPipeline(config, {\n    config: googleMeetConfig, token: () => token,\n    fetch: async (input, init) => {\n      const url = new URL(input)\n      requests.push({ url, authorization: new Headers(init.headers).get('Authorization') })\n      return fixture(url)\n    },\n  })\n  config.sourceId = 'changed'\n  config.lookbackHours = 2\n  const destination = createMemoryDestination()\n  expect((await runIngestion(request(pipeline, 'transcripts'), { journal: createMemoryJournal(), destination, now: () => cutoff })).ok).toBe(true)\n  expect(requests[0]?.url.searchParams.get('filter')).toContain('2026-10-04T12:00:00.000Z')\n  expect(requests[0]?.authorization).toBe('Bearer first')\n  expect(destination.tables.get('default.google_meet_transcripts_raw')?.[0]?.id).toBe(JSON.stringify(['meet.work', transcript.name]))\n  token = 'second'\n  expect((await runIngestion(request(pipeline, 'conferences'), { journal: createMemoryJournal(), destination, now: () => cutoff })).ok).toBe(true)\n  expect(requests.at(-1)?.authorization).toBe('Bearer second')\n})\n\ntest('Meet changed source settings fail instead of reinterpreting an existing checkpoint', async () => {\n  const pipeline = fixturePipeline()\n  const journal = createMemoryJournal()\n  const destination = createMemoryDestination()\n  expect((await runIngestion(request(pipeline, 'transcripts'), { journal, destination, now: () => cutoff })).ok).toBe(true)\n  const changed = fixturePipeline(fixture, { ...googleMeetConfig, lookbackHours: 12 })\n  const result = await runIngestion(request(changed, 'transcripts'), { journal, destination, now: () => cutoff })\n  expect(result.ok).toBe(false)\n  expect(result.streams[0]?.error).toContain('scope or format changed')\n  const state = JSON.parse(JSON.stringify((await journal.readCheckpoint('google-meet.transcripts')).envelope?.state))\n  expect(() => parseMeetState({ ...state, pending: [] }, googleMeetConfig)).toThrow('scope or format')\n  expect(() => parseMeetState({ ...state, window: { from: '2026-10-05', to: '2026-10-04', phase: 'ended' } }, googleMeetConfig)).toThrow('bounds')\n})\n\ntest('Meet failure in one resource leaves the other independent streams able to complete', async () => {\n  const pipeline = fixturePipeline((url) => url.pathname.endsWith('/entries') ? new Response('forbidden', { status: 403 }) : fixture(url))\n  const journal = createMemoryJournal()\n  const destination = createMemoryDestination()\n  const result = await runIngestion(request(pipeline, 'all'), { journal, destination, now: () => cutoff })\n  expect(result.ok).toBe(false)\n  expect(result.streams.filter((stream) => stream.outcome === 'succeeded')).toHaveLength(5)\n  expect(result.streams.find((stream) => stream.streamId.endsWith('.transcript-entries'))?.error).toContain('403')\n  expect((await journal.readCheckpoint('google-meet.transcripts')).envelope?.state).toMatchObject({ watermark: cutoff.toISOString() })\n})\n\nfor (const resource of resources) {\n  test(`Meet independently reads raw ${resource}`, async () => {\n    const destination = createMemoryDestination()\n    const result = await runIngestion(request(fixturePipeline(), resource), { journal: createMemoryJournal(), destination, now: () => cutoff })\n    expect(result.ok, JSON.stringify(result)).toBe(true)\n    expect(result.streams).toHaveLength(1)\n    expect(destination.tables.size).toBe(1)\n    const rows = [...destination.tables.values()].flat()\n    expect(rows.length).toBeGreaterThan(0)\n    expect(rows.every((row) => typeof row.id === 'string' && typeof row.raw === 'object')).toBe(true)\n    if (resource === 'recordings') expect(rows[0]?.raw).toEqual({ ...recording, conference_name: conference.name })\n    if (resource === 'participant-sessions') expect(rows[0]?.raw).toEqual({ ...session, conference_name: conference.name, participant_name: participant.name })\n  })\n}\n\ntest('Meet validates request-time credentials and native parent paths before publishing data', async () => {\n  const missing = createGoogleMeetPipeline(googleMeetConfig, { config: googleMeetConfig, token: () => undefined, fetch: async () => { throw new Error('must not fetch') } })\n  const absent = await runIngestion(request(missing), { journal: createMemoryJournal(), destination: createMemoryDestination(), now: () => cutoff })\n  expect(absent.ok).toBe(false)\n  expect(absent.streams[0]?.error).toContain('GOOGLE_MEET_ACCESS_TOKEN')\n  const invalid = fixturePipeline((url) => url.pathname.endsWith('/transcripts') ? Response.json({ transcripts: [{ name: 'conferenceRecords/other/transcripts/t1' }] }) : fixture(url))\n  const destination = createMemoryDestination()\n  const result = await runIngestion(request(invalid, 'transcripts'), { journal: createMemoryJournal(), destination, now: () => cutoff })\n  expect(result.ok).toBe(false)\n  expect(result.streams[0]?.error).toContain('outside its requested parent')\n  expect(destination.tables.size).toBe(0)\n})\n\nfunction fixturePipeline(handler: (url: URL) => Response = fixture, config = googleMeetConfig) {\n  return { ...createGoogleMeetPipeline(config, { config, token: () => 'fixture',\n    fetch: async (input) => handler(new URL(input)),\n  }), retry: { retries: 0 } }\n}\n\nfunction request(pipeline: ReturnType<typeof createGoogleMeetPipeline>, resource: Resource | 'all' = 'transcript-entries', maxChunks?: number) {\n  const bounded = { ...pipeline, streams: pipeline.streams.map((stream) => ({ ...stream, ...(maxChunks === undefined ? {} : { budget: { ...stream.budget, maxChunks } }) })) }\n  return { selected: selectStreams([bounded], resource === 'all' ? [] : [`resource:${resource}`]), backfill: undefined }\n}\n\nfunction fixture(url: URL): Response {\n  const path = url.pathname.slice('/v2/'.length)\n  if (path === 'conferenceRecords') return Response.json({ conferenceRecords: url.searchParams.get('filter')?.includes('IS NULL') ? [] : [conference] })\n  if (path.endsWith('/transcripts')) return Response.json({ transcripts: [{ ...transcript, name: `${path}/t1` }] })\n  if (path.endsWith('/participants')) return Response.json({ participants: [{ ...participant, name: `${path}/p1` }] })\n  if (path.endsWith('/participantSessions')) return Response.json({ participantSessions: [{ ...session, name: `${path}/s1` }] })\n  if (path.endsWith('/recordings')) return Response.json({ recordings: [{ ...recording, name: `${path}/r1` }] })\n  if (path.endsWith('/entries')) return Response.json(url.searchParams.has('pageToken')\n    ? { transcriptEntries: [{ name: `${path}/e2`, text: 'second' }] }\n    : { transcriptEntries: [{ name: `${path}/e1`, text: 'first' }], nextPageToken: 'entries-next' })\n  throw new Error(`Unexpected Meet request ${url.toString()}`)\n}\n\nfunction restoredJournal(previous: ReturnType<typeof createMemoryJournal>) {\n  const journal = createMemoryJournal()\n  journal.events.push(...previous.events.map((event) => ({ ...event, checkpoint: event.checkpoint === undefined ? undefined : JSON.parse(JSON.stringify(event.checkpoint)) })))\n  return journal\n}\n"
+    }
+  ],
+  "meta": {
+    "chkit": {
+      "formatVersion": 1,
+      "version": "0.2.0",
+      "changelog": [
+        {
+          "version": "0.2.0",
+          "changes": [
+            "Sync six independent raw resources in one installation pipeline: conferences, participants, participant sessions, recordings, transcript metadata, and individual transcript entries.",
+            "Default initial discovery and subsequent overlap to 24 hours, including ongoing calls; reread child collections without retaining conference catalogs or child work queues.",
+            "Checkpoint completed discovery pages after their child rows land. Replay unfinished pages with ordinary pagination, fixed bounds, source scope, and bounded token recovery.",
+            "Keep recording metadata and Drive references without downloading files; keep child rows separate with provider-name join keys and source-scoped row IDs. Migrate legacy transcript identities and embedded entries deliberately when upgrading.",
+            "Separate editable configuration, injectable requests, and resource readers. Broader artifact coverage uses an explicit lookback or isolated backfill rather than automatic historical reconciliation."
+          ]
+        },
+        {
+          "version": "0.1.0",
+          "changes": [
+            "Introduce raw conference and transcript ingestion with transcript entries nested in each transcript observation."
+          ]
+        }
+      ],
+      "language": "typescript",
+      "license": "MIT",
+      "documentation": "https://chkit.obsessiondb.com/integrations/google-meet/",
+      "logo": "https://chkit.obsessiondb.com/logos/google-meet.svg",
+      "authentication": {
+        "method": "OAuth access token",
+        "env": [
+          "GOOGLE_MEET_ACCESS_TOKEN"
+        ],
+        "setup": [
+          "Provide GOOGLE_MEET_ACCESS_TOKEN with read access to the selected resources.",
+          "Supply a new access token when the existing token expires."
+        ],
+        "documentation": "https://developers.google.com/workspace/meet/api/guides/authenticate-authorize"
+      },
+      "chkit": "^0.2.0-beta.10",
+      "ingest": "^0.2.0-beta.10",
+      "clickhouse": ">=25.3.0",
+      "root": "src/integrations/google-meet",
+      "entry": "index.ts",
+      "exports": [
+        "google_meetPipeline",
+        "createGoogleMeetPipeline",
+        "google_meet_conferencesRaw",
+        "google_meet_transcriptsRaw",
+        "google_meet_transcriptEntriesRaw",
+        "google_meet_participantsRaw",
+        "google_meet_participantSessionsRaw",
+        "google_meet_recordingsRaw"
+      ],
+      "resources": [
+        {
+          "name": "conferences",
+          "title": "Conferences",
+          "table": "google_meet_conferences_raw",
+          "description": "Conference records visible to the access token",
+          "scopes": [
+            "https://www.googleapis.com/auth/meetings.space.readonly"
+          ],
+          "strategy": "timestamp",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/conferenceRecords",
+              "documentation": "https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords/list"
+            }
+          ]
+        },
+        {
+          "name": "transcripts",
+          "title": "Transcripts",
+          "table": "google_meet_transcripts_raw",
+          "description": "Native transcript metadata for independently discovered recent and ongoing conferences",
+          "scopes": [
+            "https://www.googleapis.com/auth/meetings.space.readonly"
+          ],
+          "strategy": "timestamp",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/conferenceRecords",
+              "documentation": "https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords/list"
+            },
+            {
+              "method": "GET",
+              "path": "/conferenceRecords/{conferenceRecord}/transcripts",
+              "documentation": "https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords.transcripts/list"
+            }
+          ]
+        },
+        {
+          "name": "transcript-entries",
+          "title": "Transcript entries",
+          "table": "google_meet_transcript_entries_raw",
+          "description": "Individually keyed transcript entries for independently discovered recent and ongoing conferences",
+          "scopes": [
+            "https://www.googleapis.com/auth/meetings.space.readonly"
+          ],
+          "strategy": "timestamp",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/conferenceRecords",
+              "documentation": "https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords/list"
+            },
+            {
+              "method": "GET",
+              "path": "/conferenceRecords/{conferenceRecord}/transcripts",
+              "documentation": "https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords.transcripts/list"
+            },
+            {
+              "method": "GET",
+              "path": "/conferenceRecords/{conferenceRecord}/transcripts/{transcript}/entries",
+              "documentation": "https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords.transcripts.entries/list"
+            }
+          ]
+        },
+        {
+          "name": "participants",
+          "title": "Participants",
+          "table": "google_meet_participants_raw",
+          "description": "Native attendance records, including signed-in, anonymous, and phone participants",
+          "scopes": [
+            "https://www.googleapis.com/auth/meetings.space.readonly"
+          ],
+          "strategy": "timestamp",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/conferenceRecords",
+              "documentation": "https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords/list"
+            },
+            {
+              "method": "GET",
+              "path": "/conferenceRecords/{conferenceRecord}/participants",
+              "documentation": "https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords.participants/list"
+            }
+          ]
+        },
+        {
+          "name": "participant-sessions",
+          "title": "Participant sessions",
+          "table": "google_meet_participant_sessions_raw",
+          "description": "Individually keyed join/leave sessions with conference and participant names",
+          "scopes": [
+            "https://www.googleapis.com/auth/meetings.space.readonly"
+          ],
+          "strategy": "timestamp",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/conferenceRecords",
+              "documentation": "https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords/list"
+            },
+            {
+              "method": "GET",
+              "path": "/conferenceRecords/{conferenceRecord}/participants",
+              "documentation": "https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords.participants/list"
+            },
+            {
+              "method": "GET",
+              "path": "/conferenceRecords/{conferenceRecord}/participants/{participant}/participantSessions",
+              "documentation": "https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords.participants.participantSessions/list"
+            }
+          ]
+        },
+        {
+          "name": "recordings",
+          "title": "Recordings",
+          "table": "google_meet_recordings_raw",
+          "description": "Recording metadata and native Drive destination references; no file downloads",
+          "scopes": [
+            "https://www.googleapis.com/auth/meetings.space.readonly"
+          ],
+          "strategy": "timestamp",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/conferenceRecords",
+              "documentation": "https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords/list"
+            },
+            {
+              "method": "GET",
+              "path": "/conferenceRecords/{conferenceRecord}/recordings",
+              "documentation": "https://developers.google.com/workspace/meet/api/reference/rest/v2/conferenceRecords.recordings/list"
+            }
+          ]
+        }
+      ],
+      "views": [],
+      "sync": {
+        "description": "Six independent raw streams rediscover recent conferences with a 24-hour lookback and ongoing calls, checkpoint completed discovery pages, and replay unfinished child reads.",
+        "schedule": "Run bunx chkit ingest run --tag provider:google-meet from a scheduler.",
+        "deletions": "Missing, inaccessible, or expired resources do not delete archived raw observations. Changes on conferences outside the selected window require a wider lookback or explicit backfill."
+      },
+      "env": {
+        "GOOGLE_MEET_ACCESS_TOKEN": ""
+      },
+      "fileHashes": {
+        "src/integrations/google-meet/README.md": "d3ffc29bea4a7c1f85ee58fddf65638337da85f2b0905ed650f308cf5f73d662",
+        "src/integrations/google-meet/index.ts": "f85338c2c73a16bc906b47831e8e0a2854c615d96e99359bab47d4aa2b56b0dd",
+        "src/integrations/google-meet/config.ts": "ea50993e17d4a9b1893fc4dd5338c20ce5f71300ce7ba70e9eda8106fa36daef",
+        "src/integrations/google-meet/client.ts": "03eead1a813c22bda108d7cfa61d04f669f3d1f5f260dd9acfa4b29ebeccb108",
+        "src/integrations/google-meet/pipeline.ts": "8f45fdeb9dbe821638c8b7991eb5f555edfbfd921425a849d1e46616df2a6cee",
+        "src/integrations/google-meet/sources/resources.ts": "c8cf7a3d65804d6d9da9584acac6e5c8b7d5da19f61bbe49d45d63b5d4c07f75",
+        "src/integrations/google-meet/tests/basic.test.ts": "95550a86095233911a53918dd291ff0d0b03ba4d88101d3237a28f15bc5deb25"
+      }
+    }
+  }
+}
diff --git a/registry/google-meet/sources/resources.ts b/registry/google-meet/sources/resources.ts
new file mode 100644
index 00000000..2ca4eea2
--- /dev/null
+++ b/registry/google-meet/sources/resources.ts
@@ -0,0 +1,111 @@
+import { IngestConfigError, rawRows, rawTable, type ReadContext, type SourceChunk } from '@chkit/plugin-ingest'
+
+import { isObject, optionalString, optionalTimestamp, readCollection, timestamp, type CollectionCursor, type GoogleMeetClientDeps, type Named } from '../client.js'
+import { googleMeetConfig, type GoogleMeetReaderConfig } from '../config.js'
+
+const hourMs = 3_600_000
+
+export type Resource = 'conferences' | 'transcripts' | 'transcript-entries' | 'participants' | 'participant-sessions' | 'recordings'
+interface Bounds { from?: string; to?: string }
+interface Window extends CollectionCursor { from: string; to: string; phase: 'ended' | 'ongoing' }
+export interface MeetState { scope: string; watermark?: string; bounds?: Bounds; window?: Window }
+export type MeetSelection = { from: Date | undefined; to: Date | undefined } | undefined
+type MeetContext = ReadContext<MeetSelection, MeetState>
+type MeetChunk = SourceChunk<Record<string, unknown>, MeetState>
+
+export const google_meet_conferencesRaw = rawTable({ database: googleMeetConfig.database, name: 'google_meet_conferences_raw' })
+export const google_meet_transcriptsRaw = rawTable({ database: googleMeetConfig.database, name: 'google_meet_transcripts_raw' })
+export const google_meet_transcriptEntriesRaw = rawTable({ database: googleMeetConfig.database, name: 'google_meet_transcript_entries_raw' })
+export const google_meet_participantsRaw = rawTable({ database: googleMeetConfig.database, name: 'google_meet_participants_raw' })
+export const google_meet_participantSessionsRaw = rawTable({ database: googleMeetConfig.database, name: 'google_meet_participant_sessions_raw' })
+export const google_meet_recordingsRaw = rawTable({ database: googleMeetConfig.database, name: 'google_meet_recordings_raw' })
+
+// Every resource independently discovers conferences and replays unfinished parent pages.
+export async function* readResource(context: MeetContext, resource: Resource, deps: GoogleMeetClientDeps): AsyncGenerator<MeetChunk> {
+  const scope = meetScope(deps.config)
+  let state: MeetState = context.state ?? { scope }
+  const requestedBounds = context.selection?.from || context.selection?.to
+    ? { from: context.selection.from?.toISOString(), to: context.selection.to?.toISOString() }
+    : undefined
+  if (requestedBounds && state.bounds && JSON.stringify(requestedBounds) !== JSON.stringify(state.bounds)) throw new IngestConfigError('Meet backfill bounds changed. Use a new backfill ID.')
+  if (requestedBounds && state.watermark && !state.bounds) throw new IngestConfigError('Meet checkpoint was created without date bounds. Use a new backfill ID.')
+  state = { ...state, bounds: state.bounds ?? requestedBounds }
+  if (!state.window) {
+    const to = state.bounds?.to ?? context.cutoff.toISOString()
+    const anchor = state.watermark ?? to
+    const from = state.bounds?.from ?? new Date(Date.parse(anchor) - deps.config.lookbackHours * hourMs).toISOString()
+    if (Date.parse(from) > Date.parse(to) || state.watermark && Date.parse(state.watermark) > Date.parse(to)) throw new IngestConfigError('Meet cutoff precedes its committed range.')
+    state = { ...state, window: { from, to, phase: 'ended' } }
+    yield progress(state)
+  }
+  while (state.window) {
+    const window = state.window
+    const filter = window.phase === 'ended'
+      ? `end_time>="${window.from}" AND end_time<="${window.to}"`
+      : `end_time IS NULL AND start_time<="${window.to}"`
+    for await (const page of readCollection(context, 'conferenceRecords', 'conferenceRecords', deps, { filter, initial: { pageToken: window.pageToken, recoveryCount: window.recoveryCount }, pageSize: deps.config.pageSize })) {
+      if (!page.metadata?.reset) {
+        for (const conference of page.items) {
+          if (resource === 'conferences') yield { rows: rawRows([conference], (item) => JSON.stringify([deps.config.sourceId, item.name])) }
+          else yield* readChildren(context, resource, conference, deps)
+        }
+      }
+      state = page.next
+        ? { ...state, window: { from: window.from, to: window.to, phase: window.phase, ...page.next } }
+        : window.phase === 'ended' && !state.bounds
+          ? { ...state, window: { from: window.from, to: window.to, phase: 'ongoing' } }
+          : { scope, bounds: state.bounds, watermark: window.to }
+      // Flush all child rows before advancing discovery. Partial pages replay on resume.
+      yield progress(state)
+    }
+  }
+}
+
+export function parseMeetState(raw: unknown, config: GoogleMeetReaderConfig): MeetState {
+  const scope = meetScope(config)
+  if (!isObject(raw) || raw.scope !== scope || 'pending' in raw || 'cycle' in raw || 'active' in raw) throw new IngestConfigError('Meet checkpoint scope or format changed. Migrate the state explicitly or use a new stream ID.')
+  const state: MeetState = { scope, watermark: optionalTimestamp(raw.watermark, 'watermark') }
+  if (raw.bounds !== undefined) {
+    if (!isObject(raw.bounds)) throw new IngestConfigError('Meet backfill bounds are invalid.')
+    state.bounds = { from: optionalTimestamp(raw.bounds.from, 'backfill from'), to: optionalTimestamp(raw.bounds.to, 'backfill to') }
+    if (!state.bounds.from && !state.bounds.to || state.bounds.from && state.bounds.to && Date.parse(state.bounds.from) > Date.parse(state.bounds.to)) throw new IngestConfigError('Meet backfill bounds are invalid.')
+  }
+  if (raw.window !== undefined) {
+    const window = raw.window
+    if (!isObject(window) || window.phase !== 'ended' && window.phase !== 'ongoing' || state.bounds && window.phase === 'ongoing') throw new IngestConfigError('Meet discovery window is invalid.')
+    const from = timestamp(window.from, 'window from')
+    const to = timestamp(window.to, 'window to')
+    if (Date.parse(from) > Date.parse(to) || state.bounds?.from && from !== state.bounds.from || state.bounds?.to && to !== state.bounds.to) throw new IngestConfigError('Meet discovery bounds are invalid.')
+    if (window.recoveryCount !== undefined && window.recoveryCount !== 1) throw new IngestConfigError('Meet recovery count must be one.')
+    state.window = { from, to, phase: window.phase, pageToken: optionalString(window.pageToken, 'pageToken'), recoveryCount: window.recoveryCount }
+  }
+  if (!state.window && !state.watermark) throw new IngestConfigError('Meet checkpoint has no discovery progress.')
+  return state
+}
+
+async function* readChildren(context: MeetContext, resource: Exclude<Resource, 'conferences'>, conference: Named, deps: GoogleMeetClientDeps): AsyncGenerator<MeetChunk> {
+  const collection = resource === 'transcript-entries' ? 'transcripts' : resource === 'participant-sessions' ? 'participants' : resource
+  for await (const page of readCollection(context, `${conference.name}/${collection}`, collection, deps)) {
+    if (resource === 'transcript-entries' || resource === 'participant-sessions') {
+      const child = resource === 'transcript-entries' ? 'entries' : 'participantSessions'
+      const field = resource === 'transcript-entries' ? 'transcriptEntries' : child
+      const parentField = resource === 'transcript-entries' ? 'transcript_name' : 'participant_name'
+      for (const parent of page.items) {
+        for await (const children of readCollection(context, `${parent.name}/${child}`, field, deps)) {
+          yield { rows: rawRows(children.items.map((item) => ({ ...item, conference_name: conference.name, [parentField]: parent.name })), (item) => JSON.stringify([deps.config.sourceId, item.name])) }
+        }
+      }
+      if (!page.items.length) yield { rows: [] }
+    } else {
+      yield { rows: rawRows(page.items.map((item) => ({ ...item, conference_name: conference.name })), (item) => JSON.stringify([deps.config.sourceId, item.name])) }
+    }
+  }
+}
+
+function progress(state: MeetState): MeetChunk {
+  return { rows: [], state, id: 'meet-discovery-progress' }
+}
+
+function meetScope(config: GoogleMeetReaderConfig): string {
+  return JSON.stringify([config.sourceId, config.lookbackHours, config.pageSize])
+}
diff --git a/registry/google-meet/tests/basic.test.ts b/registry/google-meet/tests/basic.test.ts
new file mode 100644
index 00000000..0e906a54
--- /dev/null
+++ b/registry/google-meet/tests/basic.test.ts
@@ -0,0 +1,372 @@
+import { expect, test } from 'bun:test'
+import { runIngestion, selectStreams } from '@chkit/plugin-ingest'
+import { createMemoryDestination, createMemoryJournal } from '@chkit/plugin-ingest/testing'
+
+import { googleMeetConfig } from '../config.js'
+import { createGoogleMeetPipeline } from '../pipeline.js'
+import { parseMeetState, type Resource } from '../sources/resources.js'
+
+const cutoff = new Date('2026-10-05T00:00:00Z')
+const conference = { name: 'conferenceRecords/c1', startTime: '2026-10-02T00:00:00Z', endTime: '2026-10-04T12:00:00Z', expireTime: '2026-11-03T12:00:00Z' }
+const transcript = { name: `${conference.name}/transcripts/t1`, state: 'FILE_GENERATED' }
+const entry = { name: `${transcript.name}/entries/e1`, text: 'first' }
+const participant = { name: `${conference.name}/participants/p1`, signedinUser: { user: 'users/u1' } }
+const session = { name: `${participant.name}/participantSessions/s1`, startTime: conference.startTime }
+const recording = { name: `${conference.name}/recordings/r1`, state: 'FILE_GENERATED', driveDestination: { file: 'drive-file-1' } }
+const resources: readonly Resource[] = ['conferences', 'transcripts', 'transcript-entries', 'participants', 'participant-sessions', 'recordings']
+
+test('Meet replays an unfinished discovery page and its entries under the original window', async () => {
+  const urls: URL[] = []
+  const pipeline = fixturePipeline((url) => { urls.push(url); return fixture(url) })
+  const initial = createMemoryJournal()
+  const destination = createMemoryDestination()
+  const first = await runIngestion(request(pipeline, 'transcript-entries', 2), { journal: initial, destination, now: () => cutoff })
+  expect(first.streams[0]?.outcome).toBe('budget_exhausted')
+  const checkpoint = await initial.readCheckpoint('google-meet.transcript-entries')
+  expect(checkpoint.envelope?.state).toMatchObject({ window: { from: '2026-10-04T00:00:00.000Z', to: cutoff.toISOString(), phase: 'ended' } })
+  expect(checkpoint.envelope?.state).not.toHaveProperty('watermark')
+  expect(checkpoint.envelope?.state).not.toHaveProperty('active')
+  const previous = urls.length
+  const journal = restoredJournal(initial)
+  const resumed = await runIngestion(request(pipeline), { journal, destination, now: () => new Date('2026-10-06T00:00:00Z') })
+  expect(resumed.ok, JSON.stringify(resumed)).toBe(true)
+  expect(urls[previous]?.pathname).toBe('/v2/conferenceRecords')
+  expect(urls[previous]?.searchParams.get('filter')).toBe(urls[0]?.searchParams.get('filter'))
+  expect(urls[previous + 1]?.pathname).toBe(`/v2/${conference.name}/transcripts`)
+  expect(urls[previous + 2]?.searchParams.has('pageToken')).toBe(false)
+  expect(new Set(destination.tables.get('default.google_meet_transcript_entries_raw')?.map((row) => row.id)).size).toBe(2)
+  expect((await journal.readCheckpoint('google-meet.transcript-entries')).envelope?.state).toMatchObject({ watermark: cutoff.toISOString() })
+})
+
+test('Meet completes every parent on a discovery page before saving its continuation', async () => {
+  const other = { ...conference, name: 'conferenceRecords/c2' }
+  const urls: URL[] = []
+  const pipeline = fixturePipeline((url) => {
+    urls.push(url)
+    if (url.pathname === '/v2/conferenceRecords') return Response.json({ conferenceRecords: url.searchParams.get('filter')?.includes('IS NULL') ? [] : [conference, other] })
+    return fixture(url)
+  }, { ...googleMeetConfig, pageSize: 2 })
+  const journal = createMemoryJournal()
+  const destination = createMemoryDestination()
+  expect((await runIngestion(request(pipeline, 'transcript-entries', 3), { journal, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')
+  expect((await journal.readCheckpoint('google-meet.transcript-entries')).envelope?.state).toHaveProperty('window')
+  const previous = urls.length
+  expect((await runIngestion(request(pipeline), { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect(urls.slice(previous).some((url) => url.pathname === `/v2/${other.name}/transcripts`)).toBe(true)
+  expect(new Set(destination.tables.get('default.google_meet_transcript_entries_raw')?.map((row) => row.id)).size).toBe(4)
+})
+
+test('Meet resumes at the next discovery page after completing an earlier parent', async () => {
+  const other = { ...conference, name: 'conferenceRecords/c2' }
+  const urls: URL[] = []
+  const pipeline = fixturePipeline((url) => {
+    urls.push(url)
+    if (url.pathname === '/v2/conferenceRecords') return Response.json(url.searchParams.get('filter')?.includes('IS NULL') ? { conferenceRecords: [] } : url.searchParams.has('pageToken')
+      ? { conferenceRecords: [other] } : { conferenceRecords: [conference], nextPageToken: 'parents-next' })
+    return fixture(url)
+  })
+  const journal = createMemoryJournal()
+  const destination = createMemoryDestination()
+  expect((await runIngestion(request(pipeline, 'transcript-entries', 4), { journal, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')
+  expect((await journal.readCheckpoint('google-meet.transcript-entries')).envelope?.state).toMatchObject({ window: { pageToken: 'parents-next' } })
+  const previous = urls.length
+  expect((await runIngestion(request(pipeline), { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect(urls[previous]?.searchParams.get('pageToken')).toBe('parents-next')
+  expect(urls.slice(previous).some((url) => url.pathname.startsWith(`/v2/${conference.name}/`))).toBe(false)
+  expect(new Set(destination.tables.get('default.google_meet_transcript_entries_raw')?.map((row) => row.id)).size).toBe(4)
+})
+
+test('Meet replays child rows after lost destination acknowledgement without advancing discovery', async () => {
+  const pipeline = fixturePipeline()
+  const journal = createMemoryJournal()
+  const destination = createMemoryDestination()
+  const failed = await runIngestion(request(pipeline), { journal, destination: {
+    async insert(input) {
+      await destination.insert(input)
+      if (input.rows.some((row) => JSON.stringify(row.raw).includes('second'))) throw new Error('lost acknowledgement')
+    },
+  }, now: () => cutoff })
+  expect(failed.ok).toBe(false)
+  expect((await journal.readCheckpoint('google-meet.transcript-entries')).envelope?.state).toHaveProperty('window')
+  expect((await journal.readCheckpoint('google-meet.transcript-entries')).envelope?.state).not.toHaveProperty('watermark')
+  expect((await runIngestion(request(pipeline), { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect(new Set(destination.tables.get('default.google_meet_transcript_entries_raw')?.map((row) => row.id)).size).toBe(2)
+})
+
+test('Meet replay publishes changed child content under the same raw identity', async () => {
+  let changed = false
+  const pipeline = fixturePipeline((url) => url.pathname.endsWith('/entries') && !url.searchParams.has('pageToken')
+    ? Response.json({ transcriptEntries: [{ ...entry, text: changed ? 'revised' : 'first' }], nextPageToken: 'entries-next' })
+    : fixture(url))
+  const journal = createMemoryJournal()
+  const destination = createMemoryDestination()
+  expect((await runIngestion(request(pipeline, 'transcript-entries', 2), { journal, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')
+  changed = true
+  expect((await runIngestion(request(pipeline), { journal, destination, now: () => cutoff })).ok).toBe(true)
+  const versions = destination.tables.get('default.google_meet_transcript_entries_raw')?.filter((row) => row.id === JSON.stringify([googleMeetConfig.sourceId, entry.name]))
+  expect(versions?.map((row) => row.raw)).toEqual([
+    { ...entry, conference_name: conference.name, transcript_name: transcript.name },
+    { ...entry, text: 'revised', conference_name: conference.name, transcript_name: transcript.name },
+  ])
+})
+
+test('Meet discovers the preceding 24 hours by end time and also includes ongoing calls', async () => {
+  const urls: URL[] = []
+  const ongoing = { ...conference, name: 'conferenceRecords/ongoing', endTime: undefined }
+  const pipeline = fixturePipeline((url) => {
+    urls.push(url)
+    return Response.json({ conferenceRecords: url.searchParams.get('filter')?.includes('IS NULL') ? [ongoing] : [conference] })
+  })
+  const destination = createMemoryDestination()
+  expect((await runIngestion(request(pipeline, 'conferences'), { journal: createMemoryJournal(), destination, now: () => cutoff })).ok).toBe(true)
+  expect(urls.map((url) => url.searchParams.get('filter'))).toEqual([
+    'end_time>="2026-10-04T00:00:00.000Z" AND end_time<="2026-10-05T00:00:00.000Z"',
+    'end_time IS NULL AND start_time<="2026-10-05T00:00:00.000Z"',
+  ])
+  expect(urls.map((url) => url.searchParams.get('pageSize'))).toEqual(['1', '1'])
+  expect(destination.tables.get('default.google_meet_conferences_raw')).toHaveLength(2)
+})
+
+test('Meet catches up from its completed watermark while rereading a 24-hour overlap', async () => {
+  const filters: Array<string | null> = []
+  const pipeline = fixturePipeline((url) => { filters.push(url.searchParams.get('filter')); return Response.json({ conferenceRecords: [] }) })
+  const journal = createMemoryJournal()
+  const destination = createMemoryDestination()
+  expect((await runIngestion(request(pipeline, 'conferences'), { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect((await runIngestion(request(pipeline, 'conferences'), { journal, destination, now: () => new Date('2026-10-07T00:00:00Z') })).ok).toBe(true)
+  expect(filters[2]).toBe('end_time>="2026-10-04T00:00:00.000Z" AND end_time<="2026-10-07T00:00:00.000Z"')
+})
+
+test('Meet discovers a late transcript within the lookback without a not-ready placeholder', async () => {
+  let ready = false
+  const pipeline = fixturePipeline((url) => url.pathname.endsWith('/transcripts') && !ready ? Response.json({ transcripts: [] }) : fixture(url))
+  const journal = createMemoryJournal()
+  const destination = createMemoryDestination()
+  expect((await runIngestion(request(pipeline), { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect(destination.tables.size).toBe(0)
+  ready = true
+  expect((await runIngestion(request(pipeline), { journal, destination, now: () => new Date('2026-10-05T06:00:00Z') })).ok).toBe(true)
+  expect(new Set(destination.tables.get('default.google_meet_transcript_entries_raw')?.map((row) => row.id)).size).toBe(2)
+})
+
+test('Meet does not retain old conference IDs after they leave discovery', async () => {
+  let visible = true
+  let children = 0
+  const pipeline = fixturePipeline((url) => {
+    if (url.pathname === '/v2/conferenceRecords' && !visible) return Response.json({ conferenceRecords: [] })
+    if (url.pathname.endsWith('/transcripts')) children += 1
+    return fixture(url)
+  })
+  const journal = createMemoryJournal()
+  const destination = createMemoryDestination()
+  expect((await runIngestion(request(pipeline, 'transcripts'), { journal, destination, now: () => cutoff })).ok).toBe(true)
+  const previous = children
+  visible = false
+  expect((await runIngestion(request(pipeline, 'transcripts'), { journal, destination, now: () => new Date('2026-10-06T06:00:00Z') })).ok).toBe(true)
+  expect(children).toBe(previous)
+  expect((await journal.readCheckpoint('google-meet.transcripts')).envelope?.state).not.toHaveProperty('pending')
+})
+
+test('Meet writes changed transcript state under one identity on later completed passes', async () => {
+  let ready = false
+  const pipeline = fixturePipeline((url) => url.pathname.endsWith('/transcripts')
+    ? Response.json({ transcripts: [{ ...transcript, state: ready ? 'FILE_GENERATED' : 'ENDED' }] })
+    : fixture(url))
+  const journal = createMemoryJournal()
+  const destination = createMemoryDestination()
+  expect((await runIngestion(request(pipeline, 'transcripts'), { journal, destination, now: () => cutoff })).ok).toBe(true)
+  ready = true
+  expect((await runIngestion(request(pipeline, 'transcripts'), { journal, destination, now: () => new Date('2026-10-05T01:00:00Z') })).ok).toBe(true)
+  const rows = destination.tables.get('default.google_meet_transcripts_raw')
+  expect(rows?.map((row) => row.id)).toEqual([JSON.stringify([googleMeetConfig.sourceId, transcript.name]), JSON.stringify([googleMeetConfig.sourceId, transcript.name])])
+  expect(rows?.map((row) => row.raw)).toEqual([
+    { ...transcript, state: 'ENDED', conference_name: conference.name },
+    { ...transcript, conference_name: conference.name },
+  ])
+})
+
+test('Meet commits empty discovery pages and resumes their token with unchanged bounds', async () => {
+  const urls: URL[] = []
+  const pipeline = fixturePipeline((url) => {
+    urls.push(url)
+    return Response.json({ conferenceRecords: [], ...(!url.searchParams.has('pageToken') && !url.searchParams.get('filter')?.includes('IS NULL') ? { nextPageToken: 'discover-next' } : {}) })
+  })
+  const journal = createMemoryJournal()
+  const destination = createMemoryDestination()
+  expect((await runIngestion(request(pipeline, 'conferences', 2), { journal, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')
+  expect((await journal.readCheckpoint('google-meet.conferences')).envelope?.state).toMatchObject({ window: { pageToken: 'discover-next', to: cutoff.toISOString() } })
+  expect((await runIngestion(request(pipeline, 'conferences'), { journal, destination, now: () => new Date('2026-10-06T00:00:00Z') })).ok).toBe(true)
+  expect(urls[1]?.searchParams.get('pageToken')).toBe('discover-next')
+  expect(urls[1]?.searchParams.get('filter')).toBe(urls[0]?.searchParams.get('filter'))
+  expect((await journal.readCheckpoint('google-meet.conferences')).envelope?.state).toMatchObject({ watermark: cutoff.toISOString() })
+  expect(destination.tables.size).toBe(0)
+})
+
+test('Meet discovery reset clears the rejected token and keeps recovery debt across fresh runs', async () => {
+  const pipeline = fixturePipeline((url) => url.searchParams.has('pageToken')
+    ? new Response('expired page token', { status: 400 })
+    : Response.json({ conferenceRecords: [], nextPageToken: 'discover-next' }))
+  const initial = createMemoryJournal()
+  const destination = createMemoryDestination()
+  expect((await runIngestion(request(pipeline, 'conferences', 2), { journal: initial, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')
+  const reset = restoredJournal(initial)
+  expect((await runIngestion(request(pipeline, 'conferences', 1), { journal: reset, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')
+  const state = (await reset.readCheckpoint('google-meet.conferences')).envelope?.state
+  expect(state).toMatchObject({ window: { recoveryCount: 1 } })
+  expect(state).not.toHaveProperty('window.pageToken')
+  const replay = restoredJournal(reset)
+  expect((await runIngestion(request(pipeline, 'conferences', 1), { journal: replay, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')
+  expect((await replay.readCheckpoint('google-meet.conferences')).envelope?.state).toMatchObject({ window: { pageToken: 'discover-next', recoveryCount: 1 } })
+  const fresh = restoredJournal(replay)
+  const before = await fresh.readCheckpoint('google-meet.conferences')
+  const stopped = await runIngestion(request(pipeline, 'conferences'), { journal: fresh, destination, now: () => cutoff })
+  expect(stopped.ok).toBe(false)
+  expect(stopped.streams[0]?.error).toContain('repeatedly rejected')
+  expect((await fresh.readCheckpoint('google-meet.conferences')).version).toBe(before.version)
+})
+
+test('Meet can replay an expired child cursor within its unfinished parent page', async () => {
+  let rejected = false
+  const pipeline = fixturePipeline((url) => {
+    if (url.pathname.endsWith('/entries') && url.searchParams.has('pageToken') && !rejected) {
+      rejected = true
+      return new Response('page token expired', { status: 400 })
+    }
+    return fixture(url)
+  })
+  const destination = createMemoryDestination()
+  const result = await runIngestion(request(pipeline), { journal: createMemoryJournal(), destination, now: () => cutoff })
+  expect(result.ok, JSON.stringify(result)).toBe(true)
+  expect(rejected).toBe(true)
+  expect(new Set(destination.tables.get('default.google_meet_transcript_entries_raw')?.map((row) => row.id)).size).toBe(2)
+})
+
+test('Meet rejects repeated child continuations without completing the parent page', async () => {
+  const pipeline = fixturePipeline((url) => url.pathname.endsWith('/entries') ? Response.json({ transcriptEntries: [entry], nextPageToken: 'same' }) : fixture(url))
+  const journal = createMemoryJournal()
+  const result = await runIngestion(request(pipeline), { journal, destination: createMemoryDestination(), now: () => cutoff })
+  expect(result.ok).toBe(false)
+  expect(result.streams[0]?.error).toContain('repeated')
+  expect((await journal.readCheckpoint('google-meet.transcript-entries')).envelope?.state).not.toHaveProperty('watermark')
+})
+
+test('Meet bounded backfills are isolated, skip ongoing calls, and reject changed bounds', async () => {
+  const filters: Array<string | null> = []
+  const pipeline = fixturePipeline((url) => { filters.push(url.searchParams.get('filter')); return Response.json({ conferenceRecords: [] }) })
+  const journal = createMemoryJournal()
+  const destination = createMemoryDestination()
+  const backfill = { id: 'october', from: new Date('2026-10-01T00:00:00Z'), to: new Date('2026-10-03T00:00:00Z') }
+  expect((await runIngestion({ ...request(pipeline, 'conferences'), backfill }, { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect(filters).toEqual(['end_time>="2026-10-01T00:00:00.000Z" AND end_time<="2026-10-03T00:00:00.000Z"'])
+  expect((await journal.readCheckpoint('google-meet.conferences')).version).toBe(0)
+  const changed = await runIngestion({ ...request(pipeline, 'conferences'), backfill: { ...backfill, to: new Date('2026-10-04T00:00:00Z') } }, { journal, destination, now: () => cutoff })
+  expect(changed.ok).toBe(false)
+  expect(changed.streams[0]?.error).toContain('backfill bounds changed')
+})
+
+test('Meet factory snapshots configuration and reads tokens at request time', async () => {
+  const config = { ...googleMeetConfig, sourceId: 'meet.work', streamPrefix: 'meet.work', lookbackHours: 12 }
+  let token = 'first'
+  const requests: Array<{ url: URL; authorization: string | null }> = []
+  const pipeline = createGoogleMeetPipeline(config, {
+    config: googleMeetConfig, token: () => token,
+    fetch: async (input, init) => {
+      const url = new URL(input)
+      requests.push({ url, authorization: new Headers(init.headers).get('Authorization') })
+      return fixture(url)
+    },
+  })
+  config.sourceId = 'changed'
+  config.lookbackHours = 2
+  const destination = createMemoryDestination()
+  expect((await runIngestion(request(pipeline, 'transcripts'), { journal: createMemoryJournal(), destination, now: () => cutoff })).ok).toBe(true)
+  expect(requests[0]?.url.searchParams.get('filter')).toContain('2026-10-04T12:00:00.000Z')
+  expect(requests[0]?.authorization).toBe('Bearer first')
+  expect(destination.tables.get('default.google_meet_transcripts_raw')?.[0]?.id).toBe(JSON.stringify(['meet.work', transcript.name]))
+  token = 'second'
+  expect((await runIngestion(request(pipeline, 'conferences'), { journal: createMemoryJournal(), destination, now: () => cutoff })).ok).toBe(true)
+  expect(requests.at(-1)?.authorization).toBe('Bearer second')
+})
+
+test('Meet changed source settings fail instead of reinterpreting an existing checkpoint', async () => {
+  const pipeline = fixturePipeline()
+  const journal = createMemoryJournal()
+  const destination = createMemoryDestination()
+  expect((await runIngestion(request(pipeline, 'transcripts'), { journal, destination, now: () => cutoff })).ok).toBe(true)
+  const changed = fixturePipeline(fixture, { ...googleMeetConfig, lookbackHours: 12 })
+  const result = await runIngestion(request(changed, 'transcripts'), { journal, destination, now: () => cutoff })
+  expect(result.ok).toBe(false)
+  expect(result.streams[0]?.error).toContain('scope or format changed')
+  const state = JSON.parse(JSON.stringify((await journal.readCheckpoint('google-meet.transcripts')).envelope?.state))
+  expect(() => parseMeetState({ ...state, pending: [] }, googleMeetConfig)).toThrow('scope or format')
+  expect(() => parseMeetState({ ...state, window: { from: '2026-10-05', to: '2026-10-04', phase: 'ended' } }, googleMeetConfig)).toThrow('bounds')
+})
+
+test('Meet failure in one resource leaves the other independent streams able to complete', async () => {
+  const pipeline = fixturePipeline((url) => url.pathname.endsWith('/entries') ? new Response('forbidden', { status: 403 }) : fixture(url))
+  const journal = createMemoryJournal()
+  const destination = createMemoryDestination()
+  const result = await runIngestion(request(pipeline, 'all'), { journal, destination, now: () => cutoff })
+  expect(result.ok).toBe(false)
+  expect(result.streams.filter((stream) => stream.outcome === 'succeeded')).toHaveLength(5)
+  expect(result.streams.find((stream) => stream.streamId.endsWith('.transcript-entries'))?.error).toContain('403')
+  expect((await journal.readCheckpoint('google-meet.transcripts')).envelope?.state).toMatchObject({ watermark: cutoff.toISOString() })
+})
+
+for (const resource of resources) {
+  test(`Meet independently reads raw ${resource}`, async () => {
+    const destination = createMemoryDestination()
+    const result = await runIngestion(request(fixturePipeline(), resource), { journal: createMemoryJournal(), destination, now: () => cutoff })
+    expect(result.ok, JSON.stringify(result)).toBe(true)
+    expect(result.streams).toHaveLength(1)
+    expect(destination.tables.size).toBe(1)
+    const rows = [...destination.tables.values()].flat()
+    expect(rows.length).toBeGreaterThan(0)
+    expect(rows.every((row) => typeof row.id === 'string' && typeof row.raw === 'object')).toBe(true)
+    if (resource === 'recordings') expect(rows[0]?.raw).toEqual({ ...recording, conference_name: conference.name })
+    if (resource === 'participant-sessions') expect(rows[0]?.raw).toEqual({ ...session, conference_name: conference.name, participant_name: participant.name })
+  })
+}
+
+test('Meet validates request-time credentials and native parent paths before publishing data', async () => {
+  const missing = createGoogleMeetPipeline(googleMeetConfig, { config: googleMeetConfig, token: () => undefined, fetch: async () => { throw new Error('must not fetch') } })
+  const absent = await runIngestion(request(missing), { journal: createMemoryJournal(), destination: createMemoryDestination(), now: () => cutoff })
+  expect(absent.ok).toBe(false)
+  expect(absent.streams[0]?.error).toContain('GOOGLE_MEET_ACCESS_TOKEN')
+  const invalid = fixturePipeline((url) => url.pathname.endsWith('/transcripts') ? Response.json({ transcripts: [{ name: 'conferenceRecords/other/transcripts/t1' }] }) : fixture(url))
+  const destination = createMemoryDestination()
+  const result = await runIngestion(request(invalid, 'transcripts'), { journal: createMemoryJournal(), destination, now: () => cutoff })
+  expect(result.ok).toBe(false)
+  expect(result.streams[0]?.error).toContain('outside its requested parent')
+  expect(destination.tables.size).toBe(0)
+})
+
+function fixturePipeline(handler: (url: URL) => Response = fixture, config = googleMeetConfig) {
+  return { ...createGoogleMeetPipeline(config, { config, token: () => 'fixture',
+    fetch: async (input) => handler(new URL(input)),
+  }), retry: { retries: 0 } }
+}
+
+function request(pipeline: ReturnType<typeof createGoogleMeetPipeline>, resource: Resource | 'all' = 'transcript-entries', maxChunks?: number) {
+  const bounded = { ...pipeline, streams: pipeline.streams.map((stream) => ({ ...stream, ...(maxChunks === undefined ? {} : { budget: { ...stream.budget, maxChunks } }) })) }
+  return { selected: selectStreams([bounded], resource === 'all' ? [] : [`resource:${resource}`]), backfill: undefined }
+}
+
+function fixture(url: URL): Response {
+  const path = url.pathname.slice('/v2/'.length)
+  if (path === 'conferenceRecords') return Response.json({ conferenceRecords: url.searchParams.get('filter')?.includes('IS NULL') ? [] : [conference] })
+  if (path.endsWith('/transcripts')) return Response.json({ transcripts: [{ ...transcript, name: `${path}/t1` }] })
+  if (path.endsWith('/participants')) return Response.json({ participants: [{ ...participant, name: `${path}/p1` }] })
+  if (path.endsWith('/participantSessions')) return Response.json({ participantSessions: [{ ...session, name: `${path}/s1` }] })
+  if (path.endsWith('/recordings')) return Response.json({ recordings: [{ ...recording, name: `${path}/r1` }] })
+  if (path.endsWith('/entries')) return Response.json(url.searchParams.has('pageToken')
+    ? { transcriptEntries: [{ name: `${path}/e2`, text: 'second' }] }
+    : { transcriptEntries: [{ name: `${path}/e1`, text: 'first' }], nextPageToken: 'entries-next' })
+  throw new Error(`Unexpected Meet request ${url.toString()}`)
+}
+
+function restoredJournal(previous: ReturnType<typeof createMemoryJournal>) {
+  const journal = createMemoryJournal()
+  journal.events.push(...previous.events.map((event) => ({ ...event, checkpoint: event.checkpoint === undefined ? undefined : JSON.parse(JSON.stringify(event.checkpoint)) })))
+  return journal
+}
diff --git a/registry/lemlist/README.md b/registry/lemlist/README.md
index 365f2da8..ec9c6cc1 100644
--- a/registry/lemlist/README.md
+++ b/registry/lemlist/README.md
@@ -1,8 +1,12 @@
-# Lemlist raw ingestion example
+# Lemlist raw ingestion
 
-This is a small editable starting point based on the Lemlist source in [obsessiondb/brain](https://github.com/obsessiondb/brain/tree/main/scripts/brain-sync). It stores provider responses as native JSON without Brain's memory or sales projections.
+Sync seven Lemlist resources into independent raw ClickHouse tables. Provider records retain their native fields; transformations, campaign/contact joins, and reporting belong in ClickHouse.
 
-Set `LEMLIST_API_KEY` in the runtime environment and configure a direct ClickHouse connection. Edit `pageSize` and the stream list in `index.ts` for the resources needed by the project. Native JSON requires ClickHouse 25.3 or later.
+Set `LEMLIST_API_KEY` in the runtime environment and configure a direct ClickHouse connection. Edit `config.ts` for the account namespace, page size, initial date, overlap, and interval length. Native JSON requires ClickHouse 25.3 or later.
+
+`pipeline.ts` groups seven independently selectable streams in one account pipeline. Each resource owns its checkpoint and discovery; execution order is not a dependency. `sources/` contains the resource readers; `client.ts` supplies authenticated requests and `paginate()`. `index.ts` exports the pipeline and raw schema. Use `createLemlistPipeline(config, deps)` to bind reader settings and optional HTTP dependencies. Page size must be between 1 and 100. The exported raw tables use the installation's `lemlistConfig.database` at schema discovery; factories do not change storage names.
+
+Keep each stream ID and destination tied to one Lemlist account. The reader does not resolve the authenticated account identity: when changing the key to another account, use new stream IDs and destinations before ingesting so previous watermarks cannot skip that account's history.
 
 ```sh
 bunx chkit check
@@ -16,5 +20,54 @@ bunx chkit ingest run --tag provider:lemlist
 
 - `activities` → `lemlist_activities_raw`
 - `campaigns` → `lemlist_campaigns_raw`
+- `contacts` → `lemlist_contacts_raw`
+- `companies` → `lemlist_companies_raw`
+- `campaign_leads` → `lemlist_campaign_leads_raw`
+- `inbox_conversations` → `lemlist_inbox_conversations_raw`
+- `inbox_messages` → `lemlist_inbox_messages_raw`
+
+Contacts represent team-wide people; campaign leads are their distinct campaign-specific records and memberships. The [contact list](https://developer.lemlist.com/api-reference/endpoints/contacts/get-many-contacts) is a reduced representation, so the contacts reader fetches full same-resource records in batches of at most 100 IDs. Native custom fields and `campaigns[].campaignId/leadId` references remain intact. Companies are read through their complete paginated list.
+
+Campaign leads discover every campaign themselves and use [the JSON export](https://developer.lemlist.com/api-reference/endpoints/campaigns/export-campaign-leads-v2) with `state=all`. The ordinary campaign lead list documents a 500-record limit and no continuation; it is not used. Export records are preserved under `raw.data`, with `source_id` and `campaign_id` alongside them. Exports do not guarantee `contactId`; join the native lead ID against contacts' campaign references in ClickHouse rather than matching email addresses.
+
+Conversations independently discover all current team member IDs through `GET /team?version=v2`, then paginate each user's inbox. Set `inboxUserIds` to an explicit nonempty list to restrict this stream. An empty or omitted list means all discovered team members. A missing member list fails visibly; it is not an empty successful inbox. Conversation envelopes retain `source_id`, `user_id`, and untouched `data`.
+
+Messages independently paginate all current contacts, including old contacts, then page each contact's complete accessible message history with `skip/limit`. `inboxUserIds` scopes only conversations; messages cover all accessible contacts in the account. Every message request explicitly sets `markAsRead=false`. Readers issue only GET requests and do not mark conversations read or perform inbox actions. Message envelopes retain `source_id`, `contact_id`, and untouched `data`.
+
+## Sync and recovery
+
+Activities use the provider's inclusive `minDate`/`maxDate` filters on `createdAt`. The initial range starts at `2000-01-01`; later runs replay one day before the last committed watermark. A large range is split into intervals of at most thirty days. Offset pagination stays local to each interval; an unfinished interval always starts at offset zero after failure. The checkpoint advances only after every page of an interval has been written successfully, including empty intervals. An explicit backfill resumes completed intervals in its own checkpoint namespace while retaining one day of overlap.
+
+The upper bound does not freeze the provider dataset. Late arrivals or deletions can still change offset pages, and older activities can receive backfilled metadata. Do not treat activity offsets as change cursors or row chunks as immutable page identities. Periodic historical replay refreshes metadata and catches arrivals beyond the overlap:
+
+```sh
+bunx chkit ingest run --tag provider:lemlist --tag resource:activities --backfill reconcile-2026-10-04 --from 2000-01-01
+bunx chkit ingest status --tag provider:lemlist --json
+```
+
+Use a new backfill ID for each complete reconciliation; reusing an ID resumes that backfill. A reused ID with an upper bound earlier than its committed frontier is rejected; use a new ID for a narrower historical range. Date intervals intentionally have inclusive shared boundaries; stable `_id` row keys reconcile repeated observations. Empty completion markers carry interval identities, while mutable row chunks do not.
 
-Both streams scan all accessible pages each run. Removed campaigns or activity records remain stored. A failed API request fails the stream. Raw rows use provider IDs and keep the last observed value; there is no deletion reconciliation. Edit the readers, select fewer streams, or add SQL views for a specific use case. Run one ingestion process per ClickHouse target at a time.
+The six resources besides activities use `fullSync()`: their list/export endpoints do not document reliable modification filters. Each successful execution, including empty results, is recorded in its own journal namespace. An interrupted stream repeats its own complete discovery and pagination from the beginning. Campaigns use `createdAt:asc` ordering; campaign leads revisit every campaign, and messages revisit every contact. Creation timestamps and inbox page numbers are not change tokens. These full reads ignore date backfill bounds and do not provide date-range backfills.
+
+Offset and inbox pagination validate response shapes, bounds, advertised totals, and repeated pages; malformed or incomplete results fail before successful completion. Full reads are live lists rather than provider snapshots, so ongoing source changes can require another replay. Lead exports arrive as one JSON array per campaign and are yielded in bounded chunks; a large export still requires memory for the provider's complete response. API-key rate limits are handled by executor retries; pipeline defaults serialize streams and requests.
+
+Raw observations do not infer deletions. Removed contacts, companies, campaign leads, conversations, messages, campaigns, or activities remain stored; full sync does not automatically delete missing IDs. Content and availability remain limited to the API key's accessible records. Run one ingestion process per ClickHouse target at a time.
+
+## Identities and upgrading
+
+Version 0.2.0 adds five raw destinations to the two original tables. Generate and review additive migrations before running the new streams. Existing activities/campaigns stream IDs, timestamp state, raw fields and native `_id` row keys stay unchanged; those original tables belong to one installation/account.
+
+Contacts and companies preserve untouched provider records under `raw.data` with `source_id`; their row IDs encode `[sourceId, providerId]`. Campaign lead, conversation, and message row IDs encode `[sourceId, parentId, providerId]`. Conversation parent IDs are user IDs, preserving distinct user inbox observations even when the native conversation ID matches. Provider IDs remain unchanged inside `raw.data`. Changing the account requires new stream namespaces and destinations; changing the conversation user scope should use a new source namespace or explicitly reconcile its prior observations.
+
+## Fixture tests
+
+```sh
+bunx chkit add lemlist --with-tests
+bun test src/integrations/lemlist/tests/basic.test.ts
+```
+
+The portable suites check all seven resources alone and in reverse order, complete contact hydration, exports beyond 500 leads, user/contact pagination, unread preservation, empty completion, malformed continuations, source/destination replay, account configuration, and existing activity interval/backfill recovery without live credentials.
+
+```sh
+bun test src/integrations/lemlist/tests
+```
diff --git a/registry/lemlist/client.ts b/registry/lemlist/client.ts
new file mode 100644
index 00000000..5db507d1
--- /dev/null
+++ b/registry/lemlist/client.ts
@@ -0,0 +1,164 @@
+import { HttpError, IngestConfigError, paginate, rawRows, type FetchContext, type TimestampRange } from '@chkit/plugin-ingest'
+
+import { lemlistConfig, type LemlistReaderConfig } from './config.js'
+
+interface LemlistItem { _id: string; [key: string]: unknown }
+
+export interface LemlistClientDeps {
+  config: LemlistReaderConfig
+  fetch: (url: string, init: RequestInit) => Promise<Response>
+  token: () => string | undefined
+}
+
+export const defaultLemlistClientDeps: LemlistClientDeps = {
+  config: lemlistConfig,
+  fetch: (url, init) => fetch(url, init),
+  token: () => process.env.LEMLIST_API_KEY,
+}
+
+/** Offsets are local traversal positions, never durable change cursors. */
+export function readPages(
+  context: FetchContext,
+  resource: 'activities' | 'campaigns' | 'contacts' | 'companies',
+  window: TimestampRange | undefined,
+  deps: LemlistClientDeps,
+) {
+  const seen = new Set<string>()
+  return paginate({
+    context, initial: 0, label: `GET /${resource}`,
+    fetchPage: async (offset = 0, signal) => {
+      const params: Record<string, string> = { limit: String(deps.config.pageSize), offset: String(offset) }
+      if (resource === 'activities' || resource === 'campaigns') params.version = 'v2'
+      if (window) {
+        params.minDate = window.from.toISOString()
+        params.maxDate = window.to.toISOString()
+      } else if (resource !== 'contacts') {
+        params.sortBy = 'createdAt'
+        params.sortOrder = 'asc'
+      }
+      const result = await requestLemlist(`/${resource}`, params, signal, deps)
+      let items: LemlistItem[]
+      let next: number | undefined
+      if (resource === 'contacts' || resource === 'companies') {
+        const response = requireObject(result, `${resource} listing`)
+        items = requireItems(response.data, resource)
+        const limit = requireInteger(response.limit, 'listing limit', 1)
+        const total = requireInteger(response.total, 'listing total')
+        if (response.offset !== offset || limit > deps.config.pageSize || items.length > limit ||
+          offset + items.length > total || (items.length < limit && offset + items.length < total)) {
+          throw new IngestConfigError(`Lemlist ${resource} has inconsistent pagination; replay this stream.`)
+        }
+        next = offset + items.length < total ? offset + limit : undefined
+      } else {
+        // The public API returns arrays; retain compatibility with older campaign envelopes.
+        items = requireItems(resource === 'campaigns' && isObject(result) ? result.campaigns : result, resource)
+        if (items.length > deps.config.pageSize) throw new IngestConfigError(`Lemlist ${resource} exceeds pageSize.`)
+        next = items.length === deps.config.pageSize ? offset + items.length : undefined
+      }
+      rejectRepeatedPage(items, seen, resource)
+      if (next !== undefined && !Number.isSafeInteger(next)) throw new IngestConfigError('Lemlist offset exceeded the safe integer range.')
+      return { items, next }
+    },
+  })
+}
+
+/** Inbox pagination is page-based; the messages endpoint accepts the equivalent skip. */
+export function readInboxPages(context: FetchContext, scope: { userId: string } | { contactId: string }, deps: LemlistClientDeps) {
+  const path = 'userId' in scope ? '/inbox' : `/inbox/${encodeURIComponent(scope.contactId)}`
+  const seen = new Set<string>()
+  let expectedTotal: number | undefined
+  let received = 0
+  return paginate({
+    context, initial: { page: 1, skip: 0 }, label: `GET ${path}`,
+    fetchPage: async (cursor = { page: 1, skip: 0 }, signal) => {
+      const params: Record<string, string> = { limit: String(deps.config.pageSize) }
+      if ('userId' in scope) {
+        params.userId = scope.userId
+        params.page = String(cursor.page)
+      } else {
+        params.skip = String(cursor.skip)
+        params.markAsRead = 'false'
+      }
+      const response = requireObject(await requestLemlist(path, params, signal, deps), 'inbox listing')
+      const items = requireItems(response.data, path)
+      const pagination = requireObject(response.pagination, 'inbox pagination')
+      const total = requireInteger(pagination.totalItems, 'inbox totalItems')
+      const perPage = requireInteger(pagination.perPage, 'inbox perPage', 1)
+      const currentPage = requireInteger(pagination.currentPage, 'inbox currentPage', 1)
+      const totalPages = requireInteger(pagination.totalPages, 'inbox totalPages')
+      const nextPage = pagination.nextPage
+      if (currentPage !== cursor.page || perPage > deps.config.pageSize || items.length > perPage ||
+        (expectedTotal !== undefined && total !== expectedTotal) ||
+        (nextPage !== null && (!Number.isSafeInteger(nextPage) || nextPage !== currentPage + 1)) ||
+        (nextPage !== null && (items.length === 0 || currentPage >= totalPages)) ||
+        (nextPage === null && totalPages > currentPage)) {
+        throw new IngestConfigError('Lemlist inbox has malformed or incomplete pagination; replay this stream.')
+      }
+      rejectRepeatedPage(items, seen, path)
+      const count = received + items.length
+      if (count > total || (nextPage === null && count !== total)) throw new IngestConfigError('Lemlist inbox ended before its advertised complete collection.')
+      expectedTotal = total
+      received = count
+      const next = typeof nextPage === 'number' ? { page: nextPage, skip: cursor.skip + perPage } : undefined
+      return { items, next }
+    },
+  })
+}
+
+export async function requestLemlist(path: string, params: Record<string, string>, signal: AbortSignal, deps: LemlistClientDeps): Promise<unknown> {
+  const key = deps.token()?.trim()
+  if (!key) throw new IngestConfigError('Set LEMLIST_API_KEY.')
+  const url = new URL(`https://api.lemlist.com/api${path}`)
+  for (const [name, value] of Object.entries(params)) url.searchParams.set(name, value)
+  const response = await deps.fetch(url.toString(), {
+    signal: AbortSignal.any([signal, AbortSignal.timeout(30_000)]), redirect: 'error',
+    headers: { Authorization: `Basic ${Buffer.from(`:${key}`).toString('base64')}` },
+  })
+  if (!response.ok) throw await HttpError.fromResponse(response)
+  try {
+    return await response.json()
+  } catch (cause) {
+    if (cause instanceof SyntaxError) throw new IngestConfigError(`Lemlist ${path} returned invalid JSON.`)
+    throw cause
+  }
+}
+
+export function toLemlistRows(items: readonly LemlistItem[], deps: LemlistClientDeps, parent?: { campaign_id: string } | { contact_id: string } | { user_id: string }) {
+  return rawRows(items.map((data) => ({ source_id: deps.config.sourceId, ...parent, data })), ({ data }) =>
+    JSON.stringify([deps.config.sourceId, ...Object.values(parent ?? {}), data._id]))
+}
+
+export function requireItems(value: unknown, label: string): LemlistItem[] {
+  if (!Array.isArray(value) || !value.every(isItem)) throw new IngestConfigError(`Lemlist ${label} response has no valid items.`)
+  const ids = value.map((item) => item._id)
+  if (new Set(ids).size !== ids.length) throw new IngestConfigError(`Lemlist ${label} repeated an object ID.`)
+  return value
+}
+
+export function requireObject(value: unknown, label: string): Record<string, unknown> {
+  if (!isObject(value)) throw new IngestConfigError(`Lemlist ${label} is not an object.`)
+  return value
+}
+
+export function requireId(value: unknown, label: string): string {
+  if (typeof value !== 'string' || !value.trim()) throw new IngestConfigError(`Lemlist ${label} has no valid ID.`)
+  return value
+}
+
+function rejectRepeatedPage(items: readonly LemlistItem[], seen: Set<string>, label: string) {
+  if (items.some((item) => seen.has(item._id))) throw new IngestConfigError(`Lemlist ${label} repeated a page or object ID; replay this stream.`)
+  for (const item of items) seen.add(item._id)
+}
+
+function requireInteger(value: unknown, label: string, minimum = 0): number {
+  if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < minimum) throw new IngestConfigError(`Lemlist ${label} is invalid.`)
+  return value
+}
+
+function isItem(value: unknown): value is LemlistItem {
+  return isObject(value) && typeof value._id === 'string' && value._id.trim().length > 0
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
diff --git a/registry/lemlist/config.ts b/registry/lemlist/config.ts
new file mode 100644
index 00000000..44dbef3c
--- /dev/null
+++ b/registry/lemlist/config.ts
@@ -0,0 +1,24 @@
+export interface LemlistConfig {
+  /** Stable checkpoint namespace for one account; use a new value when switching accounts. */
+  sourceId: string
+  database: string
+  pageSize: number
+  start: Date
+  overlapMs: number
+  intervalMs: number
+  /** Empty or omitted discovers all team members for the conversations stream. */
+  inboxUserIds?: readonly string[]
+}
+
+export type LemlistReaderConfig = Omit<LemlistConfig, 'database'>
+
+// Storage is configured here before schema discovery. Credentials are read at request time.
+export const lemlistConfig: LemlistConfig = {
+  sourceId: 'lemlist',
+  database: 'default',
+  pageSize: 100,
+  start: new Date('2000-01-01T00:00:00Z'),
+  overlapMs: 24 * 60 * 60 * 1000,
+  intervalMs: 30 * 24 * 60 * 60 * 1000,
+  inboxUserIds: [],
+}
diff --git a/registry/lemlist/index.ts b/registry/lemlist/index.ts
index 7670c1e6..fbf99c47 100644
--- a/registry/lemlist/index.ts
+++ b/registry/lemlist/index.ts
@@ -1,47 +1,8 @@
-import { definePipeline, defineStream, HttpError, rawRows, rawTable, type FetchContext } from '@chkit/plugin-ingest'
-
-const database = 'default'
-const pageSize = 100
-
-interface Item { _id: string; [key: string]: unknown }
-
-export const lemlist_activitiesRaw = rawTable({ database, name: 'lemlist_activities_raw' })
-export const lemlist_campaignsRaw = rawTable({ database, name: 'lemlist_campaigns_raw' })
-
-export const lemlistPipeline = definePipeline({
-  id: 'lemlist', tags: ['provider:lemlist'], maxFetches: 1,
-  streams: [
-    defineStream({ id: 'lemlist.activities', tags: ['resource:activities'], destination: lemlist_activitiesRaw,
-      async *read(context) {
-        for await (const page of pages(context, 'activities')) yield { rows: rawRows(page, (item) => item._id) }
-      },
-    }),
-    defineStream({ id: 'lemlist.campaigns', tags: ['resource:campaigns'], destination: lemlist_campaignsRaw,
-      async *read(context) {
-        for await (const page of pages(context, 'campaigns')) yield { rows: rawRows(page, (item) => item._id) }
-      },
-    }),
-  ],
-})
-
-async function* pages(context: FetchContext, resource: 'activities' | 'campaigns'): AsyncGenerator<Item[]> {
-  let offset = 0
-  while (true) {
-    const url = new URL(`https://api.lemlist.com/api/${resource}`)
-    url.searchParams.set('version', 'v2')
-    url.searchParams.set('limit', String(pageSize))
-    url.searchParams.set('offset', String(offset))
-    const result = await context.attempt(async (signal) => {
-      const key = process.env.LEMLIST_API_KEY
-      if (!key) throw new Error('Set LEMLIST_API_KEY')
-      const response = await fetch(url, { signal, headers: { Authorization: `Basic ${Buffer.from(`:${key}`).toString('base64')}` } })
-      if (!response.ok) throw await HttpError.fromResponse(response)
-      return await response.json() as Item[] | { campaigns: Item[] }
-    }, { label: `GET /${resource}` })
-    const items = resource === 'campaigns' && !Array.isArray(result) ? result.campaigns : result
-    if (!Array.isArray(items)) throw new Error(`Lemlist ${resource} response has no items`)
-    if (items.length) yield items
-    if (items.length < pageSize) return
-    offset += items.length
-  }
-}
+export { createLemlistPipeline, lemlistPipeline } from './pipeline.js'
+export { lemlist_activitiesRaw } from './sources/activities.js'
+export { lemlist_campaignsRaw } from './sources/campaigns.js'
+export { lemlist_contactsRaw } from './sources/contacts.js'
+export { lemlist_companiesRaw } from './sources/companies.js'
+export { lemlist_campaignLeadsRaw } from './sources/campaign-leads.js'
+export { lemlist_inboxConversationsRaw } from './sources/inbox-conversations.js'
+export { lemlist_inboxMessagesRaw } from './sources/inbox-messages.js'
diff --git a/registry/lemlist/manifest.json b/registry/lemlist/manifest.json
index add645b0..02de42da 100644
--- a/registry/lemlist/manifest.json
+++ b/registry/lemlist/manifest.json
@@ -3,10 +3,10 @@
   "name": "lemlist",
   "type": "registry:item",
   "title": "Lemlist",
-  "description": "Small, editable Lemlist API ingestion example with raw ClickHouse tables.",
+  "description": "Seven independent Lemlist raw resource streams with acknowledged activity intervals and complete replayable reads.",
   "dependencies": [
-    "@chkit/core@^0.2.0-beta.8",
-    "@chkit/plugin-ingest@^0.2.0-beta.8"
+    "@chkit/core@^0.2.0-beta.10",
+    "@chkit/plugin-ingest@^0.2.0-beta.10"
   ],
   "files": [
     {
@@ -18,25 +18,113 @@
       "path": "index.ts",
       "type": "registry:file",
       "target": "src/integrations/lemlist/index.ts"
+    },
+    {
+      "path": "config.ts",
+      "type": "registry:file",
+      "target": "src/integrations/lemlist/config.ts"
+    },
+    {
+      "path": "client.ts",
+      "type": "registry:file",
+      "target": "src/integrations/lemlist/client.ts"
+    },
+    {
+      "path": "pipeline.ts",
+      "type": "registry:file",
+      "target": "src/integrations/lemlist/pipeline.ts"
+    },
+    {
+      "path": "sources/activities.ts",
+      "type": "registry:file",
+      "target": "src/integrations/lemlist/sources/activities.ts"
+    },
+    {
+      "path": "sources/campaigns.ts",
+      "type": "registry:file",
+      "target": "src/integrations/lemlist/sources/campaigns.ts"
+    },
+    {
+      "path": "tests/basic.test.ts",
+      "type": "registry:file",
+      "target": "src/integrations/lemlist/tests/basic.test.ts",
+      "role": "test"
+    },
+    {
+      "path": "sources/contacts.ts",
+      "type": "registry:file",
+      "target": "src/integrations/lemlist/sources/contacts.ts"
+    },
+    {
+      "path": "sources/companies.ts",
+      "type": "registry:file",
+      "target": "src/integrations/lemlist/sources/companies.ts"
+    },
+    {
+      "path": "sources/campaign-leads.ts",
+      "type": "registry:file",
+      "target": "src/integrations/lemlist/sources/campaign-leads.ts"
+    },
+    {
+      "path": "sources/inbox-conversations.ts",
+      "type": "registry:file",
+      "target": "src/integrations/lemlist/sources/inbox-conversations.ts"
+    },
+    {
+      "path": "sources/inbox-messages.ts",
+      "type": "registry:file",
+      "target": "src/integrations/lemlist/sources/inbox-messages.ts"
+    },
+    {
+      "path": "tests/resources.test.ts",
+      "type": "registry:file",
+      "target": "src/integrations/lemlist/tests/resources.test.ts",
+      "role": "test"
     }
   ],
   "meta": {
     "chkit": {
       "formatVersion": 1,
-      "version": "0.1.0",
+      "version": "0.2.0",
+      "changelog": [
+        {
+          "version": "0.2.0",
+          "changes": [
+            "Sync seven independent raw resources: campaigns, contacts, companies, campaign leads, activities, inbox conversations, and inbox messages.",
+            "Preserve bounded overlapping activity intervals, acknowledgement-only progress, explicit backfill recovery, and existing campaign/activity identities.",
+            "Hydrate complete same-resource contacts in bounded ID batches and export all campaign leads rather than using the nonpaginating 500-record list.",
+            "Independently discover campaigns, contacts, and inbox users; paginate accessible message history with markAsRead=false and preserve native records in scoped envelopes.",
+            "Use ordinary full-sync completion and safe replay for six resources without reliable modification filters; validate continuations, totals, empty completion, and source/destination recovery.",
+            "Add five raw tables with source/parent-scoped row identities and portable fixtures; preserve version 0.1.0 history and document additive migration, polling, and deletion limits.",
+            "Consume the ingestion plugin's full pagination pages, preserving continuations and empty terminal pages with independent resource checkpoints."
+          ]
+        },
+        {
+          "version": "0.1.0",
+          "changes": [
+            "Introduce raw campaigns and activities ingestion."
+          ]
+        }
+      ],
       "documentation": "https://chkit.obsessiondb.com/integrations/lemlist/",
       "logo": "https://chkit.obsessiondb.com/logos/lemlist.svg",
       "language": "typescript",
       "license": "MIT",
-      "chkit": "^0.2.0-beta.8",
-      "ingest": "^0.2.0-beta.8",
+      "chkit": "^0.2.0-beta.10",
+      "ingest": "^0.2.0-beta.10",
       "clickhouse": ">=25.3.0",
       "root": "src/integrations/lemlist",
       "entry": "index.ts",
       "exports": [
         "lemlistPipeline",
+        "createLemlistPipeline",
         "lemlist_activitiesRaw",
-        "lemlist_campaignsRaw"
+        "lemlist_campaignsRaw",
+        "lemlist_contactsRaw",
+        "lemlist_companiesRaw",
+        "lemlist_campaignLeadsRaw",
+        "lemlist_inboxConversationsRaw",
+        "lemlist_inboxMessagesRaw"
       ],
       "resources": [
         {
@@ -45,12 +133,12 @@
           "table": "lemlist_activities_raw",
           "description": "Outreach activity events",
           "scopes": [],
-          "strategy": "full",
+          "strategy": "timestamp",
           "endpoints": [
             {
               "method": "GET",
               "path": "/activities",
-              "documentation": "https://developer.lemlist.com/"
+              "documentation": "https://developer.lemlist.com/api-reference/endpoints/activities/get-many-activities"
             }
           ]
         },
@@ -65,9 +153,99 @@
             {
               "method": "GET",
               "path": "/campaigns",
-              "documentation": "https://developer.lemlist.com/"
+              "documentation": "https://developer.lemlist.com/api-reference/endpoints/campaigns/get-many-campaigns"
             }
           ]
+        },
+        {
+          "name": "contacts",
+          "title": "Contacts",
+          "table": "lemlist_contacts_raw",
+          "description": "Complete team-wide contact records and native campaign lead references",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/contacts",
+              "documentation": "https://developer.lemlist.com/api-reference/endpoints/contacts/get-many-contacts"
+            }
+          ],
+          "scopes": [],
+          "strategy": "full"
+        },
+        {
+          "name": "companies",
+          "title": "Companies",
+          "table": "lemlist_companies_raw",
+          "description": "Company records and native custom fields",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/companies",
+              "documentation": "https://developer.lemlist.com/api-reference/endpoints/companies/get-many-companies"
+            }
+          ],
+          "scopes": [],
+          "strategy": "full"
+        },
+        {
+          "name": "campaign_leads",
+          "title": "Campaign leads",
+          "table": "lemlist_campaign_leads_raw",
+          "description": "Complete campaign-specific lead exports with campaign scope",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/campaigns",
+              "documentation": "https://developer.lemlist.com/api-reference/endpoints/campaigns/get-many-campaigns"
+            },
+            {
+              "method": "GET",
+              "path": "/v2/campaigns/{campaignId}/export/leads",
+              "documentation": "https://developer.lemlist.com/api-reference/endpoints/campaigns/export-campaign-leads-v2"
+            }
+          ],
+          "scopes": [],
+          "strategy": "full"
+        },
+        {
+          "name": "inbox_conversations",
+          "title": "Inbox conversations",
+          "table": "lemlist_inbox_conversations_raw",
+          "description": "Conversations with independent user inbox scope",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/team",
+              "documentation": "https://developer.lemlist.com/api-reference/endpoints/team/get-team"
+            },
+            {
+              "method": "GET",
+              "path": "/inbox",
+              "documentation": "https://developer.lemlist.com/api-reference/endpoints/inbox/get-many-inboxes"
+            }
+          ],
+          "scopes": [],
+          "strategy": "full"
+        },
+        {
+          "name": "inbox_messages",
+          "title": "Inbox messages",
+          "table": "lemlist_inbox_messages_raw",
+          "description": "Complete accessible per-contact message history without marking conversations read",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/contacts",
+              "documentation": "https://developer.lemlist.com/api-reference/endpoints/contacts/get-many-contacts"
+            },
+            {
+              "method": "GET",
+              "path": "/inbox/{contactId}",
+              "documentation": "https://developer.lemlist.com/api-reference/endpoints/inbox/get-contact-messages"
+            }
+          ],
+          "scopes": [],
+          "strategy": "full"
         }
       ],
       "env": {
@@ -86,10 +264,13 @@
       },
       "views": [],
       "sync": {
-        "description": "A full read runs for each enabled stream. Stable IDs keep the latest observed record.",
+        "description": "Activities checkpoint acknowledged creation-time intervals; six other resources record independent full-read completion and replay mutable pagination from the beginning.",
         "schedule": "Run bunx chkit ingest run --tag provider:lemlist from a scheduler.",
-        "deletions": "Both streams scan all accessible pages each run. Removed campaigns or activity records remain stored."
+        "deletions": "Missing records are not deleted automatically. Activities need historical reconciliation for older metadata edits; other resources revisit current accessible parents on each full read."
       }
     }
-  }
+  },
+  "devDependencies": [
+    "@types/bun@^1.2.0"
+  ]
 }
diff --git a/registry/lemlist/pipeline.ts b/registry/lemlist/pipeline.ts
new file mode 100644
index 00000000..0cd3ae4f
--- /dev/null
+++ b/registry/lemlist/pipeline.ts
@@ -0,0 +1,49 @@
+import { definePipeline, defineStream, fullSync, IngestConfigError } from '@chkit/plugin-ingest'
+
+import { defaultLemlistClientDeps, type LemlistClientDeps } from './client.js'
+import { lemlistConfig, type LemlistReaderConfig } from './config.js'
+import { createActivityWindow, lemlist_activitiesRaw, readActivities } from './sources/activities.js'
+import { lemlist_campaignsRaw, readCampaigns } from './sources/campaigns.js'
+import { lemlist_contactsRaw, readContacts } from './sources/contacts.js'
+import { lemlist_companiesRaw, readCompanies } from './sources/companies.js'
+import { lemlist_campaignLeadsRaw, readCampaignLeads } from './sources/campaign-leads.js'
+import { lemlist_inboxConversationsRaw, readInboxConversations } from './sources/inbox-conversations.js'
+import { lemlist_inboxMessagesRaw, readInboxMessages } from './sources/inbox-messages.js'
+
+/** One account pipeline; every resource owns its discovery and checkpoint. */
+export function createLemlistPipeline(config: LemlistReaderConfig = lemlistConfig, deps: LemlistClientDeps = defaultLemlistClientDeps) {
+  if (!config.sourceId.trim() || !Number.isSafeInteger(config.pageSize) || config.pageSize <= 0 || config.pageSize > 100 ||
+    !Number.isSafeInteger(config.intervalMs) || config.intervalMs <= 0 ||
+    (config.inboxUserIds !== undefined && (!Array.isArray(config.inboxUserIds) ||
+      config.inboxUserIds.some((id) => typeof id !== 'string' || !id.trim()) || new Set(config.inboxUserIds).size !== config.inboxUserIds.length))) {
+    throw new IngestConfigError('Lemlist needs a sourceId, pageSize from 1 to 100, positive intervalMs, and distinct nonempty inboxUserIds.')
+  }
+  const client = { ...deps, config: { ...config, start: new Date(config.start), inboxUserIds: config.inboxUserIds ? [...config.inboxUserIds] : undefined } }
+  return definePipeline({
+    id: config.sourceId, tags: ['provider:lemlist'], maxStreams: 1, maxFetches: 1,
+    streams: [
+      defineStream({
+        id: `${config.sourceId}.activities`, tags: ['resource:activities'], destination: lemlist_activitiesRaw,
+        incremental: createActivityWindow(client.config), batchSize: 500,
+        read: (context) => readActivities(context, client),
+      }),
+      defineStream({
+        id: `${config.sourceId}.campaigns`, tags: ['resource:campaigns'], destination: lemlist_campaignsRaw,
+        incremental: fullSync(),
+        read: (context) => readCampaigns(context, client),
+      }),
+      defineStream({ id: `${config.sourceId}.contacts`, tags: ['resource:contacts'], destination: lemlist_contactsRaw,
+        incremental: fullSync(), read: (context) => readContacts(context, client) }),
+      defineStream({ id: `${config.sourceId}.companies`, tags: ['resource:companies'], destination: lemlist_companiesRaw,
+        incremental: fullSync(), read: (context) => readCompanies(context, client) }),
+      defineStream({ id: `${config.sourceId}.campaign_leads`, tags: ['resource:campaign_leads'], destination: lemlist_campaignLeadsRaw,
+        incremental: fullSync(), read: (context) => readCampaignLeads(context, client) }),
+      defineStream({ id: `${config.sourceId}.inbox_conversations`, tags: ['resource:inbox_conversations'], destination: lemlist_inboxConversationsRaw,
+        incremental: fullSync(), read: (context) => readInboxConversations(context, client) }),
+      defineStream({ id: `${config.sourceId}.inbox_messages`, tags: ['resource:inbox_messages'], destination: lemlist_inboxMessagesRaw,
+        incremental: fullSync(), read: (context) => readInboxMessages(context, client) }),
+    ],
+  })
+}
+
+export const lemlistPipeline = createLemlistPipeline()
diff --git a/registry/lemlist/releases/0.2.0.json b/registry/lemlist/releases/0.2.0.json
new file mode 100644
index 00000000..b5b3ec84
--- /dev/null
+++ b/registry/lemlist/releases/0.2.0.json
@@ -0,0 +1,306 @@
+{
+  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
+  "name": "lemlist",
+  "type": "registry:item",
+  "title": "Lemlist",
+  "description": "Seven independent Lemlist raw resource streams with acknowledged activity intervals and complete replayable reads.",
+  "dependencies": [
+    "@chkit/core@^0.2.0-beta.10",
+    "@chkit/plugin-ingest@^0.2.0-beta.10"
+  ],
+  "devDependencies": [
+    "@types/bun@^1.2.0"
+  ],
+  "files": [
+    {
+      "path": "lemlist/README.md",
+      "type": "registry:file",
+      "target": "src/integrations/lemlist/README.md",
+      "content": "# Lemlist raw ingestion\n\nSync seven Lemlist resources into independent raw ClickHouse tables. Provider records retain their native fields; transformations, campaign/contact joins, and reporting belong in ClickHouse.\n\nSet `LEMLIST_API_KEY` in the runtime environment and configure a direct ClickHouse connection. Edit `config.ts` for the account namespace, page size, initial date, overlap, and interval length. Native JSON requires ClickHouse 25.3 or later.\n\n`pipeline.ts` groups seven independently selectable streams in one account pipeline. Each resource owns its checkpoint and discovery; execution order is not a dependency. `sources/` contains the resource readers; `client.ts` supplies authenticated requests and `paginate()`. `index.ts` exports the pipeline and raw schema. Use `createLemlistPipeline(config, deps)` to bind reader settings and optional HTTP dependencies. Page size must be between 1 and 100. The exported raw tables use the installation's `lemlistConfig.database` at schema discovery; factories do not change storage names.\n\nKeep each stream ID and destination tied to one Lemlist account. The reader does not resolve the authenticated account identity: when changing the key to another account, use new stream IDs and destinations before ingesting so previous watermarks cannot skip that account's history.\n\n```sh\nbunx chkit check\nbunx chkit generate --name add_lemlist\n# Review the migration before applying it.\nbunx chkit migrate --apply\nbunx chkit ingest run --tag provider:lemlist\n```\n\n## Resources\n\n- `activities` → `lemlist_activities_raw`\n- `campaigns` → `lemlist_campaigns_raw`\n- `contacts` → `lemlist_contacts_raw`\n- `companies` → `lemlist_companies_raw`\n- `campaign_leads` → `lemlist_campaign_leads_raw`\n- `inbox_conversations` → `lemlist_inbox_conversations_raw`\n- `inbox_messages` → `lemlist_inbox_messages_raw`\n\nContacts represent team-wide people; campaign leads are their distinct campaign-specific records and memberships. The [contact list](https://developer.lemlist.com/api-reference/endpoints/contacts/get-many-contacts) is a reduced representation, so the contacts reader fetches full same-resource records in batches of at most 100 IDs. Native custom fields and `campaigns[].campaignId/leadId` references remain intact. Companies are read through their complete paginated list.\n\nCampaign leads discover every campaign themselves and use [the JSON export](https://developer.lemlist.com/api-reference/endpoints/campaigns/export-campaign-leads-v2) with `state=all`. The ordinary campaign lead list documents a 500-record limit and no continuation; it is not used. Export records are preserved under `raw.data`, with `source_id` and `campaign_id` alongside them. Exports do not guarantee `contactId`; join the native lead ID against contacts' campaign references in ClickHouse rather than matching email addresses.\n\nConversations independently discover all current team member IDs through `GET /team?version=v2`, then paginate each user's inbox. Set `inboxUserIds` to an explicit nonempty list to restrict this stream. An empty or omitted list means all discovered team members. A missing member list fails visibly; it is not an empty successful inbox. Conversation envelopes retain `source_id`, `user_id`, and untouched `data`.\n\nMessages independently paginate all current contacts, including old contacts, then page each contact's complete accessible message history with `skip/limit`. `inboxUserIds` scopes only conversations; messages cover all accessible contacts in the account. Every message request explicitly sets `markAsRead=false`. Readers issue only GET requests and do not mark conversations read or perform inbox actions. Message envelopes retain `source_id`, `contact_id`, and untouched `data`.\n\n## Sync and recovery\n\nActivities use the provider's inclusive `minDate`/`maxDate` filters on `createdAt`. The initial range starts at `2000-01-01`; later runs replay one day before the last committed watermark. A large range is split into intervals of at most thirty days. Offset pagination stays local to each interval; an unfinished interval always starts at offset zero after failure. The checkpoint advances only after every page of an interval has been written successfully, including empty intervals. An explicit backfill resumes completed intervals in its own checkpoint namespace while retaining one day of overlap.\n\nThe upper bound does not freeze the provider dataset. Late arrivals or deletions can still change offset pages, and older activities can receive backfilled metadata. Do not treat activity offsets as change cursors or row chunks as immutable page identities. Periodic historical replay refreshes metadata and catches arrivals beyond the overlap:\n\n```sh\nbunx chkit ingest run --tag provider:lemlist --tag resource:activities --backfill reconcile-2026-10-04 --from 2000-01-01\nbunx chkit ingest status --tag provider:lemlist --json\n```\n\nUse a new backfill ID for each complete reconciliation; reusing an ID resumes that backfill. A reused ID with an upper bound earlier than its committed frontier is rejected; use a new ID for a narrower historical range. Date intervals intentionally have inclusive shared boundaries; stable `_id` row keys reconcile repeated observations. Empty completion markers carry interval identities, while mutable row chunks do not.\n\nThe six resources besides activities use `fullSync()`: their list/export endpoints do not document reliable modification filters. Each successful execution, including empty results, is recorded in its own journal namespace. An interrupted stream repeats its own complete discovery and pagination from the beginning. Campaigns use `createdAt:asc` ordering; campaign leads revisit every campaign, and messages revisit every contact. Creation timestamps and inbox page numbers are not change tokens. These full reads ignore date backfill bounds and do not provide date-range backfills.\n\nOffset and inbox pagination validate response shapes, bounds, advertised totals, and repeated pages; malformed or incomplete results fail before successful completion. Full reads are live lists rather than provider snapshots, so ongoing source changes can require another replay. Lead exports arrive as one JSON array per campaign and are yielded in bounded chunks; a large export still requires memory for the provider's complete response. API-key rate limits are handled by executor retries; pipeline defaults serialize streams and requests.\n\nRaw observations do not infer deletions. Removed contacts, companies, campaign leads, conversations, messages, campaigns, or activities remain stored; full sync does not automatically delete missing IDs. Content and availability remain limited to the API key's accessible records. Run one ingestion process per ClickHouse target at a time.\n\n## Identities and upgrading\n\nVersion 0.2.0 adds five raw destinations to the two original tables. Generate and review additive migrations before running the new streams. Existing activities/campaigns stream IDs, timestamp state, raw fields and native `_id` row keys stay unchanged; those original tables belong to one installation/account.\n\nContacts and companies preserve untouched provider records under `raw.data` with `source_id`; their row IDs encode `[sourceId, providerId]`. Campaign lead, conversation, and message row IDs encode `[sourceId, parentId, providerId]`. Conversation parent IDs are user IDs, preserving distinct user inbox observations even when the native conversation ID matches. Provider IDs remain unchanged inside `raw.data`. Changing the account requires new stream namespaces and destinations; changing the conversation user scope should use a new source namespace or explicitly reconcile its prior observations.\n\n## Fixture tests\n\n```sh\nbunx chkit add lemlist --with-tests\nbun test src/integrations/lemlist/tests/basic.test.ts\n```\n\nThe portable suites check all seven resources alone and in reverse order, complete contact hydration, exports beyond 500 leads, user/contact pagination, unread preservation, empty completion, malformed continuations, source/destination replay, account configuration, and existing activity interval/backfill recovery without live credentials.\n\n```sh\nbun test src/integrations/lemlist/tests\n```\n"
+    },
+    {
+      "path": "lemlist/index.ts",
+      "type": "registry:file",
+      "target": "src/integrations/lemlist/index.ts",
+      "content": "export { createLemlistPipeline, lemlistPipeline } from './pipeline.js'\nexport { lemlist_activitiesRaw } from './sources/activities.js'\nexport { lemlist_campaignsRaw } from './sources/campaigns.js'\nexport { lemlist_contactsRaw } from './sources/contacts.js'\nexport { lemlist_companiesRaw } from './sources/companies.js'\nexport { lemlist_campaignLeadsRaw } from './sources/campaign-leads.js'\nexport { lemlist_inboxConversationsRaw } from './sources/inbox-conversations.js'\nexport { lemlist_inboxMessagesRaw } from './sources/inbox-messages.js'\n"
+    },
+    {
+      "path": "lemlist/config.ts",
+      "type": "registry:file",
+      "target": "src/integrations/lemlist/config.ts",
+      "content": "export interface LemlistConfig {\n  /** Stable checkpoint namespace for one account; use a new value when switching accounts. */\n  sourceId: string\n  database: string\n  pageSize: number\n  start: Date\n  overlapMs: number\n  intervalMs: number\n  /** Empty or omitted discovers all team members for the conversations stream. */\n  inboxUserIds?: readonly string[]\n}\n\nexport type LemlistReaderConfig = Omit<LemlistConfig, 'database'>\n\n// Storage is configured here before schema discovery. Credentials are read at request time.\nexport const lemlistConfig: LemlistConfig = {\n  sourceId: 'lemlist',\n  database: 'default',\n  pageSize: 100,\n  start: new Date('2000-01-01T00:00:00Z'),\n  overlapMs: 24 * 60 * 60 * 1000,\n  intervalMs: 30 * 24 * 60 * 60 * 1000,\n  inboxUserIds: [],\n}\n"
+    },
+    {
+      "path": "lemlist/client.ts",
+      "type": "registry:file",
+      "target": "src/integrations/lemlist/client.ts",
+      "content": "import { HttpError, IngestConfigError, paginate, rawRows, type FetchContext, type TimestampRange } from '@chkit/plugin-ingest'\n\nimport { lemlistConfig, type LemlistReaderConfig } from './config.js'\n\ninterface LemlistItem { _id: string; [key: string]: unknown }\n\nexport interface LemlistClientDeps {\n  config: LemlistReaderConfig\n  fetch: (url: string, init: RequestInit) => Promise<Response>\n  token: () => string | undefined\n}\n\nexport const defaultLemlistClientDeps: LemlistClientDeps = {\n  config: lemlistConfig,\n  fetch: (url, init) => fetch(url, init),\n  token: () => process.env.LEMLIST_API_KEY,\n}\n\n/** Offsets are local traversal positions, never durable change cursors. */\nexport function readPages(\n  context: FetchContext,\n  resource: 'activities' | 'campaigns' | 'contacts' | 'companies',\n  window: TimestampRange | undefined,\n  deps: LemlistClientDeps,\n) {\n  const seen = new Set<string>()\n  return paginate({\n    context, initial: 0, label: `GET /${resource}`,\n    fetchPage: async (offset = 0, signal) => {\n      const params: Record<string, string> = { limit: String(deps.config.pageSize), offset: String(offset) }\n      if (resource === 'activities' || resource === 'campaigns') params.version = 'v2'\n      if (window) {\n        params.minDate = window.from.toISOString()\n        params.maxDate = window.to.toISOString()\n      } else if (resource !== 'contacts') {\n        params.sortBy = 'createdAt'\n        params.sortOrder = 'asc'\n      }\n      const result = await requestLemlist(`/${resource}`, params, signal, deps)\n      let items: LemlistItem[]\n      let next: number | undefined\n      if (resource === 'contacts' || resource === 'companies') {\n        const response = requireObject(result, `${resource} listing`)\n        items = requireItems(response.data, resource)\n        const limit = requireInteger(response.limit, 'listing limit', 1)\n        const total = requireInteger(response.total, 'listing total')\n        if (response.offset !== offset || limit > deps.config.pageSize || items.length > limit ||\n          offset + items.length > total || (items.length < limit && offset + items.length < total)) {\n          throw new IngestConfigError(`Lemlist ${resource} has inconsistent pagination; replay this stream.`)\n        }\n        next = offset + items.length < total ? offset + limit : undefined\n      } else {\n        // The public API returns arrays; retain compatibility with older campaign envelopes.\n        items = requireItems(resource === 'campaigns' && isObject(result) ? result.campaigns : result, resource)\n        if (items.length > deps.config.pageSize) throw new IngestConfigError(`Lemlist ${resource} exceeds pageSize.`)\n        next = items.length === deps.config.pageSize ? offset + items.length : undefined\n      }\n      rejectRepeatedPage(items, seen, resource)\n      if (next !== undefined && !Number.isSafeInteger(next)) throw new IngestConfigError('Lemlist offset exceeded the safe integer range.')\n      return { items, next }\n    },\n  })\n}\n\n/** Inbox pagination is page-based; the messages endpoint accepts the equivalent skip. */\nexport function readInboxPages(context: FetchContext, scope: { userId: string } | { contactId: string }, deps: LemlistClientDeps) {\n  const path = 'userId' in scope ? '/inbox' : `/inbox/${encodeURIComponent(scope.contactId)}`\n  const seen = new Set<string>()\n  let expectedTotal: number | undefined\n  let received = 0\n  return paginate({\n    context, initial: { page: 1, skip: 0 }, label: `GET ${path}`,\n    fetchPage: async (cursor = { page: 1, skip: 0 }, signal) => {\n      const params: Record<string, string> = { limit: String(deps.config.pageSize) }\n      if ('userId' in scope) {\n        params.userId = scope.userId\n        params.page = String(cursor.page)\n      } else {\n        params.skip = String(cursor.skip)\n        params.markAsRead = 'false'\n      }\n      const response = requireObject(await requestLemlist(path, params, signal, deps), 'inbox listing')\n      const items = requireItems(response.data, path)\n      const pagination = requireObject(response.pagination, 'inbox pagination')\n      const total = requireInteger(pagination.totalItems, 'inbox totalItems')\n      const perPage = requireInteger(pagination.perPage, 'inbox perPage', 1)\n      const currentPage = requireInteger(pagination.currentPage, 'inbox currentPage', 1)\n      const totalPages = requireInteger(pagination.totalPages, 'inbox totalPages')\n      const nextPage = pagination.nextPage\n      if (currentPage !== cursor.page || perPage > deps.config.pageSize || items.length > perPage ||\n        (expectedTotal !== undefined && total !== expectedTotal) ||\n        (nextPage !== null && (!Number.isSafeInteger(nextPage) || nextPage !== currentPage + 1)) ||\n        (nextPage !== null && (items.length === 0 || currentPage >= totalPages)) ||\n        (nextPage === null && totalPages > currentPage)) {\n        throw new IngestConfigError('Lemlist inbox has malformed or incomplete pagination; replay this stream.')\n      }\n      rejectRepeatedPage(items, seen, path)\n      const count = received + items.length\n      if (count > total || (nextPage === null && count !== total)) throw new IngestConfigError('Lemlist inbox ended before its advertised complete collection.')\n      expectedTotal = total\n      received = count\n      const next = typeof nextPage === 'number' ? { page: nextPage, skip: cursor.skip + perPage } : undefined\n      return { items, next }\n    },\n  })\n}\n\nexport async function requestLemlist(path: string, params: Record<string, string>, signal: AbortSignal, deps: LemlistClientDeps): Promise<unknown> {\n  const key = deps.token()?.trim()\n  if (!key) throw new IngestConfigError('Set LEMLIST_API_KEY.')\n  const url = new URL(`https://api.lemlist.com/api${path}`)\n  for (const [name, value] of Object.entries(params)) url.searchParams.set(name, value)\n  const response = await deps.fetch(url.toString(), {\n    signal: AbortSignal.any([signal, AbortSignal.timeout(30_000)]), redirect: 'error',\n    headers: { Authorization: `Basic ${Buffer.from(`:${key}`).toString('base64')}` },\n  })\n  if (!response.ok) throw await HttpError.fromResponse(response)\n  try {\n    return await response.json()\n  } catch (cause) {\n    if (cause instanceof SyntaxError) throw new IngestConfigError(`Lemlist ${path} returned invalid JSON.`)\n    throw cause\n  }\n}\n\nexport function toLemlistRows(items: readonly LemlistItem[], deps: LemlistClientDeps, parent?: { campaign_id: string } | { contact_id: string } | { user_id: string }) {\n  return rawRows(items.map((data) => ({ source_id: deps.config.sourceId, ...parent, data })), ({ data }) =>\n    JSON.stringify([deps.config.sourceId, ...Object.values(parent ?? {}), data._id]))\n}\n\nexport function requireItems(value: unknown, label: string): LemlistItem[] {\n  if (!Array.isArray(value) || !value.every(isItem)) throw new IngestConfigError(`Lemlist ${label} response has no valid items.`)\n  const ids = value.map((item) => item._id)\n  if (new Set(ids).size !== ids.length) throw new IngestConfigError(`Lemlist ${label} repeated an object ID.`)\n  return value\n}\n\nexport function requireObject(value: unknown, label: string): Record<string, unknown> {\n  if (!isObject(value)) throw new IngestConfigError(`Lemlist ${label} is not an object.`)\n  return value\n}\n\nexport function requireId(value: unknown, label: string): string {\n  if (typeof value !== 'string' || !value.trim()) throw new IngestConfigError(`Lemlist ${label} has no valid ID.`)\n  return value\n}\n\nfunction rejectRepeatedPage(items: readonly LemlistItem[], seen: Set<string>, label: string) {\n  if (items.some((item) => seen.has(item._id))) throw new IngestConfigError(`Lemlist ${label} repeated a page or object ID; replay this stream.`)\n  for (const item of items) seen.add(item._id)\n}\n\nfunction requireInteger(value: unknown, label: string, minimum = 0): number {\n  if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < minimum) throw new IngestConfigError(`Lemlist ${label} is invalid.`)\n  return value\n}\n\nfunction isItem(value: unknown): value is LemlistItem {\n  return isObject(value) && typeof value._id === 'string' && value._id.trim().length > 0\n}\n\nfunction isObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value)\n}\n"
+    },
+    {
+      "path": "lemlist/pipeline.ts",
+      "type": "registry:file",
+      "target": "src/integrations/lemlist/pipeline.ts",
+      "content": "import { definePipeline, defineStream, fullSync, IngestConfigError } from '@chkit/plugin-ingest'\n\nimport { defaultLemlistClientDeps, type LemlistClientDeps } from './client.js'\nimport { lemlistConfig, type LemlistReaderConfig } from './config.js'\nimport { createActivityWindow, lemlist_activitiesRaw, readActivities } from './sources/activities.js'\nimport { lemlist_campaignsRaw, readCampaigns } from './sources/campaigns.js'\nimport { lemlist_contactsRaw, readContacts } from './sources/contacts.js'\nimport { lemlist_companiesRaw, readCompanies } from './sources/companies.js'\nimport { lemlist_campaignLeadsRaw, readCampaignLeads } from './sources/campaign-leads.js'\nimport { lemlist_inboxConversationsRaw, readInboxConversations } from './sources/inbox-conversations.js'\nimport { lemlist_inboxMessagesRaw, readInboxMessages } from './sources/inbox-messages.js'\n\n/** One account pipeline; every resource owns its discovery and checkpoint. */\nexport function createLemlistPipeline(config: LemlistReaderConfig = lemlistConfig, deps: LemlistClientDeps = defaultLemlistClientDeps) {\n  if (!config.sourceId.trim() || !Number.isSafeInteger(config.pageSize) || config.pageSize <= 0 || config.pageSize > 100 ||\n    !Number.isSafeInteger(config.intervalMs) || config.intervalMs <= 0 ||\n    (config.inboxUserIds !== undefined && (!Array.isArray(config.inboxUserIds) ||\n      config.inboxUserIds.some((id) => typeof id !== 'string' || !id.trim()) || new Set(config.inboxUserIds).size !== config.inboxUserIds.length))) {\n    throw new IngestConfigError('Lemlist needs a sourceId, pageSize from 1 to 100, positive intervalMs, and distinct nonempty inboxUserIds.')\n  }\n  const client = { ...deps, config: { ...config, start: new Date(config.start), inboxUserIds: config.inboxUserIds ? [...config.inboxUserIds] : undefined } }\n  return definePipeline({\n    id: config.sourceId, tags: ['provider:lemlist'], maxStreams: 1, maxFetches: 1,\n    streams: [\n      defineStream({\n        id: `${config.sourceId}.activities`, tags: ['resource:activities'], destination: lemlist_activitiesRaw,\n        incremental: createActivityWindow(client.config), batchSize: 500,\n        read: (context) => readActivities(context, client),\n      }),\n      defineStream({\n        id: `${config.sourceId}.campaigns`, tags: ['resource:campaigns'], destination: lemlist_campaignsRaw,\n        incremental: fullSync(),\n        read: (context) => readCampaigns(context, client),\n      }),\n      defineStream({ id: `${config.sourceId}.contacts`, tags: ['resource:contacts'], destination: lemlist_contactsRaw,\n        incremental: fullSync(), read: (context) => readContacts(context, client) }),\n      defineStream({ id: `${config.sourceId}.companies`, tags: ['resource:companies'], destination: lemlist_companiesRaw,\n        incremental: fullSync(), read: (context) => readCompanies(context, client) }),\n      defineStream({ id: `${config.sourceId}.campaign_leads`, tags: ['resource:campaign_leads'], destination: lemlist_campaignLeadsRaw,\n        incremental: fullSync(), read: (context) => readCampaignLeads(context, client) }),\n      defineStream({ id: `${config.sourceId}.inbox_conversations`, tags: ['resource:inbox_conversations'], destination: lemlist_inboxConversationsRaw,\n        incremental: fullSync(), read: (context) => readInboxConversations(context, client) }),\n      defineStream({ id: `${config.sourceId}.inbox_messages`, tags: ['resource:inbox_messages'], destination: lemlist_inboxMessagesRaw,\n        incremental: fullSync(), read: (context) => readInboxMessages(context, client) }),\n    ],\n  })\n}\n\nexport const lemlistPipeline = createLemlistPipeline()\n"
+    },
+    {
+      "path": "lemlist/sources/activities.ts",
+      "type": "registry:file",
+      "target": "src/integrations/lemlist/sources/activities.ts",
+      "content": "import { IngestConfigError, rawRows, rawTable, timestampWindow, type IncrementalStrategy, type ReadContext, type TimestampRange, type TimestampWindowState } from '@chkit/plugin-ingest'\n\nimport { readPages, type LemlistClientDeps } from '../client.js'\nimport { lemlistConfig, type LemlistReaderConfig } from '../config.js'\n\nexport const lemlist_activitiesRaw = rawTable({ database: lemlistConfig.database, name: 'lemlist_activities_raw' })\n\nexport async function* readActivities(context: ReadContext<TimestampRange, TimestampWindowState>, deps: LemlistClientDeps) {\n  for (let from = context.selection.from; from < context.selection.to;) {\n    const to = new Date(Math.min(from.getTime() + deps.config.intervalMs, context.selection.to.getTime()))\n    for await (const page of readPages(context, 'activities', { from, to }, deps)) {\n      yield { rows: rawRows(page.items, (item) => item._id) }\n    }\n    // Only an exhausted interval is a safe frontier. Its mutable offsets restart at zero.\n    const watermark = new Date(Math.max(to.getTime(), Date.parse(context.state?.watermark ?? to.toISOString()))).toISOString()\n    yield { rows: [], state: { watermark }, id: `completed-interval:${from.toISOString()}/${to.toISOString()}` }\n    from = to\n  }\n}\n\nexport function createActivityWindow(config: LemlistReaderConfig): IncrementalStrategy<TimestampWindowState, TimestampRange> {\n  const window = timestampWindow({ start: config.start, overlapMs: config.overlapMs })\n  return {\n    ...window,\n    plan(input: Parameters<typeof window.plan>[0]) {\n      const selection = window.plan(input)\n      if (input.range && input.state) {\n        const frontier = Date.parse(input.state.watermark)\n        if (selection.to.getTime() < frontier) {\n          throw new IngestConfigError('Lemlist backfill upper bound precedes its committed interval frontier; use a new backfill ID for a narrower historical range.')\n        }\n        return { ...selection, from: new Date(Math.max(selection.from.getTime(), frontier - config.overlapMs)) }\n      }\n      return selection\n    },\n  }\n}\n"
+    },
+    {
+      "path": "lemlist/sources/campaigns.ts",
+      "type": "registry:file",
+      "target": "src/integrations/lemlist/sources/campaigns.ts",
+      "content": "import { rawRows, rawTable, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { readPages, type LemlistClientDeps } from '../client.js'\nimport { lemlistConfig } from '../config.js'\n\nexport const lemlist_campaignsRaw = rawTable({ database: lemlistConfig.database, name: 'lemlist_campaigns_raw' })\n\n// No reliable modification filter: default fullSync records completion and safely replays failures.\nexport async function* readCampaigns(context: FetchContext, deps: LemlistClientDeps) {\n  for await (const page of readPages(context, 'campaigns', undefined, deps)) {\n    yield { rows: rawRows(page.items, (item) => item._id) }\n  }\n}\n"
+    },
+    {
+      "path": "lemlist/tests/basic.test.ts",
+      "type": "registry:file",
+      "target": "src/integrations/lemlist/tests/basic.test.ts",
+      "role": "test",
+      "content": "import { afterEach, expect, test } from 'bun:test'\nimport { IngestConfigError, runIngestion, selectStreams } from '@chkit/plugin-ingest'\nimport { createMemoryDestination, createMemoryJournal } from '@chkit/plugin-ingest/testing'\n\nimport { createLemlistPipeline, lemlistPipeline } from '../index.js'\nimport { lemlistConfig } from '../config.js'\nimport { defaultLemlistClientDeps } from '../client.js'\n\nconst originalFetch = globalThis.fetch\nconst originalToken = process.env.LEMLIST_API_KEY\nconst cutoff = new Date('2000-03-01T00:00:00Z')\n\nfunction setFetch(handler: (...args: Parameters<typeof fetch>) => Promise<Response>): void {\n  globalThis.fetch = Object.assign(handler, { preconnect: originalFetch.preconnect })\n  process.env.LEMLIST_API_KEY = 'fixture'\n}\n\nfunction selected(resource = 'activities') {\n  return selectStreams([lemlistPipeline], [`resource:${resource}`]).map((item) => ({ ...item, stream: { ...item.stream, retry: { retries: 0 } } }))\n}\n\nafterEach(() => {\n  globalThis.fetch = originalFetch\n  if (originalToken === undefined) delete process.env.LEMLIST_API_KEY\n  else process.env.LEMLIST_API_KEY = originalToken\n})\n\ntest.serial('Lemlist commits only exhausted date intervals and replays the unfinished interval with overlap', async () => {\n  let fail = true\n  const journal = createMemoryJournal()\n  let acknowledgeInterval = () => {}\n  const intervalCommitted = new Promise<void>((resolve) => { acknowledgeInterval = resolve })\n  const append = journal.append\n  journal.append = async (events) => {\n    await append(events)\n    if (events.some((event) => JSON.stringify(event.checkpoint?.state) === '{\"watermark\":\"2000-01-31T00:00:00.000Z\"}')) acknowledgeInterval()\n  }\n  const windows: { from: string | null; to: string | null; offset: string | null }[] = []\n  setFetch(async (input) => {\n    const url = new URL(String(input))\n    const from = url.searchParams.get('minDate')\n    windows.push({ from, to: url.searchParams.get('maxDate'), offset: url.searchParams.get('offset') })\n    if (fail && from !== '2000-01-01T00:00:00.000Z') {\n      await intervalCommitted\n      return new Response('denied', { status: 403 })\n    }\n    return Response.json([{ _id: from, custom: { retained: true } }])\n  })\n  const destination = createMemoryDestination()\n  const request = { selected: selected(), backfill: undefined }\n  expect((await runIngestion(request, { journal, destination, now: () => cutoff })).ok).toBe(false)\n  expect((await journal.readCheckpoint('lemlist.activities')).envelope?.state).toEqual({ watermark: '2000-01-31T00:00:00.000Z' })\n  expect(destination.tables.get('default.lemlist_activities_raw')?.[0]?.raw).toMatchObject({ custom: { retained: true } })\n  fail = false\n  expect((await runIngestion(request, { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect(windows[2]).toEqual({ from: '2000-01-30T00:00:00.000Z', to: '2000-02-29T00:00:00.000Z', offset: '0' })\n  expect((await journal.readCheckpoint('lemlist.activities')).envelope?.state).toEqual({ watermark: cutoff.toISOString() })\n})\n\ntest.serial('Lemlist resumes isolated explicit backfills from the completed interval frontier', async () => {\n  let fail = true\n  const starts: string[] = []\n  setFetch(async (input) => {\n    const from = new URL(String(input)).searchParams.get('minDate') ?? ''\n    starts.push(from)\n    if (fail && from !== '2025-01-01T00:00:00.000Z') return new Response('denied', { status: 403 })\n    return Response.json([])\n  })\n  const journal = createMemoryJournal()\n  const destination = createMemoryDestination()\n  const request = { selected: selected(), backfill: { id: 'history', from: new Date('2025-01-01T00:00:00Z'), to: new Date('2025-03-01T00:00:00Z') } }\n  expect((await runIngestion(request, { journal, destination, now: () => new Date('2026-01-01') })).ok).toBe(false)\n  expect((await journal.readCheckpoint('lemlist.activities#backfill:history')).envelope?.state).toEqual({ watermark: '2025-01-31T00:00:00.000Z' })\n  fail = false\n  expect((await runIngestion(request, { journal, destination, now: () => new Date('2026-01-01') })).ok).toBe(true)\n  expect(starts[2]).toBe('2025-01-30T00:00:00.000Z')\n  expect((await journal.readCheckpoint('lemlist.activities')).envelope).toBeUndefined()\n})\n\ntest.serial('Lemlist rejects a narrowed completed backfill upper bound without regressing its frontier', async () => {\n  let requests = 0\n  setFetch(async () => { requests++; return Response.json([]) })\n  const journal = createMemoryJournal()\n  const destination = createMemoryDestination()\n  const backfill = { id: 'narrowed', from: new Date('2025-01-01T00:00:00Z'), to: new Date('2025-03-01T00:00:00Z') }\n  const request = { selected: selected(), backfill }\n  expect((await runIngestion(request, { journal, destination, now: () => new Date('2026-01-01') })).ok).toBe(true)\n  const completedRequests = requests\n  // This upper bound is still after the overlap's lower bound, but must not move the watermark backwards.\n  const result = await runIngestion({ ...request, backfill: { ...backfill, to: new Date('2025-02-28T12:00:00Z') } }, {\n    journal, destination, now: () => new Date('2026-01-01'),\n  })\n  expect(result.ok).toBe(false)\n  expect(result.streams[0]?.error).toContain('use a new backfill ID')\n  expect(requests).toBe(completedRequests)\n  expect((await journal.readCheckpoint('lemlist.activities#backfill:narrowed')).envelope?.state).toEqual({ watermark: '2025-03-01T00:00:00.000Z' })\n})\n\ntest.serial('Lemlist paginates a whole date interval and a rejected sink cannot advance it', async () => {\n  const offsets: string[] = []\n  setFetch(async (input) => {\n    const url = new URL(String(input))\n    offsets.push(url.searchParams.get('offset') ?? '')\n    expect(url.searchParams.get('minDate')).toBe('2000-01-01T00:00:00.000Z')\n    expect(url.searchParams.get('maxDate')).toBe('2000-01-02T00:00:00.000Z')\n    return Response.json(url.searchParams.get('offset') === '0' ? Array.from({ length: 100 }, (_, index) => ({ _id: String(index) })) : [{ _id: 'last' }])\n  })\n  const journal = createMemoryJournal()\n  const request = { selected: selected(), backfill: undefined }\n  const result = await runIngestion(request, { journal, destination: { insert: async () => { throw new IngestConfigError('sink rejected') } }, now: () => new Date('2000-01-02') })\n  expect(result.ok).toBe(false)\n  expect((await journal.readCheckpoint('lemlist.activities')).envelope).toBeUndefined()\n  expect(offsets).toEqual(['0', '100'])\n})\n\ntest.serial('Lemlist empty activity intervals commit and campaigns always scan from zero', async () => {\n  const paths: URL[] = []\n  setFetch(async (input) => { paths.push(new URL(String(input))); return Response.json({ campaigns: [] }) })\n  const journal = createMemoryJournal()\n  const destination = createMemoryDestination()\n  const request = { selected: selected('campaigns'), backfill: undefined }\n  expect((await runIngestion(request, { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect((await runIngestion(request, { journal, destination, now: () => new Date('2000-03-02') })).ok).toBe(true)\n  expect(paths.map((url) => url.searchParams.get('offset'))).toEqual(['0', '0'])\n  expect(paths.every((url) => url.searchParams.get('sortBy') === 'createdAt' && url.searchParams.get('sortOrder') === 'asc')).toBe(true)\n  expect((await journal.readCheckpoint('lemlist.campaigns')).lastSuccessSeq).toBeGreaterThan(0)\n  expect(journal.events.filter((event) => event.namespaceId === 'lemlist.campaigns' && event.eventKind === 'work_finished' && event.workState === 'succeeded')).toHaveLength(2)\n  setFetch(async () => Response.json([]))\n  expect((await runIngestion({ selected: selected(), backfill: undefined }, { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect((await journal.readCheckpoint('lemlist.activities')).envelope?.state).toEqual({ watermark: cutoff.toISOString() })\n})\n\ntest('Lemlist binds account configuration to independent resource streams and preserves activity progress after a campaign failure', async () => {\n  const config = { ...lemlistConfig, sourceId: 'lemlist.sales', pageSize: 2, start: new Date('2026-01-01'), overlapMs: 0, intervalMs: 24 * 60 * 60 * 1000 }\n  const urls: URL[] = []\n  let campaignsAvailable = false\n  const pipeline = createLemlistPipeline(config, {\n    ...defaultLemlistClientDeps, token: () => 'sales-key',\n    fetch: async (input, init) => {\n      const url = new URL(input)\n      urls.push(url)\n      expect(init.headers).toEqual({ Authorization: `Basic ${Buffer.from(':sales-key').toString('base64')}` })\n      if (url.pathname.endsWith('/campaigns')) return campaignsAvailable ? Response.json({ campaigns: [] }) : new Response('denied', { status: 403 })\n      return Response.json(url.searchParams.get('offset') === '0' ? [{ _id: 'a' }, { _id: 'b' }] : [{ _id: 'c', custom: true }])\n    },\n  })\n  config.pageSize = 100\n  config.start.setUTCFullYear(2000)\n  const journal = createMemoryJournal()\n  const destination = createMemoryDestination()\n  const selected = selectStreams([pipeline], []).filter((item) => ['lemlist.sales.activities', 'lemlist.sales.campaigns'].includes(item.stream.id))\n    .map((item) => ({ ...item, stream: { ...item.stream, retry: { retries: 0 } } }))\n  const result = await runIngestion({ selected, backfill: undefined }, { journal, destination, now: () => new Date('2026-01-02') })\n  expect(result.streams.map((stream) => [stream.streamId, stream.outcome])).toEqual([\n    ['lemlist.sales.activities', 'succeeded'], ['lemlist.sales.campaigns', 'failed'],\n  ])\n  expect((await journal.readCheckpoint('lemlist.sales.activities')).envelope?.state).toEqual({ watermark: '2026-01-02T00:00:00.000Z' })\n  expect((await journal.readCheckpoint('lemlist.sales.campaigns')).lastSuccessSeq).toBe(0)\n  expect(urls.filter((url) => url.pathname.endsWith('/activities')).map((url) => [url.searchParams.get('minDate'), url.searchParams.get('offset'), url.searchParams.get('limit')])).toEqual([\n    ['2026-01-01T00:00:00.000Z', '0', '2'], ['2026-01-01T00:00:00.000Z', '2', '2'],\n  ])\n  expect(destination.tables.get('default.lemlist_activities_raw')?.map((row) => row.id)).toEqual(['a', 'b', 'c'])\n  campaignsAvailable = true\n  urls.length = 0\n  expect((await runIngestion({ selected: selectStreams([pipeline], ['resource:campaigns']), backfill: undefined }, { journal, destination })).ok).toBe(true)\n  expect(urls.map((url) => url.pathname)).toEqual(['/api/campaigns'])\n  expect((await journal.readCheckpoint('lemlist.sales.campaigns')).lastSuccessSeq).toBeGreaterThan(0)\n  expect((await journal.readCheckpoint('lemlist.activities')).envelope).toBeUndefined()\n})\n\ntest('Lemlist rejects repeated offset payloads without recording full-scan completion', async () => {\n  const offsets: string[] = []\n  const pipeline = createLemlistPipeline({ ...lemlistConfig, pageSize: 1 }, {\n    ...defaultLemlistClientDeps, token: () => 'fixture', fetch: async (input) => {\n      offsets.push(new URL(input).searchParams.get('offset') ?? '')\n      return Response.json({ campaigns: [{ _id: 'repeated' }] })\n    },\n  })\n  const journal = createMemoryJournal()\n  const result = await runIngestion({ selected: selectStreams([pipeline], ['resource:campaigns']), backfill: undefined }, { journal, destination: createMemoryDestination() })\n  expect(result.ok).toBe(false)\n  expect(result.streams[0]?.error).toContain('repeated a page')\n  expect(offsets).toEqual(['0', '1'])\n  expect((await journal.readCheckpoint('lemlist.campaigns')).lastSuccessSeq).toBe(0)\n})\n\ntest('Lemlist full-sync campaigns publish changed observations on the next run', async () => {\n  let title = 'before'\n  const pipeline = createLemlistPipeline(lemlistConfig, {\n    ...defaultLemlistClientDeps, token: () => 'fixture',\n    fetch: async () => Response.json({ campaigns: [{ _id: 'campaign', title }] }),\n  })\n  const journal = createMemoryJournal()\n  const destination = createMemoryDestination()\n  const request = { selected: selectStreams([pipeline], ['resource:campaigns']), backfill: undefined }\n  expect((await runIngestion(request, { journal, destination })).ok).toBe(true)\n  title = 'after'\n  expect((await runIngestion(request, { journal, destination })).ok).toBe(true)\n  expect(destination.tables.get('default.lemlist_campaigns_raw')?.map((row) => row.raw)).toEqual([\n    { _id: 'campaign', title: 'before' }, { _id: 'campaign', title: 'after' },\n  ])\n})\n"
+    },
+    {
+      "path": "lemlist/sources/contacts.ts",
+      "type": "registry:file",
+      "target": "src/integrations/lemlist/sources/contacts.ts",
+      "content": "import { IngestConfigError, rawTable, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { readPages, requestLemlist, requireItems, toLemlistRows, type LemlistClientDeps } from '../client.js'\nimport { lemlistConfig } from '../config.js'\n\nexport const lemlist_contactsRaw = rawTable({ database: lemlistConfig.database, name: 'lemlist_contacts_raw' })\n\nexport async function* readContacts(context: FetchContext, deps: LemlistClientDeps) {\n  for await (const page of readPages(context, 'contacts', undefined, deps)) {\n    if (page.items.length === 0) continue\n    // List items omit custom fields; hydrate complete objects of the same resource in <=100-ID batches.\n    const contacts = await context.attempt(async (signal) => {\n      const items = requireItems(await requestLemlist('/contacts', { idsOrEmails: page.items.map((item) => item._id).join(',') }, signal, deps), 'contact lookup')\n      const expected = new Set(page.items.map((item) => item._id))\n      if (items.length !== page.items.length || items.some((item) => !expected.has(item._id))) {\n        throw new IngestConfigError('Lemlist contact lookup did not return every discovered contact; replay this stream.')\n      }\n      return items\n    }, { label: 'GET /contacts by IDs' })\n    yield { rows: toLemlistRows(contacts, deps) }\n  }\n}\n"
+    },
+    {
+      "path": "lemlist/sources/companies.ts",
+      "type": "registry:file",
+      "target": "src/integrations/lemlist/sources/companies.ts",
+      "content": "import { rawTable, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { readPages, toLemlistRows, type LemlistClientDeps } from '../client.js'\nimport { lemlistConfig } from '../config.js'\n\nexport const lemlist_companiesRaw = rawTable({ database: lemlistConfig.database, name: 'lemlist_companies_raw' })\n\nexport async function* readCompanies(context: FetchContext, deps: LemlistClientDeps) {\n  for await (const page of readPages(context, 'companies', undefined, deps)) {\n    yield { rows: toLemlistRows(page.items, deps) }\n  }\n}\n"
+    },
+    {
+      "path": "lemlist/sources/campaign-leads.ts",
+      "type": "registry:file",
+      "target": "src/integrations/lemlist/sources/campaign-leads.ts",
+      "content": "import { rawTable, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { readPages, requestLemlist, requireItems, toLemlistRows, type LemlistClientDeps } from '../client.js'\nimport { lemlistConfig } from '../config.js'\n\nexport const lemlist_campaignLeadsRaw = rawTable({ database: lemlistConfig.database, name: 'lemlist_campaign_leads_raw' })\n\nexport async function* readCampaignLeads(context: FetchContext, deps: LemlistClientDeps) {\n  // Own complete campaign discovery: old campaigns can gain leads without changing their creation date.\n  for await (const campaigns of readPages(context, 'campaigns', undefined, deps)) {\n    for (const campaign of campaigns.items) {\n      // The normal lead list has a 500-row cap and no continuation. This endpoint explicitly exports all states.\n      const leads = await context.attempt(async (signal) => requireItems(\n        await requestLemlist(`/v2/campaigns/${encodeURIComponent(campaign._id)}/export/leads`, { state: 'all', format: 'json' }, signal, deps),\n        'complete campaign lead export',\n      ), { label: 'GET campaign lead export' })\n      for (let offset = 0; offset < leads.length; offset += deps.config.pageSize) {\n        yield { rows: toLemlistRows(leads.slice(offset, offset + deps.config.pageSize), deps, { campaign_id: campaign._id }) }\n      }\n    }\n  }\n}\n"
+    },
+    {
+      "path": "lemlist/sources/inbox-conversations.ts",
+      "type": "registry:file",
+      "target": "src/integrations/lemlist/sources/inbox-conversations.ts",
+      "content": "import { IngestConfigError, rawTable, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { readInboxPages, requestLemlist, requireId, requireObject, toLemlistRows, type LemlistClientDeps } from '../client.js'\nimport { lemlistConfig } from '../config.js'\n\nexport const lemlist_inboxConversationsRaw = rawTable({ database: lemlistConfig.database, name: 'lemlist_inbox_conversations_raw' })\n\nexport async function* readInboxConversations(context: FetchContext, deps: LemlistClientDeps) {\n  let userIds = deps.config.inboxUserIds\n  if (!userIds?.length) {\n    userIds = await context.attempt(async (signal) => {\n      const team = requireObject(await requestLemlist('/team', { version: 'v2' }, signal, deps), 'team')\n      const ids = Array.isArray(team.userIds) ? team.userIds : Array.isArray(team.users) ?\n        team.users.map((user: unknown) => requireObject(user, 'team member').userId) : undefined\n      if (!ids?.length) throw new IngestConfigError('Lemlist team has no member IDs; configure inboxUserIds or restore team access.')\n      return [...new Set(ids.map((id: unknown) => requireId(id, 'team member')))]\n    }, { label: 'GET /team members' })\n  }\n  for (const userId of userIds) {\n    for await (const page of readInboxPages(context, { userId }, deps)) {\n      yield { rows: toLemlistRows(page.items, deps, { user_id: userId }) }\n    }\n  }\n}\n"
+    },
+    {
+      "path": "lemlist/sources/inbox-messages.ts",
+      "type": "registry:file",
+      "target": "src/integrations/lemlist/sources/inbox-messages.ts",
+      "content": "import { rawTable, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { readInboxPages, readPages, toLemlistRows, type LemlistClientDeps } from '../client.js'\nimport { lemlistConfig } from '../config.js'\n\nexport const lemlist_inboxMessagesRaw = rawTable({ database: lemlistConfig.database, name: 'lemlist_inbox_messages_raw' })\n\nexport async function* readInboxMessages(context: FetchContext, deps: LemlistClientDeps) {\n  // Discover all current contacts independently; recent parent/activity watermarks cannot cover late replies.\n  for await (const contacts of readPages(context, 'contacts', undefined, deps)) {\n    for (const contact of contacts.items) {\n      for await (const page of readInboxPages(context, { contactId: contact._id }, deps)) {\n        yield { rows: toLemlistRows(page.items, deps, { contact_id: contact._id }) }\n      }\n    }\n  }\n}\n"
+    },
+    {
+      "path": "lemlist/tests/resources.test.ts",
+      "type": "registry:file",
+      "target": "src/integrations/lemlist/tests/resources.test.ts",
+      "role": "test",
+      "content": "import { expect, test } from 'bun:test'\nimport { IngestConfigError, runIngestion, selectStreams, type PipelineDefinition } from '@chkit/plugin-ingest'\nimport { createMemoryDestination, createMemoryJournal } from '@chkit/plugin-ingest/testing'\n\nimport { defaultLemlistClientDeps } from '../client.js'\nimport { lemlistConfig } from '../config.js'\nimport { createLemlistPipeline } from '../index.js'\n\nconst resources = ['activities', 'campaigns', 'contacts', 'companies', 'campaign_leads', 'inbox_conversations', 'inbox_messages']\nconst now = () => new Date('2026-01-02T00:00:00Z')\n\nfunction pipeline(handler: (url: URL, init: RequestInit) => Response | Promise<Response>, options: { pageSize?: number; inboxUserIds?: readonly string[] } = {}) {\n  return createLemlistPipeline({ ...lemlistConfig, sourceId: 'lemlist.fixture', start: new Date('2026-01-01'), ...options }, {\n    ...defaultLemlistClientDeps, token: () => 'fixture',\n    fetch: async (url, init) => handler(new URL(url), init),\n  })\n}\n\nfunction selected(value: PipelineDefinition, resource?: string) {\n  return selectStreams([value], resource ? [`resource:${resource}`] : [])\n    .map((item) => ({ ...item, stream: { ...item.stream, retry: { retries: 0 } } }))\n}\n\nfunction listing(data: { _id: string; [key: string]: unknown }[], url: URL, total = data.length) {\n  return Response.json({ data, total, limit: Number(url.searchParams.get('limit')), offset: Number(url.searchParams.get('offset')) })\n}\n\nfunction inbox(data: { _id: string; [key: string]: unknown }[], options: { page?: number; next?: number | null; total?: number; limit?: number } = {}) {\n  return Response.json({ data, pagination: {\n    totalItems: options.total ?? data.length, currentPage: options.page ?? 1, nextPage: options.next ?? null,\n    previousPage: null, perPage: options.limit ?? 100, totalPages: options.next ? options.next : options.page ?? (data.length ? 1 : 0),\n  } })\n}\n\nfunction fixture(url: URL): Response {\n  switch (url.pathname) {\n    case '/api/activities': return Response.json([{ _id: 'act', type: 'emailsSent', createdAt: '2026-01-01T12:00:00Z' }])\n    case '/api/campaigns': return Response.json([{ _id: 'cam', createdAt: '2000-01-01', name: 'Outreach' }])\n    case '/api/contacts': return url.searchParams.has('idsOrEmails') ? Response.json([{\n      _id: 'ctc', companyId: 'cpn', fields: { custom: 'kept' }, unsubscribed: false,\n      campaigns: [{ campaignId: 'cam', leadId: 'lea', leadState: 'review' }],\n    }]) : listing([{ _id: 'ctc' }], url)\n    case '/api/companies': return listing([{ _id: 'cpn', fields: { name: 'Company', custom: { kept: true } } }], url)\n    case '/api/v2/campaigns/cam/export/leads': return Response.json([{ _id: 'lea', email: 'person@example.com', lastState: 'emailsReplied', custom: 'kept' }])\n    case '/api/team': return Response.json({ _id: 'tea', userIds: ['usr'] })\n    case '/api/inbox': return inbox([{ _id: 'ibx', contactId: 'ctc', users: [{ userId: 'usr', read: false }], channels: ['email'] }])\n    case '/api/inbox/ctc': return inbox([{ _id: 'message', type: 'emailsReplied', contactId: 'ctc', leadId: 'lea', campaignId: 'cam', message: '<p>Reply</p>' }])\n    default: throw new IngestConfigError(`Unexpected fixture request: ${url.pathname}`)\n  }\n}\n\ntest('Lemlist has seven independently selectable resources with raw provider IDs and joins', async () => {\n  const paths: string[] = []\n  const value = pipeline((url, init) => {\n    expect(init.method ?? 'GET').toBe('GET')\n    paths.push(url.pathname)\n    return fixture(url)\n  })\n  expect(value.streams.map((stream) => stream.id)).toEqual(resources.map((resource) => `lemlist.fixture.${resource}`))\n  const journal = createMemoryJournal()\n  const destination = createMemoryDestination()\n  expect((await runIngestion({ selected: selected(value).reverse(), backfill: undefined }, { journal, destination, now })).ok).toBe(true)\n  expect(paths.filter((path) => path === '/api/contacts')).toHaveLength(3)\n  expect(destination.tables.get('default.lemlist_contacts_raw')?.[0]).toMatchObject({\n    id: '[\"lemlist.fixture\",\"ctc\"]', raw: { source_id: 'lemlist.fixture', data: { companyId: 'cpn', fields: { custom: 'kept' }, campaigns: [{ campaignId: 'cam', leadId: 'lea' }] } },\n  })\n  expect(destination.tables.get('default.lemlist_campaign_leads_raw')?.[0]).toMatchObject({\n    id: '[\"lemlist.fixture\",\"cam\",\"lea\"]', raw: { source_id: 'lemlist.fixture', campaign_id: 'cam', data: { _id: 'lea', lastState: 'emailsReplied', custom: 'kept' } },\n  })\n  expect(destination.tables.get('default.lemlist_inbox_messages_raw')?.[0]).toMatchObject({\n    id: '[\"lemlist.fixture\",\"ctc\",\"message\"]', raw: { source_id: 'lemlist.fixture', contact_id: 'ctc', data: { message: '<p>Reply</p>', leadId: 'lea' } },\n  })\n  for (const resource of resources) expect((await journal.readCheckpoint(`lemlist.fixture.${resource}`)).lastSuccessSeq).toBeGreaterThan(0)\n})\n\nfor (const resource of resources) {\n  test(`Lemlist ${resource} discovers its own scope when selected alone`, async () => {\n    const value = pipeline(fixture)\n    const journal = createMemoryJournal()\n    expect((await runIngestion({ selected: selected(value, resource), backfill: undefined }, { journal, destination: createMemoryDestination(), now })).ok).toBe(true)\n    expect(journal.events.filter((event) => event.namespaceId.startsWith('lemlist.fixture.'))\n      .every((event) => event.namespaceId === `lemlist.fixture.${resource}`)).toBe(true)\n  })\n}\n\ntest('Lemlist exports more than 500 campaign leads without calling the capped list endpoint', async () => {\n  const paths: URL[] = []\n  const value = pipeline((url) => {\n    paths.push(url)\n    if (url.pathname.endsWith('/export/leads')) {\n      expect(url.searchParams.get('state')).toBe('all')\n      expect(url.searchParams.get('format')).toBe('json')\n      return Response.json(Array.from({ length: 501 }, (_, index) => ({ _id: `lea-${index}`, custom: index })))\n    }\n    return fixture(url)\n  })\n  const destination = createMemoryDestination()\n  expect((await runIngestion({ selected: selected(value, 'campaign_leads'), backfill: undefined }, { journal: createMemoryJournal(), destination, now })).ok).toBe(true)\n  expect(destination.tables.get('default.lemlist_campaign_leads_raw')).toHaveLength(501)\n  expect(paths.map((url) => url.pathname)).toEqual(['/api/campaigns', '/api/v2/campaigns/cam/export/leads'])\n})\n\ntest('Lemlist full-contact hydration fails visibly when a discovered contact is unavailable', async () => {\n  const value = pipeline((url) => url.searchParams.has('idsOrEmails') ? Response.json([]) : fixture(url))\n  const journal = createMemoryJournal()\n  const result = await runIngestion({ selected: selected(value, 'contacts'), backfill: undefined }, { journal, destination: createMemoryDestination(), now })\n  expect(result.ok).toBe(false)\n  expect(result.streams[0]?.error).toContain('every discovered contact')\n  expect((await journal.readCheckpoint('lemlist.fixture.contacts')).lastSuccessSeq).toBe(0)\n})\n\ntest('Lemlist scoped conversation users are snapshotted and pagination follows provider pages', async () => {\n  const userIds = ['usr-selected']\n  const config = { ...lemlistConfig, sourceId: 'lemlist.fixture', pageSize: 2, inboxUserIds: userIds }\n  const urls: URL[] = []\n  const value = createLemlistPipeline(config, { ...defaultLemlistClientDeps, token: () => 'fixture', fetch: async (input) => {\n    const url = new URL(input)\n    urls.push(url)\n    expect(url.pathname).toBe('/api/inbox')\n    expect(url.searchParams.get('userId')).toBe('usr-selected')\n    const page = Number(url.searchParams.get('page'))\n    return inbox([{ _id: `conversation-${page}` }], { page, next: page === 1 ? 2 : null, total: 2, limit: 2 })\n  } })\n  userIds[0] = 'changed'\n  config.pageSize = 100\n  const destination = createMemoryDestination()\n  expect((await runIngestion({ selected: selected(value, 'inbox_conversations'), backfill: undefined }, { journal: createMemoryJournal(), destination, now })).ok).toBe(true)\n  expect(urls.map((url) => [url.searchParams.get('page'), url.searchParams.get('limit')])).toEqual([['1', '2'], ['2', '2']])\n  expect(destination.tables.get('default.lemlist_inbox_conversations_raw')?.map((row) => row.id)).toEqual([\n    '[\"lemlist.fixture\",\"usr-selected\",\"conversation-1\"]', '[\"lemlist.fixture\",\"usr-selected\",\"conversation-2\"]',\n  ])\n})\n\ntest('Lemlist messages revisit old contacts and use skip pagination without marking anything read', async () => {\n  let body = 'before'\n  const skips: string[] = []\n  const value = pipeline((url, init) => {\n    expect(init.method ?? 'GET').toBe('GET')\n    if (url.pathname.startsWith('/api/inbox/')) {\n      expect(url.searchParams.get('markAsRead')).toBe('false')\n      expect(url.searchParams.has('minDate')).toBe(false)\n      skips.push(url.searchParams.get('skip') ?? '')\n      const page = url.searchParams.get('skip') === '0' ? 1 : 2\n      return inbox([{ _id: `message-${page}`, createdAt: '2000-01-01', message: body }], { page, next: page === 1 ? 2 : null, total: 2, limit: 2 })\n    }\n    return listing([{ _id: 'ctc', createdAt: '2000-01-01' }], url)\n  }, { pageSize: 2 })\n  const journal = createMemoryJournal()\n  const destination = createMemoryDestination()\n  const request = { selected: selected(value, 'inbox_messages'), backfill: undefined }\n  expect((await runIngestion(request, { journal, destination, now })).ok).toBe(true)\n  body = 'edited reply'\n  expect((await runIngestion(request, { journal, destination, now })).ok).toBe(true)\n  expect(skips).toEqual(['0', '2', '0', '2'])\n  expect(destination.tables.get('default.lemlist_inbox_messages_raw')?.map((row) => row.raw)).toContainEqual({\n    source_id: 'lemlist.fixture', contact_id: 'ctc', data: { _id: 'message-1', createdAt: '2000-01-01', message: 'edited reply' },\n  })\n})\n\nfor (const resource of ['contacts', 'companies', 'campaign_leads', 'inbox_conversations', 'inbox_messages']) {\n  test(`Lemlist ${resource} safely replays destination failure from its own discovery`, async () => {\n    const paths: string[] = []\n    const value = pipeline((url) => { paths.push(url.pathname); return fixture(url) })\n    const journal = createMemoryJournal()\n    const request = { selected: selected(value, resource), backfill: undefined }\n    expect((await runIngestion(request, { journal, destination: { insert: async () => { throw new IngestConfigError('sink denied') } }, now })).ok).toBe(false)\n    expect((await journal.readCheckpoint(`lemlist.fixture.${resource}`)).lastSuccessSeq).toBe(0)\n    const first = [...paths]\n    paths.length = 0\n    expect((await runIngestion(request, { journal, destination: createMemoryDestination(), now })).ok).toBe(true)\n    expect(paths).toEqual(first)\n  })\n}\n\ntest('Lemlist empty full collections record completion without custom scan state', async () => {\n  const value = pipeline((url) => {\n    if (url.pathname === '/api/contacts' || url.pathname === '/api/companies') {\n      expect(url.searchParams.has('idsOrEmails')).toBe(false)\n      return listing([], url)\n    }\n    if (url.pathname === '/api/team') return Response.json({ users: [{ userId: 'usr' }] })\n    if (url.pathname === '/api/inbox') return inbox([])\n    return Response.json([])\n  })\n  const journal = createMemoryJournal()\n  expect((await runIngestion({ selected: selected(value), backfill: undefined }, { journal, destination: createMemoryDestination(), now })).ok).toBe(true)\n  for (const resource of resources) expect((await journal.readCheckpoint(`lemlist.fixture.${resource}`)).lastSuccessSeq).toBeGreaterThan(0)\n})\n\nfor (const malformed of ['missing', 'repeated', 'truncated', 'invalid-export']) {\n  test(`Lemlist rejects ${malformed} continuation/export without successful completion`, async () => {\n    const resource = malformed === 'invalid-export' ? 'campaign_leads' : 'inbox_conversations'\n    const value = pipeline((url) => {\n      if (malformed === 'invalid-export' && url.pathname.endsWith('/export/leads')) return Response.json({ data: [{ _id: 'capped' }], next: 'unknown' })\n      if (url.pathname === '/api/inbox') {\n        const page = Number(url.searchParams.get('page'))\n        if (malformed === 'missing') return Response.json({ data: [], pagination: { totalItems: 0 } })\n        return inbox([{ _id: `conversation-${page}` }], { page, next: malformed === 'repeated' ? page : null, total: 3 })\n      }\n      return fixture(url)\n    })\n    const journal = createMemoryJournal()\n    expect((await runIngestion({ selected: selected(value, resource), backfill: undefined }, { journal, destination: createMemoryDestination(), now })).ok).toBe(false)\n    expect((await journal.readCheckpoint(`lemlist.fixture.${resource}`)).lastSuccessSeq).toBe(0)\n  })\n}\n\nfor (const resource of ['contacts', 'companies']) {\n  test(`Lemlist ${resource} consumes every advertised offset page`, async () => {\n    const offsets: string[] = []\n    const value = pipeline((url) => {\n      if (url.searchParams.has('idsOrEmails')) {\n        const ids = url.searchParams.get('idsOrEmails')?.split(',') ?? []\n        return Response.json(ids.map((_id) => ({ _id, fields: { custom: 'complete' } })))\n      }\n      offsets.push(url.searchParams.get('offset') ?? '')\n      const offset = Number(url.searchParams.get('offset'))\n      return listing(offset === 0 ? [{ _id: 'first' }, { _id: 'second' }] : [{ _id: 'last' }], url, 3)\n    }, { pageSize: 2 })\n    const destination = createMemoryDestination()\n    expect((await runIngestion({ selected: selected(value, resource), backfill: undefined }, { journal: createMemoryJournal(), destination, now })).ok).toBe(true)\n    expect(offsets).toEqual(['0', '2'])\n    expect(destination.tables.get(`default.lemlist_${resource}_raw`)?.map((row) => row.id)).toEqual(\n      ['first', 'second', 'last'].map((id) => JSON.stringify(['lemlist.fixture', id])))\n  })\n}\n\ntest('Lemlist keeps distinct user inbox observations when native conversation IDs match', async () => {\n  const value = pipeline((url) => inbox([{ _id: 'shared', unread: url.searchParams.get('userId') === 'usr-a' }]),\n    { inboxUserIds: ['usr-a', 'usr-b'] })\n  const destination = createMemoryDestination()\n  expect((await runIngestion({ selected: selected(value, 'inbox_conversations'), backfill: undefined }, { journal: createMemoryJournal(), destination, now })).ok).toBe(true)\n  expect(destination.tables.get('default.lemlist_inbox_conversations_raw')?.map((row) => [row.id, row.raw])).toEqual([\n    ['[\"lemlist.fixture\",\"usr-a\",\"shared\"]', { source_id: 'lemlist.fixture', user_id: 'usr-a', data: { _id: 'shared', unread: true } }],\n    ['[\"lemlist.fixture\",\"usr-b\",\"shared\"]', { source_id: 'lemlist.fixture', user_id: 'usr-b', data: { _id: 'shared', unread: false } }],\n  ])\n})\n\ntest('Lemlist interrupted message traversal restarts contact discovery and skip zero', async () => {\n  let fail = true\n  const paths: string[] = []\n  const value = pipeline((url) => {\n    paths.push(url.pathname + (url.searchParams.has('skip') ? `:${url.searchParams.get('skip')}` : ''))\n    if (url.pathname === '/api/inbox/ctc') {\n      const page = url.searchParams.get('skip') === '0' ? 1 : 2\n      if (fail && page === 2) return new Response('denied', { status: 403 })\n      return inbox([{ _id: `message-${page}` }], { page, next: page === 1 ? 2 : null, total: 2, limit: 2 })\n    }\n    return fixture(url)\n  }, { pageSize: 2 })\n  const journal = createMemoryJournal()\n  const request = { selected: selected(value, 'inbox_messages'), backfill: undefined }\n  const destination = createMemoryDestination()\n  expect((await runIngestion(request, { journal, destination, now })).ok).toBe(false)\n  expect((await journal.readCheckpoint('lemlist.fixture.inbox_messages')).lastSuccessSeq).toBe(0)\n  fail = false\n  expect((await runIngestion(request, { journal, destination, now })).ok).toBe(true)\n  expect(paths).toEqual(['/api/contacts', '/api/inbox/ctc:0', '/api/inbox/ctc:2', '/api/contacts', '/api/inbox/ctc:0', '/api/inbox/ctc:2'])\n})\n\ntest('Lemlist refuses a shortened contact listing that still advertises more records', async () => {\n  const value = pipeline((url) => listing([{ _id: 'first' }], url, 3), { pageSize: 2 })\n  const journal = createMemoryJournal()\n  expect((await runIngestion({ selected: selected(value, 'contacts'), backfill: undefined }, { journal, destination: createMemoryDestination(), now })).ok).toBe(false)\n  expect((await journal.readCheckpoint('lemlist.fixture.contacts')).lastSuccessSeq).toBe(0)\n})\n\nfor (const resource of ['contacts', 'companies', 'inbox_conversations']) {\n  test(`Lemlist ${resource} refuses partially overlapping pages despite matching advertised totals`, async () => {\n    const value = pipeline((url) => {\n      if (url.searchParams.has('idsOrEmails')) return Response.json((url.searchParams.get('idsOrEmails')?.split(',') ?? []).map((_id) => ({ _id })))\n      const first = resource === 'inbox_conversations' ? url.searchParams.get('page') === '1' : url.searchParams.get('offset') === '0'\n      const items = first ? [{ _id: 'a' }, { _id: 'b' }] : [{ _id: 'b' }, { _id: 'c' }]\n      return resource === 'inbox_conversations'\n        ? inbox(items, { page: first ? 1 : 2, next: first ? 2 : null, total: 4, limit: 2 })\n        : listing(items, url, 4)\n    }, { pageSize: 2, inboxUserIds: ['usr'] })\n    const journal = createMemoryJournal()\n    const result = await runIngestion({ selected: selected(value, resource), backfill: undefined }, { journal, destination: createMemoryDestination(), now })\n    expect(result.ok).toBe(false)\n    expect(result.streams[0]?.error).toContain('object ID')\n    expect((await journal.readCheckpoint(`lemlist.fixture.${resource}`)).lastSuccessSeq).toBe(0)\n  })\n}\n"
+    }
+  ],
+  "meta": {
+    "chkit": {
+      "formatVersion": 1,
+      "version": "0.2.0",
+      "changelog": [
+        {
+          "version": "0.2.0",
+          "changes": [
+            "Sync seven independent raw resources: campaigns, contacts, companies, campaign leads, activities, inbox conversations, and inbox messages.",
+            "Preserve bounded overlapping activity intervals, acknowledgement-only progress, explicit backfill recovery, and existing campaign/activity identities.",
+            "Hydrate complete same-resource contacts in bounded ID batches and export all campaign leads rather than using the nonpaginating 500-record list.",
+            "Independently discover campaigns, contacts, and inbox users; paginate accessible message history with markAsRead=false and preserve native records in scoped envelopes.",
+            "Use ordinary full-sync completion and safe replay for six resources without reliable modification filters; validate continuations, totals, empty completion, and source/destination recovery.",
+            "Add five raw tables with source/parent-scoped row identities and portable fixtures; preserve version 0.1.0 history and document additive migration, polling, and deletion limits.",
+            "Consume the ingestion plugin's full pagination pages, preserving continuations and empty terminal pages with independent resource checkpoints."
+          ]
+        },
+        {
+          "version": "0.1.0",
+          "changes": [
+            "Introduce raw campaigns and activities ingestion."
+          ]
+        }
+      ],
+      "language": "typescript",
+      "license": "MIT",
+      "documentation": "https://chkit.obsessiondb.com/integrations/lemlist/",
+      "logo": "https://chkit.obsessiondb.com/logos/lemlist.svg",
+      "authentication": {
+        "method": "HTTP Basic API key",
+        "env": [
+          "LEMLIST_API_KEY"
+        ],
+        "setup": [
+          "Provide LEMLIST_API_KEY with read access to the selected resources.",
+          "Keep the API key in the runtime environment and rotate it according to the provider policy."
+        ],
+        "documentation": "https://developer.lemlist.com/"
+      },
+      "chkit": "^0.2.0-beta.10",
+      "ingest": "^0.2.0-beta.10",
+      "clickhouse": ">=25.3.0",
+      "root": "src/integrations/lemlist",
+      "entry": "index.ts",
+      "exports": [
+        "lemlistPipeline",
+        "createLemlistPipeline",
+        "lemlist_activitiesRaw",
+        "lemlist_campaignsRaw",
+        "lemlist_contactsRaw",
+        "lemlist_companiesRaw",
+        "lemlist_campaignLeadsRaw",
+        "lemlist_inboxConversationsRaw",
+        "lemlist_inboxMessagesRaw"
+      ],
+      "resources": [
+        {
+          "name": "activities",
+          "title": "Activities",
+          "table": "lemlist_activities_raw",
+          "description": "Outreach activity events",
+          "scopes": [],
+          "strategy": "timestamp",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/activities",
+              "documentation": "https://developer.lemlist.com/api-reference/endpoints/activities/get-many-activities"
+            }
+          ]
+        },
+        {
+          "name": "campaigns",
+          "title": "Campaigns",
+          "table": "lemlist_campaigns_raw",
+          "description": "Campaign metadata",
+          "scopes": [],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/campaigns",
+              "documentation": "https://developer.lemlist.com/api-reference/endpoints/campaigns/get-many-campaigns"
+            }
+          ]
+        },
+        {
+          "name": "contacts",
+          "title": "Contacts",
+          "table": "lemlist_contacts_raw",
+          "description": "Complete team-wide contact records and native campaign lead references",
+          "scopes": [],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/contacts",
+              "documentation": "https://developer.lemlist.com/api-reference/endpoints/contacts/get-many-contacts"
+            }
+          ]
+        },
+        {
+          "name": "companies",
+          "title": "Companies",
+          "table": "lemlist_companies_raw",
+          "description": "Company records and native custom fields",
+          "scopes": [],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/companies",
+              "documentation": "https://developer.lemlist.com/api-reference/endpoints/companies/get-many-companies"
+            }
+          ]
+        },
+        {
+          "name": "campaign_leads",
+          "title": "Campaign leads",
+          "table": "lemlist_campaign_leads_raw",
+          "description": "Complete campaign-specific lead exports with campaign scope",
+          "scopes": [],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/campaigns",
+              "documentation": "https://developer.lemlist.com/api-reference/endpoints/campaigns/get-many-campaigns"
+            },
+            {
+              "method": "GET",
+              "path": "/v2/campaigns/{campaignId}/export/leads",
+              "documentation": "https://developer.lemlist.com/api-reference/endpoints/campaigns/export-campaign-leads-v2"
+            }
+          ]
+        },
+        {
+          "name": "inbox_conversations",
+          "title": "Inbox conversations",
+          "table": "lemlist_inbox_conversations_raw",
+          "description": "Conversations with independent user inbox scope",
+          "scopes": [],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/team",
+              "documentation": "https://developer.lemlist.com/api-reference/endpoints/team/get-team"
+            },
+            {
+              "method": "GET",
+              "path": "/inbox",
+              "documentation": "https://developer.lemlist.com/api-reference/endpoints/inbox/get-many-inboxes"
+            }
+          ]
+        },
+        {
+          "name": "inbox_messages",
+          "title": "Inbox messages",
+          "table": "lemlist_inbox_messages_raw",
+          "description": "Complete accessible per-contact message history without marking conversations read",
+          "scopes": [],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/contacts",
+              "documentation": "https://developer.lemlist.com/api-reference/endpoints/contacts/get-many-contacts"
+            },
+            {
+              "method": "GET",
+              "path": "/inbox/{contactId}",
+              "documentation": "https://developer.lemlist.com/api-reference/endpoints/inbox/get-contact-messages"
+            }
+          ]
+        }
+      ],
+      "views": [],
+      "sync": {
+        "description": "Activities checkpoint acknowledged creation-time intervals; six other resources record independent full-read completion and replay mutable pagination from the beginning.",
+        "schedule": "Run bunx chkit ingest run --tag provider:lemlist from a scheduler.",
+        "deletions": "Missing records are not deleted automatically. Activities need historical reconciliation for older metadata edits; other resources revisit current accessible parents on each full read."
+      },
+      "env": {
+        "LEMLIST_API_KEY": ""
+      },
+      "fileHashes": {
+        "src/integrations/lemlist/README.md": "18d01b55f425c27184b2429bc9d6f3c610d199ae8ecab18ac59060b621a6f9ca",
+        "src/integrations/lemlist/index.ts": "6aa65944e2753412999d1833215145d0aaa5ed8978647d96f9711ed014de6393",
+        "src/integrations/lemlist/config.ts": "87997184c430703e3aeb697c53d5021ed40835bb0b65a284ac7b1c6c4b32a571",
+        "src/integrations/lemlist/client.ts": "7eee64da7df8f695ab31d3350ae7398b6366e3605a6bdafbc1a1789d928fd19e",
+        "src/integrations/lemlist/pipeline.ts": "54d6939c6e231f733ae71273676911e0555dde13c5c0b9a85cd8f81d6b92acfa",
+        "src/integrations/lemlist/sources/activities.ts": "50d9c96fa9721a5f841adb8aaf75d82c9dbb3cef1340a5f782665cfcad5fe7b8",
+        "src/integrations/lemlist/sources/campaigns.ts": "351964446bd199a25c3d781c50a231f78c54b2635c56f02b713e0d16be1e0401",
+        "src/integrations/lemlist/tests/basic.test.ts": "5eeec4a179d4cd15d6b5deb7f499f93fbad8bf14751cffad31a0a62ff7198e2f",
+        "src/integrations/lemlist/sources/contacts.ts": "38c024bebc6300769eff7c38fec7a73e5b965055ccd87bc7659e1cc1da2c4b67",
+        "src/integrations/lemlist/sources/companies.ts": "b0628e237d03957378618458c64c09da5e204c899e329a5a1c09895bc157338d",
+        "src/integrations/lemlist/sources/campaign-leads.ts": "fd9bf98f87be61b25434da983e4496e45bf55e00f94683c701907b12f0d07269",
+        "src/integrations/lemlist/sources/inbox-conversations.ts": "09c18d0bc1bfff98a832a626af14a23320e0d7aab1c14e0dc3a1f52fa406e0f2",
+        "src/integrations/lemlist/sources/inbox-messages.ts": "76cd899e97d48726bd736f658963511bb8d3c2a61f5631066e3e3d52818b62ed",
+        "src/integrations/lemlist/tests/resources.test.ts": "f055dba31ecf5717d0a051513c03e9a0c49af44c42ebc555213af57e6026f6cb"
+      }
+    }
+  }
+}
diff --git a/registry/lemlist/sources/activities.ts b/registry/lemlist/sources/activities.ts
new file mode 100644
index 00000000..9fe4a1d1
--- /dev/null
+++ b/registry/lemlist/sources/activities.ts
@@ -0,0 +1,37 @@
+import { IngestConfigError, rawRows, rawTable, timestampWindow, type IncrementalStrategy, type ReadContext, type TimestampRange, type TimestampWindowState } from '@chkit/plugin-ingest'
+
+import { readPages, type LemlistClientDeps } from '../client.js'
+import { lemlistConfig, type LemlistReaderConfig } from '../config.js'
+
+export const lemlist_activitiesRaw = rawTable({ database: lemlistConfig.database, name: 'lemlist_activities_raw' })
+
+export async function* readActivities(context: ReadContext<TimestampRange, TimestampWindowState>, deps: LemlistClientDeps) {
+  for (let from = context.selection.from; from < context.selection.to;) {
+    const to = new Date(Math.min(from.getTime() + deps.config.intervalMs, context.selection.to.getTime()))
+    for await (const page of readPages(context, 'activities', { from, to }, deps)) {
+      yield { rows: rawRows(page.items, (item) => item._id) }
+    }
+    // Only an exhausted interval is a safe frontier. Its mutable offsets restart at zero.
+    const watermark = new Date(Math.max(to.getTime(), Date.parse(context.state?.watermark ?? to.toISOString()))).toISOString()
+    yield { rows: [], state: { watermark }, id: `completed-interval:${from.toISOString()}/${to.toISOString()}` }
+    from = to
+  }
+}
+
+export function createActivityWindow(config: LemlistReaderConfig): IncrementalStrategy<TimestampWindowState, TimestampRange> {
+  const window = timestampWindow({ start: config.start, overlapMs: config.overlapMs })
+  return {
+    ...window,
+    plan(input: Parameters<typeof window.plan>[0]) {
+      const selection = window.plan(input)
+      if (input.range && input.state) {
+        const frontier = Date.parse(input.state.watermark)
+        if (selection.to.getTime() < frontier) {
+          throw new IngestConfigError('Lemlist backfill upper bound precedes its committed interval frontier; use a new backfill ID for a narrower historical range.')
+        }
+        return { ...selection, from: new Date(Math.max(selection.from.getTime(), frontier - config.overlapMs)) }
+      }
+      return selection
+    },
+  }
+}
diff --git a/registry/lemlist/sources/campaign-leads.ts b/registry/lemlist/sources/campaign-leads.ts
new file mode 100644
index 00000000..94dbd218
--- /dev/null
+++ b/registry/lemlist/sources/campaign-leads.ts
@@ -0,0 +1,22 @@
+import { rawTable, type FetchContext } from '@chkit/plugin-ingest'
+
+import { readPages, requestLemlist, requireItems, toLemlistRows, type LemlistClientDeps } from '../client.js'
+import { lemlistConfig } from '../config.js'
+
+export const lemlist_campaignLeadsRaw = rawTable({ database: lemlistConfig.database, name: 'lemlist_campaign_leads_raw' })
+
+export async function* readCampaignLeads(context: FetchContext, deps: LemlistClientDeps) {
+  // Own complete campaign discovery: old campaigns can gain leads without changing their creation date.
+  for await (const campaigns of readPages(context, 'campaigns', undefined, deps)) {
+    for (const campaign of campaigns.items) {
+      // The normal lead list has a 500-row cap and no continuation. This endpoint explicitly exports all states.
+      const leads = await context.attempt(async (signal) => requireItems(
+        await requestLemlist(`/v2/campaigns/${encodeURIComponent(campaign._id)}/export/leads`, { state: 'all', format: 'json' }, signal, deps),
+        'complete campaign lead export',
+      ), { label: 'GET campaign lead export' })
+      for (let offset = 0; offset < leads.length; offset += deps.config.pageSize) {
+        yield { rows: toLemlistRows(leads.slice(offset, offset + deps.config.pageSize), deps, { campaign_id: campaign._id }) }
+      }
+    }
+  }
+}
diff --git a/registry/lemlist/sources/campaigns.ts b/registry/lemlist/sources/campaigns.ts
new file mode 100644
index 00000000..2fb49058
--- /dev/null
+++ b/registry/lemlist/sources/campaigns.ts
@@ -0,0 +1,13 @@
+import { rawRows, rawTable, type FetchContext } from '@chkit/plugin-ingest'
+
+import { readPages, type LemlistClientDeps } from '../client.js'
+import { lemlistConfig } from '../config.js'
+
+export const lemlist_campaignsRaw = rawTable({ database: lemlistConfig.database, name: 'lemlist_campaigns_raw' })
+
+// No reliable modification filter: default fullSync records completion and safely replays failures.
+export async function* readCampaigns(context: FetchContext, deps: LemlistClientDeps) {
+  for await (const page of readPages(context, 'campaigns', undefined, deps)) {
+    yield { rows: rawRows(page.items, (item) => item._id) }
+  }
+}
diff --git a/registry/lemlist/sources/companies.ts b/registry/lemlist/sources/companies.ts
new file mode 100644
index 00000000..87034c96
--- /dev/null
+++ b/registry/lemlist/sources/companies.ts
@@ -0,0 +1,12 @@
+import { rawTable, type FetchContext } from '@chkit/plugin-ingest'
+
+import { readPages, toLemlistRows, type LemlistClientDeps } from '../client.js'
+import { lemlistConfig } from '../config.js'
+
+export const lemlist_companiesRaw = rawTable({ database: lemlistConfig.database, name: 'lemlist_companies_raw' })
+
+export async function* readCompanies(context: FetchContext, deps: LemlistClientDeps) {
+  for await (const page of readPages(context, 'companies', undefined, deps)) {
+    yield { rows: toLemlistRows(page.items, deps) }
+  }
+}
diff --git a/registry/lemlist/sources/contacts.ts b/registry/lemlist/sources/contacts.ts
new file mode 100644
index 00000000..3a63ee95
--- /dev/null
+++ b/registry/lemlist/sources/contacts.ts
@@ -0,0 +1,22 @@
+import { IngestConfigError, rawTable, type FetchContext } from '@chkit/plugin-ingest'
+
+import { readPages, requestLemlist, requireItems, toLemlistRows, type LemlistClientDeps } from '../client.js'
+import { lemlistConfig } from '../config.js'
+
+export const lemlist_contactsRaw = rawTable({ database: lemlistConfig.database, name: 'lemlist_contacts_raw' })
+
+export async function* readContacts(context: FetchContext, deps: LemlistClientDeps) {
+  for await (const page of readPages(context, 'contacts', undefined, deps)) {
+    if (page.items.length === 0) continue
+    // List items omit custom fields; hydrate complete objects of the same resource in <=100-ID batches.
+    const contacts = await context.attempt(async (signal) => {
+      const items = requireItems(await requestLemlist('/contacts', { idsOrEmails: page.items.map((item) => item._id).join(',') }, signal, deps), 'contact lookup')
+      const expected = new Set(page.items.map((item) => item._id))
+      if (items.length !== page.items.length || items.some((item) => !expected.has(item._id))) {
+        throw new IngestConfigError('Lemlist contact lookup did not return every discovered contact; replay this stream.')
+      }
+      return items
+    }, { label: 'GET /contacts by IDs' })
+    yield { rows: toLemlistRows(contacts, deps) }
+  }
+}
diff --git a/registry/lemlist/sources/inbox-conversations.ts b/registry/lemlist/sources/inbox-conversations.ts
new file mode 100644
index 00000000..a50e5abd
--- /dev/null
+++ b/registry/lemlist/sources/inbox-conversations.ts
@@ -0,0 +1,24 @@
+import { IngestConfigError, rawTable, type FetchContext } from '@chkit/plugin-ingest'
+
+import { readInboxPages, requestLemlist, requireId, requireObject, toLemlistRows, type LemlistClientDeps } from '../client.js'
+import { lemlistConfig } from '../config.js'
+
+export const lemlist_inboxConversationsRaw = rawTable({ database: lemlistConfig.database, name: 'lemlist_inbox_conversations_raw' })
+
+export async function* readInboxConversations(context: FetchContext, deps: LemlistClientDeps) {
+  let userIds = deps.config.inboxUserIds
+  if (!userIds?.length) {
+    userIds = await context.attempt(async (signal) => {
+      const team = requireObject(await requestLemlist('/team', { version: 'v2' }, signal, deps), 'team')
+      const ids = Array.isArray(team.userIds) ? team.userIds : Array.isArray(team.users) ?
+        team.users.map((user: unknown) => requireObject(user, 'team member').userId) : undefined
+      if (!ids?.length) throw new IngestConfigError('Lemlist team has no member IDs; configure inboxUserIds or restore team access.')
+      return [...new Set(ids.map((id: unknown) => requireId(id, 'team member')))]
+    }, { label: 'GET /team members' })
+  }
+  for (const userId of userIds) {
+    for await (const page of readInboxPages(context, { userId }, deps)) {
+      yield { rows: toLemlistRows(page.items, deps, { user_id: userId }) }
+    }
+  }
+}
diff --git a/registry/lemlist/sources/inbox-messages.ts b/registry/lemlist/sources/inbox-messages.ts
new file mode 100644
index 00000000..d597ca22
--- /dev/null
+++ b/registry/lemlist/sources/inbox-messages.ts
@@ -0,0 +1,17 @@
+import { rawTable, type FetchContext } from '@chkit/plugin-ingest'
+
+import { readInboxPages, readPages, toLemlistRows, type LemlistClientDeps } from '../client.js'
+import { lemlistConfig } from '../config.js'
+
+export const lemlist_inboxMessagesRaw = rawTable({ database: lemlistConfig.database, name: 'lemlist_inbox_messages_raw' })
+
+export async function* readInboxMessages(context: FetchContext, deps: LemlistClientDeps) {
+  // Discover all current contacts independently; recent parent/activity watermarks cannot cover late replies.
+  for await (const contacts of readPages(context, 'contacts', undefined, deps)) {
+    for (const contact of contacts.items) {
+      for await (const page of readInboxPages(context, { contactId: contact._id }, deps)) {
+        yield { rows: toLemlistRows(page.items, deps, { contact_id: contact._id }) }
+      }
+    }
+  }
+}
diff --git a/registry/lemlist/tests/basic.test.ts b/registry/lemlist/tests/basic.test.ts
new file mode 100644
index 00000000..794ceb47
--- /dev/null
+++ b/registry/lemlist/tests/basic.test.ts
@@ -0,0 +1,202 @@
+import { afterEach, expect, test } from 'bun:test'
+import { IngestConfigError, runIngestion, selectStreams } from '@chkit/plugin-ingest'
+import { createMemoryDestination, createMemoryJournal } from '@chkit/plugin-ingest/testing'
+
+import { createLemlistPipeline, lemlistPipeline } from '../index.js'
+import { lemlistConfig } from '../config.js'
+import { defaultLemlistClientDeps } from '../client.js'
+
+const originalFetch = globalThis.fetch
+const originalToken = process.env.LEMLIST_API_KEY
+const cutoff = new Date('2000-03-01T00:00:00Z')
+
+function setFetch(handler: (...args: Parameters<typeof fetch>) => Promise<Response>): void {
+  globalThis.fetch = Object.assign(handler, { preconnect: originalFetch.preconnect })
+  process.env.LEMLIST_API_KEY = 'fixture'
+}
+
+function selected(resource = 'activities') {
+  return selectStreams([lemlistPipeline], [`resource:${resource}`]).map((item) => ({ ...item, stream: { ...item.stream, retry: { retries: 0 } } }))
+}
+
+afterEach(() => {
+  globalThis.fetch = originalFetch
+  if (originalToken === undefined) delete process.env.LEMLIST_API_KEY
+  else process.env.LEMLIST_API_KEY = originalToken
+})
+
+test.serial('Lemlist commits only exhausted date intervals and replays the unfinished interval with overlap', async () => {
+  let fail = true
+  const journal = createMemoryJournal()
+  let acknowledgeInterval = () => {}
+  const intervalCommitted = new Promise<void>((resolve) => { acknowledgeInterval = resolve })
+  const append = journal.append
+  journal.append = async (events) => {
+    await append(events)
+    if (events.some((event) => JSON.stringify(event.checkpoint?.state) === '{"watermark":"2000-01-31T00:00:00.000Z"}')) acknowledgeInterval()
+  }
+  const windows: { from: string | null; to: string | null; offset: string | null }[] = []
+  setFetch(async (input) => {
+    const url = new URL(String(input))
+    const from = url.searchParams.get('minDate')
+    windows.push({ from, to: url.searchParams.get('maxDate'), offset: url.searchParams.get('offset') })
+    if (fail && from !== '2000-01-01T00:00:00.000Z') {
+      await intervalCommitted
+      return new Response('denied', { status: 403 })
+    }
+    return Response.json([{ _id: from, custom: { retained: true } }])
+  })
+  const destination = createMemoryDestination()
+  const request = { selected: selected(), backfill: undefined }
+  expect((await runIngestion(request, { journal, destination, now: () => cutoff })).ok).toBe(false)
+  expect((await journal.readCheckpoint('lemlist.activities')).envelope?.state).toEqual({ watermark: '2000-01-31T00:00:00.000Z' })
+  expect(destination.tables.get('default.lemlist_activities_raw')?.[0]?.raw).toMatchObject({ custom: { retained: true } })
+  fail = false
+  expect((await runIngestion(request, { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect(windows[2]).toEqual({ from: '2000-01-30T00:00:00.000Z', to: '2000-02-29T00:00:00.000Z', offset: '0' })
+  expect((await journal.readCheckpoint('lemlist.activities')).envelope?.state).toEqual({ watermark: cutoff.toISOString() })
+})
+
+test.serial('Lemlist resumes isolated explicit backfills from the completed interval frontier', async () => {
+  let fail = true
+  const starts: string[] = []
+  setFetch(async (input) => {
+    const from = new URL(String(input)).searchParams.get('minDate') ?? ''
+    starts.push(from)
+    if (fail && from !== '2025-01-01T00:00:00.000Z') return new Response('denied', { status: 403 })
+    return Response.json([])
+  })
+  const journal = createMemoryJournal()
+  const destination = createMemoryDestination()
+  const request = { selected: selected(), backfill: { id: 'history', from: new Date('2025-01-01T00:00:00Z'), to: new Date('2025-03-01T00:00:00Z') } }
+  expect((await runIngestion(request, { journal, destination, now: () => new Date('2026-01-01') })).ok).toBe(false)
+  expect((await journal.readCheckpoint('lemlist.activities#backfill:history')).envelope?.state).toEqual({ watermark: '2025-01-31T00:00:00.000Z' })
+  fail = false
+  expect((await runIngestion(request, { journal, destination, now: () => new Date('2026-01-01') })).ok).toBe(true)
+  expect(starts[2]).toBe('2025-01-30T00:00:00.000Z')
+  expect((await journal.readCheckpoint('lemlist.activities')).envelope).toBeUndefined()
+})
+
+test.serial('Lemlist rejects a narrowed completed backfill upper bound without regressing its frontier', async () => {
+  let requests = 0
+  setFetch(async () => { requests++; return Response.json([]) })
+  const journal = createMemoryJournal()
+  const destination = createMemoryDestination()
+  const backfill = { id: 'narrowed', from: new Date('2025-01-01T00:00:00Z'), to: new Date('2025-03-01T00:00:00Z') }
+  const request = { selected: selected(), backfill }
+  expect((await runIngestion(request, { journal, destination, now: () => new Date('2026-01-01') })).ok).toBe(true)
+  const completedRequests = requests
+  // This upper bound is still after the overlap's lower bound, but must not move the watermark backwards.
+  const result = await runIngestion({ ...request, backfill: { ...backfill, to: new Date('2025-02-28T12:00:00Z') } }, {
+    journal, destination, now: () => new Date('2026-01-01'),
+  })
+  expect(result.ok).toBe(false)
+  expect(result.streams[0]?.error).toContain('use a new backfill ID')
+  expect(requests).toBe(completedRequests)
+  expect((await journal.readCheckpoint('lemlist.activities#backfill:narrowed')).envelope?.state).toEqual({ watermark: '2025-03-01T00:00:00.000Z' })
+})
+
+test.serial('Lemlist paginates a whole date interval and a rejected sink cannot advance it', async () => {
+  const offsets: string[] = []
+  setFetch(async (input) => {
+    const url = new URL(String(input))
+    offsets.push(url.searchParams.get('offset') ?? '')
+    expect(url.searchParams.get('minDate')).toBe('2000-01-01T00:00:00.000Z')
+    expect(url.searchParams.get('maxDate')).toBe('2000-01-02T00:00:00.000Z')
+    return Response.json(url.searchParams.get('offset') === '0' ? Array.from({ length: 100 }, (_, index) => ({ _id: String(index) })) : [{ _id: 'last' }])
+  })
+  const journal = createMemoryJournal()
+  const request = { selected: selected(), backfill: undefined }
+  const result = await runIngestion(request, { journal, destination: { insert: async () => { throw new IngestConfigError('sink rejected') } }, now: () => new Date('2000-01-02') })
+  expect(result.ok).toBe(false)
+  expect((await journal.readCheckpoint('lemlist.activities')).envelope).toBeUndefined()
+  expect(offsets).toEqual(['0', '100'])
+})
+
+test.serial('Lemlist empty activity intervals commit and campaigns always scan from zero', async () => {
+  const paths: URL[] = []
+  setFetch(async (input) => { paths.push(new URL(String(input))); return Response.json({ campaigns: [] }) })
+  const journal = createMemoryJournal()
+  const destination = createMemoryDestination()
+  const request = { selected: selected('campaigns'), backfill: undefined }
+  expect((await runIngestion(request, { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect((await runIngestion(request, { journal, destination, now: () => new Date('2000-03-02') })).ok).toBe(true)
+  expect(paths.map((url) => url.searchParams.get('offset'))).toEqual(['0', '0'])
+  expect(paths.every((url) => url.searchParams.get('sortBy') === 'createdAt' && url.searchParams.get('sortOrder') === 'asc')).toBe(true)
+  expect((await journal.readCheckpoint('lemlist.campaigns')).lastSuccessSeq).toBeGreaterThan(0)
+  expect(journal.events.filter((event) => event.namespaceId === 'lemlist.campaigns' && event.eventKind === 'work_finished' && event.workState === 'succeeded')).toHaveLength(2)
+  setFetch(async () => Response.json([]))
+  expect((await runIngestion({ selected: selected(), backfill: undefined }, { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect((await journal.readCheckpoint('lemlist.activities')).envelope?.state).toEqual({ watermark: cutoff.toISOString() })
+})
+
+test('Lemlist binds account configuration to independent resource streams and preserves activity progress after a campaign failure', async () => {
+  const config = { ...lemlistConfig, sourceId: 'lemlist.sales', pageSize: 2, start: new Date('2026-01-01'), overlapMs: 0, intervalMs: 24 * 60 * 60 * 1000 }
+  const urls: URL[] = []
+  let campaignsAvailable = false
+  const pipeline = createLemlistPipeline(config, {
+    ...defaultLemlistClientDeps, token: () => 'sales-key',
+    fetch: async (input, init) => {
+      const url = new URL(input)
+      urls.push(url)
+      expect(init.headers).toEqual({ Authorization: `Basic ${Buffer.from(':sales-key').toString('base64')}` })
+      if (url.pathname.endsWith('/campaigns')) return campaignsAvailable ? Response.json({ campaigns: [] }) : new Response('denied', { status: 403 })
+      return Response.json(url.searchParams.get('offset') === '0' ? [{ _id: 'a' }, { _id: 'b' }] : [{ _id: 'c', custom: true }])
+    },
+  })
+  config.pageSize = 100
+  config.start.setUTCFullYear(2000)
+  const journal = createMemoryJournal()
+  const destination = createMemoryDestination()
+  const selected = selectStreams([pipeline], []).filter((item) => ['lemlist.sales.activities', 'lemlist.sales.campaigns'].includes(item.stream.id))
+    .map((item) => ({ ...item, stream: { ...item.stream, retry: { retries: 0 } } }))
+  const result = await runIngestion({ selected, backfill: undefined }, { journal, destination, now: () => new Date('2026-01-02') })
+  expect(result.streams.map((stream) => [stream.streamId, stream.outcome])).toEqual([
+    ['lemlist.sales.activities', 'succeeded'], ['lemlist.sales.campaigns', 'failed'],
+  ])
+  expect((await journal.readCheckpoint('lemlist.sales.activities')).envelope?.state).toEqual({ watermark: '2026-01-02T00:00:00.000Z' })
+  expect((await journal.readCheckpoint('lemlist.sales.campaigns')).lastSuccessSeq).toBe(0)
+  expect(urls.filter((url) => url.pathname.endsWith('/activities')).map((url) => [url.searchParams.get('minDate'), url.searchParams.get('offset'), url.searchParams.get('limit')])).toEqual([
+    ['2026-01-01T00:00:00.000Z', '0', '2'], ['2026-01-01T00:00:00.000Z', '2', '2'],
+  ])
+  expect(destination.tables.get('default.lemlist_activities_raw')?.map((row) => row.id)).toEqual(['a', 'b', 'c'])
+  campaignsAvailable = true
+  urls.length = 0
+  expect((await runIngestion({ selected: selectStreams([pipeline], ['resource:campaigns']), backfill: undefined }, { journal, destination })).ok).toBe(true)
+  expect(urls.map((url) => url.pathname)).toEqual(['/api/campaigns'])
+  expect((await journal.readCheckpoint('lemlist.sales.campaigns')).lastSuccessSeq).toBeGreaterThan(0)
+  expect((await journal.readCheckpoint('lemlist.activities')).envelope).toBeUndefined()
+})
+
+test('Lemlist rejects repeated offset payloads without recording full-scan completion', async () => {
+  const offsets: string[] = []
+  const pipeline = createLemlistPipeline({ ...lemlistConfig, pageSize: 1 }, {
+    ...defaultLemlistClientDeps, token: () => 'fixture', fetch: async (input) => {
+      offsets.push(new URL(input).searchParams.get('offset') ?? '')
+      return Response.json({ campaigns: [{ _id: 'repeated' }] })
+    },
+  })
+  const journal = createMemoryJournal()
+  const result = await runIngestion({ selected: selectStreams([pipeline], ['resource:campaigns']), backfill: undefined }, { journal, destination: createMemoryDestination() })
+  expect(result.ok).toBe(false)
+  expect(result.streams[0]?.error).toContain('repeated a page')
+  expect(offsets).toEqual(['0', '1'])
+  expect((await journal.readCheckpoint('lemlist.campaigns')).lastSuccessSeq).toBe(0)
+})
+
+test('Lemlist full-sync campaigns publish changed observations on the next run', async () => {
+  let title = 'before'
+  const pipeline = createLemlistPipeline(lemlistConfig, {
+    ...defaultLemlistClientDeps, token: () => 'fixture',
+    fetch: async () => Response.json({ campaigns: [{ _id: 'campaign', title }] }),
+  })
+  const journal = createMemoryJournal()
+  const destination = createMemoryDestination()
+  const request = { selected: selectStreams([pipeline], ['resource:campaigns']), backfill: undefined }
+  expect((await runIngestion(request, { journal, destination })).ok).toBe(true)
+  title = 'after'
+  expect((await runIngestion(request, { journal, destination })).ok).toBe(true)
+  expect(destination.tables.get('default.lemlist_campaigns_raw')?.map((row) => row.raw)).toEqual([
+    { _id: 'campaign', title: 'before' }, { _id: 'campaign', title: 'after' },
+  ])
+})
diff --git a/registry/lemlist/tests/resources.test.ts b/registry/lemlist/tests/resources.test.ts
new file mode 100644
index 00000000..7cdc4f7f
--- /dev/null
+++ b/registry/lemlist/tests/resources.test.ts
@@ -0,0 +1,284 @@
+import { expect, test } from 'bun:test'
+import { IngestConfigError, runIngestion, selectStreams, type PipelineDefinition } from '@chkit/plugin-ingest'
+import { createMemoryDestination, createMemoryJournal } from '@chkit/plugin-ingest/testing'
+
+import { defaultLemlistClientDeps } from '../client.js'
+import { lemlistConfig } from '../config.js'
+import { createLemlistPipeline } from '../index.js'
+
+const resources = ['activities', 'campaigns', 'contacts', 'companies', 'campaign_leads', 'inbox_conversations', 'inbox_messages']
+const now = () => new Date('2026-01-02T00:00:00Z')
+
+function pipeline(handler: (url: URL, init: RequestInit) => Response | Promise<Response>, options: { pageSize?: number; inboxUserIds?: readonly string[] } = {}) {
+  return createLemlistPipeline({ ...lemlistConfig, sourceId: 'lemlist.fixture', start: new Date('2026-01-01'), ...options }, {
+    ...defaultLemlistClientDeps, token: () => 'fixture',
+    fetch: async (url, init) => handler(new URL(url), init),
+  })
+}
+
+function selected(value: PipelineDefinition, resource?: string) {
+  return selectStreams([value], resource ? [`resource:${resource}`] : [])
+    .map((item) => ({ ...item, stream: { ...item.stream, retry: { retries: 0 } } }))
+}
+
+function listing(data: { _id: string; [key: string]: unknown }[], url: URL, total = data.length) {
+  return Response.json({ data, total, limit: Number(url.searchParams.get('limit')), offset: Number(url.searchParams.get('offset')) })
+}
+
+function inbox(data: { _id: string; [key: string]: unknown }[], options: { page?: number; next?: number | null; total?: number; limit?: number } = {}) {
+  return Response.json({ data, pagination: {
+    totalItems: options.total ?? data.length, currentPage: options.page ?? 1, nextPage: options.next ?? null,
+    previousPage: null, perPage: options.limit ?? 100, totalPages: options.next ? options.next : options.page ?? (data.length ? 1 : 0),
+  } })
+}
+
+function fixture(url: URL): Response {
+  switch (url.pathname) {
+    case '/api/activities': return Response.json([{ _id: 'act', type: 'emailsSent', createdAt: '2026-01-01T12:00:00Z' }])
+    case '/api/campaigns': return Response.json([{ _id: 'cam', createdAt: '2000-01-01', name: 'Outreach' }])
+    case '/api/contacts': return url.searchParams.has('idsOrEmails') ? Response.json([{
+      _id: 'ctc', companyId: 'cpn', fields: { custom: 'kept' }, unsubscribed: false,
+      campaigns: [{ campaignId: 'cam', leadId: 'lea', leadState: 'review' }],
+    }]) : listing([{ _id: 'ctc' }], url)
+    case '/api/companies': return listing([{ _id: 'cpn', fields: { name: 'Company', custom: { kept: true } } }], url)
+    case '/api/v2/campaigns/cam/export/leads': return Response.json([{ _id: 'lea', email: 'person@example.com', lastState: 'emailsReplied', custom: 'kept' }])
+    case '/api/team': return Response.json({ _id: 'tea', userIds: ['usr'] })
+    case '/api/inbox': return inbox([{ _id: 'ibx', contactId: 'ctc', users: [{ userId: 'usr', read: false }], channels: ['email'] }])
+    case '/api/inbox/ctc': return inbox([{ _id: 'message', type: 'emailsReplied', contactId: 'ctc', leadId: 'lea', campaignId: 'cam', message: '<p>Reply</p>' }])
+    default: throw new IngestConfigError(`Unexpected fixture request: ${url.pathname}`)
+  }
+}
+
+test('Lemlist has seven independently selectable resources with raw provider IDs and joins', async () => {
+  const paths: string[] = []
+  const value = pipeline((url, init) => {
+    expect(init.method ?? 'GET').toBe('GET')
+    paths.push(url.pathname)
+    return fixture(url)
+  })
+  expect(value.streams.map((stream) => stream.id)).toEqual(resources.map((resource) => `lemlist.fixture.${resource}`))
+  const journal = createMemoryJournal()
+  const destination = createMemoryDestination()
+  expect((await runIngestion({ selected: selected(value).reverse(), backfill: undefined }, { journal, destination, now })).ok).toBe(true)
+  expect(paths.filter((path) => path === '/api/contacts')).toHaveLength(3)
+  expect(destination.tables.get('default.lemlist_contacts_raw')?.[0]).toMatchObject({
+    id: '["lemlist.fixture","ctc"]', raw: { source_id: 'lemlist.fixture', data: { companyId: 'cpn', fields: { custom: 'kept' }, campaigns: [{ campaignId: 'cam', leadId: 'lea' }] } },
+  })
+  expect(destination.tables.get('default.lemlist_campaign_leads_raw')?.[0]).toMatchObject({
+    id: '["lemlist.fixture","cam","lea"]', raw: { source_id: 'lemlist.fixture', campaign_id: 'cam', data: { _id: 'lea', lastState: 'emailsReplied', custom: 'kept' } },
+  })
+  expect(destination.tables.get('default.lemlist_inbox_messages_raw')?.[0]).toMatchObject({
+    id: '["lemlist.fixture","ctc","message"]', raw: { source_id: 'lemlist.fixture', contact_id: 'ctc', data: { message: '<p>Reply</p>', leadId: 'lea' } },
+  })
+  for (const resource of resources) expect((await journal.readCheckpoint(`lemlist.fixture.${resource}`)).lastSuccessSeq).toBeGreaterThan(0)
+})
+
+for (const resource of resources) {
+  test(`Lemlist ${resource} discovers its own scope when selected alone`, async () => {
+    const value = pipeline(fixture)
+    const journal = createMemoryJournal()
+    expect((await runIngestion({ selected: selected(value, resource), backfill: undefined }, { journal, destination: createMemoryDestination(), now })).ok).toBe(true)
+    expect(journal.events.filter((event) => event.namespaceId.startsWith('lemlist.fixture.'))
+      .every((event) => event.namespaceId === `lemlist.fixture.${resource}`)).toBe(true)
+  })
+}
+
+test('Lemlist exports more than 500 campaign leads without calling the capped list endpoint', async () => {
+  const paths: URL[] = []
+  const value = pipeline((url) => {
+    paths.push(url)
+    if (url.pathname.endsWith('/export/leads')) {
+      expect(url.searchParams.get('state')).toBe('all')
+      expect(url.searchParams.get('format')).toBe('json')
+      return Response.json(Array.from({ length: 501 }, (_, index) => ({ _id: `lea-${index}`, custom: index })))
+    }
+    return fixture(url)
+  })
+  const destination = createMemoryDestination()
+  expect((await runIngestion({ selected: selected(value, 'campaign_leads'), backfill: undefined }, { journal: createMemoryJournal(), destination, now })).ok).toBe(true)
+  expect(destination.tables.get('default.lemlist_campaign_leads_raw')).toHaveLength(501)
+  expect(paths.map((url) => url.pathname)).toEqual(['/api/campaigns', '/api/v2/campaigns/cam/export/leads'])
+})
+
+test('Lemlist full-contact hydration fails visibly when a discovered contact is unavailable', async () => {
+  const value = pipeline((url) => url.searchParams.has('idsOrEmails') ? Response.json([]) : fixture(url))
+  const journal = createMemoryJournal()
+  const result = await runIngestion({ selected: selected(value, 'contacts'), backfill: undefined }, { journal, destination: createMemoryDestination(), now })
+  expect(result.ok).toBe(false)
+  expect(result.streams[0]?.error).toContain('every discovered contact')
+  expect((await journal.readCheckpoint('lemlist.fixture.contacts')).lastSuccessSeq).toBe(0)
+})
+
+test('Lemlist scoped conversation users are snapshotted and pagination follows provider pages', async () => {
+  const userIds = ['usr-selected']
+  const config = { ...lemlistConfig, sourceId: 'lemlist.fixture', pageSize: 2, inboxUserIds: userIds }
+  const urls: URL[] = []
+  const value = createLemlistPipeline(config, { ...defaultLemlistClientDeps, token: () => 'fixture', fetch: async (input) => {
+    const url = new URL(input)
+    urls.push(url)
+    expect(url.pathname).toBe('/api/inbox')
+    expect(url.searchParams.get('userId')).toBe('usr-selected')
+    const page = Number(url.searchParams.get('page'))
+    return inbox([{ _id: `conversation-${page}` }], { page, next: page === 1 ? 2 : null, total: 2, limit: 2 })
+  } })
+  userIds[0] = 'changed'
+  config.pageSize = 100
+  const destination = createMemoryDestination()
+  expect((await runIngestion({ selected: selected(value, 'inbox_conversations'), backfill: undefined }, { journal: createMemoryJournal(), destination, now })).ok).toBe(true)
+  expect(urls.map((url) => [url.searchParams.get('page'), url.searchParams.get('limit')])).toEqual([['1', '2'], ['2', '2']])
+  expect(destination.tables.get('default.lemlist_inbox_conversations_raw')?.map((row) => row.id)).toEqual([
+    '["lemlist.fixture","usr-selected","conversation-1"]', '["lemlist.fixture","usr-selected","conversation-2"]',
+  ])
+})
+
+test('Lemlist messages revisit old contacts and use skip pagination without marking anything read', async () => {
+  let body = 'before'
+  const skips: string[] = []
+  const value = pipeline((url, init) => {
+    expect(init.method ?? 'GET').toBe('GET')
+    if (url.pathname.startsWith('/api/inbox/')) {
+      expect(url.searchParams.get('markAsRead')).toBe('false')
+      expect(url.searchParams.has('minDate')).toBe(false)
+      skips.push(url.searchParams.get('skip') ?? '')
+      const page = url.searchParams.get('skip') === '0' ? 1 : 2
+      return inbox([{ _id: `message-${page}`, createdAt: '2000-01-01', message: body }], { page, next: page === 1 ? 2 : null, total: 2, limit: 2 })
+    }
+    return listing([{ _id: 'ctc', createdAt: '2000-01-01' }], url)
+  }, { pageSize: 2 })
+  const journal = createMemoryJournal()
+  const destination = createMemoryDestination()
+  const request = { selected: selected(value, 'inbox_messages'), backfill: undefined }
+  expect((await runIngestion(request, { journal, destination, now })).ok).toBe(true)
+  body = 'edited reply'
+  expect((await runIngestion(request, { journal, destination, now })).ok).toBe(true)
+  expect(skips).toEqual(['0', '2', '0', '2'])
+  expect(destination.tables.get('default.lemlist_inbox_messages_raw')?.map((row) => row.raw)).toContainEqual({
+    source_id: 'lemlist.fixture', contact_id: 'ctc', data: { _id: 'message-1', createdAt: '2000-01-01', message: 'edited reply' },
+  })
+})
+
+for (const resource of ['contacts', 'companies', 'campaign_leads', 'inbox_conversations', 'inbox_messages']) {
+  test(`Lemlist ${resource} safely replays destination failure from its own discovery`, async () => {
+    const paths: string[] = []
+    const value = pipeline((url) => { paths.push(url.pathname); return fixture(url) })
+    const journal = createMemoryJournal()
+    const request = { selected: selected(value, resource), backfill: undefined }
+    expect((await runIngestion(request, { journal, destination: { insert: async () => { throw new IngestConfigError('sink denied') } }, now })).ok).toBe(false)
+    expect((await journal.readCheckpoint(`lemlist.fixture.${resource}`)).lastSuccessSeq).toBe(0)
+    const first = [...paths]
+    paths.length = 0
+    expect((await runIngestion(request, { journal, destination: createMemoryDestination(), now })).ok).toBe(true)
+    expect(paths).toEqual(first)
+  })
+}
+
+test('Lemlist empty full collections record completion without custom scan state', async () => {
+  const value = pipeline((url) => {
+    if (url.pathname === '/api/contacts' || url.pathname === '/api/companies') {
+      expect(url.searchParams.has('idsOrEmails')).toBe(false)
+      return listing([], url)
+    }
+    if (url.pathname === '/api/team') return Response.json({ users: [{ userId: 'usr' }] })
+    if (url.pathname === '/api/inbox') return inbox([])
+    return Response.json([])
+  })
+  const journal = createMemoryJournal()
+  expect((await runIngestion({ selected: selected(value), backfill: undefined }, { journal, destination: createMemoryDestination(), now })).ok).toBe(true)
+  for (const resource of resources) expect((await journal.readCheckpoint(`lemlist.fixture.${resource}`)).lastSuccessSeq).toBeGreaterThan(0)
+})
+
+for (const malformed of ['missing', 'repeated', 'truncated', 'invalid-export']) {
+  test(`Lemlist rejects ${malformed} continuation/export without successful completion`, async () => {
+    const resource = malformed === 'invalid-export' ? 'campaign_leads' : 'inbox_conversations'
+    const value = pipeline((url) => {
+      if (malformed === 'invalid-export' && url.pathname.endsWith('/export/leads')) return Response.json({ data: [{ _id: 'capped' }], next: 'unknown' })
+      if (url.pathname === '/api/inbox') {
+        const page = Number(url.searchParams.get('page'))
+        if (malformed === 'missing') return Response.json({ data: [], pagination: { totalItems: 0 } })
+        return inbox([{ _id: `conversation-${page}` }], { page, next: malformed === 'repeated' ? page : null, total: 3 })
+      }
+      return fixture(url)
+    })
+    const journal = createMemoryJournal()
+    expect((await runIngestion({ selected: selected(value, resource), backfill: undefined }, { journal, destination: createMemoryDestination(), now })).ok).toBe(false)
+    expect((await journal.readCheckpoint(`lemlist.fixture.${resource}`)).lastSuccessSeq).toBe(0)
+  })
+}
+
+for (const resource of ['contacts', 'companies']) {
+  test(`Lemlist ${resource} consumes every advertised offset page`, async () => {
+    const offsets: string[] = []
+    const value = pipeline((url) => {
+      if (url.searchParams.has('idsOrEmails')) {
+        const ids = url.searchParams.get('idsOrEmails')?.split(',') ?? []
+        return Response.json(ids.map((_id) => ({ _id, fields: { custom: 'complete' } })))
+      }
+      offsets.push(url.searchParams.get('offset') ?? '')
+      const offset = Number(url.searchParams.get('offset'))
+      return listing(offset === 0 ? [{ _id: 'first' }, { _id: 'second' }] : [{ _id: 'last' }], url, 3)
+    }, { pageSize: 2 })
+    const destination = createMemoryDestination()
+    expect((await runIngestion({ selected: selected(value, resource), backfill: undefined }, { journal: createMemoryJournal(), destination, now })).ok).toBe(true)
+    expect(offsets).toEqual(['0', '2'])
+    expect(destination.tables.get(`default.lemlist_${resource}_raw`)?.map((row) => row.id)).toEqual(
+      ['first', 'second', 'last'].map((id) => JSON.stringify(['lemlist.fixture', id])))
+  })
+}
+
+test('Lemlist keeps distinct user inbox observations when native conversation IDs match', async () => {
+  const value = pipeline((url) => inbox([{ _id: 'shared', unread: url.searchParams.get('userId') === 'usr-a' }]),
+    { inboxUserIds: ['usr-a', 'usr-b'] })
+  const destination = createMemoryDestination()
+  expect((await runIngestion({ selected: selected(value, 'inbox_conversations'), backfill: undefined }, { journal: createMemoryJournal(), destination, now })).ok).toBe(true)
+  expect(destination.tables.get('default.lemlist_inbox_conversations_raw')?.map((row) => [row.id, row.raw])).toEqual([
+    ['["lemlist.fixture","usr-a","shared"]', { source_id: 'lemlist.fixture', user_id: 'usr-a', data: { _id: 'shared', unread: true } }],
+    ['["lemlist.fixture","usr-b","shared"]', { source_id: 'lemlist.fixture', user_id: 'usr-b', data: { _id: 'shared', unread: false } }],
+  ])
+})
+
+test('Lemlist interrupted message traversal restarts contact discovery and skip zero', async () => {
+  let fail = true
+  const paths: string[] = []
+  const value = pipeline((url) => {
+    paths.push(url.pathname + (url.searchParams.has('skip') ? `:${url.searchParams.get('skip')}` : ''))
+    if (url.pathname === '/api/inbox/ctc') {
+      const page = url.searchParams.get('skip') === '0' ? 1 : 2
+      if (fail && page === 2) return new Response('denied', { status: 403 })
+      return inbox([{ _id: `message-${page}` }], { page, next: page === 1 ? 2 : null, total: 2, limit: 2 })
+    }
+    return fixture(url)
+  }, { pageSize: 2 })
+  const journal = createMemoryJournal()
+  const request = { selected: selected(value, 'inbox_messages'), backfill: undefined }
+  const destination = createMemoryDestination()
+  expect((await runIngestion(request, { journal, destination, now })).ok).toBe(false)
+  expect((await journal.readCheckpoint('lemlist.fixture.inbox_messages')).lastSuccessSeq).toBe(0)
+  fail = false
+  expect((await runIngestion(request, { journal, destination, now })).ok).toBe(true)
+  expect(paths).toEqual(['/api/contacts', '/api/inbox/ctc:0', '/api/inbox/ctc:2', '/api/contacts', '/api/inbox/ctc:0', '/api/inbox/ctc:2'])
+})
+
+test('Lemlist refuses a shortened contact listing that still advertises more records', async () => {
+  const value = pipeline((url) => listing([{ _id: 'first' }], url, 3), { pageSize: 2 })
+  const journal = createMemoryJournal()
+  expect((await runIngestion({ selected: selected(value, 'contacts'), backfill: undefined }, { journal, destination: createMemoryDestination(), now })).ok).toBe(false)
+  expect((await journal.readCheckpoint('lemlist.fixture.contacts')).lastSuccessSeq).toBe(0)
+})
+
+for (const resource of ['contacts', 'companies', 'inbox_conversations']) {
+  test(`Lemlist ${resource} refuses partially overlapping pages despite matching advertised totals`, async () => {
+    const value = pipeline((url) => {
+      if (url.searchParams.has('idsOrEmails')) return Response.json((url.searchParams.get('idsOrEmails')?.split(',') ?? []).map((_id) => ({ _id })))
+      const first = resource === 'inbox_conversations' ? url.searchParams.get('page') === '1' : url.searchParams.get('offset') === '0'
+      const items = first ? [{ _id: 'a' }, { _id: 'b' }] : [{ _id: 'b' }, { _id: 'c' }]
+      return resource === 'inbox_conversations'
+        ? inbox(items, { page: first ? 1 : 2, next: first ? 2 : null, total: 4, limit: 2 })
+        : listing(items, url, 4)
+    }, { pageSize: 2, inboxUserIds: ['usr'] })
+    const journal = createMemoryJournal()
+    const result = await runIngestion({ selected: selected(value, resource), backfill: undefined }, { journal, destination: createMemoryDestination(), now })
+    expect(result.ok).toBe(false)
+    expect(result.streams[0]?.error).toContain('object ID')
+    expect((await journal.readCheckpoint(`lemlist.fixture.${resource}`)).lastSuccessSeq).toBe(0)
+  })
+}
diff --git a/registry/linear/README.md b/registry/linear/README.md
index a56e2864..b0c24c0f 100644
--- a/registry/linear/README.md
+++ b/registry/linear/README.md
@@ -1,8 +1,12 @@
 # Linear raw ingestion example
 
-This is a small editable starting point based on the Linear source in [obsessiondb/brain](https://github.com/obsessiondb/brain/tree/main/scripts/brain-sync). It stores provider responses as native JSON without Brain's memory or sales projections.
+One workspace pipeline syncs nine independent resource streams into native JSON tables. Readers preserve provider fields and relationship IDs; joins, business mappings, and derived metrics belong in ClickHouse. Issue labels are the explicitly selected exception: their complete names are stored as strings on each issue.
 
-Set `LINEAR_API_KEY` in the runtime environment and configure a direct ClickHouse connection. Edit the GraphQL `query` in `index.ts` to request the issue fields needed by the project. Native JSON requires ClickHouse 25.3 or later.
+Set `LINEAR_API_KEY` in the runtime environment and configure a direct ClickHouse connection. Edit the GraphQL queries and raw table declarations in `sources/` to request fields and configure destinations. Native JSON requires ClickHouse 25.3 or later.
+
+`config.ts` supplies source identity, initial timestamp, and overlap. `createLinearPipeline(config, deps)` snapshots configuration and binds injectable `fetch` and token readers. `pipeline.ts` groups resources without dependency ordering. Destination schemas stay in their source modules rather than runtime configuration.
+
+Keep stream IDs and destinations tied to one Linear workspace. The reader does not resolve the authenticated workspace identity: changing the token to another workspace requires a new source ID and destinations before ingestion, so old checkpoints cannot skip its history. Adding requested fields later requires reconciliation to populate older observations.
 
 ```sh
 bunx chkit check
@@ -14,6 +18,63 @@ bunx chkit ingest run --tag provider:linear
 
 ## Resources
 
-- `issues` → `linear_issues_raw`
+| Stream suffix | Raw table | Selection |
+| --- | --- | --- |
+| `issues` | `linear_issues_raw` | Updated-time window |
+| `comments` | `linear_comments_raw` | Own updated-time window |
+| `projects` | `linear_projects_raw` | Updated-time window |
+| `project_updates` | `linear_project_updates_raw` | Own updated-time window |
+| `cycles` | `linear_cycles_raw` | Updated-time window |
+| `users` | `linear_users_raw` | Updated-time window, including disabled users |
+| `teams` | `linear_teams_raw` | Updated-time window |
+| `issue_relations` | `linear_issue_relations_raw` | Full accessible relation collection |
+| `issue_history` | `linear_issue_history_raw` | All accessible history after independent issue discovery |
+
+The default IDs are `linear` for the pipeline and `linear.<resource>` for each stream. Each owns its journal progress. Run a resource separately with:
+
+```sh
+bunx chkit ingest run --tag provider:linear --tag resource:comments
+bunx chkit ingest run --tag provider:linear --tag resource:issue_history
+```
+
+Repeated tags use AND matching. The default `maxStreams: 1` executes selected streams sequentially to limit API usage. Selection and failure in one stream do not make another stream's discovery depend on it. Give expensive history reads their own schedule and execution budget; individual issues remain records inside the resource stream.
+
+## Stored data and joins
+
+Each table uses the provider record ID as its row identity and retains requested fields directly in `raw`. Relationships remain provider-shaped references such as `project: { id }`, `cycle: { id }`, or `issue: { id }`. Join those IDs to other raw tables in ClickHouse.
+
+Issues contain metadata, state details, relationship IDs, and a fully paginated `labels` string array. Comments, project updates, relations, and history are individual records in their own tables. Comments retain nullable parent IDs and user references, including comments on project updates or other parent types. Issue history retains native transition fields and its issue reference; cycle movement and status-duration calculations happen downstream.
+
+Workflow state, project status, and label definition streams are outside this package's current scope. Project/team memberships and other paginated associations are not fetched as truncated nested collections. Bounded inline state/status metadata remains raw.
+
+## Sync and recovery
+
+Seven root collections use bounded `updatedAt` filters, `orderBy: updatedAt`, and `includeArchived: true`. Users also request `includeDisabled: true`. Each initial window starts at the configured date, defaulting to the Unix epoch. Subsequent windows replay five minutes before that stream's committed watermark. Comments use their own collection and update timestamp; a comment on an old issue does not require the issue stream to run or its parent timestamp to change.
+
+Relay cursors only continue the current read. `paginate()` owns request retries and rejects repeated continuations; readers validate connections, identities, timestamps, and GraphQL errors, including partial responses. Issues complete all label pages before publishing their label strings. A label retrieval failure leaves only the issues window incomplete.
+
+Newest-first pages do not define a safe timestamp frontier. A window checkpoint advances to its upper cutoff only after all pages and destination writes succeed, including an empty successful window. An interrupted or failed window replays from its lower bound. Mutable row chunks omit explicit immutable IDs so changed provider fields stay eligible on replay.
+
+Issue relations have a root listing without a reliable timestamp filter. Issue history has no workspace-level feed or timestamp filter: its reader independently paginates every accessible issue ID, then each issue's history. Both use the library's `fullSync()` completion checkpoints. Each invocation starts its collection again, and interrupted work replays from the beginning. Their successful completion is journaled even when empty; no parent stream watermark, saved mutable offset, or per-issue scan ledger is used. Full-sync resources ignore date bounds and provide no date-range backfill.
+
+The API does not guarantee atomic snapshots. Deleted records and removed relations remain stored; missing observations do not generate tombstones. A label rename is not assumed to update every issue's timestamp. Periodic reconciliation refreshes older observations and changes beyond overlap:
+
+```sh
+bunx chkit ingest run --tag provider:linear --tag resource:issues --backfill reconcile-2026-10-05 --from 1970-01-01
+bunx chkit ingest status --tag provider:linear --json
+```
+
+Use a new backfill ID for each reconciliation. Timestamp replay reads current observations, while the separate history stream reads the provider's accessible event records; neither reconstructs an atomic historical workspace snapshot. Run one ingestion process per ClickHouse target at a time.
+
+## Upgrading existing data
+
+Version `0.2.0` adds eight raw destinations and keeps issue row IDs and the default `linear.issues` stream ID stable. Published `0.1.0` installations may retain nested comment payloads in issue JSON. Those observations are neither removed nor moved automatically: populate the new destinations through their own initial reads and reconcile or deliberately migrate legacy data. Application queries should join the comments table; old embedded fields can remain until their issue is observed again or migrated.
+
+## Fixture tests
+
+```sh
+bunx chkit add linear --with-tests
+bun test src/integrations/linear/tests/basic.test.ts
+```
 
-Every run reads all accessible issues. The example requests the first 100 comments per issue; extend the query for complete discussions. A failed API request fails the stream. Raw rows use provider IDs and keep the last observed value; there is no deletion reconciliation. Edit the readers, select fewer streams, or add SQL views for a specific use case. Run one ingestion process per ClickHouse target at a time.
+Portable fixtures exercise independent selection and checkpoints, raw fields and join IDs, complete label names, old-parent comment and history coverage, continuation validation, retries, source/sink failure replay, mutable full reads, and empty completion without live credentials.
diff --git a/registry/linear/client.ts b/registry/linear/client.ts
new file mode 100644
index 00000000..96a02351
--- /dev/null
+++ b/registry/linear/client.ts
@@ -0,0 +1,56 @@
+import { HttpError, IngestConfigError, type ErrorClassifier } from '@chkit/plugin-ingest'
+
+export type LinearObject = Record<string, unknown>
+
+export interface LinearClientDeps {
+  fetch: (url: string, init: RequestInit) => Promise<Response>
+  token: () => string | undefined
+}
+
+export const defaultLinearClientDeps: LinearClientDeps = {
+  fetch: (url, init) => fetch(url, init),
+  token: () => process.env.LINEAR_API_KEY,
+}
+
+/** paginate supplies the executor attempt for each GraphQL page. */
+export async function graphql(document: string, variables: Record<string, unknown>, signal: AbortSignal, deps: LinearClientDeps): Promise<LinearObject> {
+  const token = deps.token()?.trim()
+  if (!token) throw new IngestConfigError('Set LINEAR_API_KEY.')
+  const response = await deps.fetch('https://api.linear.app/graphql', {
+    method: 'POST', signal: AbortSignal.any([signal, AbortSignal.timeout(30_000)]), redirect: 'error',
+    headers: { Authorization: token, 'Content-Type': 'application/json' },
+    body: JSON.stringify({ query: document, variables }),
+  })
+  if (!response.ok) throw await HttpError.fromResponse(response)
+  const body = requireLinearObject(await response.clone().json(), 'GraphQL response')
+  if (body.errors !== undefined && !Array.isArray(body.errors)) throw new IngestConfigError('Linear GraphQL errors is not an array.')
+  if (Array.isArray(body.errors) && body.errors.length > 0) {
+    const rateLimited = body.errors.some((error: unknown) => isLinearObject(error) &&
+      isLinearObject(error.extensions) && error.extensions.code === 'RATELIMITED')
+    if (rateLimited) throw await HttpError.fromResponse(response)
+    throw new IngestConfigError(`Linear GraphQL returned errors: ${JSON.stringify(body.errors)}`)
+  }
+  return requireLinearObject(body.data, 'GraphQL data')
+}
+
+/** Linear documents HTTP 400 rate errors; preserve GraphQL 200 rate errors too. */
+export function classifyLinearError(cause: unknown): ReturnType<ErrorClassifier> {
+  if (cause instanceof SyntaxError) return { kind: 'permanent' }
+  if (!(cause instanceof HttpError) || ![200, 400].includes(cause.status) || !/"code"\s*:\s*"RATELIMITED"/.test(cause.body)) return undefined
+  const headers = cause.response.headers
+  const resets = ['requests', 'endpoint-requests', 'complexity'].flatMap((kind) => {
+    if (headers.get(`x-ratelimit-${kind}-remaining`) !== '0') return []
+    const reset = Number(headers.get(`x-ratelimit-${kind}-reset`))
+    return Number.isFinite(reset) && reset > 0 ? [Math.max(0, reset - Date.now())] : []
+  })
+  return { kind: 'rate_limited', retryAfterMs: cause.retryAfterMs ?? (resets.length ? Math.max(...resets) : undefined) }
+}
+
+export function requireLinearObject(value: unknown, label: string): LinearObject {
+  if (!isLinearObject(value)) throw new IngestConfigError(`Linear ${label} is not an object.`)
+  return value
+}
+
+function isLinearObject(value: unknown): value is LinearObject {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
diff --git a/registry/linear/config.ts b/registry/linear/config.ts
new file mode 100644
index 00000000..dc8dc34f
--- /dev/null
+++ b/registry/linear/config.ts
@@ -0,0 +1,13 @@
+export interface LinearConfig {
+  /** Stable, non-secret stream prefix for this installation. */
+  sourceId: string
+  start: Date
+  overlapMs: number
+}
+
+// Source identity and date selection; raw destinations and requested fields live in sources/.
+export const linearConfig: LinearConfig = {
+  sourceId: 'linear',
+  start: new Date(0),
+  overlapMs: 5 * 60 * 1000,
+}
diff --git a/registry/linear/index.ts b/registry/linear/index.ts
index 0d200c07..0773625d 100644
--- a/registry/linear/index.ts
+++ b/registry/linear/index.ts
@@ -1,50 +1,10 @@
-import { definePipeline, defineStream, HttpError, rawRows, rawTable, type FetchContext } from '@chkit/plugin-ingest'
-
-const database = 'default'
-const query = `query Issues($after: String) {
-  issues(first: 100, after: $after) {
-    nodes { id identifier title description url createdAt updatedAt completedAt canceledAt
-      team { id key name } state { name type } assignee { id name email }
-      comments(first: 100) { nodes { id body createdAt updatedAt } pageInfo { hasNextPage endCursor } }
-    }
-    pageInfo { hasNextPage endCursor }
-  }
-}`
-interface Issue { id: string; [key: string]: unknown }
-interface ResponseBody { data?: { issues: { nodes: Issue[]; pageInfo: { hasNextPage: boolean; endCursor: string | null } } }; errors?: { message: string }[] }
-
-export const linear_issuesRaw = rawTable({ database, name: 'linear_issues_raw' })
-
-export const linearPipeline = definePipeline({
-  id: 'linear', tags: ['provider:linear'], maxFetches: 1,
-  streams: [defineStream({ id: 'linear.issues', tags: ['resource:issues'], destination: linear_issuesRaw,
-    async *read(context) {
-      let after: string | null = null
-      const seen = new Set<string>()
-      while (true) {
-        const body = await readPage(context, after)
-        const issues = body.data?.issues
-        if (body.errors?.length || !issues) throw new Error(`Linear query failed: ${body.errors?.map((item) => item.message).join('; ') ?? 'missing issues'}`)
-        if (issues.nodes.length) yield { rows: rawRows(issues.nodes, (issue) => issue.id) }
-        if (!issues.pageInfo.hasNextPage) return
-        after = issues.pageInfo.endCursor
-        if (!after || seen.has(after)) throw new Error('Linear returned no new issue cursor')
-        seen.add(after)
-      }
-    },
-  })],
-})
-
-async function readPage(context: FetchContext, after: string | null): Promise<ResponseBody> {
-  return context.attempt(async (signal) => {
-    const token = process.env.LINEAR_API_KEY
-    if (!token) throw new Error('Set LINEAR_API_KEY')
-    const response = await fetch('https://api.linear.app/graphql', {
-      method: 'POST', signal,
-      headers: { Authorization: token, 'Content-Type': 'application/json' },
-      body: JSON.stringify({ query, variables: { after } }),
-    })
-    if (!response.ok) throw await HttpError.fromResponse(response)
-    return await response.json() as ResponseBody
-  }, { label: 'POST /graphql issues' })
-}
+export { linearPipeline, createLinearPipeline } from './pipeline.js'
+export { linear_issuesRaw } from './sources/issues.js'
+export { linear_commentsRaw } from './sources/comments.js'
+export { linear_projectsRaw } from './sources/projects.js'
+export { linear_projectUpdatesRaw } from './sources/project-updates.js'
+export { linear_cyclesRaw } from './sources/cycles.js'
+export { linear_usersRaw } from './sources/users.js'
+export { linear_teamsRaw } from './sources/teams.js'
+export { linear_issueRelationsRaw } from './sources/issue-relations.js'
+export { linear_issueHistoryRaw } from './sources/issue-history.js'
diff --git a/registry/linear/manifest.json b/registry/linear/manifest.json
index f0154b1a..cc399e09 100644
--- a/registry/linear/manifest.json
+++ b/registry/linear/manifest.json
@@ -3,10 +3,10 @@
   "name": "linear",
   "type": "registry:item",
   "title": "Linear",
-  "description": "Small, editable Linear API ingestion example with raw ClickHouse tables.",
+  "description": "Editable Linear ingestion with nine independent raw resource streams, overlapping update windows, and complete issue history.",
   "dependencies": [
-    "@chkit/core@^0.2.0-beta.8",
-    "@chkit/plugin-ingest@^0.2.0-beta.8"
+    "@chkit/core@^0.2.0-beta.10",
+    "@chkit/plugin-ingest@^0.2.0-beta.10"
   ],
   "files": [
     {
@@ -18,33 +18,132 @@
       "path": "index.ts",
       "type": "registry:file",
       "target": "src/integrations/linear/index.ts"
+    },
+    {
+      "path": "config.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/config.ts"
+    },
+    {
+      "path": "client.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/client.ts"
+    },
+    {
+      "path": "pipeline.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/pipeline.ts"
+    },
+    {
+      "path": "sources/issues.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/sources/issues.ts"
+    },
+    {
+      "path": "sources/common.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/sources/common.ts"
+    },
+    {
+      "path": "sources/comments.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/sources/comments.ts"
+    },
+    {
+      "path": "sources/projects.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/sources/projects.ts"
+    },
+    {
+      "path": "sources/project-updates.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/sources/project-updates.ts"
+    },
+    {
+      "path": "sources/cycles.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/sources/cycles.ts"
+    },
+    {
+      "path": "sources/users.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/sources/users.ts"
+    },
+    {
+      "path": "sources/teams.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/sources/teams.ts"
+    },
+    {
+      "path": "sources/issue-relations.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/sources/issue-relations.ts"
+    },
+    {
+      "path": "sources/issue-history.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/sources/issue-history.ts"
+    },
+    {
+      "path": "tests/basic.test.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/tests/basic.test.ts",
+      "role": "test"
     }
   ],
   "meta": {
     "chkit": {
       "formatVersion": 1,
-      "version": "0.1.0",
+      "version": "0.2.0",
+      "changelog": [
+        {
+          "version": "0.2.0",
+          "changes": [
+            "Sync issues, comments, projects, project updates, cycles, users, and teams through independent overlapping updated-time windows, including archived and disabled resources.",
+            "Add independent full-sync streams for issue relations and issue history; discover and paginate history for all accessible issues without relying on parent stream progress or modification times.",
+            "Store each resource in its own raw table with provider IDs and relationship references; retain complete issue labels as strings and leave joins and metrics to ClickHouse.",
+            "Use shared pagination, validated GraphQL responses, request-level retries and sink-acknowledged completion checkpoints; separate configuration, injectable requests, readers, and pipeline wiring.",
+            "Existing issue IDs remain stable; migrate retained nested comment observations deliberately and populate the eight new destinations through their own initial syncs.",
+            "Consume full pagination pages and use shared continuation-cycle detection while preserving independent resource checkpoints and GraphQL response validation."
+          ]
+        },
+        {
+          "version": "0.1.0",
+          "changes": [
+            "Introduce raw GraphQL issue ingestion."
+          ]
+        }
+      ],
       "documentation": "https://chkit.obsessiondb.com/integrations/linear/",
       "logo": "https://chkit.obsessiondb.com/logos/linear.svg",
       "language": "typescript",
       "license": "MIT",
-      "chkit": "^0.2.0-beta.8",
-      "ingest": "^0.2.0-beta.8",
+      "chkit": "^0.2.0-beta.10",
+      "ingest": "^0.2.0-beta.10",
       "clickhouse": ">=25.3.0",
       "root": "src/integrations/linear",
       "entry": "index.ts",
       "exports": [
         "linearPipeline",
-        "linear_issuesRaw"
+        "createLinearPipeline",
+        "linear_issuesRaw",
+        "linear_commentsRaw",
+        "linear_projectsRaw",
+        "linear_projectUpdatesRaw",
+        "linear_cyclesRaw",
+        "linear_usersRaw",
+        "linear_teamsRaw",
+        "linear_issueRelationsRaw",
+        "linear_issueHistoryRaw"
       ],
       "resources": [
         {
           "name": "issues",
           "title": "Issues",
           "table": "linear_issues_raw",
-          "description": "Issue fields and the first 100 comments per issue.",
+          "description": "Archived and active issue fields, relationship IDs, and fully paginated label names as strings.",
           "scopes": [],
-          "strategy": "full",
+          "strategy": "timestamp",
           "endpoints": [
             {
               "method": "POST",
@@ -52,6 +151,78 @@
               "documentation": "https://linear.app/developers/graphql"
             }
           ]
+        },
+        {
+          "name": "comments",
+          "title": "Comments",
+          "table": "linear_comments_raw",
+          "description": "Raw comments selected by their own update times, with nullable issue and other parent references.",
+          "scopes": [],
+          "strategy": "timestamp",
+          "endpoints": [{ "method": "POST", "path": "/graphql", "documentation": "https://linear.app/developers/graphql" }]
+        },
+        {
+          "name": "projects",
+          "title": "Projects",
+          "table": "linear_projects_raw",
+          "description": "Project metadata and provider relationship references selected by project update times.",
+          "scopes": [],
+          "strategy": "timestamp",
+          "endpoints": [{ "method": "POST", "path": "/graphql", "documentation": "https://linear.app/developers/graphql" }]
+        },
+        {
+          "name": "project_updates",
+          "title": "Project updates",
+          "table": "linear_project_updates_raw",
+          "description": "Authored progress and health updates with project and author references.",
+          "scopes": [],
+          "strategy": "timestamp",
+          "endpoints": [{ "method": "POST", "path": "/graphql", "documentation": "https://linear.app/developers/graphql" }]
+        },
+        {
+          "name": "cycles",
+          "title": "Cycles",
+          "table": "linear_cycles_raw",
+          "description": "Cycle dates, descriptions, and team references selected by cycle update times.",
+          "scopes": [],
+          "strategy": "timestamp",
+          "endpoints": [{ "method": "POST", "path": "/graphql", "documentation": "https://linear.app/developers/graphql" }]
+        },
+        {
+          "name": "users",
+          "title": "Users",
+          "table": "linear_users_raw",
+          "description": "Accessible user metadata, including disabled users, selected by user update times.",
+          "scopes": [],
+          "strategy": "timestamp",
+          "endpoints": [{ "method": "POST", "path": "/graphql", "documentation": "https://linear.app/developers/graphql" }]
+        },
+        {
+          "name": "teams",
+          "title": "Teams",
+          "table": "linear_teams_raw",
+          "description": "Accessible team metadata selected by team update times.",
+          "scopes": [],
+          "strategy": "timestamp",
+          "endpoints": [{ "method": "POST", "path": "/graphql", "documentation": "https://linear.app/developers/graphql" }]
+        },
+        {
+          "name": "issue_relations",
+          "title": "Issue relations",
+          "table": "linear_issue_relations_raw",
+          "description": "Complete accessible relation records with type and both directed issue references; no reliable root change filter exists.",
+          "scopes": [],
+          "strategy": "full",
+          "endpoints": [{ "method": "POST", "path": "/graphql", "documentation": "https://linear.app/developers/graphql" }]
+        },
+        {
+          "name": "issue_history",
+          "title": "Issue history",
+          "table": "linear_issue_history_raw",
+          "description": "Complete accessible history for independently discovered issues; the parent history connection has no timestamp filter.",
+          "scopes": [],
+          "strategy": "full",
+          "endpoints": [{ "method": "POST", "path": "/graphql", "documentation": "https://linear.app/developers/graphql" }]
         }
       ],
       "env": {
@@ -70,10 +241,13 @@
       },
       "views": [],
       "sync": {
-        "description": "A full read runs for each enabled stream. Stable IDs keep the latest observed record.",
+        "description": "One workspace pipeline groups nine independent raw streams. Seven resources use bounded updatedAt windows with five-minute overlap; issue relations and history use fullSync. Each stream completes only after destination acknowledgement.",
         "schedule": "Run bunx chkit ingest run --tag provider:linear from a scheduler.",
-        "deletions": "Every run reads all accessible issues. The example requests the first 100 comments per issue; extend the query for complete discussions."
+        "deletions": "Deleted records and removed relations remain stored; absence is not a tombstone. Comments have their own update windows. Periodic reconciliation refreshes older observations and label renames beyond the issue overlap; retained legacy nested comments require deliberate migration."
       }
     }
-  }
+  },
+  "devDependencies": [
+    "@types/bun@^1.2.0"
+  ]
 }
diff --git a/registry/linear/pipeline.ts b/registry/linear/pipeline.ts
new file mode 100644
index 00000000..74759335
--- /dev/null
+++ b/registry/linear/pipeline.ts
@@ -0,0 +1,70 @@
+import { definePipeline, defineStream, fullSync, timestampWindow } from '@chkit/plugin-ingest'
+
+import { classifyLinearError, defaultLinearClientDeps, type LinearClientDeps } from './client.js'
+import { linearConfig, type LinearConfig } from './config.js'
+import { linear_issuesRaw, readIssues } from './sources/issues.js'
+import { linear_commentsRaw, readComments } from './sources/comments.js'
+import { linear_projectsRaw, readProjects } from './sources/projects.js'
+import { linear_projectUpdatesRaw, readProjectUpdates } from './sources/project-updates.js'
+import { linear_cyclesRaw, readCycles } from './sources/cycles.js'
+import { linear_usersRaw, readUsers } from './sources/users.js'
+import { linear_teamsRaw, readTeams } from './sources/teams.js'
+import { linear_issueRelationsRaw, readIssueRelations } from './sources/issue-relations.js'
+import { linear_issueHistoryRaw, readIssueHistory } from './sources/issue-history.js'
+
+export function createLinearPipeline(config: LinearConfig = linearConfig, deps: LinearClientDeps = defaultLinearClientDeps) {
+  const source = { ...config, start: new Date(config.start) }
+  const options = { classifyError: classifyLinearError }
+  return definePipeline({
+    id: source.sourceId, tags: ['provider:linear'], maxStreams: 1, maxFetches: 1,
+    streams: [
+      defineStream({
+        ...options, id: `${source.sourceId}.issues`, tags: ['resource:issues'], destination: linear_issuesRaw,
+        incremental: timestampWindow({ start: source.start, overlapMs: source.overlapMs }),
+        read: (context) => readIssues(context, deps),
+      }),
+      defineStream({
+        ...options, id: `${source.sourceId}.comments`, tags: ['resource:comments'], destination: linear_commentsRaw,
+        incremental: timestampWindow({ start: source.start, overlapMs: source.overlapMs }),
+        read: (context) => readComments(context, deps),
+      }),
+      defineStream({
+        ...options, id: `${source.sourceId}.projects`, tags: ['resource:projects'], destination: linear_projectsRaw,
+        incremental: timestampWindow({ start: source.start, overlapMs: source.overlapMs }),
+        read: (context) => readProjects(context, deps),
+      }),
+      defineStream({
+        ...options, id: `${source.sourceId}.project_updates`, tags: ['resource:project_updates'], destination: linear_projectUpdatesRaw,
+        incremental: timestampWindow({ start: source.start, overlapMs: source.overlapMs }),
+        read: (context) => readProjectUpdates(context, deps),
+      }),
+      defineStream({
+        ...options, id: `${source.sourceId}.cycles`, tags: ['resource:cycles'], destination: linear_cyclesRaw,
+        incremental: timestampWindow({ start: source.start, overlapMs: source.overlapMs }),
+        read: (context) => readCycles(context, deps),
+      }),
+      defineStream({
+        ...options, id: `${source.sourceId}.users`, tags: ['resource:users'], destination: linear_usersRaw,
+        incremental: timestampWindow({ start: source.start, overlapMs: source.overlapMs }),
+        read: (context) => readUsers(context, deps),
+      }),
+      defineStream({
+        ...options, id: `${source.sourceId}.teams`, tags: ['resource:teams'], destination: linear_teamsRaw,
+        incremental: timestampWindow({ start: source.start, overlapMs: source.overlapMs }),
+        read: (context) => readTeams(context, deps),
+      }),
+      defineStream({
+        ...options, id: `${source.sourceId}.issue_relations`, tags: ['resource:issue_relations'], destination: linear_issueRelationsRaw,
+        incremental: fullSync(),
+        read: (context) => readIssueRelations(context, deps),
+      }),
+      defineStream({
+        ...options, id: `${source.sourceId}.issue_history`, tags: ['resource:issue_history'], destination: linear_issueHistoryRaw,
+        incremental: fullSync(),
+        read: (context) => readIssueHistory(context, deps),
+      }),
+    ],
+  })
+}
+
+export const linearPipeline = createLinearPipeline()
diff --git a/registry/linear/releases/0.2.0.json b/registry/linear/releases/0.2.0.json
new file mode 100644
index 00000000..2906c0a9
--- /dev/null
+++ b/registry/linear/releases/0.2.0.json
@@ -0,0 +1,335 @@
+{
+  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
+  "name": "linear",
+  "type": "registry:item",
+  "title": "Linear",
+  "description": "Editable Linear ingestion with nine independent raw resource streams, overlapping update windows, and complete issue history.",
+  "dependencies": [
+    "@chkit/core@^0.2.0-beta.10",
+    "@chkit/plugin-ingest@^0.2.0-beta.10"
+  ],
+  "devDependencies": [
+    "@types/bun@^1.2.0"
+  ],
+  "files": [
+    {
+      "path": "linear/README.md",
+      "type": "registry:file",
+      "target": "src/integrations/linear/README.md",
+      "content": "# Linear raw ingestion example\n\nOne workspace pipeline syncs nine independent resource streams into native JSON tables. Readers preserve provider fields and relationship IDs; joins, business mappings, and derived metrics belong in ClickHouse. Issue labels are the explicitly selected exception: their complete names are stored as strings on each issue.\n\nSet `LINEAR_API_KEY` in the runtime environment and configure a direct ClickHouse connection. Edit the GraphQL queries and raw table declarations in `sources/` to request fields and configure destinations. Native JSON requires ClickHouse 25.3 or later.\n\n`config.ts` supplies source identity, initial timestamp, and overlap. `createLinearPipeline(config, deps)` snapshots configuration and binds injectable `fetch` and token readers. `pipeline.ts` groups resources without dependency ordering. Destination schemas stay in their source modules rather than runtime configuration.\n\nKeep stream IDs and destinations tied to one Linear workspace. The reader does not resolve the authenticated workspace identity: changing the token to another workspace requires a new source ID and destinations before ingestion, so old checkpoints cannot skip its history. Adding requested fields later requires reconciliation to populate older observations.\n\n```sh\nbunx chkit check\nbunx chkit generate --name add_linear\n# Review the migration before applying it.\nbunx chkit migrate --apply\nbunx chkit ingest run --tag provider:linear\n```\n\n## Resources\n\n| Stream suffix | Raw table | Selection |\n| --- | --- | --- |\n| `issues` | `linear_issues_raw` | Updated-time window |\n| `comments` | `linear_comments_raw` | Own updated-time window |\n| `projects` | `linear_projects_raw` | Updated-time window |\n| `project_updates` | `linear_project_updates_raw` | Own updated-time window |\n| `cycles` | `linear_cycles_raw` | Updated-time window |\n| `users` | `linear_users_raw` | Updated-time window, including disabled users |\n| `teams` | `linear_teams_raw` | Updated-time window |\n| `issue_relations` | `linear_issue_relations_raw` | Full accessible relation collection |\n| `issue_history` | `linear_issue_history_raw` | All accessible history after independent issue discovery |\n\nThe default IDs are `linear` for the pipeline and `linear.<resource>` for each stream. Each owns its journal progress. Run a resource separately with:\n\n```sh\nbunx chkit ingest run --tag provider:linear --tag resource:comments\nbunx chkit ingest run --tag provider:linear --tag resource:issue_history\n```\n\nRepeated tags use AND matching. The default `maxStreams: 1` executes selected streams sequentially to limit API usage. Selection and failure in one stream do not make another stream's discovery depend on it. Give expensive history reads their own schedule and execution budget; individual issues remain records inside the resource stream.\n\n## Stored data and joins\n\nEach table uses the provider record ID as its row identity and retains requested fields directly in `raw`. Relationships remain provider-shaped references such as `project: { id }`, `cycle: { id }`, or `issue: { id }`. Join those IDs to other raw tables in ClickHouse.\n\nIssues contain metadata, state details, relationship IDs, and a fully paginated `labels` string array. Comments, project updates, relations, and history are individual records in their own tables. Comments retain nullable parent IDs and user references, including comments on project updates or other parent types. Issue history retains native transition fields and its issue reference; cycle movement and status-duration calculations happen downstream.\n\nWorkflow state, project status, and label definition streams are outside this package's current scope. Project/team memberships and other paginated associations are not fetched as truncated nested collections. Bounded inline state/status metadata remains raw.\n\n## Sync and recovery\n\nSeven root collections use bounded `updatedAt` filters, `orderBy: updatedAt`, and `includeArchived: true`. Users also request `includeDisabled: true`. Each initial window starts at the configured date, defaulting to the Unix epoch. Subsequent windows replay five minutes before that stream's committed watermark. Comments use their own collection and update timestamp; a comment on an old issue does not require the issue stream to run or its parent timestamp to change.\n\nRelay cursors only continue the current read. `paginate()` owns request retries and rejects repeated continuations; readers validate connections, identities, timestamps, and GraphQL errors, including partial responses. Issues complete all label pages before publishing their label strings. A label retrieval failure leaves only the issues window incomplete.\n\nNewest-first pages do not define a safe timestamp frontier. A window checkpoint advances to its upper cutoff only after all pages and destination writes succeed, including an empty successful window. An interrupted or failed window replays from its lower bound. Mutable row chunks omit explicit immutable IDs so changed provider fields stay eligible on replay.\n\nIssue relations have a root listing without a reliable timestamp filter. Issue history has no workspace-level feed or timestamp filter: its reader independently paginates every accessible issue ID, then each issue's history. Both use the library's `fullSync()` completion checkpoints. Each invocation starts its collection again, and interrupted work replays from the beginning. Their successful completion is journaled even when empty; no parent stream watermark, saved mutable offset, or per-issue scan ledger is used. Full-sync resources ignore date bounds and provide no date-range backfill.\n\nThe API does not guarantee atomic snapshots. Deleted records and removed relations remain stored; missing observations do not generate tombstones. A label rename is not assumed to update every issue's timestamp. Periodic reconciliation refreshes older observations and changes beyond overlap:\n\n```sh\nbunx chkit ingest run --tag provider:linear --tag resource:issues --backfill reconcile-2026-10-05 --from 1970-01-01\nbunx chkit ingest status --tag provider:linear --json\n```\n\nUse a new backfill ID for each reconciliation. Timestamp replay reads current observations, while the separate history stream reads the provider's accessible event records; neither reconstructs an atomic historical workspace snapshot. Run one ingestion process per ClickHouse target at a time.\n\n## Upgrading existing data\n\nVersion `0.2.0` adds eight raw destinations and keeps issue row IDs and the default `linear.issues` stream ID stable. Published `0.1.0` installations may retain nested comment payloads in issue JSON. Those observations are neither removed nor moved automatically: populate the new destinations through their own initial reads and reconcile or deliberately migrate legacy data. Application queries should join the comments table; old embedded fields can remain until their issue is observed again or migrated.\n\n## Fixture tests\n\n```sh\nbunx chkit add linear --with-tests\nbun test src/integrations/linear/tests/basic.test.ts\n```\n\nPortable fixtures exercise independent selection and checkpoints, raw fields and join IDs, complete label names, old-parent comment and history coverage, continuation validation, retries, source/sink failure replay, mutable full reads, and empty completion without live credentials.\n"
+    },
+    {
+      "path": "linear/index.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/index.ts",
+      "content": "export { linearPipeline, createLinearPipeline } from './pipeline.js'\nexport { linear_issuesRaw } from './sources/issues.js'\nexport { linear_commentsRaw } from './sources/comments.js'\nexport { linear_projectsRaw } from './sources/projects.js'\nexport { linear_projectUpdatesRaw } from './sources/project-updates.js'\nexport { linear_cyclesRaw } from './sources/cycles.js'\nexport { linear_usersRaw } from './sources/users.js'\nexport { linear_teamsRaw } from './sources/teams.js'\nexport { linear_issueRelationsRaw } from './sources/issue-relations.js'\nexport { linear_issueHistoryRaw } from './sources/issue-history.js'\n"
+    },
+    {
+      "path": "linear/config.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/config.ts",
+      "content": "export interface LinearConfig {\n  /** Stable, non-secret stream prefix for this installation. */\n  sourceId: string\n  start: Date\n  overlapMs: number\n}\n\n// Source identity and date selection; raw destinations and requested fields live in sources/.\nexport const linearConfig: LinearConfig = {\n  sourceId: 'linear',\n  start: new Date(0),\n  overlapMs: 5 * 60 * 1000,\n}\n"
+    },
+    {
+      "path": "linear/client.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/client.ts",
+      "content": "import { HttpError, IngestConfigError, type ErrorClassifier } from '@chkit/plugin-ingest'\n\nexport type LinearObject = Record<string, unknown>\n\nexport interface LinearClientDeps {\n  fetch: (url: string, init: RequestInit) => Promise<Response>\n  token: () => string | undefined\n}\n\nexport const defaultLinearClientDeps: LinearClientDeps = {\n  fetch: (url, init) => fetch(url, init),\n  token: () => process.env.LINEAR_API_KEY,\n}\n\n/** paginate supplies the executor attempt for each GraphQL page. */\nexport async function graphql(document: string, variables: Record<string, unknown>, signal: AbortSignal, deps: LinearClientDeps): Promise<LinearObject> {\n  const token = deps.token()?.trim()\n  if (!token) throw new IngestConfigError('Set LINEAR_API_KEY.')\n  const response = await deps.fetch('https://api.linear.app/graphql', {\n    method: 'POST', signal: AbortSignal.any([signal, AbortSignal.timeout(30_000)]), redirect: 'error',\n    headers: { Authorization: token, 'Content-Type': 'application/json' },\n    body: JSON.stringify({ query: document, variables }),\n  })\n  if (!response.ok) throw await HttpError.fromResponse(response)\n  const body = requireLinearObject(await response.clone().json(), 'GraphQL response')\n  if (body.errors !== undefined && !Array.isArray(body.errors)) throw new IngestConfigError('Linear GraphQL errors is not an array.')\n  if (Array.isArray(body.errors) && body.errors.length > 0) {\n    const rateLimited = body.errors.some((error: unknown) => isLinearObject(error) &&\n      isLinearObject(error.extensions) && error.extensions.code === 'RATELIMITED')\n    if (rateLimited) throw await HttpError.fromResponse(response)\n    throw new IngestConfigError(`Linear GraphQL returned errors: ${JSON.stringify(body.errors)}`)\n  }\n  return requireLinearObject(body.data, 'GraphQL data')\n}\n\n/** Linear documents HTTP 400 rate errors; preserve GraphQL 200 rate errors too. */\nexport function classifyLinearError(cause: unknown): ReturnType<ErrorClassifier> {\n  if (cause instanceof SyntaxError) return { kind: 'permanent' }\n  if (!(cause instanceof HttpError) || ![200, 400].includes(cause.status) || !/\"code\"\\s*:\\s*\"RATELIMITED\"/.test(cause.body)) return undefined\n  const headers = cause.response.headers\n  const resets = ['requests', 'endpoint-requests', 'complexity'].flatMap((kind) => {\n    if (headers.get(`x-ratelimit-${kind}-remaining`) !== '0') return []\n    const reset = Number(headers.get(`x-ratelimit-${kind}-reset`))\n    return Number.isFinite(reset) && reset > 0 ? [Math.max(0, reset - Date.now())] : []\n  })\n  return { kind: 'rate_limited', retryAfterMs: cause.retryAfterMs ?? (resets.length ? Math.max(...resets) : undefined) }\n}\n\nexport function requireLinearObject(value: unknown, label: string): LinearObject {\n  if (!isLinearObject(value)) throw new IngestConfigError(`Linear ${label} is not an object.`)\n  return value\n}\n\nfunction isLinearObject(value: unknown): value is LinearObject {\n  return typeof value === 'object' && value !== null && !Array.isArray(value)\n}\n"
+    },
+    {
+      "path": "linear/pipeline.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/pipeline.ts",
+      "content": "import { definePipeline, defineStream, fullSync, timestampWindow } from '@chkit/plugin-ingest'\n\nimport { classifyLinearError, defaultLinearClientDeps, type LinearClientDeps } from './client.js'\nimport { linearConfig, type LinearConfig } from './config.js'\nimport { linear_issuesRaw, readIssues } from './sources/issues.js'\nimport { linear_commentsRaw, readComments } from './sources/comments.js'\nimport { linear_projectsRaw, readProjects } from './sources/projects.js'\nimport { linear_projectUpdatesRaw, readProjectUpdates } from './sources/project-updates.js'\nimport { linear_cyclesRaw, readCycles } from './sources/cycles.js'\nimport { linear_usersRaw, readUsers } from './sources/users.js'\nimport { linear_teamsRaw, readTeams } from './sources/teams.js'\nimport { linear_issueRelationsRaw, readIssueRelations } from './sources/issue-relations.js'\nimport { linear_issueHistoryRaw, readIssueHistory } from './sources/issue-history.js'\n\nexport function createLinearPipeline(config: LinearConfig = linearConfig, deps: LinearClientDeps = defaultLinearClientDeps) {\n  const source = { ...config, start: new Date(config.start) }\n  const options = { classifyError: classifyLinearError }\n  return definePipeline({\n    id: source.sourceId, tags: ['provider:linear'], maxStreams: 1, maxFetches: 1,\n    streams: [\n      defineStream({\n        ...options, id: `${source.sourceId}.issues`, tags: ['resource:issues'], destination: linear_issuesRaw,\n        incremental: timestampWindow({ start: source.start, overlapMs: source.overlapMs }),\n        read: (context) => readIssues(context, deps),\n      }),\n      defineStream({\n        ...options, id: `${source.sourceId}.comments`, tags: ['resource:comments'], destination: linear_commentsRaw,\n        incremental: timestampWindow({ start: source.start, overlapMs: source.overlapMs }),\n        read: (context) => readComments(context, deps),\n      }),\n      defineStream({\n        ...options, id: `${source.sourceId}.projects`, tags: ['resource:projects'], destination: linear_projectsRaw,\n        incremental: timestampWindow({ start: source.start, overlapMs: source.overlapMs }),\n        read: (context) => readProjects(context, deps),\n      }),\n      defineStream({\n        ...options, id: `${source.sourceId}.project_updates`, tags: ['resource:project_updates'], destination: linear_projectUpdatesRaw,\n        incremental: timestampWindow({ start: source.start, overlapMs: source.overlapMs }),\n        read: (context) => readProjectUpdates(context, deps),\n      }),\n      defineStream({\n        ...options, id: `${source.sourceId}.cycles`, tags: ['resource:cycles'], destination: linear_cyclesRaw,\n        incremental: timestampWindow({ start: source.start, overlapMs: source.overlapMs }),\n        read: (context) => readCycles(context, deps),\n      }),\n      defineStream({\n        ...options, id: `${source.sourceId}.users`, tags: ['resource:users'], destination: linear_usersRaw,\n        incremental: timestampWindow({ start: source.start, overlapMs: source.overlapMs }),\n        read: (context) => readUsers(context, deps),\n      }),\n      defineStream({\n        ...options, id: `${source.sourceId}.teams`, tags: ['resource:teams'], destination: linear_teamsRaw,\n        incremental: timestampWindow({ start: source.start, overlapMs: source.overlapMs }),\n        read: (context) => readTeams(context, deps),\n      }),\n      defineStream({\n        ...options, id: `${source.sourceId}.issue_relations`, tags: ['resource:issue_relations'], destination: linear_issueRelationsRaw,\n        incremental: fullSync(),\n        read: (context) => readIssueRelations(context, deps),\n      }),\n      defineStream({\n        ...options, id: `${source.sourceId}.issue_history`, tags: ['resource:issue_history'], destination: linear_issueHistoryRaw,\n        incremental: fullSync(),\n        read: (context) => readIssueHistory(context, deps),\n      }),\n    ],\n  })\n}\n\nexport const linearPipeline = createLinearPipeline()\n"
+    },
+    {
+      "path": "linear/sources/issues.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/sources/issues.ts",
+      "content": "import { IngestConfigError, rawRows, rawTable, type FetchContext, type ReadContext, type TimestampRange, type TimestampWindowState } from '@chkit/plugin-ingest'\n\nimport { requireLinearObject, type LinearClientDeps, type LinearObject } from '../client.js'\nimport { linearConnection, linearId, readLinearPages } from './common.js'\n\nconst query = `query Issues($after: String, $from: DateTimeOrDuration!, $to: DateTimeOrDuration!) {\n  issues(first: 100, after: $after, includeArchived: true, orderBy: updatedAt,\n    filter: { updatedAt: { gte: $from, lte: $to } }) {\n    nodes { id identifier number title description url branchName createdAt updatedAt archivedAt\n      startedAt completedAt canceledAt dueDate estimate priority sortOrder subIssueSortOrder\n      team { id } state { id name type color } assignee { id } creator { id }\n      project { id } cycle { id } parent { id }\n      labels(first: 20, includeArchived: true) { nodes { id name } pageInfo { hasNextPage endCursor } }\n    }\n    pageInfo { hasNextPage endCursor }\n  }\n}`\nconst labelsQuery = `query IssueLabels($id: String!, $after: String) {\n  issue(id: $id) { labels(first: 100, after: $after, includeArchived: true) {\n    nodes { id name } pageInfo { hasNextPage endCursor }\n  } }\n}`\n\nexport const linear_issuesRaw = rawTable({ database: 'default', name: 'linear_issues_raw' })\n\nexport async function* readIssues(context: ReadContext<TimestampRange, TimestampWindowState>, deps: LinearClientDeps) {\n  for await (const page of readLinearPages(context, {\n    query, select: (data) => data.issues, label: 'issues', window: context.selection,\n    variables: { from: context.selection.from.toISOString(), to: context.selection.to.toISOString() },\n  }, deps)) {\n    for (const issue of page.items) {\n      const labels = await completeLabels(context, issue, deps)\n      yield { rows: rawRows([{ ...issue, labels }], linearId) }\n    }\n  }\n}\n\n/** Label names are the explicitly requested projection; consume every label page first. */\nasync function completeLabels(context: FetchContext, issue: LinearObject, deps: LinearClientDeps): Promise<string[]> {\n  const first = linearConnection(issue.labels, 'issue labels')\n  const labels = first.items.map(labelName)\n  if (first.next !== undefined) {\n    for await (const page of readLinearPages(context, {\n      query: labelsQuery, variables: { id: linearId(issue) }, initial: first.next, label: 'issue labels',\n      select: (data) => requireLinearObject(data.issue, 'label parent issue').labels,\n    }, deps)) labels.push(...page.items.map(labelName))\n  }\n  return labels\n}\n\nfunction labelName(label: LinearObject): string {\n  if (typeof label.name !== 'string' || !label.name.trim()) throw new IngestConfigError('Linear label has no name.')\n  return label.name\n}\n"
+    },
+    {
+      "path": "linear/sources/common.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/sources/common.ts",
+      "content": "import { IngestConfigError, paginate, type FetchContext, type TimestampRange } from '@chkit/plugin-ingest'\n\nimport { graphql, requireLinearObject, type LinearClientDeps, type LinearObject } from '../client.js'\n\n/** A GraphQL page is one executor-owned attempt; cursors are local to this read. */\nexport function readLinearPages(context: FetchContext, input: {\n  query: string\n  select: (data: LinearObject) => unknown\n  label: string\n  variables?: Record<string, unknown>\n  initial?: string\n  window?: TimestampRange\n}, deps: LinearClientDeps) {\n  return paginate<LinearObject, string>({\n    context, initial: input.initial, label: `POST /graphql ${input.label}`,\n    fetchPage: async (after, signal) => {\n      const data = await graphql(input.query, { ...input.variables, after: after ?? null }, signal, deps)\n      const page = linearConnection(input.select(data), input.label)\n      if (input.window) {\n        for (const item of page.items) {\n          const updated = typeof item.updatedAt === 'string' ? Date.parse(item.updatedAt) : NaN\n          if (!Number.isFinite(updated) || updated < input.window.from.getTime() || updated > input.window.to.getTime()) {\n            throw new IngestConfigError(`Linear ${input.label} has no updatedAt within the requested window.`)\n          }\n        }\n      }\n      return page\n    },\n  })\n}\n\nexport function linearConnection(value: unknown, label: string) {\n  const connection = requireLinearObject(value, `${label} connection`)\n  if (!Array.isArray(connection.nodes)) throw new IngestConfigError(`Linear ${label} nodes is not an array.`)\n  const items = connection.nodes.map((node: unknown) => {\n    const item = requireLinearObject(node, `${label} node`)\n    linearId(item)\n    return item\n  })\n  const page = requireLinearObject(connection.pageInfo, `${label} pageInfo`)\n  if (typeof page.hasNextPage !== 'boolean') throw new IngestConfigError(`Linear ${label} has no hasNextPage flag.`)\n  if (!page.hasNextPage) return { items, next: undefined }\n  if (typeof page.endCursor !== 'string' || !page.endCursor.trim()) {\n    throw new IngestConfigError(`Linear ${label} returned no new cursor.`)\n  }\n  return { items, next: page.endCursor }\n}\n\nexport function linearId(item: LinearObject): string {\n  if (typeof item.id !== 'string' || !item.id.trim()) throw new IngestConfigError('Linear object has no valid ID.')\n  return item.id\n}\n"
+    },
+    {
+      "path": "linear/sources/comments.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/sources/comments.ts",
+      "content": "import { rawRows, rawTable, type ReadContext, type TimestampRange, type TimestampWindowState } from '@chkit/plugin-ingest'\n\nimport type { LinearClientDeps } from '../client.js'\nimport { linearId, readLinearPages } from './common.js'\n\nconst query = `query Comments($after: String, $from: DateTimeOrDuration!, $to: DateTimeOrDuration!) {\n  comments(first: 100, after: $after, includeArchived: true, orderBy: updatedAt,\n    filter: { updatedAt: { gte: $from, lte: $to } }) {\n    nodes { id body url createdAt updatedAt archivedAt editedAt resolvedAt quotedText reactionData\n      issueId projectUpdateId documentContentId initiativeUpdateId projectId initiativeId\n      parentId resolvingCommentId user { id } externalUser { id } resolvingUser { id }\n    }\n    pageInfo { hasNextPage endCursor }\n  }\n}`\n\nexport const linear_commentsRaw = rawTable({ database: 'default', name: 'linear_comments_raw' })\n\nexport async function* readComments(context: ReadContext<TimestampRange, TimestampWindowState>, deps: LinearClientDeps) {\n  for await (const page of readLinearPages(context, {\n    query, select: (data) => data.comments, label: 'comments', window: context.selection,\n    variables: { from: context.selection.from.toISOString(), to: context.selection.to.toISOString() },\n  }, deps)) yield { rows: rawRows(page.items, linearId) }\n}\n"
+    },
+    {
+      "path": "linear/sources/projects.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/sources/projects.ts",
+      "content": "import { rawRows, rawTable, type ReadContext, type TimestampRange, type TimestampWindowState } from '@chkit/plugin-ingest'\n\nimport type { LinearClientDeps } from '../client.js'\nimport { linearId, readLinearPages } from './common.js'\n\nconst query = `query Projects($after: String, $from: DateTimeOrDuration!, $to: DateTimeOrDuration!) {\n  projects(first: 100, after: $after, includeArchived: true, orderBy: updatedAt,\n    filter: { updatedAt: { gte: $from, lte: $to } }) {\n    nodes { id name description content url slugId icon color createdAt updatedAt archivedAt\n      startDate startDateResolution targetDate targetDateResolution startedAt completedAt canceledAt\n      priority sortOrder lead { id } creator { id } status { id name type color }\n    }\n    pageInfo { hasNextPage endCursor }\n  }\n}`\n\nexport const linear_projectsRaw = rawTable({ database: 'default', name: 'linear_projects_raw' })\n\nexport async function* readProjects(context: ReadContext<TimestampRange, TimestampWindowState>, deps: LinearClientDeps) {\n  for await (const page of readLinearPages(context, {\n    query, select: (data) => data.projects, label: 'projects', window: context.selection,\n    variables: { from: context.selection.from.toISOString(), to: context.selection.to.toISOString() },\n  }, deps)) yield { rows: rawRows(page.items, linearId) }\n}\n"
+    },
+    {
+      "path": "linear/sources/project-updates.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/sources/project-updates.ts",
+      "content": "import { rawRows, rawTable, type ReadContext, type TimestampRange, type TimestampWindowState } from '@chkit/plugin-ingest'\n\nimport type { LinearClientDeps } from '../client.js'\nimport { linearId, readLinearPages } from './common.js'\n\nconst query = `query ProjectUpdates($after: String, $from: DateTimeOrDuration!, $to: DateTimeOrDuration!) {\n  projectUpdates(first: 100, after: $after, includeArchived: true, orderBy: updatedAt,\n    filter: { updatedAt: { gte: $from, lte: $to } }) {\n    nodes { id body url slugId health createdAt updatedAt archivedAt editedAt reactionData\n      project { id } user { id }\n    }\n    pageInfo { hasNextPage endCursor }\n  }\n}`\n\nexport const linear_projectUpdatesRaw = rawTable({ database: 'default', name: 'linear_project_updates_raw' })\n\nexport async function* readProjectUpdates(context: ReadContext<TimestampRange, TimestampWindowState>, deps: LinearClientDeps) {\n  for await (const page of readLinearPages(context, {\n    query, select: (data) => data.projectUpdates, label: 'project updates', window: context.selection,\n    variables: { from: context.selection.from.toISOString(), to: context.selection.to.toISOString() },\n  }, deps)) yield { rows: rawRows(page.items, linearId) }\n}\n"
+    },
+    {
+      "path": "linear/sources/cycles.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/sources/cycles.ts",
+      "content": "import { rawRows, rawTable, type ReadContext, type TimestampRange, type TimestampWindowState } from '@chkit/plugin-ingest'\n\nimport type { LinearClientDeps } from '../client.js'\nimport { linearId, readLinearPages } from './common.js'\n\nconst query = `query Cycles($after: String, $from: DateTimeOrDuration!, $to: DateTimeOrDuration!) {\n  cycles(first: 100, after: $after, includeArchived: true, orderBy: updatedAt,\n    filter: { updatedAt: { gte: $from, lte: $to } }) {\n    nodes { id number name description startsAt endsAt completedAt autoArchivedAt\n      createdAt updatedAt archivedAt team { id }\n    }\n    pageInfo { hasNextPage endCursor }\n  }\n}`\n\nexport const linear_cyclesRaw = rawTable({ database: 'default', name: 'linear_cycles_raw' })\n\nexport async function* readCycles(context: ReadContext<TimestampRange, TimestampWindowState>, deps: LinearClientDeps) {\n  for await (const page of readLinearPages(context, {\n    query, select: (data) => data.cycles, label: 'cycles', window: context.selection,\n    variables: { from: context.selection.from.toISOString(), to: context.selection.to.toISOString() },\n  }, deps)) yield { rows: rawRows(page.items, linearId) }\n}\n"
+    },
+    {
+      "path": "linear/sources/users.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/sources/users.ts",
+      "content": "import { rawRows, rawTable, type ReadContext, type TimestampRange, type TimestampWindowState } from '@chkit/plugin-ingest'\n\nimport type { LinearClientDeps } from '../client.js'\nimport { linearId, readLinearPages } from './common.js'\n\nconst query = `query Users($after: String, $from: DateTimeOrDuration!, $to: DateTimeOrDuration!) {\n  users(first: 100, after: $after, includeArchived: true, includeDisabled: true, orderBy: updatedAt,\n    filter: { updatedAt: { gte: $from, lte: $to } }) {\n    nodes { id name displayName email description title avatarUrl url timezone\n      active admin owner guest app disableReason createdAt updatedAt archivedAt organization { id }\n    }\n    pageInfo { hasNextPage endCursor }\n  }\n}`\n\nexport const linear_usersRaw = rawTable({ database: 'default', name: 'linear_users_raw' })\n\nexport async function* readUsers(context: ReadContext<TimestampRange, TimestampWindowState>, deps: LinearClientDeps) {\n  for await (const page of readLinearPages(context, {\n    query, select: (data) => data.users, label: 'users', window: context.selection,\n    variables: { from: context.selection.from.toISOString(), to: context.selection.to.toISOString() },\n  }, deps)) yield { rows: rawRows(page.items, linearId) }\n}\n"
+    },
+    {
+      "path": "linear/sources/teams.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/sources/teams.ts",
+      "content": "import { rawRows, rawTable, type ReadContext, type TimestampRange, type TimestampWindowState } from '@chkit/plugin-ingest'\n\nimport type { LinearClientDeps } from '../client.js'\nimport { linearId, readLinearPages } from './common.js'\n\nconst query = `query Teams($after: String, $from: DateTimeOrDuration!, $to: DateTimeOrDuration!) {\n  teams(first: 100, after: $after, includeArchived: true, orderBy: updatedAt,\n    filter: { updatedAt: { gte: $from, lte: $to } }) {\n    nodes { id name key description icon color timezone visibility retiredAt\n      cyclesEnabled cycleStartDay cycleDuration cycleCooldownTime createdAt updatedAt archivedAt\n      parent { id } organization { id }\n    }\n    pageInfo { hasNextPage endCursor }\n  }\n}`\n\nexport const linear_teamsRaw = rawTable({ database: 'default', name: 'linear_teams_raw' })\n\nexport async function* readTeams(context: ReadContext<TimestampRange, TimestampWindowState>, deps: LinearClientDeps) {\n  for await (const page of readLinearPages(context, {\n    query, select: (data) => data.teams, label: 'teams', window: context.selection,\n    variables: { from: context.selection.from.toISOString(), to: context.selection.to.toISOString() },\n  }, deps)) yield { rows: rawRows(page.items, linearId) }\n}\n"
+    },
+    {
+      "path": "linear/sources/issue-relations.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/sources/issue-relations.ts",
+      "content": "import { rawRows, rawTable, type ReadContext } from '@chkit/plugin-ingest'\n\nimport type { LinearClientDeps } from '../client.js'\nimport { linearId, readLinearPages } from './common.js'\n\nconst query = `query IssueRelations($after: String) {\n  issueRelations(first: 100, after: $after, includeArchived: true, orderBy: updatedAt) {\n    nodes { id type createdAt updatedAt archivedAt issue { id } relatedIssue { id } }\n    pageInfo { hasNextPage endCursor }\n  }\n}`\n\nexport const linear_issueRelationsRaw = rawTable({ database: 'default', name: 'linear_issue_relations_raw' })\n\nexport async function* readIssueRelations(context: ReadContext<undefined, undefined>, deps: LinearClientDeps) {\n  for await (const page of readLinearPages(context, {\n    query, select: (data) => data.issueRelations, label: 'issue relations',\n  }, deps)) yield { rows: rawRows(page.items, linearId) }\n}\n"
+    },
+    {
+      "path": "linear/sources/issue-history.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/sources/issue-history.ts",
+      "content": "import { rawRows, rawTable, type ReadContext } from '@chkit/plugin-ingest'\n\nimport { requireLinearObject, type LinearClientDeps } from '../client.js'\nimport { linearId, readLinearPages } from './common.js'\n\nconst parentsQuery = `query IssueHistoryParents($after: String) {\n  issues(first: 100, after: $after, includeArchived: true, orderBy: updatedAt) {\n    nodes { id } pageInfo { hasNextPage endCursor }\n  }\n}`\nconst historyQuery = `query IssueHistory($id: String!, $after: String) {\n  issue(id: $id) { history(first: 100, after: $after, includeArchived: true, orderBy: updatedAt) {\n    nodes { id createdAt updatedAt archivedAt issue { id } actorId\n      fromTitle toTitle updatedDescription fromAssigneeId toAssigneeId\n      fromPriority toPriority fromEstimate toEstimate fromDueDate toDueDate\n      fromTeamId toTeamId fromParentId toParentId fromStateId toStateId\n      fromCycleId toCycleId fromProjectId toProjectId toConvertedProjectId\n      addedLabelIds removedLabelIds archived trashed autoClosed autoArchived attachmentId\n      fromSlaStartedAt toSlaStartedAt fromSlaBreachesAt toSlaBreachesAt\n      fromSlaBreached toSlaBreached fromSlaType toSlaType\n    }\n    pageInfo { hasNextPage endCursor }\n  } }\n}`\n\nexport const linear_issueHistoryRaw = rawTable({ database: 'default', name: 'linear_issue_history_raw' })\n\n/** Own complete parent discovery: old issues can gain history independently of other streams. */\nexport async function* readIssueHistory(context: ReadContext<undefined, undefined>, deps: LinearClientDeps) {\n  for await (const parents of readLinearPages(context, {\n    query: parentsQuery, select: (data) => data.issues, label: 'history parents',\n  }, deps)) {\n    for (const issue of parents.items) {\n      for await (const page of readLinearPages(context, {\n        query: historyQuery, variables: { id: linearId(issue) }, label: 'issue history',\n        select: (data) => requireLinearObject(data.issue, 'history parent issue').history,\n      }, deps)) yield { rows: rawRows(page.items, linearId) }\n    }\n  }\n}\n"
+    },
+    {
+      "path": "linear/tests/basic.test.ts",
+      "type": "registry:file",
+      "target": "src/integrations/linear/tests/basic.test.ts",
+      "role": "test",
+      "content": "import { expect, test } from 'bun:test'\nimport { IngestConfigError, runIngestion, selectStreams, type FetchContext, type Page } from '@chkit/plugin-ingest'\nimport { createMemoryDestination, createMemoryJournal } from '@chkit/plugin-ingest/testing'\n\nimport { createLinearPipeline, linearPipeline } from '../index.js'\nimport { linearConfig, type LinearConfig } from '../config.js'\nimport type { LinearObject } from '../client.js'\nimport { readLinearPages } from '../sources/common.js'\n\nconst cutoff = new Date('2026-01-02T00:00:00Z')\nconst updatedAt = '2026-01-01T12:00:00Z'\nconst resources = ['issues', 'comments', 'projects', 'project_updates', 'cycles', 'users', 'teams', 'issue_relations', 'issue_history']\nconst timestampResources = resources.slice(0, 7)\nconst issue = { id: 'issue-a', identifier: 'ENG-1', title: 'Archived issue', updatedAt, archivedAt: updatedAt,\n  team: { id: 'team-a' }, assignee: { id: 'user-a' }, project: { id: 'project-a' }, cycle: { id: 'cycle-a' },\n  custom: { retained: true }, labels: connection([{ id: 'label-a', name: 'Bug' }, { id: 'label-b', name: 'Customer' }]) }\nconst comment = { id: 'comment-a', body: 'Discussion', updatedAt, issueId: 'issue-a', projectUpdateId: null, user: { id: 'user-a' }, custom: ['retained'] }\nconst project = { id: 'project-a', name: 'Project', updatedAt, archivedAt: updatedAt, lead: { id: 'user-a' }, status: { id: 'status-a', name: 'Started' }, custom: true }\nconst projectUpdate = { id: 'project-update-a', body: 'Progress', updatedAt, project: { id: 'project-a' }, user: { id: 'user-a' }, custom: true }\nconst cycle = { id: 'cycle-a', number: 7, updatedAt, archivedAt: updatedAt, team: { id: 'team-a' }, custom: true }\nconst user = { id: 'user-a', name: 'Disabled user', updatedAt, active: false, organization: { id: 'organization-a' }, custom: true }\nconst team = { id: 'team-a', key: 'ENG', name: 'Archived team', updatedAt, archivedAt: updatedAt, custom: true }\nconst relation = { id: 'relation-a', type: 'blocks', updatedAt: '2020-01-01T00:00:00Z', issue: { id: 'issue-a' }, relatedIssue: { id: 'issue-b' }, custom: true }\nconst history = { id: 'history-a', updatedAt: '2020-01-01T00:00:00Z', issue: { id: 'issue-a' }, actorId: 'user-a', fromTitle: 'Before', toTitle: 'After', custom: true }\nconst expectedRows = {\n  issues: { ...issue, labels: ['Bug', 'Customer'] }, comments: comment, projects: project, project_updates: projectUpdate,\n  cycles: cycle, users: user, teams: team, issue_relations: relation, issue_history: history,\n}\n\ninterface GraphqlRequest { query: string; variables: Record<string, unknown> }\ntype Responder = (body: GraphqlRequest) => Response | Promise<Response>\ntype Pipeline = ReturnType<typeof createLinearPipeline>\n\ntest('Linear exposes nine independently selectable raw resource tables with provider join identities', async () => {\n  const requests: GraphqlRequest[] = []\n  const pipeline = fixturePipeline((body) => { requests.push(body); return fixtureResponse(body) })\n  expect(linearPipeline.streams).toHaveLength(9)\n  expect(pipeline.streams.map((stream) => stream.id).sort()).toEqual(resources.map((resource) => `linear.${resource}`).sort())\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  const result = await runIngestion(request(pipeline), { journal, destination, now: () => cutoff })\n  expect(result.ok, JSON.stringify(result)).toBe(true)\n  expect(destination.tables.size).toBe(9)\n  for (const [resource, raw] of Object.entries(expectedRows)) {\n    expect(destination.tables.get(`default.linear_${resource}_raw`)?.map(({ id, raw }) => ({ id, raw }))).toEqual([{ id: raw.id, raw }])\n  }\n  for (const body of requests) expect(body.query).toContain('includeArchived: true')\n  expect(requests.find((body) => operation(body) === 'Users')?.query).toContain('includeDisabled: true')\n  expect(requests.find((body) => operation(body) === 'Comments')?.query).toContain('issueId projectUpdateId')\n  expect(requests.find((body) => operation(body) === 'IssueHistory')?.query).toContain('actorId')\n  const bounded = requests.filter((body) => body.variables.from !== undefined)\n  expect(bounded).toHaveLength(7)\n  for (const body of bounded) {\n    expect(body.query).toContain('updatedAt: { gte: $from, lte: $to }')\n    expect(body.query).toContain('orderBy: updatedAt')\n    expect(body.variables).toEqual({ after: null, from: '1970-01-01T00:00:00.000Z', to: cutoff.toISOString() })\n  }\n  for (const resource of timestampResources) {\n    expect((await journal.readCheckpoint(`linear.${resource}`)).envelope?.state).toEqual({ watermark: cutoff.toISOString() })\n  }\n  for (const resource of ['issue_relations', 'issue_history']) {\n    expect((await journal.readCheckpoint(`linear.${resource}`)).envelope).toBeUndefined()\n    expect((await journal.readCheckpoint(`linear.${resource}`)).lastSuccessSeq).toBeGreaterThan(0)\n  }\n})\n\ntest('each resource runs alone and reversing stream order preserves the same observations', async () => {\n  const pipeline = fixturePipeline(), combined = createMemoryDestination()\n  expect((await runIngestion(request({ ...pipeline, streams: [...pipeline.streams].reverse() }),\n    { journal: createMemoryJournal(), destination: combined, now: () => cutoff })).ok).toBe(true)\n  for (const resource of resources) {\n    const destination = createMemoryDestination(), calls: string[] = []\n    const isolated = fixturePipeline((body) => { calls.push(operation(body)); return fixtureResponse(body) })\n    const selected = request(isolated, resource)\n    expect(selected.selected.map((entry) => entry.stream.id)).toEqual([`linear.${resource}`])\n    expect((await runIngestion(selected, { journal: createMemoryJournal(), destination, now: () => cutoff })).ok).toBe(true)\n    expect(destination.tables.size).toBe(1)\n    expect(destination.tables.get(`default.linear_${resource}_raw`)?.map(({ id, raw }) => ({ id, raw })))\n      .toEqual(combined.tables.get(`default.linear_${resource}_raw`)?.map(({ id, raw }) => ({ id, raw })))\n    expect(calls).toHaveLength(resource === 'issue_history' ? 2 : 1)\n  }\n})\n\ntest('Linear page adapters preserve continuations and empty terminal pages', async () => {\n  const signal = new AbortController().signal\n  const context: FetchContext = { signal, attempt: (operation) => operation(signal) }\n  const pages: Page<LinearObject, string>[] = []\n  const afters: unknown[] = []\n  for await (const page of readLinearPages(context, {\n    query: 'query Comments($after: String) { comments(first: 100, after: $after) { nodes { id updatedAt } pageInfo { hasNextPage endCursor } } }',\n    select: (data) => data.comments, label: 'comments', window: { from: new Date(0), to: cutoff },\n  }, {\n    token: () => 'fixture', fetch: async (_url, init) => {\n      const body: GraphqlRequest = JSON.parse(String(init.body))\n      afters.push(body.variables.after)\n      return response('comments', body.variables.after === 'next' ? [comment] : [],\n        body.variables.after === null ? 'next' : body.variables.after === 'next' ? 'terminal' : null)\n    },\n  })) pages.push(page)\n  expect(afters).toEqual([null, 'next', 'terminal'])\n  expect(pages.map((page) => page.items)).toEqual([[], [comment], []])\n  expect(pages.map((page) => page.next)).toEqual(['next', 'terminal', undefined])\n})\n\ntest('comment-only edits use their own update window without discovering or depending on old issues', async () => {\n  let edited = false\n  const requests: GraphqlRequest[] = []\n  const oldIssue = { ...issue, updatedAt: '2020-01-01T00:00:00Z' }\n  const pipeline = fixturePipeline((body) => {\n    requests.push(body)\n    if (operation(body) === 'Issues') return response('issues', edited ? [] : [oldIssue])\n    if (operation(body) === 'Comments') return response('comments', [{ ...comment,\n      body: edited ? 'Edited discussion on an old issue' : 'Original discussion', updatedAt: edited ? '2026-01-02T12:00:00Z' : updatedAt }])\n    throw new IngestConfigError(`Unexpected request: ${operation(body)}`)\n  })\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  const initial = { ...request(pipeline), selected: request(pipeline).selected.filter((entry) => ['linear.issues', 'linear.comments'].includes(entry.stream.id)) }\n  expect((await runIngestion(initial, { journal, destination, now: () => cutoff })).ok).toBe(true)\n  requests.length = 0\n  edited = true\n  expect((await runIngestion(request(pipeline, 'comments'), { journal, destination, now: () => new Date('2026-01-03') })).ok).toBe(true)\n  expect(requests.map(operation)).toEqual(['Comments'])\n  expect(requests[0]?.variables).toEqual({ after: null, from: '2026-01-01T23:55:00.000Z', to: '2026-01-03T00:00:00.000Z' })\n  expect((await journal.readCheckpoint('linear.issues')).envelope?.state).toEqual({ watermark: cutoff.toISOString() })\n  expect((await journal.readCheckpoint('linear.comments')).envelope?.state).toEqual({ watermark: '2026-01-03T00:00:00.000Z' })\n  const rows = destination.tables.get('default.linear_comments_raw') ?? []\n  expect(rows).toHaveLength(2)\n  expect(new Set(rows.map((row) => row.id)).size).toBe(1)\n  expect(rows.at(-1)?.raw).toEqual({ ...comment, body: 'Edited discussion on an old issue', updatedAt: '2026-01-02T12:00:00Z' })\n  requests.length = 0\n  expect((await runIngestion(request(pipeline, 'issues'), { journal, destination, now: () => new Date('2026-01-04') })).ok).toBe(true)\n  expect(requests.map(operation)).toEqual(['Issues'])\n  expect(requests[0]?.variables.from).toBe('2026-01-01T23:55:00.000Z')\n  expect((await journal.readCheckpoint('linear.comments')).envelope?.state).toEqual({ watermark: '2026-01-03T00:00:00.000Z' })\n})\n\ntest('issue labels are complete string arrays across nested pages while issue pages remain independent', async () => {\n  const requests: GraphqlRequest[] = []\n  const nextIssue = { ...issue, id: 'issue-b', labels: connection([]) }\n  const pipeline = fixturePipeline((body) => {\n    requests.push(body)\n    if (operation(body) === 'IssueLabels') return Response.json({ data: { issue: { labels: connection(\n      body.variables.after === 'labels-next' ? [{ id: 'label-b', name: 'Customer' }] : [{ id: 'label-c', name: 'Urgent' }],\n      body.variables.after === 'labels-next' ? 'labels-last' : null) } } })\n    if (body.variables.after) return response('issues', [nextIssue])\n    return response('issues', [{ ...issue, labels: connection([{ id: 'label-a', name: 'Bug' }], 'labels-next') }], 'issues-next')\n  })\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  expect((await runIngestion(request(pipeline, 'issues'), { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect(requests.map(operation)).toEqual(['Issues', 'IssueLabels', 'IssueLabels', 'Issues'])\n  expect(requests.filter((body) => operation(body) === 'IssueLabels').map((body) => body.variables)).toEqual([\n    { id: 'issue-a', after: 'labels-next' }, { id: 'issue-a', after: 'labels-last' },\n  ])\n  expect(requests.every((body) => !body.query.includes('comments('))).toBe(true)\n  expect(destination.tables.get('default.linear_issues_raw')?.map((row) => row.raw)).toEqual([\n    { ...issue, labels: ['Bug', 'Customer', 'Urgent'] }, { ...nextIssue, labels: [] },\n  ])\n  expect((await journal.readCheckpoint('linear.issues')).envelope?.state).toEqual({ watermark: cutoff.toISOString() })\n})\n\ntest('a labels page failure leaves the issue window uncommitted and replays from its first page', async () => {\n  let fail = true\n  const starts: unknown[] = []\n  const pipeline = fixturePipeline((body) => {\n    if (operation(body) === 'IssueLabels') return fail ? Response.json({ errors: [{ message: 'denied' }] })\n      : Response.json({ data: { issue: { labels: connection([{ id: 'label-b', name: 'Customer' }]) } } })\n    starts.push(body.variables.after)\n    return response('issues', [{ ...issue, labels: connection([{ id: 'label-a', name: 'Bug' }], 'labels-next') }])\n  })\n  const journal = createMemoryJournal(), destination = createMemoryDestination(), selected = request(pipeline, 'issues')\n  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(false)\n  expect((await journal.readCheckpoint('linear.issues')).envelope).toBeUndefined()\n  expect(destination.tables.size).toBe(0)\n  fail = false\n  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect(starts).toEqual([null, null])\n  expect(destination.tables.get('default.linear_issues_raw')?.[0]?.raw).toEqual(expectedRows.issues)\n})\n\ntest('a failed comment page does not block any other resource and the next run replays its own window', async () => {\n  let fail = true\n  const starts: unknown[] = []\n  const second = { ...comment, id: 'comment-b' }\n  const pipeline = fixturePipeline((body) => {\n    if (operation(body) !== 'Comments') return fixtureResponse(body)\n    if (body.variables.after) return fail ? new Response('denied', { status: 403 }) : response('comments', [second])\n    starts.push(body.variables.after)\n    return response('comments', [comment], 'comments-next')\n  })\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  const failed = await runIngestion(request(pipeline), { journal, destination, now: () => cutoff })\n  expect(failed.ok).toBe(false)\n  expect(failed.streams.filter((stream) => stream.outcome === 'failed').map((stream) => stream.streamId)).toEqual(['linear.comments'])\n  expect((await journal.readCheckpoint('linear.comments')).envelope).toBeUndefined()\n  for (const resource of resources.filter((resource) => resource !== 'comments')) {\n    expect((await journal.readCheckpoint(`linear.${resource}`)).lastSuccessSeq).toBeGreaterThan(0)\n  }\n  fail = false\n  expect((await runIngestion(request(pipeline, 'comments'), { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect(starts).toEqual([null, null])\n  expect(destination.tables.get('default.linear_comments_raw')?.map((row) => row.id)).toEqual(['comment-a', 'comment-b'])\n  expect((await journal.readCheckpoint('linear.comments')).envelope?.state).toEqual({ watermark: cutoff.toISOString() })\n})\n\ntest('rejected comment writes preserve their prior watermark and replay the unacknowledged update window', async () => {\n  const starts: unknown[] = []\n  const pipeline = fixturePipeline((body) => {\n    starts.push(body.variables.from)\n    return response('comments', [{ ...comment, updatedAt: body.variables.from === '1970-01-01T00:00:00.000Z' ? updatedAt : '2026-01-02T12:00:00Z' }])\n  })\n  const journal = createMemoryJournal(), destination = createMemoryDestination(), selected = request(pipeline, 'comments')\n  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(true)\n  const now = () => new Date('2026-01-03')\n  expect((await runIngestion(selected, { journal, destination: { insert: async () => { throw new IngestConfigError('sink rejected') } }, now })).ok).toBe(false)\n  expect((await journal.readCheckpoint('linear.comments')).envelope?.state).toEqual({ watermark: cutoff.toISOString() })\n  expect((await runIngestion(selected, { journal, destination, now })).ok).toBe(true)\n  expect(starts).toEqual(['1970-01-01T00:00:00.000Z', '2026-01-01T23:55:00.000Z', '2026-01-01T23:55:00.000Z'])\n  expect((await journal.readCheckpoint('linear.comments')).envelope?.state).toEqual({ watermark: now().toISOString() })\n})\n\ntest('empty resources complete independently and timestamp windows overlap while full resources enumerate again', async () => {\n  const requests: GraphqlRequest[] = []\n  const pipeline = fixturePipeline((body) => { requests.push(body); return emptyResponse(body) })\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  for (const now of [cutoff, new Date('2026-01-03')]) {\n    expect((await runIngestion(request(pipeline), { journal, destination, now: () => now })).ok).toBe(true)\n  }\n  expect(destination.tables.size).toBe(0)\n  for (const resource of timestampResources) {\n    expect((await journal.readCheckpoint(`linear.${resource}`)).envelope?.state).toEqual({ watermark: '2026-01-03T00:00:00.000Z' })\n  }\n  const incremental = requests.filter((body) => body.variables.from !== undefined)\n  expect(incremental).toHaveLength(14)\n  expect(incremental.slice(0, 7).every((body) => body.variables.from === '1970-01-01T00:00:00.000Z')).toBe(true)\n  expect(incremental.slice(7).every((body) => body.variables.from === '2026-01-01T23:55:00.000Z')).toBe(true)\n  for (const name of ['IssueRelations', 'IssueHistoryParents']) {\n    const full = requests.filter((body) => operation(body) === name)\n    expect(full).toHaveLength(2)\n    expect(full.every((body) => !body.query.includes('filter:') && body.variables.from === undefined)).toBe(true)\n  }\n  for (const resource of ['issue_relations', 'issue_history']) {\n    expect((await journal.readCheckpoint(`linear.${resource}`)).envelope).toBeUndefined()\n    expect(journal.events.filter((event) => event.namespaceId === `linear.${resource}` && event.eventKind === 'work_finished' && event.workState === 'succeeded')).toHaveLength(2)\n  }\n})\n\ntest('history enumerates all old and archived issues independently and retains paginated history join identities', async () => {\n  const requests: GraphqlRequest[] = []\n  const second = { ...history, id: 'history-b', toTitle: 'Later' }\n  const third = { ...history, id: 'history-c', issue: { id: 'issue-b' } }\n  const pipeline = fixturePipeline((body) => {\n    requests.push(body)\n    if (operation(body) === 'IssueHistoryParents') return response('issues', [{ id: body.variables.after ? 'issue-b' : 'issue-a',\n      updatedAt: '2020-01-01T00:00:00Z', archivedAt: '2020-01-02T00:00:00Z' }], body.variables.after ? null : 'parents-next')\n    return Response.json({ data: { issue: { history: connection(body.variables.id === 'issue-b' ? [third] : body.variables.after ? [second] : [history],\n      body.variables.id === 'issue-a' && !body.variables.after ? 'history-next' : null) } } })\n  })\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  expect((await runIngestion(request(pipeline, 'issue_history'), { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect(requests.map(operation)).toEqual(['IssueHistoryParents', 'IssueHistory', 'IssueHistory', 'IssueHistoryParents', 'IssueHistory'])\n  expect(requests.every((body) => body.variables.from === undefined && !body.query.includes('filter:'))).toBe(true)\n  expect(destination.tables.get('default.linear_issue_history_raw')?.map(({ id, raw }) => ({ id, raw }))).toEqual([history, second, third].map((raw) => ({ id: raw.id, raw })))\n  expect((await journal.readCheckpoint('linear.issues')).lastSuccessSeq).toBe(0)\n  expect((await journal.readCheckpoint('linear.issue_history')).envelope).toBeUndefined()\n})\n\ntest('mutable relation full sync replays its first page after source and sink failures and refreshes old records', async () => {\n  let fail = true, changed = false\n  const starts: unknown[] = []\n  const second = { ...relation, id: 'relation-b' }\n  const pipeline = fixturePipeline((body) => {\n    expect(operation(body)).toBe('IssueRelations')\n    expect(body.variables.from).toBeUndefined()\n    expect(body.query).not.toContain('filter:')\n    if (body.variables.after) return fail ? new Response('denied', { status: 403 }) : response('issueRelations', [second])\n    starts.push(body.variables.after)\n    return response('issueRelations', [{ ...relation, type: changed ? 'duplicate' : relation.type }], 'relations-next')\n  })\n  const journal = createMemoryJournal(), destination = createMemoryDestination(), selected = request(pipeline, 'issue_relations')\n  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(false)\n  expect((await journal.readCheckpoint('linear.issue_relations')).lastSuccessSeq).toBe(0)\n  fail = false\n  expect((await runIngestion(selected, { journal, destination: { insert: async () => { throw new IngestConfigError('sink rejected') } }, now: () => cutoff })).ok).toBe(false)\n  expect((await journal.readCheckpoint('linear.issue_relations')).lastSuccessSeq).toBe(0)\n  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(true)\n  changed = true\n  expect((await runIngestion(selected, { journal, destination, now: () => new Date('2026-01-03') })).ok).toBe(true)\n  expect(starts).toEqual([null, null, null, null])\n  expect((await journal.readCheckpoint('linear.issue_relations')).envelope).toBeUndefined()\n  const rows = destination.tables.get('default.linear_issue_relations_raw') ?? []\n  expect(rows.filter((row) => row.id === relation.id).map((row) => row.raw)).toEqual([relation, { ...relation, type: 'duplicate' }])\n})\n\ntest('history failures replay all parent discovery without recording completion before every history write succeeds', async () => {\n  let fail = true\n  const starts: unknown[] = []\n  const second = { ...history, id: 'history-b', issue: { id: 'issue-b' } }\n  const pipeline = fixturePipeline((body) => {\n    if (operation(body) === 'IssueHistoryParents') {\n      starts.push(body.variables.after)\n      return response('issues', [{ id: 'issue-a' }, { id: 'issue-b' }])\n    }\n    if (body.variables.id === 'issue-b' && fail) return new Response('denied', { status: 403 })\n    return Response.json({ data: { issue: { history: connection(body.variables.id === 'issue-a' ? [history] : [second]) } } })\n  })\n  const journal = createMemoryJournal(), destination = createMemoryDestination(), selected = request(pipeline, 'issue_history')\n  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(false)\n  expect((await journal.readCheckpoint('linear.issue_history')).lastSuccessSeq).toBe(0)\n  expect((await journal.readCheckpoint('linear.issue_history')).envelope).toBeUndefined()\n  fail = false\n  expect((await runIngestion(selected, { journal, destination: { insert: async () => { throw new IngestConfigError('sink rejected') } }, now: () => cutoff })).ok).toBe(false)\n  expect((await journal.readCheckpoint('linear.issue_history')).lastSuccessSeq).toBe(0)\n  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect(starts).toEqual([null, null, null])\n  expect((await journal.readCheckpoint('linear.issue_history')).envelope).toBeUndefined()\n  expect((await journal.readCheckpoint('linear.issue_history')).lastSuccessSeq).toBeGreaterThan(0)\n  expect(destination.tables.get('default.linear_issue_history_raw')?.map(({ id, raw }) => ({ id, raw }))).toEqual([history, second].map((raw) => ({ id: raw.id, raw })))\n  expect((await journal.readCheckpoint('linear.issues')).lastSuccessSeq).toBe(0)\n})\n\ntest('Linear binds custom date selection and isolates each installation and resource checkpoint', async () => {\n  const requests: GraphqlRequest[] = []\n  const config = { ...linearConfig, sourceId: 'linear.fixture', start: new Date('2025-01-01'), overlapMs: 60_000 }\n  const pipeline = createLinearPipeline(config, { token: () => 'bound-token', fetch: async (_url, init) => {\n    expect(new Headers(init.headers).get('authorization')).toBe('bound-token')\n    const body: GraphqlRequest = JSON.parse(String(init.body))\n    requests.push(body)\n    return emptyResponse(body)\n  } })\n  config.start.setUTCFullYear(2000)\n  config.overlapMs = 3_600_000\n  config.sourceId = 'mutated'\n  expect(pipeline.streams.map((stream) => stream.id).sort()).toEqual(resources.map((resource) => `linear.fixture.${resource}`).sort())\n  const failing = createLinearPipeline({ ...linearConfig, sourceId: 'linear.denied' }, { token: () => 'denied', fetch: async () => new Response('denied', { status: 403 }) })\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  const selected = selectStreams([failing, pipeline], ['resource:comments']).map((entry) => ({ ...entry, stream: { ...entry.stream, retry: { retries: 0 } } }))\n  const result = await runIngestion({ selected, backfill: undefined }, { journal, destination, now: () => cutoff })\n  expect(result.streams.map((stream) => stream.outcome)).toEqual(['failed', 'succeeded'])\n  expect(requests[0]?.variables).toEqual({ after: null, from: '2025-01-01T00:00:00.000Z', to: cutoff.toISOString() })\n  expect((await journal.readCheckpoint('linear.denied.comments')).envelope).toBeUndefined()\n  expect((await journal.readCheckpoint('linear.fixture.comments')).envelope?.state).toEqual({ watermark: cutoff.toISOString() })\n  const onlyFixture = selectStreams([failing, pipeline], ['stream:linear.fixture.comments'])\n  expect(onlyFixture.map((entry) => entry.stream.id)).toEqual(['linear.fixture.comments'])\n  expect((await runIngestion({ selected: onlyFixture, backfill: undefined }, { journal, destination, now: () => new Date('2026-01-03') })).ok).toBe(true)\n  expect(requests[1]?.variables.from).toBe('2026-01-01T23:59:00.000Z')\n  expect((await journal.readCheckpoint('linear.fixture.issues')).envelope).toBeUndefined()\n  expect((await journal.readCheckpoint('linear.comments')).envelope).toBeUndefined()\n})\n\ntest('nullable provider comment references retain the comment ID and unmodified raw payload', async () => {\n  const detached = { ...comment, issueId: null, projectUpdateId: 'project-update-a', user: null }\n  const pipeline = fixturePipeline(() => response('comments', [detached]))\n  const destination = createMemoryDestination()\n  expect((await runIngestion(request(pipeline, 'comments'), { journal: createMemoryJournal(), destination, now: () => cutoff })).ok).toBe(true)\n  expect(destination.tables.get('default.linear_comments_raw')?.map(({ id, raw }) => ({ id, raw }))).toEqual([{ id: detached.id, raw: detached }])\n})\n\ntest('GraphQL HTTP400 and HTTP200 rate exhaustion each consume exactly one page retry', async () => {\n  for (const status of [400, 200]) {\n    let attempts = 0\n    const pipeline = fixturePipeline(() => ++attempts === 1\n      ? Response.json({ errors: [{ message: 'rate limit', extensions: { code: 'RATELIMITED' } }] }, { status, headers: { 'Retry-After': '0' } })\n      : response('comments', []))\n    const selected = request(pipeline, 'comments').selected.map((entry) => ({ ...entry, stream: { ...entry.stream, retry: { retries: 1, minTimeout: 0, maxTimeout: 0 } } }))\n    const journal = createMemoryJournal()\n    expect((await runIngestion({ selected, backfill: undefined }, { journal, destination: createMemoryDestination(), now: () => cutoff })).ok).toBe(true)\n    expect(attempts).toBe(2)\n    expect(journal.events.filter((event) => event.eventKind === 'retry_scheduled' && event.errorClass === 'rate_limited')).toHaveLength(1)\n  }\n})\n\ntest('partial GraphQL data with errors cannot write rows, retry, or complete a resource', async () => {\n  for (const resource of ['comments', 'issue_relations', 'issue_history']) {\n    let attempts = 0\n    const pipeline = fixturePipeline((body) => {\n      attempts++\n      return Response.json({ data: operation(body) === 'IssueHistoryParents' ? { issues: connection([{ id: issue.id }]) }\n        : operation(body) === 'Comments' ? { comments: connection([comment]) } : { issueRelations: connection([relation]) },\n      errors: [{ message: 'Some fields were denied', extensions: { code: 'FORBIDDEN' } }] })\n    })\n    const selected = request(pipeline, resource).selected.map((entry) => ({ ...entry, stream: { ...entry.stream, retry: { retries: 1, minTimeout: 0, maxTimeout: 0 } } }))\n    const journal = createMemoryJournal(), destination = createMemoryDestination()\n    expect((await runIngestion({ selected, backfill: undefined }, { journal, destination, now: () => cutoff })).ok).toBe(false)\n    expect(attempts).toBe(1)\n    expect(destination.tables.size).toBe(0)\n    expect((await journal.readCheckpoint(`linear.${resource}`)).lastSuccessSeq).toBe(0)\n    expect(journal.events.filter((event) => event.eventKind === 'retry_scheduled')).toHaveLength(0)\n  }\n})\n\ntest('malformed root and nested continuations fail before another request or successful checkpoint', async () => {\n  for (const name of ['Comments', 'IssueRelations', 'IssueLabels', 'IssueHistoryParents', 'IssueHistory']) {\n    for (const endCursor of [7, ' ', null]) {\n      let attempts = 0\n      const pipeline = fixturePipeline((body) => {\n        if (operation(body) !== name) return precedingResponse(body, name)\n        attempts++\n        return connectionFor(body, { nodes: [], pageInfo: { hasNextPage: true, endCursor } })\n      })\n      const resource = resourceFor(name), journal = createMemoryJournal()\n      const result = await runIngestion(request(pipeline, resource), { journal, destination: createMemoryDestination(), now: () => cutoff })\n      expect(result.ok, `${name}:${String(endCursor)}`).toBe(false)\n      expect(attempts).toBe(1)\n      expect((await journal.readCheckpoint(`linear.${resource}`)).envelope).toBeUndefined()\n      expect((await journal.readCheckpoint(`linear.${resource}`)).lastSuccessSeq).toBe(0)\n    }\n  }\n})\n\ntest('cyclic root and nested pagination fails permanently without replaying a whole reader', async () => {\n  for (const name of ['Comments', 'IssueRelations', 'IssueLabels', 'IssueHistoryParents', 'IssueHistory']) {\n    const afters: unknown[] = []\n    const pipeline = fixturePipeline((body) => {\n      if (operation(body) !== name) return precedingResponse(body, name)\n      afters.push(body.variables.after)\n      return connectionFor(body, connection([], body.variables.after === 'a' ? 'b' : 'a'))\n    })\n    const resource = resourceFor(name), journal = createMemoryJournal()\n    const selected = request(pipeline, resource).selected.map((entry) => ({ ...entry, stream: { ...entry.stream, retry: { retries: 1, minTimeout: 0, maxTimeout: 0 } } }))\n    const result = await runIngestion({ selected, backfill: undefined }, { journal, destination: createMemoryDestination(), now: () => cutoff })\n    expect(result.ok, name).toBe(false)\n    expect(afters).toEqual(name === 'IssueLabels' ? ['a', 'b'] : [null, 'a', 'b'])\n    expect((await journal.readCheckpoint(`linear.${resource}`)).lastSuccessSeq).toBe(0)\n    expect(journal.events.filter((event) => event.eventKind === 'retry_scheduled')).toHaveLength(0)\n  }\n})\n\ntest('a repeated initial label cursor cannot publish the issue or retry its label read', async () => {\n  const afters: unknown[] = []\n  const pipeline = fixturePipeline((body) => {\n    if (operation(body) !== 'IssueLabels') return precedingResponse(body, 'IssueLabels')\n    afters.push(body.variables.after)\n    return connectionFor(body, connection([{ id: 'label-cyclic', name: 'Incomplete' }], 'a'))\n  })\n  const selected = request(pipeline, 'issues').selected.map((entry) => ({\n    ...entry, stream: { ...entry.stream, retry: { retries: 1, minTimeout: 0, maxTimeout: 0 } },\n  }))\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  const result = await runIngestion({ selected, backfill: undefined }, { journal, destination, now: () => cutoff })\n\n  expect(result.ok).toBe(false)\n  expect(result.streams[0]?.error).toContain('repeated continuation')\n  expect(afters).toEqual(['a'])\n  expect(destination.tables.size).toBe(0)\n  expect((await journal.readCheckpoint('linear.issues')).envelope).toBeUndefined()\n  expect((await journal.readCheckpoint('linear.issues')).lastSuccessSeq).toBe(0)\n  expect(journal.events.filter((event) => event.eventKind === 'retry_scheduled')).toHaveLength(0)\n})\n\ntest('malformed connections or provider identities cannot silently complete an empty-looking window', async () => {\n  for (const payload of [\n    { nodes: {}, pageInfo: { hasNextPage: false, endCursor: null } },\n    { nodes: [], pageInfo: { hasNextPage: 'false', endCursor: null } },\n    connection([{ ...comment, id: '' }]), connection([{ ...comment, updatedAt: 'invalid' }]),\n    connection([{ ...comment, updatedAt: '2026-01-03T00:00:00Z' }]),\n  ]) {\n    let attempts = 0\n    const pipeline = fixturePipeline(() => { attempts++; return Response.json({ data: { comments: payload } }) })\n    const journal = createMemoryJournal()\n    expect((await runIngestion(request(pipeline, 'comments'), { journal, destination: createMemoryDestination(), now: () => cutoff })).ok).toBe(false)\n    expect(attempts).toBe(1)\n    expect((await journal.readCheckpoint('linear.comments')).envelope).toBeUndefined()\n  }\n})\n\nfunction fixturePipeline(respond: Responder = fixtureResponse, config: LinearConfig = linearConfig): Pipeline {\n  return createLinearPipeline(config, { token: () => 'fixture', fetch: async (_url, init) => respond(JSON.parse(String(init.body))) })\n}\n\nfunction request(pipeline: Pipeline, resource?: string) {\n  return { selected: selectStreams([pipeline], resource ? [`resource:${resource}`] : []).map((entry) => ({\n    ...entry, stream: { ...entry.stream, batchSize: 1, retry: { retries: 0 } },\n  })), backfill: undefined }\n}\n\nfunction operation(body: GraphqlRequest): string {\n  const name = /query\\s+(\\w+)/.exec(body.query)?.[1]\n  if (!name) throw new IngestConfigError('Fixture received an unnamed GraphQL operation.')\n  return name\n}\n\nfunction fixtureResponse(body: GraphqlRequest): Response {\n  switch (operation(body)) {\n    case 'Issues': return response('issues', [issue])\n    case 'Comments': return response('comments', [comment])\n    case 'Projects': return response('projects', [project])\n    case 'ProjectUpdates': return response('projectUpdates', [projectUpdate])\n    case 'Cycles': return response('cycles', [cycle])\n    case 'Users': return response('users', [user])\n    case 'Teams': return response('teams', [team])\n    case 'IssueRelations': return response('issueRelations', [relation])\n    case 'IssueHistoryParents': return response('issues', [{ id: issue.id, updatedAt: '2020-01-01T00:00:00Z' }])\n    case 'IssueHistory': return Response.json({ data: { issue: { history: connection([history]) } } })\n    default: throw new IngestConfigError(`Unexpected Linear fixture operation: ${operation(body)}`)\n  }\n}\n\nfunction connection(items: readonly unknown[], next: string | null = null) {\n  return { nodes: items, pageInfo: { hasNextPage: next !== null, endCursor: next } }\n}\n\nfunction response(root: string, items: readonly unknown[], next: string | null = null): Response {\n  return Response.json({ data: { [root]: connection(items, next) } })\n}\n\nfunction emptyResponse(body: GraphqlRequest): Response {\n  return connectionFor(body, connection([]))\n}\n\nfunction connectionFor(body: GraphqlRequest, page: unknown): Response {\n  const roots: Record<string, string> = { Issues: 'issues', Comments: 'comments', Projects: 'projects', ProjectUpdates: 'projectUpdates',\n    Cycles: 'cycles', Users: 'users', Teams: 'teams', IssueRelations: 'issueRelations', IssueHistoryParents: 'issues' }\n  const root = roots[operation(body)]\n  if (root) return Response.json({ data: { [root]: page } })\n  if (operation(body) === 'IssueLabels') return Response.json({ data: { issue: { labels: page } } })\n  if (operation(body) === 'IssueHistory') return Response.json({ data: { issue: { history: page } } })\n  throw new IngestConfigError(`Unexpected Linear fixture operation: ${operation(body)}`)\n}\n\nfunction resourceFor(name: string): string {\n  return name === 'Comments' ? 'comments' : name === 'IssueRelations' ? 'issue_relations' : name === 'IssueLabels' ? 'issues' : 'issue_history'\n}\n\nfunction precedingResponse(body: GraphqlRequest, target: string): Response {\n  if (target === 'IssueLabels') return response('issues', [{ ...issue, labels: connection([], 'a') }])\n  return fixtureResponse(body)\n}\n"
+    }
+  ],
+  "meta": {
+    "chkit": {
+      "formatVersion": 1,
+      "version": "0.2.0",
+      "changelog": [
+        {
+          "version": "0.2.0",
+          "changes": [
+            "Sync issues, comments, projects, project updates, cycles, users, and teams through independent overlapping updated-time windows, including archived and disabled resources.",
+            "Add independent full-sync streams for issue relations and issue history; discover and paginate history for all accessible issues without relying on parent stream progress or modification times.",
+            "Store each resource in its own raw table with provider IDs and relationship references; retain complete issue labels as strings and leave joins and metrics to ClickHouse.",
+            "Use shared pagination, validated GraphQL responses, request-level retries and sink-acknowledged completion checkpoints; separate configuration, injectable requests, readers, and pipeline wiring.",
+            "Existing issue IDs remain stable; migrate retained nested comment observations deliberately and populate the eight new destinations through their own initial syncs.",
+            "Consume full pagination pages and use shared continuation-cycle detection while preserving independent resource checkpoints and GraphQL response validation."
+          ]
+        },
+        {
+          "version": "0.1.0",
+          "changes": [
+            "Introduce raw GraphQL issue ingestion."
+          ]
+        }
+      ],
+      "language": "typescript",
+      "license": "MIT",
+      "documentation": "https://chkit.obsessiondb.com/integrations/linear/",
+      "logo": "https://chkit.obsessiondb.com/logos/linear.svg",
+      "authentication": {
+        "method": "Personal API key",
+        "env": [
+          "LINEAR_API_KEY"
+        ],
+        "setup": [
+          "Provide LINEAR_API_KEY with read access to the selected resources.",
+          "Keep the API key in the runtime environment and rotate it according to the provider policy."
+        ],
+        "documentation": "https://linear.app/developers/graphql"
+      },
+      "chkit": "^0.2.0-beta.10",
+      "ingest": "^0.2.0-beta.10",
+      "clickhouse": ">=25.3.0",
+      "root": "src/integrations/linear",
+      "entry": "index.ts",
+      "exports": [
+        "linearPipeline",
+        "createLinearPipeline",
+        "linear_issuesRaw",
+        "linear_commentsRaw",
+        "linear_projectsRaw",
+        "linear_projectUpdatesRaw",
+        "linear_cyclesRaw",
+        "linear_usersRaw",
+        "linear_teamsRaw",
+        "linear_issueRelationsRaw",
+        "linear_issueHistoryRaw"
+      ],
+      "resources": [
+        {
+          "name": "issues",
+          "title": "Issues",
+          "table": "linear_issues_raw",
+          "description": "Archived and active issue fields, relationship IDs, and fully paginated label names as strings.",
+          "scopes": [],
+          "strategy": "timestamp",
+          "endpoints": [
+            {
+              "method": "POST",
+              "path": "/graphql",
+              "documentation": "https://linear.app/developers/graphql"
+            }
+          ]
+        },
+        {
+          "name": "comments",
+          "title": "Comments",
+          "table": "linear_comments_raw",
+          "description": "Raw comments selected by their own update times, with nullable issue and other parent references.",
+          "scopes": [],
+          "strategy": "timestamp",
+          "endpoints": [
+            {
+              "method": "POST",
+              "path": "/graphql",
+              "documentation": "https://linear.app/developers/graphql"
+            }
+          ]
+        },
+        {
+          "name": "projects",
+          "title": "Projects",
+          "table": "linear_projects_raw",
+          "description": "Project metadata and provider relationship references selected by project update times.",
+          "scopes": [],
+          "strategy": "timestamp",
+          "endpoints": [
+            {
+              "method": "POST",
+              "path": "/graphql",
+              "documentation": "https://linear.app/developers/graphql"
+            }
+          ]
+        },
+        {
+          "name": "project_updates",
+          "title": "Project updates",
+          "table": "linear_project_updates_raw",
+          "description": "Authored progress and health updates with project and author references.",
+          "scopes": [],
+          "strategy": "timestamp",
+          "endpoints": [
+            {
+              "method": "POST",
+              "path": "/graphql",
+              "documentation": "https://linear.app/developers/graphql"
+            }
+          ]
+        },
+        {
+          "name": "cycles",
+          "title": "Cycles",
+          "table": "linear_cycles_raw",
+          "description": "Cycle dates, descriptions, and team references selected by cycle update times.",
+          "scopes": [],
+          "strategy": "timestamp",
+          "endpoints": [
+            {
+              "method": "POST",
+              "path": "/graphql",
+              "documentation": "https://linear.app/developers/graphql"
+            }
+          ]
+        },
+        {
+          "name": "users",
+          "title": "Users",
+          "table": "linear_users_raw",
+          "description": "Accessible user metadata, including disabled users, selected by user update times.",
+          "scopes": [],
+          "strategy": "timestamp",
+          "endpoints": [
+            {
+              "method": "POST",
+              "path": "/graphql",
+              "documentation": "https://linear.app/developers/graphql"
+            }
+          ]
+        },
+        {
+          "name": "teams",
+          "title": "Teams",
+          "table": "linear_teams_raw",
+          "description": "Accessible team metadata selected by team update times.",
+          "scopes": [],
+          "strategy": "timestamp",
+          "endpoints": [
+            {
+              "method": "POST",
+              "path": "/graphql",
+              "documentation": "https://linear.app/developers/graphql"
+            }
+          ]
+        },
+        {
+          "name": "issue_relations",
+          "title": "Issue relations",
+          "table": "linear_issue_relations_raw",
+          "description": "Complete accessible relation records with type and both directed issue references; no reliable root change filter exists.",
+          "scopes": [],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "POST",
+              "path": "/graphql",
+              "documentation": "https://linear.app/developers/graphql"
+            }
+          ]
+        },
+        {
+          "name": "issue_history",
+          "title": "Issue history",
+          "table": "linear_issue_history_raw",
+          "description": "Complete accessible history for independently discovered issues; the parent history connection has no timestamp filter.",
+          "scopes": [],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "POST",
+              "path": "/graphql",
+              "documentation": "https://linear.app/developers/graphql"
+            }
+          ]
+        }
+      ],
+      "views": [],
+      "sync": {
+        "description": "One workspace pipeline groups nine independent raw streams. Seven resources use bounded updatedAt windows with five-minute overlap; issue relations and history use fullSync. Each stream completes only after destination acknowledgement.",
+        "schedule": "Run bunx chkit ingest run --tag provider:linear from a scheduler.",
+        "deletions": "Deleted records and removed relations remain stored; absence is not a tombstone. Comments have their own update windows. Periodic reconciliation refreshes older observations and label renames beyond the issue overlap; retained legacy nested comments require deliberate migration."
+      },
+      "env": {
+        "LINEAR_API_KEY": ""
+      },
+      "fileHashes": {
+        "src/integrations/linear/README.md": "50cb9a5a3f93f6b44c80d40059d6b08cd8b1e2e08e909328d340e6b5a0d68c8d",
+        "src/integrations/linear/index.ts": "819a578cd47a80021d7a27fbc27ce25e3b648d45119822d2fedd81f9fa63d83b",
+        "src/integrations/linear/config.ts": "ddc36859b8b51bac3e4a93b94d581d6ad1f2c61aac6b6ce7f09e16ddfb37c73d",
+        "src/integrations/linear/client.ts": "a364e3eb225cd94e60f3a3c8b6e28731e5a61ae872828c1095f5671717adc84b",
+        "src/integrations/linear/pipeline.ts": "5fd9761f638fbcaa9d2a5e8285383126049ccb7f7f304a2297f5e70f40999996",
+        "src/integrations/linear/sources/issues.ts": "c71825ef9f0fb3aeb6a1eaa8cdd283585942651337dbbe4fd268afc37ed6845c",
+        "src/integrations/linear/sources/common.ts": "6cdc12337315141f7fd0a9ae65f535dd545bfc8cbe63151b987ffd98710c590b",
+        "src/integrations/linear/sources/comments.ts": "4ea76019a6cc995b3cee610c8c4740987df88093c6c50d235f9d02e8e3a36d2c",
+        "src/integrations/linear/sources/projects.ts": "0bfc3105bfeaf9e07f8e0256a65a84729a470123b548d5062bba29c60f112b66",
+        "src/integrations/linear/sources/project-updates.ts": "3bb7268a499ff87098b41f0b294c0d63ce9926d0c6bed5a13cc953289c9ebe73",
+        "src/integrations/linear/sources/cycles.ts": "939245e98c416380b22e676a391e429798f20acdbb1c3c61df698884d543fe0b",
+        "src/integrations/linear/sources/users.ts": "ae93d3283c188b68e03266b9b9570c925bdb43e9a217c59295ac056366ee756d",
+        "src/integrations/linear/sources/teams.ts": "2581027a77285d0624d3d9a6f897edc0cc3340281a83a8e768824ab9329c8e79",
+        "src/integrations/linear/sources/issue-relations.ts": "44f539f9234aceba7b5477ca97f2e0a18d03bfac3c9b232f7a1222dbab3a99be",
+        "src/integrations/linear/sources/issue-history.ts": "6d035181b09c8bab4998c4e4b15b22e00d3842f57e37ba8509eb00fc94bd2458",
+        "src/integrations/linear/tests/basic.test.ts": "033ea6f6094eae51711b8820258778e2ca44a6f346e6dc114fcd093df17e745e"
+      }
+    }
+  }
+}
diff --git a/registry/linear/sources/comments.ts b/registry/linear/sources/comments.ts
new file mode 100644
index 00000000..342583a2
--- /dev/null
+++ b/registry/linear/sources/comments.ts
@@ -0,0 +1,24 @@
+import { rawRows, rawTable, type ReadContext, type TimestampRange, type TimestampWindowState } from '@chkit/plugin-ingest'
+
+import type { LinearClientDeps } from '../client.js'
+import { linearId, readLinearPages } from './common.js'
+
+const query = `query Comments($after: String, $from: DateTimeOrDuration!, $to: DateTimeOrDuration!) {
+  comments(first: 100, after: $after, includeArchived: true, orderBy: updatedAt,
+    filter: { updatedAt: { gte: $from, lte: $to } }) {
+    nodes { id body url createdAt updatedAt archivedAt editedAt resolvedAt quotedText reactionData
+      issueId projectUpdateId documentContentId initiativeUpdateId projectId initiativeId
+      parentId resolvingCommentId user { id } externalUser { id } resolvingUser { id }
+    }
+    pageInfo { hasNextPage endCursor }
+  }
+}`
+
+export const linear_commentsRaw = rawTable({ database: 'default', name: 'linear_comments_raw' })
+
+export async function* readComments(context: ReadContext<TimestampRange, TimestampWindowState>, deps: LinearClientDeps) {
+  for await (const page of readLinearPages(context, {
+    query, select: (data) => data.comments, label: 'comments', window: context.selection,
+    variables: { from: context.selection.from.toISOString(), to: context.selection.to.toISOString() },
+  }, deps)) yield { rows: rawRows(page.items, linearId) }
+}
diff --git a/registry/linear/sources/common.ts b/registry/linear/sources/common.ts
new file mode 100644
index 00000000..268d3bcc
--- /dev/null
+++ b/registry/linear/sources/common.ts
@@ -0,0 +1,52 @@
+import { IngestConfigError, paginate, type FetchContext, type TimestampRange } from '@chkit/plugin-ingest'
+
+import { graphql, requireLinearObject, type LinearClientDeps, type LinearObject } from '../client.js'
+
+/** A GraphQL page is one executor-owned attempt; cursors are local to this read. */
+export function readLinearPages(context: FetchContext, input: {
+  query: string
+  select: (data: LinearObject) => unknown
+  label: string
+  variables?: Record<string, unknown>
+  initial?: string
+  window?: TimestampRange
+}, deps: LinearClientDeps) {
+  return paginate<LinearObject, string>({
+    context, initial: input.initial, label: `POST /graphql ${input.label}`,
+    fetchPage: async (after, signal) => {
+      const data = await graphql(input.query, { ...input.variables, after: after ?? null }, signal, deps)
+      const page = linearConnection(input.select(data), input.label)
+      if (input.window) {
+        for (const item of page.items) {
+          const updated = typeof item.updatedAt === 'string' ? Date.parse(item.updatedAt) : NaN
+          if (!Number.isFinite(updated) || updated < input.window.from.getTime() || updated > input.window.to.getTime()) {
+            throw new IngestConfigError(`Linear ${input.label} has no updatedAt within the requested window.`)
+          }
+        }
+      }
+      return page
+    },
+  })
+}
+
+export function linearConnection(value: unknown, label: string) {
+  const connection = requireLinearObject(value, `${label} connection`)
+  if (!Array.isArray(connection.nodes)) throw new IngestConfigError(`Linear ${label} nodes is not an array.`)
+  const items = connection.nodes.map((node: unknown) => {
+    const item = requireLinearObject(node, `${label} node`)
+    linearId(item)
+    return item
+  })
+  const page = requireLinearObject(connection.pageInfo, `${label} pageInfo`)
+  if (typeof page.hasNextPage !== 'boolean') throw new IngestConfigError(`Linear ${label} has no hasNextPage flag.`)
+  if (!page.hasNextPage) return { items, next: undefined }
+  if (typeof page.endCursor !== 'string' || !page.endCursor.trim()) {
+    throw new IngestConfigError(`Linear ${label} returned no new cursor.`)
+  }
+  return { items, next: page.endCursor }
+}
+
+export function linearId(item: LinearObject): string {
+  if (typeof item.id !== 'string' || !item.id.trim()) throw new IngestConfigError('Linear object has no valid ID.')
+  return item.id
+}
diff --git a/registry/linear/sources/cycles.ts b/registry/linear/sources/cycles.ts
new file mode 100644
index 00000000..35c0bed8
--- /dev/null
+++ b/registry/linear/sources/cycles.ts
@@ -0,0 +1,23 @@
+import { rawRows, rawTable, type ReadContext, type TimestampRange, type TimestampWindowState } from '@chkit/plugin-ingest'
+
+import type { LinearClientDeps } from '../client.js'
+import { linearId, readLinearPages } from './common.js'
+
+const query = `query Cycles($after: String, $from: DateTimeOrDuration!, $to: DateTimeOrDuration!) {
+  cycles(first: 100, after: $after, includeArchived: true, orderBy: updatedAt,
+    filter: { updatedAt: { gte: $from, lte: $to } }) {
+    nodes { id number name description startsAt endsAt completedAt autoArchivedAt
+      createdAt updatedAt archivedAt team { id }
+    }
+    pageInfo { hasNextPage endCursor }
+  }
+}`
+
+export const linear_cyclesRaw = rawTable({ database: 'default', name: 'linear_cycles_raw' })
+
+export async function* readCycles(context: ReadContext<TimestampRange, TimestampWindowState>, deps: LinearClientDeps) {
+  for await (const page of readLinearPages(context, {
+    query, select: (data) => data.cycles, label: 'cycles', window: context.selection,
+    variables: { from: context.selection.from.toISOString(), to: context.selection.to.toISOString() },
+  }, deps)) yield { rows: rawRows(page.items, linearId) }
+}
diff --git a/registry/linear/sources/issue-history.ts b/registry/linear/sources/issue-history.ts
new file mode 100644
index 00000000..a3b8a740
--- /dev/null
+++ b/registry/linear/sources/issue-history.ts
@@ -0,0 +1,40 @@
+import { rawRows, rawTable, type ReadContext } from '@chkit/plugin-ingest'
+
+import { requireLinearObject, type LinearClientDeps } from '../client.js'
+import { linearId, readLinearPages } from './common.js'
+
+const parentsQuery = `query IssueHistoryParents($after: String) {
+  issues(first: 100, after: $after, includeArchived: true, orderBy: updatedAt) {
+    nodes { id } pageInfo { hasNextPage endCursor }
+  }
+}`
+const historyQuery = `query IssueHistory($id: String!, $after: String) {
+  issue(id: $id) { history(first: 100, after: $after, includeArchived: true, orderBy: updatedAt) {
+    nodes { id createdAt updatedAt archivedAt issue { id } actorId
+      fromTitle toTitle updatedDescription fromAssigneeId toAssigneeId
+      fromPriority toPriority fromEstimate toEstimate fromDueDate toDueDate
+      fromTeamId toTeamId fromParentId toParentId fromStateId toStateId
+      fromCycleId toCycleId fromProjectId toProjectId toConvertedProjectId
+      addedLabelIds removedLabelIds archived trashed autoClosed autoArchived attachmentId
+      fromSlaStartedAt toSlaStartedAt fromSlaBreachesAt toSlaBreachesAt
+      fromSlaBreached toSlaBreached fromSlaType toSlaType
+    }
+    pageInfo { hasNextPage endCursor }
+  } }
+}`
+
+export const linear_issueHistoryRaw = rawTable({ database: 'default', name: 'linear_issue_history_raw' })
+
+/** Own complete parent discovery: old issues can gain history independently of other streams. */
+export async function* readIssueHistory(context: ReadContext<undefined, undefined>, deps: LinearClientDeps) {
+  for await (const parents of readLinearPages(context, {
+    query: parentsQuery, select: (data) => data.issues, label: 'history parents',
+  }, deps)) {
+    for (const issue of parents.items) {
+      for await (const page of readLinearPages(context, {
+        query: historyQuery, variables: { id: linearId(issue) }, label: 'issue history',
+        select: (data) => requireLinearObject(data.issue, 'history parent issue').history,
+      }, deps)) yield { rows: rawRows(page.items, linearId) }
+    }
+  }
+}
diff --git a/registry/linear/sources/issue-relations.ts b/registry/linear/sources/issue-relations.ts
new file mode 100644
index 00000000..4a04c08c
--- /dev/null
+++ b/registry/linear/sources/issue-relations.ts
@@ -0,0 +1,19 @@
+import { rawRows, rawTable, type ReadContext } from '@chkit/plugin-ingest'
+
+import type { LinearClientDeps } from '../client.js'
+import { linearId, readLinearPages } from './common.js'
+
+const query = `query IssueRelations($after: String) {
+  issueRelations(first: 100, after: $after, includeArchived: true, orderBy: updatedAt) {
+    nodes { id type createdAt updatedAt archivedAt issue { id } relatedIssue { id } }
+    pageInfo { hasNextPage endCursor }
+  }
+}`
+
+export const linear_issueRelationsRaw = rawTable({ database: 'default', name: 'linear_issue_relations_raw' })
+
+export async function* readIssueRelations(context: ReadContext<undefined, undefined>, deps: LinearClientDeps) {
+  for await (const page of readLinearPages(context, {
+    query, select: (data) => data.issueRelations, label: 'issue relations',
+  }, deps)) yield { rows: rawRows(page.items, linearId) }
+}
diff --git a/registry/linear/sources/issues.ts b/registry/linear/sources/issues.ts
new file mode 100644
index 00000000..377a2754
--- /dev/null
+++ b/registry/linear/sources/issues.ts
@@ -0,0 +1,54 @@
+import { IngestConfigError, rawRows, rawTable, type FetchContext, type ReadContext, type TimestampRange, type TimestampWindowState } from '@chkit/plugin-ingest'
+
+import { requireLinearObject, type LinearClientDeps, type LinearObject } from '../client.js'
+import { linearConnection, linearId, readLinearPages } from './common.js'
+
+const query = `query Issues($after: String, $from: DateTimeOrDuration!, $to: DateTimeOrDuration!) {
+  issues(first: 100, after: $after, includeArchived: true, orderBy: updatedAt,
+    filter: { updatedAt: { gte: $from, lte: $to } }) {
+    nodes { id identifier number title description url branchName createdAt updatedAt archivedAt
+      startedAt completedAt canceledAt dueDate estimate priority sortOrder subIssueSortOrder
+      team { id } state { id name type color } assignee { id } creator { id }
+      project { id } cycle { id } parent { id }
+      labels(first: 20, includeArchived: true) { nodes { id name } pageInfo { hasNextPage endCursor } }
+    }
+    pageInfo { hasNextPage endCursor }
+  }
+}`
+const labelsQuery = `query IssueLabels($id: String!, $after: String) {
+  issue(id: $id) { labels(first: 100, after: $after, includeArchived: true) {
+    nodes { id name } pageInfo { hasNextPage endCursor }
+  } }
+}`
+
+export const linear_issuesRaw = rawTable({ database: 'default', name: 'linear_issues_raw' })
+
+export async function* readIssues(context: ReadContext<TimestampRange, TimestampWindowState>, deps: LinearClientDeps) {
+  for await (const page of readLinearPages(context, {
+    query, select: (data) => data.issues, label: 'issues', window: context.selection,
+    variables: { from: context.selection.from.toISOString(), to: context.selection.to.toISOString() },
+  }, deps)) {
+    for (const issue of page.items) {
+      const labels = await completeLabels(context, issue, deps)
+      yield { rows: rawRows([{ ...issue, labels }], linearId) }
+    }
+  }
+}
+
+/** Label names are the explicitly requested projection; consume every label page first. */
+async function completeLabels(context: FetchContext, issue: LinearObject, deps: LinearClientDeps): Promise<string[]> {
+  const first = linearConnection(issue.labels, 'issue labels')
+  const labels = first.items.map(labelName)
+  if (first.next !== undefined) {
+    for await (const page of readLinearPages(context, {
+      query: labelsQuery, variables: { id: linearId(issue) }, initial: first.next, label: 'issue labels',
+      select: (data) => requireLinearObject(data.issue, 'label parent issue').labels,
+    }, deps)) labels.push(...page.items.map(labelName))
+  }
+  return labels
+}
+
+function labelName(label: LinearObject): string {
+  if (typeof label.name !== 'string' || !label.name.trim()) throw new IngestConfigError('Linear label has no name.')
+  return label.name
+}
diff --git a/registry/linear/sources/project-updates.ts b/registry/linear/sources/project-updates.ts
new file mode 100644
index 00000000..dda80331
--- /dev/null
+++ b/registry/linear/sources/project-updates.ts
@@ -0,0 +1,23 @@
+import { rawRows, rawTable, type ReadContext, type TimestampRange, type TimestampWindowState } from '@chkit/plugin-ingest'
+
+import type { LinearClientDeps } from '../client.js'
+import { linearId, readLinearPages } from './common.js'
+
+const query = `query ProjectUpdates($after: String, $from: DateTimeOrDuration!, $to: DateTimeOrDuration!) {
+  projectUpdates(first: 100, after: $after, includeArchived: true, orderBy: updatedAt,
+    filter: { updatedAt: { gte: $from, lte: $to } }) {
+    nodes { id body url slugId health createdAt updatedAt archivedAt editedAt reactionData
+      project { id } user { id }
+    }
+    pageInfo { hasNextPage endCursor }
+  }
+}`
+
+export const linear_projectUpdatesRaw = rawTable({ database: 'default', name: 'linear_project_updates_raw' })
+
+export async function* readProjectUpdates(context: ReadContext<TimestampRange, TimestampWindowState>, deps: LinearClientDeps) {
+  for await (const page of readLinearPages(context, {
+    query, select: (data) => data.projectUpdates, label: 'project updates', window: context.selection,
+    variables: { from: context.selection.from.toISOString(), to: context.selection.to.toISOString() },
+  }, deps)) yield { rows: rawRows(page.items, linearId) }
+}
diff --git a/registry/linear/sources/projects.ts b/registry/linear/sources/projects.ts
new file mode 100644
index 00000000..c7720c19
--- /dev/null
+++ b/registry/linear/sources/projects.ts
@@ -0,0 +1,24 @@
+import { rawRows, rawTable, type ReadContext, type TimestampRange, type TimestampWindowState } from '@chkit/plugin-ingest'
+
+import type { LinearClientDeps } from '../client.js'
+import { linearId, readLinearPages } from './common.js'
+
+const query = `query Projects($after: String, $from: DateTimeOrDuration!, $to: DateTimeOrDuration!) {
+  projects(first: 100, after: $after, includeArchived: true, orderBy: updatedAt,
+    filter: { updatedAt: { gte: $from, lte: $to } }) {
+    nodes { id name description content url slugId icon color createdAt updatedAt archivedAt
+      startDate startDateResolution targetDate targetDateResolution startedAt completedAt canceledAt
+      priority sortOrder lead { id } creator { id } status { id name type color }
+    }
+    pageInfo { hasNextPage endCursor }
+  }
+}`
+
+export const linear_projectsRaw = rawTable({ database: 'default', name: 'linear_projects_raw' })
+
+export async function* readProjects(context: ReadContext<TimestampRange, TimestampWindowState>, deps: LinearClientDeps) {
+  for await (const page of readLinearPages(context, {
+    query, select: (data) => data.projects, label: 'projects', window: context.selection,
+    variables: { from: context.selection.from.toISOString(), to: context.selection.to.toISOString() },
+  }, deps)) yield { rows: rawRows(page.items, linearId) }
+}
diff --git a/registry/linear/sources/teams.ts b/registry/linear/sources/teams.ts
new file mode 100644
index 00000000..1caf0a7c
--- /dev/null
+++ b/registry/linear/sources/teams.ts
@@ -0,0 +1,24 @@
+import { rawRows, rawTable, type ReadContext, type TimestampRange, type TimestampWindowState } from '@chkit/plugin-ingest'
+
+import type { LinearClientDeps } from '../client.js'
+import { linearId, readLinearPages } from './common.js'
+
+const query = `query Teams($after: String, $from: DateTimeOrDuration!, $to: DateTimeOrDuration!) {
+  teams(first: 100, after: $after, includeArchived: true, orderBy: updatedAt,
+    filter: { updatedAt: { gte: $from, lte: $to } }) {
+    nodes { id name key description icon color timezone visibility retiredAt
+      cyclesEnabled cycleStartDay cycleDuration cycleCooldownTime createdAt updatedAt archivedAt
+      parent { id } organization { id }
+    }
+    pageInfo { hasNextPage endCursor }
+  }
+}`
+
+export const linear_teamsRaw = rawTable({ database: 'default', name: 'linear_teams_raw' })
+
+export async function* readTeams(context: ReadContext<TimestampRange, TimestampWindowState>, deps: LinearClientDeps) {
+  for await (const page of readLinearPages(context, {
+    query, select: (data) => data.teams, label: 'teams', window: context.selection,
+    variables: { from: context.selection.from.toISOString(), to: context.selection.to.toISOString() },
+  }, deps)) yield { rows: rawRows(page.items, linearId) }
+}
diff --git a/registry/linear/sources/users.ts b/registry/linear/sources/users.ts
new file mode 100644
index 00000000..8ab3bc65
--- /dev/null
+++ b/registry/linear/sources/users.ts
@@ -0,0 +1,23 @@
+import { rawRows, rawTable, type ReadContext, type TimestampRange, type TimestampWindowState } from '@chkit/plugin-ingest'
+
+import type { LinearClientDeps } from '../client.js'
+import { linearId, readLinearPages } from './common.js'
+
+const query = `query Users($after: String, $from: DateTimeOrDuration!, $to: DateTimeOrDuration!) {
+  users(first: 100, after: $after, includeArchived: true, includeDisabled: true, orderBy: updatedAt,
+    filter: { updatedAt: { gte: $from, lte: $to } }) {
+    nodes { id name displayName email description title avatarUrl url timezone
+      active admin owner guest app disableReason createdAt updatedAt archivedAt organization { id }
+    }
+    pageInfo { hasNextPage endCursor }
+  }
+}`
+
+export const linear_usersRaw = rawTable({ database: 'default', name: 'linear_users_raw' })
+
+export async function* readUsers(context: ReadContext<TimestampRange, TimestampWindowState>, deps: LinearClientDeps) {
+  for await (const page of readLinearPages(context, {
+    query, select: (data) => data.users, label: 'users', window: context.selection,
+    variables: { from: context.selection.from.toISOString(), to: context.selection.to.toISOString() },
+  }, deps)) yield { rows: rawRows(page.items, linearId) }
+}
diff --git a/registry/linear/tests/basic.test.ts b/registry/linear/tests/basic.test.ts
new file mode 100644
index 00000000..02bd0941
--- /dev/null
+++ b/registry/linear/tests/basic.test.ts
@@ -0,0 +1,526 @@
+import { expect, test } from 'bun:test'
+import { IngestConfigError, runIngestion, selectStreams, type FetchContext, type Page } from '@chkit/plugin-ingest'
+import { createMemoryDestination, createMemoryJournal } from '@chkit/plugin-ingest/testing'
+
+import { createLinearPipeline, linearPipeline } from '../index.js'
+import { linearConfig, type LinearConfig } from '../config.js'
+import type { LinearObject } from '../client.js'
+import { readLinearPages } from '../sources/common.js'
+
+const cutoff = new Date('2026-01-02T00:00:00Z')
+const updatedAt = '2026-01-01T12:00:00Z'
+const resources = ['issues', 'comments', 'projects', 'project_updates', 'cycles', 'users', 'teams', 'issue_relations', 'issue_history']
+const timestampResources = resources.slice(0, 7)
+const issue = { id: 'issue-a', identifier: 'ENG-1', title: 'Archived issue', updatedAt, archivedAt: updatedAt,
+  team: { id: 'team-a' }, assignee: { id: 'user-a' }, project: { id: 'project-a' }, cycle: { id: 'cycle-a' },
+  custom: { retained: true }, labels: connection([{ id: 'label-a', name: 'Bug' }, { id: 'label-b', name: 'Customer' }]) }
+const comment = { id: 'comment-a', body: 'Discussion', updatedAt, issueId: 'issue-a', projectUpdateId: null, user: { id: 'user-a' }, custom: ['retained'] }
+const project = { id: 'project-a', name: 'Project', updatedAt, archivedAt: updatedAt, lead: { id: 'user-a' }, status: { id: 'status-a', name: 'Started' }, custom: true }
+const projectUpdate = { id: 'project-update-a', body: 'Progress', updatedAt, project: { id: 'project-a' }, user: { id: 'user-a' }, custom: true }
+const cycle = { id: 'cycle-a', number: 7, updatedAt, archivedAt: updatedAt, team: { id: 'team-a' }, custom: true }
+const user = { id: 'user-a', name: 'Disabled user', updatedAt, active: false, organization: { id: 'organization-a' }, custom: true }
+const team = { id: 'team-a', key: 'ENG', name: 'Archived team', updatedAt, archivedAt: updatedAt, custom: true }
+const relation = { id: 'relation-a', type: 'blocks', updatedAt: '2020-01-01T00:00:00Z', issue: { id: 'issue-a' }, relatedIssue: { id: 'issue-b' }, custom: true }
+const history = { id: 'history-a', updatedAt: '2020-01-01T00:00:00Z', issue: { id: 'issue-a' }, actorId: 'user-a', fromTitle: 'Before', toTitle: 'After', custom: true }
+const expectedRows = {
+  issues: { ...issue, labels: ['Bug', 'Customer'] }, comments: comment, projects: project, project_updates: projectUpdate,
+  cycles: cycle, users: user, teams: team, issue_relations: relation, issue_history: history,
+}
+
+interface GraphqlRequest { query: string; variables: Record<string, unknown> }
+type Responder = (body: GraphqlRequest) => Response | Promise<Response>
+type Pipeline = ReturnType<typeof createLinearPipeline>
+
+test('Linear exposes nine independently selectable raw resource tables with provider join identities', async () => {
+  const requests: GraphqlRequest[] = []
+  const pipeline = fixturePipeline((body) => { requests.push(body); return fixtureResponse(body) })
+  expect(linearPipeline.streams).toHaveLength(9)
+  expect(pipeline.streams.map((stream) => stream.id).sort()).toEqual(resources.map((resource) => `linear.${resource}`).sort())
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  const result = await runIngestion(request(pipeline), { journal, destination, now: () => cutoff })
+  expect(result.ok, JSON.stringify(result)).toBe(true)
+  expect(destination.tables.size).toBe(9)
+  for (const [resource, raw] of Object.entries(expectedRows)) {
+    expect(destination.tables.get(`default.linear_${resource}_raw`)?.map(({ id, raw }) => ({ id, raw }))).toEqual([{ id: raw.id, raw }])
+  }
+  for (const body of requests) expect(body.query).toContain('includeArchived: true')
+  expect(requests.find((body) => operation(body) === 'Users')?.query).toContain('includeDisabled: true')
+  expect(requests.find((body) => operation(body) === 'Comments')?.query).toContain('issueId projectUpdateId')
+  expect(requests.find((body) => operation(body) === 'IssueHistory')?.query).toContain('actorId')
+  const bounded = requests.filter((body) => body.variables.from !== undefined)
+  expect(bounded).toHaveLength(7)
+  for (const body of bounded) {
+    expect(body.query).toContain('updatedAt: { gte: $from, lte: $to }')
+    expect(body.query).toContain('orderBy: updatedAt')
+    expect(body.variables).toEqual({ after: null, from: '1970-01-01T00:00:00.000Z', to: cutoff.toISOString() })
+  }
+  for (const resource of timestampResources) {
+    expect((await journal.readCheckpoint(`linear.${resource}`)).envelope?.state).toEqual({ watermark: cutoff.toISOString() })
+  }
+  for (const resource of ['issue_relations', 'issue_history']) {
+    expect((await journal.readCheckpoint(`linear.${resource}`)).envelope).toBeUndefined()
+    expect((await journal.readCheckpoint(`linear.${resource}`)).lastSuccessSeq).toBeGreaterThan(0)
+  }
+})
+
+test('each resource runs alone and reversing stream order preserves the same observations', async () => {
+  const pipeline = fixturePipeline(), combined = createMemoryDestination()
+  expect((await runIngestion(request({ ...pipeline, streams: [...pipeline.streams].reverse() }),
+    { journal: createMemoryJournal(), destination: combined, now: () => cutoff })).ok).toBe(true)
+  for (const resource of resources) {
+    const destination = createMemoryDestination(), calls: string[] = []
+    const isolated = fixturePipeline((body) => { calls.push(operation(body)); return fixtureResponse(body) })
+    const selected = request(isolated, resource)
+    expect(selected.selected.map((entry) => entry.stream.id)).toEqual([`linear.${resource}`])
+    expect((await runIngestion(selected, { journal: createMemoryJournal(), destination, now: () => cutoff })).ok).toBe(true)
+    expect(destination.tables.size).toBe(1)
+    expect(destination.tables.get(`default.linear_${resource}_raw`)?.map(({ id, raw }) => ({ id, raw })))
+      .toEqual(combined.tables.get(`default.linear_${resource}_raw`)?.map(({ id, raw }) => ({ id, raw })))
+    expect(calls).toHaveLength(resource === 'issue_history' ? 2 : 1)
+  }
+})
+
+test('Linear page adapters preserve continuations and empty terminal pages', async () => {
+  const signal = new AbortController().signal
+  const context: FetchContext = { signal, attempt: (operation) => operation(signal) }
+  const pages: Page<LinearObject, string>[] = []
+  const afters: unknown[] = []
+  for await (const page of readLinearPages(context, {
+    query: 'query Comments($after: String) { comments(first: 100, after: $after) { nodes { id updatedAt } pageInfo { hasNextPage endCursor } } }',
+    select: (data) => data.comments, label: 'comments', window: { from: new Date(0), to: cutoff },
+  }, {
+    token: () => 'fixture', fetch: async (_url, init) => {
+      const body: GraphqlRequest = JSON.parse(String(init.body))
+      afters.push(body.variables.after)
+      return response('comments', body.variables.after === 'next' ? [comment] : [],
+        body.variables.after === null ? 'next' : body.variables.after === 'next' ? 'terminal' : null)
+    },
+  })) pages.push(page)
+  expect(afters).toEqual([null, 'next', 'terminal'])
+  expect(pages.map((page) => page.items)).toEqual([[], [comment], []])
+  expect(pages.map((page) => page.next)).toEqual(['next', 'terminal', undefined])
+})
+
+test('comment-only edits use their own update window without discovering or depending on old issues', async () => {
+  let edited = false
+  const requests: GraphqlRequest[] = []
+  const oldIssue = { ...issue, updatedAt: '2020-01-01T00:00:00Z' }
+  const pipeline = fixturePipeline((body) => {
+    requests.push(body)
+    if (operation(body) === 'Issues') return response('issues', edited ? [] : [oldIssue])
+    if (operation(body) === 'Comments') return response('comments', [{ ...comment,
+      body: edited ? 'Edited discussion on an old issue' : 'Original discussion', updatedAt: edited ? '2026-01-02T12:00:00Z' : updatedAt }])
+    throw new IngestConfigError(`Unexpected request: ${operation(body)}`)
+  })
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  const initial = { ...request(pipeline), selected: request(pipeline).selected.filter((entry) => ['linear.issues', 'linear.comments'].includes(entry.stream.id)) }
+  expect((await runIngestion(initial, { journal, destination, now: () => cutoff })).ok).toBe(true)
+  requests.length = 0
+  edited = true
+  expect((await runIngestion(request(pipeline, 'comments'), { journal, destination, now: () => new Date('2026-01-03') })).ok).toBe(true)
+  expect(requests.map(operation)).toEqual(['Comments'])
+  expect(requests[0]?.variables).toEqual({ after: null, from: '2026-01-01T23:55:00.000Z', to: '2026-01-03T00:00:00.000Z' })
+  expect((await journal.readCheckpoint('linear.issues')).envelope?.state).toEqual({ watermark: cutoff.toISOString() })
+  expect((await journal.readCheckpoint('linear.comments')).envelope?.state).toEqual({ watermark: '2026-01-03T00:00:00.000Z' })
+  const rows = destination.tables.get('default.linear_comments_raw') ?? []
+  expect(rows).toHaveLength(2)
+  expect(new Set(rows.map((row) => row.id)).size).toBe(1)
+  expect(rows.at(-1)?.raw).toEqual({ ...comment, body: 'Edited discussion on an old issue', updatedAt: '2026-01-02T12:00:00Z' })
+  requests.length = 0
+  expect((await runIngestion(request(pipeline, 'issues'), { journal, destination, now: () => new Date('2026-01-04') })).ok).toBe(true)
+  expect(requests.map(operation)).toEqual(['Issues'])
+  expect(requests[0]?.variables.from).toBe('2026-01-01T23:55:00.000Z')
+  expect((await journal.readCheckpoint('linear.comments')).envelope?.state).toEqual({ watermark: '2026-01-03T00:00:00.000Z' })
+})
+
+test('issue labels are complete string arrays across nested pages while issue pages remain independent', async () => {
+  const requests: GraphqlRequest[] = []
+  const nextIssue = { ...issue, id: 'issue-b', labels: connection([]) }
+  const pipeline = fixturePipeline((body) => {
+    requests.push(body)
+    if (operation(body) === 'IssueLabels') return Response.json({ data: { issue: { labels: connection(
+      body.variables.after === 'labels-next' ? [{ id: 'label-b', name: 'Customer' }] : [{ id: 'label-c', name: 'Urgent' }],
+      body.variables.after === 'labels-next' ? 'labels-last' : null) } } })
+    if (body.variables.after) return response('issues', [nextIssue])
+    return response('issues', [{ ...issue, labels: connection([{ id: 'label-a', name: 'Bug' }], 'labels-next') }], 'issues-next')
+  })
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  expect((await runIngestion(request(pipeline, 'issues'), { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect(requests.map(operation)).toEqual(['Issues', 'IssueLabels', 'IssueLabels', 'Issues'])
+  expect(requests.filter((body) => operation(body) === 'IssueLabels').map((body) => body.variables)).toEqual([
+    { id: 'issue-a', after: 'labels-next' }, { id: 'issue-a', after: 'labels-last' },
+  ])
+  expect(requests.every((body) => !body.query.includes('comments('))).toBe(true)
+  expect(destination.tables.get('default.linear_issues_raw')?.map((row) => row.raw)).toEqual([
+    { ...issue, labels: ['Bug', 'Customer', 'Urgent'] }, { ...nextIssue, labels: [] },
+  ])
+  expect((await journal.readCheckpoint('linear.issues')).envelope?.state).toEqual({ watermark: cutoff.toISOString() })
+})
+
+test('a labels page failure leaves the issue window uncommitted and replays from its first page', async () => {
+  let fail = true
+  const starts: unknown[] = []
+  const pipeline = fixturePipeline((body) => {
+    if (operation(body) === 'IssueLabels') return fail ? Response.json({ errors: [{ message: 'denied' }] })
+      : Response.json({ data: { issue: { labels: connection([{ id: 'label-b', name: 'Customer' }]) } } })
+    starts.push(body.variables.after)
+    return response('issues', [{ ...issue, labels: connection([{ id: 'label-a', name: 'Bug' }], 'labels-next') }])
+  })
+  const journal = createMemoryJournal(), destination = createMemoryDestination(), selected = request(pipeline, 'issues')
+  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(false)
+  expect((await journal.readCheckpoint('linear.issues')).envelope).toBeUndefined()
+  expect(destination.tables.size).toBe(0)
+  fail = false
+  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect(starts).toEqual([null, null])
+  expect(destination.tables.get('default.linear_issues_raw')?.[0]?.raw).toEqual(expectedRows.issues)
+})
+
+test('a failed comment page does not block any other resource and the next run replays its own window', async () => {
+  let fail = true
+  const starts: unknown[] = []
+  const second = { ...comment, id: 'comment-b' }
+  const pipeline = fixturePipeline((body) => {
+    if (operation(body) !== 'Comments') return fixtureResponse(body)
+    if (body.variables.after) return fail ? new Response('denied', { status: 403 }) : response('comments', [second])
+    starts.push(body.variables.after)
+    return response('comments', [comment], 'comments-next')
+  })
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  const failed = await runIngestion(request(pipeline), { journal, destination, now: () => cutoff })
+  expect(failed.ok).toBe(false)
+  expect(failed.streams.filter((stream) => stream.outcome === 'failed').map((stream) => stream.streamId)).toEqual(['linear.comments'])
+  expect((await journal.readCheckpoint('linear.comments')).envelope).toBeUndefined()
+  for (const resource of resources.filter((resource) => resource !== 'comments')) {
+    expect((await journal.readCheckpoint(`linear.${resource}`)).lastSuccessSeq).toBeGreaterThan(0)
+  }
+  fail = false
+  expect((await runIngestion(request(pipeline, 'comments'), { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect(starts).toEqual([null, null])
+  expect(destination.tables.get('default.linear_comments_raw')?.map((row) => row.id)).toEqual(['comment-a', 'comment-b'])
+  expect((await journal.readCheckpoint('linear.comments')).envelope?.state).toEqual({ watermark: cutoff.toISOString() })
+})
+
+test('rejected comment writes preserve their prior watermark and replay the unacknowledged update window', async () => {
+  const starts: unknown[] = []
+  const pipeline = fixturePipeline((body) => {
+    starts.push(body.variables.from)
+    return response('comments', [{ ...comment, updatedAt: body.variables.from === '1970-01-01T00:00:00.000Z' ? updatedAt : '2026-01-02T12:00:00Z' }])
+  })
+  const journal = createMemoryJournal(), destination = createMemoryDestination(), selected = request(pipeline, 'comments')
+  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(true)
+  const now = () => new Date('2026-01-03')
+  expect((await runIngestion(selected, { journal, destination: { insert: async () => { throw new IngestConfigError('sink rejected') } }, now })).ok).toBe(false)
+  expect((await journal.readCheckpoint('linear.comments')).envelope?.state).toEqual({ watermark: cutoff.toISOString() })
+  expect((await runIngestion(selected, { journal, destination, now })).ok).toBe(true)
+  expect(starts).toEqual(['1970-01-01T00:00:00.000Z', '2026-01-01T23:55:00.000Z', '2026-01-01T23:55:00.000Z'])
+  expect((await journal.readCheckpoint('linear.comments')).envelope?.state).toEqual({ watermark: now().toISOString() })
+})
+
+test('empty resources complete independently and timestamp windows overlap while full resources enumerate again', async () => {
+  const requests: GraphqlRequest[] = []
+  const pipeline = fixturePipeline((body) => { requests.push(body); return emptyResponse(body) })
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  for (const now of [cutoff, new Date('2026-01-03')]) {
+    expect((await runIngestion(request(pipeline), { journal, destination, now: () => now })).ok).toBe(true)
+  }
+  expect(destination.tables.size).toBe(0)
+  for (const resource of timestampResources) {
+    expect((await journal.readCheckpoint(`linear.${resource}`)).envelope?.state).toEqual({ watermark: '2026-01-03T00:00:00.000Z' })
+  }
+  const incremental = requests.filter((body) => body.variables.from !== undefined)
+  expect(incremental).toHaveLength(14)
+  expect(incremental.slice(0, 7).every((body) => body.variables.from === '1970-01-01T00:00:00.000Z')).toBe(true)
+  expect(incremental.slice(7).every((body) => body.variables.from === '2026-01-01T23:55:00.000Z')).toBe(true)
+  for (const name of ['IssueRelations', 'IssueHistoryParents']) {
+    const full = requests.filter((body) => operation(body) === name)
+    expect(full).toHaveLength(2)
+    expect(full.every((body) => !body.query.includes('filter:') && body.variables.from === undefined)).toBe(true)
+  }
+  for (const resource of ['issue_relations', 'issue_history']) {
+    expect((await journal.readCheckpoint(`linear.${resource}`)).envelope).toBeUndefined()
+    expect(journal.events.filter((event) => event.namespaceId === `linear.${resource}` && event.eventKind === 'work_finished' && event.workState === 'succeeded')).toHaveLength(2)
+  }
+})
+
+test('history enumerates all old and archived issues independently and retains paginated history join identities', async () => {
+  const requests: GraphqlRequest[] = []
+  const second = { ...history, id: 'history-b', toTitle: 'Later' }
+  const third = { ...history, id: 'history-c', issue: { id: 'issue-b' } }
+  const pipeline = fixturePipeline((body) => {
+    requests.push(body)
+    if (operation(body) === 'IssueHistoryParents') return response('issues', [{ id: body.variables.after ? 'issue-b' : 'issue-a',
+      updatedAt: '2020-01-01T00:00:00Z', archivedAt: '2020-01-02T00:00:00Z' }], body.variables.after ? null : 'parents-next')
+    return Response.json({ data: { issue: { history: connection(body.variables.id === 'issue-b' ? [third] : body.variables.after ? [second] : [history],
+      body.variables.id === 'issue-a' && !body.variables.after ? 'history-next' : null) } } })
+  })
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  expect((await runIngestion(request(pipeline, 'issue_history'), { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect(requests.map(operation)).toEqual(['IssueHistoryParents', 'IssueHistory', 'IssueHistory', 'IssueHistoryParents', 'IssueHistory'])
+  expect(requests.every((body) => body.variables.from === undefined && !body.query.includes('filter:'))).toBe(true)
+  expect(destination.tables.get('default.linear_issue_history_raw')?.map(({ id, raw }) => ({ id, raw }))).toEqual([history, second, third].map((raw) => ({ id: raw.id, raw })))
+  expect((await journal.readCheckpoint('linear.issues')).lastSuccessSeq).toBe(0)
+  expect((await journal.readCheckpoint('linear.issue_history')).envelope).toBeUndefined()
+})
+
+test('mutable relation full sync replays its first page after source and sink failures and refreshes old records', async () => {
+  let fail = true, changed = false
+  const starts: unknown[] = []
+  const second = { ...relation, id: 'relation-b' }
+  const pipeline = fixturePipeline((body) => {
+    expect(operation(body)).toBe('IssueRelations')
+    expect(body.variables.from).toBeUndefined()
+    expect(body.query).not.toContain('filter:')
+    if (body.variables.after) return fail ? new Response('denied', { status: 403 }) : response('issueRelations', [second])
+    starts.push(body.variables.after)
+    return response('issueRelations', [{ ...relation, type: changed ? 'duplicate' : relation.type }], 'relations-next')
+  })
+  const journal = createMemoryJournal(), destination = createMemoryDestination(), selected = request(pipeline, 'issue_relations')
+  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(false)
+  expect((await journal.readCheckpoint('linear.issue_relations')).lastSuccessSeq).toBe(0)
+  fail = false
+  expect((await runIngestion(selected, { journal, destination: { insert: async () => { throw new IngestConfigError('sink rejected') } }, now: () => cutoff })).ok).toBe(false)
+  expect((await journal.readCheckpoint('linear.issue_relations')).lastSuccessSeq).toBe(0)
+  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(true)
+  changed = true
+  expect((await runIngestion(selected, { journal, destination, now: () => new Date('2026-01-03') })).ok).toBe(true)
+  expect(starts).toEqual([null, null, null, null])
+  expect((await journal.readCheckpoint('linear.issue_relations')).envelope).toBeUndefined()
+  const rows = destination.tables.get('default.linear_issue_relations_raw') ?? []
+  expect(rows.filter((row) => row.id === relation.id).map((row) => row.raw)).toEqual([relation, { ...relation, type: 'duplicate' }])
+})
+
+test('history failures replay all parent discovery without recording completion before every history write succeeds', async () => {
+  let fail = true
+  const starts: unknown[] = []
+  const second = { ...history, id: 'history-b', issue: { id: 'issue-b' } }
+  const pipeline = fixturePipeline((body) => {
+    if (operation(body) === 'IssueHistoryParents') {
+      starts.push(body.variables.after)
+      return response('issues', [{ id: 'issue-a' }, { id: 'issue-b' }])
+    }
+    if (body.variables.id === 'issue-b' && fail) return new Response('denied', { status: 403 })
+    return Response.json({ data: { issue: { history: connection(body.variables.id === 'issue-a' ? [history] : [second]) } } })
+  })
+  const journal = createMemoryJournal(), destination = createMemoryDestination(), selected = request(pipeline, 'issue_history')
+  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(false)
+  expect((await journal.readCheckpoint('linear.issue_history')).lastSuccessSeq).toBe(0)
+  expect((await journal.readCheckpoint('linear.issue_history')).envelope).toBeUndefined()
+  fail = false
+  expect((await runIngestion(selected, { journal, destination: { insert: async () => { throw new IngestConfigError('sink rejected') } }, now: () => cutoff })).ok).toBe(false)
+  expect((await journal.readCheckpoint('linear.issue_history')).lastSuccessSeq).toBe(0)
+  expect((await runIngestion(selected, { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect(starts).toEqual([null, null, null])
+  expect((await journal.readCheckpoint('linear.issue_history')).envelope).toBeUndefined()
+  expect((await journal.readCheckpoint('linear.issue_history')).lastSuccessSeq).toBeGreaterThan(0)
+  expect(destination.tables.get('default.linear_issue_history_raw')?.map(({ id, raw }) => ({ id, raw }))).toEqual([history, second].map((raw) => ({ id: raw.id, raw })))
+  expect((await journal.readCheckpoint('linear.issues')).lastSuccessSeq).toBe(0)
+})
+
+test('Linear binds custom date selection and isolates each installation and resource checkpoint', async () => {
+  const requests: GraphqlRequest[] = []
+  const config = { ...linearConfig, sourceId: 'linear.fixture', start: new Date('2025-01-01'), overlapMs: 60_000 }
+  const pipeline = createLinearPipeline(config, { token: () => 'bound-token', fetch: async (_url, init) => {
+    expect(new Headers(init.headers).get('authorization')).toBe('bound-token')
+    const body: GraphqlRequest = JSON.parse(String(init.body))
+    requests.push(body)
+    return emptyResponse(body)
+  } })
+  config.start.setUTCFullYear(2000)
+  config.overlapMs = 3_600_000
+  config.sourceId = 'mutated'
+  expect(pipeline.streams.map((stream) => stream.id).sort()).toEqual(resources.map((resource) => `linear.fixture.${resource}`).sort())
+  const failing = createLinearPipeline({ ...linearConfig, sourceId: 'linear.denied' }, { token: () => 'denied', fetch: async () => new Response('denied', { status: 403 }) })
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  const selected = selectStreams([failing, pipeline], ['resource:comments']).map((entry) => ({ ...entry, stream: { ...entry.stream, retry: { retries: 0 } } }))
+  const result = await runIngestion({ selected, backfill: undefined }, { journal, destination, now: () => cutoff })
+  expect(result.streams.map((stream) => stream.outcome)).toEqual(['failed', 'succeeded'])
+  expect(requests[0]?.variables).toEqual({ after: null, from: '2025-01-01T00:00:00.000Z', to: cutoff.toISOString() })
+  expect((await journal.readCheckpoint('linear.denied.comments')).envelope).toBeUndefined()
+  expect((await journal.readCheckpoint('linear.fixture.comments')).envelope?.state).toEqual({ watermark: cutoff.toISOString() })
+  const onlyFixture = selectStreams([failing, pipeline], ['stream:linear.fixture.comments'])
+  expect(onlyFixture.map((entry) => entry.stream.id)).toEqual(['linear.fixture.comments'])
+  expect((await runIngestion({ selected: onlyFixture, backfill: undefined }, { journal, destination, now: () => new Date('2026-01-03') })).ok).toBe(true)
+  expect(requests[1]?.variables.from).toBe('2026-01-01T23:59:00.000Z')
+  expect((await journal.readCheckpoint('linear.fixture.issues')).envelope).toBeUndefined()
+  expect((await journal.readCheckpoint('linear.comments')).envelope).toBeUndefined()
+})
+
+test('nullable provider comment references retain the comment ID and unmodified raw payload', async () => {
+  const detached = { ...comment, issueId: null, projectUpdateId: 'project-update-a', user: null }
+  const pipeline = fixturePipeline(() => response('comments', [detached]))
+  const destination = createMemoryDestination()
+  expect((await runIngestion(request(pipeline, 'comments'), { journal: createMemoryJournal(), destination, now: () => cutoff })).ok).toBe(true)
+  expect(destination.tables.get('default.linear_comments_raw')?.map(({ id, raw }) => ({ id, raw }))).toEqual([{ id: detached.id, raw: detached }])
+})
+
+test('GraphQL HTTP400 and HTTP200 rate exhaustion each consume exactly one page retry', async () => {
+  for (const status of [400, 200]) {
+    let attempts = 0
+    const pipeline = fixturePipeline(() => ++attempts === 1
+      ? Response.json({ errors: [{ message: 'rate limit', extensions: { code: 'RATELIMITED' } }] }, { status, headers: { 'Retry-After': '0' } })
+      : response('comments', []))
+    const selected = request(pipeline, 'comments').selected.map((entry) => ({ ...entry, stream: { ...entry.stream, retry: { retries: 1, minTimeout: 0, maxTimeout: 0 } } }))
+    const journal = createMemoryJournal()
+    expect((await runIngestion({ selected, backfill: undefined }, { journal, destination: createMemoryDestination(), now: () => cutoff })).ok).toBe(true)
+    expect(attempts).toBe(2)
+    expect(journal.events.filter((event) => event.eventKind === 'retry_scheduled' && event.errorClass === 'rate_limited')).toHaveLength(1)
+  }
+})
+
+test('partial GraphQL data with errors cannot write rows, retry, or complete a resource', async () => {
+  for (const resource of ['comments', 'issue_relations', 'issue_history']) {
+    let attempts = 0
+    const pipeline = fixturePipeline((body) => {
+      attempts++
+      return Response.json({ data: operation(body) === 'IssueHistoryParents' ? { issues: connection([{ id: issue.id }]) }
+        : operation(body) === 'Comments' ? { comments: connection([comment]) } : { issueRelations: connection([relation]) },
+      errors: [{ message: 'Some fields were denied', extensions: { code: 'FORBIDDEN' } }] })
+    })
+    const selected = request(pipeline, resource).selected.map((entry) => ({ ...entry, stream: { ...entry.stream, retry: { retries: 1, minTimeout: 0, maxTimeout: 0 } } }))
+    const journal = createMemoryJournal(), destination = createMemoryDestination()
+    expect((await runIngestion({ selected, backfill: undefined }, { journal, destination, now: () => cutoff })).ok).toBe(false)
+    expect(attempts).toBe(1)
+    expect(destination.tables.size).toBe(0)
+    expect((await journal.readCheckpoint(`linear.${resource}`)).lastSuccessSeq).toBe(0)
+    expect(journal.events.filter((event) => event.eventKind === 'retry_scheduled')).toHaveLength(0)
+  }
+})
+
+test('malformed root and nested continuations fail before another request or successful checkpoint', async () => {
+  for (const name of ['Comments', 'IssueRelations', 'IssueLabels', 'IssueHistoryParents', 'IssueHistory']) {
+    for (const endCursor of [7, ' ', null]) {
+      let attempts = 0
+      const pipeline = fixturePipeline((body) => {
+        if (operation(body) !== name) return precedingResponse(body, name)
+        attempts++
+        return connectionFor(body, { nodes: [], pageInfo: { hasNextPage: true, endCursor } })
+      })
+      const resource = resourceFor(name), journal = createMemoryJournal()
+      const result = await runIngestion(request(pipeline, resource), { journal, destination: createMemoryDestination(), now: () => cutoff })
+      expect(result.ok, `${name}:${String(endCursor)}`).toBe(false)
+      expect(attempts).toBe(1)
+      expect((await journal.readCheckpoint(`linear.${resource}`)).envelope).toBeUndefined()
+      expect((await journal.readCheckpoint(`linear.${resource}`)).lastSuccessSeq).toBe(0)
+    }
+  }
+})
+
+test('cyclic root and nested pagination fails permanently without replaying a whole reader', async () => {
+  for (const name of ['Comments', 'IssueRelations', 'IssueLabels', 'IssueHistoryParents', 'IssueHistory']) {
+    const afters: unknown[] = []
+    const pipeline = fixturePipeline((body) => {
+      if (operation(body) !== name) return precedingResponse(body, name)
+      afters.push(body.variables.after)
+      return connectionFor(body, connection([], body.variables.after === 'a' ? 'b' : 'a'))
+    })
+    const resource = resourceFor(name), journal = createMemoryJournal()
+    const selected = request(pipeline, resource).selected.map((entry) => ({ ...entry, stream: { ...entry.stream, retry: { retries: 1, minTimeout: 0, maxTimeout: 0 } } }))
+    const result = await runIngestion({ selected, backfill: undefined }, { journal, destination: createMemoryDestination(), now: () => cutoff })
+    expect(result.ok, name).toBe(false)
+    expect(afters).toEqual(name === 'IssueLabels' ? ['a', 'b'] : [null, 'a', 'b'])
+    expect((await journal.readCheckpoint(`linear.${resource}`)).lastSuccessSeq).toBe(0)
+    expect(journal.events.filter((event) => event.eventKind === 'retry_scheduled')).toHaveLength(0)
+  }
+})
+
+test('a repeated initial label cursor cannot publish the issue or retry its label read', async () => {
+  const afters: unknown[] = []
+  const pipeline = fixturePipeline((body) => {
+    if (operation(body) !== 'IssueLabels') return precedingResponse(body, 'IssueLabels')
+    afters.push(body.variables.after)
+    return connectionFor(body, connection([{ id: 'label-cyclic', name: 'Incomplete' }], 'a'))
+  })
+  const selected = request(pipeline, 'issues').selected.map((entry) => ({
+    ...entry, stream: { ...entry.stream, retry: { retries: 1, minTimeout: 0, maxTimeout: 0 } },
+  }))
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  const result = await runIngestion({ selected, backfill: undefined }, { journal, destination, now: () => cutoff })
+
+  expect(result.ok).toBe(false)
+  expect(result.streams[0]?.error).toContain('repeated continuation')
+  expect(afters).toEqual(['a'])
+  expect(destination.tables.size).toBe(0)
+  expect((await journal.readCheckpoint('linear.issues')).envelope).toBeUndefined()
+  expect((await journal.readCheckpoint('linear.issues')).lastSuccessSeq).toBe(0)
+  expect(journal.events.filter((event) => event.eventKind === 'retry_scheduled')).toHaveLength(0)
+})
+
+test('malformed connections or provider identities cannot silently complete an empty-looking window', async () => {
+  for (const payload of [
+    { nodes: {}, pageInfo: { hasNextPage: false, endCursor: null } },
+    { nodes: [], pageInfo: { hasNextPage: 'false', endCursor: null } },
+    connection([{ ...comment, id: '' }]), connection([{ ...comment, updatedAt: 'invalid' }]),
+    connection([{ ...comment, updatedAt: '2026-01-03T00:00:00Z' }]),
+  ]) {
+    let attempts = 0
+    const pipeline = fixturePipeline(() => { attempts++; return Response.json({ data: { comments: payload } }) })
+    const journal = createMemoryJournal()
+    expect((await runIngestion(request(pipeline, 'comments'), { journal, destination: createMemoryDestination(), now: () => cutoff })).ok).toBe(false)
+    expect(attempts).toBe(1)
+    expect((await journal.readCheckpoint('linear.comments')).envelope).toBeUndefined()
+  }
+})
+
+function fixturePipeline(respond: Responder = fixtureResponse, config: LinearConfig = linearConfig): Pipeline {
+  return createLinearPipeline(config, { token: () => 'fixture', fetch: async (_url, init) => respond(JSON.parse(String(init.body))) })
+}
+
+function request(pipeline: Pipeline, resource?: string) {
+  return { selected: selectStreams([pipeline], resource ? [`resource:${resource}`] : []).map((entry) => ({
+    ...entry, stream: { ...entry.stream, batchSize: 1, retry: { retries: 0 } },
+  })), backfill: undefined }
+}
+
+function operation(body: GraphqlRequest): string {
+  const name = /query\s+(\w+)/.exec(body.query)?.[1]
+  if (!name) throw new IngestConfigError('Fixture received an unnamed GraphQL operation.')
+  return name
+}
+
+function fixtureResponse(body: GraphqlRequest): Response {
+  switch (operation(body)) {
+    case 'Issues': return response('issues', [issue])
+    case 'Comments': return response('comments', [comment])
+    case 'Projects': return response('projects', [project])
+    case 'ProjectUpdates': return response('projectUpdates', [projectUpdate])
+    case 'Cycles': return response('cycles', [cycle])
+    case 'Users': return response('users', [user])
+    case 'Teams': return response('teams', [team])
+    case 'IssueRelations': return response('issueRelations', [relation])
+    case 'IssueHistoryParents': return response('issues', [{ id: issue.id, updatedAt: '2020-01-01T00:00:00Z' }])
+    case 'IssueHistory': return Response.json({ data: { issue: { history: connection([history]) } } })
+    default: throw new IngestConfigError(`Unexpected Linear fixture operation: ${operation(body)}`)
+  }
+}
+
+function connection(items: readonly unknown[], next: string | null = null) {
+  return { nodes: items, pageInfo: { hasNextPage: next !== null, endCursor: next } }
+}
+
+function response(root: string, items: readonly unknown[], next: string | null = null): Response {
+  return Response.json({ data: { [root]: connection(items, next) } })
+}
+
+function emptyResponse(body: GraphqlRequest): Response {
+  return connectionFor(body, connection([]))
+}
+
+function connectionFor(body: GraphqlRequest, page: unknown): Response {
+  const roots: Record<string, string> = { Issues: 'issues', Comments: 'comments', Projects: 'projects', ProjectUpdates: 'projectUpdates',
+    Cycles: 'cycles', Users: 'users', Teams: 'teams', IssueRelations: 'issueRelations', IssueHistoryParents: 'issues' }
+  const root = roots[operation(body)]
+  if (root) return Response.json({ data: { [root]: page } })
+  if (operation(body) === 'IssueLabels') return Response.json({ data: { issue: { labels: page } } })
+  if (operation(body) === 'IssueHistory') return Response.json({ data: { issue: { history: page } } })
+  throw new IngestConfigError(`Unexpected Linear fixture operation: ${operation(body)}`)
+}
+
+function resourceFor(name: string): string {
+  return name === 'Comments' ? 'comments' : name === 'IssueRelations' ? 'issue_relations' : name === 'IssueLabels' ? 'issues' : 'issue_history'
+}
+
+function precedingResponse(body: GraphqlRequest, target: string): Response {
+  if (target === 'IssueLabels') return response('issues', [{ ...issue, labels: connection([], 'a') }])
+  return fixtureResponse(body)
+}
diff --git a/registry/package.json b/registry/package.json
index 189db8fc..fd99620a 100644
--- a/registry/package.json
+++ b/registry/package.json
@@ -7,7 +7,7 @@
     "build": "tsc -p tsconfig.json --noEmit",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "lint": "biome lint .",
-    "test": "bun test */tests ../scripts/registry-catalog.test.ts --timeout 30000"
+    "test": "bun test */tests ../scripts/registry-catalog.test.ts ../scripts/registry-releases.test.ts --timeout 30000"
   },
   "devDependencies": {
     "@chkit/clickhouse": "workspace:*",
diff --git a/registry/slack/README.md b/registry/slack/README.md
index a1eb328b..003e25c3 100644
--- a/registry/slack/README.md
+++ b/registry/slack/README.md
@@ -30,7 +30,7 @@ Use an external scheduler to repeat ingestion, with one ingestion process per pr
 
 ## Included resources
 
-All three streams read their complete selected resource on every run. Each discovers its own authenticated workspace through `auth.test`; the messages stream independently discovers conversations.
+One installation pipeline contains independent streams for channels, users, and messages. Channels and users read their complete selected resource on every run. Messages bootstrap the recent 24 hours by default and then read checkpointed overlapping time ranges. Each reader discovers its authenticated workspace through `auth.test`; messages independently discover conversations. A channel is an individual entity inside the messages resource, so channel and thread traversal stays within that stream.
 
 | Stream tag | Default raw table | Required scopes for defaults |
 |---|---|---|
@@ -40,10 +40,12 @@ All three streams read their complete selected resource on every run. Each disco
 
 - **Channels:** conversation metadata returned by [`conversations.list`](https://docs.slack.dev/reference/methods/conversations.list/), including archived conversations when returned. No separate `conversations.info` expansion or membership request.
 - **Users:** complete objects returned by [`users.list`](https://docs.slack.dev/reference/methods/users.list/), including profiles, bots, and deleted-user flags.
-- **Messages:** all accessible retained [`conversations.history`](https://docs.slack.dev/reference/methods/conversations.history/) pages for selected conversations. With `includeReplies: true`, roots with `reply_count > 0` also fetch every `conversations.replies` page. Replies and their parents share the raw messages table.
+- **Messages:** the selected timestamp range of accessible [`conversations.history`](https://docs.slack.dev/reference/methods/conversations.history/) pages for selected conversations. With `includeReplies: true`, roots with `reply_count > 0` also fetch every `conversations.replies` page. Replies and their parents share the raw messages table.
 
 Messages preserve blocks, attachments, reactions, metadata, and file references when returned. File references do not download files. No separate files, reactions, pins, canvases, search, or events reader is included.
 
+Replies are individual Message objects with their own `ts` and a `thread_ts` parent reference, so they use the messages stream and table. The reader does not assemble a conversation array inside each parent or enrich messages with channel/user records. Run messages before, after, or without the metadata streams; it discovers conversation IDs independently and checkpoints each completed history page after its replies finish. Join users, channels, and thread parents later in ClickHouse using source, workspace, channel, and native message keys.
+
 ## Choose conversations and request pacing
 
 The default config selects public channels, includes replies, uses metadata pages of 200, and uses history/reply pages of 15. `requestIntervalMs` defaults to 3000; `messageIntervalMs` defaults to 60000.
@@ -61,11 +63,13 @@ Set `channels` to an array of Slack conversation IDs to restrict channels and me
 
 Keep `sourceId` stable after ingestion begins. A second workspace should use a distinct source ID and a separate table prefix or database. Changing these values changes stream and storage identities and requires a deliberate migration.
 
+`createSlackPipeline` in `pipeline.ts` binds source identity, selection, page sizes, pacing, and message state settings when the pipeline is created. Later changes to a config object do not alter that pipeline. Raw table names are defined from `config.ts` when the schema modules load; the factory does not rename or create destination schemas. Set `database` and `tablePrefix` in the installed config before loading schemas and generating migrations.
+
 Slack documents one request per minute and 15 objects per page for new commercially distributed apps outside the Slack Marketplace. Marketplace and internal customer-built apps retain Tier 3 limits. See the current [history method](https://docs.slack.dev/reference/methods/conversations.history/) and [rate-limit clarification](https://docs.slack.dev/changelog/2025/06/03/rate-limits-clarity/). For an internal app entitled to Tier 3, edit `messagePageSize` to 200 and `messageIntervalMs` to 1200 after confirming its limits.
 
 The pipeline runs one stream, fetch, and load at a time. Requests have a 30-second timeout and use the ingestion executor's retry and cancellation context. The pipeline permits five retries after the initial attempt, with exponential backoff from 1 to 60 seconds. HTTP `429` honors `Retry-After`; Slack rate-limit responses and transient server codes also retry. Authentication and permission errors, including Slack `ok: false` responses, fail visibly instead of becoming empty datasets.
 
-Full history and thread reads can take hours or days at the conservative defaults. Restrict conversations and selected streams, and choose `--max-duration` for the expected scan. The CLI's default duration is 3600 seconds. Interrupted runs restart their scans rather than resuming from a saved cursor.
+History and thread reads can take hours or days at conservative defaults. Restrict conversations and selected streams, and choose `--max-duration` for the workload. The CLI default is 3600 seconds. Interrupted message reads resume a completed timestamp boundary and replay the incomplete history page with its replies; metadata reads restart. A history page and all its replies must fit the execution budget, including its completion marker. Reduce messagePageSize or increase the budget if that unit repeatedly cannot finish.
 
 To read only messages:
 
@@ -103,17 +107,27 @@ LIMIT 20;
 
 There are no packaged typed views. Add SQL projections in the project's schema for the fields needed by the application. Preserve source and workspace identity in joins.
 
-## Full reads and coverage limits
+## Incremental messages and recovery
+
+The first messages run reads the recent 24 hours to a fixed execution cutoff. Set `historyFrom` to an exact timestamp string for a broader initial bootstrap; its default is `undefined`. Later runs begin at the completed watermark minus `overlapMs` (24 hours by default), so gaps between runs remain eligible. Newly discovered channels use the same selected range. There is no periodic historical reconciliation.
+
+Checkpoints retain exact timestamp strings, the authenticated workspace and query scope, fixed bounds, channel position, and the last completed history-page frontier. History progresses newest first; replies progress oldest first using temporary local boundaries. A history page and all of its selected replies must finish before an empty checkpoint marker advances history. Interrupted pages replay from their original boundary, including any child rows already loaded. Temporary API cursors never enter durable state; expiry replays that unfinished timestamp interval once. Empty terminal pages also commit progress.
 
-Each run starts at the beginning and reads history without date bounds or subtype filtering. Within each channel, history pagination finishes before threads are read. Old roots are scanned again to capture late replies when Slack still retains and exposes them. Short or empty pages continue when a cursor exists; repeated cursors or `has_more: true` without a cursor fail explicitly. Full reads save no incremental checkpoint.
+One history page and all its replies must fit a fresh execution's duration and chunk budget, including the completion marker. A budget that always stops before that marker will keep replaying the same page. Reduce `messagePageSize`, raise the budget, or narrow the selected workload. The integration deliberately accepts page replay instead of maintaining durable per-thread or per-reply checkpoints.
+
+Keep source identity and selection stable; changing the account, channels, types, reply policy, bootstrap lower bound, or overlap fails against existing state. Use a new source ID for a deliberate separate installation. The message strategy is version 2; incompatible saved strategy versions require an explicit migration or a new stream identity. Version 0.2.0 preserves raw tables and row IDs. Earlier released full readers had no saved provider state; their first upgraded messages run bootstraps once.
 
 The destination stores the latest **observed** payload per identity. Deleted messages, deselected conversations, and data made inaccessible remain in ClickHouse. Loaded batches stay visible when a run fails; there is no atomic snapshot replacement or rollback. Changes during pagination may cause misses or repeated observations. Slack retention, permissions, and token access determine historical coverage.
 
-The integration has no deletion reconciliation, permanent edit log, webhooks, or continuous change capture. Date-range backfill flags do not make these readers bounded or incremental.
+Replies are fetched only for roots returned in the selected history range, up to the fixed upper cutoff. Old edits and late replies attached to roots outside that range are outside normal coverage. The integration has no historical reconciliation, deletion reconciliation, permanent edit log, webhooks, or continuous change capture.
+
+Messages support isolated date-bound backfills with `--backfill <id> --from <date> --to <date>`. Bounds select root/history timestamps; child replies for those roots are read up to the upper cutoff. Unfinished backfills retain their original bounds; changing those bounds requires another ID. An omitted upper bound freezes the original execution cutoff. Channels and users remain full reads and do not interpret date ranges. Historical raw observations loaded later can replace newer observations because replacement uses ingestion time.
 
 ## Customize the source
 
-`sources/channels.ts`, `sources/users.ts`, and `sources/messages.ts` each contain a resource's raw schema and reader. `client.ts` handles HTTP, authentication, validation, pagination, row IDs, and pacing; `pipeline.ts` composes the streams.
+`sources/channels.ts`, `sources/users.ts`, and `sources/messages.ts` each contain a resource's raw schema and reader. `client.ts` handles HTTP, authentication, validation, row IDs, and pacing; all three readers use the plugin's `paginate` helper. Messages use it to cross empty or parent-only pages, retain native `has_more` in metadata, and return to timestamp pagination as soon as rows establish a safe frontier. `state.ts` validates provider timestamp checkpoints; `pipeline.ts` binds reader configuration and composes the three streams. Each stream has its own journal progress and resource tag, so selecting users does not run messages and a message failure does not prevent a users run.
+
+Conversation selection validates configured IDs after discovery finishes. If a configured ID is missing, the stream fails visibly; any metadata pages already loaded remain visible.
 
 Remove a stream from `pipeline.ts` to stop ingestion while retaining its schema export in `index.ts` to preserve the table. Removing schema exports can generate destructive migration operations; review them. Test reader changes and revisit pacing when changing concurrency.
 
@@ -123,13 +137,13 @@ Install the optional portable test suite, then run it:
 
 ```sh
 bunx chkit add slack --with-tests
-bun test src/integrations/slack/tests/slack.test.ts
+bun test src/integrations/slack/tests/slack.test.ts src/integrations/slack/tests/checkpoints.test.ts
 ```
 
 For a custom install path, point the command at its `tests/slack.test.ts`. Tests use sanitized responses, mocked HTTP, and in-memory ingestion destinations. They require Bun and no Slack credentials or ClickHouse server. Update fixtures and expectations alongside customized readers.
 
 ## Smoke check
 
-After a migration and successful run, inspect `chkit ingest status --tag provider:slack` and query `SELECT count() FROM default.slack_messages_raw FINAL`. Compare a known message and an older thread with their stored payloads. Add a reply to that test thread, rerun ingestion, and verify the reply is collected. Row counts alone do not establish complete live API coverage.
+After a migration and successful run, inspect `chkit ingest status --tag provider:slack` and query `SELECT count() FROM default.slack_messages_raw FINAL`. Compare a known message and an older thread with their stored payloads. Add a reply to that old thread, then run a messages-only backfill with a new ID and `--from` before the root's timestamp to verify the reply is collected. Normal incremental runs revisit roots within the selected overlap; an old root outside that range requires an explicit backfill. Row counts alone do not establish complete live API coverage.
 
 The [Slack integration guide](https://chkit.obsessiondb.com/integrations/slack/) covers installation, SQL queries, scheduling, and recovery.
diff --git a/registry/slack/client.ts b/registry/slack/client.ts
index 43d8e78d..6cf6f740 100644
--- a/registry/slack/client.ts
+++ b/registry/slack/client.ts
@@ -1,12 +1,13 @@
 import { setTimeout as sleep } from 'node:timers/promises'
 
-import { HttpError, IngestConfigError, rawRows, type ErrorClassifier, type FetchContext } from '@chkit/plugin-ingest'
+import { HttpError, IngestConfigError, paginate, rawRows, type ErrorClassifier, type FetchContext } from '@chkit/plugin-ingest'
 
-import { slackConfig } from './config.js'
+import { slackConfig, type SlackReaderConfig } from './config.js'
 
 export type SlackEntity = Record<string, unknown>
 
 export interface SlackClientDeps {
+  config: SlackReaderConfig
   fetch: (url: string, init: RequestInit) => Promise<Response>
   token: () => string | undefined
   wait: (milliseconds: number, signal: AbortSignal) => Promise<void>
@@ -18,66 +19,73 @@ export interface CollectionRequest {
   idField: 'id' | 'ts'
   query?: Record<string, string>
   pageSize?: number
+  /** Read empty/parent-only cursor pages until the next durable timestamp boundary. */
+  timePagination?: boolean
 }
 
-const defaultDeps: SlackClientDeps = {
+interface SlackPage { items: SlackEntity[]; cursor: string; hasMore: boolean }
+export class SlackCursorExpiredError extends IngestConfigError {}
+
+export const defaultSlackClientDeps: SlackClientDeps = {
+  config: slackConfig,
   fetch: (url, init) => fetch(url, init),
   token: () => process.env.SLACK_API_TOKEN,
   wait: async (milliseconds, signal) => { await sleep(milliseconds, undefined, { signal }) },
 }
 
 /** Each page is validated inside attempt, so executor retry/cancellation owns every request. */
-export async function* readCollection(
+export function readCollection(
   context: FetchContext,
   request: CollectionRequest,
-  deps: SlackClientDeps = defaultDeps,
-): AsyncGenerator<SlackEntity[]> {
-  const messageRequest = request.field === 'messages'
-  const limit = request.pageSize ?? (messageRequest ? slackConfig.messagePageSize : slackConfig.pageSize)
-  if (!Number.isSafeInteger(limit) || limit <= 0 || limit >= 1_000) {
-    throw new IngestConfigError('Slack page sizes must be safe integers between 1 and 999.')
-  }
-  const seenCursors = new Set<string>()
-  let cursor = ''
-  while (true) {
-    context.signal.throwIfAborted()
-    const query = { ...request.query, limit: String(limit), ...(cursor ? { cursor } : {}) }
-    const page = await context.attempt(async (signal) => {
-      const payload = await requestSlack(request.method, query, signal, deps)
-      return parsePage(payload, request)
-    }, { label: `GET /api/${request.method}` })
-    if (page.items.length > 0) yield page.items
-    // Empty/short pages can still have a cursor. Only cursor exhaustion ends a scan.
-    if (!page.cursor) return
-    if (seenCursors.has(page.cursor)) throw new IngestConfigError(`Slack ${request.method} repeated a pagination cursor.`)
-    seenCursors.add(page.cursor)
-    cursor = page.cursor
-  }
+  deps: SlackClientDeps = defaultSlackClientDeps,
+) {
+  return paginate({
+    context, label: `GET /api/${request.method}`,
+    fetchPage: async (cursor: string | undefined, signal) => {
+      const page = await fetchCollectionPage(request, cursor ?? '', signal, deps)
+      const timeBoundary = request.timePagination && (page.items.some((item) =>
+        request.method !== 'conversations.replies' || entityId(item, 'ts') !== request.query?.ts) || !page.hasMore)
+      if (request.timePagination && !timeBoundary && !page.cursor) {
+        throw new IngestConfigError('Slack empty page did not provide a new continuation.')
+      }
+      // Catalog reads follow cursors even across empty/short pages.
+      // Timestamp reads stop at a data boundary; native has_more still plans their next interval.
+      return { items: page.items, next: timeBoundary ? undefined : page.cursor || undefined, metadata: { hasMore: page.hasMore } }
+    },
+  })
 }
 
 /** Discover independently in each reader; pipeline stream order is not a dependency. */
-export async function discoverChannels(context: FetchContext, deps?: SlackClientDeps): Promise<SlackEntity[]> {
+export async function discoverChannels(context: FetchContext, deps: SlackClientDeps = defaultSlackClientDeps): Promise<SlackEntity[]> {
+  const channels: SlackEntity[] = []
+  for await (const page of readChannelPages(context, deps)) channels.push(...page.items)
+  return channels
+}
+
+/** Yield selected metadata pages directly; configured IDs must all be accessible. */
+export async function* readChannelPages(context: FetchContext, deps: SlackClientDeps = defaultSlackClientDeps) {
+  const config = deps.config
   const allowedTypes = ['public_channel', 'private_channel', 'im', 'mpim']
-  if (slackConfig.conversationTypes.length === 0 || !slackConfig.conversationTypes.every((type) => allowedTypes.includes(type))) {
+  if (config.conversationTypes.length === 0 || !config.conversationTypes.every((type) => allowedTypes.includes(type))) {
     throw new IngestConfigError('Slack conversationTypes must select public_channel, private_channel, im, or mpim.')
   }
-  const channels: SlackEntity[] = []
+  const selected = config.channels
+  const missing = new Set(selected)
   for await (const page of readCollection(context, {
     method: 'conversations.list', field: 'channels', idField: 'id',
-    query: { types: slackConfig.conversationTypes.join(','), exclude_archived: 'false' },
-  }, deps)) channels.push(...page)
-  const selected = slackConfig.channels
-  if (selected === undefined) return channels
-  for (const id of selected) {
-    if (!channels.some((channel) => entityId(channel, 'id') === id)) {
-      throw new IngestConfigError(`Configured Slack channel "${id}" was not found or is not accessible for conversationTypes.`)
-    }
+    query: { types: config.conversationTypes.join(','), exclude_archived: 'false' },
+  }, deps)) {
+    const channels = selected === undefined ? page.items : page.items.filter((channel) => selected.includes(entityId(channel, 'id')))
+    for (const channel of channels) missing.delete(entityId(channel, 'id'))
+    yield { ...page, items: channels }
+  }
+  for (const id of missing) {
+    throw new IngestConfigError(`Configured Slack channel "${id}" was not found or is not accessible for conversationTypes.`)
   }
-  return channels.filter((channel) => selected.includes(entityId(channel, 'id')))
 }
 
 /** Scope row identities to the authenticated workspace, never its mutable display name. */
-export async function getWorkspace(context: FetchContext, deps: SlackClientDeps = defaultDeps): Promise<string> {
+export async function getWorkspace(context: FetchContext, deps: SlackClientDeps = defaultSlackClientDeps): Promise<string> {
   return context.attempt(async (signal) => {
     const payload = await requestSlack('auth.test', {}, signal, deps)
     return entityId(payload, 'team_id')
@@ -91,14 +99,15 @@ export function toSlackRows(
   teamId: string,
   idField: 'id' | 'ts',
   channelId?: string,
+  sourceId = slackConfig.sourceId,
 ) {
   return rawRows(
     items.map((data) => ({
-      source_id: slackConfig.sourceId, team_id: teamId,
+      source_id: sourceId, team_id: teamId,
       ...(channelId === undefined ? {} : { channel_id: channelId }), data,
     })),
     ({ data }) => JSON.stringify([
-      slackConfig.sourceId, resource, teamId, ...(channelId === undefined ? [] : [channelId]), entityId(data, idField),
+      sourceId, resource, teamId, ...(channelId === undefined ? [] : [channelId]), entityId(data, idField),
     ]),
   )
 }
@@ -120,6 +129,13 @@ export const classifySlackError: ErrorClassifier = (cause) => {
   return undefined
 }
 
+async function fetchCollectionPage(request: CollectionRequest, cursor: string, signal: AbortSignal, deps: SlackClientDeps): Promise<SlackPage> {
+  const limit = request.pageSize ?? (request.field === 'messages' ? deps.config.messagePageSize : deps.config.pageSize)
+  if (!Number.isSafeInteger(limit) || limit <= 0 || limit >= 1_000) throw new IngestConfigError('Slack page sizes must be safe integers between 1 and 999.')
+  const query = { ...request.query, limit: String(limit), ...(cursor ? { cursor } : {}) }
+  return parsePage(await requestSlack(request.method, query, signal, deps), request)
+}
+
 async function requestSlack(
   method: CollectionRequest['method'] | 'auth.test',
   query: Record<string, string>,
@@ -129,7 +145,7 @@ async function requestSlack(
   const token = deps.token()?.trim()
   if (!token) throw new IngestConfigError('Set SLACK_API_TOKEN before running Slack ingestion. Schema imports do not need credentials.')
   const interval = method === 'conversations.history' || method === 'conversations.replies'
-    ? slackConfig.messageIntervalMs : slackConfig.requestIntervalMs
+    ? deps.config.messageIntervalMs : deps.config.requestIntervalMs
   if (!Number.isSafeInteger(interval) || interval < 0 || interval > 2_147_483_647) {
     throw new IngestConfigError('Slack request intervals must be non-negative safe integers within the timer range.')
   }
@@ -151,6 +167,7 @@ async function requestSlack(
   // Slack reports authentication, permission, and transient errors in HTTP 200 responses.
   if (!payload.ok) {
     const code = typeof payload.error === 'string' ? payload.error : 'unknown_error'
+    if (code === 'invalid_cursor') throw new SlackCursorExpiredError(`Slack ${method} pagination cursor expired.`)
     if (code === 'ratelimited' || code === 'rate_limited') {
       const headers = new Headers(response.headers)
       if (!headers.has('Retry-After')) headers.set('Retry-After', '60')
@@ -190,10 +207,10 @@ function parsePage(payload: Record<string, unknown>, request: CollectionRequest)
   if (payload.has_more !== undefined && typeof payload.has_more !== 'boolean') {
     throw new IngestConfigError(`Slack ${request.method} returned an invalid has_more flag.`)
   }
-  if (payload.has_more === true && !cursor) {
+  if (payload.has_more === true && !cursor && !request.timePagination) {
     throw new IngestConfigError(`Slack ${request.method} reports more data without a pagination cursor; refusing an incomplete scan.`)
   }
-  return { items, cursor }
+  return { items, cursor, hasMore: payload.has_more === true || cursor.length > 0 }
 }
 
 function isObject(value: unknown): value is Record<string, unknown> {
diff --git a/registry/slack/config.ts b/registry/slack/config.ts
index ab5af1e1..48a45b43 100644
--- a/registry/slack/config.ts
+++ b/registry/slack/config.ts
@@ -11,8 +11,14 @@ export interface SlackConfig {
   messagePageSize: number
   requestIntervalMs: number
   messageIntervalMs: number
+  /** Optional bootstrap lower bound; undefined starts with the recent overlap window. */
+  historyFrom?: string
+  overlapMs: number
 }
 
+/** Runtime reader settings; destination names are defined when the schemas load. */
+export type SlackReaderConfig = Omit<SlackConfig, 'database' | 'tablePrefix'>
+
 // Credentials are read only in client.ts at request time. Keep these values stable across runs.
 export const slackConfig: SlackConfig = {
   sourceId: 'slack.primary',
@@ -27,4 +33,6 @@ export const slackConfig: SlackConfig = {
   messagePageSize: 15,
   requestIntervalMs: 3_000,
   messageIntervalMs: 60_000,
+  historyFrom: undefined,
+  overlapMs: 86_400_000,
 }
diff --git a/registry/slack/manifest.json b/registry/slack/manifest.json
index b07d86ac..4eab58ae 100644
--- a/registry/slack/manifest.json
+++ b/registry/slack/manifest.json
@@ -3,71 +3,189 @@
   "name": "slack",
   "type": "registry:item",
   "title": "Slack",
-  "description": "Editable Slack API readers and raw ClickHouse tables for conversations, users, messages, and thread replies.",
-  "dependencies": ["@chkit/core@^0.2.0-beta.8", "@chkit/plugin-ingest@^0.2.0-beta.8"],
-  "devDependencies": ["@types/bun@^1.2.0"],
+  "description": "Editable raw Slack readers with recent overlapping message ranges and checkpoints after complete history pages and replies.",
+  "dependencies": [
+    "@chkit/core@^0.2.0-beta.10",
+    "@chkit/plugin-ingest@^0.2.0-beta.10"
+  ],
+  "devDependencies": [
+    "@types/bun@^1.2.0"
+  ],
   "files": [
-    { "path": "README.md", "type": "registry:file", "target": "src/integrations/slack/README.md" },
-    { "path": "client.ts", "type": "registry:file", "target": "src/integrations/slack/client.ts" },
-    { "path": "config.ts", "type": "registry:file", "target": "src/integrations/slack/config.ts" },
-    { "path": "index.ts", "type": "registry:file", "target": "src/integrations/slack/index.ts" },
-    { "path": "pipeline.ts", "type": "registry:file", "target": "src/integrations/slack/pipeline.ts" },
-    { "path": "sources/channels.ts", "type": "registry:file", "target": "src/integrations/slack/sources/channels.ts" },
-    { "path": "sources/users.ts", "type": "registry:file", "target": "src/integrations/slack/sources/users.ts" },
-    { "path": "sources/messages.ts", "type": "registry:file", "target": "src/integrations/slack/sources/messages.ts" },
-    { "path": "tests/slack.test.ts", "type": "registry:file", "target": "src/integrations/slack/tests/slack.test.ts", "role": "test" },
-    { "path": "tests/fixtures.ts", "type": "registry:file", "target": "src/integrations/slack/tests/fixtures.ts", "role": "test" }
+    {
+      "path": "README.md",
+      "type": "registry:file",
+      "target": "src/integrations/slack/README.md"
+    },
+    {
+      "path": "client.ts",
+      "type": "registry:file",
+      "target": "src/integrations/slack/client.ts"
+    },
+    {
+      "path": "config.ts",
+      "type": "registry:file",
+      "target": "src/integrations/slack/config.ts"
+    },
+    {
+      "path": "index.ts",
+      "type": "registry:file",
+      "target": "src/integrations/slack/index.ts"
+    },
+    {
+      "path": "pipeline.ts",
+      "type": "registry:file",
+      "target": "src/integrations/slack/pipeline.ts"
+    },
+    {
+      "path": "sources/channels.ts",
+      "type": "registry:file",
+      "target": "src/integrations/slack/sources/channels.ts"
+    },
+    {
+      "path": "sources/users.ts",
+      "type": "registry:file",
+      "target": "src/integrations/slack/sources/users.ts"
+    },
+    {
+      "path": "sources/messages.ts",
+      "type": "registry:file",
+      "target": "src/integrations/slack/sources/messages.ts"
+    },
+    {
+      "path": "tests/slack.test.ts",
+      "type": "registry:file",
+      "target": "src/integrations/slack/tests/slack.test.ts",
+      "role": "test"
+    },
+    {
+      "path": "tests/fixtures.ts",
+      "type": "registry:file",
+      "target": "src/integrations/slack/tests/fixtures.ts",
+      "role": "test"
+    },
+    {
+      "path": "state.ts",
+      "type": "registry:file",
+      "target": "src/integrations/slack/state.ts"
+    },
+    {
+      "path": "tests/checkpoints.test.ts",
+      "type": "registry:file",
+      "target": "src/integrations/slack/tests/checkpoints.test.ts",
+      "role": "test"
+    }
   ],
   "meta": {
     "chkit": {
       "formatVersion": 1,
-      "version": "0.1.1",
+      "version": "0.2.0",
+      "changelog": [
+        {
+          "version": "0.2.0",
+          "changes": [
+            "Use one installation pipeline with independently selectable channels, users, and messages streams and unchanged raw tables and scoped record identities.",
+            "Default messages to a recent 24-hour bootstrap, then overlap the completed watermark by 24 hours; allow explicit historyFrom bootstrap coverage and isolated bounded backfills.",
+            "Checkpoint fixed windows and complete history pages after all their selected replies load; replay an interrupted page without durable thread queues or child cursors.",
+            "Reuse full paginate pages and native has_more metadata with exact timestamp frontiers and bounded temporary-cursor replay; reject incompatible strategy state explicitly.",
+            "Document that old edits and late replies on roots outside the selected range are outside normal coverage; remove periodic historical reconciliation and include portable recovery fixtures."
+          ]
+        },
+        {
+          "version": "0.1.1",
+          "changes": [
+            "Add provider logo presentation metadata; distributed source is unchanged."
+          ]
+        },
+        {
+          "version": "0.1.0",
+          "changes": [
+            "Introduce raw conversations, users, messages, and thread replies with configurable conversation selection and request pacing."
+          ]
+        }
+      ],
       "documentation": "https://chkit.obsessiondb.com/integrations/slack/",
       "logo": "https://chkit.obsessiondb.com/logos/slack.svg",
       "language": "typescript",
       "license": "MIT",
-      "chkit": "^0.2.0-beta.8",
-      "ingest": "^0.2.0-beta.8",
+      "chkit": "^0.2.0-beta.10",
+      "ingest": "^0.2.0-beta.10",
       "clickhouse": ">=25.3.0",
       "root": "src/integrations/slack",
       "entry": "index.ts",
-      "exports": ["slack", "slackChannelsRaw", "slackUsersRaw", "slackMessagesRaw"],
+      "exports": [
+        "slack",
+        "slackChannelsRaw",
+        "slackUsersRaw",
+        "slackMessagesRaw"
+      ],
       "resources": [
         {
           "name": "channels",
           "title": "Conversations",
           "table": "slack_channels_raw",
           "description": "Selected accessible conversations, including archived channels, with complete returned topics, purpose, membership flags, and shared-channel metadata. Public channels by default; private channels, DMs, and group DMs are opt-in.",
-          "scopes": ["channels:read"],
+          "scopes": [
+            "channels:read"
+          ],
           "strategy": "full",
-          "endpoints": [{ "method": "GET", "path": "/conversations.list", "documentation": "https://docs.slack.dev/reference/methods/conversations.list/" }]
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/conversations.list",
+              "documentation": "https://docs.slack.dev/reference/methods/conversations.list/"
+            }
+          ]
         },
         {
           "name": "users",
           "title": "Users",
           "table": "slack_users_raw",
           "description": "Complete returned workspace member and bot profiles, IDs, names, status, timezone, and deactivation flags. Email requires the optional users:read.email scope.",
-          "scopes": ["users:read"],
+          "scopes": [
+            "users:read"
+          ],
           "strategy": "full",
-          "endpoints": [{ "method": "GET", "path": "/users.list", "documentation": "https://docs.slack.dev/reference/methods/users.list/" }]
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/users.list",
+              "documentation": "https://docs.slack.dev/reference/methods/users.list/"
+            }
+          ]
         },
         {
           "name": "messages",
           "title": "Messages and thread replies",
           "table": "slack_messages_raw",
-          "description": "All retained accessible history in selected conversations and replies to every discovered thread, preserving timestamp strings, text, blocks, attachments, file references, reactions, subtypes, and metadata as returned. No file downloads or separate reaction enumeration.",
-          "scopes": ["channels:read", "channels:history"],
-          "strategy": "full",
+          "description": "Raw messages selected by recent overlapping timestamp windows, plus replies belonging to selected roots. History-page progress commits after every selected reply is loaded. Old roots outside the range are not revisited; timestamps remain exact strings.",
+          "scopes": [
+            "channels:read",
+            "channels:history"
+          ],
+          "strategy": "cursor",
           "endpoints": [
-            { "method": "GET", "path": "/conversations.history", "documentation": "https://docs.slack.dev/reference/methods/conversations.history/" },
-            { "method": "GET", "path": "/conversations.replies", "documentation": "https://docs.slack.dev/reference/methods/conversations.replies/" }
+            {
+              "method": "GET",
+              "path": "/conversations.history",
+              "documentation": "https://docs.slack.dev/reference/methods/conversations.history/"
+            },
+            {
+              "method": "GET",
+              "path": "/conversations.replies",
+              "documentation": "https://docs.slack.dev/reference/methods/conversations.replies/"
+            }
           ]
         }
       ],
-      "env": { "SLACK_API_TOKEN": "" },
+      "env": {
+        "SLACK_API_TOKEN": ""
+      },
       "authentication": {
         "method": "Slack OAuth bearer token (user token recommended)",
-        "env": ["SLACK_API_TOKEN"],
+        "env": [
+          "SLACK_API_TOKEN"
+        ],
         "documentation": "https://docs.slack.dev/authentication/tokens/",
         "setup": [
           "Create a Slack app for the workspace at api.slack.com/apps. Open OAuth & Permissions.",
@@ -79,8 +197,8 @@
       },
       "views": [],
       "sync": {
-        "description": "Each run fully reads enabled resources. Messages discover their own selected conversations, read retained history, and revisit every discovered thread when includeReplies is true. Conservative history/replies defaults use 15-item pages and a 60-second delay before requests; internal apps can tune these to their Slack tier.",
-        "schedule": "Run chkit ingest run through cron, CI, or an existing scheduler, with one process per project/target. Select channel IDs and size the execution budget for a complete scan; interrupted full reads restart from the beginning.",
+        "description": "Channels and users are full reads. Messages initially select the recent 24 hours unless historyFrom is set, then overlap the completed watermark by 24 hours. Each history page and all its selected replies finish before its timestamp frontier commits. Temporary cursors and child progress are not persisted; old-root replies and old edits outside the selected range are outside normal coverage.",
+        "schedule": "Run chkit ingest run through cron, CI, or an existing scheduler, with one process per project/target. Interrupted message windows keep their fixed bounds and replay the incomplete history page; users/channels restart full reads. One history page and all its replies must fit the execution budget. Conservative message pacing remains 15 items and one request per minute.",
         "deletions": "Later observations replace stable row IDs, but deleted, inaccessible, or deselected records remain. The integration does not consume Slack events, propagate deletions, or maintain a complete change log."
       }
     }
diff --git a/registry/slack/pipeline.ts b/registry/slack/pipeline.ts
index 8229b074..099a810c 100644
--- a/registry/slack/pipeline.ts
+++ b/registry/slack/pipeline.ts
@@ -1,24 +1,32 @@
 import { definePipeline, defineStream } from '@chkit/plugin-ingest'
 
-import { classifySlackError } from './client.js'
-import { slackConfig } from './config.js'
+import { classifySlackError, defaultSlackClientDeps, type SlackClientDeps } from './client.js'
+import { slackConfig, type SlackReaderConfig } from './config.js'
 import { readChannels, slackChannelsRaw } from './sources/channels.js'
 import { readUsers, slackUsersRaw } from './sources/users.js'
 import { readMessages, slackMessagesRaw } from './sources/messages.js'
+import { createSlackMessageStrategy } from './state.js'
 
 const streamOptions = { classifyError: classifySlackError, batchSize: 500 }
 
-// Delete a stream entry to stop collecting it; keep its schema export to retain existing data.
-export const slack = definePipeline({
-  id: slackConfig.sourceId,
-  tags: ['provider:slack'],
-  maxStreams: 1,
-  maxFetches: 1,
-  maxLoads: 1,
-  retry: { retries: 5, minTimeout: 1_000, maxTimeout: 60_000, randomize: true },
-  streams: [
-    defineStream({ ...streamOptions, id: `${slackConfig.sourceId}.channels`, tags: ['resource:channels'], destination: slackChannelsRaw, read: readChannels }),
-    defineStream({ ...streamOptions, id: `${slackConfig.sourceId}.users`, tags: ['resource:users'], destination: slackUsersRaw, read: readUsers }),
-    defineStream({ ...streamOptions, id: `${slackConfig.sourceId}.messages`, tags: ['resource:messages'], destination: slackMessagesRaw, read: readMessages }),
-  ],
-})
+// One installation pipeline, with independent streams for the three resource types.
+// Destination names come from config.ts when the raw schemas load.
+export function createSlackPipeline(config: SlackReaderConfig = slackConfig, deps: SlackClientDeps = defaultSlackClientDeps) {
+  const boundConfig = { ...config, channels: config.channels ? [...config.channels] : undefined, conversationTypes: [...config.conversationTypes] }
+  const client = { ...deps, config: boundConfig }
+  return definePipeline({
+    id: boundConfig.sourceId,
+    tags: ['provider:slack'],
+    maxStreams: 1,
+    maxFetches: 1,
+    maxLoads: 1,
+    retry: { retries: 5, minTimeout: 1_000, maxTimeout: 60_000, randomize: true },
+    streams: [
+      defineStream({ ...streamOptions, id: `${boundConfig.sourceId}.channels`, tags: ['resource:channels'], destination: slackChannelsRaw, read: (context) => readChannels(context, client) }),
+      defineStream({ ...streamOptions, id: `${boundConfig.sourceId}.users`, tags: ['resource:users'], destination: slackUsersRaw, read: (context) => readUsers(context, client) }),
+      defineStream({ ...streamOptions, batchSize: 1, id: `${boundConfig.sourceId}.messages`, tags: ['resource:messages'], destination: slackMessagesRaw, incremental: createSlackMessageStrategy(boundConfig), read: (context) => readMessages(context, client) }),
+    ],
+  })
+}
+
+export const slack = createSlackPipeline()
diff --git a/registry/slack/releases/0.2.0.json b/registry/slack/releases/0.2.0.json
new file mode 100644
index 00000000..5a5dd560
--- /dev/null
+++ b/registry/slack/releases/0.2.0.json
@@ -0,0 +1,232 @@
+{
+  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
+  "name": "slack",
+  "type": "registry:item",
+  "title": "Slack",
+  "description": "Editable raw Slack readers with recent overlapping message ranges and checkpoints after complete history pages and replies.",
+  "dependencies": [
+    "@chkit/core@^0.2.0-beta.10",
+    "@chkit/plugin-ingest@^0.2.0-beta.10"
+  ],
+  "devDependencies": [
+    "@types/bun@^1.2.0"
+  ],
+  "files": [
+    {
+      "path": "slack/README.md",
+      "type": "registry:file",
+      "target": "src/integrations/slack/README.md",
+      "content": "# Slack raw ingestion\n\nThis is editable source code: change the readers, schemas, and `pipeline.ts` directly. It uses the [chkit CLI](https://www.npmjs.com/package/chkit), `@chkit/core`, and `@chkit/plugin-ingest`; subsequent runs execute the installed code without contacting the registry.\n\n## First run\n\nSet `SLACK_API_TOKEN` in the execution environment and configure the project's direct ClickHouse connection. Native JSON requires ClickHouse 25.3 or newer. Review `config.ts` before generating the first migration; the default database is `default` and table names start with `slack_`.\n\n### Create a Slack token\n\n1. Create a Slack app for the intended workspace through [Slack app settings](https://docs.slack.dev/app-management/quickstart-app-settings/).\n2. Open **OAuth & Permissions** and add **User Token Scopes** `channels:read`, `channels:history`, and `users:read` for the default public-channel integration. Add `users:read.email` if profile email addresses are needed.\n3. Install or reinstall the app in the workspace and approve the requested scopes. Copy the **User OAuth Token** from **OAuth & Permissions**.\n4. Set `SLACK_API_TOKEN` in the project's `.env` or the scheduler's secret environment.\n\nUser OAuth tokens are recommended for broad history and thread access. A bot may list public channels it has not joined, so select IDs of joined conversations rather than `channels: undefined`. Thread reads also require matching history scopes and conversation access; see [`conversations.replies`](https://docs.slack.dev/reference/methods/conversations.replies/). An enabled thread permission failure fails the messages stream visibly. Fix token access or explicitly set `includeReplies: false` for history-only ingestion. See [Slack tokens](https://docs.slack.dev/authentication/tokens/).\n\nBun loads a project `.env`. A scheduler or other runtime must explicitly supply the variables. `.env.example` lists names and does not load credentials. Tokens are read when requests run; schema imports, `check`, migration generation, and `ingest list` make no Slack requests and need no token. The integration does not obtain or refresh OAuth credentials.\n\n```sh\nbunx chkit check\nbunx chkit ingest list --tag provider:slack\nbunx chkit generate --name add-slack\n# Review the generated SQL.\nbunx chkit migrate --apply\nbunx chkit ingest run --tag provider:slack\n```\n\nUse an external scheduler to repeat ingestion, with one ingestion process per project and destination at a time.\n\n## Included resources\n\nOne installation pipeline contains independent streams for channels, users, and messages. Channels and users read their complete selected resource on every run. Messages bootstrap the recent 24 hours by default and then read checkpointed overlapping time ranges. Each reader discovers its authenticated workspace through `auth.test`; messages independently discover conversations. A channel is an individual entity inside the messages resource, so channel and thread traversal stays within that stream.\n\n| Stream tag | Default raw table | Required scopes for defaults |\n|---|---|---|\n| `resource:channels` | `slack_channels_raw` | `channels:read` |\n| `resource:users` | `slack_users_raw` | `users:read`; optional `users:read.email` |\n| `resource:messages` | `slack_messages_raw` | `channels:read`, `channels:history` |\n\n- **Channels:** conversation metadata returned by [`conversations.list`](https://docs.slack.dev/reference/methods/conversations.list/), including archived conversations when returned. No separate `conversations.info` expansion or membership request.\n- **Users:** complete objects returned by [`users.list`](https://docs.slack.dev/reference/methods/users.list/), including profiles, bots, and deleted-user flags.\n- **Messages:** the selected timestamp range of accessible [`conversations.history`](https://docs.slack.dev/reference/methods/conversations.history/) pages for selected conversations. With `includeReplies: true`, roots with `reply_count > 0` also fetch every `conversations.replies` page. Replies and their parents share the raw messages table.\n\nMessages preserve blocks, attachments, reactions, metadata, and file references when returned. File references do not download files. No separate files, reactions, pins, canvases, search, or events reader is included.\n\nReplies are individual Message objects with their own `ts` and a `thread_ts` parent reference, so they use the messages stream and table. The reader does not assemble a conversation array inside each parent or enrich messages with channel/user records. Run messages before, after, or without the metadata streams; it discovers conversation IDs independently and checkpoints each completed history page after its replies finish. Join users, channels, and thread parents later in ClickHouse using source, workspace, channel, and native message keys.\n\n## Choose conversations and request pacing\n\nThe default config selects public channels, includes replies, uses metadata pages of 200, and uses history/reply pages of 15. `requestIntervalMs` defaults to 3000; `messageIntervalMs` defaults to 60000.\n\nSet `channels` to an array of Slack conversation IDs to restrict channels and messages. `undefined` selects all discovered conversations; `[]` selects none. Selection uses IDs, not names. A configured ID absent from discovery fails visibly. Users remain workspace-wide.\n\n`conversationTypes` defaults to `['public_channel']`. Additional types require these read scopes and history scopes:\n\n| Type | Discovery | History and replies |\n|---|---|---|\n| `public_channel` | `channels:read` | `channels:history` |\n| `private_channel` | `groups:read` | `groups:history` |\n| `im` | `im:read` | `im:history` |\n| `mpim` | `mpim:read` | `mpim:history` |\n\nKeep `sourceId` stable after ingestion begins. A second workspace should use a distinct source ID and a separate table prefix or database. Changing these values changes stream and storage identities and requires a deliberate migration.\n\n`createSlackPipeline` in `pipeline.ts` binds source identity, selection, page sizes, pacing, and message state settings when the pipeline is created. Later changes to a config object do not alter that pipeline. Raw table names are defined from `config.ts` when the schema modules load; the factory does not rename or create destination schemas. Set `database` and `tablePrefix` in the installed config before loading schemas and generating migrations.\n\nSlack documents one request per minute and 15 objects per page for new commercially distributed apps outside the Slack Marketplace. Marketplace and internal customer-built apps retain Tier 3 limits. See the current [history method](https://docs.slack.dev/reference/methods/conversations.history/) and [rate-limit clarification](https://docs.slack.dev/changelog/2025/06/03/rate-limits-clarity/). For an internal app entitled to Tier 3, edit `messagePageSize` to 200 and `messageIntervalMs` to 1200 after confirming its limits.\n\nThe pipeline runs one stream, fetch, and load at a time. Requests have a 30-second timeout and use the ingestion executor's retry and cancellation context. The pipeline permits five retries after the initial attempt, with exponential backoff from 1 to 60 seconds. HTTP `429` honors `Retry-After`; Slack rate-limit responses and transient server codes also retry. Authentication and permission errors, including Slack `ok: false` responses, fail visibly instead of becoming empty datasets.\n\nHistory and thread reads can take hours or days at conservative defaults. Restrict conversations and selected streams, and choose `--max-duration` for the workload. The CLI default is 3600 seconds. Interrupted message reads resume a completed timestamp boundary and replay the incomplete history page with its replies; metadata reads restart. A history page and all its replies must fit the execution budget, including its completion marker. Reduce messagePageSize or increase the budget if that unit repeatedly cannot finish.\n\nTo read only messages:\n\n```sh\nbunx chkit ingest run --tag provider:slack --tag resource:messages --max-duration 86400\n```\n\n## Stored data and identities\n\nEvery raw table contains stable `id`, native JSON `raw`, and chkit batch/run/ingestion-time columns. `raw` contains `source_id`, authenticated `team_id`, and the complete provider object under `data`. Messages also contain `channel_id`.\n\nThe row IDs are JSON-encoded arrays:\n\n| Resource | Identity |\n|---|---|\n| Channels | `[sourceId, 'channels', teamId, conversation.id]` |\n| Users | `[sourceId, 'users', teamId, user.id]` |\n| Messages | `[sourceId, 'messages', teamId, channelId, message.ts]` |\n\nMessage timestamps remain strings. A parent returned by `conversations.replies` has the same identity as its history observation. Replies use their own timestamps; their `thread_ts` retains the root reference. Channel names, user emails, and message text are never keys.\n\nThe tables use `ReplacingMergeTree(_chkit_ingested_at)`. Later ingestion time wins; there is no Slack source-version ordering. Use `FINAL` for the latest observed row:\n\n```sql\nWITH toJSONString(raw) AS payload\nSELECT\n  JSONExtractString(payload, 'channel_id') AS channel_id,\n  JSONExtractString(payload, 'data', 'ts') AS ts,\n  JSONExtractString(payload, 'data', 'thread_ts') AS thread_ts,\n  JSONExtractString(payload, 'data', 'user') AS user_id,\n  JSONExtractString(payload, 'data', 'text') AS text\nFROM default.slack_messages_raw FINAL\nLIMIT 20;\n```\n\nThere are no packaged typed views. Add SQL projections in the project's schema for the fields needed by the application. Preserve source and workspace identity in joins.\n\n## Incremental messages and recovery\n\nThe first messages run reads the recent 24 hours to a fixed execution cutoff. Set `historyFrom` to an exact timestamp string for a broader initial bootstrap; its default is `undefined`. Later runs begin at the completed watermark minus `overlapMs` (24 hours by default), so gaps between runs remain eligible. Newly discovered channels use the same selected range. There is no periodic historical reconciliation.\n\nCheckpoints retain exact timestamp strings, the authenticated workspace and query scope, fixed bounds, channel position, and the last completed history-page frontier. History progresses newest first; replies progress oldest first using temporary local boundaries. A history page and all of its selected replies must finish before an empty checkpoint marker advances history. Interrupted pages replay from their original boundary, including any child rows already loaded. Temporary API cursors never enter durable state; expiry replays that unfinished timestamp interval once. Empty terminal pages also commit progress.\n\nOne history page and all its replies must fit a fresh execution's duration and chunk budget, including the completion marker. A budget that always stops before that marker will keep replaying the same page. Reduce `messagePageSize`, raise the budget, or narrow the selected workload. The integration deliberately accepts page replay instead of maintaining durable per-thread or per-reply checkpoints.\n\nKeep source identity and selection stable; changing the account, channels, types, reply policy, bootstrap lower bound, or overlap fails against existing state. Use a new source ID for a deliberate separate installation. The message strategy is version 2; incompatible saved strategy versions require an explicit migration or a new stream identity. Version 0.2.0 preserves raw tables and row IDs. Earlier released full readers had no saved provider state; their first upgraded messages run bootstraps once.\n\nThe destination stores the latest **observed** payload per identity. Deleted messages, deselected conversations, and data made inaccessible remain in ClickHouse. Loaded batches stay visible when a run fails; there is no atomic snapshot replacement or rollback. Changes during pagination may cause misses or repeated observations. Slack retention, permissions, and token access determine historical coverage.\n\nReplies are fetched only for roots returned in the selected history range, up to the fixed upper cutoff. Old edits and late replies attached to roots outside that range are outside normal coverage. The integration has no historical reconciliation, deletion reconciliation, permanent edit log, webhooks, or continuous change capture.\n\nMessages support isolated date-bound backfills with `--backfill <id> --from <date> --to <date>`. Bounds select root/history timestamps; child replies for those roots are read up to the upper cutoff. Unfinished backfills retain their original bounds; changing those bounds requires another ID. An omitted upper bound freezes the original execution cutoff. Channels and users remain full reads and do not interpret date ranges. Historical raw observations loaded later can replace newer observations because replacement uses ingestion time.\n\n## Customize the source\n\n`sources/channels.ts`, `sources/users.ts`, and `sources/messages.ts` each contain a resource's raw schema and reader. `client.ts` handles HTTP, authentication, validation, row IDs, and pacing; all three readers use the plugin's `paginate` helper. Messages use it to cross empty or parent-only pages, retain native `has_more` in metadata, and return to timestamp pagination as soon as rows establish a safe frontier. `state.ts` validates provider timestamp checkpoints; `pipeline.ts` binds reader configuration and composes the three streams. Each stream has its own journal progress and resource tag, so selecting users does not run messages and a message failure does not prevent a users run.\n\nConversation selection validates configured IDs after discovery finishes. If a configured ID is missing, the stream fails visibly; any metadata pages already loaded remain visible.\n\nRemove a stream from `pipeline.ts` to stop ingestion while retaining its schema export in `index.ts` to preserve the table. Removing schema exports can generate destructive migration operations; review them. Test reader changes and revisit pacing when changing concurrency.\n\n## Fixture tests\n\nInstall the optional portable test suite, then run it:\n\n```sh\nbunx chkit add slack --with-tests\nbun test src/integrations/slack/tests/slack.test.ts src/integrations/slack/tests/checkpoints.test.ts\n```\n\nFor a custom install path, point the command at its `tests/slack.test.ts`. Tests use sanitized responses, mocked HTTP, and in-memory ingestion destinations. They require Bun and no Slack credentials or ClickHouse server. Update fixtures and expectations alongside customized readers.\n\n## Smoke check\n\nAfter a migration and successful run, inspect `chkit ingest status --tag provider:slack` and query `SELECT count() FROM default.slack_messages_raw FINAL`. Compare a known message and an older thread with their stored payloads. Add a reply to that old thread, then run a messages-only backfill with a new ID and `--from` before the root's timestamp to verify the reply is collected. Normal incremental runs revisit roots within the selected overlap; an old root outside that range requires an explicit backfill. Row counts alone do not establish complete live API coverage.\n\nThe [Slack integration guide](https://chkit.obsessiondb.com/integrations/slack/) covers installation, SQL queries, scheduling, and recovery.\n"
+    },
+    {
+      "path": "slack/client.ts",
+      "type": "registry:file",
+      "target": "src/integrations/slack/client.ts",
+      "content": "import { setTimeout as sleep } from 'node:timers/promises'\n\nimport { HttpError, IngestConfigError, paginate, rawRows, type ErrorClassifier, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { slackConfig, type SlackReaderConfig } from './config.js'\n\nexport type SlackEntity = Record<string, unknown>\n\nexport interface SlackClientDeps {\n  config: SlackReaderConfig\n  fetch: (url: string, init: RequestInit) => Promise<Response>\n  token: () => string | undefined\n  wait: (milliseconds: number, signal: AbortSignal) => Promise<void>\n}\n\nexport interface CollectionRequest {\n  method: 'conversations.list' | 'users.list' | 'conversations.history' | 'conversations.replies'\n  field: 'channels' | 'members' | 'messages'\n  idField: 'id' | 'ts'\n  query?: Record<string, string>\n  pageSize?: number\n  /** Read empty/parent-only cursor pages until the next durable timestamp boundary. */\n  timePagination?: boolean\n}\n\ninterface SlackPage { items: SlackEntity[]; cursor: string; hasMore: boolean }\nexport class SlackCursorExpiredError extends IngestConfigError {}\n\nexport const defaultSlackClientDeps: SlackClientDeps = {\n  config: slackConfig,\n  fetch: (url, init) => fetch(url, init),\n  token: () => process.env.SLACK_API_TOKEN,\n  wait: async (milliseconds, signal) => { await sleep(milliseconds, undefined, { signal }) },\n}\n\n/** Each page is validated inside attempt, so executor retry/cancellation owns every request. */\nexport function readCollection(\n  context: FetchContext,\n  request: CollectionRequest,\n  deps: SlackClientDeps = defaultSlackClientDeps,\n) {\n  return paginate({\n    context, label: `GET /api/${request.method}`,\n    fetchPage: async (cursor: string | undefined, signal) => {\n      const page = await fetchCollectionPage(request, cursor ?? '', signal, deps)\n      const timeBoundary = request.timePagination && (page.items.some((item) =>\n        request.method !== 'conversations.replies' || entityId(item, 'ts') !== request.query?.ts) || !page.hasMore)\n      if (request.timePagination && !timeBoundary && !page.cursor) {\n        throw new IngestConfigError('Slack empty page did not provide a new continuation.')\n      }\n      // Catalog reads follow cursors even across empty/short pages.\n      // Timestamp reads stop at a data boundary; native has_more still plans their next interval.\n      return { items: page.items, next: timeBoundary ? undefined : page.cursor || undefined, metadata: { hasMore: page.hasMore } }\n    },\n  })\n}\n\n/** Discover independently in each reader; pipeline stream order is not a dependency. */\nexport async function discoverChannels(context: FetchContext, deps: SlackClientDeps = defaultSlackClientDeps): Promise<SlackEntity[]> {\n  const channels: SlackEntity[] = []\n  for await (const page of readChannelPages(context, deps)) channels.push(...page.items)\n  return channels\n}\n\n/** Yield selected metadata pages directly; configured IDs must all be accessible. */\nexport async function* readChannelPages(context: FetchContext, deps: SlackClientDeps = defaultSlackClientDeps) {\n  const config = deps.config\n  const allowedTypes = ['public_channel', 'private_channel', 'im', 'mpim']\n  if (config.conversationTypes.length === 0 || !config.conversationTypes.every((type) => allowedTypes.includes(type))) {\n    throw new IngestConfigError('Slack conversationTypes must select public_channel, private_channel, im, or mpim.')\n  }\n  const selected = config.channels\n  const missing = new Set(selected)\n  for await (const page of readCollection(context, {\n    method: 'conversations.list', field: 'channels', idField: 'id',\n    query: { types: config.conversationTypes.join(','), exclude_archived: 'false' },\n  }, deps)) {\n    const channels = selected === undefined ? page.items : page.items.filter((channel) => selected.includes(entityId(channel, 'id')))\n    for (const channel of channels) missing.delete(entityId(channel, 'id'))\n    yield { ...page, items: channels }\n  }\n  for (const id of missing) {\n    throw new IngestConfigError(`Configured Slack channel \"${id}\" was not found or is not accessible for conversationTypes.`)\n  }\n}\n\n/** Scope row identities to the authenticated workspace, never its mutable display name. */\nexport async function getWorkspace(context: FetchContext, deps: SlackClientDeps = defaultSlackClientDeps): Promise<string> {\n  return context.attempt(async (signal) => {\n    const payload = await requestSlack('auth.test', {}, signal, deps)\n    return entityId(payload, 'team_id')\n  }, { label: 'POST /api/auth.test' })\n}\n\n/** Original fields stay under data; provider fields cannot overwrite envelope metadata. */\nexport function toSlackRows(\n  items: readonly SlackEntity[],\n  resource: string,\n  teamId: string,\n  idField: 'id' | 'ts',\n  channelId?: string,\n  sourceId = slackConfig.sourceId,\n) {\n  return rawRows(\n    items.map((data) => ({\n      source_id: sourceId, team_id: teamId,\n      ...(channelId === undefined ? {} : { channel_id: channelId }), data,\n    })),\n    ({ data }) => JSON.stringify([\n      sourceId, resource, teamId, ...(channelId === undefined ? [] : [channelId]), entityId(data, idField),\n    ]),\n  )\n}\n\nexport function entityId(entity: SlackEntity, field: string): string {\n  const value = entity[field]\n  if (typeof value !== 'string' || value.trim().length === 0) {\n    throw new IngestConfigError(`Slack entity is missing a valid ${field} string.`)\n  }\n  if (field === 'ts' && !/^\\d+\\.\\d+$/.test(value)) {\n    throw new IngestConfigError('Slack message ts must be an unmodified decimal timestamp string.')\n  }\n  return value\n}\n\nexport const classifySlackError: ErrorClassifier = (cause) => {\n  if (cause instanceof IngestConfigError || cause instanceof SyntaxError) return { kind: 'permanent' }\n  // HTTP errors preserve Retry-After, server retries, and permanent 4xx semantics.\n  return undefined\n}\n\nasync function fetchCollectionPage(request: CollectionRequest, cursor: string, signal: AbortSignal, deps: SlackClientDeps): Promise<SlackPage> {\n  const limit = request.pageSize ?? (request.field === 'messages' ? deps.config.messagePageSize : deps.config.pageSize)\n  if (!Number.isSafeInteger(limit) || limit <= 0 || limit >= 1_000) throw new IngestConfigError('Slack page sizes must be safe integers between 1 and 999.')\n  const query = { ...request.query, limit: String(limit), ...(cursor ? { cursor } : {}) }\n  return parsePage(await requestSlack(request.method, query, signal, deps), request)\n}\n\nasync function requestSlack(\n  method: CollectionRequest['method'] | 'auth.test',\n  query: Record<string, string>,\n  signal: AbortSignal,\n  deps: SlackClientDeps,\n): Promise<Record<string, unknown>> {\n  const token = deps.token()?.trim()\n  if (!token) throw new IngestConfigError('Set SLACK_API_TOKEN before running Slack ingestion. Schema imports do not need credentials.')\n  const interval = method === 'conversations.history' || method === 'conversations.replies'\n    ? deps.config.messageIntervalMs : deps.config.requestIntervalMs\n  if (!Number.isSafeInteger(interval) || interval < 0 || interval > 2_147_483_647) {\n    throw new IngestConfigError('Slack request intervals must be non-negative safe integers within the timer range.')\n  }\n  await deps.wait(interval, signal)\n  signal.throwIfAborted()\n  const url = new URL(`https://slack.com/api/${method}`)\n  for (const [key, value] of Object.entries(query)) url.searchParams.set(key, value)\n  const response = await deps.fetch(url.toString(), {\n    method: method === 'auth.test' ? 'POST' : 'GET',\n    headers: { Authorization: `Bearer ${token}`, Accept: 'application/json' },\n    signal: AbortSignal.any([signal, AbortSignal.timeout(30_000)]),\n    redirect: 'error',\n  })\n  if (!response.ok) throw await HttpError.fromResponse(response)\n  const payload: unknown = await response.json()\n  if (!isObject(payload) || typeof payload.ok !== 'boolean') {\n    throw new IngestConfigError(`Slack ${method} returned an invalid response envelope.`)\n  }\n  // Slack reports authentication, permission, and transient errors in HTTP 200 responses.\n  if (!payload.ok) {\n    const code = typeof payload.error === 'string' ? payload.error : 'unknown_error'\n    if (code === 'invalid_cursor') throw new SlackCursorExpiredError(`Slack ${method} pagination cursor expired.`)\n    if (code === 'ratelimited' || code === 'rate_limited') {\n      const headers = new Headers(response.headers)\n      if (!headers.has('Retry-After')) headers.set('Retry-After', '60')\n      throw await HttpError.fromResponse(new Response(JSON.stringify({ error: code }), { status: 429, headers }))\n    }\n    if (['internal_error', 'fatal_error', 'service_unavailable', 'request_timeout'].includes(code)) {\n      throw await HttpError.fromResponse(new Response(JSON.stringify({ error: code }), { status: 503 }))\n    }\n    const needed = typeof payload.needed === 'string' ? ` Required scopes: ${payload.needed}.` : ''\n    const repliesHint = method === 'conversations.replies' ? ' Disable includeReplies explicitly for history-only reads.' : ''\n    throw new IngestConfigError(`Slack ${method} failed (${code}).${needed} Check SLACK_API_TOKEN, resource scopes, and conversation access.${repliesHint}`)\n  }\n  return payload\n}\n\nfunction parsePage(payload: Record<string, unknown>, request: CollectionRequest) {\n  const values = payload[request.field]\n  if (!Array.isArray(values)) throw new IngestConfigError(`Slack ${request.method} returned no ${request.field} array.`)\n  const items = values.map((value: unknown) => {\n    if (!isObject(value)) throw new IngestConfigError(`Slack ${request.method} returned an invalid entity.`)\n    entityId(value, request.idField)\n    if (request.field === 'messages' && value.reply_count !== undefined\n      && (typeof value.reply_count !== 'number' || !Number.isSafeInteger(value.reply_count) || value.reply_count < 0)) {\n      throw new IngestConfigError(`Slack ${request.method} returned an invalid reply_count.`)\n    }\n    return value\n  })\n  const metadata = payload.response_metadata\n  if (metadata !== undefined && !isObject(metadata)) {\n    throw new IngestConfigError(`Slack ${request.method} returned invalid response_metadata.`)\n  }\n  const next = isObject(metadata) ? metadata.next_cursor : undefined\n  if (next !== undefined && next !== null && typeof next !== 'string') {\n    throw new IngestConfigError(`Slack ${request.method} returned an invalid next_cursor.`)\n  }\n  const cursor = typeof next === 'string' ? next.trim() : ''\n  if (payload.has_more !== undefined && typeof payload.has_more !== 'boolean') {\n    throw new IngestConfigError(`Slack ${request.method} returned an invalid has_more flag.`)\n  }\n  if (payload.has_more === true && !cursor && !request.timePagination) {\n    throw new IngestConfigError(`Slack ${request.method} reports more data without a pagination cursor; refusing an incomplete scan.`)\n  }\n  return { items, cursor, hasMore: payload.has_more === true || cursor.length > 0 }\n}\n\nfunction isObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value)\n}\n"
+    },
+    {
+      "path": "slack/config.ts",
+      "type": "registry:file",
+      "target": "src/integrations/slack/config.ts",
+      "content": "export interface SlackConfig {\n  /** Stable, non-secret installation identity. Changing it creates new stream identities. */\n  sourceId: string\n  database: string\n  tablePrefix: string\n  /** Undefined selects every conversation returned for conversationTypes; otherwise use IDs. */\n  channels: readonly string[] | undefined\n  conversationTypes: readonly ('public_channel' | 'private_channel' | 'im' | 'mpim')[]\n  includeReplies: boolean\n  pageSize: number\n  messagePageSize: number\n  requestIntervalMs: number\n  messageIntervalMs: number\n  /** Optional bootstrap lower bound; undefined starts with the recent overlap window. */\n  historyFrom?: string\n  overlapMs: number\n}\n\n/** Runtime reader settings; destination names are defined when the schemas load. */\nexport type SlackReaderConfig = Omit<SlackConfig, 'database' | 'tablePrefix'>\n\n// Credentials are read only in client.ts at request time. Keep these values stable across runs.\nexport const slackConfig: SlackConfig = {\n  sourceId: 'slack.primary',\n  database: 'default',\n  tablePrefix: 'slack',\n  channels: undefined,\n  conversationTypes: ['public_channel'],\n  includeReplies: true,\n  pageSize: 200,\n  // Conservative defaults for commercially distributed apps outside the Slack Marketplace.\n  // Internal customer-built apps can use larger pages and their Tier 3 request rate.\n  messagePageSize: 15,\n  requestIntervalMs: 3_000,\n  messageIntervalMs: 60_000,\n  historyFrom: undefined,\n  overlapMs: 86_400_000,\n}\n"
+    },
+    {
+      "path": "slack/index.ts",
+      "type": "registry:file",
+      "target": "src/integrations/slack/index.ts",
+      "content": "export { slack } from './pipeline.js'\nexport { slackChannelsRaw } from './sources/channels.js'\nexport { slackUsersRaw } from './sources/users.js'\nexport { slackMessagesRaw } from './sources/messages.js'\n"
+    },
+    {
+      "path": "slack/pipeline.ts",
+      "type": "registry:file",
+      "target": "src/integrations/slack/pipeline.ts",
+      "content": "import { definePipeline, defineStream } from '@chkit/plugin-ingest'\n\nimport { classifySlackError, defaultSlackClientDeps, type SlackClientDeps } from './client.js'\nimport { slackConfig, type SlackReaderConfig } from './config.js'\nimport { readChannels, slackChannelsRaw } from './sources/channels.js'\nimport { readUsers, slackUsersRaw } from './sources/users.js'\nimport { readMessages, slackMessagesRaw } from './sources/messages.js'\nimport { createSlackMessageStrategy } from './state.js'\n\nconst streamOptions = { classifyError: classifySlackError, batchSize: 500 }\n\n// One installation pipeline, with independent streams for the three resource types.\n// Destination names come from config.ts when the raw schemas load.\nexport function createSlackPipeline(config: SlackReaderConfig = slackConfig, deps: SlackClientDeps = defaultSlackClientDeps) {\n  const boundConfig = { ...config, channels: config.channels ? [...config.channels] : undefined, conversationTypes: [...config.conversationTypes] }\n  const client = { ...deps, config: boundConfig }\n  return definePipeline({\n    id: boundConfig.sourceId,\n    tags: ['provider:slack'],\n    maxStreams: 1,\n    maxFetches: 1,\n    maxLoads: 1,\n    retry: { retries: 5, minTimeout: 1_000, maxTimeout: 60_000, randomize: true },\n    streams: [\n      defineStream({ ...streamOptions, id: `${boundConfig.sourceId}.channels`, tags: ['resource:channels'], destination: slackChannelsRaw, read: (context) => readChannels(context, client) }),\n      defineStream({ ...streamOptions, id: `${boundConfig.sourceId}.users`, tags: ['resource:users'], destination: slackUsersRaw, read: (context) => readUsers(context, client) }),\n      defineStream({ ...streamOptions, batchSize: 1, id: `${boundConfig.sourceId}.messages`, tags: ['resource:messages'], destination: slackMessagesRaw, incremental: createSlackMessageStrategy(boundConfig), read: (context) => readMessages(context, client) }),\n    ],\n  })\n}\n\nexport const slack = createSlackPipeline()\n"
+    },
+    {
+      "path": "slack/sources/channels.ts",
+      "type": "registry:file",
+      "target": "src/integrations/slack/sources/channels.ts",
+      "content": "import { rawTable, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { defaultSlackClientDeps, getWorkspace, readChannelPages, toSlackRows, type SlackClientDeps } from '../client.js'\nimport { slackConfig } from '../config.js'\n\nexport const slackChannelsRaw = rawTable({ database: slackConfig.database, name: `${slackConfig.tablePrefix}_channels_raw` })\n\nexport async function* readChannels(context: FetchContext, deps: SlackClientDeps = defaultSlackClientDeps) {\n  const teamId = await getWorkspace(context, deps)\n  for await (const page of readChannelPages(context, deps)) {\n    yield { rows: toSlackRows(page.items, 'channels', teamId, 'id', undefined, deps.config.sourceId) }\n  }\n}\n"
+    },
+    {
+      "path": "slack/sources/users.ts",
+      "type": "registry:file",
+      "target": "src/integrations/slack/sources/users.ts",
+      "content": "import { rawTable, type FetchContext } from '@chkit/plugin-ingest'\n\nimport { defaultSlackClientDeps, getWorkspace, readCollection, toSlackRows, type SlackClientDeps } from '../client.js'\nimport { slackConfig } from '../config.js'\n\nexport const slackUsersRaw = rawTable({ database: slackConfig.database, name: `${slackConfig.tablePrefix}_users_raw` })\n\nexport async function* readUsers(context: FetchContext, deps: SlackClientDeps = defaultSlackClientDeps) {\n  const teamId = await getWorkspace(context, deps)\n  for await (const page of readCollection(context, { method: 'users.list', field: 'members', idField: 'id' }, deps)) {\n    yield { rows: toSlackRows(page.items, 'users', teamId, 'id', undefined, deps.config.sourceId) }\n  }\n}\n"
+    },
+    {
+      "path": "slack/sources/messages.ts",
+      "type": "registry:file",
+      "target": "src/integrations/slack/sources/messages.ts",
+      "content": "import { IngestConfigError, rawTable, type ReadContext, type SourceChunk, type RawRow } from '@chkit/plugin-ingest'\n\nimport { defaultSlackClientDeps, discoverChannels, entityId, getWorkspace, readCollection, SlackCursorExpiredError, toSlackRows, type SlackClientDeps, type SlackEntity } from '../client.js'\nimport { slackConfig } from '../config.js'\nimport { formatTimestamp, messageScope, timestampMicros, type SlackMessageSelection, type SlackMessageState } from '../state.js'\n\nexport const slackMessagesRaw = rawTable({ database: slackConfig.database, name: `${slackConfig.tablePrefix}_messages_raw` })\n\n/** Temporary API cursors never enter the checkpoint; exact timestamps survive expiration. */\nexport async function* readMessages(\n  context: ReadContext<SlackMessageSelection, SlackMessageState>,\n  deps: SlackClientDeps = defaultSlackClientDeps,\n): AsyncGenerator<SourceChunk<RawRow, SlackMessageState>> {\n  const config = deps.config\n  const teamId = await getWorkspace(context, deps)\n  const scope = messageScope(teamId, config)\n  if (context.state && context.state.scope !== scope) throw new IngestConfigError('Slack checkpoint belongs to a different workspace or query. Restore the configuration or use a distinct sourceId.')\n  const initialFrom = context.selection.from ?? config.historyFrom ?? formatTimestamp(max(0n, timestampMicros(context.selection.to) - BigInt(config.overlapMs) * 1_000n))\n  let state: SlackMessageState = context.state ?? { scope, watermark: initialFrom }\n  if (!state.active) {\n    const channels = (await discoverChannels(context, deps)).map((channel) => entityId(channel, 'id')).sort()\n    const to = context.selection.to\n    const from = context.selection.from ?? (context.state ? formatTimestamp(max(config.historyFrom === undefined ? 0n : timestampMicros(config.historyFrom), timestampMicros(state.watermark) - BigInt(config.overlapMs) * 1_000n)) : initialFrom)\n    if (timestampMicros(from) > timestampMicros(to)) throw new IngestConfigError('Slack selection starts after its cutoff.')\n    state = { ...state, active: { from, to, channels, channelIndex: 0, latest: formatTimestamp(timestampMicros(to) + 1n),\n      requestedFrom: context.selection.from, requestedTo: context.selection.requestedTo } }\n    yield marker(state, 'window-open')\n  } else if (context.selection.backfill && (context.selection.from !== state.active.requestedFrom || context.selection.requestedTo !== state.active.requestedTo)) {\n    throw new IngestConfigError('Slack backfill bounds changed while a window is unfinished. Resume the original range or use a new backfill ID.')\n  }\n\n  while (state.active && state.active.channelIndex < state.active.channels.length) {\n    context.signal.throwIfAborted()\n    const work = state.active\n    const channelId = work.channels[work.channelIndex]\n    if (!channelId) throw new IngestConfigError('Slack checkpoint has no current channel.')\n    const page = await readTimePage(context, { channel: channelId, oldest: formatTimestamp(max(0n, timestampMicros(work.from) - 1n)), latest: work.latest,\n      inclusive: 'false', include_all_metadata: 'true' }, 'conversations.history', deps)\n    assertRange(page.items, timestampMicros(work.from), timestampMicros(work.latest) - 1n)\n    const latest = page.items.length ? formatTimestamp(page.items.reduce((oldest, item) => min(oldest, timestampMicros(entityId(item, 'ts'))), timestampMicros(work.latest))) : work.latest\n    if (page.hasMore && (page.items.length === 0 || timestampMicros(latest) >= timestampMicros(work.latest))) throw new IngestConfigError('Slack history pagination has no safe timestamp progress.')\n    const roots = config.includeReplies ? page.items.filter((item) => typeof item.reply_count === 'number' && item.reply_count > 0)\n      .map((item) => typeof item.thread_ts === 'string' ? entityId(item, 'thread_ts') : entityId(item, 'ts')) : []\n    if (page.items.length) yield { rows: toSlackRows(page.items, 'messages', teamId, 'ts', channelId, config.sourceId) }\n    for (const root of new Set(roots)) {\n      let after = formatTimestamp(max(0n, timestampMicros(root) - 1n))\n      while (true) {\n        const replies = await readTimePage(context, { channel: channelId, ts: root, oldest: after,\n          latest: formatTimestamp(timestampMicros(work.to) + 1n), inclusive: 'false', include_all_metadata: 'true' }, 'conversations.replies', deps)\n        const children = replies.items.filter((item) => entityId(item, 'ts') !== root)\n        assertRange(children, timestampMicros(after) + 1n, timestampMicros(work.to))\n        if (replies.hasMore && children.length === 0) throw new IngestConfigError('Slack thread pagination has no safe timestamp progress.')\n        if (replies.items.length) yield { rows: toSlackRows(replies.items, 'messages', teamId, 'ts', channelId, config.sourceId) }\n        if (!replies.hasMore) break\n        after = formatTimestamp(children.reduce((frontier, item) => max(frontier, timestampMicros(entityId(item, 'ts'))), timestampMicros(after)))\n      }\n    }\n    // Only a fully read history page and all its replies may advance durable history.\n    context.signal.throwIfAborted()\n    state = { ...state, active: { ...work, channelIndex: work.channelIndex + (page.hasMore ? 0 : 1),\n      latest: page.hasMore ? latest : formatTimestamp(timestampMicros(work.to) + 1n) } }\n    yield marker(state, 'history-page-complete')\n  }\n  if (state.active) {\n    state = { scope, watermark: formatTimestamp(max(timestampMicros(state.watermark), timestampMicros(state.active.to))) }\n    yield marker(state, 'window-complete')\n  }\n}\n\n/** Empty cursor pages use the live cursor; nonempty pages establish timestamp boundaries. */\nasync function readTimePage(\n  context: ReadContext<SlackMessageSelection, SlackMessageState>, query: Record<string, string>,\n  method: 'conversations.history' | 'conversations.replies', deps?: SlackClientDeps,\n): Promise<{ items: SlackEntity[]; hasMore: boolean }> {\n  let restarted = false\n  const parents = new Map<string, SlackEntity>()\n  while (true) {\n    let continued = false\n    try {\n      for await (const page of readCollection(context, { method, field: 'messages', idField: 'ts', query, timePagination: true }, deps)) {\n        for (const item of page.items) parents.set(entityId(item, 'ts'), item)\n        if (page.next === undefined) return { items: [...parents.values()], hasMore: page.metadata?.hasMore === true }\n        continued = true\n      }\n    } catch (error) {\n      if (!(error instanceof SlackCursorExpiredError) || !continued || restarted) throw error\n      restarted = true\n    }\n  }\n}\n\nfunction marker(state: SlackMessageState, id: string): SourceChunk<RawRow, SlackMessageState> {\n  // State-only boundaries flush previous rows without assigning identity to mutable data.\n  return { rows: [], state, id }\n}\nfunction assertRange(items: SlackEntity[], from: bigint, to: bigint): void {\n  if (items.some((item) => {\n    const ts = timestampMicros(entityId(item, 'ts'))\n    return ts < from || ts > to\n  })) throw new IngestConfigError('Slack returned a message outside the requested timestamp interval.')\n}\nfunction max(left: bigint, right: bigint): bigint { return left > right ? left : right }\nfunction min(left: bigint, right: bigint): bigint { return left < right ? left : right }\n"
+    },
+    {
+      "path": "slack/tests/slack.test.ts",
+      "type": "registry:file",
+      "target": "src/integrations/slack/tests/slack.test.ts",
+      "role": "test",
+      "content": "import { afterEach, describe, expect, test } from 'bun:test'\n\nimport { HttpError, definePipeline, defineStream, runIngestion, selectStreams, type FetchContext, type ReadContext, type SourceChunk } from '@chkit/plugin-ingest'\nimport { createMemoryDestination, createMemoryJournal } from '@chkit/plugin-ingest/testing'\n\nimport { classifySlackError, discoverChannels, readCollection, type SlackClientDeps } from '../client.js'\nimport { slackConfig } from '../config.js'\nimport * as definitions from '../index.js'\nimport { createSlackPipeline, slack } from '../pipeline.js'\nimport { readChannels } from '../sources/channels.js'\nimport { readUsers } from '../sources/users.js'\nimport { readMessages } from '../sources/messages.js'\nimport { messageScope, parseMessageState, slackMessageStrategy, type SlackMessageSelection, type SlackMessageState } from '../state.js'\nimport { channel, fixtureDeps, parentMessage, replyMessage, standaloneMessage, user } from './fixtures.js'\n\nconst readers: Record<string, (context: FetchContext, deps: SlackClientDeps) => AsyncIterable<SourceChunk>> = {\n  channels: readChannels, users: readUsers,\n}\nconst originalConfig = { ...slackConfig }\nconst fixtureNow = () => new Date('2023-11-15T00:00:00Z')\n\nafterEach(() => { Object.assign(slackConfig, originalConfig) })\n\ndescribe('Slack raw template', () => {\n  test('exports three raw destinations and checkpointed messages without credentials', () => {\n    const exported = Object.values(definitions)\n    expect(exported).toContain(slack)\n    expect(slack.streams).toHaveLength(3)\n    expect(slack.streams.map((stream) => stream.destination.name)).toEqual(['slack_channels_raw', 'slack_users_raw', 'slack_messages_raw'])\n    for (const stream of slack.streams) {\n      expect(exported).toContain(stream.destination)\n      expect(stream.incremental.id).toBe(stream.id.endsWith('.messages') ? 'slack.message-ranges' : 'chkit.full_sync')\n    }\n    expect(selectStreams([slack], ['provider:slack', 'resource:messages']).map(({ stream }) => stream.id)).toEqual(['slack.primary.messages'])\n  })\n\n  test('a pipeline binds installation identity and reader settings independently of later config edits', async () => {\n    const config = { ...slackConfig, sourceId: 'slack.secondary', channels: ['C1'], conversationTypes: ['public_channel'] as const,\n      includeReplies: false, pageSize: 37, messagePageSize: 12, requestIntervalMs: 7, messageIntervalMs: 11, historyFrom: '1699999999.000000' }\n    const expectedScope = messageScope('T1', config)\n    const requests: URL[] = [], waits: number[] = []\n    const defaults = fixtureDeps()\n    const deps = fixtureDeps((url, init) => { requests.push(url); return defaults.fetch(url.toString(), init) })\n    deps.wait = async (milliseconds) => { waits.push(milliseconds) }\n    const pipeline = createSlackPipeline(config, deps)\n    config.sourceId = 'changed'\n    config.channels.push('missing')\n    config.historyFrom = 'invalid'\n    slackConfig.sourceId = 'unrelated'\n    slackConfig.includeReplies = true\n    slackConfig.historyFrom = 'invalid'\n    const journal = createMemoryJournal(), destination = createMemoryDestination()\n    const result = await runIngestion({ selected: selectStreams([pipeline], []), backfill: undefined }, { now: fixtureNow, journal, destination })\n    expect(result.ok, JSON.stringify(result)).toBe(true)\n    expect(result.streams.map((stream) => stream.streamId)).toEqual(['slack.secondary.channels', 'slack.secondary.users', 'slack.secondary.messages'])\n    expect(parseMessageState((await journal.readCheckpoint('slack.secondary.messages')).envelope?.state).scope).toBe(expectedScope)\n    expect(destination.tables.get('default.slack_messages_raw')?.[0]?.id).toBe(JSON.stringify(['slack.secondary', 'messages', 'T1', 'C1', parentMessage.ts]))\n    expect(destination.tables.get('default.slack_users_raw')?.[0]?.raw).toMatchObject({ source_id: 'slack.secondary' })\n    expect(requests.filter((url) => url.pathname === '/api/conversations.list' || url.pathname === '/api/users.list').every((url) => url.searchParams.get('limit') === '37')).toBe(true)\n    expect(requests.find((url) => url.pathname === '/api/conversations.history')?.searchParams.get('limit')).toBe('12')\n    expect(requests.find((url) => url.pathname === '/api/conversations.history')?.searchParams.get('oldest')).toBe('1699999998.999999')\n    expect(requests.some((url) => url.pathname === '/api/conversations.replies')).toBe(false)\n    expect(waits).toContain(7)\n    expect(waits).toContain(11)\n  })\n\n  test('a failed resource leaves the other resource streams selectable and able to commit', async () => {\n    const defaults = fixtureDeps()\n    const deps = fixtureDeps((url, init) => url.pathname === '/api/users.list'\n      ? Response.json({ ok: false, error: 'missing_scope', needed: 'users:read' }) : defaults.fetch(url.toString(), init))\n    const pipeline = createSlackPipeline(slackConfig, deps)\n    const journal = createMemoryJournal(), destination = createMemoryDestination()\n    const result = await runIngestion({ selected: selectStreams([pipeline], []), backfill: undefined }, { now: fixtureNow, journal, destination })\n    expect(result.ok).toBe(false)\n    expect(result.streams.map((stream) => stream.outcome)).toEqual(['succeeded', 'failed', 'succeeded'])\n    expect(destination.tables.has('default.slack_channels_raw')).toBe(true)\n    expect(destination.tables.has('default.slack_users_raw')).toBe(false)\n    expect(destination.tables.has('default.slack_messages_raw')).toBe(true)\n    expect(parseMessageState((await journal.readCheckpoint('slack.primary.messages')).envelope?.state).active).toBeUndefined()\n    expect((await journal.readCheckpoint('slack.primary.users')).envelope).toBeUndefined()\n    expect(selectStreams([pipeline], ['resource:users']).map(({ stream }) => stream.id)).toEqual(['slack.primary.users'])\n  })\n\n  test('messages run before metadata streams and replay an unfinished page independently', async () => {\n    const calls: string[] = []\n    const defaults = fixtureDeps()\n    const deps = fixtureDeps((url, init) => { calls.push(url.pathname); return defaults.fetch(url.toString(), init) })\n    const pipeline = createSlackPipeline(slackConfig, deps)\n    const limited = { ...pipeline, streams: pipeline.streams.map((stream) => ({ ...stream, budget: { ...stream.budget, maxChunks: 2 } })) }\n    const journal = createMemoryJournal(), destination = createMemoryDestination()\n    const first = await runIngestion({ selected: selectStreams([limited], ['resource:messages']), backfill: undefined }, { now: fixtureNow, journal, destination })\n    expect(first.streams[0]?.outcome).toBe('budget_exhausted')\n    const pending = await journal.readCheckpoint('slack.primary.messages')\n    expect(parseMessageState(pending.envelope?.state).active?.latest).toBe('1700006400.000001')\n    expect(parseMessageState(pending.envelope?.state).active).not.toHaveProperty('threads')\n    expect(destination.tables.has('default.slack_channels_raw')).toBe(false)\n    expect(destination.tables.has('default.slack_users_raw')).toBe(false)\n    expect((await journal.readCheckpoint('slack.primary.channels')).version).toBe(0)\n    expect((await journal.readCheckpoint('slack.primary.users')).version).toBe(0)\n    calls.length = 0\n    expect((await runIngestion({ selected: selectStreams([pipeline], ['resource:users']), backfill: undefined }, { now: fixtureNow, journal, destination })).ok).toBe(true)\n    expect(calls).toEqual(['/api/auth.test', '/api/users.list'])\n    expect(await journal.readCheckpoint('slack.primary.messages')).toEqual(pending)\n    calls.length = 0\n    expect((await runIngestion({ selected: selectStreams([pipeline], ['resource:messages']), backfill: undefined }, { now: fixtureNow, journal, destination })).ok).toBe(true)\n    expect(calls).toEqual(['/api/auth.test', '/api/conversations.history', '/api/conversations.replies'])\n    expect(destination.tables.get('default.slack_messages_raw')?.map((row) => row.raw)).toContainEqual({ source_id: 'slack.primary', team_id: 'T1', channel_id: 'C1', data: replyMessage })\n    expect((await journal.readCheckpoint('slack.primary.channels')).version).toBe(0)\n  })\n\n  test('every stream preserves provider payloads and reruns publish edits under stable identities', async () => {\n    let changed = false\n    const defaults = fixtureDeps()\n    const deps = fixtureDeps((url, init) => url.pathname === '/api/conversations.history' && changed\n      ? Response.json({ ok: true, messages: [{ ...parentMessage, text: 'Edited discussion' }, standaloneMessage], response_metadata: { next_cursor: '' } })\n      : defaults.fetch(url.toString(), init))\n    const pipeline = fixturePipeline(deps)\n    const journal = createMemoryJournal()\n    const destination = createMemoryDestination()\n    const request = { selected: selectStreams([pipeline], []), backfill: undefined }\n    const first = await runIngestion(request, { now: fixtureNow, journal, destination })\n    expect(first.ok, JSON.stringify(first)).toBe(true)\n    expect(first.streams.map((stream) => stream.rows)).toEqual([1, 2, 4])\n    expect(destination.tables.size).toBe(3)\n    expect(destination.tables.get('default.slack_users_raw')?.map((row) => row.raw)).toContainEqual({ source_id: 'slack.primary', team_id: 'T1', data: user })\n    const messages = destination.tables.get('default.slack_messages_raw') ?? []\n    expect(messages.map((row) => row.raw)).toContainEqual({ source_id: 'slack.primary', team_id: 'T1', channel_id: 'C1', data: parentMessage })\n    expect(messages.map((row) => row.raw)).toContainEqual({ source_id: 'slack.primary', team_id: 'T1', channel_id: 'C1', data: replyMessage })\n    expect(new Set(messages.map((row) => row.id)).size).toBe(3)\n    expect(messages.find((row) => JSON.stringify(row.raw).includes('Edited discussion'))).toBeUndefined()\n    changed = true\n    const second = await runIngestion(request, { now: fixtureNow, journal, destination })\n    expect(second.ok, JSON.stringify(second)).toBe(true)\n    const repeated = destination.tables.get('default.slack_messages_raw') ?? []\n    const edited = repeated.find((row) => JSON.stringify(row.raw).includes('Edited discussion'))\n    expect(edited?.id).toBe(JSON.stringify(['slack.primary', 'messages', 'T1', 'C1', parentMessage.ts]))\n    expect(new Set(repeated.map((row) => row.id)).size).toBe(3)\n  })\n\n  test('cursor pagination continues across an empty page and includes all later entities', async () => {\n    const cursors: Array<string | null> = []\n    const deps = fixtureDeps((url) => {\n      const cursor = url.searchParams.get('cursor')\n      cursors.push(cursor)\n      if (cursor === null) return Response.json({ ok: true, channels: [], response_metadata: { next_cursor: 'empty-next' } })\n      if (cursor === 'empty-next') return Response.json({ ok: true, channels: [channel], response_metadata: { next_cursor: 'final-next' } })\n      if (cursor === 'final-next') return Response.json({ ok: true, channels: [{ ...channel, id: 'C2' }], response_metadata: { next_cursor: null } })\n      throw new Error(`Unexpected cursor ${cursor}`)\n    })\n    const pages = await collect(readCollection(context(), { method: 'conversations.list', field: 'channels', idField: 'id', pageSize: 2 }, deps))\n    expect(pages.flatMap((page) => page.items).map((value) => value.id)).toEqual(['C1', 'C2'])\n    expect(pages.map((page) => page.next)).toEqual(['empty-next', 'final-next', undefined])\n    expect(pages.map((page) => page.items.length)).toEqual([0, 1, 1])\n    expect(cursors).toEqual([null, 'empty-next', 'final-next'])\n  })\n\n  test('the channels reader yields a page before fetching the next selected conversation page', async () => {\n    let channelCalls = 0\n    const defaults = fixtureDeps()\n    const deps = fixtureDeps((url, init) => {\n      if (url.pathname !== '/api/conversations.list') return defaults.fetch(url.toString(), init)\n      channelCalls += 1\n      return Response.json({ ok: true, channels: [{ ...channel, id: channelCalls === 1 ? 'C1' : 'C2' }],\n        response_metadata: { next_cursor: channelCalls === 1 ? 'next' : '' } })\n    })\n    const iterator = readChannels(context(), deps)\n    const first = await iterator.next()\n    expect(first.done).toBe(false)\n    expect(first.value?.rows[0]?.id).toBe(JSON.stringify(['slack.primary', 'channels', 'T1', 'C1']))\n    expect(channelCalls).toBe(1)\n    const second = await iterator.next()\n    expect(second.done).toBe(false)\n    expect(second.value?.rows[0]?.id).toBe(JSON.stringify(['slack.primary', 'channels', 'T1', 'C2']))\n    expect(channelCalls).toBe(2)\n    expect((await iterator.next()).done).toBe(true)\n  })\n\n  test('channel discovery reports missing configured IDs after yielding accessible pages', async () => {\n    const deps = { ...fixtureDeps(), config: { ...slackConfig, channels: ['C1', 'missing'] } }\n    const iterator = readChannels(context(), deps)\n    const first = await iterator.next()\n    expect(first.done).toBe(false)\n    expect(first.value?.rows).toHaveLength(1)\n    await expect(iterator.next()).rejects.toThrow('Configured Slack channel \"missing\" was not found')\n  })\n\n  test('messages discover channels independently and paginate threads including the parent payload', async () => {\n    const requests: URL[] = []\n    const defaults = fixtureDeps()\n    const deps = fixtureDeps((url, init) => {\n      requests.push(url)\n      if (url.pathname === '/api/conversations.history') return Response.json({ ok: true, messages: [parentMessage], response_metadata: { next_cursor: '' } })\n      if (url.pathname === '/api/conversations.replies') {\n        expect(url.searchParams.get('channel')).toBe('C1')\n        expect(url.searchParams.get('ts')).toBe(parentMessage.ts)\n        return url.searchParams.has('cursor')\n          ? Response.json({ ok: true, messages: [replyMessage], response_metadata: { next_cursor: '' } })\n          : Response.json({ ok: true, messages: [{ ...parentMessage, text: 'Latest parent' }], response_metadata: { next_cursor: 'reply-next' } })\n      }\n      return defaults.fetch(url.toString(), init)\n    })\n    const chunks = await collect(readMessages(context(), deps))\n    expect(chunks.flatMap((chunk) => chunk.rows).map((row) => row.raw)).toContainEqual({ source_id: 'slack.primary', team_id: 'T1', channel_id: 'C1', data: { ...parentMessage, text: 'Latest parent' } })\n    expect(chunks.flatMap((chunk) => chunk.rows)).toHaveLength(3)\n    expect(chunks.filter((chunk) => chunk.rows.length > 0).every((chunk) => chunk.state === undefined)).toBe(true)\n    expect(chunks.filter((chunk) => chunk.rows.length === 0).every((chunk) => chunk.state !== undefined)).toBe(true)\n    expect(chunks.filter((chunk) => chunk.rows.length > 0).every((chunk) => chunk.id === undefined)).toBe(true)\n    const messageRequests = requests.filter((url) => ['conversations.history', 'conversations.replies'].some((method) => url.pathname.endsWith(method)))\n    expect(messageRequests.map((url) => url.searchParams.get('limit'))).toEqual(['15', '15', '15'])\n    expect(messageRequests.at(-1)?.searchParams.get('cursor')).toBe('reply-next')\n    expect(requests.some((url) => url.pathname === '/api/conversations.list')).toBe(true)\n  })\n\n  test('row identities separate source installations, workspaces, and conversations', async () => {\n    const defaults = fixtureDeps()\n    const readForTeam = async (team: string) => collect(readMessages(context(), fixtureDeps((url, init) => {\n      if (url.pathname === '/api/auth.test') return Response.json({ ok: true, team_id: team })\n      if (url.pathname === '/api/conversations.list') return Response.json({ ok: true, channels: [channel, { ...channel, id: 'C2' }], response_metadata: { next_cursor: '' } })\n      if (url.pathname === '/api/conversations.history') return Response.json({ ok: true, messages: [standaloneMessage], response_metadata: { next_cursor: '' } })\n      return defaults.fetch(url.toString(), init)\n    })))\n    const first = (await readForTeam('T1')).flatMap((chunk) => chunk.rows)\n    const second = (await readForTeam('T2')).flatMap((chunk) => chunk.rows)\n    slackConfig.sourceId = 'slack.secondary'\n    const separateSource = (await readForTeam('T1')).flatMap((chunk) => chunk.rows)\n    expect(new Set([...first, ...second, ...separateSource].map((row) => row.id)).size).toBe(6)\n    expect(first[0]?.id).toBe(JSON.stringify(['slack.primary', 'messages', 'T1', 'C1', standaloneMessage.ts]))\n  })\n\n  test('finishes a history page and its replies before moving the timestamp frontier', async () => {\n    const requests: string[] = []\n    const defaults = fixtureDeps()\n    const deps = fixtureDeps((url, init) => {\n      if (url.pathname === '/api/conversations.history') {\n        const latest = url.searchParams.get('latest')\n        const resumed = latest === parentMessage.ts\n        requests.push(`history:${resumed ? 'resumed' : 'first'}`)\n        return Response.json({ ok: true, messages: [resumed ? { ...standaloneMessage, ts: '1699999999.000003' } : parentMessage], has_more: !resumed })\n      }\n      if (url.pathname === '/api/conversations.replies') {\n        requests.push('replies')\n        return Response.json({ ok: true, messages: [parentMessage, replyMessage], response_metadata: { next_cursor: null } })\n      }\n      return defaults.fetch(url.toString(), init)\n    })\n    const chunks = await collect(readMessages(context(), deps))\n    expect(chunks.flatMap((chunk) => chunk.rows)).toHaveLength(4)\n    expect(requests).toEqual(['history:first', 'replies', 'history:resumed'])\n  })\n\n  test('history-only selection avoids thread API requests', async () => {\n    slackConfig.includeReplies = false\n    const requests: string[] = []\n    const defaults = fixtureDeps()\n    const deps = fixtureDeps((url, init) => { requests.push(url.pathname); return defaults.fetch(url.toString(), init) })\n    const chunks = await collect(readMessages(context(), deps))\n    expect(chunks.flatMap((chunk) => chunk.rows)).toHaveLength(2)\n    expect(requests).not.toContain('/api/conversations.replies')\n  })\n\n  test('configured channel IDs narrow discovery and unknown IDs fail visibly', async () => {\n    slackConfig.channels = ['C1']\n    const defaults = fixtureDeps()\n    const deps = fixtureDeps((url, init) => url.pathname === '/api/conversations.list'\n      ? Response.json({ ok: true, channels: [channel, { ...channel, id: 'C2' }], response_metadata: { next_cursor: '' } })\n      : defaults.fetch(url.toString(), init))\n    expect((await discoverChannels(context(), deps)).map((value) => value.id)).toEqual(['C1'])\n    slackConfig.channels = ['missing']\n    await expect(discoverChannels(context(), deps)).rejects.toThrow('missing')\n    slackConfig.channels = []\n    expect(await discoverChannels(context(), deps)).toEqual([])\n  })\n\n  test('cancellation stops before the second history page and preserves configured pacing', async () => {\n    const controller = new AbortController()\n    const requests: URL[] = []\n    const waits: number[] = []\n    const defaults = fixtureDeps()\n    const deps = fixtureDeps((url, init) => {\n      requests.push(url)\n      return url.pathname === '/api/conversations.history'\n        ? Response.json({ ok: true, messages: [standaloneMessage], response_metadata: { next_cursor: 'history-next' } })\n        : defaults.fetch(url.toString(), init)\n    })\n    deps.wait = async (milliseconds, signal) => { waits.push(milliseconds); signal.throwIfAborted() }\n    const iterator = readMessages(context(controller.signal), deps)\n    const opening = await iterator.next()\n    expect(opening.value?.rows).toHaveLength(0)\n    const first = await iterator.next()\n    expect(first.value?.rows).toHaveLength(1)\n    controller.abort(new Error('fixture cancelled'))\n    await expect(iterator.next()).rejects.toThrow('fixture cancelled')\n    expect(requests.filter((url) => url.pathname === '/api/conversations.history')).toHaveLength(1)\n    expect(waits).toContain(slackConfig.messageIntervalMs)\n    expect(waits.filter((milliseconds) => milliseconds === slackConfig.requestIntervalMs).length).toBeGreaterThanOrEqual(1)\n  })\n\n  test('malformed successful responses fail instead of becoming empty datasets', async () => {\n    for (const payload of [{}, { ok: true, members: null }, { ok: true, members: [{ name: 'missing-id' }] }]) {\n      const defaults = fixtureDeps()\n      const deps = fixtureDeps((url, init) => url.pathname === '/api/users.list' ? Response.json(payload) : defaults.fetch(url.toString(), init))\n      await expect(collect(readUsers(context(), deps))).rejects.toThrow('Slack')\n    }\n  })\n\n  test('malformed message timestamps and pagination fail rather than truncate a scan', async () => {\n    const request = { method: 'conversations.history', field: 'messages', idField: 'ts' } as const\n    for (const payload of [\n      { ok: true, messages: [{ ...standaloneMessage, ts: 1_700_000_002.000003 }] },\n      { ok: true, messages: [{ ...standaloneMessage, ts: 'invalid' }] },\n      { ok: true, messages: [standaloneMessage], has_more: true },\n      { ok: true, messages: [standaloneMessage], response_metadata: { next_cursor: 123 } },\n    ]) {\n      await expect(collect(readCollection(context(), request, fixtureDeps(() => Response.json(payload))))).rejects.toThrow('Slack')\n    }\n    let calls = 0\n    const repeated = fixtureDeps(() => {\n      calls += 1\n      if (calls > 3) throw new Error('Repeated cursor was not rejected')\n      return Response.json({ ok: true, messages: [standaloneMessage], response_metadata: { next_cursor: 'same-cursor' } })\n    })\n    await expect(collect(readCollection(context(), request, repeated))).rejects.toThrow('repeated')\n    expect(calls).toBe(2)\n  })\n\n  test('HTTP 200 permission errors fail permanently without loading any rows', async () => {\n    let calls = 0\n    const defaults = fixtureDeps()\n    const deps = fixtureDeps((url, init) => {\n      if (url.pathname !== '/api/users.list') return defaults.fetch(url.toString(), init)\n      calls += 1\n      return Response.json({ ok: false, error: 'missing_scope', needed: 'users:read', provided: 'channels:read' })\n    })\n    const destination = createMemoryDestination()\n    const result = await runFixture(deps, ['users'], destination)\n    expect(result.ok).toBe(false)\n    expect(result.streams[0]?.error).toContain('missing_scope')\n    expect(result.streams[0]?.error).toContain('users:read')\n    expect(result.streams[0]?.rows).toBe(0)\n    expect(calls).toBe(1)\n    expect(destination.tables.size).toBe(0)\n  })\n\n  test('HTTP 200 transient errors retry inside the ingestion executor', async () => {\n    let calls = 0\n    const defaults = fixtureDeps()\n    const deps = fixtureDeps((url, init) => {\n      if (url.pathname !== '/api/users.list') return defaults.fetch(url.toString(), init)\n      calls += 1\n      return calls === 1 ? Response.json({ ok: false, error: 'internal_error' }) : Response.json({ ok: true, members: [user], response_metadata: { next_cursor: '' } })\n    })\n    const result = await runFixture(deps, ['users'])\n    expect(result.ok, JSON.stringify(result)).toBe(true)\n    expect(calls).toBe(2)\n  })\n\n  test.each(['users', 'messages'])('%s pagination has one executor retry budget per request', async (resource) => {\n    let calls = 0\n    const defaults = fixtureDeps()\n    const method = resource === 'users' ? 'users.list' : 'conversations.history'\n    const deps = fixtureDeps((url, init) => {\n      if (url.pathname !== `/api/${method}`) return defaults.fetch(url.toString(), init)\n      calls += 1\n      return Response.json({ ok: false, error: 'internal_error' })\n    })\n    const result = await runFixture(deps, [resource])\n    expect(result.ok).toBe(false)\n    expect(result.streams[0]?.outcome).toBe('failed')\n    expect(calls).toBe(2)\n  })\n\n  test('HTTP 200 rate-limit errors retain Retry-After and retry under executor authority', async () => {\n    let calls = 0\n    const defaults = fixtureDeps()\n    const deps = fixtureDeps((url, init) => {\n      if (url.pathname !== '/api/users.list') return defaults.fetch(url.toString(), init)\n      calls += 1\n      return calls === 1\n        ? Response.json({ ok: false, error: 'ratelimited' }, { headers: { 'Retry-After': '0' } })\n        : Response.json({ ok: true, members: [user], response_metadata: { next_cursor: '' } })\n    })\n    const journal = createMemoryJournal()\n    const pipeline = fixturePipeline(deps, ['users'])\n    const result = await runIngestion({ selected: selectStreams([pipeline], []), backfill: undefined }, { now: fixtureNow, journal, destination: createMemoryDestination() })\n    expect(result.ok, JSON.stringify(result)).toBe(true)\n    expect(calls).toBe(2)\n    expect(journal.events.some((event) => event.eventKind === 'retry_scheduled' && event.errorClass === 'rate_limited')).toBe(true)\n  })\n\n  test('thread permission errors fail the stream and leave already loaded history visible', async () => {\n    let replyCalls = 0\n    const defaults = fixtureDeps()\n    const deps = fixtureDeps((url, init) => {\n      if (url.pathname !== '/api/conversations.replies') return defaults.fetch(url.toString(), init)\n      replyCalls += 1\n      return Response.json({ ok: false, error: 'missing_scope', needed: 'channels:history' })\n    })\n    const fixture = fixturePipeline(deps, ['messages'])\n    const pipeline = definePipeline({ ...fixture, streams: fixture.streams.map((stream) => ({ ...stream, batchSize: 1 })) })\n    const destination = createMemoryDestination()\n    const result = await runIngestion({ selected: selectStreams([pipeline], []), backfill: undefined }, { now: fixtureNow, journal: createMemoryJournal(), destination })\n    expect(result.ok).toBe(false)\n    expect(result.streams[0]?.outcome).toBe('failed')\n    expect(result.streams[0]?.error).toContain('missing_scope')\n    expect(replyCalls).toBe(1)\n    expect(destination.tables.get('default.slack_messages_raw')).toHaveLength(2)\n    expect(destination.tables.get('default.slack_messages_raw')?.map((row) => row.raw)).toContainEqual({ source_id: 'slack.primary', team_id: 'T1', channel_id: 'C1', data: parentMessage })\n  })\n\n  test('429 errors preserve Retry-After and retry the current page', async () => {\n    let calls = 0\n    const defaults = fixtureDeps()\n    const deps = fixtureDeps((url, init) => {\n      if (url.pathname !== '/api/users.list') return defaults.fetch(url.toString(), init)\n      calls += 1\n      return calls === 1\n        ? Response.json({ ok: false, error: 'ratelimited' }, { status: 429, headers: { 'Retry-After': '0' } })\n        : Response.json({ ok: true, members: [user], response_metadata: { next_cursor: '' } })\n    })\n    const journal = createMemoryJournal()\n    const pipeline = fixturePipeline(deps, ['users'])\n    const result = await runIngestion({ selected: selectStreams([pipeline], []), backfill: undefined }, { now: fixtureNow, journal, destination: createMemoryDestination() })\n    expect(result.ok, JSON.stringify(result)).toBe(true)\n    expect(calls).toBe(2)\n    expect(journal.events.some((event) => event.eventKind === 'retry_scheduled' && event.errorClass === 'rate_limited')).toBe(true)\n    const http = await HttpError.fromResponse(new Response(null, { status: 429, headers: { 'Retry-After': '2' } }))\n    expect(http.retryAfterMs).toBe(2_000)\n    expect(classifySlackError(http, { kind: 'rate_limited', retryAfterMs: 2_000 })).toBeUndefined()\n  })\n\n  test('missing credentials fail only when a reader runs', async () => {\n    const deps = fixtureDeps(() => { throw new Error('must not fetch') })\n    deps.token = () => undefined\n    expect(slack.streams).toHaveLength(3)\n    await expect(collect(readUsers(context(), deps))).rejects.toThrow('SLACK_API_TOKEN')\n  })\n})\n\nfunction fixturePipeline(deps: SlackClientDeps, selectedResources?: readonly string[]) {\n  return definePipeline({\n    ...slack,\n    retry: { retries: 1, minTimeout: 0, maxTimeout: 0, randomize: false },\n    streams: slack.streams.filter((stream) => selectedResources === undefined || selectedResources.includes(stream.id.split('.').at(-1) ?? '')).map((stream) => {\n      if (stream.id.endsWith('.messages')) return defineStream({ ...stream, incremental: slackMessageStrategy, read: (context) => readMessages(context, deps) })\n      const read = readers[stream.id.split('.').at(-1) ?? '']\n      if (!read) throw new Error(`No fixture reader for ${stream.id}`)\n      return { ...stream, read: (context: FetchContext) => read(context, deps) }\n    }),\n  })\n}\n\nasync function runFixture(deps: SlackClientDeps, selectedResources: readonly string[], destination = createMemoryDestination()) {\n  const pipeline = fixturePipeline(deps, selectedResources)\n  return runIngestion({ selected: selectStreams([pipeline], []), backfill: undefined }, { now: fixtureNow, journal: createMemoryJournal(), destination })\n}\n\nfunction context(signal = new AbortController().signal): ReadContext<SlackMessageSelection, SlackMessageState> {\n  return { signal, attempt: async (operation) => operation(signal), streamId: 'slack.primary.messages', state: undefined,\n    cutoff: fixtureNow(), selection: slackMessageStrategy.plan({ cutoff: fixtureNow(), state: undefined, range: undefined }) }\n}\n\nasync function collect<T>(items: AsyncIterable<T>): Promise<T[]> {\n  const result: T[] = []\n  for await (const item of items) result.push(item)\n  return result\n}\n"
+    },
+    {
+      "path": "slack/tests/fixtures.ts",
+      "type": "registry:file",
+      "target": "src/integrations/slack/tests/fixtures.ts",
+      "role": "test",
+      "content": "import type { SlackClientDeps } from '../client.js'\nimport { slackConfig } from '../config.js'\n\nexport const channel = {\n  id: 'C1', name: 'project-example', is_channel: true, is_private: false, is_archived: false,\n  topic: { value: 'Example project', creator: 'U1', last_set: 1_700_000_000 },\n}\n\nexport const user = {\n  id: 'U1', team_id: 'T1', name: 'ada-example', deleted: false,\n  profile: { real_name: 'Ada Example', email: 'ada@example.test', fields: { custom_field: { value: 'retained' } } },\n}\n\nexport const parentMessage = {\n  type: 'message', user: 'U1', ts: '1700000000.000001', thread_ts: '1700000000.000001',\n  text: 'A project discussion', reply_count: 1,\n  blocks: [{ type: 'section', text: { type: 'mrkdwn', text: '*Original formatting*' } }],\n  reactions: [{ name: 'eyes', users: ['U2'], count: 1 }],\n  files: [{ id: 'F1', title: 'Example attachment', mimetype: 'text/plain' }],\n}\n\nexport const replyMessage = {\n  type: 'message', user: 'U2', ts: '1700000001.000002', thread_ts: parentMessage.ts,\n  text: 'Thread reply', attachments: [{ fallback: 'Original attachment', extra_field: ['one', 'two'] }],\n}\n\nexport const standaloneMessage = { type: 'message', user: 'U1', ts: '1700000002.000003', text: 'Independent message' }\n\nexport function fixtureDeps(\n  respond: (url: URL, init: RequestInit) => Response | Promise<Response> = (url) => {\n    switch (url.pathname) {\n      case '/api/auth.test': return Response.json({ ok: true, team_id: 'T1', user_id: 'U1' })\n      case '/api/conversations.list': return Response.json({ ok: true, channels: [channel], response_metadata: { next_cursor: '' } })\n      case '/api/users.list': return Response.json({ ok: true, members: [user, { id: 'U2', team_id: 'T1', name: 'grace-example', profile: {} }], response_metadata: { next_cursor: '' } })\n      case '/api/conversations.history': return Response.json({ ok: true, messages: [parentMessage, standaloneMessage], response_metadata: { next_cursor: '' }, has_more: false })\n      case '/api/conversations.replies': return Response.json({ ok: true, messages: [parentMessage, replyMessage], response_metadata: { next_cursor: '' }, has_more: false })\n      default: throw new Error(`Unexpected fixture URL: ${url.pathname}`)\n    }\n  },\n): SlackClientDeps {\n  return {\n    config: slackConfig,\n    token: () => 'fixture-token',\n    wait: async () => {},\n    fetch: (url, init) => Promise.resolve(respond(new URL(url), init)),\n  }\n}\n"
+    },
+    {
+      "path": "slack/state.ts",
+      "type": "registry:file",
+      "target": "src/integrations/slack/state.ts",
+      "content": "import { IngestConfigError, type IncrementalStrategy } from '@chkit/plugin-ingest'\nimport { slackConfig, type SlackReaderConfig } from './config.js'\n\nexport interface MessageWork {\n  from: string\n  to: string\n  channels: string[]\n  channelIndex: number\n  latest: string\n  requestedFrom?: string\n  requestedTo?: string\n}\nexport interface SlackMessageState {\n  scope: string\n  watermark: string\n  active?: MessageWork\n}\nexport interface SlackMessageSelection { from?: string; to: string; requestedTo?: string; backfill: boolean }\n\nexport function createSlackMessageStrategy(config: SlackReaderConfig): IncrementalStrategy<SlackMessageState, SlackMessageSelection> {\n  return {\n    id: 'slack.message-ranges', version: 2, parseState: parseMessageState,\n    plan({ cutoff, range }) {\n      if (config.historyFrom !== undefined) timestampMicros(config.historyFrom)\n      if (!Number.isSafeInteger(config.overlapMs) || config.overlapMs < 0) throw new IngestConfigError('Slack overlapMs must be a non-negative safe integer.')\n      return { from: range?.from ? dateTimestamp(range.from) : undefined, to: dateTimestamp(range?.to ?? cutoff),\n        requestedTo: range?.to ? dateTimestamp(range.to) : undefined, backfill: range !== undefined }\n    },\n  }\n}\n\nexport const slackMessageStrategy = createSlackMessageStrategy(slackConfig)\n\nexport function messageScope(teamId: string, config: SlackReaderConfig = slackConfig): string {\n  return JSON.stringify([config.sourceId, teamId, config.channels ? [...config.channels].sort() : null,\n    [...config.conversationTypes].sort(), config.includeReplies, config.historyFrom ?? null, config.overlapMs])\n}\n\nexport function timestampMicros(value: string): bigint {\n  if (!/^\\d+\\.\\d{1,6}$/.test(value)) throw new IngestConfigError('Slack timestamps must be exact decimal strings with at most six fractional digits.')\n  const [seconds = '', fraction = ''] = value.split('.')\n  return BigInt(seconds) * 1_000_000n + BigInt(fraction.padEnd(6, '0'))\n}\n\nexport function formatTimestamp(value: bigint): string {\n  if (value < 0n) throw new IngestConfigError('Slack timestamp cannot be negative.')\n  return `${value / 1_000_000n}.${(value % 1_000_000n).toString().padStart(6, '0')}`\n}\n\nexport function dateTimestamp(value: Date): string {\n  if (!Number.isSafeInteger(value.getTime()) || value.getTime() < 0) throw new IngestConfigError('Slack time bounds must be valid dates after the Unix epoch.')\n  return formatTimestamp(BigInt(value.getTime()) * 1_000n)\n}\n\nexport function parseMessageState(raw: unknown): SlackMessageState {\n  if (!isObject(raw) || typeof raw.scope !== 'string') throw new IngestConfigError('Invalid Slack checkpoint scope.')\n  if ('knownChannels' in raw || 'lastFullAt' in raw) throw new IngestConfigError('Slack message checkpoint uses the former retained-work format. Migrate it explicitly or use a new sourceId for strategy version 2.')\n  const watermark = readTimestamp(raw.watermark)\n  let active: MessageWork | undefined\n  if (raw.active !== undefined) {\n    const work = raw.active\n    if (!isObject(work) || typeof work.channelIndex !== 'number' || !Number.isSafeInteger(work.channelIndex)\n      || !Array.isArray(work.channels) || !work.channels.every((id: unknown): id is string => typeof id === 'string' && id.length > 0)\n      || new Set(work.channels).size !== work.channels.length) throw new IngestConfigError('Invalid Slack active work.')\n    if ('threads' in work || 'historyDone' in work || 'kind' in work) throw new IngestConfigError('Slack message checkpoint uses the former retained-work format. Migrate it explicitly or use a new sourceId for strategy version 2.')\n    if (work.channelIndex < 0 || work.channelIndex > work.channels.length) throw new IngestConfigError('Invalid Slack channel position.')\n    const from = readTimestamp(work.from), to = readTimestamp(work.to), latest = readTimestamp(work.latest)\n    if (timestampMicros(from) > timestampMicros(to) || timestampMicros(latest) <= timestampMicros(from) - 1n\n      || timestampMicros(latest) > timestampMicros(to) + 1n) throw new IngestConfigError('Invalid Slack window bounds.')\n    active = { from, to, channels: [...work.channels], channelIndex: work.channelIndex, latest,\n      requestedFrom: work.requestedFrom === undefined ? undefined : readTimestamp(work.requestedFrom),\n      requestedTo: work.requestedTo === undefined ? undefined : readTimestamp(work.requestedTo) }\n  }\n  return { scope: raw.scope, watermark, active }\n}\n\nfunction readTimestamp(value: unknown): string {\n  if (typeof value !== 'string') throw new IngestConfigError('Invalid Slack checkpoint timestamp.')\n  timestampMicros(value)\n  return value\n}\nfunction isObject(value: unknown): value is Record<string, unknown> { return typeof value === 'object' && value !== null && !Array.isArray(value) }\n"
+    },
+    {
+      "path": "slack/tests/checkpoints.test.ts",
+      "type": "registry:file",
+      "target": "src/integrations/slack/tests/checkpoints.test.ts",
+      "role": "test",
+      "content": "import { afterEach, expect, test } from 'bun:test'\nimport { definePipeline, defineStream, runIngestion, selectStreams } from '@chkit/plugin-ingest'\nimport { createMemoryDestination, createMemoryJournal } from '@chkit/plugin-ingest/testing'\n\nimport { slackConfig } from '../config.js'\nimport { readMessages, slackMessagesRaw } from '../sources/messages.js'\nimport { createSlackMessageStrategy, dateTimestamp, parseMessageState, timestampMicros } from '../state.js'\nimport { fixtureDeps, parentMessage, replyMessage, standaloneMessage } from './fixtures.js'\nimport type { SlackClientDeps } from '../client.js'\n\nconst originalConfig = { ...slackConfig }\nconst cutoff = new Date('2023-11-15T00:00:00Z')\nafterEach(() => { Object.assign(slackConfig, originalConfig) })\n\ntest('an incomplete history page replays its replies under the original frozen bounds', async () => {\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  const calls: URL[] = []\n  const defaults = fixtureDeps()\n  const deps = fixtureDeps((url, init) => { calls.push(url); return defaults.fetch(url.toString(), init) })\n  const first = await runIngestion(request(pipeline(deps, { maxChunks: 2 })), { journal, destination, now: () => cutoff })\n  expect(first.streams[0]?.outcome).toBe('budget_exhausted')\n  const saved = parseMessageState((await journal.readCheckpoint('slack.primary.messages')).envelope?.state)\n  expect(saved.watermark).toBe('1699920000.000000')\n  expect(saved.active).toMatchObject({ from: '1699920000.000000', to: dateTimestamp(cutoff), latest: '1700006400.000001', channelIndex: 0 })\n  expect(saved.active).not.toHaveProperty('threads')\n  const restored = createMemoryJournal()\n  await restored.append(journal.events.map((event) => ({ ...event,\n    checkpoint: event.checkpoint === undefined ? undefined : JSON.parse(JSON.stringify(event.checkpoint)),\n  })))\n  calls.length = 0\n  const second = await runIngestion(request(pipeline(deps)), { journal: restored, destination, now: () => new Date('2023-11-16T00:00:00Z') })\n  expect(second.ok, JSON.stringify(second)).toBe(true)\n  expect(calls.map((url) => url.pathname)).toEqual(['/api/auth.test', '/api/conversations.history', '/api/conversations.replies'])\n  expect(calls.filter((url) => url.pathname.endsWith('history') || url.pathname.endsWith('replies')).every((url) => url.searchParams.get('latest') === '1700006400.000001')).toBe(true)\n  const completed = parseMessageState((await restored.readCheckpoint('slack.primary.messages')).envelope?.state)\n  expect(completed.active).toBeUndefined()\n  expect(completed.watermark).toBe(dateTimestamp(cutoff))\n  expect(destination.tables.get('default.slack_messages_raw')?.map((row) => row.raw)).toContainEqual({ source_id: 'slack.primary', team_id: 'T1', channel_id: 'C1', data: replyMessage })\n})\n\ntest('lost child acknowledgement replays the whole history page without advancing it', async () => {\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  const controller = new AbortController()\n  const first = await runIngestion(request(pipeline(fixtureDeps())), {\n    journal, now: () => cutoff, signal: controller.signal,\n    destination: { async insert(input) {\n      await destination.insert(input)\n      if (input.rows.some((row) => JSON.stringify(row.raw).includes(replyMessage.text))) controller.abort(new Error('lost child acknowledgement'))\n    } },\n  })\n  expect(first.ok).toBe(false)\n  const saved = parseMessageState((await journal.readCheckpoint('slack.primary.messages')).envelope?.state)\n  expect(saved.active?.latest).toBe('1700006400.000001')\n  expect(saved.active?.channelIndex).toBe(0)\n  const calls: string[] = []\n  const defaults = fixtureDeps()\n  const deps = fixtureDeps((url, init) => { calls.push(url.pathname); return defaults.fetch(url.toString(), init) })\n  expect((await runIngestion(request(pipeline(deps)), { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect(calls).toEqual(['/api/auth.test', '/api/conversations.history', '/api/conversations.replies'])\n  expect(destination.tables.get('default.slack_messages_raw')).toHaveLength(4)\n  expect(parseMessageState((await journal.readCheckpoint('slack.primary.messages')).envelope?.state).active).toBeUndefined()\n})\n\ntest('multi-page replies use local ascending timestamps and restart the incomplete thread on resume', async () => {\n  const secondReply = { ...replyMessage, ts: '1700000001.000003', text: 'Second reply' }\n  const oldest: string[] = []\n  const defaults = fixtureDeps()\n  const deps = fixtureDeps((url, init) => {\n    if (url.pathname !== '/api/conversations.replies') return defaults.fetch(url.toString(), init)\n    oldest.push(url.searchParams.get('oldest') ?? '')\n    const final = url.searchParams.get('oldest') === replyMessage.ts\n    return Response.json({ ok: true, messages: final ? [secondReply] : [parentMessage, replyMessage], has_more: !final })\n  })\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  expect((await runIngestion(request(pipeline(deps, { maxChunks: 3 })), { journal, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')\n  const saved = parseMessageState((await journal.readCheckpoint('slack.primary.messages')).envelope?.state)\n  expect(saved.active?.latest).toBe('1700006400.000001')\n  expect(saved.active).not.toHaveProperty('threads')\n  expect((await runIngestion(request(pipeline(deps)), { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect(oldest).toEqual(['1700000000.000000', '1700000000.000000', replyMessage.ts])\n  expect(destination.tables.get('default.slack_messages_raw')?.map((row) => row.raw)).toContainEqual({ source_id: 'slack.primary', team_id: 'T1', channel_id: 'C1', data: secondReply })\n})\n\ntest('a completed history page resumes from an exact timestamp rather than an expiring cursor', async () => {\n  slackConfig.includeReplies = false\n  const newest = { ...standaloneMessage, ts: '1700000002.000002' }\n  const older = { ...standaloneMessage, ts: '1700000002.000001' }\n  const urls: URL[] = []\n  const defaults = fixtureDeps()\n  const deps = fixtureDeps((url, init) => {\n    if (url.pathname !== '/api/conversations.history') return defaults.fetch(url.toString(), init)\n    urls.push(url)\n    const resumed = url.searchParams.get('latest') === newest.ts\n    return Response.json({ ok: true, messages: [resumed ? older : newest], has_more: !resumed })\n  })\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  expect((await runIngestion(request(pipeline(deps, { maxChunks: 3 })), { journal, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')\n  const saved = parseMessageState((await journal.readCheckpoint('slack.primary.messages')).envelope?.state)\n  expect(saved.active?.latest).toBe(newest.ts)\n  expect(JSON.stringify(saved)).not.toContain('cursor')\n  expect((await runIngestion(request(pipeline(deps)), { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect(urls.map((url) => url.searchParams.get('latest'))).toEqual(['1700006400.000001', newest.ts])\n  expect(urls.every((url) => !url.searchParams.has('cursor'))).toBe(true)\n  expect(new Set(destination.tables.get('default.slack_messages_raw')?.map((row) => row.id)).size).toBe(2)\n})\n\ntest('empty history cursor pages precede the completed timestamp boundary', async () => {\n  slackConfig.includeReplies = false\n  const urls: URL[] = []\n  const defaults = fixtureDeps()\n  const deps = fixtureDeps((url, init) => {\n    if (url.pathname !== '/api/conversations.history') return defaults.fetch(url.toString(), init)\n    urls.push(url)\n    if (url.searchParams.get('latest') === standaloneMessage.ts) return Response.json({ ok: true, messages: [parentMessage], has_more: false })\n    return Response.json(url.searchParams.has('cursor')\n      ? { ok: true, messages: [standaloneMessage], has_more: true, response_metadata: { next_cursor: 'empty-page' } }\n      : { ok: true, messages: [], has_more: true, response_metadata: { next_cursor: 'empty-page' } })\n  })\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  expect((await runIngestion(request(pipeline(deps, { maxChunks: 3 })), { journal, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')\n  const saved = parseMessageState((await journal.readCheckpoint('slack.primary.messages')).envelope?.state)\n  expect(saved.active?.latest).toBe(standaloneMessage.ts)\n  expect(JSON.stringify(saved)).not.toContain('empty-page')\n  expect((await runIngestion(request(pipeline(deps)), { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect(urls.map((url) => [url.searchParams.get('cursor'), url.searchParams.get('latest')])).toEqual([\n    [null, '1700006400.000001'], ['empty-page', '1700006400.000001'], [null, standaloneMessage.ts],\n  ])\n})\n\ntest('a page too large for the chunk budget replays until the budget can include its completion marker', async () => {\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  const deps = fixtureDeps()\n  const small = request(pipeline(deps, { maxChunks: 2 }))\n  expect((await runIngestion(small, { journal, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')\n  const checkpoint = await journal.readCheckpoint('slack.primary.messages')\n  expect((await runIngestion(small, { journal, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')\n  expect((await journal.readCheckpoint('slack.primary.messages')).version).toBe(checkpoint.version)\n  expect(parseMessageState((await journal.readCheckpoint('slack.primary.messages')).envelope?.state).active?.channelIndex).toBe(0)\n  expect((await runIngestion(request(pipeline(deps, { maxChunks: 5 })), { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect(new Set(destination.tables.get('default.slack_messages_raw')?.map((row) => row.id)).size).toBe(3)\n})\n\ntest('default bootstrap is recent and subsequent passes overlap the completed watermark by 24 hours', async () => {\n  const oldest: string[] = []\n  const defaults = fixtureDeps()\n  const deps = fixtureDeps((url, init) => {\n    if (url.pathname !== '/api/conversations.history') return defaults.fetch(url.toString(), init)\n    oldest.push(url.searchParams.get('oldest') ?? '')\n    return Response.json({ ok: true, messages: [], has_more: false })\n  })\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  expect((await runIngestion(request(pipeline(deps)), { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect((await runIngestion(request(pipeline(deps)), { journal, destination, now: () => new Date('2023-11-15T12:00:00Z') })).ok).toBe(true)\n  expect(oldest).toEqual(['1699919999.999999', '1699919999.999999'])\n  expect(parseMessageState((await journal.readCheckpoint('slack.primary.messages')).envelope?.state).watermark).toBe('1700049600.000000')\n})\n\ntest('recent roots gain replies during overlap while old roots and their late replies stay outside normal coverage', async () => {\n  const recentRoot = { ...parentMessage, ts: dateTimestamp(new Date('2023-11-15T06:00:00Z')), thread_ts: dateTimestamp(new Date('2023-11-15T06:00:00Z')) }\n  const recentReply = { ...replyMessage, ts: dateTimestamp(new Date('2023-11-15T07:00:00Z')), thread_ts: recentRoot.ts, text: 'Recent reply' }\n  const oldLateReply = { ...replyMessage, ts: dateTimestamp(new Date('2023-11-17T06:00:00Z')), text: 'Old root late reply' }\n  let now = new Date('2023-11-15T06:30:00Z')\n  const roots: string[] = []\n  const defaults = fixtureDeps()\n  const deps = fixtureDeps((url, init) => {\n    if (url.pathname === '/api/conversations.history') {\n      const from = timestampMicros(url.searchParams.get('oldest') ?? '0.000000')\n      const to = timestampMicros(url.searchParams.get('latest') ?? '0.000000')\n      return Response.json({ ok: true, messages: [parentMessage, recentRoot].filter((item) => timestampMicros(item.ts) > from && timestampMicros(item.ts) < to), has_more: false })\n    }\n    if (url.pathname === '/api/conversations.replies') {\n      const root = url.searchParams.get('ts') ?? ''\n      roots.push(root)\n      const to = timestampMicros(url.searchParams.get('latest') ?? '0.000000')\n      return Response.json({ ok: true, messages: root === recentRoot.ts\n        ? [recentRoot, recentReply].filter((item) => timestampMicros(item.ts) < to)\n        : [parentMessage, replyMessage, oldLateReply].filter((item) => timestampMicros(item.ts) < to), has_more: false })\n    }\n    return defaults.fetch(url.toString(), init)\n  })\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  const execute = () => runIngestion(request(pipeline(deps)), { journal, destination, now: () => now })\n  expect((await execute()).ok).toBe(true)\n  now = new Date('2023-11-15T08:00:00Z')\n  expect((await execute()).ok).toBe(true)\n  expect(destination.tables.get('default.slack_messages_raw')?.map((row) => row.raw)).toContainEqual({ source_id: 'slack.primary', team_id: 'T1', channel_id: 'C1', data: recentReply })\n  now = new Date('2023-11-16T08:00:00Z')\n  expect((await execute()).ok).toBe(true)\n  now = new Date('2023-11-17T08:00:00Z')\n  expect((await execute()).ok).toBe(true)\n  roots.length = 0\n  now = new Date('2023-11-24T08:00:00Z')\n  expect((await execute()).ok).toBe(true)\n  expect(roots).toEqual([])\n  expect(destination.tables.get('default.slack_messages_raw')?.some((row) => JSON.stringify(row.raw).includes(oldLateReply.text))).toBe(false)\n})\n\ntest('an explicit historyFrom expands initial coverage without periodic historical reconciliation', async () => {\n  slackConfig.historyFrom = '0.000000'\n  const bounds: string[] = []\n  const defaults = fixtureDeps()\n  const deps = fixtureDeps((url, init) => {\n    if (url.pathname !== '/api/conversations.history') return defaults.fetch(url.toString(), init)\n    bounds.push(url.searchParams.get('oldest') ?? '')\n    return Response.json({ ok: true, messages: [], has_more: false })\n  })\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  expect((await runIngestion(request(pipeline(deps)), { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect((await runIngestion(request(pipeline(deps)), { journal, destination, now: () => new Date('2023-11-23T00:00:00Z') })).ok).toBe(true)\n  expect(bounds).toEqual(['0.000000', '1699919999.999999'])\n})\n\ntest('empty terminal pages commit progress and query or account changes reject saved state', async () => {\n  const defaults = fixtureDeps()\n  const deps = fixtureDeps((url, init) => url.pathname === '/api/conversations.history'\n    ? Response.json({ ok: true, messages: [], has_more: false }) : defaults.fetch(url.toString(), init))\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  expect((await runIngestion(request(pipeline(deps)), { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect(parseMessageState((await journal.readCheckpoint('slack.primary.messages')).envelope?.state).watermark).toBe(dateTimestamp(cutoff))\n  expect(destination.tables.size).toBe(0)\n  const otherTeam = fixtureDeps((url, init) => url.pathname === '/api/auth.test' ? Response.json({ ok: true, team_id: 'T2' }) : defaults.fetch(url.toString(), init))\n  expect((await runIngestion(request(pipeline(otherTeam)), { journal, destination, now: () => cutoff })).streams[0]?.error).toContain('different workspace or query')\n  slackConfig.includeReplies = false\n  expect((await runIngestion(request(pipeline(deps)), { journal, destination, now: () => cutoff })).streams[0]?.error).toContain('different workspace or query')\n  expect(() => parseMessageState({ scope: 'broken', watermark: 1700006400 })).toThrow('timestamp')\n})\n\ntest('backfills isolate normal progress and retain requested bounds through a coarse-page pause', async () => {\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  const backfill = { id: 'november', from: new Date('2023-11-14T00:00:00Z'), to: cutoff }\n  const selected = selectStreams([pipeline(fixtureDeps(), { maxChunks: 2 })], [])\n  expect((await runIngestion({ selected, backfill }, { journal, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')\n  expect((await journal.readCheckpoint('slack.primary.messages')).envelope).toBeUndefined()\n  const changed = await runIngestion({ selected: selectStreams([pipeline(fixtureDeps())], []), backfill: { ...backfill, to: new Date('2023-11-16T00:00:00Z') } }, { journal, destination, now: () => cutoff })\n  expect(changed.ok).toBe(false)\n  expect(changed.streams[0]?.error).toContain('bounds changed')\n  expect((await runIngestion({ selected: selectStreams([pipeline(fixtureDeps())], []), backfill }, { journal, destination, now: () => cutoff })).ok).toBe(true)\n})\n\ntest('a backfill without an explicit upper bound resumes its original cutoff', async () => {\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  const backfill = { id: 'open-ended', from: new Date('2023-11-14T00:00:00Z'), to: undefined }\n  expect((await runIngestion({ selected: selectStreams([pipeline(fixtureDeps(), { maxChunks: 2 })], []), backfill }, { journal, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')\n  expect((await runIngestion({ selected: selectStreams([pipeline(fixtureDeps())], []), backfill }, { journal, destination, now: () => new Date('2023-11-16T00:00:00Z') })).ok).toBe(true)\n  expect((await journal.readCheckpoint('slack.primary.messages')).envelope).toBeUndefined()\n  expect(parseMessageState((await journal.readCheckpoint('slack.primary.messages#backfill:open-ended')).envelope?.state).watermark).toBe(dateTimestamp(cutoff))\n})\n\ntest('strategy version 2 rejects old envelopes before making requests', async () => {\n  const deps = fixtureDeps(), journal = createMemoryJournal(), destination = createMemoryDestination()\n  const current = pipeline(deps, { maxChunks: 1 })\n  const old = { ...current, streams: current.streams.map((stream) => ({ ...stream, incremental: { ...stream.incremental, version: 1 } })) }\n  expect((await runIngestion(request(old), { journal, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')\n  let calls = 0\n  const unused = fixtureDeps(() => { calls += 1; throw new Error('Old checkpoint must fail before requesting') })\n  const result = await runIngestion(request(pipeline(unused)), { journal, destination, now: () => cutoff })\n  expect(result.ok).toBe(false)\n  expect(result.streams[0]?.error).toContain('slack.message-ranges@1')\n  expect(result.streams[0]?.error).toContain('slack.message-ranges@2')\n  expect(calls).toBe(0)\n  expect(() => parseMessageState({ scope: 'old', watermark: '0.000000', knownChannels: [] })).toThrow('former retained-work format')\n})\n\ntest('expired temporary reply cursors replay their bounds and retain the newest parent observation', async () => {\n  const cursors: string[] = []\n  const updatedParent = { ...parentMessage, text: 'Updated parent' }\n  const defaults = fixtureDeps()\n  const deps = fixtureDeps((url, init) => {\n    if (url.pathname !== '/api/conversations.replies') return defaults.fetch(url.toString(), init)\n    const cursor = url.searchParams.get('cursor') ?? ''\n    cursors.push(cursor)\n    if (cursor === 'expired') return Response.json({ ok: false, error: 'invalid_cursor' })\n    if (cursor === 'current') return Response.json({ ok: true, messages: [updatedParent, replyMessage], has_more: false })\n    return Response.json({ ok: true, messages: [parentMessage], has_more: true, response_metadata: { next_cursor: cursors.length === 1 ? 'expired' : 'current' } })\n  })\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  expect((await runIngestion(request(pipeline(deps)), { journal, destination, now: () => cutoff })).ok).toBe(true)\n  expect(cursors).toEqual(['', 'expired', '', 'current'])\n  expect(destination.tables.get('default.slack_messages_raw')?.map((row) => row.raw)).toContainEqual({ source_id: 'slack.primary', team_id: 'T1', channel_id: 'C1', data: updatedParent })\n  expect(JSON.stringify((await journal.readCheckpoint('slack.primary.messages')).envelope?.state)).not.toContain('cursor')\n})\n\ntest.each(['initial', 'after-replay'])('a rejected reply cursor %s leaves the entire history page unfinished', async (failure) => {\n  const cursors: Array<string | null> = []\n  const defaults = fixtureDeps()\n  const deps = fixtureDeps((url, init) => {\n    if (url.pathname !== '/api/conversations.replies') return defaults.fetch(url.toString(), init)\n    const cursor = url.searchParams.get('cursor')\n    cursors.push(cursor)\n    return Response.json(failure === 'initial' || cursor\n      ? { ok: false, error: 'invalid_cursor' }\n      : { ok: true, messages: [parentMessage], has_more: true, response_metadata: { next_cursor: 'expired' } })\n  })\n  const journal = createMemoryJournal(), destination = createMemoryDestination()\n  const result = await runIngestion(request(pipeline(deps)), { journal, destination, now: () => cutoff })\n  expect(result.ok).toBe(false)\n  expect(result.streams[0]?.error).toContain('cursor expired')\n  expect(cursors).toEqual(failure === 'initial' ? [null] : [null, 'expired', null, 'expired'])\n  expect(parseMessageState((await journal.readCheckpoint('slack.primary.messages')).envelope?.state).active?.latest).toBe('1700006400.000001')\n  expect(destination.tables.get('default.slack_messages_raw')?.map((row) => row.raw)).not.toContainEqual({ source_id: 'slack.primary', team_id: 'T1', channel_id: 'C1', data: replyMessage })\n})\n\nfunction pipeline(deps: SlackClientDeps, budget?: { maxChunks?: number }) {\n  return definePipeline({ id: 'slack.primary', retry: { retries: 0 }, streams: [defineStream({\n    id: 'slack.primary.messages', destination: slackMessagesRaw, incremental: createSlackMessageStrategy(deps.config), batchSize: 1, budget,\n    read: (context) => readMessages(context, deps),\n  })] })\n}\nfunction request(value: ReturnType<typeof pipeline>) { return { selected: selectStreams([value], []), backfill: undefined } }\n"
+    }
+  ],
+  "meta": {
+    "chkit": {
+      "formatVersion": 1,
+      "version": "0.2.0",
+      "changelog": [
+        {
+          "version": "0.2.0",
+          "changes": [
+            "Use one installation pipeline with independently selectable channels, users, and messages streams and unchanged raw tables and scoped record identities.",
+            "Default messages to a recent 24-hour bootstrap, then overlap the completed watermark by 24 hours; allow explicit historyFrom bootstrap coverage and isolated bounded backfills.",
+            "Checkpoint fixed windows and complete history pages after all their selected replies load; replay an interrupted page without durable thread queues or child cursors.",
+            "Reuse full paginate pages and native has_more metadata with exact timestamp frontiers and bounded temporary-cursor replay; reject incompatible strategy state explicitly.",
+            "Document that old edits and late replies on roots outside the selected range are outside normal coverage; remove periodic historical reconciliation and include portable recovery fixtures."
+          ]
+        },
+        {
+          "version": "0.1.1",
+          "changes": [
+            "Add provider logo presentation metadata; distributed source is unchanged."
+          ]
+        },
+        {
+          "version": "0.1.0",
+          "changes": [
+            "Introduce raw conversations, users, messages, and thread replies with configurable conversation selection and request pacing."
+          ]
+        }
+      ],
+      "language": "typescript",
+      "license": "MIT",
+      "documentation": "https://chkit.obsessiondb.com/integrations/slack/",
+      "logo": "https://chkit.obsessiondb.com/logos/slack.svg",
+      "authentication": {
+        "method": "Slack OAuth bearer token (user token recommended)",
+        "env": [
+          "SLACK_API_TOKEN"
+        ],
+        "setup": [
+          "Create a Slack app for the workspace at api.slack.com/apps. Open OAuth & Permissions.",
+          "Add channels:read, channels:history, and users:read under User Token Scopes for the default three streams. Add users:read.email only when emails are needed.",
+          "For private channels add groups:read and groups:history; for DMs add im:read and im:history; for group DMs add mpim:read and mpim:history. Enable the matching conversationTypes in config.ts.",
+          "Install or reinstall the app to the workspace and copy the User OAuth Token into SLACK_API_TOKEN in the project .env or scheduler secret environment. A bot token only reads conversations it can access; enabled thread replies must also be permitted.",
+          "Keep tokens outside version control. Supply token refresh separately when using expiring tokens; the integration does not manage OAuth issuance or refresh."
+        ],
+        "documentation": "https://docs.slack.dev/authentication/tokens/"
+      },
+      "chkit": "^0.2.0-beta.10",
+      "ingest": "^0.2.0-beta.10",
+      "clickhouse": ">=25.3.0",
+      "root": "src/integrations/slack",
+      "entry": "index.ts",
+      "exports": [
+        "slack",
+        "slackChannelsRaw",
+        "slackUsersRaw",
+        "slackMessagesRaw"
+      ],
+      "resources": [
+        {
+          "name": "channels",
+          "title": "Conversations",
+          "table": "slack_channels_raw",
+          "description": "Selected accessible conversations, including archived channels, with complete returned topics, purpose, membership flags, and shared-channel metadata. Public channels by default; private channels, DMs, and group DMs are opt-in.",
+          "scopes": [
+            "channels:read"
+          ],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/conversations.list",
+              "documentation": "https://docs.slack.dev/reference/methods/conversations.list/"
+            }
+          ]
+        },
+        {
+          "name": "users",
+          "title": "Users",
+          "table": "slack_users_raw",
+          "description": "Complete returned workspace member and bot profiles, IDs, names, status, timezone, and deactivation flags. Email requires the optional users:read.email scope.",
+          "scopes": [
+            "users:read"
+          ],
+          "strategy": "full",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/users.list",
+              "documentation": "https://docs.slack.dev/reference/methods/users.list/"
+            }
+          ]
+        },
+        {
+          "name": "messages",
+          "title": "Messages and thread replies",
+          "table": "slack_messages_raw",
+          "description": "Raw messages selected by recent overlapping timestamp windows, plus replies belonging to selected roots. History-page progress commits after every selected reply is loaded. Old roots outside the range are not revisited; timestamps remain exact strings.",
+          "scopes": [
+            "channels:read",
+            "channels:history"
+          ],
+          "strategy": "cursor",
+          "endpoints": [
+            {
+              "method": "GET",
+              "path": "/conversations.history",
+              "documentation": "https://docs.slack.dev/reference/methods/conversations.history/"
+            },
+            {
+              "method": "GET",
+              "path": "/conversations.replies",
+              "documentation": "https://docs.slack.dev/reference/methods/conversations.replies/"
+            }
+          ]
+        }
+      ],
+      "views": [],
+      "sync": {
+        "description": "Channels and users are full reads. Messages initially select the recent 24 hours unless historyFrom is set, then overlap the completed watermark by 24 hours. Each history page and all its selected replies finish before its timestamp frontier commits. Temporary cursors and child progress are not persisted; old-root replies and old edits outside the selected range are outside normal coverage.",
+        "schedule": "Run chkit ingest run through cron, CI, or an existing scheduler, with one process per project/target. Interrupted message windows keep their fixed bounds and replay the incomplete history page; users/channels restart full reads. One history page and all its replies must fit the execution budget. Conservative message pacing remains 15 items and one request per minute.",
+        "deletions": "Later observations replace stable row IDs, but deleted, inaccessible, or deselected records remain. The integration does not consume Slack events, propagate deletions, or maintain a complete change log."
+      },
+      "env": {
+        "SLACK_API_TOKEN": ""
+      },
+      "fileHashes": {
+        "src/integrations/slack/README.md": "116614d7a6bf10e3f9e5e0250df64591e0bf1ebe3daa795a3754e93a6709399f",
+        "src/integrations/slack/client.ts": "dd955eaa26ecd4a60f435beb95239300dc5b974f4cc0b2a78753f277256690e2",
+        "src/integrations/slack/config.ts": "58bc3230105c660d0a230355243754664eb28c1b8b76cbcf40458404808a93aa",
+        "src/integrations/slack/index.ts": "6ff55043ea0e8bbe99722ffdd1c84b06902a917da224d6c7f95e26b9f7f94626",
+        "src/integrations/slack/pipeline.ts": "5e7b842e83cce7877a54878df7a27aad69e3d195b46e866b8b615f5763873847",
+        "src/integrations/slack/sources/channels.ts": "9a8fc49fdce34dce5fe667cf7b00c8309ad3f7b1fc8e7f441708c0f0132dfea7",
+        "src/integrations/slack/sources/users.ts": "08c790d4fea3806a1fd36ce5e3f1ef22f267e7cc762fea7ba5d351db05a107ba",
+        "src/integrations/slack/sources/messages.ts": "61a19640d5feff32ea05f89049b1c178121ab604f0b3a81e86038b9264b80fd3",
+        "src/integrations/slack/tests/slack.test.ts": "5f6a6d88e6d4a4743089b1d5a424ab042617ae12656e6f84d30c7883381050c8",
+        "src/integrations/slack/tests/fixtures.ts": "3dc1cd88b00ad0ec72a8211d4d3abce52e8ad277c4bb72a3c366123740ab1b9c",
+        "src/integrations/slack/state.ts": "9a8b6b502c828f7627ec27d321d86268558c679cd36b6c80c393a84d8a7ce5d9",
+        "src/integrations/slack/tests/checkpoints.test.ts": "d1f693dfc017bd3f6a5e170d26c2610391f8e77580f143d980b933a4b8eb9a1f"
+      }
+    }
+  }
+}
diff --git a/registry/slack/sources/channels.ts b/registry/slack/sources/channels.ts
index d61fbf6c..e5011b67 100644
--- a/registry/slack/sources/channels.ts
+++ b/registry/slack/sources/channels.ts
@@ -1,11 +1,13 @@
 import { rawTable, type FetchContext } from '@chkit/plugin-ingest'
 
-import { discoverChannels, getWorkspace, toSlackRows, type SlackClientDeps } from '../client.js'
+import { defaultSlackClientDeps, getWorkspace, readChannelPages, toSlackRows, type SlackClientDeps } from '../client.js'
 import { slackConfig } from '../config.js'
 
 export const slackChannelsRaw = rawTable({ database: slackConfig.database, name: `${slackConfig.tablePrefix}_channels_raw` })
 
-export async function* readChannels(context: FetchContext, deps?: SlackClientDeps) {
+export async function* readChannels(context: FetchContext, deps: SlackClientDeps = defaultSlackClientDeps) {
   const teamId = await getWorkspace(context, deps)
-  yield { rows: toSlackRows(await discoverChannels(context, deps), 'channels', teamId, 'id') }
+  for await (const page of readChannelPages(context, deps)) {
+    yield { rows: toSlackRows(page.items, 'channels', teamId, 'id', undefined, deps.config.sourceId) }
+  }
 }
diff --git a/registry/slack/sources/messages.ts b/registry/slack/sources/messages.ts
index 8e3bf9b7..29666148 100644
--- a/registry/slack/sources/messages.ts
+++ b/registry/slack/sources/messages.ts
@@ -1,38 +1,103 @@
-import { rawTable, type FetchContext } from '@chkit/plugin-ingest'
+import { IngestConfigError, rawTable, type ReadContext, type SourceChunk, type RawRow } from '@chkit/plugin-ingest'
 
-import { discoverChannels, entityId, getWorkspace, readCollection, toSlackRows, type SlackClientDeps } from '../client.js'
+import { defaultSlackClientDeps, discoverChannels, entityId, getWorkspace, readCollection, SlackCursorExpiredError, toSlackRows, type SlackClientDeps, type SlackEntity } from '../client.js'
 import { slackConfig } from '../config.js'
+import { formatTimestamp, messageScope, timestampMicros, type SlackMessageSelection, type SlackMessageState } from '../state.js'
 
 export const slackMessagesRaw = rawTable({ database: slackConfig.database, name: `${slackConfig.tablePrefix}_messages_raw` })
 
-/** Full scans revisit old roots as well as recent messages, including late thread replies. */
-export async function* readMessages(context: FetchContext, deps?: SlackClientDeps) {
+/** Temporary API cursors never enter the checkpoint; exact timestamps survive expiration. */
+export async function* readMessages(
+  context: ReadContext<SlackMessageSelection, SlackMessageState>,
+  deps: SlackClientDeps = defaultSlackClientDeps,
+): AsyncGenerator<SourceChunk<RawRow, SlackMessageState>> {
+  const config = deps.config
   const teamId = await getWorkspace(context, deps)
-  for (const channel of await discoverChannels(context, deps)) {
-    const channelId = entityId(channel, 'id')
-    const threads = new Set<string>()
-    for await (const page of readCollection(context, {
-      method: 'conversations.history', field: 'messages', idField: 'ts',
-      query: { channel: channelId, include_all_metadata: 'true' },
-    }, deps)) {
-      yield { rows: toSlackRows(page, 'messages', teamId, 'ts', channelId) }
-      if (!slackConfig.includeReplies) continue
-      for (const message of page) {
-        if (typeof message.reply_count !== 'number' || message.reply_count === 0) continue
-        const root = typeof message.thread_ts === 'string' ? entityId(message, 'thread_ts') : entityId(message, 'ts')
-        threads.add(root)
+  const scope = messageScope(teamId, config)
+  if (context.state && context.state.scope !== scope) throw new IngestConfigError('Slack checkpoint belongs to a different workspace or query. Restore the configuration or use a distinct sourceId.')
+  const initialFrom = context.selection.from ?? config.historyFrom ?? formatTimestamp(max(0n, timestampMicros(context.selection.to) - BigInt(config.overlapMs) * 1_000n))
+  let state: SlackMessageState = context.state ?? { scope, watermark: initialFrom }
+  if (!state.active) {
+    const channels = (await discoverChannels(context, deps)).map((channel) => entityId(channel, 'id')).sort()
+    const to = context.selection.to
+    const from = context.selection.from ?? (context.state ? formatTimestamp(max(config.historyFrom === undefined ? 0n : timestampMicros(config.historyFrom), timestampMicros(state.watermark) - BigInt(config.overlapMs) * 1_000n)) : initialFrom)
+    if (timestampMicros(from) > timestampMicros(to)) throw new IngestConfigError('Slack selection starts after its cutoff.')
+    state = { ...state, active: { from, to, channels, channelIndex: 0, latest: formatTimestamp(timestampMicros(to) + 1n),
+      requestedFrom: context.selection.from, requestedTo: context.selection.requestedTo } }
+    yield marker(state, 'window-open')
+  } else if (context.selection.backfill && (context.selection.from !== state.active.requestedFrom || context.selection.requestedTo !== state.active.requestedTo)) {
+    throw new IngestConfigError('Slack backfill bounds changed while a window is unfinished. Resume the original range or use a new backfill ID.')
+  }
+
+  while (state.active && state.active.channelIndex < state.active.channels.length) {
+    context.signal.throwIfAborted()
+    const work = state.active
+    const channelId = work.channels[work.channelIndex]
+    if (!channelId) throw new IngestConfigError('Slack checkpoint has no current channel.')
+    const page = await readTimePage(context, { channel: channelId, oldest: formatTimestamp(max(0n, timestampMicros(work.from) - 1n)), latest: work.latest,
+      inclusive: 'false', include_all_metadata: 'true' }, 'conversations.history', deps)
+    assertRange(page.items, timestampMicros(work.from), timestampMicros(work.latest) - 1n)
+    const latest = page.items.length ? formatTimestamp(page.items.reduce((oldest, item) => min(oldest, timestampMicros(entityId(item, 'ts'))), timestampMicros(work.latest))) : work.latest
+    if (page.hasMore && (page.items.length === 0 || timestampMicros(latest) >= timestampMicros(work.latest))) throw new IngestConfigError('Slack history pagination has no safe timestamp progress.')
+    const roots = config.includeReplies ? page.items.filter((item) => typeof item.reply_count === 'number' && item.reply_count > 0)
+      .map((item) => typeof item.thread_ts === 'string' ? entityId(item, 'thread_ts') : entityId(item, 'ts')) : []
+    if (page.items.length) yield { rows: toSlackRows(page.items, 'messages', teamId, 'ts', channelId, config.sourceId) }
+    for (const root of new Set(roots)) {
+      let after = formatTimestamp(max(0n, timestampMicros(root) - 1n))
+      while (true) {
+        const replies = await readTimePage(context, { channel: channelId, ts: root, oldest: after,
+          latest: formatTimestamp(timestampMicros(work.to) + 1n), inclusive: 'false', include_all_metadata: 'true' }, 'conversations.replies', deps)
+        const children = replies.items.filter((item) => entityId(item, 'ts') !== root)
+        assertRange(children, timestampMicros(after) + 1n, timestampMicros(work.to))
+        if (replies.hasMore && children.length === 0) throw new IngestConfigError('Slack thread pagination has no safe timestamp progress.')
+        if (replies.items.length) yield { rows: toSlackRows(replies.items, 'messages', teamId, 'ts', channelId, config.sourceId) }
+        if (!replies.hasMore) break
+        after = formatTimestamp(children.reduce((frontier, item) => max(frontier, timestampMicros(entityId(item, 'ts'))), timestampMicros(after)))
       }
     }
-    // Finish history pagination before scanning threads: a long thread must not leave
-    // the history cursor idle for hours, since Slack cursors expire.
-    for (const root of threads) {
-      for await (const replies of readCollection(context, {
-        method: 'conversations.replies', field: 'messages', idField: 'ts',
-        query: { channel: channelId, ts: root, include_all_metadata: 'true' },
-      }, deps)) {
-        // Slack repeats the parent; the shared channel/ts identity reconciles observations.
-        yield { rows: toSlackRows(replies, 'messages', teamId, 'ts', channelId) }
+    // Only a fully read history page and all its replies may advance durable history.
+    context.signal.throwIfAborted()
+    state = { ...state, active: { ...work, channelIndex: work.channelIndex + (page.hasMore ? 0 : 1),
+      latest: page.hasMore ? latest : formatTimestamp(timestampMicros(work.to) + 1n) } }
+    yield marker(state, 'history-page-complete')
+  }
+  if (state.active) {
+    state = { scope, watermark: formatTimestamp(max(timestampMicros(state.watermark), timestampMicros(state.active.to))) }
+    yield marker(state, 'window-complete')
+  }
+}
+
+/** Empty cursor pages use the live cursor; nonempty pages establish timestamp boundaries. */
+async function readTimePage(
+  context: ReadContext<SlackMessageSelection, SlackMessageState>, query: Record<string, string>,
+  method: 'conversations.history' | 'conversations.replies', deps?: SlackClientDeps,
+): Promise<{ items: SlackEntity[]; hasMore: boolean }> {
+  let restarted = false
+  const parents = new Map<string, SlackEntity>()
+  while (true) {
+    let continued = false
+    try {
+      for await (const page of readCollection(context, { method, field: 'messages', idField: 'ts', query, timePagination: true }, deps)) {
+        for (const item of page.items) parents.set(entityId(item, 'ts'), item)
+        if (page.next === undefined) return { items: [...parents.values()], hasMore: page.metadata?.hasMore === true }
+        continued = true
       }
+    } catch (error) {
+      if (!(error instanceof SlackCursorExpiredError) || !continued || restarted) throw error
+      restarted = true
     }
   }
 }
+
+function marker(state: SlackMessageState, id: string): SourceChunk<RawRow, SlackMessageState> {
+  // State-only boundaries flush previous rows without assigning identity to mutable data.
+  return { rows: [], state, id }
+}
+function assertRange(items: SlackEntity[], from: bigint, to: bigint): void {
+  if (items.some((item) => {
+    const ts = timestampMicros(entityId(item, 'ts'))
+    return ts < from || ts > to
+  })) throw new IngestConfigError('Slack returned a message outside the requested timestamp interval.')
+}
+function max(left: bigint, right: bigint): bigint { return left > right ? left : right }
+function min(left: bigint, right: bigint): bigint { return left < right ? left : right }
diff --git a/registry/slack/sources/users.ts b/registry/slack/sources/users.ts
index 24500ab9..48b74633 100644
--- a/registry/slack/sources/users.ts
+++ b/registry/slack/sources/users.ts
@@ -1,13 +1,13 @@
 import { rawTable, type FetchContext } from '@chkit/plugin-ingest'
 
-import { getWorkspace, readCollection, toSlackRows, type SlackClientDeps } from '../client.js'
+import { defaultSlackClientDeps, getWorkspace, readCollection, toSlackRows, type SlackClientDeps } from '../client.js'
 import { slackConfig } from '../config.js'
 
 export const slackUsersRaw = rawTable({ database: slackConfig.database, name: `${slackConfig.tablePrefix}_users_raw` })
 
-export async function* readUsers(context: FetchContext, deps?: SlackClientDeps) {
+export async function* readUsers(context: FetchContext, deps: SlackClientDeps = defaultSlackClientDeps) {
   const teamId = await getWorkspace(context, deps)
   for await (const page of readCollection(context, { method: 'users.list', field: 'members', idField: 'id' }, deps)) {
-    yield { rows: toSlackRows(page, 'users', teamId, 'id') }
+    yield { rows: toSlackRows(page.items, 'users', teamId, 'id', undefined, deps.config.sourceId) }
   }
 }
diff --git a/registry/slack/state.ts b/registry/slack/state.ts
new file mode 100644
index 00000000..c7c7e0bd
--- /dev/null
+++ b/registry/slack/state.ts
@@ -0,0 +1,82 @@
+import { IngestConfigError, type IncrementalStrategy } from '@chkit/plugin-ingest'
+import { slackConfig, type SlackReaderConfig } from './config.js'
+
+export interface MessageWork {
+  from: string
+  to: string
+  channels: string[]
+  channelIndex: number
+  latest: string
+  requestedFrom?: string
+  requestedTo?: string
+}
+export interface SlackMessageState {
+  scope: string
+  watermark: string
+  active?: MessageWork
+}
+export interface SlackMessageSelection { from?: string; to: string; requestedTo?: string; backfill: boolean }
+
+export function createSlackMessageStrategy(config: SlackReaderConfig): IncrementalStrategy<SlackMessageState, SlackMessageSelection> {
+  return {
+    id: 'slack.message-ranges', version: 2, parseState: parseMessageState,
+    plan({ cutoff, range }) {
+      if (config.historyFrom !== undefined) timestampMicros(config.historyFrom)
+      if (!Number.isSafeInteger(config.overlapMs) || config.overlapMs < 0) throw new IngestConfigError('Slack overlapMs must be a non-negative safe integer.')
+      return { from: range?.from ? dateTimestamp(range.from) : undefined, to: dateTimestamp(range?.to ?? cutoff),
+        requestedTo: range?.to ? dateTimestamp(range.to) : undefined, backfill: range !== undefined }
+    },
+  }
+}
+
+export const slackMessageStrategy = createSlackMessageStrategy(slackConfig)
+
+export function messageScope(teamId: string, config: SlackReaderConfig = slackConfig): string {
+  return JSON.stringify([config.sourceId, teamId, config.channels ? [...config.channels].sort() : null,
+    [...config.conversationTypes].sort(), config.includeReplies, config.historyFrom ?? null, config.overlapMs])
+}
+
+export function timestampMicros(value: string): bigint {
+  if (!/^\d+\.\d{1,6}$/.test(value)) throw new IngestConfigError('Slack timestamps must be exact decimal strings with at most six fractional digits.')
+  const [seconds = '', fraction = ''] = value.split('.')
+  return BigInt(seconds) * 1_000_000n + BigInt(fraction.padEnd(6, '0'))
+}
+
+export function formatTimestamp(value: bigint): string {
+  if (value < 0n) throw new IngestConfigError('Slack timestamp cannot be negative.')
+  return `${value / 1_000_000n}.${(value % 1_000_000n).toString().padStart(6, '0')}`
+}
+
+export function dateTimestamp(value: Date): string {
+  if (!Number.isSafeInteger(value.getTime()) || value.getTime() < 0) throw new IngestConfigError('Slack time bounds must be valid dates after the Unix epoch.')
+  return formatTimestamp(BigInt(value.getTime()) * 1_000n)
+}
+
+export function parseMessageState(raw: unknown): SlackMessageState {
+  if (!isObject(raw) || typeof raw.scope !== 'string') throw new IngestConfigError('Invalid Slack checkpoint scope.')
+  if ('knownChannels' in raw || 'lastFullAt' in raw) throw new IngestConfigError('Slack message checkpoint uses the former retained-work format. Migrate it explicitly or use a new sourceId for strategy version 2.')
+  const watermark = readTimestamp(raw.watermark)
+  let active: MessageWork | undefined
+  if (raw.active !== undefined) {
+    const work = raw.active
+    if (!isObject(work) || typeof work.channelIndex !== 'number' || !Number.isSafeInteger(work.channelIndex)
+      || !Array.isArray(work.channels) || !work.channels.every((id: unknown): id is string => typeof id === 'string' && id.length > 0)
+      || new Set(work.channels).size !== work.channels.length) throw new IngestConfigError('Invalid Slack active work.')
+    if ('threads' in work || 'historyDone' in work || 'kind' in work) throw new IngestConfigError('Slack message checkpoint uses the former retained-work format. Migrate it explicitly or use a new sourceId for strategy version 2.')
+    if (work.channelIndex < 0 || work.channelIndex > work.channels.length) throw new IngestConfigError('Invalid Slack channel position.')
+    const from = readTimestamp(work.from), to = readTimestamp(work.to), latest = readTimestamp(work.latest)
+    if (timestampMicros(from) > timestampMicros(to) || timestampMicros(latest) <= timestampMicros(from) - 1n
+      || timestampMicros(latest) > timestampMicros(to) + 1n) throw new IngestConfigError('Invalid Slack window bounds.')
+    active = { from, to, channels: [...work.channels], channelIndex: work.channelIndex, latest,
+      requestedFrom: work.requestedFrom === undefined ? undefined : readTimestamp(work.requestedFrom),
+      requestedTo: work.requestedTo === undefined ? undefined : readTimestamp(work.requestedTo) }
+  }
+  return { scope: raw.scope, watermark, active }
+}
+
+function readTimestamp(value: unknown): string {
+  if (typeof value !== 'string') throw new IngestConfigError('Invalid Slack checkpoint timestamp.')
+  timestampMicros(value)
+  return value
+}
+function isObject(value: unknown): value is Record<string, unknown> { return typeof value === 'object' && value !== null && !Array.isArray(value) }
diff --git a/registry/slack/tests/checkpoints.test.ts b/registry/slack/tests/checkpoints.test.ts
new file mode 100644
index 00000000..f901bf5b
--- /dev/null
+++ b/registry/slack/tests/checkpoints.test.ts
@@ -0,0 +1,309 @@
+import { afterEach, expect, test } from 'bun:test'
+import { definePipeline, defineStream, runIngestion, selectStreams } from '@chkit/plugin-ingest'
+import { createMemoryDestination, createMemoryJournal } from '@chkit/plugin-ingest/testing'
+
+import { slackConfig } from '../config.js'
+import { readMessages, slackMessagesRaw } from '../sources/messages.js'
+import { createSlackMessageStrategy, dateTimestamp, parseMessageState, timestampMicros } from '../state.js'
+import { fixtureDeps, parentMessage, replyMessage, standaloneMessage } from './fixtures.js'
+import type { SlackClientDeps } from '../client.js'
+
+const originalConfig = { ...slackConfig }
+const cutoff = new Date('2023-11-15T00:00:00Z')
+afterEach(() => { Object.assign(slackConfig, originalConfig) })
+
+test('an incomplete history page replays its replies under the original frozen bounds', async () => {
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  const calls: URL[] = []
+  const defaults = fixtureDeps()
+  const deps = fixtureDeps((url, init) => { calls.push(url); return defaults.fetch(url.toString(), init) })
+  const first = await runIngestion(request(pipeline(deps, { maxChunks: 2 })), { journal, destination, now: () => cutoff })
+  expect(first.streams[0]?.outcome).toBe('budget_exhausted')
+  const saved = parseMessageState((await journal.readCheckpoint('slack.primary.messages')).envelope?.state)
+  expect(saved.watermark).toBe('1699920000.000000')
+  expect(saved.active).toMatchObject({ from: '1699920000.000000', to: dateTimestamp(cutoff), latest: '1700006400.000001', channelIndex: 0 })
+  expect(saved.active).not.toHaveProperty('threads')
+  const restored = createMemoryJournal()
+  await restored.append(journal.events.map((event) => ({ ...event,
+    checkpoint: event.checkpoint === undefined ? undefined : JSON.parse(JSON.stringify(event.checkpoint)),
+  })))
+  calls.length = 0
+  const second = await runIngestion(request(pipeline(deps)), { journal: restored, destination, now: () => new Date('2023-11-16T00:00:00Z') })
+  expect(second.ok, JSON.stringify(second)).toBe(true)
+  expect(calls.map((url) => url.pathname)).toEqual(['/api/auth.test', '/api/conversations.history', '/api/conversations.replies'])
+  expect(calls.filter((url) => url.pathname.endsWith('history') || url.pathname.endsWith('replies')).every((url) => url.searchParams.get('latest') === '1700006400.000001')).toBe(true)
+  const completed = parseMessageState((await restored.readCheckpoint('slack.primary.messages')).envelope?.state)
+  expect(completed.active).toBeUndefined()
+  expect(completed.watermark).toBe(dateTimestamp(cutoff))
+  expect(destination.tables.get('default.slack_messages_raw')?.map((row) => row.raw)).toContainEqual({ source_id: 'slack.primary', team_id: 'T1', channel_id: 'C1', data: replyMessage })
+})
+
+test('lost child acknowledgement replays the whole history page without advancing it', async () => {
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  const controller = new AbortController()
+  const first = await runIngestion(request(pipeline(fixtureDeps())), {
+    journal, now: () => cutoff, signal: controller.signal,
+    destination: { async insert(input) {
+      await destination.insert(input)
+      if (input.rows.some((row) => JSON.stringify(row.raw).includes(replyMessage.text))) controller.abort(new Error('lost child acknowledgement'))
+    } },
+  })
+  expect(first.ok).toBe(false)
+  const saved = parseMessageState((await journal.readCheckpoint('slack.primary.messages')).envelope?.state)
+  expect(saved.active?.latest).toBe('1700006400.000001')
+  expect(saved.active?.channelIndex).toBe(0)
+  const calls: string[] = []
+  const defaults = fixtureDeps()
+  const deps = fixtureDeps((url, init) => { calls.push(url.pathname); return defaults.fetch(url.toString(), init) })
+  expect((await runIngestion(request(pipeline(deps)), { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect(calls).toEqual(['/api/auth.test', '/api/conversations.history', '/api/conversations.replies'])
+  expect(destination.tables.get('default.slack_messages_raw')).toHaveLength(4)
+  expect(parseMessageState((await journal.readCheckpoint('slack.primary.messages')).envelope?.state).active).toBeUndefined()
+})
+
+test('multi-page replies use local ascending timestamps and restart the incomplete thread on resume', async () => {
+  const secondReply = { ...replyMessage, ts: '1700000001.000003', text: 'Second reply' }
+  const oldest: string[] = []
+  const defaults = fixtureDeps()
+  const deps = fixtureDeps((url, init) => {
+    if (url.pathname !== '/api/conversations.replies') return defaults.fetch(url.toString(), init)
+    oldest.push(url.searchParams.get('oldest') ?? '')
+    const final = url.searchParams.get('oldest') === replyMessage.ts
+    return Response.json({ ok: true, messages: final ? [secondReply] : [parentMessage, replyMessage], has_more: !final })
+  })
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  expect((await runIngestion(request(pipeline(deps, { maxChunks: 3 })), { journal, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')
+  const saved = parseMessageState((await journal.readCheckpoint('slack.primary.messages')).envelope?.state)
+  expect(saved.active?.latest).toBe('1700006400.000001')
+  expect(saved.active).not.toHaveProperty('threads')
+  expect((await runIngestion(request(pipeline(deps)), { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect(oldest).toEqual(['1700000000.000000', '1700000000.000000', replyMessage.ts])
+  expect(destination.tables.get('default.slack_messages_raw')?.map((row) => row.raw)).toContainEqual({ source_id: 'slack.primary', team_id: 'T1', channel_id: 'C1', data: secondReply })
+})
+
+test('a completed history page resumes from an exact timestamp rather than an expiring cursor', async () => {
+  slackConfig.includeReplies = false
+  const newest = { ...standaloneMessage, ts: '1700000002.000002' }
+  const older = { ...standaloneMessage, ts: '1700000002.000001' }
+  const urls: URL[] = []
+  const defaults = fixtureDeps()
+  const deps = fixtureDeps((url, init) => {
+    if (url.pathname !== '/api/conversations.history') return defaults.fetch(url.toString(), init)
+    urls.push(url)
+    const resumed = url.searchParams.get('latest') === newest.ts
+    return Response.json({ ok: true, messages: [resumed ? older : newest], has_more: !resumed })
+  })
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  expect((await runIngestion(request(pipeline(deps, { maxChunks: 3 })), { journal, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')
+  const saved = parseMessageState((await journal.readCheckpoint('slack.primary.messages')).envelope?.state)
+  expect(saved.active?.latest).toBe(newest.ts)
+  expect(JSON.stringify(saved)).not.toContain('cursor')
+  expect((await runIngestion(request(pipeline(deps)), { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect(urls.map((url) => url.searchParams.get('latest'))).toEqual(['1700006400.000001', newest.ts])
+  expect(urls.every((url) => !url.searchParams.has('cursor'))).toBe(true)
+  expect(new Set(destination.tables.get('default.slack_messages_raw')?.map((row) => row.id)).size).toBe(2)
+})
+
+test('empty history cursor pages precede the completed timestamp boundary', async () => {
+  slackConfig.includeReplies = false
+  const urls: URL[] = []
+  const defaults = fixtureDeps()
+  const deps = fixtureDeps((url, init) => {
+    if (url.pathname !== '/api/conversations.history') return defaults.fetch(url.toString(), init)
+    urls.push(url)
+    if (url.searchParams.get('latest') === standaloneMessage.ts) return Response.json({ ok: true, messages: [parentMessage], has_more: false })
+    return Response.json(url.searchParams.has('cursor')
+      ? { ok: true, messages: [standaloneMessage], has_more: true, response_metadata: { next_cursor: 'empty-page' } }
+      : { ok: true, messages: [], has_more: true, response_metadata: { next_cursor: 'empty-page' } })
+  })
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  expect((await runIngestion(request(pipeline(deps, { maxChunks: 3 })), { journal, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')
+  const saved = parseMessageState((await journal.readCheckpoint('slack.primary.messages')).envelope?.state)
+  expect(saved.active?.latest).toBe(standaloneMessage.ts)
+  expect(JSON.stringify(saved)).not.toContain('empty-page')
+  expect((await runIngestion(request(pipeline(deps)), { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect(urls.map((url) => [url.searchParams.get('cursor'), url.searchParams.get('latest')])).toEqual([
+    [null, '1700006400.000001'], ['empty-page', '1700006400.000001'], [null, standaloneMessage.ts],
+  ])
+})
+
+test('a page too large for the chunk budget replays until the budget can include its completion marker', async () => {
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  const deps = fixtureDeps()
+  const small = request(pipeline(deps, { maxChunks: 2 }))
+  expect((await runIngestion(small, { journal, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')
+  const checkpoint = await journal.readCheckpoint('slack.primary.messages')
+  expect((await runIngestion(small, { journal, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')
+  expect((await journal.readCheckpoint('slack.primary.messages')).version).toBe(checkpoint.version)
+  expect(parseMessageState((await journal.readCheckpoint('slack.primary.messages')).envelope?.state).active?.channelIndex).toBe(0)
+  expect((await runIngestion(request(pipeline(deps, { maxChunks: 5 })), { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect(new Set(destination.tables.get('default.slack_messages_raw')?.map((row) => row.id)).size).toBe(3)
+})
+
+test('default bootstrap is recent and subsequent passes overlap the completed watermark by 24 hours', async () => {
+  const oldest: string[] = []
+  const defaults = fixtureDeps()
+  const deps = fixtureDeps((url, init) => {
+    if (url.pathname !== '/api/conversations.history') return defaults.fetch(url.toString(), init)
+    oldest.push(url.searchParams.get('oldest') ?? '')
+    return Response.json({ ok: true, messages: [], has_more: false })
+  })
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  expect((await runIngestion(request(pipeline(deps)), { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect((await runIngestion(request(pipeline(deps)), { journal, destination, now: () => new Date('2023-11-15T12:00:00Z') })).ok).toBe(true)
+  expect(oldest).toEqual(['1699919999.999999', '1699919999.999999'])
+  expect(parseMessageState((await journal.readCheckpoint('slack.primary.messages')).envelope?.state).watermark).toBe('1700049600.000000')
+})
+
+test('recent roots gain replies during overlap while old roots and their late replies stay outside normal coverage', async () => {
+  const recentRoot = { ...parentMessage, ts: dateTimestamp(new Date('2023-11-15T06:00:00Z')), thread_ts: dateTimestamp(new Date('2023-11-15T06:00:00Z')) }
+  const recentReply = { ...replyMessage, ts: dateTimestamp(new Date('2023-11-15T07:00:00Z')), thread_ts: recentRoot.ts, text: 'Recent reply' }
+  const oldLateReply = { ...replyMessage, ts: dateTimestamp(new Date('2023-11-17T06:00:00Z')), text: 'Old root late reply' }
+  let now = new Date('2023-11-15T06:30:00Z')
+  const roots: string[] = []
+  const defaults = fixtureDeps()
+  const deps = fixtureDeps((url, init) => {
+    if (url.pathname === '/api/conversations.history') {
+      const from = timestampMicros(url.searchParams.get('oldest') ?? '0.000000')
+      const to = timestampMicros(url.searchParams.get('latest') ?? '0.000000')
+      return Response.json({ ok: true, messages: [parentMessage, recentRoot].filter((item) => timestampMicros(item.ts) > from && timestampMicros(item.ts) < to), has_more: false })
+    }
+    if (url.pathname === '/api/conversations.replies') {
+      const root = url.searchParams.get('ts') ?? ''
+      roots.push(root)
+      const to = timestampMicros(url.searchParams.get('latest') ?? '0.000000')
+      return Response.json({ ok: true, messages: root === recentRoot.ts
+        ? [recentRoot, recentReply].filter((item) => timestampMicros(item.ts) < to)
+        : [parentMessage, replyMessage, oldLateReply].filter((item) => timestampMicros(item.ts) < to), has_more: false })
+    }
+    return defaults.fetch(url.toString(), init)
+  })
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  const execute = () => runIngestion(request(pipeline(deps)), { journal, destination, now: () => now })
+  expect((await execute()).ok).toBe(true)
+  now = new Date('2023-11-15T08:00:00Z')
+  expect((await execute()).ok).toBe(true)
+  expect(destination.tables.get('default.slack_messages_raw')?.map((row) => row.raw)).toContainEqual({ source_id: 'slack.primary', team_id: 'T1', channel_id: 'C1', data: recentReply })
+  now = new Date('2023-11-16T08:00:00Z')
+  expect((await execute()).ok).toBe(true)
+  now = new Date('2023-11-17T08:00:00Z')
+  expect((await execute()).ok).toBe(true)
+  roots.length = 0
+  now = new Date('2023-11-24T08:00:00Z')
+  expect((await execute()).ok).toBe(true)
+  expect(roots).toEqual([])
+  expect(destination.tables.get('default.slack_messages_raw')?.some((row) => JSON.stringify(row.raw).includes(oldLateReply.text))).toBe(false)
+})
+
+test('an explicit historyFrom expands initial coverage without periodic historical reconciliation', async () => {
+  slackConfig.historyFrom = '0.000000'
+  const bounds: string[] = []
+  const defaults = fixtureDeps()
+  const deps = fixtureDeps((url, init) => {
+    if (url.pathname !== '/api/conversations.history') return defaults.fetch(url.toString(), init)
+    bounds.push(url.searchParams.get('oldest') ?? '')
+    return Response.json({ ok: true, messages: [], has_more: false })
+  })
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  expect((await runIngestion(request(pipeline(deps)), { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect((await runIngestion(request(pipeline(deps)), { journal, destination, now: () => new Date('2023-11-23T00:00:00Z') })).ok).toBe(true)
+  expect(bounds).toEqual(['0.000000', '1699919999.999999'])
+})
+
+test('empty terminal pages commit progress and query or account changes reject saved state', async () => {
+  const defaults = fixtureDeps()
+  const deps = fixtureDeps((url, init) => url.pathname === '/api/conversations.history'
+    ? Response.json({ ok: true, messages: [], has_more: false }) : defaults.fetch(url.toString(), init))
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  expect((await runIngestion(request(pipeline(deps)), { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect(parseMessageState((await journal.readCheckpoint('slack.primary.messages')).envelope?.state).watermark).toBe(dateTimestamp(cutoff))
+  expect(destination.tables.size).toBe(0)
+  const otherTeam = fixtureDeps((url, init) => url.pathname === '/api/auth.test' ? Response.json({ ok: true, team_id: 'T2' }) : defaults.fetch(url.toString(), init))
+  expect((await runIngestion(request(pipeline(otherTeam)), { journal, destination, now: () => cutoff })).streams[0]?.error).toContain('different workspace or query')
+  slackConfig.includeReplies = false
+  expect((await runIngestion(request(pipeline(deps)), { journal, destination, now: () => cutoff })).streams[0]?.error).toContain('different workspace or query')
+  expect(() => parseMessageState({ scope: 'broken', watermark: 1700006400 })).toThrow('timestamp')
+})
+
+test('backfills isolate normal progress and retain requested bounds through a coarse-page pause', async () => {
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  const backfill = { id: 'november', from: new Date('2023-11-14T00:00:00Z'), to: cutoff }
+  const selected = selectStreams([pipeline(fixtureDeps(), { maxChunks: 2 })], [])
+  expect((await runIngestion({ selected, backfill }, { journal, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')
+  expect((await journal.readCheckpoint('slack.primary.messages')).envelope).toBeUndefined()
+  const changed = await runIngestion({ selected: selectStreams([pipeline(fixtureDeps())], []), backfill: { ...backfill, to: new Date('2023-11-16T00:00:00Z') } }, { journal, destination, now: () => cutoff })
+  expect(changed.ok).toBe(false)
+  expect(changed.streams[0]?.error).toContain('bounds changed')
+  expect((await runIngestion({ selected: selectStreams([pipeline(fixtureDeps())], []), backfill }, { journal, destination, now: () => cutoff })).ok).toBe(true)
+})
+
+test('a backfill without an explicit upper bound resumes its original cutoff', async () => {
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  const backfill = { id: 'open-ended', from: new Date('2023-11-14T00:00:00Z'), to: undefined }
+  expect((await runIngestion({ selected: selectStreams([pipeline(fixtureDeps(), { maxChunks: 2 })], []), backfill }, { journal, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')
+  expect((await runIngestion({ selected: selectStreams([pipeline(fixtureDeps())], []), backfill }, { journal, destination, now: () => new Date('2023-11-16T00:00:00Z') })).ok).toBe(true)
+  expect((await journal.readCheckpoint('slack.primary.messages')).envelope).toBeUndefined()
+  expect(parseMessageState((await journal.readCheckpoint('slack.primary.messages#backfill:open-ended')).envelope?.state).watermark).toBe(dateTimestamp(cutoff))
+})
+
+test('strategy version 2 rejects old envelopes before making requests', async () => {
+  const deps = fixtureDeps(), journal = createMemoryJournal(), destination = createMemoryDestination()
+  const current = pipeline(deps, { maxChunks: 1 })
+  const old = { ...current, streams: current.streams.map((stream) => ({ ...stream, incremental: { ...stream.incremental, version: 1 } })) }
+  expect((await runIngestion(request(old), { journal, destination, now: () => cutoff })).streams[0]?.outcome).toBe('budget_exhausted')
+  let calls = 0
+  const unused = fixtureDeps(() => { calls += 1; throw new Error('Old checkpoint must fail before requesting') })
+  const result = await runIngestion(request(pipeline(unused)), { journal, destination, now: () => cutoff })
+  expect(result.ok).toBe(false)
+  expect(result.streams[0]?.error).toContain('slack.message-ranges@1')
+  expect(result.streams[0]?.error).toContain('slack.message-ranges@2')
+  expect(calls).toBe(0)
+  expect(() => parseMessageState({ scope: 'old', watermark: '0.000000', knownChannels: [] })).toThrow('former retained-work format')
+})
+
+test('expired temporary reply cursors replay their bounds and retain the newest parent observation', async () => {
+  const cursors: string[] = []
+  const updatedParent = { ...parentMessage, text: 'Updated parent' }
+  const defaults = fixtureDeps()
+  const deps = fixtureDeps((url, init) => {
+    if (url.pathname !== '/api/conversations.replies') return defaults.fetch(url.toString(), init)
+    const cursor = url.searchParams.get('cursor') ?? ''
+    cursors.push(cursor)
+    if (cursor === 'expired') return Response.json({ ok: false, error: 'invalid_cursor' })
+    if (cursor === 'current') return Response.json({ ok: true, messages: [updatedParent, replyMessage], has_more: false })
+    return Response.json({ ok: true, messages: [parentMessage], has_more: true, response_metadata: { next_cursor: cursors.length === 1 ? 'expired' : 'current' } })
+  })
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  expect((await runIngestion(request(pipeline(deps)), { journal, destination, now: () => cutoff })).ok).toBe(true)
+  expect(cursors).toEqual(['', 'expired', '', 'current'])
+  expect(destination.tables.get('default.slack_messages_raw')?.map((row) => row.raw)).toContainEqual({ source_id: 'slack.primary', team_id: 'T1', channel_id: 'C1', data: updatedParent })
+  expect(JSON.stringify((await journal.readCheckpoint('slack.primary.messages')).envelope?.state)).not.toContain('cursor')
+})
+
+test.each(['initial', 'after-replay'])('a rejected reply cursor %s leaves the entire history page unfinished', async (failure) => {
+  const cursors: Array<string | null> = []
+  const defaults = fixtureDeps()
+  const deps = fixtureDeps((url, init) => {
+    if (url.pathname !== '/api/conversations.replies') return defaults.fetch(url.toString(), init)
+    const cursor = url.searchParams.get('cursor')
+    cursors.push(cursor)
+    return Response.json(failure === 'initial' || cursor
+      ? { ok: false, error: 'invalid_cursor' }
+      : { ok: true, messages: [parentMessage], has_more: true, response_metadata: { next_cursor: 'expired' } })
+  })
+  const journal = createMemoryJournal(), destination = createMemoryDestination()
+  const result = await runIngestion(request(pipeline(deps)), { journal, destination, now: () => cutoff })
+  expect(result.ok).toBe(false)
+  expect(result.streams[0]?.error).toContain('cursor expired')
+  expect(cursors).toEqual(failure === 'initial' ? [null] : [null, 'expired', null, 'expired'])
+  expect(parseMessageState((await journal.readCheckpoint('slack.primary.messages')).envelope?.state).active?.latest).toBe('1700006400.000001')
+  expect(destination.tables.get('default.slack_messages_raw')?.map((row) => row.raw)).not.toContainEqual({ source_id: 'slack.primary', team_id: 'T1', channel_id: 'C1', data: replyMessage })
+})
+
+function pipeline(deps: SlackClientDeps, budget?: { maxChunks?: number }) {
+  return definePipeline({ id: 'slack.primary', retry: { retries: 0 }, streams: [defineStream({
+    id: 'slack.primary.messages', destination: slackMessagesRaw, incremental: createSlackMessageStrategy(deps.config), batchSize: 1, budget,
+    read: (context) => readMessages(context, deps),
+  })] })
+}
+function request(value: ReturnType<typeof pipeline>) { return { selected: selectStreams([value], []), backfill: undefined } }
diff --git a/registry/slack/tests/fixtures.ts b/registry/slack/tests/fixtures.ts
index c649e3d4..003602e9 100644
--- a/registry/slack/tests/fixtures.ts
+++ b/registry/slack/tests/fixtures.ts
@@ -1,4 +1,5 @@
 import type { SlackClientDeps } from '../client.js'
+import { slackConfig } from '../config.js'
 
 export const channel = {
   id: 'C1', name: 'project-example', is_channel: true, is_private: false, is_archived: false,
@@ -38,6 +39,7 @@ export function fixtureDeps(
   },
 ): SlackClientDeps {
   return {
+    config: slackConfig,
     token: () => 'fixture-token',
     wait: async () => {},
     fetch: (url, init) => Promise.resolve(respond(new URL(url), init)),
diff --git a/registry/slack/tests/install.e2e.test.ts b/registry/slack/tests/install.e2e.test.ts
index 21514e42..afbfc038 100644
--- a/registry/slack/tests/install.e2e.test.ts
+++ b/registry/slack/tests/install.e2e.test.ts
@@ -5,12 +5,13 @@ import { join, resolve } from 'node:path'
 import { pathToFileURL } from 'node:url'
 
 import { createStatelessLiveExecutor, createPrefix, getLiveEnv, quoteIdent, waitForTable } from '@chkit/clickhouse/e2e-testkit'
-import { createClickHouseDestination, definePipeline, runIngestion, selectStreams, type FetchContext, type SourceChunk } from '@chkit/plugin-ingest'
+import { createClickHouseDestination, definePipeline, defineStream, runIngestion, selectStreams, type FetchContext, type SourceChunk } from '@chkit/plugin-ingest'
 import { createMemoryJournal } from '@chkit/plugin-ingest/testing'
 
 import { buildRegistryCatalog } from '../../../packages/cli/src/registry/build.js'
 import { formatTestDiagnostic, runCli } from '../../../packages/cli/src/test/e2e-testkit.js'
 import { readRegistrySourceCatalog } from '../../../scripts/registry-catalog.js'
+import { CLI_VERSION } from '../../../packages/cli/src/runtime/version.js'
 import { channel, fixtureDeps, parentMessage, replyMessage, standaloneMessage, user } from './fixtures.js'
 
 describe.serial('built Slack template installed into a consumer', () => {
@@ -33,7 +34,13 @@ describe.serial('built Slack template installed into a consumer', () => {
     const directory = await mkdtemp(join(tmpdir(), 'chkit-slack-installed-'))
     temporary.push(directory)
     const outputDir = join(directory, 'registry')
-    await buildRegistryCatalog({ catalog: await readRegistrySourceCatalog(), sourceRoot: join(root, 'registry'), outputDir })
+    // Exercise source with workspace packages, retaining the template version and changelog.
+    const sourceCatalog = await readRegistrySourceCatalog()
+    const catalog = { ...sourceCatalog, items: sourceCatalog.items.map((item) => ({ ...item,
+      dependencies: [`@chkit/core@${CLI_VERSION}`, `@chkit/plugin-ingest@${CLI_VERSION}`],
+      meta: { chkit: { ...item.meta.chkit, chkit: CLI_VERSION, ingest: CLI_VERSION } },
+    })) }
+    await buildRegistryCatalog({ catalog, sourceRoot: join(root, 'registry'), outputDir })
     const project = join(directory, 'project')
     await writeProject(project, root, env.clickhouseDatabase, prefix)
     const cliEnv = {
@@ -55,7 +62,7 @@ describe.serial('built Slack template installed into a consumer', () => {
     const add = cli(['add', 'slack', '--registry', outputDir, '--with-tests', '--no-install', '--json'])
     expect(add.exitCode, formatTestDiagnostic('install', add)).toBe(0)
     expect(JSON.parse(add.stdout).template.name).toBe('slack')
-    const fixtureTests = Bun.spawnSync(['bun', 'test', 'src/integrations/slack/tests/slack.test.ts'], {
+    const fixtureTests = Bun.spawnSync(['bun', 'test', 'src/integrations/slack/tests/slack.test.ts', 'src/integrations/slack/tests/checkpoints.test.ts'], {
       cwd: project, env: { ...process.env, SLACK_API_TOKEN: '' },
     })
     expect(fixtureTests.exitCode, fixtureTests.stderr.toString()).toBe(0)
@@ -76,6 +83,7 @@ describe.serial('built Slack template installed into a consumer', () => {
     const channels: typeof import('../sources/channels.js') = await import(pathToFileURL(join(project, 'src/integrations/slack/sources/channels.ts')).href)
     const users: typeof import('../sources/users.js') = await import(pathToFileURL(join(project, 'src/integrations/slack/sources/users.ts')).href)
     const messages: typeof import('../sources/messages.js') = await import(pathToFileURL(join(project, 'src/integrations/slack/sources/messages.ts')).href)
+    const state: typeof import('../state.js') = await import(pathToFileURL(join(project, 'src/integrations/slack/state.ts')).href)
     let revision = 1
     const defaults = fixtureDeps()
     const deps = fixtureDeps((url, init) => {
@@ -87,11 +95,11 @@ describe.serial('built Slack template installed into a consumer', () => {
     const readers: Record<string, (context: FetchContext) => AsyncIterable<SourceChunk>> = {
       channels: (context) => channels.readChannels(context, deps),
       users: (context) => users.readUsers(context, deps),
-      messages: (context) => messages.readMessages(context, deps),
     }
     const pipeline = definePipeline({
       ...installed.slack, retry: { retries: 0 },
       streams: installed.slack.streams.map((stream) => {
+        if (stream.id.endsWith('.messages')) return defineStream({ ...stream, incremental: state.slackMessageStrategy, read: (context) => messages.readMessages(context, deps) })
         const read = readers[stream.id.split('.').at(-1) ?? '']
         if (!read) throw new Error(`Installed fixture reader missing for ${stream.id}`)
         return { ...stream, read }
@@ -100,7 +108,7 @@ describe.serial('built Slack template installed into a consumer', () => {
     const journal = createMemoryJournal()
     for (const next of [1, 2]) {
       revision = next
-      const result = await runIngestion({ selected: selectStreams([pipeline], []), backfill: undefined }, { journal, destination: createClickHouseDestination(executor) })
+      const result = await runIngestion({ selected: selectStreams([pipeline], []), backfill: undefined }, { journal, destination: createClickHouseDestination(executor), now: () => new Date('2023-11-15T00:00:00Z') })
       expect(result.ok, JSON.stringify(result)).toBe(true)
     }
     const table = (resource: string) => `${quoteIdent(env.clickhouseDatabase)}.${quoteIdent(`${prefix}_${resource}_raw`)}`
diff --git a/registry/slack/tests/slack.test.ts b/registry/slack/tests/slack.test.ts
index f3f4aab3..3f442822 100644
--- a/registry/slack/tests/slack.test.ts
+++ b/registry/slack/tests/slack.test.ts
@@ -1,34 +1,111 @@
 import { afterEach, describe, expect, test } from 'bun:test'
 
-import { HttpError, definePipeline, runIngestion, selectStreams, type FetchContext, type SourceChunk } from '@chkit/plugin-ingest'
+import { HttpError, definePipeline, defineStream, runIngestion, selectStreams, type FetchContext, type ReadContext, type SourceChunk } from '@chkit/plugin-ingest'
 import { createMemoryDestination, createMemoryJournal } from '@chkit/plugin-ingest/testing'
 
 import { classifySlackError, discoverChannels, readCollection, type SlackClientDeps } from '../client.js'
 import { slackConfig } from '../config.js'
 import * as definitions from '../index.js'
-import { slack } from '../pipeline.js'
+import { createSlackPipeline, slack } from '../pipeline.js'
 import { readChannels } from '../sources/channels.js'
 import { readUsers } from '../sources/users.js'
 import { readMessages } from '../sources/messages.js'
+import { messageScope, parseMessageState, slackMessageStrategy, type SlackMessageSelection, type SlackMessageState } from '../state.js'
 import { channel, fixtureDeps, parentMessage, replyMessage, standaloneMessage, user } from './fixtures.js'
 
 const readers: Record<string, (context: FetchContext, deps: SlackClientDeps) => AsyncIterable<SourceChunk>> = {
-  channels: readChannels, users: readUsers, messages: readMessages,
+  channels: readChannels, users: readUsers,
 }
 const originalConfig = { ...slackConfig }
+const fixtureNow = () => new Date('2023-11-15T00:00:00Z')
 
 afterEach(() => { Object.assign(slackConfig, originalConfig) })
 
 describe('Slack raw template', () => {
-  test('exports three raw destinations and full-read streams without credentials', () => {
+  test('exports three raw destinations and checkpointed messages without credentials', () => {
     const exported = Object.values(definitions)
     expect(exported).toContain(slack)
     expect(slack.streams).toHaveLength(3)
     expect(slack.streams.map((stream) => stream.destination.name)).toEqual(['slack_channels_raw', 'slack_users_raw', 'slack_messages_raw'])
     for (const stream of slack.streams) {
       expect(exported).toContain(stream.destination)
-      expect(stream.incremental.id).toBe('chkit.full_sync')
+      expect(stream.incremental.id).toBe(stream.id.endsWith('.messages') ? 'slack.message-ranges' : 'chkit.full_sync')
     }
+    expect(selectStreams([slack], ['provider:slack', 'resource:messages']).map(({ stream }) => stream.id)).toEqual(['slack.primary.messages'])
+  })
+
+  test('a pipeline binds installation identity and reader settings independently of later config edits', async () => {
+    const config = { ...slackConfig, sourceId: 'slack.secondary', channels: ['C1'], conversationTypes: ['public_channel'] as const,
+      includeReplies: false, pageSize: 37, messagePageSize: 12, requestIntervalMs: 7, messageIntervalMs: 11, historyFrom: '1699999999.000000' }
+    const expectedScope = messageScope('T1', config)
+    const requests: URL[] = [], waits: number[] = []
+    const defaults = fixtureDeps()
+    const deps = fixtureDeps((url, init) => { requests.push(url); return defaults.fetch(url.toString(), init) })
+    deps.wait = async (milliseconds) => { waits.push(milliseconds) }
+    const pipeline = createSlackPipeline(config, deps)
+    config.sourceId = 'changed'
+    config.channels.push('missing')
+    config.historyFrom = 'invalid'
+    slackConfig.sourceId = 'unrelated'
+    slackConfig.includeReplies = true
+    slackConfig.historyFrom = 'invalid'
+    const journal = createMemoryJournal(), destination = createMemoryDestination()
+    const result = await runIngestion({ selected: selectStreams([pipeline], []), backfill: undefined }, { now: fixtureNow, journal, destination })
+    expect(result.ok, JSON.stringify(result)).toBe(true)
+    expect(result.streams.map((stream) => stream.streamId)).toEqual(['slack.secondary.channels', 'slack.secondary.users', 'slack.secondary.messages'])
+    expect(parseMessageState((await journal.readCheckpoint('slack.secondary.messages')).envelope?.state).scope).toBe(expectedScope)
+    expect(destination.tables.get('default.slack_messages_raw')?.[0]?.id).toBe(JSON.stringify(['slack.secondary', 'messages', 'T1', 'C1', parentMessage.ts]))
+    expect(destination.tables.get('default.slack_users_raw')?.[0]?.raw).toMatchObject({ source_id: 'slack.secondary' })
+    expect(requests.filter((url) => url.pathname === '/api/conversations.list' || url.pathname === '/api/users.list').every((url) => url.searchParams.get('limit') === '37')).toBe(true)
+    expect(requests.find((url) => url.pathname === '/api/conversations.history')?.searchParams.get('limit')).toBe('12')
+    expect(requests.find((url) => url.pathname === '/api/conversations.history')?.searchParams.get('oldest')).toBe('1699999998.999999')
+    expect(requests.some((url) => url.pathname === '/api/conversations.replies')).toBe(false)
+    expect(waits).toContain(7)
+    expect(waits).toContain(11)
+  })
+
+  test('a failed resource leaves the other resource streams selectable and able to commit', async () => {
+    const defaults = fixtureDeps()
+    const deps = fixtureDeps((url, init) => url.pathname === '/api/users.list'
+      ? Response.json({ ok: false, error: 'missing_scope', needed: 'users:read' }) : defaults.fetch(url.toString(), init))
+    const pipeline = createSlackPipeline(slackConfig, deps)
+    const journal = createMemoryJournal(), destination = createMemoryDestination()
+    const result = await runIngestion({ selected: selectStreams([pipeline], []), backfill: undefined }, { now: fixtureNow, journal, destination })
+    expect(result.ok).toBe(false)
+    expect(result.streams.map((stream) => stream.outcome)).toEqual(['succeeded', 'failed', 'succeeded'])
+    expect(destination.tables.has('default.slack_channels_raw')).toBe(true)
+    expect(destination.tables.has('default.slack_users_raw')).toBe(false)
+    expect(destination.tables.has('default.slack_messages_raw')).toBe(true)
+    expect(parseMessageState((await journal.readCheckpoint('slack.primary.messages')).envelope?.state).active).toBeUndefined()
+    expect((await journal.readCheckpoint('slack.primary.users')).envelope).toBeUndefined()
+    expect(selectStreams([pipeline], ['resource:users']).map(({ stream }) => stream.id)).toEqual(['slack.primary.users'])
+  })
+
+  test('messages run before metadata streams and replay an unfinished page independently', async () => {
+    const calls: string[] = []
+    const defaults = fixtureDeps()
+    const deps = fixtureDeps((url, init) => { calls.push(url.pathname); return defaults.fetch(url.toString(), init) })
+    const pipeline = createSlackPipeline(slackConfig, deps)
+    const limited = { ...pipeline, streams: pipeline.streams.map((stream) => ({ ...stream, budget: { ...stream.budget, maxChunks: 2 } })) }
+    const journal = createMemoryJournal(), destination = createMemoryDestination()
+    const first = await runIngestion({ selected: selectStreams([limited], ['resource:messages']), backfill: undefined }, { now: fixtureNow, journal, destination })
+    expect(first.streams[0]?.outcome).toBe('budget_exhausted')
+    const pending = await journal.readCheckpoint('slack.primary.messages')
+    expect(parseMessageState(pending.envelope?.state).active?.latest).toBe('1700006400.000001')
+    expect(parseMessageState(pending.envelope?.state).active).not.toHaveProperty('threads')
+    expect(destination.tables.has('default.slack_channels_raw')).toBe(false)
+    expect(destination.tables.has('default.slack_users_raw')).toBe(false)
+    expect((await journal.readCheckpoint('slack.primary.channels')).version).toBe(0)
+    expect((await journal.readCheckpoint('slack.primary.users')).version).toBe(0)
+    calls.length = 0
+    expect((await runIngestion({ selected: selectStreams([pipeline], ['resource:users']), backfill: undefined }, { now: fixtureNow, journal, destination })).ok).toBe(true)
+    expect(calls).toEqual(['/api/auth.test', '/api/users.list'])
+    expect(await journal.readCheckpoint('slack.primary.messages')).toEqual(pending)
+    calls.length = 0
+    expect((await runIngestion({ selected: selectStreams([pipeline], ['resource:messages']), backfill: undefined }, { now: fixtureNow, journal, destination })).ok).toBe(true)
+    expect(calls).toEqual(['/api/auth.test', '/api/conversations.history', '/api/conversations.replies'])
+    expect(destination.tables.get('default.slack_messages_raw')?.map((row) => row.raw)).toContainEqual({ source_id: 'slack.primary', team_id: 'T1', channel_id: 'C1', data: replyMessage })
+    expect((await journal.readCheckpoint('slack.primary.channels')).version).toBe(0)
   })
 
   test('every stream preserves provider payloads and reruns publish edits under stable identities', async () => {
@@ -41,7 +118,7 @@ describe('Slack raw template', () => {
     const journal = createMemoryJournal()
     const destination = createMemoryDestination()
     const request = { selected: selectStreams([pipeline], []), backfill: undefined }
-    const first = await runIngestion(request, { journal, destination })
+    const first = await runIngestion(request, { now: fixtureNow, journal, destination })
     expect(first.ok, JSON.stringify(first)).toBe(true)
     expect(first.streams.map((stream) => stream.rows)).toEqual([1, 2, 4])
     expect(destination.tables.size).toBe(3)
@@ -52,7 +129,7 @@ describe('Slack raw template', () => {
     expect(new Set(messages.map((row) => row.id)).size).toBe(3)
     expect(messages.find((row) => JSON.stringify(row.raw).includes('Edited discussion'))).toBeUndefined()
     changed = true
-    const second = await runIngestion(request, { journal, destination })
+    const second = await runIngestion(request, { now: fixtureNow, journal, destination })
     expect(second.ok, JSON.stringify(second)).toBe(true)
     const repeated = destination.tables.get('default.slack_messages_raw') ?? []
     const edited = repeated.find((row) => JSON.stringify(row.raw).includes('Edited discussion'))
@@ -71,10 +148,42 @@ describe('Slack raw template', () => {
       throw new Error(`Unexpected cursor ${cursor}`)
     })
     const pages = await collect(readCollection(context(), { method: 'conversations.list', field: 'channels', idField: 'id', pageSize: 2 }, deps))
-    expect(pages.flat().map((value) => value.id)).toEqual(['C1', 'C2'])
+    expect(pages.flatMap((page) => page.items).map((value) => value.id)).toEqual(['C1', 'C2'])
+    expect(pages.map((page) => page.next)).toEqual(['empty-next', 'final-next', undefined])
+    expect(pages.map((page) => page.items.length)).toEqual([0, 1, 1])
     expect(cursors).toEqual([null, 'empty-next', 'final-next'])
   })
 
+  test('the channels reader yields a page before fetching the next selected conversation page', async () => {
+    let channelCalls = 0
+    const defaults = fixtureDeps()
+    const deps = fixtureDeps((url, init) => {
+      if (url.pathname !== '/api/conversations.list') return defaults.fetch(url.toString(), init)
+      channelCalls += 1
+      return Response.json({ ok: true, channels: [{ ...channel, id: channelCalls === 1 ? 'C1' : 'C2' }],
+        response_metadata: { next_cursor: channelCalls === 1 ? 'next' : '' } })
+    })
+    const iterator = readChannels(context(), deps)
+    const first = await iterator.next()
+    expect(first.done).toBe(false)
+    expect(first.value?.rows[0]?.id).toBe(JSON.stringify(['slack.primary', 'channels', 'T1', 'C1']))
+    expect(channelCalls).toBe(1)
+    const second = await iterator.next()
+    expect(second.done).toBe(false)
+    expect(second.value?.rows[0]?.id).toBe(JSON.stringify(['slack.primary', 'channels', 'T1', 'C2']))
+    expect(channelCalls).toBe(2)
+    expect((await iterator.next()).done).toBe(true)
+  })
+
+  test('channel discovery reports missing configured IDs after yielding accessible pages', async () => {
+    const deps = { ...fixtureDeps(), config: { ...slackConfig, channels: ['C1', 'missing'] } }
+    const iterator = readChannels(context(), deps)
+    const first = await iterator.next()
+    expect(first.done).toBe(false)
+    expect(first.value?.rows).toHaveLength(1)
+    await expect(iterator.next()).rejects.toThrow('Configured Slack channel "missing" was not found')
+  })
+
   test('messages discover channels independently and paginate threads including the parent payload', async () => {
     const requests: URL[] = []
     const defaults = fixtureDeps()
@@ -93,7 +202,9 @@ describe('Slack raw template', () => {
     const chunks = await collect(readMessages(context(), deps))
     expect(chunks.flatMap((chunk) => chunk.rows).map((row) => row.raw)).toContainEqual({ source_id: 'slack.primary', team_id: 'T1', channel_id: 'C1', data: { ...parentMessage, text: 'Latest parent' } })
     expect(chunks.flatMap((chunk) => chunk.rows)).toHaveLength(3)
-    expect(chunks.every((chunk) => !('state' in chunk) && !('id' in chunk))).toBe(true)
+    expect(chunks.filter((chunk) => chunk.rows.length > 0).every((chunk) => chunk.state === undefined)).toBe(true)
+    expect(chunks.filter((chunk) => chunk.rows.length === 0).every((chunk) => chunk.state !== undefined)).toBe(true)
+    expect(chunks.filter((chunk) => chunk.rows.length > 0).every((chunk) => chunk.id === undefined)).toBe(true)
     const messageRequests = requests.filter((url) => ['conversations.history', 'conversations.replies'].some((method) => url.pathname.endsWith(method)))
     expect(messageRequests.map((url) => url.searchParams.get('limit'))).toEqual(['15', '15', '15'])
     expect(messageRequests.at(-1)?.searchParams.get('cursor')).toBe('reply-next')
@@ -116,14 +227,15 @@ describe('Slack raw template', () => {
     expect(first[0]?.id).toBe(JSON.stringify(['slack.primary', 'messages', 'T1', 'C1', standaloneMessage.ts]))
   })
 
-  test('finishes every history page before opening threads and scans each root once', async () => {
+  test('finishes a history page and its replies before moving the timestamp frontier', async () => {
     const requests: string[] = []
     const defaults = fixtureDeps()
     const deps = fixtureDeps((url, init) => {
       if (url.pathname === '/api/conversations.history') {
-        const cursor = url.searchParams.get('cursor')
-        requests.push(`history:${cursor ?? 'first'}`)
-        return Response.json({ ok: true, messages: [parentMessage], response_metadata: { next_cursor: cursor === null ? 'history-final' : '' } })
+        const latest = url.searchParams.get('latest')
+        const resumed = latest === parentMessage.ts
+        requests.push(`history:${resumed ? 'resumed' : 'first'}`)
+        return Response.json({ ok: true, messages: [resumed ? { ...standaloneMessage, ts: '1699999999.000003' } : parentMessage], has_more: !resumed })
       }
       if (url.pathname === '/api/conversations.replies') {
         requests.push('replies')
@@ -133,7 +245,7 @@ describe('Slack raw template', () => {
     })
     const chunks = await collect(readMessages(context(), deps))
     expect(chunks.flatMap((chunk) => chunk.rows)).toHaveLength(4)
-    expect(requests).toEqual(['history:first', 'history:history-final', 'replies'])
+    expect(requests).toEqual(['history:first', 'replies', 'history:resumed'])
   })
 
   test('history-only selection avoids thread API requests', async () => {
@@ -172,6 +284,8 @@ describe('Slack raw template', () => {
     })
     deps.wait = async (milliseconds, signal) => { waits.push(milliseconds); signal.throwIfAborted() }
     const iterator = readMessages(context(controller.signal), deps)
+    const opening = await iterator.next()
+    expect(opening.value?.rows).toHaveLength(0)
     const first = await iterator.next()
     expect(first.value?.rows).toHaveLength(1)
     controller.abort(new Error('fixture cancelled'))
@@ -240,6 +354,21 @@ describe('Slack raw template', () => {
     expect(calls).toBe(2)
   })
 
+  test.each(['users', 'messages'])('%s pagination has one executor retry budget per request', async (resource) => {
+    let calls = 0
+    const defaults = fixtureDeps()
+    const method = resource === 'users' ? 'users.list' : 'conversations.history'
+    const deps = fixtureDeps((url, init) => {
+      if (url.pathname !== `/api/${method}`) return defaults.fetch(url.toString(), init)
+      calls += 1
+      return Response.json({ ok: false, error: 'internal_error' })
+    })
+    const result = await runFixture(deps, [resource])
+    expect(result.ok).toBe(false)
+    expect(result.streams[0]?.outcome).toBe('failed')
+    expect(calls).toBe(2)
+  })
+
   test('HTTP 200 rate-limit errors retain Retry-After and retry under executor authority', async () => {
     let calls = 0
     const defaults = fixtureDeps()
@@ -252,7 +381,7 @@ describe('Slack raw template', () => {
     })
     const journal = createMemoryJournal()
     const pipeline = fixturePipeline(deps, ['users'])
-    const result = await runIngestion({ selected: selectStreams([pipeline], []), backfill: undefined }, { journal, destination: createMemoryDestination() })
+    const result = await runIngestion({ selected: selectStreams([pipeline], []), backfill: undefined }, { now: fixtureNow, journal, destination: createMemoryDestination() })
     expect(result.ok, JSON.stringify(result)).toBe(true)
     expect(calls).toBe(2)
     expect(journal.events.some((event) => event.eventKind === 'retry_scheduled' && event.errorClass === 'rate_limited')).toBe(true)
@@ -269,7 +398,7 @@ describe('Slack raw template', () => {
     const fixture = fixturePipeline(deps, ['messages'])
     const pipeline = definePipeline({ ...fixture, streams: fixture.streams.map((stream) => ({ ...stream, batchSize: 1 })) })
     const destination = createMemoryDestination()
-    const result = await runIngestion({ selected: selectStreams([pipeline], []), backfill: undefined }, { journal: createMemoryJournal(), destination })
+    const result = await runIngestion({ selected: selectStreams([pipeline], []), backfill: undefined }, { now: fixtureNow, journal: createMemoryJournal(), destination })
     expect(result.ok).toBe(false)
     expect(result.streams[0]?.outcome).toBe('failed')
     expect(result.streams[0]?.error).toContain('missing_scope')
@@ -290,7 +419,7 @@ describe('Slack raw template', () => {
     })
     const journal = createMemoryJournal()
     const pipeline = fixturePipeline(deps, ['users'])
-    const result = await runIngestion({ selected: selectStreams([pipeline], []), backfill: undefined }, { journal, destination: createMemoryDestination() })
+    const result = await runIngestion({ selected: selectStreams([pipeline], []), backfill: undefined }, { now: fixtureNow, journal, destination: createMemoryDestination() })
     expect(result.ok, JSON.stringify(result)).toBe(true)
     expect(calls).toBe(2)
     expect(journal.events.some((event) => event.eventKind === 'retry_scheduled' && event.errorClass === 'rate_limited')).toBe(true)
@@ -312,6 +441,7 @@ function fixturePipeline(deps: SlackClientDeps, selectedResources?: readonly str
     ...slack,
     retry: { retries: 1, minTimeout: 0, maxTimeout: 0, randomize: false },
     streams: slack.streams.filter((stream) => selectedResources === undefined || selectedResources.includes(stream.id.split('.').at(-1) ?? '')).map((stream) => {
+      if (stream.id.endsWith('.messages')) return defineStream({ ...stream, incremental: slackMessageStrategy, read: (context) => readMessages(context, deps) })
       const read = readers[stream.id.split('.').at(-1) ?? '']
       if (!read) throw new Error(`No fixture reader for ${stream.id}`)
       return { ...stream, read: (context: FetchContext) => read(context, deps) }
@@ -321,11 +451,12 @@ function fixturePipeline(deps: SlackClientDeps, selectedResources?: readonly str
 
 async function runFixture(deps: SlackClientDeps, selectedResources: readonly string[], destination = createMemoryDestination()) {
   const pipeline = fixturePipeline(deps, selectedResources)
-  return runIngestion({ selected: selectStreams([pipeline], []), backfill: undefined }, { journal: createMemoryJournal(), destination })
+  return runIngestion({ selected: selectStreams([pipeline], []), backfill: undefined }, { now: fixtureNow, journal: createMemoryJournal(), destination })
 }
 
-function context(signal = new AbortController().signal): FetchContext {
-  return { signal, attempt: async (operation) => operation(signal) }
+function context(signal = new AbortController().signal): ReadContext<SlackMessageSelection, SlackMessageState> {
+  return { signal, attempt: async (operation) => operation(signal), streamId: 'slack.primary.messages', state: undefined,
+    cutoff: fixtureNow(), selection: slackMessageStrategy.plan({ cutoff: fixtureNow(), state: undefined, range: undefined }) }
 }
 
 async function collect<T>(items: AsyncIterable<T>): Promise<T[]> {
diff --git a/scripts/check-registry-docs.test.ts b/scripts/check-registry-docs.test.ts
index a6f4983e..a1ecedc6 100644
--- a/scripts/check-registry-docs.test.ts
+++ b/scripts/check-registry-docs.test.ts
@@ -1,11 +1,12 @@
 import { afterEach, expect, test } from 'bun:test'
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs'
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import type { RegistryCatalog } from '../packages/cli/src/registry/model.js'
 import { checkRegistryDocs } from './check-registry-docs.js'
 
 const roots: string[] = []
+const CHANGELOG_REFERENCE = '<RegistryReference name="example" section="changelog" />'
 afterEach(() => {
   for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true })
 })
@@ -32,7 +33,7 @@ test('reports missing canonical metadata and guides for every added app', () =>
 
 test('requires exact resource names in the body, excluding metadata and longer names', () => {
   const fixture = createFixture()
-  writeFileSync(fixture.guide, '---\ntitle: Integrating ClickHouse with Example\ndescription: "Read `records`."\n---\n`object_attributes` and `records_archive` are available.\n')
+  writeFileSync(fixture.guide, `---\ntitle: Integrating ClickHouse with Example\ndescription: "Read \`records\`."\n---\n\`object_attributes\` and \`records_archive\` are available.\n${CHANGELOG_REFERENCE}\n`)
   expect(checkRegistryDocs(fixture.catalog, fixture)).toEqual([
     'integrations/example.mdx: document the registry resource `objects` in the guide body.',
     'integrations/example.mdx: document the registry resource `records` in the guide body.',
@@ -42,9 +43,9 @@ test('requires exact resource names in the body, excluding metadata and longer n
 test('accepts manifest-generated resource coverage only for the matching provider', () => {
   const fixture = createFixture()
   const source = '---\ntitle: Integrating ClickHouse with Example\ndescription: Sync Example records.\n---\n'
-  writeFileSync(fixture.guide, `${source}<RegistryReference name="example" section="resources" />\n`)
+  writeFileSync(fixture.guide, `${source}<RegistryReference name="example" section="resources" />\n${CHANGELOG_REFERENCE}\n`)
   expect(checkRegistryDocs(fixture.catalog, fixture)).toEqual([])
-  writeFileSync(fixture.guide, `${source}<RegistryReference name="different-app" section="resources" />\n`)
+  writeFileSync(fixture.guide, `${source}<RegistryReference name="different-app" section="resources" />\n${CHANGELOG_REFERENCE}\n`)
   expect(checkRegistryDocs(fixture.catalog, fixture)).toEqual([
     'integrations/example.mdx: document the registry resource `objects` in the guide body.',
     'integrations/example.mdx: document the registry resource `records` in the guide body.',
@@ -60,6 +61,7 @@ test('requires usable provider references and credential setup for official apps
       authentication: undefined,
       views: undefined,
       sync: undefined,
+      changelog: undefined,
       resources: app.meta.chkit.resources.map((resource) => ({ ...resource, endpoints: [] })),
     } },
   }))
@@ -67,14 +69,26 @@ test('requires usable provider references and credential setup for official apps
     'example: official apps must declare meta.chkit.authentication for their integration reference.',
     'example: official apps must declare meta.chkit.views for their integration reference.',
     'example: official apps must declare meta.chkit.sync for their integration reference.',
+    'example: official apps must declare meta.chkit.changelog for their integration reference.',
     'example: resource objects needs a title, default table, and API endpoint references.',
     'example: resource records needs a title, default table, and API endpoint references.',
   ])
 })
 
+test('requires changelog references generated from the matching integration metadata', () => {
+  const fixture = createFixture()
+  const source = readFileSync(fixture.guide, 'utf8')
+  for (const replacement of ['### 1.0.0\nAdd the integration.', '<RegistryReference name="different-app" section="changelog" />']) {
+    writeFileSync(fixture.guide, source.replace(CHANGELOG_REFERENCE, replacement))
+    expect(checkRegistryDocs(fixture.catalog, fixture)).toEqual([
+      'integrations/example.mdx: generate the integration changelog with <RegistryReference name="example" section="changelog" />.',
+    ])
+  }
+})
+
 test('reports incorrect SEO metadata and malformed YAML with the guide path', () => {
   const fixture = createFixture()
-  writeFileSync(fixture.guide, '---\ntitle: Example\ndescription: ""\n---\n`objects` and `records`\n')
+  writeFileSync(fixture.guide, `---\ntitle: Example\ndescription: ""\n---\n\`objects\` and \`records\`\n${CHANGELOG_REFERENCE}\n`)
   expect(checkRegistryDocs(fixture.catalog, fixture)).toEqual([
     'integrations/example.mdx: frontmatter title must be "Integrating ClickHouse with Example".',
     'integrations/example.mdx: frontmatter description must be a non-empty string.',
@@ -128,7 +142,7 @@ function createFixture(extension = 'mdx') {
   mkdirSync(join(docsDir, 'integrations'), { recursive: true })
   mkdirSync(join(publicDir, 'logos'), { recursive: true })
   const guide = join(docsDir, `integrations/example.${extension}`)
-  writeFileSync(guide, '---\ntitle: "Integrating ClickHouse with Example"\ndescription: >-\n  Sync Example records into ClickHouse.\n---\nThe `objects` and `records` resources are synced.\n')
+  writeFileSync(guide, `---\ntitle: "Integrating ClickHouse with Example"\ndescription: >-\n  Sync Example records into ClickHouse.\n---\nThe \`objects\` and \`records\` resources are synced.\n\n## Changelog\n\n${CHANGELOG_REFERENCE}\n`)
   writeFileSync(join(publicDir, 'logos/example.svg'), '<svg xmlns="http://www.w3.org/2000/svg"/>')
   const catalog: RegistryCatalog = {
     name: 'chkit',
@@ -143,6 +157,7 @@ function createFixture(extension = 'mdx') {
       meta: { chkit: {
         formatVersion: 1,
         version: '1.0.0',
+        changelog: [{ version: '1.0.0', changes: ['Add the integration.'] }],
         language: 'typescript',
         license: 'MIT',
         chkit: '^0.2.0',
diff --git a/scripts/check-registry-docs.ts b/scripts/check-registry-docs.ts
index 5b88168c..f6f0f2f6 100644
--- a/scripts/check-registry-docs.ts
+++ b/scripts/check-registry-docs.ts
@@ -12,7 +12,7 @@ interface DocsPaths {
 }
 
 // Run with `bun scripts/check-registry-docs.ts`; the docs build runs this automatically.
-// Each official app needs a canonical guide, SEO metadata, documented resources, and local logo assets.
+// Each official app needs a canonical guide, SEO metadata, documented resources, a generated changelog, and local logo assets.
 if (import.meta.main) {
   const repoDir = fileURLToPath(new URL('../', import.meta.url))
   const catalog = await readRegistrySourceCatalog()
@@ -64,7 +64,7 @@ export function checkRegistryDocs(catalog: RegistryCatalog, paths: DocsPaths): s
 function checkReferenceMetadata(item: RegistryItem): string[] {
   const metadata = item.meta.chkit
   const errors: string[] = []
-  for (const field of ['authentication', 'views', 'sync'] as const) {
+  for (const field of ['authentication', 'views', 'sync', 'changelog'] as const) {
     if (metadata[field] === undefined) errors.push(`${item.name}: official apps must declare meta.chkit.${field} for their integration reference.`)
   }
   for (const resource of metadata.resources) {
@@ -107,6 +107,9 @@ function checkGuide(path: string, item: RegistryItem, docsDir: string): string[]
       errors.push(`${label}: document the registry resource \`${resource}\` in the guide body.`)
     }
   }
+  if (!body.includes(`<RegistryReference name="${item.name}" section="changelog" />`)) {
+    errors.push(`${label}: generate the integration changelog with <RegistryReference name="${item.name}" section="changelog" />.`)
+  }
   return errors
 }
 
diff --git a/scripts/registry-catalog.test.ts b/scripts/registry-catalog.test.ts
index d002b16b..37d5a6c0 100644
--- a/scripts/registry-catalog.test.ts
+++ b/scripts/registry-catalog.test.ts
@@ -1,10 +1,14 @@
 import { afterEach, expect, test } from 'bun:test'
-import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import { mkdir, mkdtemp, readFile, rm, symlink, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
-import { join } from 'node:path'
+import { join, resolve } from 'node:path'
 
 import { buildRegistryCatalog } from '../packages/cli/src/registry/build.js'
+import { applyInstallation, planInstallation } from '../packages/cli/src/registry/install.js'
 import type { RegistryItem } from '../packages/cli/src/registry/model.js'
+import { CLI_VERSION } from '../packages/cli/src/runtime/version.js'
+import { formatTestDiagnostic, runCli } from '../packages/cli/src/test/e2e-testkit.js'
+import { spawnWithTimeout } from '../packages/cli/src/test/spawn-cli.js'
 import { buildOfficialRegistry } from './build-registry.js'
 import { readRegistrySourceCatalog } from './registry-catalog.js'
 
@@ -63,6 +67,53 @@ test('builds a first release without history and preserves committed historical
   expect(await readFile(join(outputDir, 'example/0.1.1.json'), 'utf8')).not.toBe(first)
 })
 
+test.serial('modular provider artifacts install runnable readers, discoverable schemas, and portable fixtures at relocated paths', async () => {
+  const workspace = resolve(import.meta.dir, '..')
+  const root = await fixtureRoot(), outputDir = join(root, 'built'), project = join(root, 'consumer')
+  const names = ['circleback', 'github', 'google-calendar', 'google-meet', 'lemlist', 'linear']
+  const source = await readRegistrySourceCatalog()
+  const catalog = { ...source, items: source.items.filter((item) => names.includes(item.name)).map((item) => ({
+    ...item, dependencies: [`@chkit/core@${CLI_VERSION}`, `@chkit/plugin-ingest@${CLI_VERSION}`],
+    meta: { chkit: { ...item.meta.chkit, chkit: CLI_VERSION, ingest: CLI_VERSION } },
+  })) }
+  expect(catalog.items.map((item) => item.name)).toEqual(names)
+  const built = await buildRegistryCatalog({ catalog, sourceRoot: join(workspace, 'registry'), outputDir })
+  await mkdir(project)
+  await symlink(join(workspace, 'node_modules'), join(project, 'node_modules'), 'dir')
+  await writeFile(join(project, 'package.json'), JSON.stringify({ name: 'registry-consumer', private: true, type: 'module' }))
+  await writeFile(join(project, 'tsconfig.json'), JSON.stringify({
+    compilerOptions: { target: 'ES2022', module: 'NodeNext', moduleResolution: 'NodeNext', customConditions: ['source'],
+      lib: ['ES2022'], types: ['bun'], strict: true, skipLibCheck: true, noEmit: true },
+    include: ['src/**/*.ts', 'clickhouse.config.ts'],
+  }))
+  for (const item of built.items) {
+    const plan = await planInstallation({ cwd: project, item, origin: join(outputDir, `${item.name}.json`), cliVersion: CLI_VERSION,
+      path: `src/providers/${item.name}`, withTests: true, noInstall: true, packageManager: 'bun' })
+    await applyInstallation(plan)
+  }
+  const credentials = Object.fromEntries(built.items.flatMap((item) => Object.keys(item.meta.chkit.env).map((name) => [name, ''])))
+  const list = runCli(project, ['ingest', 'list', '--json'], credentials)
+  expect(list.exitCode, formatTestDiagnostic('installed provider discovery without credentials', list)).toBe(0)
+  const streams: Array<{ pipelineId: string; destination: string; tags: string[] }> = JSON.parse(list.stdout).streams
+  for (const item of built.items) {
+    const selected = streams.filter((stream) => stream.tags.includes(`provider:${item.name}`))
+    expect(new Set(selected.map((stream) => stream.pipelineId)).size).toBe(1)
+    for (const resource of item.meta.chkit.resources) {
+      expect(selected.some((stream) => stream.tags.includes(`resource:${resource.name}`))).toBe(true)
+      expect(selected.some((stream) => stream.destination.endsWith(`.${resource.table}`))).toBe(true)
+    }
+  }
+  const generate = runCli(project, ['generate', '--dryrun', '--json'], credentials)
+  expect(generate.exitCode, formatTestDiagnostic('installed raw schema discovery', generate)).toBe(0)
+  const expectedTables = new Set(built.items.flatMap((item) => item.meta.chkit.resources.map((resource) => resource.table)))
+  const operations: Array<{ type: string }> = JSON.parse(generate.stdout).operations
+  expect(operations.filter((operation) => operation.type === 'create_table')).toHaveLength(expectedTables.size)
+  const types = spawnWithTimeout([process.execPath, join(workspace, 'node_modules/typescript/bin/tsc'), '--noEmit'], { cwd: project, env: credentials })
+  expect(types.exitCode, formatTestDiagnostic('installed consumer typecheck', types)).toBe(0)
+  const tests = spawnWithTimeout([process.execPath, 'test', ...built.items.map((item) => `src/providers/${item.name}/tests`), '--timeout', '30000'], { cwd: project, env: credentials })
+  expect(tests.exitCode, formatTestDiagnostic('installed portable fixture suites', tests)).toBe(0)
+}, 120_000)
+
 function fixtureItem(name: string): RegistryItem {
   return {
     name, type: 'registry:item', title: name, description: 'Fixture source.',
diff --git a/scripts/registry-releases.test.ts b/scripts/registry-releases.test.ts
new file mode 100644
index 00000000..b2972bbc
--- /dev/null
+++ b/scripts/registry-releases.test.ts
@@ -0,0 +1,225 @@
+import { afterEach, expect, test } from 'bun:test'
+import { spawnSync } from 'node:child_process'
+import { mkdir, mkdtemp, readFile, rename, rm, symlink, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { buildRegistryCatalog } from '../packages/cli/src/registry/build.js'
+import type { RegistryItem } from '../packages/cli/src/registry/model.js'
+import { readRegistrySourceCatalog } from './registry-catalog.js'
+import { checkRegistryReleases, refreshRegistryReleases } from './registry-releases.js'
+
+const roots: string[] = []
+afterEach(async () => {
+  await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })))
+})
+
+test('refreshes the same PR draft after source edits and keeps published bytes intact', async () => {
+  const repoRoot = await fixture()
+  const published = await readFile(join(repoRoot, 'registry/example/releases/0.1.0.json'), 'utf8')
+  await draft(repoRoot)
+  expect(await refreshRegistryReleases({ repoRoot, base: 'origin/main' })).toEqual(['registry/example/releases/0.2.0.json'])
+  git(repoRoot, ['add', 'registry'])
+  commit(repoRoot, 'First PR draft')
+  expect(await checkRegistryReleases({ repoRoot, base: 'origin/main' })).toEqual(['example'])
+  await writeFile(join(repoRoot, 'registry/example/index.ts'), 'export const pipeline = { changed: true }\n')
+  await expect(checkRegistryReleases({ repoRoot, base: 'origin/main' })).rejects.toThrow('Stale release artifact')
+  await refreshRegistryReleases({ repoRoot, base: 'origin/main', names: ['example'] })
+  expect(await checkRegistryReleases({ repoRoot, base: 'origin/main' })).toEqual(['example'])
+  const artifact = JSON.parse(await readFile(join(repoRoot, 'registry/example/releases/0.2.0.json'), 'utf8'))
+  expect(artifact.files[0].content).toContain('changed: true')
+  expect(artifact.meta.chkit.changelog[0].changes).toEqual(['Add durable sync.'])
+  expect(await readFile(join(repoRoot, 'registry/example/releases/0.1.0.json'), 'utf8')).toBe(published)
+})
+
+test('rejects two unmerged release artifacts for one integration, including untracked files', async () => {
+  const repoRoot = await fixture()
+  await draft(repoRoot)
+  await refreshRegistryReleases({ repoRoot, base: 'origin/main' })
+  await writeFile(join(repoRoot, 'registry/example/releases/0.1.1.json'), '{}\n')
+  await expect(checkRegistryReleases({ repoRoot, base: 'origin/main' })).rejects.toThrow('multiple draft releases')
+  await expect(refreshRegistryReleases({ repoRoot, base: 'origin/main' })).rejects.toThrow('multiple draft releases')
+})
+
+test('rejects modified and deleted published releases before writing a draft', async () => {
+  const repoRoot = await fixture()
+  await draft(repoRoot)
+  const path = join(repoRoot, 'registry/example/releases/0.1.0.json')
+  await writeFile(path, '{}\n')
+  await expect(refreshRegistryReleases({ repoRoot, base: 'origin/main' })).rejects.toThrow('Published release artifact must remain unchanged')
+  await rm(path)
+  await expect(checkRegistryReleases({ repoRoot, base: 'origin/main' })).rejects.toThrow('Published release artifact must remain unchanged')
+  expect(await Bun.file(join(repoRoot, 'registry/example/releases/0.2.0.json')).exists()).toBe(false)
+})
+
+test('rejects a draft symlink to a published artifact without changing its bytes', async () => {
+  const repoRoot = await fixture()
+  await draft(repoRoot)
+  const publishedPath = join(repoRoot, 'registry/example/releases/0.1.0.json')
+  const published = await readFile(publishedPath, 'utf8')
+  await symlink('0.1.0.json', join(repoRoot, 'registry/example/releases/0.2.0.json'))
+  await expect(checkRegistryReleases({ repoRoot, base: 'origin/main' })).rejects.toThrow('Refusing a symlink in registry path')
+  await expect(refreshRegistryReleases({ repoRoot, base: 'origin/main' })).rejects.toThrow('Refusing a symlink in registry path')
+  expect(await readFile(publishedPath, 'utf8')).toBe(published)
+})
+
+test('rejects a published artifact replaced by a symlink with identical content', async () => {
+  const repoRoot = await fixture()
+  const publishedPath = join(repoRoot, 'registry/example/releases/0.1.0.json')
+  const copyPath = join(repoRoot, 'published-copy.json')
+  const published = await readFile(publishedPath, 'utf8')
+  await writeFile(copyPath, published)
+  await rm(publishedPath)
+  await symlink(copyPath, publishedPath)
+  await expect(checkRegistryReleases({ repoRoot, base: 'origin/main' })).rejects.toThrow('Refusing a symlink in registry path')
+  await expect(refreshRegistryReleases({ repoRoot, base: 'origin/main' })).rejects.toThrow('Refusing a symlink in registry path')
+  expect(await readFile(copyPath, 'utf8')).toBe(published)
+})
+
+test('rejects a symlinked releases directory before refreshing its draft', async () => {
+  const repoRoot = await fixture()
+  await draft(repoRoot)
+  const releases = join(repoRoot, 'registry/example/releases')
+  const history = join(repoRoot, 'history')
+  const published = await readFile(join(releases, '0.1.0.json'), 'utf8')
+  await rename(releases, history)
+  await symlink(history, releases)
+  await expect(refreshRegistryReleases({ repoRoot, base: 'origin/main' })).rejects.toThrow('Refusing a symlink in registry path')
+  expect(await readFile(join(history, '0.1.0.json'), 'utf8')).toBe(published)
+  expect(await Bun.file(join(history, '0.2.0.json')).exists()).toBe(false)
+})
+
+test('validates every draft target before creating any selected release artifact', async () => {
+  const repoRoot = await fixture()
+  await draft(repoRoot)
+  const source = join(repoRoot, 'registry/z-dangerous')
+  await mkdir(join(source, 'releases'), { recursive: true })
+  await writeFile(join(source, 'manifest.json'), JSON.stringify(item('0.1.0', [{ version: '0.1.0', changes: ['Initial integration.'] }], 'z-dangerous')))
+  await writeFile(join(source, 'index.ts'), 'export const pipeline = {}\n')
+  const publishedPath = join(repoRoot, 'registry/example/releases/0.1.0.json')
+  const published = await readFile(publishedPath, 'utf8')
+  await symlink(publishedPath, join(source, 'releases/0.1.0.json'))
+  await expect(refreshRegistryReleases({ repoRoot, base: 'origin/main' })).rejects.toThrow('Refusing a symlink in registry path')
+  expect(await Bun.file(join(repoRoot, 'registry/example/releases/0.2.0.json')).exists()).toBe(false)
+  expect(await readFile(publishedPath, 'utf8')).toBe(published)
+})
+
+test('refuses refresh of an already merged version while allowing a no-op refresh', async () => {
+  const repoRoot = await fixture()
+  expect(await checkRegistryReleases({ repoRoot, base: 'origin/main' })).toEqual([])
+  expect(await refreshRegistryReleases({ repoRoot, base: 'origin/main' })).toEqual([])
+  await expect(refreshRegistryReleases({ repoRoot, base: 'origin/main', names: ['example'] })).rejects.toThrow('already published on the base branch')
+  await writeFile(join(repoRoot, 'registry/example/index.ts'), 'export const pipeline = { changed: true }\n')
+  await expect(checkRegistryReleases({ repoRoot, base: 'origin/main' })).rejects.toThrow('Bump the published integration version')
+})
+
+test('preserves published changelog entries and requires release notes for the draft', async () => {
+  const repoRoot = await fixture(true)
+  await draft(repoRoot, [
+    { version: '0.2.0', changes: ['Add durable sync.'] },
+    { version: '0.1.0', changes: ['Initial integration.'] },
+  ])
+  await refreshRegistryReleases({ repoRoot, base: 'origin/main' })
+  await draft(repoRoot, [
+    { version: '0.2.0', changes: ['Add durable sync.'] },
+    { version: '0.1.0', changes: ['Rewrite history.'] },
+  ])
+  await expect(refreshRegistryReleases({ repoRoot, base: 'origin/main' })).rejects.toThrow('Published changelog entry example@0.1.0')
+  await draft(repoRoot, [{ version: '0.2.0', changes: ['Add durable sync.'] }])
+  await expect(checkRegistryReleases({ repoRoot, base: 'origin/main' })).rejects.toThrow('Published changelog entry example@0.1.0')
+  const legacyRoot = await fixture()
+  await writeFile(join(legacyRoot, 'registry/example/manifest.json'), JSON.stringify(item('0.2.0')))
+  await expect(refreshRegistryReleases({ repoRoot: legacyRoot, base: 'origin/main' })).rejects.toThrow('requires its current changelog entry')
+})
+
+test('rejects invented historical entries and draft artifacts that disagree with the manifest', async () => {
+  const repoRoot = await fixture()
+  await draft(repoRoot, [
+    { version: '0.2.0', changes: ['Add durable sync.'] },
+    { version: '0.1.1', changes: ['An abandoned draft.'] },
+  ])
+  await expect(refreshRegistryReleases({ repoRoot, base: 'origin/main' })).rejects.toThrow('does not identify a published base release')
+  await draft(repoRoot)
+  await writeFile(join(repoRoot, 'registry/example/releases/0.1.1.json'), '{}\n')
+  await expect(checkRegistryReleases({ repoRoot, base: 'origin/main' })).rejects.toThrow('must match manifest version 0.2.0')
+})
+
+test('checks missing artifacts, rejects version rollback, and reports an unavailable base', async () => {
+  const repoRoot = await fixture()
+  await draft(repoRoot)
+  await expect(checkRegistryReleases({ repoRoot, base: 'origin/main' })).rejects.toThrow('Missing release artifact')
+  await writeFile(join(repoRoot, 'registry/example/manifest.json'), JSON.stringify(item('0.0.9', [{ version: '0.0.9', changes: ['Rollback.'] }])))
+  await expect(refreshRegistryReleases({ repoRoot, base: 'origin/main' })).rejects.toThrow('must advance beyond published version 0.1.0')
+  await expect(checkRegistryReleases({ repoRoot, base: 'missing-base' })).rejects.toThrow('Git release check failed')
+})
+
+test('supports a new integration and validates named refresh before writing any artifacts', async () => {
+  const repoRoot = await fixture()
+  const source = join(repoRoot, 'registry/new-provider')
+  await mkdir(source)
+  const manifest = item('0.1.0', [{ version: '0.1.0', changes: ['Initial integration.'] }], 'new-provider')
+  await writeFile(join(source, 'manifest.json'), JSON.stringify(manifest))
+  await writeFile(join(source, 'index.ts'), 'export const pipeline = {}\n')
+  await expect(refreshRegistryReleases({ repoRoot, base: 'origin/main', names: ['new-provider', 'unknown'] })).rejects.toThrow('Unknown integration: unknown')
+  expect(await Bun.file(join(source, 'releases/0.1.0.json')).exists()).toBe(false)
+  await refreshRegistryReleases({ repoRoot, base: 'origin/main', names: ['new-provider'] })
+  expect(await checkRegistryReleases({ repoRoot, base: 'origin/main' })).toEqual(['new-provider'])
+})
+
+test('uses the explicitly selected base to decide which releases are still drafts', async () => {
+  const repoRoot = await fixture()
+  await draft(repoRoot)
+  await refreshRegistryReleases({ repoRoot, base: 'origin/main' })
+  git(repoRoot, ['add', 'registry'])
+  commit(repoRoot, 'Merge next release')
+  git(repoRoot, ['update-ref', 'refs/remotes/origin/next', 'HEAD'])
+  expect(await checkRegistryReleases({ repoRoot, base: 'origin/main' })).toEqual(['example'])
+  expect(await checkRegistryReleases({ repoRoot, base: 'origin/next' })).toEqual([])
+  await expect(refreshRegistryReleases({ repoRoot, base: 'origin/next', names: ['example'] })).rejects.toThrow('already published on the base branch')
+})
+
+async function fixture(withChangelog = false): Promise<string> {
+  const repoRoot = await mkdtemp(join(tmpdir(), 'chkit-registry-release-test-'))
+  roots.push(repoRoot)
+  git(repoRoot, ['init', '-b', 'main'])
+  const source = join(repoRoot, 'registry/example')
+  await mkdir(join(source, 'releases'), { recursive: true })
+  const changelog = withChangelog ? [{ version: '0.1.0', changes: ['Initial integration.'] }] : undefined
+  await writeFile(join(source, 'manifest.json'), JSON.stringify(item('0.1.0', changelog)))
+  await writeFile(join(source, 'index.ts'), 'export const pipeline = {}\n')
+  const outputDir = join(repoRoot, 'build')
+  const catalog = await readRegistrySourceCatalog(join(repoRoot, 'registry'))
+  await buildRegistryCatalog({ catalog, sourceRoot: join(repoRoot, 'registry'), outputDir })
+  await writeFile(join(source, 'releases/0.1.0.json'), await readFile(join(outputDir, 'example/0.1.0.json')))
+  git(repoRoot, ['add', 'registry'])
+  commit(repoRoot, 'Base release')
+  git(repoRoot, ['update-ref', 'refs/remotes/origin/main', 'HEAD'])
+  return repoRoot
+}
+
+async function draft(repoRoot: string, changelog = [{ version: '0.2.0', changes: ['Add durable sync.'] }]): Promise<void> {
+  await writeFile(join(repoRoot, 'registry/example/manifest.json'), JSON.stringify(item('0.2.0', changelog)))
+}
+
+function item(version: string, changelog?: Array<{ version: string; changes: string[] }>, name = 'example'): RegistryItem {
+  return {
+    name, type: 'registry:item', title: name, description: 'Fixture source.',
+    dependencies: ['@chkit/core@^0.2.0', '@chkit/plugin-ingest@^0.2.0'],
+    files: [{ path: 'index.ts', type: 'registry:file', target: `src/integrations/${name}/index.ts` }],
+    meta: { chkit: {
+      formatVersion: 1, version, changelog, language: 'typescript', license: 'MIT',
+      chkit: '^0.2.0', ingest: '^0.2.0', clickhouse: '>=25.3.0',
+      root: `src/integrations/${name}`, entry: 'index.ts', exports: ['pipeline'],
+      resources: [{ name: 'records', description: 'Records.', scopes: [], strategy: 'full' }], env: {},
+    } },
+  }
+}
+
+function git(repoRoot: string, args: string[]): void {
+  const result = spawnSync('git', args, { cwd: repoRoot, encoding: 'utf8' })
+  if (result.status !== 0) throw new Error(`Git fixture failed: ${result.stderr || result.error?.message}`)
+}
+
+function commit(repoRoot: string, title: string): void {
+  const message = `${title}\n\nCo-Authored-By: Marc Höffl <marc.hoeffl@gmail.com>\nCo-Authored-By: replicas-connector[bot] <replicas-connector[bot]@users.noreply.github.com>`
+  git(repoRoot, ['-c', 'user.name=Fixture', '-c', 'user.email=fixture@example.test', 'commit', '-m', message])
+}
diff --git a/scripts/registry-releases.ts b/scripts/registry-releases.ts
new file mode 100644
index 00000000..139195fc
--- /dev/null
+++ b/scripts/registry-releases.ts
@@ -0,0 +1,146 @@
+#!/usr/bin/env bun
+import { spawnSync } from 'node:child_process'
+import { mkdir, mkdtemp, readdir, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { buildRegistryCatalog } from '../packages/cli/src/registry/build.js'
+import { assertProjectPath, readOptional } from '../packages/cli/src/registry/files.js'
+import { parseRegistryItem, type RegistryCatalog } from '../packages/cli/src/registry/model.js'
+import { readRegistrySourceCatalog } from './registry-catalog.js'
+
+interface ReleaseOptions { repoRoot?: string; base?: string }
+interface ReleaseContext {
+  repoRoot: string
+  catalog: RegistryCatalog
+  drafts: string[]
+}
+
+if (import.meta.main) {
+  const [command, ...args] = process.argv.slice(2)
+  let base: string | undefined
+  const names: string[] = []
+  for (let index = 0; index < args.length; index++) {
+    const argument = args[index]
+    if (argument === '--') continue
+    if (argument === '--base') {
+      base = args[++index]
+      if (!base || base.startsWith('-')) throw new Error('--base requires a Git ref')
+    } else if (!argument || argument.startsWith('-')) throw new Error(`Unknown option: ${argument}`)
+    else names.push(argument)
+  }
+  if (command === 'refresh') {
+    const files = await refreshRegistryReleases({ base, names })
+    console.log(`Refreshed ${files.length} integration draft release(s).`)
+  } else if (command === 'check' && names.length === 0) {
+    const drafts = await checkRegistryReleases({ base })
+    console.log(`Registry releases checked: ${drafts.length} integration draft release(s), one per integration.`)
+  } else throw new Error('Usage: registry-releases.ts <check|refresh> [--base <ref>] [integration...]')
+}
+
+export async function checkRegistryReleases(input: ReleaseOptions = {}): Promise<string[]> {
+  const context = await readReleaseContext(input)
+  const artifacts = await buildArtifacts(context)
+  for (const [path, content] of artifacts) {
+    await assertProjectPath(context.repoRoot, join(context.repoRoot, path))
+    const committed = await readOptional(join(context.repoRoot, path))
+    if (committed === undefined) throw new Error(`Missing release artifact: ${path}. Run bun run registry:release.`)
+    if (committed !== content) {
+      const name = path.split('/')[1]
+      const advice = name && context.drafts.includes(name)
+        ? 'Refresh the draft with bun run registry:release.'
+        : 'Bump the published integration version and add its changelog entry.'
+      throw new Error(`Stale release artifact: ${path}. ${advice}`)
+    }
+  }
+  return context.drafts
+}
+
+export async function refreshRegistryReleases(input: ReleaseOptions & { names?: string[] } = {}): Promise<string[]> {
+  const context = await readReleaseContext(input)
+  const names = input.names?.length ? [...new Set(input.names)] : context.drafts
+  for (const name of names) {
+    if (!context.catalog.items.some((item) => item.name === name)) throw new Error(`Unknown integration: ${name}`)
+    if (!context.drafts.includes(name)) throw new Error(`Integration ${name} is already published on the base branch. Bump its version before refreshing.`)
+  }
+  const catalog = { ...context.catalog, items: context.catalog.items.filter((item) => names.includes(item.name)) }
+  const artifacts = await buildArtifacts({ ...context, catalog })
+  // Build and validate every selected draft before writing any release artifact.
+  await Promise.all([...artifacts.keys()].map((path) => assertProjectPath(context.repoRoot, join(context.repoRoot, path))))
+  for (const [path, content] of artifacts) {
+    const target = join(context.repoRoot, path)
+    await mkdir(dirname(target), { recursive: true })
+    await writeFile(target, content)
+  }
+  return [...artifacts.keys()]
+}
+
+async function readReleaseContext(input: ReleaseOptions): Promise<ReleaseContext> {
+  const repoRoot = resolve(input.repoRoot ?? fileURLToPath(new URL('../', import.meta.url)))
+  const base = input.base ?? `origin/${process.env.GITHUB_BASE_REF || 'main'}`
+  const commit = git(repoRoot, ['rev-parse', '--verify', '--end-of-options', `${base}^{commit}`]).trim()
+  const baseFiles = new Set(git(repoRoot, ['ls-tree', '-r', '--name-only', '-z', commit, '--', 'registry']).split('\0').filter(Boolean))
+  const historical = [...baseFiles].filter((path) => /^registry\/[^/]+\/releases\/[^/]+\.json$/.test(path))
+  for (const path of historical) {
+    await assertProjectPath(repoRoot, join(repoRoot, path))
+    const existing = await readOptional(join(repoRoot, path))
+    if (existing !== git(repoRoot, ['show', `${commit}:${path}`])) {
+      throw new Error(`Published release artifact must remain unchanged: ${path}`)
+    }
+  }
+  const catalog = await readRegistrySourceCatalog(join(repoRoot, 'registry'))
+  const drafts: string[] = []
+  for (const item of catalog.items) {
+    const meta = item.meta.chkit
+    const prefix = `registry/${item.name}/releases/`
+    const expected = `${prefix}${meta.version}.json`
+    const releases = await readdir(join(repoRoot, prefix)).catch((error: unknown) => {
+      if (error instanceof Error && 'code' in error && error.code === 'ENOENT') return []
+      throw error
+    })
+    const added = releases.filter((file) => file.endsWith('.json') && !baseFiles.has(`${prefix}${file}`))
+    if (added.length > 1) throw new Error(`Integration ${item.name} has multiple draft releases in this PR: ${added.join(', ')}. Keep one release and refresh it as the PR changes.`)
+    if (added.length === 1 && `${prefix}${added[0]}` !== expected) throw new Error(`Draft release for ${item.name} must match manifest version ${meta.version}.`)
+    const manifestPath = `registry/${item.name}/manifest.json`
+    const previous = baseFiles.has(manifestPath)
+      ? parseRegistryItem(JSON.parse(git(repoRoot, ['show', `${commit}:${manifestPath}`])), false).meta.chkit
+      : undefined
+    if (previous && meta.version !== previous.version && Bun.semver.order(meta.version, previous.version) !== 1) {
+      throw new Error(`Integration ${item.name} must advance beyond published version ${previous.version}.`)
+    }
+    for (const entry of previous?.changelog ?? []) {
+      const current = meta.changelog?.find((candidate) => candidate.version === entry.version)
+      if (JSON.stringify(current) !== JSON.stringify(entry)) throw new Error(`Published changelog entry ${item.name}@${entry.version} must remain unchanged.`)
+    }
+    if (!baseFiles.has(expected)) {
+      if (meta.changelog?.[0]?.version !== meta.version) throw new Error(`Draft ${item.name}@${meta.version} requires its current changelog entry.`)
+      for (const entry of meta.changelog.slice(1)) {
+        if (!baseFiles.has(`${prefix}${entry.version}.json`)) throw new Error(`Changelog entry ${item.name}@${entry.version} does not identify a published base release.`)
+      }
+      drafts.push(item.name)
+    }
+  }
+  return { repoRoot, catalog, drafts }
+}
+
+async function buildArtifacts(context: ReleaseContext): Promise<Map<string, string>> {
+  const outputDir = await mkdtemp(join(tmpdir(), 'chkit-registry-drafts-'))
+  try {
+    const { items } = await buildRegistryCatalog({ catalog: context.catalog, sourceRoot: join(context.repoRoot, 'registry'), outputDir })
+    const artifacts = await Promise.all(items.map(async (item) => {
+      const filename = `${item.meta.chkit.version}.json`
+      const content = await readOptional(join(outputDir, item.name, filename))
+      if (content === undefined) throw new Error(`Builder did not produce ${item.name}@${item.meta.chkit.version}`)
+      return [`registry/${item.name}/releases/${filename}`, content] as const
+    }))
+    return new Map(artifacts)
+  } finally {
+    await rm(outputDir, { recursive: true, force: true })
+  }
+}
+
+function git(repoRoot: string, args: string[]): string {
+  const result = spawnSync('git', args, { cwd: repoRoot, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 })
+  if (result.status !== 0) throw new Error(`Git release check failed: ${result.stderr || result.error?.message || args.join(' ')}`)
+  return result.stdout
+}
diff --git a/skills/chkit-ingestion/SKILL.md b/skills/chkit-ingestion/SKILL.md
index 945abe70..adcc8a3d 100644
--- a/skills/chkit-ingestion/SKILL.md
+++ b/skills/chkit-ingestion/SKILL.md
@@ -1,19 +1,35 @@
 ---
 name: chkit-ingestion
-description: Author or adapt API ingestion sources with @chkit/plugin-ingest. Use for chkit streams, readers, pagination, incremental checkpoints, destinations, and loader choices; excludes generated insert helpers from plugin-codegen.
+description: Author or improve API ingestion sources and registry integrations with @chkit/plugin-ingest. Use for provider-specific sync, pagination, durable checkpoints, recovery, raw destinations, and loader choices; excludes generated insert helpers from plugin-codegen.
 ---
 
 # chkit ingestion authoring
 
-Implement a source reader with finite runs. Inspect the installed plugin version, config, and existing streams; preserve the user's choices.
+Implement a recoverable source reader with finite runs. Inspect the installed plugin version, config, and existing streams; preserve the user's choices.
 
 ## Decide before coding
 
 Establish auth, response shape, pagination, record IDs, change filters/cursors, deletes, volume, and freshness needs from code and provider docs. Ask for missing facts that affect implementation. Verify provider capabilities.
 
-Treat stored shape and mapping together: prefer raw objects plus a SQL view when the shape may evolve and storage is affordable; map inside `read` for a known schema. Model warehouse entities separately; embed bounded child collections when consumers need complete documents. A unified document table is a specialized retrieval model.
+Recommend normalized raw ingestion by default: sync provider resources as directly as possible into independent streams and raw destinations, with source and parent identifiers for relationships. Normalize resource boundaries while preserving each provider object's fields and structure. Perform field transformations, business mappings, joins, enrichment, and denormalization afterward in ClickHouse SQL views, materialized views, or derived tables. Keep readers focused on source retrieval, pagination, checkpointing, and the minimal identity/envelope mapping needed to store raw observations. Use a shaped ingestion schema or projected/embedded document model when the user explicitly requests it; retain inseparable bounded objects as the provider returns them.
 
-Start with the default loader and a full sync for small datasets; add provider-supported incremental reads when needed. Explain consequential choices at their implementation step, introducing tuning and custom interfaces only as required.
+Choose the strongest appropriate sync mechanism the provider actually supports: a change feed or sync token, reliable modification windows, or full reads with safe replay. A simple full read is appropriate when the API lacks reliable change selection and its cost is acceptable, as well as for small catalogs or explicitly requested prototypes. Use the default loader unless another publication contract is needed. Explain consequential choices and coverage limits.
+
+Use one pipeline per account or installation, with independently selectable streams per resource type or configured collection. People and Companies need independent streams; individual people remain records within their collection. Prefer a raw destination per resource type; share one when resource types have the same provider representation and retain an explicit resource discriminator. A pipeline shares execution defaults; its stream order does not provide discovery dependencies. Parent-scoped endpoints may require parent enumeration inside the child reader, but each child stream performs its own discovery and owns its checkpoints. Parent publication does not wait for child streams.
+
+Prefer existing `paginate()` and incremental strategies. Add custom state only when a provider's recovery contract needs progress beyond the executor's journal; ordinary `fullSync()` already records successful work, including empty reads. Keep editable configuration, authenticated request handling, and meaningful resource readers distinct without creating one-line proxy modules or a generic scan framework. Bind factory configuration to both readers and strategies, keep setup-time raw table definitions explicit, and test that configured streams can run independently. Put repeated generic mechanics in the library when the existing API cannot express them concisely.
+
+Prefer coarse page or parent checkpoints when replay cost is acceptable. Read a unit and its required children with ordinary pagination, then publish its completion state after its rows; interruption replays the unfinished unit. Add finer child positions only when needed to make progress within execution budgets. Choose revisit windows from the user's volume and freshness requirements; an explicit recent-only policy does not require retained-object queues or historical reconciliation.
+
+`paginate()` yields full `{ items, next, metadata? }` pages, including empty terminal pages. Use `page.items` for rows and carry provider checkpoint candidates in metadata, then explicitly yield them as chunk `state` with `cursorState`. `next` is the request continuation; metadata is not automatically durable progress. Keep checkpoint snapshots fresh and complete, and let `paginate` own the request attempt rather than nesting `context.attempt` inside it. See the stable-sync reference for sync-token boundaries.
+
+## Registry quality bar
+
+Before creating or materially changing an official registry integration, read [Stable sync design and verification](references/stable-sync.md). Registry providers are reusable implementations of supported capabilities: deliver documented bootstrap and freshness coverage, incremental selection where available, and durable recovery. Reconcile changes beyond the recent window when required by the chosen coverage policy. Do not stop at a happy-path pagination example.
+
+For each resource, establish its provider contract and choose a safe completion boundary before coding. Keep provider payloads raw; application-specific projections are optional and separate. Compare existing registry providers and established implementations such as Brain when accessible, then verify the API contract rather than copying their assumptions. Private repository access is not a dependency of the installed skill.
+
+The release gate is evidence that interruptions resume or safely replay, progress follows destination acknowledgement, empty reads commit completion, and late-change coverage matches the documented policy. Full scans are valid when justified by the API; completion checkpoints do not make them change feeds. Reliable full-sync replay does not require a provider-owned scan state machine. Match manifest strategy labels to actual behavior, document limitations and identity/state migrations, and add portable failure/restart fixtures.
 
 ## Read only the relevant docs
 
@@ -32,15 +48,18 @@ Use local `apps/docs/src/content/docs/api-sync/` or these URLs. Match the instal
 - TypeScript and direct ClickHouse config are required. Preserve existing schema discovery: add the provider entry to `schema` paths, or re-export its schema and active pipelines from the project `entry`. Migrations create destinations.
 - Stream IDs own checkpoints: keep them stable and account-scoped. Pipelines group streams without dependency ordering.
 - Use `context.attempt`/`paginate`, forward cancellation, and throw `HttpError.fromResponse` for HTTP failures. Yield bounded chunks.
-- Enforce both time bounds. Persist only provider-guaranteed, complete resume state after all preceding rows are represented; the executor commits it after writes.
-- Size `overlapMs` to the latest arrival: minutes for indexing delay, days when records or children appear long after their timestamp (recordings, transcripts). Newest-first pages have no safe intermediate `state`; resume only from a completed window.
+- Support historical bounds or state explicitly that a full-sync reader ignores them and does not provide date-range backfills. When supported, enforce both bounds and freeze unfinished selections across restarts. Persist complete validated resume state; the executor commits it after writes.
+- Separate the completed watermark from unfinished traversal state. Newest-first pages cannot alone advance a completed timestamp watermark; documented fixed-window timestamp frontiers or scoped page positions can still resume unfinished reads. Preserve timestamp precision and equal-timestamp coverage.
+- Choose overlap from indexing/arrival behavior, volume, and requested freshness. Use reliable child update filters independently of parent update times. For child changes without parent updates, reread parents within the chosen lookback; document that changes on older parents are excluded. Use broader rereads, retained parents, or reconciliation only when broader coverage is required.
 - Custom tables need `ingestionColumns`. Prefer `simpleLoader`; custom loaders must preserve write identity and acknowledge publication before returning receipts.
-- Delivery is at-least-once: choose reconciliation keys/versioning. Declare chunk `id` only for stable logical intervals; avoid volatile mapped fields.
-- Prefer tombstones for logical deletion. Fetch deletion signals explicitly; full sync does not reconcile missing IDs. Never infer deletions from partial scans. Complete required child reads before yielding a root.
+- Delivery is at-least-once: choose reconciliation keys/versioning. Leave explicit chunk `id` unset for mutable observations. A stable page, cursor, or window label is insufficient: explicit data-bearing IDs require replay-immutable content. State-only markers can flush progress.
+- Fetch deletion signals explicitly and retain raw cancellation/tombstone payloads. Full sync does not reconcile missing IDs; never infer deletions from partial or inaccessible scans. Each raw resource stream completes independently. If an embedded document model is explicitly required, finish its required children before publishing it as complete, or retain durable pending work with explicit completion semantics.
 - Use an external scheduler and run one process per project/target, including backfills.
 
 ## Deliver and verify
 
 For integrations published in the official app registry, include the provider's official logo for the documentation listing. Store the asset in `apps/docs/public/logos/<provider>.svg` (or another supported image format), record its official source in `apps/docs/public/logos/README.md`, and set `meta.chkit.logo` to `https://chkit.obsessiondb.com/logos/<provider>.svg`. Use the provider's artwork without redrawing or altering it. The docs build requires the logo URL and a matching local asset. Read `apps/docs/src/content/docs/api-sync/registry-authoring.md` for registry metadata, integration guides, and immutable release publication.
 
-Deliver definitions, config, and run/query commands. Inspect exports with `chkit ingest list`; generate and review migrations, then use `chkit check` against the configured development target after applying them. `check` has no `--offline` flag. Test empty input, pagination, checkpoint boundaries, and failure replay with fixtures. Keep live writes within authorization. Report verified behavior and limitations.
+Keep one draft version artifact per integration per unmerged PR. Releases already present in the merged base are immutable; committed PR drafts remain editable. Consolidate later edits into the draft's current `meta.chkit.changelog` entry and regenerate that same version with `bun run registry:release -- --base origin/main <provider>`; validate with `bun run check:registry-releases -- --base origin/main`. Use the actual PR base if different. A version bump follows a previously merged release, not each coding iteration.
+
+Deliver definitions, config, and run/query commands. Inspect exports with `chkit ingest list`; generate and review migrations, then use `chkit check` against the configured development target after applying them. `check` has no `--offline` flag. Test checkpoint behavior through `runIngestion` and memory adapters, not just reader iteration; use the applicable recovery cases in the stable-sync reference for registry sources. Keep live writes within authorization. Report verified behavior and limitations.
diff --git a/skills/chkit-ingestion/references/stable-sync.md b/skills/chkit-ingestion/references/stable-sync.md
new file mode 100644
index 00000000..f29b032c
--- /dev/null
+++ b/skills/chkit-ingestion/references/stable-sync.md
@@ -0,0 +1,85 @@
+# Stable registry syncs
+
+Apply this contract when authoring or improving registry providers. Select mechanisms from official provider documentation and observed response shapes; do not invent change filters or durable cursors. Preserve explicit user constraints. A provider limitation calls for safe replay and an honest coverage statement.
+
+## Establish the source contract
+
+For each resource, record the account/query scope, stable record identity, bootstrap coverage, filter timestamp meaning, ordering, boundary inclusivity, pagination guarantees, cursor lifetime, and retention. Check whether edits, deletions, and child-only changes update the selected timestamp. Determine whether pages are snapshots, live mutable lists, or a change feed. Verify filter/token incompatibilities and provider caps on child collections.
+
+Choose the strongest appropriate mechanism, independently for each resource:
+
+| Provider contract | Selection and durable progress |
+| --- | --- |
+| Change feed or sync token | Bootstrap completely, retain the input token throughout pagination, and promote a terminal replacement token only after all corresponding writes |
+| Reliable modification filter | Fixed upper cutoff and overlapping lower bound; checkpoint a fully consumed window or independently complete bounded interval |
+| Creation-time filter | Use for proven immutable events or parent discovery; distinguish discovery progress from freshness and choose an explicit revisit window for delayed children or later edits |
+| Full mutable listing | Use `fullSync()` with ordinary pagination and journaled execution completion; replay an interrupted stream from the beginning when offsets are mutable. Add finer progress only when the collection's cost and provider contract justify it |
+
+A full read is appropriate when the API lacks a reliable change mechanism and its complete cost is acceptable. For a registry resource, explain that choice. The executor records successful work, including empty `fullSync()` executions; do not add cycle counters or state-only markers merely to duplicate that completion. A creation timestamp is not a modification cursor; a pagination cursor is not automatically a change token. Runtime `cursorState()` can implement a full scan, so the helper alone does not determine the manifest's strategy label.
+
+Choose meaningful stream boundaries before designing custom recovery. Use one pipeline per account or installation, with one independently selectable stream per resource type or configured collection. Attio demonstrates independent People/Companies readers sharing a raw records table and using ordinary full-sync pagination. Individual entities stay inside their resource stream; do not make a stream per person, meeting, message, or task. GitHub separates issues, PRs, comments, reviews, commits, and stargazers for each repository, while Slack channels are traversal scope inside its messages stream. Pipelines share execution defaults, not durable progress or discovery order. Each resource resolves its own configured parents, so a failure or selection in another resource cannot block discovery or parent publication.
+
+Prefer existing pagination and checkpoint primitives. Separate editable configuration, authenticated requests, pipeline composition, and meaningful resource readers when those responsibilities warrant modules; avoid empty proxy files. Pipeline factories must bind the supplied account/filter configuration to readers and strategies consistently. Exported raw tables are setup-time schema definitions: document that changing runtime reader settings does not redefine storage. Extract genuinely repeated mechanics into the library rather than copying a generic state machine into each provider. Native sync tokens, fixed-window frontiers, delayed-child queues, and acknowledged parent traversal can still require provider-owned state; removing generic boilerplate must preserve those invariants.
+
+Prefer the coarsest useful checkpoint when repeating API work is affordable. A child stream can read all children of one parent discovery page, yield their rows without advancing discovery, then emit a state-only completion boundary carrying the next parent-page cursor. The executor flushes previous rows before committing that boundary. A failed or interrupted unit replays from its saved input; it needs no per-child queue, cached child page, or child index. Keep the original selection and scope in saved state. Use small discovery pages and enough budget to finish a unit, including the boundary marker; finer positions are justified when a single unit otherwise restarts forever. Mutable source pages still need an honest replay/coverage contract.
+
+Use `paginate<TItem, TCursor, TMetadata>` for page transport: its result retains `items`, `next`, and optional metadata, including empty pages. The reader maps `page.items` to rows and safe metadata to a chunk's `state`; `cursorState` and the executor already own persistence after acknowledgement. A sync-token adapter retains the input sync token alongside nonterminal page progress, then supplies a terminal replacement token with no next-page continuation. Yield that terminal checkpoint even when its items are empty. Repeated continuations are rejected before their page is exposed. Do not create singleton-item wrappers or manual loops merely to preserve page metadata; protocol resets and parent discovery can still need provider logic.
+
+Calendar represents a validated token reset as an empty page with a fresh compound continuation and checkpointed recovery debt, keeping it inside one paginator. Slack uses `next` only to cross empty or parent-only message pages, while native `has_more` metadata guides the reader's next durable timestamp interval. Keep generic continuation checks in `paginate`; retain provider-specific validation and state needed for recovery or unfinished child work.
+
+In a chkit checkout, inspect relevant `registry/<provider>/` implementations and tests. Calendar demonstrates terminal sync-token promotion; Slack exact history timestamps with replies completed before a page checkpoint; Meet recent conference rediscovery and coarse parent-page replay; Circleback independent full reads and complete meeting-transcript snapshots; GitHub independent raw parent/child resources with child-owned windows; Linear independent resource windows and full-history discovery; Lemlist completed activity intervals alongside complete full reads. Apply their recovery invariants to the normalized raw resource model, with dates, budgets, and account scope chosen for the new provider. Consult Brain's provider implementations when available while keeping its application projections out of raw registry schemas.
+
+## Keep progress recoverable
+
+- Bind stream IDs and saved state to stable non-secret source, account, and query identities. Check authenticated identity when the provider exposes it; otherwise require new stream/destination identities when switching accounts. Credentials themselves must not become checkpoint scope. Validate saved types, bounds, parent positions, and scope before reuse. Version custom strategies and document migrations.
+- Separate completed coverage from unfinished work. Persist fixed window bounds and enough scoped position to resume or replay the unfinished unit; fine-grained child positions are optional. Recomputing a cutoff must not move an unfinished selection. Preserve exact provider timestamp precision and handle equal timestamps without skipping records.
+- When custom progress is necessary, yield fresh, complete candidate state. The executor owns its durable commit after destination evidence. Never advance a watermark past rows or required work that is neither loaded nor durably retained. Empty terminal pages must also commit required token/watermark progress; use state-only markers or batching that flushes those safe boundaries. Ordinary empty full-sync success needs no custom marker.
+- Persist offsets or opaque page tokens only under a documented resumption contract. Expiring page tokens can be saved while valid if state also retains the original input and a safe recovery path. For mutable offset lists, restart the interrupted stream's collection at zero. If justified custom state tracks multiple work units within a stream, skip acknowledged units only within the saved selection and restart its unfinished mutable unit. Frozen selection means unchanged predicates, not a frozen source dataset; retain discovered parent IDs only when their replay cost or source contract requires it. Coverage still depends on provider ordering, snapshots, or eventual stability and the chosen revisit policy. A completed cycle resets any such progress and selects current work again.
+- On an expired token, replay the same scoped collection from its committed input or rebuild a baseline as the provider requires. Bound protocol resets across the unfinished selection, not just one process: retain reset debt or detect repeated recovery without useful durable progress. Repeated rejection/stalled recovery fails visibly. Keep existing raw observations during baseline recovery. Absence from a rebuilt baseline is not automatically deletion.
+- Treat explicit backfills as separate checkpoint namespaces. Honor both bounds for historical selection. Reject unsupported bounds when the reader can enforce that contract, or document that a simple full-sync reader ignores bounds and provides no date-range backfill. Retain the original unfinished bounds for supported backfills, reject incompatible reuse of a backfill ID, and prevent interval watermarks from regressing. A bundled helper ignoring `range` does not establish historical-range coverage.
+
+## Preserve raw data and delayed children
+
+Recommend normalized raw sync by default: one raw stream and destination per meaningful resource type, synced as directly as possible from the provider. Preserve complete provider objects, including sparse cancellation payloads, with stable source/parent/provider keys. Normalization separates resource collections; it does not require flattening or renaming the provider's fields. Readers handle retrieval and recovery with minimal identity/envelope mapping. Perform field transformations, business mappings, enrichment, joins, and denormalization afterward in ClickHouse SQL views, materialized views, or derived tables; use an ingestion projection only when explicitly requested.
+
+Each child reader resolves parents from configured identity or its own discovery, then pages raw child rows. Stream order is not a dependency contract and child completion does not gate raw parent publication.
+
+Validate complete resource coverage rather than accepting endpoint defaults. A capped list with no continuation may require the provider's complete export endpoint; a default incomplete-only or current-user filter requires verified status/ownership partitions. Retrieve complete same-resource detail when a list deliberately omits fields, without assembling unrelated resource records. Reads must remain read-only: explicitly disable retrieval side effects such as an inbox endpoint's default mark-as-read behavior. Preserve native nested fields and links; binary downloads and extra metadata resources require their own scope decision.
+
+Use a child's reliable update filter for its own incremental window. A parent timestamp does not imply child freshness unless the provider guarantees that child changes advance it. When broader coverage is needed, revisit all eligible parents with ordinary pagination/fullSync, or retain delayed-artifact work. When the user chooses bounded recent coverage, rediscover parents in that lookback and clearly exclude later changes on older parents. Choose overlap and any reconciliation cadence from provider retention, delay, volume, and freshness requirements; do not add historical reconciliation or retained queues solely to maximize theoretical coverage.
+
+Embed children only for an explicit document model or an inseparable bounded provider object. In that model, a child failure must not publish an incomplete document as complete: finish required children or retain durable pending work and explicit completion semantics. Delayed recordings/transcripts may use repeated parent discovery within an explicit lookback instead of a retained-parent catalog.
+
+Bound pending queues and in-memory work; fail visibly rather than silently dropping entries. Pending work that expires before collection is a coverage gap. Distinguish unavailable, forbidden, not-found, and still-processing outcomes using provider evidence. Diagnostics are not a retry queue unless the reader actually executes them.
+
+Mutable row chunks should normally omit explicit chunk IDs so changed observations remain eligible for publication. Stable page numbers, offsets, cursor strings, and interval labels can suppress changed replay content. Explicit data-bearing IDs require immutable, repeatable content; state-only progress markers may use logical boundary IDs. Stable row IDs handle repeated observations, separately from batch deduplication.
+
+Raw destinations retain latest observed records unless a stronger current-state protocol exists. Consume explicit deletion signals when supported. Do not infer deletion from partial, failed, inaccessible, or expired scans. Removing unseen records requires a separately designed completed-generation reconciliation.
+
+When recording retrieval availability, keep its observation separate from successful resource content. A later permission failure or not-found response must not replace previously collected content with null; an actual successful empty response can replace the same resource snapshot. Distinguish operational availability keys from native resource identities in schemas and documentation.
+
+## Bound execution and prove recovery
+
+Use executor request/retry/cancellation authority with finite request timeouts. Validate repeated or malformed continuations and absent required terminal tokens. Classify provider-specific rate limits, permanent permission failures, and recoverable protocol resets correctly. Bound chunk sizes and expensive runs; ensure a run budget can reach a useful checkpoint, or partition the selection rather than perpetually replaying an oversized bootstrap.
+
+Use portable fixtures through `runIngestion` with memory journal/destination adapters. Exercise the applicable contracts:
+
+- Interrupt or exhaust a budget mid-window, page, parent, or child; deserialize saved state in a fresh run and verify complete eventual coverage under the original bounds.
+- Accept destination rows, then lose the load acknowledgement or fail journal publication; verify replay without skipped rows or an advanced completed frontier. Reader-only tests cannot prove this ordering.
+- Commit empty input and empty terminal progress; continue across empty pages that still have a cursor; reject repeated/malformed pagination and malformed or scope-mismatched saved state.
+- Expire provider tokens, retain the correct input token across pages, and promote terminal tokens only after writes. Verify bounded recovery instead of an endless reset.
+- Cover timestamp ties, exact precision, inclusive/exclusive bounds, overlapping runs, late changes within the declared coverage window, parent discovery changes, and explicit backfill isolation where supported. Broader old-edit coverage is required only when the implementation claims it.
+- Replay mutable observations with changed content and unchanged provider IDs. Test child failure/availability/retention behavior instead of silently truncating a document or queue.
+- Bind non-default source/filter/page settings through the pipeline factory and verify requests, row identity, and saved scope agree. Select one resource independently and fail a different resource without losing its acknowledged progress. For modular templates, install at a relocated consumer path and verify credential-free discovery, raw schema generation, typechecking, and portable fixture execution.
+
+Mark distributed fixture files with `role: "test"`, include their dependencies, and keep them free of repository-only imports and live credentials. For new packaging or destination changes, verify installed consumers and real ClickHouse JSON/replay behavior in an authorized isolated target; memory adapters do not establish merge or deduplication-window behavior.
+
+Before delivery, align manifest labels, README, and integration guide with implemented coverage, bootstrap, normal sync, resumption, reconciliation, deletion semantics, account changes, backfill support, and tuning. Document row/state identity changes and report the evidence and remaining API limits.
+
+## Keep one release draft per integration
+
+Treat release artifacts already present in the PR's merged base as immutable history. A new artifact on an unmerged PR branch is a draft, even after it is committed or pushed. Each integration has at most one new version artifact in that PR; update the same draft throughout implementation instead of retaining intermediate versions. Choose a new version relative to the latest merged release, then keep it until the PR merges.
+
+Maintain cumulative `meta.chkit.changelog` entries with semantic `version` and `changes` arrays, newest first. The first entry matches the current template version. Consolidate the final user-visible changes and identity migrations in that one entry, and preserve earlier released notes. Do not describe temporary PR revisions as published releases or require migrations from them.
+
+In the chkit checkout, regenerate the selected draft with `bun run registry:release -- --base origin/main <provider>` and run `bun run check:registry-releases -- --base origin/main`. Use the actual PR base if different. The release command rewrites only current drafts absent from that base; the guard verifies one added artifact per integration, unchanged published history, and source/artifact agreement. After merging, further source or metadata changes belong to a new version and changelog entry in a later PR.