@namzu/sdk 61.4.0 → 62.0.0

package/src/manager/resident/loop.ts

@@ -1,119 +0,0 @@
-import { setTimeout as sleep } from 'node:timers/promises'
-import {
-	ResidentConflictError,
-	type ResidentDecision,
-	type ResidentExecutionStore,
-	type ResidentState,
-} from './store.js'
-
-/**
- * @experimental Developer-owned step; bind providers, tools and budgets in the host.
- *
- * @deprecated Residents are deprecated and removed in the next major release. Learning (`runLearningCycle` and the other `Learning*` names) keeps working, but `runLearningCycle` still takes a resident agenda until learning gets its own activation target in the next major release; for long-running work use scheduled tasks (`LocalTaskScheduler`), session goals and background agents.
- */
-export type ResidentStep = (state: ResidentState, signal: AbortSignal) => Promise<ResidentDecision>
-
-/**
- * @experimental No model is invoked for an idle, terminal or unresolved resident.
- *
- * @deprecated Residents are deprecated and removed in the next major release. Learning (`runLearningCycle` and the other `Learning*` names) keeps working, but `runLearningCycle` still takes a resident agenda until learning gets its own activation target in the next major release; for long-running work use scheduled tasks (`LocalTaskScheduler`), session goals and background agents.
- */
-export type ResidentStepResult =
-	| { status: 'settled'; state: ResidentState }
-	| {
-			status: 'idle'
-			reason: 'not-due' | 'terminal' | 'unresolved' | 'contended'
-			state: ResidentState
-	  }
-
-/**
- * @experimental A failed/aborted callback leaves its durable claim unresolved.
- *
- * @deprecated Residents are deprecated and removed in the next major release. Learning (`runLearningCycle` and the other `Learning*` names) keeps working, but `runLearningCycle` still takes a resident agenda until learning gets its own activation target in the next major release; for long-running work use scheduled tasks (`LocalTaskScheduler`), session goals and background agents.
- */
-export async function stepResident(
-	store: ResidentExecutionStore,
-	step: ResidentStep,
-	signal: AbortSignal,
-	now: () => number = Date.now,
-): Promise<ResidentStepResult> {
-	signal.throwIfAborted()
-	const state = await store.read()
-	signal.throwIfAborted()
-	if (!state) throw new Error('Create the resident before running it.')
-	if (state.phase === 'running') return { status: 'idle', reason: 'unresolved', state }
-	if (state.phase !== 'waiting') return { status: 'idle', reason: 'terminal', state }
-	if (state.wakeAt === null || state.wakeAt > now())
-		return { status: 'idle', reason: 'not-due', state }
-	let claim: ResidentState
-	try {
-		claim = await store.claim(state, now())
-	} catch (error) {
-		if (!(error instanceof ResidentConflictError)) throw error
-		return {
-			status: 'idle',
-			reason: 'contended',
-			state: (await store.read()) ?? state,
-		}
-	}
-	signal.throwIfAborted()
-	const decision = await step(claim, signal)
-	signal.throwIfAborted()
-	return {
-		status: 'settled',
-		state: await store.settle(claim, decision, now()),
-	}
-}
-
-/**
- * @experimental Bounded local driver; not a daemon, process recovery service or notification transport.
- *
- * @deprecated Residents are deprecated and removed in the next major release. Learning (`runLearningCycle` and the other `Learning*` names) keeps working, but `runLearningCycle` still takes a resident agenda until learning gets its own activation target in the next major release; for long-running work use scheduled tasks (`LocalTaskScheduler`), session goals and background agents.
- */
-export interface ResidentLoopOptions {
-	readonly store: ResidentExecutionStore
-	readonly step: ResidentStep
-	readonly signal: AbortSignal
-	/** Required finite admission cap for this invocation, independent of provider token limits. */
-	readonly maxSteps: number
-	/** Maximum single idle wait, default 60 seconds. Longer waits return control to the host. */
-	readonly maxIdleMs?: number
-}
-
-/**
- * @experimental Continue a pursuit without a new user message. Null wake times
- * and terminal states stop immediately; cancellation also interrupts idle waits.
- * An abort cannot undo callback effects or forcibly stop a callback ignoring its signal.
- *
- * @deprecated Residents are deprecated and removed in the next major release. Learning (`runLearningCycle` and the other `Learning*` names) keeps working, but `runLearningCycle` still takes a resident agenda until learning gets its own activation target in the next major release; for long-running work use scheduled tasks (`LocalTaskScheduler`), session goals and background agents.
- */
-export async function runResident(options: ResidentLoopOptions): Promise<ResidentStepResult> {
-	const maxIdleMs = options.maxIdleMs ?? 60_000
-	if (
-		!Number.isSafeInteger(options.maxSteps) ||
-		options.maxSteps < 1 ||
-		!Number.isSafeInteger(maxIdleMs) ||
-		maxIdleMs < 0 ||
-		maxIdleMs > 2_147_483_647
-	) {
-		throw new TypeError(
-			'Resident loop requires positive finite maxSteps and bounded nonnegative maxIdleMs.',
-		)
-	}
-	let admitted = 0
-	while (true) {
-		const result = await stepResident(options.store, options.step, options.signal)
-		if (result.status === 'settled') admitted++
-		if (admitted >= options.maxSteps) return result
-		const { state } = result
-		if (
-			state.phase !== 'waiting' ||
-			state.wakeAt === null ||
-			(result.status === 'idle' && result.reason !== 'not-due')
-		)
-			return result
-		const delay = Math.max(0, state.wakeAt - Date.now())
-		if (delay > maxIdleMs) return result
-		await sleep(Math.max(1, delay), undefined, { signal: options.signal })
-	}
-}

