@hobin/developer 0.1.9 → 0.1.11

package/extensions/developer.ts

@@ -18,6 +18,19 @@ import {
 import { Container, Markdown, Text } from "@earendil-works/pi-tui";
 import { Type, type Static } from "typebox";
 
+import {
+	COMPACTION_LANGUAGE_ENTRY,
+	applyCompactionLanguageEvent,
+	continuityConsumed,
+	continuityPending,
+	detectStrongUserLanguage,
+	initialCompactionLanguageState,
+	languageObserved,
+	projectCompactionContinuity,
+	reconstructCompactionLanguage,
+	settlementContinuityEvent,
+	type CompactionLanguageState,
+} from "./compaction-language.ts";
 import {
 	availablePackageSkills,
 	isWithinRoot,
@@ -40,6 +53,7 @@ import {
 	applyDeveloperEvent,
 	canApplyDeveloperEvent,
 	developerSnapshot,
+	formatInvariantHandling,
 	initialState,
 	normalizeDeveloperEvent,
 	parseChoiceResponseSpec,
@@ -49,6 +63,7 @@ import {
 	type ChoiceResponseSpec,
 	type DeveloperState,
 	type ImplementationProfile,
+	type InvariantHandling,
 	type FocusEvent,
 	type JudgmentEvent,
 	type PendingQuestion,
@@ -202,6 +217,59 @@ interface ChoiceResponseSpecInput {
 	fields: ChoiceResponseFieldInput[];
 }
 
+type InvariantHandlingInput =
+	| {
+			kind: "not-applicable";
+			reason: string;
+	  }
+	| {
+			kind: "evidence-preserving-boundary";
+			raw_representation: string;
+			refined_representation: string;
+			producer: string;
+			failure: string;
+			first_effect: string;
+	  }
+	| {
+			kind: "trusted-compiler-gap";
+			assertion: string;
+			established_by: string;
+			limitation: string;
+			containment: string;
+			verification: string;
+	  };
+
+function invariantHandlingFromInput(
+	input: InvariantHandlingInput | undefined,
+): InvariantHandling {
+	if (!input) {
+		return {
+			kind: "not-applicable",
+			reason:
+				"Legacy direct tool execution omitted the now-required invariant-handling declaration.",
+		};
+	}
+	if (input.kind === "not-applicable") return input;
+	if (input.kind === "evidence-preserving-boundary") {
+		return {
+			kind: input.kind,
+			rawRepresentation: input.raw_representation,
+			refinedRepresentation: input.refined_representation,
+			producer: input.producer,
+			failure: input.failure,
+			firstEffect: input.first_effect,
+		};
+	}
+	return {
+		kind: input.kind,
+		assertion: input.assertion,
+		establishedBy: input.established_by,
+		limitation: input.limitation,
+		containment: input.containment,
+		verification: input.verification,
+	};
+}
+
 interface OpenQuestionInput {
 	question: string;
 	context?: string;
@@ -449,7 +517,9 @@ function protocolPrompt(
 		"- Adapt away from that topology when evidence makes a stage not applicable, but never jump directly from a resolved model to mutation: use sketch for feature implementation or signal for existing-code structural movement first.",
 		"- Route by the requested work product, not keywords: use sketch to create an original caller-facing interface, representation boundary, ownership map, or collaboration; use abstraction-review only when a concrete candidate surface already exists to keep/revise/split/reject/defer; use model first only when unresolved cases, rules, or policy can materially change that surface.",
 		`- Call ${ROUTE_TOOL} for exactly one concrete judgment or one green-to-green implementation movement.`,
-		"- Use target=implementation only when the next local movement, stable landing, and narrow verification are already justified; otherwise choose the focused skill whose scope fits the current question.",
+		"- Use target=implementation only when the next local movement, stable landing, narrow verification, and invariant handling are already justified; otherwise choose the focused skill whose scope fits the current question.",
+		"- Invariant gate: an unchecked assertion, cast, non-null claim, ignored conversion result, or typed deserialization target is not evidence that broader, external, persisted, legacy, or otherwise less-trusted input satisfies a domain invariant. Parse or construct a refined value whose success carries the learned information before dependent effects; validation followed by narrowing does not satisfy this gate.",
+		"- Every implementation route must classify invariant handling as not applicable, an evidence-preserving boundary, or a trusted compiler gap. A trusted compiler gap is valid only after a complete check or trusted contract already established the fact, the language cannot retain it, the unsafe operation is isolated to one owner, and a falsifier is named. Encountering a missing boundary requires sketch, not an implementation assertion.",
 		"- An implementation step has one observable difference and one structural or behavioral purpose. Stop when its failure is locally explainable and the repository is green, pausable, and reviewable.",
 		"- For implementation structural work intended to preserve behavior, set execution_profile=behavior-preserving-structure; omit the field for other implementation actions and every skill route.",
 		`- Follow the routed method, then close the route with ${JUDGMENT_TOOL}. After every implementation stable landing, route again from the new evidence before selecting another movement.`,
@@ -498,6 +568,11 @@ function protocolPrompt(
 		lines.push(
 			`Active route: ${state.activeRoute.routeId} · ${state.activeRoute.target} · ${state.activeRoute.question}`,
 		);
+		if (state.activeRoute.implementationStep) {
+			lines.push(
+				`Active invariant handling: ${formatInvariantHandling(state.activeRoute.implementationStep.invariantHandling)}. Stop and route sketch instead of mutating if this declaration is contradicted by the code.`,
+			);
+		}
 		if (state.activeRoute.methodLocation) {
 			lines.push(
 				`Active skill location: ${state.activeRoute.methodLocation}. Read it again if compaction or a later turn no longer contains the full instructions.`,
@@ -621,6 +696,8 @@ function expandedJudgment(
 export default async function developer(pi: ExtensionAPI) {
 	let availableSkills = new Map<string, Skill>();
 	let state = initialState();
+	let compactionLanguage: CompactionLanguageState =
+		initialCompactionLanguageState();
 	let routeOpening = false;
 	const routesWithMutation = new Set<string>();
 	let toolPolicyMemory: ToolPolicyMemory = { withheldBuiltins: new Set() };
@@ -732,9 +809,11 @@ export default async function developer(pi: ExtensionAPI) {
 	};
 
 	const reconstruct = (ctx: ExtensionContext) => {
+		const branch = ctx.sessionManager.getBranch();
 		state = toolPolicyRestartRequired
 			? initialState()
-			: reconstructState(ctx.sessionManager.getBranch());
+			: reconstructState(branch);
+		compactionLanguage = reconstructCompactionLanguage(branch);
 		syncProtocolTools();
 		refreshUI(ctx);
 	};
@@ -752,6 +831,16 @@ export default async function developer(pi: ExtensionAPI) {
 		};
 		pi.appendEntry(ACTIVATION_ENTRY, event);
 		state = applyDeveloperEvent(state, event);
+		if (!enabled && compactionLanguage.pending) {
+			const consumed = continuityConsumed(
+				compactionLanguage.pending.compactionId,
+			);
+			pi.appendEntry(COMPACTION_LANGUAGE_ENTRY, consumed);
+			compactionLanguage = applyCompactionLanguageEvent(
+				compactionLanguage,
+				consumed,
+			);
+		}
 		syncProtocolTools();
 		refreshUI(ctx);
 		return true;
@@ -798,6 +887,83 @@ export default async function developer(pi: ExtensionAPI) {
 		},
 		{ additionalProperties: false },
 	);
+	const InvariantHandlingParam = Type.Union([
+		Type.Object(
+			{
+				kind: Type.Literal("not-applicable"),
+				reason: Type.String({
+					minLength: 1,
+					maxLength: MAX_EVIDENCE_CHARS,
+					description:
+						"Why this movement neither creates nor narrows broader or less-trusted data into an invariant-carrying value",
+				}),
+			},
+			{ additionalProperties: false },
+		),
+		Type.Object(
+			{
+				kind: Type.Literal("evidence-preserving-boundary"),
+				raw_representation: Type.String({
+					minLength: 1,
+					maxLength: MAX_EVIDENCE_CHARS,
+				}),
+				refined_representation: Type.String({
+					minLength: 1,
+					maxLength: MAX_EVIDENCE_CHARS,
+				}),
+				producer: Type.String({
+					minLength: 1,
+					maxLength: MAX_EVIDENCE_CHARS,
+					description:
+						"Parser, refinement function, or smart constructor whose success returns the refined value",
+				}),
+				failure: Type.String({
+					minLength: 1,
+					maxLength: MAX_EVIDENCE_CHARS,
+				}),
+				first_effect: Type.String({
+					minLength: 1,
+					maxLength: MAX_EVIDENCE_CHARS,
+					description:
+						"First dependent domain effect allowed only after successful refinement",
+				}),
+			},
+			{ additionalProperties: false },
+		),
+		Type.Object(
+			{
+				kind: Type.Literal("trusted-compiler-gap"),
+				assertion: Type.String({
+					minLength: 1,
+					maxLength: MAX_EVIDENCE_CHARS,
+				}),
+				established_by: Type.String({
+					minLength: 1,
+					maxLength: MAX_EVIDENCE_CHARS,
+					description:
+						"Complete check or trusted runtime contract that already established the asserted fact",
+				}),
+				limitation: Type.String({
+					minLength: 1,
+					maxLength: MAX_EVIDENCE_CHARS,
+					description:
+						"Why ordinary language narrowing cannot retain the established fact",
+				}),
+				containment: Type.String({
+					minLength: 1,
+					maxLength: MAX_EVIDENCE_CHARS,
+					description: "Single parser or constructor owner containing the gap",
+				}),
+				verification: Type.String({
+					minLength: 1,
+					maxLength: MAX_EVIDENCE_CHARS,
+					description:
+						"Falsifier for the claimed prior evidence and containment",
+				}),
+			},
+			{ additionalProperties: false },
+		),
+	]);
 	const RouteParams = Type.Union([
 		Type.Object(
 			{
@@ -840,6 +1006,7 @@ export default async function developer(pi: ExtensionAPI) {
 					description:
 						"The narrowest check that can catch the likely break in this movement",
 				}),
+				invariant_handling: InvariantHandlingParam,
 				alternatives_considered: Type.Optional(
 					Type.Array(RouteAlternativeParam, {
 						maxItems: 6,
@@ -865,11 +1032,11 @@ export default async function developer(pi: ExtensionAPI) {
 		name: ROUTE_TOOL,
 		label: "Developer Route Question",
 		description:
-			"Route one concrete judgment or one green-to-green implementation movement. Route by work product: sketch creates an original design surface, abstraction-review judges an already-shaped candidate, and model settles unresolved conditions before design. Then use implementation stable landings and verify before completion.",
+			"Route one concrete judgment or one green-to-green implementation movement. Route by work product: sketch creates an original design surface, abstraction-review judges an already-shaped candidate, and model settles unresolved conditions before design. Implementation must declare how invariant-bearing values are constructed without unchecked narrowing. Then use stable landings and verify before completion.",
 		promptSnippet: "Choose how to handle one development question",
 		promptGuidelines: [
 			`Call ${ROUTE_TOOL} only when there is no active Developer route.`,
-			`Use ${ROUTE_TOOL} with the most focused skill supported by current evidence; choose sketch for an original interface or boundary, abstraction-review only for an already-shaped candidate, and model only for unresolved condition space. target=implementation requires one movement, one stable landing, and one narrow verification.`,
+			`Use ${ROUTE_TOOL} with the most focused skill supported by current evidence; choose sketch for an original interface or boundary, abstraction-review only for an already-shaped candidate, and model only for unresolved condition space. target=implementation requires one movement, one stable landing, one narrow verification, and a truthful invariant_handling declaration. Validation followed by an assertion is not an evidence-preserving boundary.`,
 			`When ${ROUTE_TOOL} follows an implementation judgment with another implementation route, cite the previous landing in known_evidence and record plausible skill routes in alternatives_considered instead of selecting implementation by momentum.`,
 			`After a resolved model, use sketch for first feature implementation framing or signal for existing-code structural movement before implementation mutation.`,
 		],
@@ -1014,6 +1181,10 @@ export default async function developer(pi: ExtensionAPI) {
 						"# Implementation action",
 						"",
 						"The next local action is already justified. Keep this route open while using Pi implementation tools and collecting evidence.",
+						"",
+						"## Invariant gate",
+						"",
+						"Follow the route's invariant-handling declaration. Broader or less-trusted input must become an invariant-carrying value through a parser, refinement function, or smart constructor before dependent effects. Validation followed by an assertion, cast, non-null claim, ignored conversion result, or typed decode is not evidence. If the declared handling is incomplete, stop without mutation and route sketch. Keep any trusted compiler gap isolated to its declared owner and verify its prior evidence and containment.",
 					].join("\n");
 				}
 
@@ -1032,6 +1203,11 @@ export default async function developer(pi: ExtensionAPI) {
 									? params.verification
 									: "Run the narrowest relevant check and inspect the resulting diff or output."
 								).trim(),
+								invariantHandling: invariantHandlingFromInput(
+									"invariant_handling" in params
+										? params.invariant_handling
+										: undefined,
+								),
 							}
 						: undefined;
 
@@ -1069,6 +1245,7 @@ export default async function developer(pi: ExtensionAPI) {
 								`Movement: ${implementationStep.movement}`,
 								`Stable landing: ${implementationStep.stopCondition}`,
 								`Narrow verification: ${implementationStep.verification}`,
+								`Invariant handling: ${formatInvariantHandling(implementationStep.invariantHandling)}`,
 								"Stop this implementation route at that landing, record the evidence, and route again before another movement.",
 							]
 						: []),
@@ -1146,7 +1323,8 @@ export default async function developer(pi: ExtensionAPI) {
 					context.lastComponent,
 				);
 			}
-			const event = result.details as RouteEvent | undefined;
+			const normalized = normalizeDeveloperEvent(result.details);
+			const event = normalized?.kind === "route" ? normalized : undefined;
 			let text = theme.fg("success", `routed ${routeRenderText(event)}`);
 			if (expanded && event) {
 				text += `\n${detailLine(theme, "route", event.routeId, "text")}`;
@@ -1180,6 +1358,7 @@ export default async function developer(pi: ExtensionAPI) {
 					text += `\n${detailLine(theme, "movement", event.implementationStep.movement, "text")}`;
 					text += `\n${detailLine(theme, "landing", event.implementationStep.stopCondition)}`;
 					text += `\n${detailLine(theme, "verify", event.implementationStep.verification)}`;
+					text += `\n${detailLine(theme, "invariant", formatInvariantHandling(event.implementationStep.invariantHandling))}`;
 				}
 			}
 			if (!expanded && event)
@@ -1355,7 +1534,9 @@ export default async function developer(pi: ExtensionAPI) {
 					context.lastComponent,
 				);
 			}
-			const event = result.details as ReferenceLoadEvent | undefined;
+			const normalized = normalizeDeveloperEvent(result.details);
+			const event =
+				normalized?.kind === "reference-load" ? normalized : undefined;
 			let text = theme.fg(
 				"success",
 				`loaded ${event?.path ?? "Developer reference"}`,
@@ -1984,7 +2165,8 @@ export default async function developer(pi: ExtensionAPI) {
 					context.lastComponent,
 				);
 			}
-			const event = result.details as JudgmentEvent | undefined;
+			const normalized = normalizeDeveloperEvent(result.details);
+			const event = normalized?.kind === "judgment" ? normalized : undefined;
 			const summary = judgmentRenderText(event);
 			let text =
 				event?.status === "resolved"
@@ -2274,6 +2456,41 @@ export default async function developer(pi: ExtensionAPI) {
 		},
 	);
 
+	pi.on("input", (event) => {
+		if (!state.enabled) return;
+		const tag = detectStrongUserLanguage(event.text, event.source);
+		if (!tag || tag === compactionLanguage.language) return;
+		const observed = languageObserved(tag);
+		pi.appendEntry(COMPACTION_LANGUAGE_ENTRY, observed);
+		compactionLanguage = applyCompactionLanguageEvent(
+			compactionLanguage,
+			observed,
+		);
+	});
+
+	pi.on("session_compact", (event) => {
+		if (!state.enabled || !compactionLanguage.language) return;
+		const pending = continuityPending(
+			event.compactionEntry.id,
+			compactionLanguage.language,
+		);
+		const next = applyCompactionLanguageEvent(compactionLanguage, pending);
+		if (next === compactionLanguage) return;
+		pi.appendEntry(COMPACTION_LANGUAGE_ENTRY, pending);
+		compactionLanguage = next;
+	});
+
+	pi.on("context", (event) => {
+		if (!state.enabled) return;
+		const projection = projectCompactionContinuity(
+			event.messages,
+			compactionLanguage,
+		);
+		if (!projection) return;
+		compactionLanguage = projection.state;
+		return { messages: projection.messages as typeof event.messages };
+	});
+
 	pi.on("before_agent_start", (event) => {
 		availableSkills = availablePackageSkills(
 			event.systemPromptOptions.skills ?? [],
@@ -2373,7 +2590,17 @@ export default async function developer(pi: ExtensionAPI) {
 		if (startEnabled === true && !state.enabled) setEnabled(true, ctx);
 	});
 	pi.on("session_tree", (_event, ctx) => reconstruct(ctx));
-	pi.on("agent_settled", (_event, ctx) => refreshUI(ctx));
+	pi.on("agent_settled", (_event, ctx) => {
+		const consumed = settlementContinuityEvent(compactionLanguage);
+		if (consumed) {
+			pi.appendEntry(COMPACTION_LANGUAGE_ENTRY, consumed);
+			compactionLanguage = applyCompactionLanguageEvent(
+				compactionLanguage,
+				consumed,
+			);
+		}
+		refreshUI(ctx);
+	});
 	pi.on("session_shutdown", (_event, ctx) => {
 		releaseProtocolTools();
 		if (!toolPolicyRestartRequired) {

package/extensions/references/behavior-preserving-structural-change.md

@@ -46,7 +46,10 @@ For movement across a boundary, update one sender or caller at a time when the
 old and new forms can safely coexist. Confirm that each intermediate state is
 valid. Do not rely on a final large diff to explain which step changed behavior.
 A forwarding interface over the old implementation can be a temporary seam, but
-it is not evidence that the interface is a stable public abstraction.
+it is not evidence that the interface is a stable public abstraction. An
+assertion, cast, non-null claim, or unchecked typed decode is not a compatibility
+seam: if old or external data is broader than the new invariant, an adapter must
+parse and return the new representation or explicit failure.
 
 For suspected dead code, combine static references, dynamic reachability, and a
 scoped observation window appropriate to rare jobs, reflection, configuration,
@@ -192,10 +195,15 @@ The protocol is being misused when:
 - behavior work is hidden inside a structural label;
 - the route continues after a new human-owned policy question appears;
 - an intermediate state cannot safely run or be reviewed;
-- cleanup continues past the accepted pressure because the code could be nicer.
+- cleanup continues past the accepted pressure because the code could be nicer;
+- validation is preserved while its result is discarded and an assertion claims
+  the new representation.
 
 ## Source Trace
 
+- Alexis King, “Parse, don’t validate,” published November 5, 2019, for
+  evidence-preserving refinement before execution. The compatibility-seam and
+  migration wording is a Developer adaptation.
 - Sandi Metz, Katrina Owen, and TJ Stankus, *99 Bottles of OOP*, Second
   Edition, version 2.2.2, 2024: Chapters 3-5, pp. 51-137, especially
   pp. 58-71, 84-101, and 113-125, on methodical transformations, flocking,

package/extensions/skills.ts

@@ -86,13 +86,17 @@ export function availablePackageSkills(
 	return available;
 }
 
+function hasErrorCode(error: unknown, code: string): boolean {
+	return isRecord(error) && error.code === code;
+}
+
 export async function skillReferencePaths(skill: Skill): Promise<string[]> {
 	const referencesRoot = resolve(skill.baseDir, "references");
 	let entries: Dirent[];
 	try {
 		entries = await readdir(referencesRoot, { withFileTypes: true });
 	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return [];
+		if (hasErrorCode(error, "ENOENT")) return [];
 		throw error;
 	}
 
@@ -248,7 +252,7 @@ export async function loadSkillReferencePolicy(
 	try {
 		source = await readFile(policyPath, "utf8");
 	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+		if (hasErrorCode(error, "ENOENT")) {
 			if (catalog.length > 0) {
 				throw new Error(
 					`Developer skill ${skill.name} has references but no reference-policy.json.`,

package/extensions/state.ts

@@ -46,6 +46,36 @@ export type QuestionUpdateStatus =
 export type ImplementationProfile =
 	| "ordinary"
 	| "behavior-preserving-structure";
+export type InvariantHandling =
+	| {
+			kind: "not-applicable";
+			reason: string;
+	  }
+	| {
+			kind: "evidence-preserving-boundary";
+			rawRepresentation: string;
+			refinedRepresentation: string;
+			producer: string;
+			failure: string;
+			firstEffect: string;
+	  }
+	| {
+			kind: "trusted-compiler-gap";
+			assertion: string;
+			establishedBy: string;
+			limitation: string;
+			containment: string;
+			verification: string;
+	  };
+
+export function formatInvariantHandling(value: InvariantHandling): string {
+	if (value.kind === "not-applicable")
+		return `not applicable — ${value.reason}`;
+	if (value.kind === "evidence-preserving-boundary") {
+		return `${value.rawRepresentation} -> ${value.refinedRepresentation} via ${value.producer}; failure=${value.failure}; first effect=${value.firstEffect}`;
+	}
+	return `trusted compiler gap — ${value.assertion}; established by ${value.establishedBy}; limitation=${value.limitation}; contained at ${value.containment}; check=${value.verification}`;
+}
 
 export interface ActivationEvent {
 	protocol: typeof PROTOCOL;
@@ -63,6 +93,7 @@ export interface ImplementationStepContract {
 	movement: string;
 	stopCondition: string;
 	verification: string;
+	invariantHandling: InvariantHandling;
 }
 
 export interface RouteAlternative {
@@ -248,6 +279,20 @@ function isStringArray(value: unknown): value is string[] {
 	);
 }
 
+function parseArray<T>(
+	value: unknown,
+	parse: (item: unknown) => T | undefined,
+): T[] | undefined {
+	if (!Array.isArray(value)) return undefined;
+	const parsed: T[] = [];
+	for (const item of value) {
+		const result = parse(item);
+		if (result === undefined) return undefined;
+		parsed.push(result);
+	}
+	return parsed;
+}
+
 function isJudgmentStatus(value: unknown): value is JudgmentStatus {
 	return (
 		value === "resolved" ||
@@ -263,6 +308,51 @@ function isImplementationProfile(
 	return value === "ordinary" || value === "behavior-preserving-structure";
 }
 
+function parseInvariantHandling(value: unknown): InvariantHandling | undefined {
+	if (!isObject(value) || typeof value.kind !== "string") return undefined;
+	if (value.kind === "not-applicable") {
+		if (typeof value.reason !== "string") return undefined;
+		return { kind: value.kind, reason: value.reason };
+	}
+	if (value.kind === "evidence-preserving-boundary") {
+		if (
+			typeof value.rawRepresentation !== "string" ||
+			typeof value.refinedRepresentation !== "string" ||
+			typeof value.producer !== "string" ||
+			typeof value.failure !== "string" ||
+			typeof value.firstEffect !== "string"
+		) {
+			return undefined;
+		}
+		return {
+			kind: value.kind,
+			rawRepresentation: value.rawRepresentation,
+			refinedRepresentation: value.refinedRepresentation,
+			producer: value.producer,
+			failure: value.failure,
+			firstEffect: value.firstEffect,
+		};
+	}
+	if (value.kind !== "trusted-compiler-gap") return undefined;
+	if (
+		typeof value.assertion !== "string" ||
+		typeof value.establishedBy !== "string" ||
+		typeof value.limitation !== "string" ||
+		typeof value.containment !== "string" ||
+		typeof value.verification !== "string"
+	) {
+		return undefined;
+	}
+	return {
+		kind: value.kind,
+		assertion: value.assertion,
+		establishedBy: value.establishedBy,
+		limitation: value.limitation,
+		containment: value.containment,
+		verification: value.verification,
+	};
+}
+
 function parseImplementationStep(
 	value: unknown,
 ): ImplementationStepContract | undefined {
@@ -274,10 +364,20 @@ function parseImplementationStep(
 	) {
 		return undefined;
 	}
+	const invariantHandling =
+		value.invariantHandling === undefined
+			? {
+					kind: "not-applicable" as const,
+					reason:
+						"Legacy implementation route predates the invariant-handling declaration.",
+				}
+			: parseInvariantHandling(value.invariantHandling);
+	if (!invariantHandling) return undefined;
 	return {
 		movement: value.movement,
 		stopCondition: value.stopCondition,
 		verification: value.verification,
+		invariantHandling,
 	};
 }
 
@@ -622,19 +722,21 @@ export function normalizeDeveloperEvent(
 		) {
 			return undefined;
 		}
-		const consideredAlternatives = Array.isArray(value.consideredAlternatives)
-			? value.consideredAlternatives.map(parseRouteAlternative)
-			: [];
-		if (consideredAlternatives.some((alternative) => !alternative))
-			return undefined;
-		const referenceRoutes = Array.isArray(value.referenceRoutes)
-			? value.referenceRoutes.map(parseReferencePolicyRoute)
-			: [];
-		if (referenceRoutes.some((route) => !route)) return undefined;
-		const loadedReferences = Array.isArray(value.loadedReferences)
-			? value.loadedReferences.map(parseReferenceLoad)
-			: [];
-		if (loadedReferences.some((reference) => !reference)) return undefined;
+		const consideredAlternatives =
+			value.consideredAlternatives === undefined
+				? []
+				: parseArray(value.consideredAlternatives, parseRouteAlternative);
+		if (!consideredAlternatives) return undefined;
+		const referenceRoutes =
+			value.referenceRoutes === undefined
+				? []
+				: parseArray(value.referenceRoutes, parseReferencePolicyRoute);
+		if (!referenceRoutes) return undefined;
+		const loadedReferences =
+			value.loadedReferences === undefined
+				? []
+				: parseArray(value.loadedReferences, parseReferenceLoad);
+		if (!loadedReferences) return undefined;
 		return {
 			protocol: PROTOCOL,
 			kind: "route",
@@ -643,15 +745,15 @@ export function normalizeDeveloperEvent(
 			target: value.target,
 			reason: value.reason,
 			knownEvidence: value.knownEvidence,
-			consideredAlternatives: consideredAlternatives as RouteAlternative[],
+			consideredAlternatives,
 			availableReferences: value.availableReferences ?? [],
-			referenceRoutes: referenceRoutes as ReferencePolicyRoute[],
+			referenceRoutes,
 			referenceExemptionCriteria:
 				value.referenceExemptionCriteria === undefined
 					? undefined
 					: parseReferencePolicyExemption(value.referenceExemptionCriteria),
 			referencePolicySha256: value.referencePolicySha256,
-			loadedReferences: loadedReferences as ReferenceLoad[],
+			loadedReferences,
 			targetQuestionId: value.targetQuestionId,
 			methodLocation: value.methodLocation,
 			executionProfile: value.executionProfile,
@@ -698,21 +800,21 @@ export function normalizeDeveloperEvent(
 		return undefined;
 	}
 
-	const openedQuestions = value.openedQuestions.map(parsePendingQuestion);
-	if (openedQuestions.some((question) => !question)) return undefined;
-	const referenceBasis = Array.isArray(value.referenceBasis)
-		? value.referenceBasis.map(parseReferenceBasis)
-		: [];
-	if (referenceBasis.some((basis) => !basis)) return undefined;
-	if (
-		value.questionUpdates !== undefined &&
-		!Array.isArray(value.questionUpdates)
-	)
-		return undefined;
-	const questionUpdates = Array.isArray(value.questionUpdates)
-		? value.questionUpdates.map(parseQuestionUpdate)
-		: [];
-	if (questionUpdates.some((update) => !update)) return undefined;
+	const openedQuestions = parseArray(
+		value.openedQuestions,
+		parsePendingQuestion,
+	);
+	if (!openedQuestions) return undefined;
+	const referenceBasis =
+		value.referenceBasis === undefined
+			? []
+			: parseArray(value.referenceBasis, parseReferenceBasis);
+	if (!referenceBasis) return undefined;
+	const questionUpdates =
+		value.questionUpdates === undefined
+			? []
+			: parseArray(value.questionUpdates, parseQuestionUpdate);
+	if (!questionUpdates) return undefined;
 	return {
 		protocol: PROTOCOL,
 		kind: "judgment",
@@ -722,13 +824,13 @@ export function normalizeDeveloperEvent(
 		status: value.status,
 		result: value.result,
 		basis: value.basis,
-		referenceBasis: referenceBasis as ReferenceBasis[],
+		referenceBasis,
 		referenceExemption:
 			value.referenceExemption === undefined
 				? undefined
 				: parseReferenceExemption(value.referenceExemption),
-		openedQuestions: openedQuestions as PendingQuestion[],
-		questionUpdates: questionUpdates as QuestionUpdate[],
+		openedQuestions,
+		questionUpdates,
 		artifacts: value.artifacts,
 		changedArtifacts:
 			typeof value.changedArtifacts === "boolean"