@namzu/sdk 48.3.1 → 50.0.0

package/src/pals/activity/subscription-policy.ts

@@ -0,0 +1,230 @@
+import { chmodSync, lstatSync, mkdirSync, readdirSync, realpathSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+import { isDeepStrictEqual } from 'node:util'
+import { z } from 'zod'
+import { DiskRevisionRecordStore } from '../../store/kv/revision-record-store.js'
+import { defineSchema } from '../../store/schema.js'
+import {
+	observationRouteKeySchema,
+	observationSourceSchema,
+} from '../communication/ingress-schema.js'
+import type { PalIngressAuthorizationRequest } from '../communication/ingress-types.js'
+import { addressSchema, freezeCommunicationValue } from '../communication/schema.js'
+import type { PalMessageAuthorization } from '../communication/types.js'
+import { subscriptionSchema } from './subscription-schema.js'
+import type {
+	PalActivitySubscriptionAuthorizationRequest,
+	PalActivitySubscriptionStore,
+} from './subscription-types.js'
+
+export interface PalActivitySubscriptionPermission {
+	readonly v: 1
+	readonly subscriptionId: string
+	readonly revision: number
+	readonly observe: boolean
+	readonly disclose: boolean
+	readonly receive: boolean
+	readonly wake: boolean
+}
+export interface PalActivitySubscriptionPermissionUpdate
+	extends Omit<PalActivitySubscriptionPermission, 'v' | 'revision'> {
+	readonly expectedRevision: number
+}
+export class PalActivitySubscriptionPermissionConflictError extends Error {
+	override readonly name = 'PalActivitySubscriptionPermissionConflictError'
+}
+const permissionSchema = z
+	.object({
+		v: z.literal(1),
+		subscriptionId: z.string().uuid(),
+		revision: z.number().int().positive().safe(),
+		observe: z.boolean(),
+		disclose: z.boolean(),
+		receive: z.boolean(),
+		wake: z.boolean(),
+	})
+	.strict()
+const updateSchema = permissionSchema
+	.omit({ v: true, revision: true })
+	.extend({ expectedRevision: z.number().int().nonnegative().safe() })
+const denied = (): PalMessageAuthorization => ({
+	allow: false,
+	reason: 'No current permission for this exact Pal activity subscription.',
+})
+
+/** Explicit local operator consent. Missing rules deny and each phase rereads current records. */
+export class DiskPalActivitySubscriptionPolicy {
+	private readonly root: string
+	private readonly secure: (path: string) => void
+	private readonly subscriptions: PalActivitySubscriptionStore
+	private readonly records = new DiskRevisionRecordStore<PalActivitySubscriptionPermission>(
+		defineSchema({
+			kind: 'pal-activity-subscription-permission',
+			current: 1,
+			migrations: {},
+		}),
+		'Pal activity subscription permission',
+		(value) => value.revision,
+	)
+	constructor(options: {
+		root: string
+		subscriptions: PalActivitySubscriptionStore
+		secureDirectory?: (path: string) => void
+	}) {
+		this.root = resolve(options.root)
+		this.subscriptions = options.subscriptions
+		this.secure =
+			options.secureDirectory ??
+			((path) => {
+				if (process.platform !== 'win32') chmodSync(path, 0o700)
+			})
+		this.directory(this.root)
+	}
+	private directory(path: string) {
+		mkdirSync(path, { recursive: true, mode: 0o700 })
+		const stat = lstatSync(path)
+		if (!stat.isDirectory() || stat.isSymbolicLink() || realpathSync(path) !== path)
+			throw new Error('Pal activity permissions require real directories without aliases.')
+		this.secure(path)
+	}
+	private location(id: string) {
+		const key = z.string().uuid().parse(id)
+		this.directory(this.root)
+		const directory = join(this.root, key)
+		this.directory(directory)
+		const revisionsDir = join(directory, 'revisions')
+		this.directory(revisionsDir)
+		for (const name of readdirSync(revisionsDir)) {
+			if (!/^[1-9][0-9]*\.json$/u.test(name)) continue
+			const stat = lstatSync(join(revisionsDir, name))
+			if (!stat.isFile() || stat.isSymbolicLink())
+				throw new Error('Pal permission commits must be real files.')
+		}
+		return {
+			legacyPath: join(directory, 'permission.json'),
+			revisionsDir,
+			publishLegacyProjection: false,
+		}
+	}
+	private checked(input: unknown, id: string) {
+		const { schemaVersion: _schemaVersion, ...value } = permissionSchema
+			.extend({ schemaVersion: z.literal(1).optional() })
+			.parse(input)
+		if (value.subscriptionId !== id) throw new Error('Foreign Pal subscription permission.')
+		return freezeCommunicationValue(value)
+	}
+	async get(id: string): Promise<PalActivitySubscriptionPermission | null> {
+		const record = await this.records.read(this.location(id))
+		return record === null ? null : this.checked(record, id)
+	}
+	async update(
+		input: PalActivitySubscriptionPermissionUpdate,
+	): Promise<PalActivitySubscriptionPermission> {
+		const captured = updateSchema.parse(input)
+		if (!(await this.subscriptions.get(captured.subscriptionId)))
+			throw new Error('Unknown Pal activity subscription.')
+		return this.records.transact(this.location(captured.subscriptionId), (stored) => {
+			const current = stored === null ? null : this.checked(stored, captured.subscriptionId)
+			if ((current?.revision ?? 0) !== captured.expectedRevision)
+				throw new PalActivitySubscriptionPermissionConflictError(
+					'Subscription permission changed; reload before updating.',
+				)
+			const { expectedRevision, ...values } = captured
+			const record = this.checked(
+				{ ...values, v: 1, revision: expectedRevision + 1 },
+				values.subscriptionId,
+			)
+			return { record, result: record }
+		})
+	}
+	async authorizeSubscription(
+		request: PalActivitySubscriptionAuthorizationRequest,
+	): Promise<PalMessageAuthorization> {
+		const phase = z.enum(['observe', 'disclose', 'receive', 'accept']).parse(request.phase)
+		const permitted = (rule: PalActivitySubscriptionPermission | null) =>
+			phase === 'accept' ? rule?.observe && rule.disclose && rule.receive : rule?.[phase]
+		const captured = freezeCommunicationValue(subscriptionSchema.parse(request.subscription))
+		const stored = await this.subscriptions.get(captured.id)
+		const subscription = stored ? freezeCommunicationValue(subscriptionSchema.parse(stored)) : null
+		if (
+			!subscription?.enabled ||
+			subscription.configurationRevision !== captured.configurationRevision ||
+			!isDeepStrictEqual(subscription.scope, captured.scope) ||
+			!isDeepStrictEqual(subscription.recipient, captured.recipient)
+		)
+			return denied()
+		const observed = await this.get(subscription.id)
+		if (!permitted(observed)) return denied()
+		const current = await this.subscriptions.get(subscription.id)
+		if (
+			!current?.enabled ||
+			current.configurationRevision !== captured.configurationRevision ||
+			!isDeepStrictEqual(current.scope, captured.scope) ||
+			!isDeepStrictEqual(current.recipient, captured.recipient)
+		)
+			return denied()
+		const rule = await this.get(subscription.id)
+		if (!rule || !permitted(rule)) return denied()
+		return {
+			allow: true,
+			grant: {
+				id: `pal-subscription:${subscription.id}:${phase}`,
+				revision: String(rule.revision),
+			},
+		}
+	}
+	async authorizeIngress(input: PalIngressAuthorizationRequest): Promise<PalMessageAuthorization> {
+		if (!('kind' in input) || input.kind !== 'observation') return denied()
+		const request = freezeCommunicationValue(
+			z
+				.object({
+					kind: z.literal('observation'),
+					phase: z.enum(['accept', 'deliver', 'wake']),
+					source: observationSourceSchema,
+					routeKey: observationRouteKeySchema,
+					recipient: addressSchema,
+				})
+				.parse(input),
+		)
+		const id = z.string().uuid().parse(request.source.subscriptionId)
+		const phase = z.enum(['accept', 'deliver', 'wake']).parse(request.phase)
+		const stored = await this.subscriptions.get(id)
+		const subscription = stored ? freezeCommunicationValue(subscriptionSchema.parse(stored)) : null
+		if (
+			!subscription?.enabled ||
+			request.routeKey.kind !== 'observation' ||
+			request.routeKey.subscriptionId !== id ||
+			!isDeepStrictEqual(request.source.scope, subscription.scope) ||
+			!isDeepStrictEqual(request.routeKey.scope, subscription.scope) ||
+			!isDeepStrictEqual(request.recipient, subscription.recipient) ||
+			!isDeepStrictEqual(request.routeKey.recipient, subscription.recipient)
+		)
+			return denied()
+		const observed = await this.get(id)
+		if (
+			!observed?.observe ||
+			!observed.disclose ||
+			!observed.receive ||
+			(phase === 'wake' && !observed.wake)
+		)
+			return denied()
+		const current = await this.subscriptions.get(id)
+		if (
+			!current?.enabled ||
+			current.configurationRevision !== subscription.configurationRevision ||
+			!isDeepStrictEqual(current.scope, subscription.scope) ||
+			!isDeepStrictEqual(current.recipient, subscription.recipient)
+		)
+			return denied()
+		const rule = await this.get(id)
+		if (!rule?.observe || !rule.disclose || !rule.receive || (phase === 'wake' && !rule.wake))
+			return denied()
+		return {
+			allow: true,
+			grant: {
+				id: `pal-subscription:${id}:${phase}`,
+				revision: String(rule.revision),
+			},
+		}
+	}
+}

package/src/pals/activity/subscription-schema.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod'
+import { activityCursorSchema, activityScopeSchema } from '../communication/ingress-schema.js'
+import { addressSchema } from '../communication/schema.js'
+
+const positive = z.number().int().positive().safe()
+export const subscriptionScopeSchema = activityScopeSchema
+export const subscriptionCursorSchema = activityCursorSchema
+const subscriptionObjectSchema = z
+	.object({
+		v: z.literal(1),
+		id: z.string().uuid(),
+		revision: positive,
+		configurationRevision: positive,
+		scope: subscriptionScopeSchema,
+		recipient: addressSchema,
+		enabled: z.boolean(),
+		cursor: subscriptionCursorSchema.nullable(),
+	})
+	.strict()
+export const subscriptionSchema = subscriptionObjectSchema.refine(
+	(v) => v.scope.tenantId === v.recipient.tenantId,
+	'Cross-tenant observation is refused.',
+)
+export const storedSubscriptionSchema = subscriptionObjectSchema
+	.extend({ schemaVersion: z.literal(1).optional() })
+	.transform(({ schemaVersion: _schemaVersion, ...value }) => value)
+	.pipe(subscriptionSchema)

package/src/pals/activity/subscription-store.ts

@@ -0,0 +1,172 @@
+import { chmodSync, lstatSync, mkdirSync, readdirSync, realpathSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+import { isDeepStrictEqual } from 'node:util'
+import { z } from 'zod'
+import { DiskRevisionRecordStore } from '../../store/kv/revision-record-store.js'
+import { defineSchema } from '../../store/schema.js'
+import { freezeCommunicationValue } from '../communication/schema.js'
+import {
+	storedSubscriptionSchema,
+	subscriptionCursorSchema,
+	subscriptionSchema,
+} from './subscription-schema.js'
+import type { PalActivitySubscription, PalActivitySubscriptionStore } from './subscription-types.js'
+import type { PalActivityCursor } from './types.js'
+
+export class PalActivitySubscriptionConflictError extends Error {
+	override readonly name = 'PalActivitySubscriptionConflictError'
+}
+
+/** Private immutable revision commits. No cursors are accepted from a client or model. */
+export class DiskPalActivitySubscriptionStore implements PalActivitySubscriptionStore {
+	private readonly root: string
+	private readonly secure: (path: string) => void
+	private readonly records = new DiskRevisionRecordStore<PalActivitySubscription>(
+		defineSchema({
+			kind: 'pal-activity-subscription',
+			current: 1,
+			migrations: {},
+		}),
+		'Pal activity subscription',
+		(value) => value.revision,
+	)
+	constructor(options: {
+		root: string
+		secureDirectory?: (path: string) => void
+	}) {
+		this.root = resolve(options.root)
+		this.secure =
+			options.secureDirectory ??
+			((path) => {
+				if (process.platform !== 'win32') chmodSync(path, 0o700)
+			})
+		this.directory(this.root)
+	}
+	private directory(path: string) {
+		mkdirSync(path, { recursive: true, mode: 0o700 })
+		const stat = lstatSync(path)
+		if (!stat.isDirectory() || stat.isSymbolicLink() || realpathSync(path) !== path)
+			throw new Error('Pal subscriptions require real directories without aliases.')
+		this.secure(path)
+	}
+	private location(input: string) {
+		const id = z.string().uuid().parse(input)
+		this.directory(this.root)
+		const directory = join(this.root, id)
+		this.directory(directory)
+		const revisionsDir = join(directory, 'revisions')
+		this.directory(revisionsDir)
+		for (const name of readdirSync(revisionsDir)) {
+			if (!/^[1-9][0-9]*\.json$/u.test(name)) continue
+			const stat = lstatSync(join(revisionsDir, name))
+			if (!stat.isFile() || stat.isSymbolicLink())
+				throw new Error('Pal subscription commits must be real files.')
+		}
+		return {
+			legacyPath: join(directory, 'subscription.json'),
+			revisionsDir,
+			publishLegacyProjection: false,
+		}
+	}
+	private checked(input: unknown, id: string): PalActivitySubscription {
+		const value = storedSubscriptionSchema.parse(input)
+		if (value.id !== id || value.configurationRevision > value.revision)
+			throw new Error('Foreign or invalid Pal activity subscription.')
+		return freezeCommunicationValue(value)
+	}
+	async get(id: string): Promise<PalActivitySubscription | null> {
+		const value = await this.records.read(this.location(id))
+		return value === null ? null : this.checked(value, id)
+	}
+	/** Complete current records for trusted host projection; a bad record rejects the whole list. */
+	async list(): Promise<readonly PalActivitySubscription[]> {
+		try {
+			const entry = lstatSync(this.root)
+			if (!entry.isDirectory() || entry.isSymbolicLink() || realpathSync(this.root) !== this.root)
+				throw new Error('Pal subscriptions require real directories without aliases.')
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code === 'ENOENT') return Object.freeze([])
+			throw error
+		}
+		const subscriptions: PalActivitySubscription[] = []
+		for (const name of readdirSync(this.root).sort()) {
+			if (!z.string().uuid().safeParse(name).success) continue
+			const value = await this.get(name)
+			if (value) subscriptions.push(value)
+		}
+		return Object.freeze(subscriptions)
+	}
+	async create(input: Parameters<PalActivitySubscriptionStore['create']>[0]) {
+		const value = subscriptionSchema.parse({
+			...input,
+			v: 1,
+			revision: 1,
+			configurationRevision: 1,
+			cursor: null,
+		})
+		const proposed = this.checked(value, value.id)
+		return this.records.transact(this.location(proposed.id), (stored) => {
+			if (stored !== null)
+				throw new PalActivitySubscriptionConflictError('Subscription identity already exists.')
+			return { record: proposed, result: proposed }
+		})
+	}
+	async setEnabled(input: Parameters<PalActivitySubscriptionStore['setEnabled']>[0]) {
+		const captured = z
+			.object({
+				id: z.string().uuid(),
+				expectedRevision: z.number().int().positive().safe(),
+				enabled: z.boolean(),
+			})
+			.strict()
+			.parse(input)
+		return this.records.transact(this.location(captured.id), (stored) => {
+			const current = stored === null ? null : this.checked(stored, captured.id)
+			if (!current || current.revision !== captured.expectedRevision)
+				throw new PalActivitySubscriptionConflictError(
+					'Subscription changed; reload before changing consent.',
+				)
+			const record = this.checked(
+				{
+					...current,
+					enabled: captured.enabled,
+					revision: current.revision + 1,
+					configurationRevision: current.configurationRevision + 1,
+				},
+				current.id,
+			)
+			return { record, result: record }
+		})
+	}
+	async advance(input: PalActivitySubscription, inputCursor: PalActivityCursor) {
+		const parsed = subscriptionSchema.parse(input)
+		const captured = this.checked(parsed, parsed.id)
+		const cursor = freezeCommunicationValue(subscriptionCursorSchema.parse(inputCursor))
+		if (cursor.after.seq < cursor.root.seq || cursor.after.offset < cursor.root.offset)
+			throw new Error('Subscription cursor cannot precede its root.')
+		if (captured.cursor) {
+			const previous = captured.cursor
+			if (
+				cursor.scopeHash !== previous.scopeHash ||
+				!isDeepStrictEqual(cursor.root, previous.root) ||
+				cursor.after.seq < previous.after.seq ||
+				cursor.after.offset < previous.after.offset ||
+				cursor.generation < previous.generation ||
+				(cursor.after.seq === previous.after.seq && !isDeepStrictEqual(cursor, previous))
+			)
+				throw new Error('Subscription cursor identity changed or moved backwards.')
+		}
+		return this.records.transact(this.location(captured.id), (stored) => {
+			const current = stored === null ? null : this.checked(stored, captured.id)
+			if (!current || !current.enabled || !isDeepStrictEqual(current, captured))
+				throw new PalActivitySubscriptionConflictError(
+					'Subscription changed before accepted progress could commit.',
+				)
+			const record = this.checked(
+				{ ...current, revision: current.revision + 1, cursor },
+				current.id,
+			)
+			return { record, result: record }
+		})
+	}
+}

package/src/pals/activity/subscription-types.ts

@@ -0,0 +1,48 @@
+import type { PalAddress } from '../communication/types.js'
+import type { PalActivityCursor, PalActivityFact, PalActivityScope } from './types.js'
+
+/** Host-owned, immutable observation scope and destination, with separately revocable consent. */
+export interface PalActivitySubscription {
+	readonly v: 1
+	readonly id: string
+	readonly revision: number
+	readonly configurationRevision: number
+	readonly scope: PalActivityScope
+	readonly recipient: PalAddress
+	readonly enabled: boolean
+	readonly cursor: PalActivityCursor | null
+}
+
+export interface PalActivitySubscriptionStore {
+	get(id: string): Promise<PalActivitySubscription | null>
+	create(input: {
+		readonly id: string
+		readonly scope: PalActivityScope
+		readonly recipient: PalAddress
+		readonly enabled: boolean
+	}): Promise<PalActivitySubscription>
+	setEnabled(input: {
+		readonly id: string
+		readonly expectedRevision: number
+		readonly enabled: boolean
+	}): Promise<PalActivitySubscription>
+	/** Only an unchanged cursor emitted by the trusted original-journal source may be committed. */
+	advance(
+		subscription: PalActivitySubscription,
+		cursor: PalActivityCursor,
+	): Promise<PalActivitySubscription>
+}
+
+export interface PalActivitySubscriptionAuthorizationRequest {
+	/** `accept` requires observe, disclose and receive together immediately before inbox acceptance. */
+	readonly phase: 'observe' | 'disclose' | 'receive' | 'accept'
+	readonly subscription: PalActivitySubscription
+	readonly fact?: PalActivityFact
+}
+
+export interface PalActivitySubscriptionResult {
+	readonly subscription: PalActivitySubscription
+	readonly accepted: readonly string[]
+	readonly suppressed: readonly string[]
+	readonly complete: boolean
+}

package/src/pals/activity/subscriptions.ts

@@ -0,0 +1,209 @@
+import { isDeepStrictEqual } from 'node:util'
+import { z } from 'zod'
+import { ingressIntentDigest, ingressIntentId } from '../communication/ingress-schema.js'
+import type { PalIngressStore, PalObservationIntent } from '../communication/ingress-types.js'
+import { freezeCommunicationValue, hash, label } from '../communication/schema.js'
+import type { PalMessageAuthorization, PalMessageGrant } from '../communication/types.js'
+import type { PalStore } from '../types.js'
+import { createPalActivitySource } from './source.js'
+import { subscriptionSchema } from './subscription-schema.js'
+import type {
+	PalActivitySubscriptionAuthorizationRequest,
+	PalActivitySubscriptionResult,
+	PalActivitySubscriptionStore,
+} from './subscription-types.js'
+import type {
+	PalActivityFact,
+	PalActivityReadOptions,
+	PalActivityScope,
+	PalActivitySourceOptions,
+} from './types.js'
+
+export class PalActivitySubscriptionDeniedError extends Error {
+	override readonly name = 'PalActivitySubscriptionDeniedError'
+	constructor() {
+		super('Current Pal observation, disclosure and recipient consent are required.')
+	}
+}
+
+export interface PalActivitySubscriptionRunnerOptions {
+	readonly subscriptions: PalActivitySubscriptionStore
+	readonly ingress: PalIngressStore
+	readonly pals: PalStore
+	readonly openJournal: PalActivitySourceOptions['openJournal']
+	/**
+	 * Trusted current host policy. Observation, disclosure and receipt are independent decisions;
+	 * the final `accept` phase must require all three together under current consent.
+	 */
+	readonly authorize: (
+		request: PalActivitySubscriptionAuthorizationRequest,
+		signal: AbortSignal,
+	) => Promise<PalMessageAuthorization>
+	/**
+	 * Resolve prior subscription IDs from original turn delivery evidence retained by the host.
+	 * An independent turn yields []; unknown or incomplete evidence must reject. Never accept
+	 * a model, renderer or remote client's assertion about its own provenance.
+	 */
+	readonly resolveCausality: (
+		scope: PalActivityScope,
+		fact: PalActivityFact,
+		signal: AbortSignal,
+	) => Promise<readonly string[]>
+	readonly now?: () => number
+	/** Hint only. Observer failures and pending promises cannot prevent acceptance/progress. */
+	readonly notify?: (palId: string) => void | Promise<void>
+}
+
+/** One bounded page, no daemon and no inference. Progress follows durable inbox acceptance. */
+export async function publishPalActivityOnce(
+	options: PalActivitySubscriptionRunnerOptions,
+	id: string,
+	input: Omit<PalActivityReadOptions, 'cursor'>,
+): Promise<PalActivitySubscriptionResult> {
+	const subscriptionId = z.string().uuid().parse(id)
+	const { signal } = input
+	const { subscriptions, ingress, pals, openJournal, authorize, resolveCausality, notify } = options
+	const now = options.now ?? Date.now
+	if (
+		typeof authorize !== 'function' ||
+		typeof resolveCausality !== 'function' ||
+		typeof openJournal !== 'function'
+	)
+		throw new TypeError(
+			'Pal subscriptions require trusted policy, causality and original journal ports.',
+		)
+	signal.throwIfAborted()
+	const stored = await subscriptions.get(subscriptionId)
+	if (!stored) throw new PalActivitySubscriptionDeniedError()
+	const subscription = freezeCommunicationValue(subscriptionSchema.parse(stored))
+	async function current() {
+		signal.throwIfAborted()
+		const value = await subscriptions.get(subscriptionId)
+		signal.throwIfAborted()
+		if (
+			!value?.enabled ||
+			value.configurationRevision !== subscription.configurationRevision ||
+			!isDeepStrictEqual(value.scope, subscription.scope) ||
+			!isDeepStrictEqual(value.recipient, subscription.recipient)
+		)
+			throw new PalActivitySubscriptionDeniedError()
+	}
+	async function permitted(
+		phase: PalActivitySubscriptionAuthorizationRequest['phase'],
+		fact?: PalActivityFact,
+	): Promise<PalMessageGrant> {
+		await current()
+		const decision = await authorize(
+			freezeCommunicationValue({
+				phase,
+				subscription,
+				...(fact ? { fact } : {}),
+			}),
+			signal,
+		)
+		signal.throwIfAborted()
+		if (!decision.allow) throw new PalActivitySubscriptionDeniedError()
+		const grant = freezeCommunicationValue(
+			z.object({ id: label, revision: label }).strict().parse(decision.grant),
+		)
+		await current()
+		return grant
+	}
+	const source = createPalActivitySource({
+		scope: subscription.scope,
+		pals,
+		openJournal,
+		async authorize() {
+			await permitted('observe')
+			return true
+		},
+	})
+	const page = await source.read({
+		signal,
+		maxRecords: input.maxRecords,
+		maxReadBytes: input.maxReadBytes,
+		...(subscription.cursor ? { cursor: subscription.cursor } : {}),
+	})
+	const accepted: string[] = []
+	const suppressed: string[] = []
+	for (const fact of page.facts) {
+		const observed = await permitted('observe', fact)
+		const lineage = z
+			.array(z.string().uuid())
+			.refine((ids) => new Set(ids).size === ids.length)
+			.parse(await resolveCausality(subscription.scope, fact, signal))
+		signal.throwIfAborted()
+		await current()
+		if (lineage.includes(subscription.id)) {
+			suppressed.push(fact.id)
+			continue
+		}
+		const disclosed = await permitted('disclose', fact)
+		const received = await permitted('receive', fact)
+		const recipient = pals.get(subscription.recipient.palId)
+		if (!recipient) throw new PalActivitySubscriptionDeniedError()
+		const acceptedGrant = await permitted('accept', fact)
+		const draft = {
+			kind: 'observation' as const,
+			operationId: fact.id,
+			source: {
+				kind: 'host-observation' as const,
+				subscriptionId: subscription.id,
+				scope: subscription.scope,
+			},
+			recipient: subscription.recipient,
+			routeKey: {
+				v: 1 as const,
+				kind: 'observation' as const,
+				recipient: subscription.recipient,
+				subscriptionId: subscription.id,
+				scope: subscription.scope,
+			},
+			fact,
+			subscriptionTrail: [...lineage, subscription.id],
+			replyTo: null,
+			grant: {
+				id: hash([
+					'pal-observation-grants/1',
+					subscription.id,
+					observed.id,
+					disclosed.id,
+					received.id,
+					acceptedGrant.id,
+				]),
+				revision: hash([
+					subscription.configurationRevision,
+					observed.revision,
+					disclosed.revision,
+					received.revision,
+					acceptedGrant.revision,
+				]),
+			},
+			createdAt: now(),
+		}
+		const intentId = ingressIntentId(draft)
+		const intent = freezeCommunicationValue({
+			...draft,
+			id: intentId,
+			digest: ingressIntentDigest({ ...draft, id: intentId }),
+		}) as PalObservationIntent
+		await ingress.acceptIngress(intent, recipient.revision)
+		accepted.push(intent.id)
+		if (notify) {
+			try {
+				Promise.resolve(notify(subscription.recipient.palId)).catch(() => {})
+			} catch {}
+		}
+	}
+	await permitted('observe')
+	const next =
+		subscription.cursor && isDeepStrictEqual(subscription.cursor, page.cursor)
+			? subscription
+			: await subscriptions.advance(subscription, page.cursor)
+	return freezeCommunicationValue({
+		subscription: next,
+		accepted,
+		suppressed,
+		complete: page.complete,
+	})
+}