@namzu/sdk 38.2.1 → 39.0.0

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

@@ -0,0 +1,412 @@
+import { z } from 'zod'
+import {
+	evidenceSearchInput,
+	evidenceTermRefinement,
+	evidenceTermsSchema,
+} from '../../store/evidence/search-input.js'
+import { evidenceExclusionsSchema } from '../../store/evidence/selection.js'
+import type {
+	RunEvidenceReadOptions,
+	RunEvidenceReadResult,
+	RunEvidenceSearchResult,
+	RunEvidenceSource,
+} from '../../store/evidence/types.js'
+import type {
+	ResidentHistoryMatch,
+	ResidentHistoryScope,
+	ResidentHistorySource,
+} from './history.js'
+
+/** @experimental Host authority for one pursuit, project and admission boundary. */
+export interface ResidentToolEvidenceScope extends ResidentHistoryScope {
+	readonly projectId: string
+}
+/** @experimental Identity of an agenda-verified settlement, not a fabricated transcript. */
+export type ResidentSettledInvocation = Pick<
+	ResidentHistoryMatch,
+	'revision' | 'claimId' | 'step' | 'kind'
+>
+/** @experimental Settlement is checked before the host resolves the attempt's invocation. */
+export interface ResidentToolEvidenceOptions {
+	readonly history: ResidentHistorySource
+	readonly projectId: string
+	/** Host-enforced upper bound for resolveRun'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
+	readonly resolveRun: (
+		settled: ResidentSettledInvocation,
+		signal?: AbortSignal,
+	) => Promise<RunEvidenceSource>
+}
+/** @experimental An optional shared ceiling covers history, resolution and run evidence. */
+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. */
+export interface ResidentToolEvidenceSearchResult {
+	readonly scope: ResidentToolEvidenceScope
+	readonly revision: number | null
+	readonly claimId: string | null
+	readonly evidence: RunEvidenceSearchResult | null
+	readonly nextCursor: string | null
+	readonly incomplete: boolean
+	readonly unavailableRevisions: readonly number[]
+	readonly historyBytes: number
+	/** Present for bounded calls: history + declared resolution + run 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. */
+export interface ResidentToolEvidenceReadOptions
+	extends Omit<RunEvidenceReadOptions, 'maxReadBytes'> {
+	readonly revision: number
+	/** Shared operation ceiling, at most 8 MiB; reserves at least 1 MiB for run reads. */
+	readonly maxReadBytes?: number
+}
+/** @experimental Exact invocation text plus the settled claim that authorized access. */
+export interface ResidentToolEvidenceReadResult extends RunEvidenceReadResult {
+	readonly revision: number
+	readonly claimId: string
+	readonly chargedBytes?: number
+}
+/** @experimental A host must bind tool access to the executing run, not just this source. */
+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. */
+export function createResidentToolEvidenceSource(
+	options: ResidentToolEvidenceOptions,
+): ResidentToolEvidenceSource {
+	const { history, resolveRun } = 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 run 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,
+		runCursor: 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 run(entry: ResidentSettledInvocation, signal?: AbortSignal) {
+		signal?.throwIfAborted()
+		const source = await resolveRun(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(),
+				runId: z.string().uuid(),
+			})
+			.parse(source.scope)
+		return { source, owner }
+	}
+	function assertOwner(
+		page: { scope: RunEvidenceSource['scope'] },
+		owner: RunEvidenceSource['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.runCursor) {
+				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: RunEvidenceSearchResult | null = null
+			if (selected) {
+				try {
+					budget?.resolve()
+					const { source, owner } = await run(selected, signal)
+					const narrowAtCursor =
+						!!refined && !!cursor.runCursor && source.supportsTermRefinement === true
+					const page = await source.search(
+						{
+							...(refined && !narrowAtCursor ? refined : search),
+							...(search.terms ? { matchMode: 'token' as const, caseSensitive: false } : {}),
+							...(cursor.runCursor && (!refined || narrowAtCursor)
+								? { cursor: cursor.runCursor }
+								: {}),
+							...(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,
+							runCursor: evidence.nextCursor,
+						})
+					: nextRevision
+						? encode({ ...advancedCursor, revision: nextRevision, runCursor: 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 run(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/manager/run/persistence.ts

@@ -104,6 +104,12 @@ export class RunPersistence {
 			id: config.runId,
 			status: 'idle',
 			metadata: {
+				scope: {
+					tenantId: config.tenantId,
+					projectId: config.projectId,
+					sessionId: config.sessionId,
+					runId: config.runId,
+				},
 				agentId: config.agentId,
 				agentName: config.agentName,
 				config: config.runConfig,

package/src/plugin/loader.ts

@@ -268,7 +268,10 @@ export async function discoverAllPluginDirs(
 	const projectRoot = workingDirectory ?? process.cwd()
 	const userRoot = options?.userRoot ?? homedir()
 	const userPluginDir = options?.userRoot ? 'plugins' : USER_PLUGIN_DIR
-	const sharedRoot = await samePhysicalDirectory(projectRoot, userRoot)
+	const sharedRoot = await samePhysicalDirectory(
+		join(projectRoot, PROJECT_PLUGIN_DIR),
+		join(userRoot, userPluginDir),
+	)
 
 	const [project, user] = await Promise.all([
 		mayScan('project') && !sharedRoot
@@ -290,11 +293,13 @@ export async function discoverAllPluginDirs(
 }
 
 /**
- * Whether two scope roots name the same directory, including through a
+ * Whether two plugin directories name the same directory, including through a
  * symlink. When home is the working directory, `.namzu/plugins` is user state:
  * treating the same bytes as project state would let a project-only trust
  * policy admit user-owned executable code, while scanning both installs it
- * twice. Missing roots fall back to normalized absolute names; discovery will
+ * twice. Hosts may pass the application home rather than the OS home, so the
+ * comparison includes each scope's relative plugin path. Missing directories
+ * fall back to normalized absolute names; discovery will
  * independently report them empty.
  */
 async function samePhysicalDirectory(left: string, right: string): Promise<boolean> {

package/src/prompt/coding-agent-doctrine.ts

@@ -45,6 +45,7 @@ export const CODING_AGENT_WORKING_DOCTRINE = `## How you work
 
 ### Reporting
 - Report outcomes faithfully. If tests fail, say so and show the output. If you skipped a step, say it was skipped. When something is done and verified, state it plainly without hedging.
+- Preserve exact identifiers when reporting evidence. Do not translate, normalize or correct their spelling.
 - Never present a green run on a subset as a green run. Name what was actually executed.
 - Reference code as \`path:line\` so the user can jump to it.
 - Correct an earlier statement only when the error would change the user's code, conclusions or decisions; state it once, plainly, and continue. No apologies, no tally of past mistakes.
@@ -52,6 +53,7 @@ export const CODING_AGENT_WORKING_DOCTRINE = `## How you work
 ### Using available evidence
 - Carry the active task and established facts across turns. A question or status request during ongoing work does not cancel that work unless the user says so. Ask for clarification when the intended change is genuinely unspecified; do not ask the user to repeat information already available.
 - Treat a successful tool result together with its exact inputs as evidence of what happened. Content you successfully wrote is available evidence, just like content you read. An announced action, proposed call, failed call, or another agent's unsupported claim is not proof of completion.
+- Match the source to the time the question asks about. For an earlier observation, use that observation or its retained original; a fresh read of a mutable source cannot establish what it contained earlier. For current state or a new action, check freshness as needed. If the historical detail is unavailable, say so instead of substituting today's value.
 - Reuse relevant evidence still available in conversation instead of observing it again by habit. Distinguish the last observed state from a guarantee that external state has not changed. Re-observe when evidence is missing, partial or invalidated, when another actor may have changed the target, or when freshness matters to the next action. If a check or exact-match edit reports a mismatch, inspect the current state and revise the action; do not force the old plan through.
 - When an observation is needed, ask the narrowest question that resolves the uncertainty. For a known file, inspect that file rather than listing the whole working directory. Recover missing observations with read-only tools, not by repeating a state-changing action.
 

package/src/prompt/index.ts

@@ -23,3 +23,5 @@ export {
 export type { CodingAgentDoctrineOptions } from './coding-agent-doctrine.js'
 export { createResidentStepContributions } from './resident-step.js'
 export type { ResidentStepPromptOptions } from './resident-step.js'
+export { createResidentStepContext } from './resident-learning.js'
+export type { ResidentStepContextOptions, ResidentStepContextBundle } from './resident-learning.js'

package/src/prompt/resident-learning.ts

@@ -0,0 +1,143 @@
+import { z } from 'zod'
+import { freezeResidentLearning, projectResidentLearning } from '../manager/resident/learning.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. */
+export interface ResidentStepContextBundle {
+	readonly contributions: readonly PromptContribution[]
+	readonly tools: readonly ToolDefinition[]
+}
+
+/** @experimental The host must reject reads from runs outside the admitted scope. */
+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.
+ */
+export function createResidentStepContext(
+	options: ResidentStepContextOptions,
+): ResidentStepContextBundle {
+	const learning = options.learning ? freezeResidentLearning(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 = projectResidentLearning(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 projectResidentLearning(
+			{ ...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('Run 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 run.',
+				}
+			}
+		},
+	})
+	return Object.freeze({
+		tools: Object.freeze([tool]),
+		contributions: Object.freeze([
+			...contributions,
+			Object.freeze({
+				id: 'namzu.resident-step.learning-catalogue',
+				placement: 'dynamic' 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: 'turn' 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.'
+					}
+				},
+			}),
+		]),
+	})
+}