@namzu/sdk 61.3.0 → 62.0.0

package/src/manager/resident/tool-evidence.ts

@@ -1,455 +0,0 @@
-import { z } from 'zod'
-import {
-	evidenceSearchInput,
-	evidenceTermRefinement,
-	evidenceTermsSchema,
-} from '../../store/evidence/search-input.js'
-import { evidenceExclusionsSchema } from '../../store/evidence/selection.js'
-import type {
-	SessionEvidenceReadOptions,
-	SessionEvidenceReadResult,
-	SessionEvidenceSearchResult,
-	SessionEvidenceSource,
-} from '../../store/evidence/types.js'
-import type {
-	ResidentHistoryMatch,
-	ResidentHistoryScope,
-	ResidentHistorySource,
-} from './history.js'
-
-/**
- * @experimental Host authority for one pursuit, project and admission boundary.
- *
- * @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 ResidentToolEvidenceScope extends ResidentHistoryScope {
-	readonly projectId: string
-}
-/**
- * @experimental Identity of an agenda-verified settlement, not a fabricated transcript.
- *
- * @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 ResidentSettledInvocation = Pick<
-	ResidentHistoryMatch,
-	'revision' | 'claimId' | 'step' | 'kind'
->
-/**
- * @experimental Settlement is checked before the host resolves the attempt's invocation.
- *
- * @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 ResidentToolEvidenceOptions {
-	readonly history: ResidentHistorySource
-	readonly projectId: string
-	/** Host-enforced upper bound for resolveTurn's document reads, charged in full.
-	 * Required only when an operation supplies maxReadBytes. Zero asserts no
-	 * document reads. This is a declared bound, not a measured receipt.
-	 */
-	readonly resolutionReadBytes?: number
-	/**
-	 * The evidence of the one turn that performed a settled invocation. Its
-	 * scope must name that turn (`turnId` present): a source spanning a whole
-	 * session could answer with another turn's records.
-	 */
-	readonly resolveTurn: (
-		settled: ResidentSettledInvocation,
-		signal?: AbortSignal,
-	) => Promise<SessionEvidenceSource>
-}
-/**
- * @experimental An optional shared ceiling covers history, resolution and turn evidence.
- *
- * @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 ResidentToolEvidenceSearchOptions {
-	readonly query?: string
-	/** Token discovery: 1–16 terms, matched case-insensitively. Combined query/filter JSON ≤512 UTF-8 bytes. */
-	readonly terms?: readonly string[]
-	/** Omit successful retrieval copies before they consume candidate slots. */
-	readonly excludeSuccessfulTools?: readonly string[]
-	/** Omit query/terms/filter to continue the exact captured search. */
-	readonly cursor?: string
-	/** With a token cursor, continue using a strict subset of its terms. Requires
-	 * supportsTermRefinement. Scope, exclusions and the original cursor stay intact.
-	 */
-	readonly refineTerms?: readonly string[]
-	readonly maxReadBytes?: number
-}
-/**
- * @experimental Tool records from at most one settled invocation per bounded search page.
- *
- * @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 ResidentToolEvidenceSearchResult {
-	readonly scope: ResidentToolEvidenceScope
-	readonly revision: number | null
-	readonly claimId: string | null
-	readonly evidence: SessionEvidenceSearchResult | null
-	readonly nextCursor: string | null
-	readonly incomplete: boolean
-	readonly unavailableRevisions: readonly number[]
-	readonly historyBytes: number
-	/** Present for bounded calls: history + declared resolution + turn evidence reads.
-	 * Failed source reads without a receipt conservatively consume the remainder.
-	 */
-	readonly chargedBytes?: number
-}
-/**
- * @experimental The revision is authorized anew on every read, including after restart.
- *
- * @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 ResidentToolEvidenceReadOptions
-	extends Omit<SessionEvidenceReadOptions, 'maxReadBytes'> {
-	readonly revision: number
-	/** Shared operation ceiling, at most 8 MiB; reserves at least 1 MiB for turn evidence reads. */
-	readonly maxReadBytes?: number
-}
-/**
- * @experimental Exact invocation text plus the settled claim that authorized access.
- *
- * @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 ResidentToolEvidenceReadResult extends SessionEvidenceReadResult {
-	readonly revision: number
-	readonly claimId: string
-	readonly chargedBytes?: number
-}
-/**
- * @experimental A host must bind tool access to the executing turn, not just this source.
- *
- * @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 ResidentToolEvidenceSource {
-	readonly scope: ResidentToolEvidenceScope
-	readonly supportsTermRefinement?: boolean
-	search(
-		options?: ResidentToolEvidenceSearchOptions,
-		signal?: AbortSignal,
-	): Promise<ResidentToolEvidenceSearchResult>
-	read(
-		options: ResidentToolEvidenceReadOptions,
-		signal?: AbortSignal,
-	): Promise<ResidentToolEvidenceReadResult>
-}
-
-/**
- * @experimental Reuses the immutable agenda boundary; it never enumerates arbitrary sessions.
- *
- * @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 createResidentToolEvidenceSource(
-	options: ResidentToolEvidenceOptions,
-): ResidentToolEvidenceSource {
-	const { history, resolveTurn } = options
-	const resolutionReadBytes = z
-		.number()
-		.int()
-		.min(0)
-		.max(8 * 1024 * 1024)
-		.optional()
-		.parse(options.resolutionReadBytes)
-	function operationBudget(maxReadBytes: number | undefined) {
-		if (maxReadBytes === undefined) return undefined
-		if (resolutionReadBytes === undefined)
-			throw new Error('Bounded resident retrieval requires a declared resolution read bound.')
-		const limit = z
-			.number()
-			.int()
-			.positive()
-			.max(8 * 1024 * 1024)
-			.parse(maxReadBytes)
-		const historyLimit = limit - resolutionReadBytes - 1024 * 1024
-		if (historyLimit < 1)
-			throw new Error(
-				'Resident read budget cannot fit history, resolution and turn evidence reads.',
-			)
-		let charged = 0
-		return {
-			historyLimit,
-			get remaining() {
-				return limit - charged
-			},
-			get chargedBytes() {
-				return charged
-			},
-			charge(bytes: number, allowance: number) {
-				if (
-					!Number.isSafeInteger(bytes) ||
-					bytes < 0 ||
-					bytes > allowance ||
-					charged + bytes > limit
-				)
-					throw new Error('Resident evidence returned an invalid read budget receipt.')
-				charged += bytes
-			},
-			resolve() {
-				charged += resolutionReadBytes
-			},
-			exhaust() {
-				charged = limit
-			},
-		}
-	}
-	const scope = Object.freeze({
-		...history.scope,
-		projectId: z.string().uuid().parse(options.projectId),
-	})
-	const revision = z.number().int().min(1).max(scope.throughRevision).safe()
-	const searchSchema = z
-		.object({
-			query: z.string().max(256).optional(),
-			terms: evidenceTermsSchema,
-			excludeSuccessfulTools: evidenceExclusionsSchema.optional(),
-		})
-		.strict()
-	function searchInput(value: unknown) {
-		const parsed = searchSchema.parse(value)
-		const search = evidenceSearchInput({
-			...parsed,
-			...(parsed.terms ? { matchMode: 'token' as const } : {}),
-		})
-		const result: z.infer<typeof searchSchema> = {
-			...(search.terms ? { terms: search.terms } : { query: search.query }),
-			...(parsed.excludeSuccessfulTools?.length
-				? { excludeSuccessfulTools: [...new Set(parsed.excludeSuccessfulTools)].sort() }
-				: {}),
-		}
-		if (
-			(search.terms || result.excludeSuccessfulTools) &&
-			Buffer.byteLength(JSON.stringify(result)) > 512
-		)
-			throw new Error('Resident search terms and filters exceed 512 UTF-8 bytes.')
-		return result
-	}
-	const cursorBase = {
-		scope: z.literal(JSON.stringify(scope)),
-		revision,
-		turnCursor: z.string().max(4096).optional(),
-	}
-	const cursorSchema = z.discriminatedUnion('version', [
-		z.object({ ...cursorBase, version: z.literal(1), query: z.string().max(256) }).strict(),
-		z.object({ ...cursorBase, version: z.literal(2), search: searchSchema }).strict(),
-	])
-	const encode = (value: z.infer<typeof cursorSchema>) => {
-		const encoded = Buffer.from(JSON.stringify(cursorSchema.parse(value))).toString('base64url')
-		if (encoded.length > 8192) throw new Error('Resident continuation exceeds its encoded bound.')
-		return encoded
-	}
-	async function turn(entry: ResidentSettledInvocation, signal?: AbortSignal) {
-		signal?.throwIfAborted()
-		const source = await resolveTurn(entry, signal)
-		signal?.throwIfAborted()
-		if (source.scope.tenantId !== scope.tenantId || source.scope.projectId !== scope.projectId)
-			throw new Error('Historical invocation belongs to a different owner.')
-		const owner = z
-			.object({
-				tenantId: z.string().uuid(),
-				projectId: z.string().uuid(),
-				sessionId: z.string().uuid(),
-				turnId: z.string().uuid(),
-			})
-			.parse(source.scope)
-		return { source, owner }
-	}
-	function assertOwner(
-		page: { scope: SessionEvidenceSource['scope'] },
-		owner: SessionEvidenceSource['scope'],
-		signal?: AbortSignal,
-	) {
-		signal?.throwIfAborted()
-		if (
-			!page?.scope ||
-			Object.entries(owner).some(([key, value]) => page.scope[key as keyof typeof owner] !== value)
-		)
-			throw new Error('Historical evidence result belongs to a different owner.')
-	}
-	return Object.freeze({
-		scope,
-		supportsTermRefinement: true,
-		async search(input: ResidentToolEvidenceSearchOptions = {}, signal?: AbortSignal) {
-			signal?.throwIfAborted()
-			const budget = operationBudget(input.maxReadBytes)
-			const prior = input.cursor
-				? cursorSchema.parse(
-						JSON.parse(
-							Buffer.from(z.string().max(8192).parse(input.cursor), 'base64url').toString('utf8'),
-						),
-					)
-				: undefined
-			const supplied =
-				input.query !== undefined ||
-				input.terms !== undefined ||
-				input.excludeSuccessfulTools !== undefined
-			const previous = prior
-				? searchInput(prior.version === 1 ? { query: prior.query } : prior.search)
-				: undefined
-			const search =
-				supplied || !previous
-					? searchInput({
-							...(input.query !== undefined ? { query: input.query } : {}),
-							...(input.terms !== undefined ? { terms: input.terms } : {}),
-							...(input.excludeSuccessfulTools !== undefined
-								? { excludeSuccessfulTools: input.excludeSuccessfulTools }
-								: {}),
-						})
-					: previous
-			if (previous && JSON.stringify(previous) !== JSON.stringify(search))
-				throw new Error('Resident tool search query changed.')
-			const refined =
-				input.refineTerms !== undefined
-					? searchInput({
-							terms: evidenceTermRefinement(
-								{
-									terms: search.terms,
-									cursor: input.cursor,
-									matchMode: 'token',
-									caseSensitive: false,
-								},
-								input.refineTerms,
-							),
-							excludeSuccessfulTools: search.excludeSuccessfulTools,
-						})
-					: undefined
-			const cursor: z.infer<typeof cursorSchema> =
-				prior ??
-				(search.terms || search.excludeSuccessfulTools
-					? {
-							version: 2 as const,
-							scope: JSON.stringify(scope),
-							search,
-							revision: scope.throughRevision,
-						}
-					: {
-							version: 1 as const,
-							scope: JSON.stringify(scope),
-							query: search.query ?? '',
-							revision: scope.throughRevision,
-						})
-			let selected: ResidentSettledInvocation | null = null
-			const advancedCursor = refined ? { ...cursor, version: 2 as const, search: refined } : cursor
-			let nextRevision: number | null = null
-			let historyBytes = 0
-			const unavailable = new Set<number>()
-			if (cursor.turnCursor) {
-				const page = await history.read(
-					{
-						revision: cursor.revision,
-						part: 0,
-						...(budget ? { maxReadBytes: budget.historyLimit } : {}),
-					},
-					signal,
-				)
-				signal?.throwIfAborted()
-				budget?.charge(page.scannedBytes, budget.historyLimit)
-				selected = page.entry
-				historyBytes += page.scannedBytes
-				for (const missing of page.unavailableRevisions) unavailable.add(missing)
-				nextRevision = cursor.revision > 2 ? cursor.revision - 1 : null
-			} else {
-				const page = await history.search(
-					{
-						cursor: cursor.revision,
-						limit: 1,
-						...(budget ? { maxReadBytes: budget.historyLimit } : {}),
-					},
-					signal,
-				)
-				signal?.throwIfAborted()
-				budget?.charge(page.scannedBytes, budget.historyLimit)
-				historyBytes += page.scannedBytes
-				for (const missing of page.unavailableRevisions) unavailable.add(missing)
-				nextRevision = page.nextCursor
-				const match = page.matches[0]
-				// Browse always selects the settled summary (part 0). The bounded history
-				// source has already verified both sides of this settlement transition.
-				if (match) selected = match
-			}
-			let evidence: SessionEvidenceSearchResult | null = null
-			if (selected) {
-				try {
-					budget?.resolve()
-					const { source, owner } = await turn(selected, signal)
-					const narrowAtCursor =
-						!!refined && !!cursor.turnCursor && source.supportsTermRefinement === true
-					const page = await source.search(
-						{
-							...(refined && !narrowAtCursor ? refined : search),
-							...(search.terms ? { matchMode: 'token' as const, caseSensitive: false } : {}),
-							...(cursor.turnCursor && (!refined || narrowAtCursor)
-								? { cursor: cursor.turnCursor }
-								: {}),
-							...(narrowAtCursor ? { refineTerms: refined?.terms } : {}),
-							...(budget ? { maxReadBytes: budget.remaining } : {}),
-						},
-						signal,
-					)
-					assertOwner(page, owner, signal)
-					budget?.charge(page.scannedBytes, budget.remaining)
-					evidence = page
-				} catch {
-					signal?.throwIfAborted()
-					// A throwing host/source returned no reliable byte receipt. The
-					// caller must not reuse that allowance for another automatic page.
-					budget?.exhaust()
-					unavailable.add(selected.revision)
-				}
-			}
-			const nextCursor =
-				evidence?.nextCursor && selected
-					? encode({
-							...advancedCursor,
-							revision: selected.revision,
-							turnCursor: evidence.nextCursor,
-						})
-					: nextRevision
-						? encode({ ...advancedCursor, revision: nextRevision, turnCursor: undefined })
-						: null
-			return {
-				scope,
-				revision: selected?.revision ?? null,
-				claimId: selected?.claimId ?? null,
-				evidence,
-				nextCursor,
-				incomplete: unavailable.size > 0 || !!evidence?.incomplete || nextCursor !== null,
-				unavailableRevisions: [...unavailable],
-				historyBytes,
-				...(budget ? { chargedBytes: budget.chargedBytes } : {}),
-			}
-		},
-		async read(input: ResidentToolEvidenceReadOptions, signal?: AbortSignal) {
-			signal?.throwIfAborted()
-			const budget = operationBudget(input.maxReadBytes)
-			const page = await history.read(
-				{
-					revision: revision.parse(input.revision),
-					part: 0,
-					...(budget ? { maxReadBytes: budget.historyLimit } : {}),
-				},
-				signal,
-			)
-			signal?.throwIfAborted()
-			budget?.charge(page.scannedBytes, budget.historyLimit)
-			if (!page.entry) throw new Error('The requested settled claim is unavailable.')
-			budget?.resolve()
-			const { source, owner } = await turn(page.entry, signal)
-			const result = await source.read(
-				{
-					address: input.address,
-					...(input.byteOffset !== undefined ? { byteOffset: input.byteOffset } : {}),
-					...(budget ? { maxReadBytes: budget.remaining } : {}),
-				},
-				signal,
-			)
-			assertOwner(result, owner, signal)
-			budget?.charge(result.scannedBytes, budget.remaining)
-			return {
-				...result,
-				revision: page.entry.revision,
-				claimId: page.entry.claimId,
-				...(budget ? { chargedBytes: budget.chargedBytes } : {}),
-			}
-		},
-	})
-}

package/src/prompt/resident-learning.ts

@@ -1,152 +0,0 @@
-import { z } from 'zod'
-import { freezeLearning, projectLearning } from '../learning/skill.js'
-import { defineTool } from '../tools/defineTool.js'
-import type { ToolContext, ToolDefinition } from '../types/tool/index.js'
-import type { PromptContribution } from './contributions.js'
-import { type ResidentStepPromptOptions, createResidentStepContributions } from './resident-step.js'
-
-/**
- * @experimental One admission's context and read-only access to its evaluated guidance.
- *
- * @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 ResidentStepContextBundle {
-	readonly contributions: readonly PromptContribution[]
-	readonly tools: readonly ToolDefinition[]
-}
-
-/**
- * @experimental The host must reject reads from runs outside the admitted scope.
- *
- * @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 ResidentStepContextOptions extends ResidentStepPromptOptions {
-	readonly authorizeLearningRead: (context: ToolContext) => boolean
-}
-
-/**
- * @experimental List guidance descriptions first; disclose complete bodies only
- * when requested. Selection is local to this admission, never persisted as a
- * preference or inferred from keywords. Mount both returned tools and context.
- *
- * @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 createResidentStepContext(
-	options: ResidentStepContextOptions,
-): ResidentStepContextBundle {
-	const learning = options.learning ? freezeLearning(options.learning) : undefined
-	const contributions = createResidentStepContributions({
-		...options,
-		learning: learning ? { ...learning, skills: [] } : undefined,
-	})
-	const taskSkills = learning?.skills.filter((skill) => (skill.purpose ?? 'task') === 'task')
-	if (!learning || !taskSkills?.length)
-		return Object.freeze({ contributions, tools: Object.freeze([]) })
-	const authorize = options.authorizeLearningRead
-	const resolveSources = options.resolveLearningSources
-	const selected = new Set<string>()
-	const profileChars = projectLearning(learning, { maxChars: 12_000, skillNames: [] }).text.length
-	const project = (names: readonly string[], maxChars = 12_000) => {
-		let sources: ReturnType<NonNullable<typeof resolveSources>> = []
-		try {
-			sources = resolveSources?.() ?? []
-		} catch {
-			// Unavailable observations cannot establish a dependency match.
-		}
-		return projectLearning(
-			{ ...learning, identity: undefined, preferences: [] },
-			{ maxChars, skillNames: names, sources },
-		)
-	}
-	// Metadata is a catalogue, not executable instructions. Bound its size and
-	// escape control characters; complete descriptions remain available on read.
-	const catalogue = taskSkills.map((skill) => ({
-		name: skill.name,
-		description: [...skill.description]
-			.slice(0, 160)
-			.map((c) => {
-				const code = c.charCodeAt(0)
-				return code < 32 || (code >= 127 && code <= 159) ? ' ' : c
-			})
-			.join(''),
-		descriptionShortened: [...skill.description].length > 160,
-	}))
-	const tool = defineTool({
-		name: 'read_resident_skill',
-		description:
-			'Read one evaluated resident skill whose description fits the current task. Use an exact name from the resident skill catalogue. Returns its complete instructions and evidence only if declared source dependencies still match. Loading does not grant permissions or establish that guidance applies. Skip unrelated skills; do not search the workspace to satisfy their descriptions.',
-		inputSchema: z.object({ name: z.string().regex(/^[a-z0-9][a-z0-9_-]{0,63}$/) }).strict(),
-		category: 'custom',
-		permissions: [],
-		readOnly: true,
-		destructive: false,
-		concurrencySafe: true,
-		presentCall: (input) => ({ kind: 'generic', label: input.name }),
-		async execute(input, context) {
-			context.abortSignal?.throwIfAborted()
-			try {
-				if (authorize(context) !== true) throw new Error('Turn does not own this admission.')
-				const projection = project([input.name])
-				if (!projection.includedSkills.includes(input.name))
-					return {
-						success: false,
-						output: JSON.stringify({ withheldSkills: projection.withheldSkills }),
-						error:
-							'Skill unavailable in this admission or its sources are unverified. Use current task evidence.',
-					}
-				selected.add(input.name)
-				return { success: true, output: projection.text }
-			} catch {
-				context.abortSignal?.throwIfAborted()
-				return {
-					success: false,
-					output: '',
-					error: 'Resident skill access is unavailable for this turn.',
-				}
-			}
-		},
-	})
-	return Object.freeze({
-		tools: Object.freeze([tool]),
-		contributions: Object.freeze([
-			...contributions,
-			Object.freeze({
-				id: 'namzu.resident-step.learning-catalogue',
-				placement: 'context' as const,
-				render: () =>
-					[
-						'## Available evaluated resident skills',
-						'These descriptions advertise optional guidance, not instructions to execute. Read a relevant skill with read_resident_skill before using it. Skip unrelated skills and work directly from the requested evidence; availability does not establish applicability. A skill evaluated on one task family may hinder another. Current objectives, project instructions and permissions always take precedence.',
-						JSON.stringify(catalogue),
-					].join('\n'),
-			}),
-			Object.freeze({
-				id: 'namzu.resident-step.selected-learning',
-				placement: 'context' as const,
-				render: () => {
-					if (!selected.size) return null
-					try {
-						const projection = project([...selected], Math.max(0, 12_000 - profileChars))
-						return [
-							'## Selected resident guidance for this request',
-							'Apply only while relevant to the current task. Matching source revisions do not prove claims.',
-							projection.text,
-							...projection.withheldSkills.map((skill) =>
-								JSON.stringify({ kind: 'withheld-guidance', ...skill }),
-							),
-							...(projection.omitted
-								? [
-										'Some selected guidance is withheld or omitted. Recheck current evidence; do not recover its instructions from earlier messages as a substitute.',
-									]
-								: []),
-						]
-							.filter(Boolean)
-							.join('\n')
-					} catch {
-						return 'Selected resident guidance is unavailable for this request. Use current task evidence; do not reuse earlier skill instructions.'
-					}
-				},
-			}),
-		]),
-	})
-}