@danypops/papyrus 0.42.0 → 0.42.2

package/src/discussion-service.ts

@@ -4,8 +4,13 @@
  * design rationale.
  */
 import { DISCUSSION_LIST_DEFAULT_LIMIT, DISCUSSION_LIST_MAX_LIMIT, DISCUSSION_MAX_ROUNDS } from "./constants.ts";
+import type { Artifact } from "./domain/artifact.ts";
+import type { ArtifactEventContext } from "./domain/artifact-event.ts";
 import {
 	DISCUSSION_SUBTYPE,
+	type DiscussionExtra,
+	type DiscussionOptionsMode,
+	type DiscussionRound,
 	isDiscussionArtifact,
 	readDiscussionExtra,
 	validateDeferReason,
@@ -14,12 +19,7 @@ import {
 	validateDiscussionOptions,
 	validateSelectedOptions,
 	validateSettlement,
-	type DiscussionExtra,
-	type DiscussionOptionsMode,
-	type DiscussionRound,
 } from "./domain/discussion.ts";
-import type { Artifact } from "./domain/artifact.ts";
-import type { ArtifactEventContext } from "./domain/artifact-event.ts";
 import type { AtomicArtifactStore } from "./ports/atomic-artifact-store.ts";
 import type { DiscussionRoundStore } from "./ports/discussion-round-store.ts";
 
@@ -72,7 +72,11 @@ export class Discussions {
 	}
 
 	/** Validates a freshly-posed choice; undefined when neither field is given (nothing posed), since both/neither is the only valid shape. */
-	private validatePosedOptions(options: string[] | undefined, optionsMode: DiscussionOptionsMode | undefined, optionDescriptions: string[] | undefined): { options: string[]; mode: DiscussionOptionsMode; optionDescriptions?: string[] } | undefined {
+	private validatePosedOptions(
+		options: string[] | undefined,
+		optionsMode: DiscussionOptionsMode | undefined,
+		optionDescriptions: string[] | undefined,
+	): { options: string[]; mode: DiscussionOptionsMode; optionDescriptions?: string[] } | undefined {
 		if (options === undefined && optionsMode === undefined) return undefined;
 		return validateDiscussionOptions(options ?? [], optionsMode ?? "", optionDescriptions);
 	}
@@ -82,25 +86,46 @@ export class Discussions {
 		const content = validateDiscussionContent(input.content);
 		const posed = this.validatePosedOptions(input.options, input.optionsMode, input.optionDescriptions);
 		return this.artifacts.atomic(() => {
-			const discussion = this.artifacts.create({
-				kind: "task",
-				subtype: DISCUSSION_SUBTYPE,
-				title: input.title,
-				body: input.body ?? "",
-				status: "in-progress",
-				labels: input.labels,
-				extra: {
-					discussion: {
-						state: "active",
-						roundCount: 1,
-						...(posed ? { pendingOptions: posed.options, pendingOptionsMode: posed.mode, ...(posed.optionDescriptions ? { pendingOptionDescriptions: posed.optionDescriptions } : {}) } : {}),
+			const discussion = this.artifacts.create(
+				{
+					kind: "task",
+					subtype: DISCUSSION_SUBTYPE,
+					title: input.title,
+					body: input.body ?? "",
+					status: "in-progress",
+					labels: input.labels,
+					extra: {
+						discussion: {
+							state: "active",
+							roundCount: 1,
+							...(posed
+								? {
+										pendingOptions: posed.options,
+										pendingOptionsMode: posed.mode,
+										...(posed.optionDescriptions ? { pendingOptionDescriptions: posed.optionDescriptions } : {}),
+									}
+								: {}),
+						},
 					},
 				},
-			}, context);
-			const round = this.rounds.append({
-				discussionId: discussion.id, roundNumber: 1, actor, content,
-				...(posed ? { options: posed.options, optionsMode: posed.mode, ...(posed.optionDescriptions ? { optionDescriptions: posed.optionDescriptions } : {}) } : {}),
-			}, new Date().toISOString());
+				context,
+			);
+			const round = this.rounds.append(
+				{
+					discussionId: discussion.id,
+					roundNumber: 1,
+					actor,
+					content,
+					...(posed
+						? {
+								options: posed.options,
+								optionsMode: posed.mode,
+								...(posed.optionDescriptions ? { optionDescriptions: posed.optionDescriptions } : {}),
+							}
+						: {}),
+				},
+				new Date().toISOString(),
+			);
 			for (const taskId of input.blocksTaskIds ?? []) this.block(discussion.id, taskId, context);
 			return { discussion: this.artifacts.get(discussion.id)!, rounds: [round] };
 		});
@@ -114,24 +139,49 @@ export class Discussions {
 			const discussion = requireDiscussion(this.artifacts.get(discussionId), discussionId);
 			const state = this.extra(discussion);
 			if (state.state !== "active") throw new DiscussionError(`discussion "${discussionId}" is ${state.state}; resume it before replying`);
-			if (state.roundCount >= DISCUSSION_MAX_ROUNDS) throw new DiscussionError(`discussion "${discussionId}" has reached its ${DISCUSSION_MAX_ROUNDS}-round limit; settle or defer it`);
-			const selected = input.selected !== undefined ? validateSelectedOptions(input.selected, state.pendingOptions, state.pendingOptionsMode) : undefined;
+			if (state.roundCount >= DISCUSSION_MAX_ROUNDS)
+				throw new DiscussionError(`discussion "${discussionId}" has reached its ${DISCUSSION_MAX_ROUNDS}-round limit; settle or defer it`);
+			const selected =
+				input.selected !== undefined ? validateSelectedOptions(input.selected, state.pendingOptions, state.pendingOptionsMode) : undefined;
 			const nextRound = state.roundCount + 1;
-			const round = this.rounds.append({
-				discussionId, roundNumber: nextRound, actor: validActor, content: validContent,
-				...(posed ? { options: posed.options, optionsMode: posed.mode, ...(posed.optionDescriptions ? { optionDescriptions: posed.optionDescriptions } : {}) } : {}),
-				...(selected ? { selected } : {}),
-			}, new Date().toISOString());
+			const round = this.rounds.append(
+				{
+					discussionId,
+					roundNumber: nextRound,
+					actor: validActor,
+					content: validContent,
+					...(posed
+						? {
+								options: posed.options,
+								optionsMode: posed.mode,
+								...(posed.optionDescriptions ? { optionDescriptions: posed.optionDescriptions } : {}),
+							}
+						: {}),
+					...(selected ? { selected } : {}),
+				},
+				new Date().toISOString(),
+			);
 			// Whenever this round answers the pending choice OR poses a new one, the base must drop ALL
 			// three pending* fields first -- otherwise a re-pose that omits descriptions this time would
 			// leave a stale pendingOptionDescriptions array (sized for the OLD options) spread through
 			// unchanged, no longer aligned 1:1 with the new pendingOptions. Only a plain reply that
 			// neither answers nor re-poses leaves the existing pending state untouched.
-			const { pendingOptions: _clearedOptions, pendingOptionsMode: _clearedMode, pendingOptionDescriptions: _clearedDescriptions, ...withoutPending } = state;
+			const {
+				pendingOptions: _clearedOptions,
+				pendingOptionsMode: _clearedMode,
+				pendingOptionDescriptions: _clearedDescriptions,
+				...withoutPending
+			} = state;
 			const nextState = {
 				...(selected || posed ? withoutPending : state),
 				roundCount: nextRound,
-				...(posed ? { pendingOptions: posed.options, pendingOptionsMode: posed.mode, ...(posed.optionDescriptions ? { pendingOptionDescriptions: posed.optionDescriptions } : {}) } : {}),
+				...(posed
+					? {
+							pendingOptions: posed.options,
+							pendingOptionsMode: posed.mode,
+							...(posed.optionDescriptions ? { pendingOptionDescriptions: posed.optionDescriptions } : {}),
+						}
+					: {}),
 			};
 			const updated = this.artifacts.setExtra(discussionId, { ...discussion.extra, discussion: nextState }, context)!;
 			return { discussion: updated, rounds: [round] };
@@ -143,11 +193,16 @@ export class Discussions {
 		return this.artifacts.atomic(() => {
 			const discussion = requireDiscussion(this.artifacts.get(discussionId), discussionId);
 			const state = this.extra(discussion);
-			if (state.state !== "active") throw new DiscussionError(`discussion "${discussionId}" is ${state.state}; only an active Discussion can be deferred`);
-			return this.artifacts.setExtra(discussionId, {
-				...discussion.extra,
-				discussion: { ...state, state: "deferred", ...(validReason === undefined ? {} : { deferredReason: validReason }) },
-			}, context)!;
+			if (state.state !== "active")
+				throw new DiscussionError(`discussion "${discussionId}" is ${state.state}; only an active Discussion can be deferred`);
+			return this.artifacts.setExtra(
+				discussionId,
+				{
+					...discussion.extra,
+					discussion: { ...state, state: "deferred", ...(validReason === undefined ? {} : { deferredReason: validReason }) },
+				},
+				context,
+			)!;
 		});
 	}
 
@@ -155,7 +210,8 @@ export class Discussions {
 		return this.artifacts.atomic(() => {
 			const discussion = requireDiscussion(this.artifacts.get(discussionId), discussionId);
 			const state = this.extra(discussion);
-			if (state.state !== "deferred") throw new DiscussionError(`discussion "${discussionId}" is ${state.state}; only a deferred Discussion can be resumed`);
+			if (state.state !== "deferred")
+				throw new DiscussionError(`discussion "${discussionId}" is ${state.state}; only a deferred Discussion can be resumed`);
 			const { deferredReason: _deferredReason, ...rest } = state;
 			return this.artifacts.setExtra(discussionId, { ...discussion.extra, discussion: { ...rest, state: "active" } }, context)!;
 		});
@@ -167,10 +223,14 @@ export class Discussions {
 			const discussion = requireDiscussion(this.artifacts.get(discussionId), discussionId);
 			const state = this.extra(discussion);
 			if (state.state === "settled") throw new DiscussionError(`discussion "${discussionId}" is already settled`);
-			const updated = this.artifacts.setExtra(discussionId, {
-				...discussion.extra,
-				discussion: { ...state, state: "settled", settlement: validSettlement, settledAt: new Date().toISOString() },
-			}, context)!;
+			const updated = this.artifacts.setExtra(
+				discussionId,
+				{
+					...discussion.extra,
+					discussion: { ...state, state: "settled", settlement: validSettlement, settledAt: new Date().toISOString() },
+				},
+				context,
+			)!;
 			return this.artifacts.setStatus(discussionId, "done", context) ?? updated;
 		});
 	}
@@ -178,7 +238,8 @@ export class Discussions {
 	/** Links an existing active Discussion to a Task it blocks; refuses a non-task target or an already-settled Discussion. */
 	block(discussionId: string, taskId: string, context?: ArtifactEventContext): void {
 		const discussion = requireDiscussion(this.artifacts.get(discussionId), discussionId);
-		if (this.extra(discussion).state === "settled") throw new DiscussionError(`discussion "${discussionId}" is settled; it can no longer block anything`);
+		if (this.extra(discussion).state === "settled")
+			throw new DiscussionError(`discussion "${discussionId}" is settled; it can no longer block anything`);
 		const task = this.artifacts.get(taskId);
 		if (!task) throw new DiscussionError(`task "${taskId}" not found`);
 		if (task.kind !== "task" || isDiscussionArtifact(task)) throw new DiscussionError(`artifact "${taskId}" is not a task`);
@@ -211,7 +272,11 @@ export class Discussions {
 		const rows = this.artifacts.query({ kind: "task", subtype: DISCUSSION_SUBTYPE, limit });
 		if (!filter.state) return rows;
 		return rows.filter((row) => {
-			try { return this.extra(row).state === filter.state; } catch { return false; }
+			try {
+				return this.extra(row).state === filter.state;
+			} catch {
+				return false;
+			}
 		});
 	}
 }

package/src/domain/artifact-event.ts

@@ -10,8 +10,17 @@
  */
 import { ARTIFACT_EVENT_ACTOR_MAX_LENGTH, ARTIFACT_EVENT_HISTORY_DEFAULT_LIMIT, ARTIFACT_EVENT_HISTORY_MAX_LIMIT } from "../constants.ts";
 
-export const ARTIFACT_EVENT_TYPES = ["created", "updated", "status_changed", "extra_set", "linked", "unlinked", "trashed", "restored"] as const;
-export type ArtifactEventType = typeof ARTIFACT_EVENT_TYPES[number];
+export const ARTIFACT_EVENT_TYPES = [
+	"created",
+	"updated",
+	"status_changed",
+	"extra_set",
+	"linked",
+	"unlinked",
+	"trashed",
+	"restored",
+] as const;
+export type ArtifactEventType = (typeof ARTIFACT_EVENT_TYPES)[number];
 export type ArtifactEventDirection = "asc" | "desc";
 
 /** Caller-supplied identity for a mutation. All fields are advisory (self-reported), not cryptographically verified. */
@@ -73,7 +82,9 @@ function boundedString(value: string, field: string, maximum: number): string {
 }
 
 /** Fills defaults and enforces bounds. The one place every appended event is normalized. */
-export function resolveArtifactEvent(input: AppendArtifactEvent): Required<Pick<AppendArtifactEvent, "actor" | "source">> & AppendArtifactEvent {
+export function resolveArtifactEvent(
+	input: AppendArtifactEvent,
+): Required<Pick<AppendArtifactEvent, "actor" | "source">> & AppendArtifactEvent {
 	if (!input.artifactId) throw new Error("artifactId is required");
 	const actor = boundedString(input.actor ?? ARTIFACT_EVENT_DEFAULT_ACTOR, "actor", ARTIFACT_EVENT_ACTOR_MAX_LENGTH);
 	const source = boundedString(input.source ?? ARTIFACT_EVENT_DEFAULT_SOURCE, "source", ARTIFACT_EVENT_ACTOR_MAX_LENGTH);
@@ -81,7 +92,9 @@ export function resolveArtifactEvent(input: AppendArtifactEvent): Required<Pick<
 	return { ...input, actor, source };
 }
 
-export function normalizeArtifactEventQuery(query: ArtifactEventQuery): Required<Pick<ArtifactEventQuery, "limit" | "direction">> & ArtifactEventQuery {
+export function normalizeArtifactEventQuery(
+	query: ArtifactEventQuery,
+): Required<Pick<ArtifactEventQuery, "limit" | "direction">> & ArtifactEventQuery {
 	if (!query.artifactId && !query.actor && !query.sessionId) {
 		throw new Error("artifact event query requires artifactId, actor, or sessionId to stay bounded");
 	}

package/src/domain/artifact.ts

@@ -94,7 +94,9 @@ export function externalSourceOf(artifact: Pick<Artifact, "labels">): string | u
 export function requireLocallyOwnedContent(artifact: Artifact): Artifact {
 	const system = externalSourceOf(artifact);
 	if (system !== undefined) {
-		throw new Error(`"${artifact.title}" is a read-only projection from ${system}; edit it there, or capture a correction as a new linked Doc, until a write-back capability is integrated`);
+		throw new Error(
+			`"${artifact.title}" is a read-only projection from ${system}; edit it there, or capture a correction as a new linked Doc, until a write-back capability is integrated`,
+		);
 	}
 	return artifact;
 }

package/src/domain/blueprint-definition.ts

@@ -1,10 +1,4 @@
-import {
-	SEED_RELATIONS,
-	SKILL_MAX_BLUEPRINTS,
-	SKILL_MAX_ENUM_VALUES,
-	SKILL_MAX_INPUTS,
-	SKILL_MAX_LINKS,
-} from "../constants.ts";
+import { SEED_RELATIONS, SKILL_MAX_BLUEPRINTS, SKILL_MAX_ENUM_VALUES, SKILL_MAX_INPUTS, SKILL_MAX_LINKS } from "../constants.ts";
 
 export type BlueprintArgumentValue = string | number | boolean;
 export type BlueprintInputType = "string" | "number" | "boolean";
@@ -124,17 +118,18 @@ function validateInputs(value: unknown): Record<string, BlueprintInputDefinition
 		if (RESERVED_KEYS.has(name)) throw new Error(`reserved input name "${name}"`);
 		if (!NAME_PATTERN.test(name)) throw new Error(`invalid input name "${name}"`);
 		const input = record(raw, `input "${name}"`);
-		if (!BLUEPRINT_INPUT_TYPES.has(input["type"] as BlueprintInputType)) throw new Error(`input "${name}" has unsupported type`);
-		const type = input["type"] as BlueprintInputType;
-		if (input["required"] !== undefined && typeof input["required"] !== "boolean") {
+		if (!BLUEPRINT_INPUT_TYPES.has(input.type as BlueprintInputType)) throw new Error(`input "${name}" has unsupported type`);
+		const type = input.type as BlueprintInputType;
+		if (input.required !== undefined && typeof input.required !== "boolean") {
 			throw new Error(`input "${name}" required must be boolean`);
 		}
 		const normalized: BlueprintInputDefinition = { type };
-		if (input["required"] !== undefined) normalized.required = input["required"] as boolean;
-		if (input["default"] !== undefined) normalized.default = validateArgumentValue(name, type, input["default"]);
-		if (input["enum"] !== undefined) {
-			const values = array(input["enum"], `input "${name}" enum`);
-			if (values.length === 0 || values.length > SKILL_MAX_ENUM_VALUES) throw new Error(`input "${name}" enum must contain 1-${SKILL_MAX_ENUM_VALUES} values`);
+		if (input.required !== undefined) normalized.required = input.required as boolean;
+		if (input.default !== undefined) normalized.default = validateArgumentValue(name, type, input.default);
+		if (input.enum !== undefined) {
+			const values = array(input.enum, `input "${name}" enum`);
+			if (values.length === 0 || values.length > SKILL_MAX_ENUM_VALUES)
+				throw new Error(`input "${name}" enum must contain 1-${SKILL_MAX_ENUM_VALUES} values`);
 			normalized.enum = values.map((entry) => validateArgumentValue(name, type, entry));
 			if (normalized.default !== undefined && !normalized.enum.includes(normalized.default)) {
 				throw new Error(`input "${name}" default must be one of its enum values`);
@@ -147,9 +142,9 @@ function validateInputs(value: unknown): Record<string, BlueprintInputDefinition
 
 function validateBlueprint<T extends { ref: string; title: string }>(value: unknown, kind: string): T {
 	const source = record(value, `${kind} blueprint`);
-	const ref = string(source["ref"], `${kind} blueprint ref`);
+	const ref = string(source.ref, `${kind} blueprint ref`);
 	if (!NAME_PATTERN.test(ref)) throw new Error(`invalid blueprint ref "${ref}"`);
-	const title = string(source["title"], `${kind} blueprint title`);
+	const title = string(source.title, `${kind} blueprint title`);
 	return { ...source, ref, title } as T;
 }
 
@@ -187,22 +182,22 @@ function assertAcyclic(steps: DependentStep[]): void {
 
 function validateCallBlueprint(value: unknown): CallBlueprint {
 	const source = record(value, "call blueprint");
-	const ref = string(source["ref"], "call blueprint ref");
+	const ref = string(source.ref, "call blueprint ref");
 	if (!NAME_PATTERN.test(ref)) throw new Error(`invalid blueprint ref "${ref}"`);
-	const title = string(source["title"], "call blueprint title");
-	const targetId = string(source["targetId"] ?? source["skillId"], "call blueprint targetId");
+	const title = string(source.title, "call blueprint title");
+	const targetId = string(source.targetId ?? source.skillId, "call blueprint targetId");
 	return { ...source, ref, title, targetId } as CallBlueprint;
 }
 
 export function validateBlueprintDefinition(value: unknown): BlueprintDefinition {
 	const source = record(value, "blueprint definition");
-	if (source["version"] !== 1) throw new Error("blueprint definition version must be 1");
-	const inputs = validateInputs(source["inputs"]);
-	const rawBlueprints = record(source["blueprints"], "blueprints");
-	const docs = array(rawBlueprints["docs"] ?? [], "doc blueprints").map((entry) => validateBlueprint<DocBlueprint>(entry, "doc"));
-	const rules = array(rawBlueprints["rules"] ?? [], "rule blueprints").map((entry) => validateBlueprint<RuleBlueprint>(entry, "rule"));
-	const tasks = array(rawBlueprints["tasks"] ?? [], "task blueprints").map((entry) => validateBlueprint<TaskBlueprint>(entry, "task"));
-	const calls = array(rawBlueprints["skills"] ?? [], "call blueprints").map(validateCallBlueprint);
+	if (source.version !== 1) throw new Error("blueprint definition version must be 1");
+	const inputs = validateInputs(source.inputs);
+	const rawBlueprints = record(source.blueprints, "blueprints");
+	const docs = array(rawBlueprints.docs ?? [], "doc blueprints").map((entry) => validateBlueprint<DocBlueprint>(entry, "doc"));
+	const rules = array(rawBlueprints.rules ?? [], "rule blueprints").map((entry) => validateBlueprint<RuleBlueprint>(entry, "rule"));
+	const tasks = array(rawBlueprints.tasks ?? [], "task blueprints").map((entry) => validateBlueprint<TaskBlueprint>(entry, "task"));
+	const calls = array(rawBlueprints.skills ?? [], "call blueprints").map(validateCallBlueprint);
 	const all = [...docs, ...rules, ...tasks, ...calls];
 	if (all.length === 0 || all.length > SKILL_MAX_BLUEPRINTS) throw new Error(`blueprints must contain 1-${SKILL_MAX_BLUEPRINTS} artifacts`);
 	const refs = new Set<string>();
@@ -237,11 +232,11 @@ export function validateBlueprintDefinition(value: unknown): BlueprintDefinition
 	for (const name of placeholders(all)) {
 		if (!Object.hasOwn(inputs, name)) throw new Error(`unknown input placeholder "${name}"`);
 	}
-	const links = array(source["links"] ?? [], "links").map((entry) => {
+	const links = array(source.links ?? [], "links").map((entry) => {
 		const link = record(entry, "link");
-		const from = string(link["from"], "link from");
-		const relation = string(link["relation"], "link relation");
-		const to = string(link["to"], "link to");
+		const from = string(link.from, "link from");
+		const relation = string(link.relation, "link relation");
+		const to = string(link.to, "link to");
 		if (!refs.has(from)) throw new Error(`unknown blueprint ref "${from}"`);
 		if (!refs.has(to)) throw new Error(`unknown blueprint ref "${to}"`);
 		if (!RELATIONS.has(relation)) throw new Error(`unknown link relation "${relation}"`);

package/src/domain/checklist.ts

@@ -1,6 +1,6 @@
 export const PROOF_TYPES = ["file", "symbol", "code", "test", "command", "artifact", "url"] as const;
 
-export type ProofType = typeof PROOF_TYPES[number];
+export type ProofType = (typeof PROOF_TYPES)[number];
 
 export interface ProofReference {
 	type: ProofType;
@@ -25,13 +25,13 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 }
 
 function proofReference(value: unknown): ProofReference | undefined {
-	if (!isRecord(value) || !PROOF_TYPES.includes(value["type"] as ProofType)) return undefined;
-	if (typeof value["target"] !== "string" || value["target"].trim().length === 0) return undefined;
-	if (value["expect"] !== undefined && typeof value["expect"] !== "string") return undefined;
+	if (!isRecord(value) || !PROOF_TYPES.includes(value.type as ProofType)) return undefined;
+	if (typeof value.target !== "string" || value.target.trim().length === 0) return undefined;
+	if (value.expect !== undefined && typeof value.expect !== "string") return undefined;
 	return {
-		type: value["type"] as ProofType,
-		target: value["target"],
-		...(typeof value["expect"] === "string" ? { expect: value["expect"] } : {}),
+		type: value.type as ProofType,
+		target: value.target,
+		...(typeof value.expect === "string" ? { expect: value.expect } : {}),
 	};
 }
 
@@ -40,10 +40,10 @@ export function validateChecklist(value: unknown): Checklist {
 	const checklist: Checklist = {};
 	for (const [item, criterion] of Object.entries(value)) {
 		if (item.trim().length === 0) throw new Error("checklist item must not be empty");
-		if (!isRecord(criterion) || !Array.isArray(criterion["proof"]) || criterion["proof"].length === 0) {
+		if (!isRecord(criterion) || !Array.isArray(criterion.proof) || criterion.proof.length === 0) {
 			throw new Error(`checklist item "${item}" requires at least one proof reference`);
 		}
-		const proof = criterion["proof"].map(proofReference);
+		const proof = criterion.proof.map(proofReference);
 		if (proof.some((reference) => reference === undefined)) {
 			throw new Error(`checklist item "${item}" requires a typed, non-empty proof target`);
 		}
@@ -54,17 +54,20 @@ export function validateChecklist(value: unknown): Checklist {
 
 export function checklistEntries(value: unknown): ChecklistEntry[] {
 	if (Array.isArray(value)) {
-		return value.flatMap((item) => typeof item === "string"
-			? [{ item, proof: [], legacy: true }]
-			: isRecord(item) && typeof item["title"] === "string"
-				? [{ item: item["title"], proof: [], legacy: true }]
-				: []);
+		return value.flatMap((item) =>
+			typeof item === "string"
+				? [{ item, proof: [], legacy: true }]
+				: isRecord(item) && typeof item.title === "string"
+					? [{ item: item.title, proof: [], legacy: true }]
+					: [],
+		);
 	}
 	if (!isRecord(value)) return [];
 	return Object.entries(value).map(([item, criterion]) => {
-		const references = isRecord(criterion) && Array.isArray(criterion["proof"])
-			? criterion["proof"].map(proofReference).filter((proof): proof is ProofReference => proof !== undefined)
-			: [];
+		const references =
+			isRecord(criterion) && Array.isArray(criterion.proof)
+				? criterion.proof.map(proofReference).filter((proof): proof is ProofReference => proof !== undefined)
+				: [];
 		return { item, proof: references, legacy: false };
 	});
 }

package/src/domain/discussion.ts

@@ -32,7 +32,7 @@ import {
 export const DISCUSSION_SUBTYPE = "discussion";
 
 export const DISCUSSION_STATES = ["active", "deferred", "settled"] as const;
-export type DiscussionState = typeof DISCUSSION_STATES[number];
+export type DiscussionState = (typeof DISCUSSION_STATES)[number];
 
 /**
  * A round can pose a choice (options + optionsMode) the way opencode's QuestionV2 poses
@@ -40,7 +40,7 @@ export type DiscussionState = typeof DISCUSSION_STATES[number];
  * (exactly one pick); "multi" allows several -- see constants.ts.
  */
 export const DISCUSSION_OPTIONS_MODES = ["single", "multi"] as const;
-export type DiscussionOptionsMode = typeof DISCUSSION_OPTIONS_MODES[number];
+export type DiscussionOptionsMode = (typeof DISCUSSION_OPTIONS_MODES)[number];
 
 /** Persisted in a discussion Doc's `extra.discussion`. pendingOptions/-Mode is the current-state cache of "is there an unanswered posed choice right now" -- cleared once answered, set again whenever a round poses a new one. */
 export interface DiscussionExtra {
@@ -113,7 +113,11 @@ export function validateSettlement(settlement: string): string {
 /** Validates a freshly-posed choice: 2..DISCUSSION_OPTIONS_MAX_COUNT unique, bounded-length
  * options, a real mode, and a non-empty description for every option once
  * DISCUSSION_OPTION_DESCRIPTION_REQUIRED_FROM_COUNT or more are posed. */
-export function validateDiscussionOptions(options: string[], mode: string, optionDescriptions?: string[]): { options: string[]; mode: DiscussionOptionsMode; optionDescriptions?: string[] } {
+export function validateDiscussionOptions(
+	options: string[],
+	mode: string,
+	optionDescriptions?: string[],
+): { options: string[]; mode: DiscussionOptionsMode; optionDescriptions?: string[] } {
 	if (!(DISCUSSION_OPTIONS_MODES as readonly string[]).includes(mode)) {
 		throw new Error(`options_mode must be one of ${DISCUSSION_OPTIONS_MODES.join(", ")}`);
 	}
@@ -123,20 +127,35 @@ export function validateDiscussionOptions(options: string[], mode: string, optio
 	for (const option of options) boundedString(option, "option", DISCUSSION_OPTION_MAX_LENGTH);
 	if (new Set(options).size !== options.length) throw new Error("options must not repeat an entry");
 	const descriptionsRequired = options.length >= DISCUSSION_OPTION_DESCRIPTION_REQUIRED_FROM_COUNT;
-	if (descriptionsRequired && (optionDescriptions === undefined || optionDescriptions.some((description) => description.trim().length === 0))) {
-		throw new Error(`option_descriptions is required, with a non-empty entry for every option, once ${DISCUSSION_OPTION_DESCRIPTION_REQUIRED_FROM_COUNT} or more options are posed`);
+	if (
+		descriptionsRequired &&
+		(optionDescriptions === undefined || optionDescriptions.some((description) => description.trim().length === 0))
+	) {
+		throw new Error(
+			`option_descriptions is required, with a non-empty entry for every option, once ${DISCUSSION_OPTION_DESCRIPTION_REQUIRED_FROM_COUNT} or more options are posed`,
+		);
 	}
 	if (optionDescriptions !== undefined) {
-		if (optionDescriptions.length !== options.length) throw new Error("option_descriptions must have exactly one entry per option (use an empty string for none)");
+		if (optionDescriptions.length !== options.length)
+			throw new Error("option_descriptions must have exactly one entry per option (use an empty string for none)");
 		for (const description of optionDescriptions) {
-			if (description.length > DISCUSSION_OPTION_DESCRIPTION_MAX_LENGTH) throw new Error(`option description must be at most ${DISCUSSION_OPTION_DESCRIPTION_MAX_LENGTH} characters`);
+			if (description.length > DISCUSSION_OPTION_DESCRIPTION_MAX_LENGTH)
+				throw new Error(`option description must be at most ${DISCUSSION_OPTION_DESCRIPTION_MAX_LENGTH} characters`);
 		}
 	}
-	return { options: [...options], mode: mode as DiscussionOptionsMode, ...(optionDescriptions !== undefined ? { optionDescriptions: [...optionDescriptions] } : {}) };
+	return {
+		options: [...options],
+		mode: mode as DiscussionOptionsMode,
+		...(optionDescriptions !== undefined ? { optionDescriptions: [...optionDescriptions] } : {}),
+	};
 }
 
 /** Validates an answer against the Discussion's currently pending posed choice, if any. */
-export function validateSelectedOptions(selected: string[], pendingOptions: string[] | undefined, pendingMode: DiscussionOptionsMode | undefined): string[] {
+export function validateSelectedOptions(
+	selected: string[],
+	pendingOptions: string[] | undefined,
+	pendingMode: DiscussionOptionsMode | undefined,
+): string[] {
 	if (!pendingOptions || pendingOptions.length === 0 || !pendingMode) {
 		throw new Error("this Discussion has no pending options to select from");
 	}
@@ -155,26 +174,26 @@ export function isDiscussionArtifact(artifact: { kind: string; subtype: string }
 
 /** Reads and defensively validates the extra.discussion shape; throws on a corrupt/foreign shape rather than silently treating it as some default state. */
 export function readDiscussionExtra(extra: Record<string, unknown>): DiscussionExtra {
-	const raw = extra["discussion"];
+	const raw = extra.discussion;
 	if (typeof raw !== "object" || raw === null) throw new Error("artifact is not a Discussion (missing extra.discussion)");
 	const record = raw as Record<string, unknown>;
-	const state = record["state"];
+	const state = record.state;
 	if (typeof state !== "string" || !(DISCUSSION_STATES as readonly string[]).includes(state)) {
 		throw new Error(`invalid Discussion state "${String(state)}"`);
 	}
-	const roundCount = record["roundCount"];
+	const roundCount = record.roundCount;
 	if (typeof roundCount !== "number" || !Number.isInteger(roundCount) || roundCount < 0) {
 		throw new Error("invalid Discussion roundCount");
 	}
-	const pendingOptions = record["pendingOptions"];
+	const pendingOptions = record.pendingOptions;
 	if (pendingOptions !== undefined && (!Array.isArray(pendingOptions) || pendingOptions.some((entry) => typeof entry !== "string"))) {
 		throw new Error("invalid Discussion pendingOptions");
 	}
-	const pendingOptionsMode = record["pendingOptionsMode"];
+	const pendingOptionsMode = record.pendingOptionsMode;
 	if (pendingOptionsMode !== undefined && !(DISCUSSION_OPTIONS_MODES as readonly unknown[]).includes(pendingOptionsMode)) {
 		throw new Error("invalid Discussion pendingOptionsMode");
 	}
-	const pendingOptionDescriptions = record["pendingOptionDescriptions"];
+	const pendingOptionDescriptions = record.pendingOptionDescriptions;
 	if (pendingOptionDescriptions !== undefined) {
 		if (!Array.isArray(pendingOptionDescriptions) || pendingOptionDescriptions.some((entry) => typeof entry !== "string")) {
 			throw new Error("invalid Discussion pendingOptionDescriptions");
@@ -186,9 +205,9 @@ export function readDiscussionExtra(extra: Record<string, unknown>): DiscussionE
 	return {
 		state: state as DiscussionState,
 		roundCount,
-		...(typeof record["deferredReason"] === "string" ? { deferredReason: record["deferredReason"] } : {}),
-		...(typeof record["settlement"] === "string" ? { settlement: record["settlement"] } : {}),
-		...(typeof record["settledAt"] === "string" ? { settledAt: record["settledAt"] } : {}),
+		...(typeof record.deferredReason === "string" ? { deferredReason: record.deferredReason } : {}),
+		...(typeof record.settlement === "string" ? { settlement: record.settlement } : {}),
+		...(typeof record.settledAt === "string" ? { settledAt: record.settledAt } : {}),
 		...(pendingOptions !== undefined ? { pendingOptions: pendingOptions as string[] } : {}),
 		...(pendingOptionsMode !== undefined ? { pendingOptionsMode: pendingOptionsMode as DiscussionOptionsMode } : {}),
 		...(pendingOptionDescriptions !== undefined ? { pendingOptionDescriptions: pendingOptionDescriptions as string[] } : {}),

package/src/domain/gate.ts

@@ -1,5 +1,5 @@
 export const GATE_TYPES = ["file-exists", "command", "contains", "test"] as const;
-export type GateType = typeof GATE_TYPES[number];
+export type GateType = (typeof GATE_TYPES)[number];
 
 export interface Gate {
 	type: GateType;
@@ -20,19 +20,19 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 export function validateGates(value: unknown): Gate[] {
 	if (!Array.isArray(value)) throw new Error("gates must be an array");
 	return value.map((entry, index) => {
-		if (!isRecord(entry) || !GATE_TYPES.includes(entry["type"] as GateType)) {
+		if (!isRecord(entry) || !GATE_TYPES.includes(entry.type as GateType)) {
 			throw new Error(`gate at index ${index} requires a valid type (${GATE_TYPES.join(", ")})`);
 		}
-		if (typeof entry["target"] !== "string" || entry["target"].trim().length === 0) {
+		if (typeof entry.target !== "string" || entry.target.trim().length === 0) {
 			throw new Error(`gate at index ${index} requires a non-empty target`);
 		}
-		if (entry["expect"] !== undefined && typeof entry["expect"] !== "string") {
+		if (entry.expect !== undefined && typeof entry.expect !== "string") {
 			throw new Error(`gate at index ${index} expect must be a string`);
 		}
 		return {
-			type: entry["type"] as GateType,
-			target: entry["target"],
-			...(typeof entry["expect"] === "string" ? { expect: entry["expect"] } : {}),
+			type: entry.type as GateType,
+			target: entry.target,
+			...(typeof entry.expect === "string" ? { expect: entry.expect } : {}),
 		};
 	});
 }

package/src/domain/log-entry.ts

@@ -18,7 +18,7 @@
  */
 
 export const LOG_LEVELS = ["debug", "info", "warning", "error"] as const;
-export type LogLevel = typeof LOG_LEVELS[number];
+export type LogLevel = (typeof LOG_LEVELS)[number];
 
 export const LOG_SOURCE_ID_MAX_LENGTH = 256;
 export const LOG_MESSAGE_MAX_CHARACTERS = 4000;