package/src/manager/resident/outbox.ts

@@ -1,341 +0,0 @@
-import { randomUUID } from 'node:crypto'
-import { z } from 'zod'
-import type { ResidentAgendaState } from './agenda.js'
-import { ResidentConflictError } from './store.js'
-
-const time = z.number().int().nonnegative().safe().max(8_640_000_000_000_000)
-const label = z.string().trim().min(1).max(256)
-
-export const residentMessageInputSchema = z.object({
-	id: z.string().uuid(),
-	pursuitId: z.string().uuid(),
-	destination: label,
-	body: z
-		.string()
-		.min(1)
-		.max(8_000)
-		.refine((value) => value.trim().length > 0),
-	notBefore: time,
-})
-
-/**
- * @experimental Host-approved content and an opaque destination route, never credentials.
- *
- * @deprecated Residents are deprecated and removed in the next major release. Learning (`runLearningCycle` and the other `Learning*` names) keeps working, but `runLearningCycle` still takes a resident agenda until learning gets its own activation target in the next major release; for long-running work use scheduled tasks (`LocalTaskScheduler`), session goals and background agents.
- */
-export type ResidentMessageInput = Readonly<z.infer<typeof residentMessageInputSchema>>
-
-export const residentOutboxMessageSchema = residentMessageInputSchema
-	.extend({
-		tenantId: z.string().uuid(),
-		agentKey: z.string().min(1).max(200),
-		sourceClaimId: z.string().uuid().nullable(),
-		revision: z.number().int().positive().safe(),
-		attempts: z.number().int().nonnegative().safe(),
-		phase: z.enum(['pending', 'sending', 'acknowledged', 'cancelled']),
-		claimId: z.string().uuid().nullable(),
-		nextAttemptAt: time.nullable(),
-		receiptId: label.nullable(),
-		acknowledgedAt: time.nullable(),
-		lastReason: z.string().trim().min(1).max(1_000).nullable(),
-	})
-	.superRefine((message, context) => {
-		if (
-			(message.phase === 'sending') !== (message.claimId !== null) ||
-			(message.phase === 'pending') !== (message.nextAttemptAt !== null) ||
-			(message.phase === 'acknowledged') !== (message.receiptId !== null) ||
-			(message.phase === 'acknowledged') !== (message.acknowledgedAt !== null) ||
-			(message.nextAttemptAt !== null && message.nextAttemptAt < message.notBefore) ||
-			(message.phase !== 'pending' && message.attempts === 0)
-		)
-			context.addIssue({ code: z.ZodIssueCode.custom, message: 'Invalid outbox lifecycle.' })
-	})
-
-/**
- * @experimental Acknowledgment proves transport acceptance, not human reading.
- *
- * @deprecated Residents are deprecated and removed in the next major release. Learning (`runLearningCycle` and the other `Learning*` names) keeps working, but `runLearningCycle` still takes a resident agenda until learning gets its own activation target in the next major release; for long-running work use scheduled tasks (`LocalTaskScheduler`), session goals and background agents.
- */
-export type ResidentOutboxMessage = Readonly<z.infer<typeof residentOutboxMessageSchema>>
-
-export const residentDeliveryOutcomeSchema = z.discriminatedUnion('kind', [
-	z.object({ kind: z.literal('acknowledged'), receiptId: label }),
-	z.object({
-		kind: z.literal('not-accepted'),
-		retryAt: time.nullable(),
-		reason: z.string().trim().min(1).max(1_000),
-	}),
-])
-
-/**
- * @experimental Retry only with evidence of non-acceptance; null retryAt ends delivery.
- *
- * @deprecated Residents are deprecated and removed in the next major release. Learning (`runLearningCycle` and the other `Learning*` names) keeps working, but `runLearningCycle` still takes a resident agenda until learning gets its own activation target in the next major release; for long-running work use scheduled tasks (`LocalTaskScheduler`), session goals and background agents.
- */
-export type ResidentDeliveryOutcome = Readonly<z.infer<typeof residentDeliveryOutcomeSchema>>
-
-/**
- * @experimental Atomic admission and exact-claim settlement, without automatic claim expiry.
- *
- * @deprecated Residents are deprecated and removed in the next major release. Learning (`runLearningCycle` and the other `Learning*` names) keeps working, but `runLearningCycle` still takes a resident agenda until learning gets its own activation target in the next major release; for long-running work use scheduled tasks (`LocalTaskScheduler`), session goals and background agents.
- */
-export interface ResidentOutboxStore {
-	read(): Promise<ResidentAgendaState | null>
-	claimMessage(
-		expected: ResidentAgendaState,
-		id: string,
-		now: number,
-	): Promise<ResidentOutboxMessage>
-	settleMessage(
-		expected: ResidentOutboxMessage,
-		outcome: ResidentDeliveryOutcome,
-		now: number,
-	): Promise<ResidentOutboxMessage>
-}
-
-/**
- * @experimental A synchronous host policy, evaluated before claiming and again before sending.
- *
- * @deprecated Residents are deprecated and removed in the next major release. Learning (`runLearningCycle` and the other `Learning*` names) keeps working, but `runLearningCycle` still takes a resident agenda until learning gets its own activation target in the next major release; for long-running work use scheduled tasks (`LocalTaskScheduler`), session goals and background agents.
- */
-export type ResidentDeliveryGate = (
-	message: ResidentOutboxMessage,
-	now: number,
-) =>
-	| { readonly allow: true }
-	| {
-			readonly allow: false
-			readonly nextCheckAt: number | null
-			readonly reason: string
-	  }
-
-/**
- * @experimental Bind an authorized route; forward message.id as the stable idempotency key.
- *
- * @deprecated Residents are deprecated and removed in the next major release. Learning (`runLearningCycle` and the other `Learning*` names) keeps working, but `runLearningCycle` still takes a resident agenda until learning gets its own activation target in the next major release; for long-running work use scheduled tasks (`LocalTaskScheduler`), session goals and background agents.
- */
-export type ResidentMessageTransport = (
-	message: ResidentOutboxMessage,
-	signal: AbortSignal,
-) => Promise<ResidentDeliveryOutcome>
-
-/**
- * @experimental One dispatch admission, with no model invocation, polling or implicit retries.
- *
- * @deprecated Residents are deprecated and removed in the next major release. Learning (`runLearningCycle` and the other `Learning*` names) keeps working, but `runLearningCycle` still takes a resident agenda until learning gets its own activation target in the next major release; for long-running work use scheduled tasks (`LocalTaskScheduler`), session goals and background agents.
- */
-export interface ResidentDeliveryOptions {
-	readonly signal: AbortSignal
-	readonly gate: ResidentDeliveryGate
-	readonly now?: () => number
-}
-
-/**
- * @experimental An idle result never asserts a message reached its destination.
- *
- * @deprecated Residents are deprecated and removed in the next major release. Learning (`runLearningCycle` and the other `Learning*` names) keeps working, but `runLearningCycle` still takes a resident agenda until learning gets its own activation target in the next major release; for long-running work use scheduled tasks (`LocalTaskScheduler`), session goals and background agents.
- */
-export type ResidentDeliveryResult =
-	| { readonly status: 'settled'; readonly message: ResidentOutboxMessage }
-	| {
-			readonly status: 'idle'
-			readonly reason: 'paused' | 'unresolved' | 'empty' | 'not-due' | 'window' | 'contended'
-			readonly nextCheckAt: number | null
-	  }
-
-/** Internal pure enqueue used in the same revision transaction as pursuit settlement. */
-export function appendResidentMessage(
-	state: ResidentAgendaState,
-	input: ResidentMessageInput,
-	sourceClaimId: string | null = null,
-): readonly ResidentOutboxMessage[] {
-	const checked = residentMessageInputSchema.parse(input)
-	if (!state.pursuits.some((p) => p.id === checked.pursuitId))
-		throw new Error('Outbox message references an unknown pursuit.')
-	const messages = state.outbox ?? []
-	const existing = messages.find((message) => message.id === checked.id)
-	if (existing) {
-		if (
-			existing.pursuitId !== checked.pursuitId ||
-			existing.destination !== checked.destination ||
-			existing.body !== checked.body ||
-			existing.notBefore !== checked.notBefore ||
-			existing.sourceClaimId !== sourceClaimId
-		)
-			throw new Error('Outbox message ID already names a different immutable intent.')
-		return messages
-	}
-	if (messages.length >= 128) throw new Error('Resident outbox capacity reached (128 intents).')
-	return [
-		...messages,
-		Object.freeze(
-			residentOutboxMessageSchema.parse({
-				...checked,
-				tenantId: state.tenantId,
-				agentKey: state.agentKey,
-				sourceClaimId,
-				revision: 1,
-				attempts: 0,
-				phase: 'pending',
-				claimId: null,
-				nextAttemptAt: checked.notBefore,
-				receiptId: null,
-				acknowledgedAt: null,
-				lastReason: null,
-			}),
-		),
-	]
-}
-
-/** Internal exact-message transition; agenda storage owns exclusive admission. */
-export function claimResidentOutboxMessage(
-	message: ResidentOutboxMessage,
-	now: number,
-): ResidentOutboxMessage {
-	time.parse(now)
-	if (message.phase !== 'pending' || message.nextAttemptAt === null || message.nextAttemptAt > now)
-		throw new ResidentConflictError()
-	return Object.freeze(
-		residentOutboxMessageSchema.parse({
-			...message,
-			revision: message.revision + 1,
-			attempts: message.attempts + 1,
-			phase: 'sending',
-			claimId: randomUUID(),
-			nextAttemptAt: null,
-		}),
-	)
-}
-
-/** Internal settlement; unknown failures deliberately have no transition. */
-export function settleResidentOutboxMessage(
-	message: ResidentOutboxMessage,
-	outcome: ResidentDeliveryOutcome,
-	now: number,
-): ResidentOutboxMessage {
-	time.parse(now)
-	const checked = residentDeliveryOutcomeSchema.parse(outcome)
-	if (message.phase !== 'sending' || message.claimId === null) throw new ResidentConflictError()
-	if (checked.kind === 'not-accepted' && checked.retryAt !== null && checked.retryAt <= now)
-		throw new TypeError('A delivery retry must be scheduled in the future.')
-	return Object.freeze(
-		residentOutboxMessageSchema.parse({
-			...message,
-			revision: message.revision + 1,
-			claimId: null,
-			...(checked.kind === 'acknowledged'
-				? { phase: 'acknowledged', receiptId: checked.receiptId, acknowledgedAt: now }
-				: {
-						phase: checked.retryAt === null ? 'cancelled' : 'pending',
-						nextAttemptAt: checked.retryAt,
-						lastReason: checked.reason,
-					}),
-		}),
-	)
-}
-
-function admission(gate: ResidentDeliveryGate, message: ResidentOutboxMessage, now: number) {
-	const result = gate(message, now)
-	if (result.allow === true) return result
-	if (
-		result.allow !== false ||
-		typeof result.reason !== 'string' ||
-		!result.reason.trim() ||
-		result.reason.trim().length > 1_000
-	)
-		throw new TypeError('Invalid resident delivery gate result.')
-	if (result.nextCheckAt !== null) {
-		time.parse(result.nextCheckAt)
-		if (result.nextCheckAt <= now) throw new TypeError('Delivery gate must defer into the future.')
-	}
-	return result
-}
-
-/**
- * @experimental Persist one send claim before calling a host-owned transport.
- * Throws, malformed outcomes and cancellation keep the claim unresolved. Stop
- * old executors and inspect effects before explicit settleMessage reconciliation.
- *
- * @deprecated Residents are deprecated and removed in the next major release. Learning (`runLearningCycle` and the other `Learning*` names) keeps working, but `runLearningCycle` still takes a resident agenda until learning gets its own activation target in the next major release; for long-running work use scheduled tasks (`LocalTaskScheduler`), session goals and background agents.
- */
-export async function deliverResidentMessage(
-	store: ResidentOutboxStore,
-	transport: ResidentMessageTransport,
-	options: ResidentDeliveryOptions,
-): Promise<ResidentDeliveryResult> {
-	const { signal, gate } = options
-	const clock = options.now ?? Date.now
-	const now = () => time.parse(clock())
-	signal.throwIfAborted()
-	const state = await store.read()
-	signal.throwIfAborted()
-	if (!state) throw new Error('Create the resident agenda before delivering messages.')
-	const idle = (
-		reason: Extract<ResidentDeliveryResult, { status: 'idle' }>['reason'],
-		nextCheckAt: number | null = null,
-	): ResidentDeliveryResult => ({ status: 'idle', reason, nextCheckAt })
-	if (state.paused) return idle('paused')
-	const messages = state.outbox ?? []
-	if (messages.some((message) => message.phase === 'sending')) return idle('unresolved')
-	const pending = messages.filter((message) => message.phase === 'pending')
-	if (!pending.length) return idle('empty')
-	let nextCheckAt: number | null = null
-	let gated = false
-	const at = now()
-	for (const message of pending.sort(
-		(a, b) => (a.nextAttemptAt ?? 0) - (b.nextAttemptAt ?? 0) || a.id.localeCompare(b.id),
-	)) {
-		if (message.nextAttemptAt !== null && message.nextAttemptAt > at) {
-			nextCheckAt = Math.min(nextCheckAt ?? Number.POSITIVE_INFINITY, message.nextAttemptAt)
-			continue
-		}
-		const permission = admission(gate, message, at)
-		signal.throwIfAborted()
-		if (!permission.allow) {
-			gated = true
-			if (permission.nextCheckAt !== null)
-				nextCheckAt = Math.min(nextCheckAt ?? Number.POSITIVE_INFINITY, permission.nextCheckAt)
-			continue
-		}
-		let claimed: ResidentOutboxMessage
-		try {
-			claimed = await store.claimMessage(state, message.id, now())
-		} catch (error) {
-			if (error instanceof ResidentConflictError) return idle('contended')
-			throw error
-		}
-		signal.throwIfAborted()
-		const fresh = await store.read()
-		signal.throwIfAborted()
-		const current = fresh?.outbox?.find((item) => item.id === claimed.id)
-		if (!current || current.revision !== claimed.revision || current.claimId !== claimed.claimId)
-			return idle('contended')
-		// A pause or closing window during admission must not start the transport.
-		const checkedAt = now()
-		const permissionNow = fresh?.paused
-			? {
-					allow: false as const,
-					nextCheckAt: checkedAt + 1,
-					reason: 'Resident agenda paused before send.',
-				}
-			: admission(gate, claimed, checkedAt)
-		if (!permissionNow.allow) {
-			// Transport has not been entered: scheduling another check has no remote effect.
-			await store.settleMessage(
-				claimed,
-				{
-					kind: 'not-accepted',
-					retryAt: permissionNow.nextCheckAt ?? checkedAt + 1,
-					reason: permissionNow.reason,
-				},
-				checkedAt,
-			)
-			return idle(fresh?.paused ? 'paused' : 'window', permissionNow.nextCheckAt)
-		}
-		signal.throwIfAborted()
-		const outcome = await transport(claimed, signal)
-		signal.throwIfAborted()
-		return { status: 'settled', message: await store.settleMessage(claimed, outcome, now()) }
-	}
-	return idle(gated ? 'window' : 'not-due', nextCheckAt)
-}

package/src/manager/resident/proposal.ts

@@ -1,119 +0,0 @@
-import { z } from 'zod'
-import type { ResidentAgendaState } from './agenda.js'
-
-const identifier = z.string().uuid()
-const revision = z.number().int().positive().safe()
-const domain = z
-	.string()
-	.min(1)
-	.max(120)
-	.refine((value) => value.trim().length > 0, 'A proposal domain must contain text.')
-const reason = z.string().trim().min(1).max(1_000)
-const evidenceKey = z.string().trim().min(1).max(256)
-
-export const residentProposalSchema = z.object({
-	id: identifier,
-	parentId: identifier,
-	parentRevision: revision,
-	domain,
-	objective: z.string().trim().min(1).max(8_000),
-	reason,
-	evidenceKey,
-})
-
-export const residentProposalLimitsSchema = z.object({
-	domains: z.array(domain).min(1),
-	maxChildrenPerParent: z.number().int().min(1).max(8),
-	maxDepth: z.number().int().min(1).max(4),
-})
-
-/**
- * @experimental An inert subgoal proposal; creating it grants no execution authority.
- *
- * @deprecated Residents are deprecated and removed in the next major release. Learning (`runLearningCycle` and the other `Learning*` names) keeps working, but `runLearningCycle` still takes a resident agenda until learning gets its own activation target in the next major release; for long-running work use scheduled tasks (`LocalTaskScheduler`), session goals and background agents.
- */
-export interface ResidentProposal {
-	readonly id: string
-	readonly parentId: string
-	readonly parentRevision: number
-	readonly domain: string
-	readonly objective: string
-	readonly reason: string
-	readonly evidenceKey: string
-}
-
-/**
- * @experimental Host-approved routing domains and finite subgoal admission bounds.
- *
- * @deprecated Residents are deprecated and removed in the next major release. Learning (`runLearningCycle` and the other `Learning*` names) keeps working, but `runLearningCycle` still takes a resident agenda until learning gets its own activation target in the next major release; for long-running work use scheduled tasks (`LocalTaskScheduler`), session goals and background agents.
- */
-export interface ResidentProposalLimits {
-	readonly domains: readonly string[]
-	readonly maxChildrenPerParent: number
-	readonly maxDepth: number
-}
-
-/** Persisted provenance shared with the agenda's schema validation. */
-export const residentProposalOriginSchema = z.object({
-	proposalId: identifier,
-	parentId: identifier,
-	parentRevision: revision,
-	domain,
-	reason,
-	evidenceKey,
-	depth: z.number().int().min(1).max(4),
-})
-
-/**
- * @experimental Host-admitted ancestry and evidence for a resident subgoal.
- *
- * @deprecated Residents are deprecated and removed in the next major release. Learning (`runLearningCycle` and the other `Learning*` names) keeps working, but `runLearningCycle` still takes a resident agenda until learning gets its own activation target in the next major release; for long-running work use scheduled tasks (`LocalTaskScheduler`), session goals and background agents.
- */
-export type ResidentProposalOrigin = Readonly<z.infer<typeof residentProposalOriginSchema>>
-
-/**
- * @experimental Pure validation against one agenda snapshot. The host must
- * atomically bind this snapshot to admission. Domains are routing metadata;
- * this does not prove an objective fits its domain or authorize any tools.
- *
- * @deprecated Residents are deprecated and removed in the next major release. Learning (`runLearningCycle` and the other `Learning*` names) keeps working, but `runLearningCycle` still takes a resident agenda until learning gets its own activation target in the next major release; for long-running work use scheduled tasks (`LocalTaskScheduler`), session goals and background agents.
- */
-export function validateResidentProposal(
-	agenda: ResidentAgendaState,
-	input: ResidentProposal,
-	limits: ResidentProposalLimits,
-): ResidentProposalOrigin {
-	const proposal = residentProposalSchema.parse(input)
-	const policy = residentProposalLimitsSchema.parse(limits)
-	if (agenda.paused) throw new Error('A paused agenda cannot admit resident proposals.')
-	if (agenda.pursuits.length >= 32) throw new Error('Resident agenda pursuit bound reached.')
-	if (agenda.pursuits.some((pursuit) => pursuit.origin?.proposalId === proposal.id))
-		throw new Error('Resident proposal has already been admitted.')
-	const parent = agenda.pursuits.find((pursuit) => pursuit.id === proposal.parentId)
-	if (!parent) throw new Error('Unknown resident proposal parent.')
-	if (parent.state.revision !== proposal.parentRevision)
-		throw new Error('Resident proposal parent revision is stale.')
-	if (parent.state.phase !== 'waiting' && parent.state.phase !== 'complete')
-		throw new Error('Resident proposal parent must be waiting or complete.')
-	if (!policy.domains.includes(proposal.domain))
-		throw new Error('Resident proposal domain is not host-approved.')
-	if (
-		agenda.pursuits.filter((pursuit) => pursuit.origin?.parentId === parent.id).length +
-			(parent.retiredChildren ?? 0) >=
-		policy.maxChildrenPerParent
-	)
-		throw new Error('Resident proposal parent child bound reached.')
-	const depth = (parent.origin?.depth ?? 0) + 1
-	if (depth > policy.maxDepth) throw new Error('Resident proposal depth bound reached.')
-	return Object.freeze(
-		residentProposalOriginSchema.parse({
-			proposalId: proposal.id,
-			parentId: proposal.parentId,
-			parentRevision: proposal.parentRevision,
-			domain: proposal.domain,
-			reason: proposal.reason,
-			evidenceKey: proposal.evidenceKey,
-			depth,
-		}),
-	)
-}