@vimhead.dev/norn-cli 0.1.0-tip.35240723931.1 → 0.1.0-tip.35343816255.1

package/assets/packages/sdk/src/api.ts

@@ -1,6 +1,9 @@
 import type { CreateAgentSessionOptions, EventBus, PromptOptions } from "@earendil-works/pi-coding-agent";
-import { z } from "zod";
-import type { NornResolvedSeerModeConfig } from "./seer/config.ts";
+import { Type, type Static, type StaticDecode, type StaticEncode, type TCodec, type TSchema } from "typebox";
+import type { TLocalizedValidationError } from "typebox/error";
+import { createWorkflowTransition } from "@vimhead.dev/norn-core/workflow-transition";
+import { Value } from "typebox/value";
+import { isPlainObject, jsonValueSchema } from "./schema.ts";
 
 const WORKFLOW_DECLARATION_KIND = "norn.workflow";
 
@@ -18,24 +21,14 @@ export type NornWorkflowIsolation<Mode extends NornWorkflowIsolationMode = NornW
 	readonly mode: Mode;
 };
 
-declare const nornWorkflowRefParamsBrand: unique symbol;
-declare const nornWorkflowRefForwardParamsBrand: unique symbol;
-
-type NornWorkflowRefForwardParams = Record<string, unknown> & {
-	readonly [nornWorkflowRefForwardParamsBrand]: true;
-};
-
-export type NornWorkflowRef<ParamsSchema extends z.ZodType = z.ZodType, Id extends string = string, ForwardParams = unknown> = Id & {
-	readonly [nornWorkflowRefParamsBrand]: (params: z.input<ParamsSchema> & ForwardParams) => z.input<ParamsSchema> & ForwardParams;
-};
-
 export type NornWorkflowDeclaration<
 	Id extends string = string,
-	ParamsSchema extends z.ZodType = z.ZodType,
+	ParamsSchema extends TSchema = TSchema,
 	IsolationMode extends NornWorkflowIsolationMode = NornWorkflowIsolationMode,
 > = {
+	(params: StaticEncode<ParamsSchema>): NornRunNext;
 	readonly kind: typeof WORKFLOW_DECLARATION_KIND;
-	readonly id: NornWorkflowRef<ParamsSchema, Id>;
+	readonly id: Id;
 	readonly isEntrypoint: boolean;
 	readonly instructions?: string;
 	readonly params: ParamsSchema;
@@ -43,41 +36,22 @@ export type NornWorkflowDeclaration<
 	readonly isolation: NornWorkflowIsolation<IsolationMode>;
 };
 
-export type NornAnyWorkflowDeclaration = NornWorkflowDeclaration<string, z.ZodType<any, any>>;
-export type NornWorkflowTarget<ParamsSchema extends z.ZodType = z.ZodType> = NornWorkflowDeclaration<string, ParamsSchema> | NornWorkflowRef<ParamsSchema>;
-export type NornWorkflowRefSchemaInput<ParamsSchema extends z.ZodType = z.ZodType> = string | {
-	readonly id: NornWorkflowRef<ParamsSchema>;
-	readonly workflow?: never;
-	readonly forwardParams?: never;
-};
-export type NornWorkflowRefSchemaOptions<ParamsSchema extends z.ZodType = z.ZodType> = {
+export type NornAnyWorkflowDeclaration = Pick<NornWorkflowDeclaration, keyof NornWorkflowDeclaration> & ((params: never) => NornRunNext);
+export type NornWorkflowRefSchemaOptions<ParamsSchema extends TSchema = TSchema> = {
 	readonly params?: ParamsSchema;
 };
-export type NornWorkflowRefInput<ParamsSchema extends z.ZodType> =
-	| NornWorkflowRefSchemaInput<ParamsSchema>
-	| {
-		readonly workflow: NornWorkflowRefSchemaInput<z.ZodType<any, any>>;
-		readonly forwardParams: Record<string, unknown>;
-	};
-export type NornWorkflowRefOutput<ParamsSchema extends z.ZodType> = {
-	readonly workflow: NornWorkflowRef<ParamsSchema, string, NornWorkflowRefForwardParams>;
-	readonly forwardParams: NornWorkflowRefForwardParams;
-};
+export type NornWorkflowRefInput = StaticEncode<typeof workflowReferenceInputSchema>;
+export type NornWorkflowRefOutput<ParamsSchema extends TSchema> = (params: StaticEncode<ParamsSchema> & object) => NornRunNext;
 
-export type NornWorkflowParamsInput<TWorkflow extends NornAnyWorkflowDeclaration> = z.input<TWorkflow["params"]>;
-export type NornWorkflowParams<TWorkflow extends NornAnyWorkflowDeclaration> = z.output<TWorkflow["params"]>;
-export type NornWorkflowTargetParamsInput<TWorkflow extends NornWorkflowTarget<any>> = TWorkflow extends NornWorkflowDeclaration<string, infer ParamsSchema>
-	? z.input<ParamsSchema>
-	: TWorkflow extends NornWorkflowRef<infer ParamsSchema, string, infer ForwardParams>
-		? z.input<ParamsSchema> & ForwardParams
-		: never;
+export type NornWorkflowParamsInput<TWorkflow extends NornAnyWorkflowDeclaration> = StaticEncode<TWorkflow["params"]>;
+export type NornWorkflowParams<TWorkflow extends NornAnyWorkflowDeclaration> = StaticDecode<TWorkflow["params"]>;
 
-export type NornWorkflowGate<ParamsSchema extends z.ZodType> = unknown extends z.input<ParamsSchema>
+export type NornWorkflowGate<ParamsSchema extends TSchema> = unknown extends StaticEncode<ParamsSchema>
 	? NornWorkflowAnyGate
-	: z.input<ParamsSchema> extends Record<string, unknown>
+	: StaticEncode<ParamsSchema> extends Record<string, unknown>
 		? {
 			readonly enabled: true;
-			readonly fields?: readonly Extract<keyof z.input<ParamsSchema>, string>[];
+			readonly fields?: readonly Extract<keyof StaticEncode<ParamsSchema>, string>[];
 		}
 		: {
 			readonly enabled: true;
@@ -90,7 +64,7 @@ type NornWorkflowInstructions =
 
 export type NornWorkflowDefinition<
 	Id extends string | undefined = string | undefined,
-	ParamsSchema extends z.ZodType = z.ZodType,
+	ParamsSchema extends TSchema = TSchema,
 	IsolationMode extends NornWorkflowIsolationMode = NornWorkflowIsolationMode,
 > = {
 	readonly id?: Id;
@@ -101,26 +75,27 @@ export type NornWorkflowDefinition<
 
 export type NornAnyWorkflowDefinition = {
 	readonly id?: string;
-	readonly params: z.ZodType;
+	readonly params: TSchema;
 	readonly gate?: NornWorkflowAnyGate;
 	readonly isolation?: NornWorkflowIsolation;
 } & NornWorkflowInstructions;
 
-export type NornWorkflowStateDefinition<T = unknown, Id extends string = string> = {
+export type NornWorkflowStateDefinition<Schema extends TSchema = TSchema, Id extends string = string> = {
 	readonly id: Id;
 	readonly description?: string;
-	readonly schema: z.ZodType<T>;
+	readonly schema: Schema;
 };
 
-export type NornWorkflowStateDefinitionInput<T = unknown, Id extends string | undefined = string | undefined> = {
+export type NornWorkflowStateDefinitionInput<Schema extends TSchema = TSchema, Id extends string | undefined = string | undefined> = {
 	readonly id?: Id;
 	readonly description?: string;
-	readonly schema: z.ZodType<T>;
+	readonly schema: Schema;
 };
 
 export type NornWorkflowPluginWorkflows = Record<string, NornAnyWorkflowDefinition>;
 export type NornWorkflowPluginStateTree = { readonly [key: string]: NornWorkflowPluginStateTreeNode };
-export type NornWorkflowPluginStateTreeNode = z.ZodType | NornWorkflowStateDefinitionInput | NornWorkflowPluginStateTree;
+type NornStateSchema = TSchema & ({ readonly "~kind": string } | { readonly "~unsafe": unknown });
+export type NornWorkflowPluginStateTreeNode = NornStateSchema | NornWorkflowStateDefinitionInput | NornWorkflowPluginStateTree;
 
 type JoinPath<Head extends string, Parts extends readonly string[]> = Parts extends readonly []
 	? Head
@@ -128,13 +103,13 @@ type JoinPath<Head extends string, Parts extends readonly string[]> = Parts exte
 		? JoinPath<`${Head}.${First}`, Rest>
 		: string;
 
-type NornInvalidGateFields<TWorkflow> = TWorkflow extends { readonly params: infer ParamsSchema extends z.ZodType; readonly gate: { readonly fields: infer Fields extends readonly string[] } }
-	? Exclude<Fields[number], Extract<keyof z.input<ParamsSchema>, string>>
+type NornInvalidGateFields<TWorkflow> = TWorkflow extends { readonly params: infer ParamsSchema extends TSchema; readonly gate: { readonly fields: infer Fields extends readonly string[] } }
+	? Exclude<Fields[number], Extract<keyof StaticEncode<ParamsSchema>, string>>
 	: never;
 
 type NornValidatedWorkflowGate<TWorkflow> = [NornInvalidGateFields<TWorkflow>] extends [never]
 	? unknown
-	: { readonly gate: { readonly fields: readonly Extract<keyof z.input<TWorkflow extends { readonly params: infer ParamsSchema extends z.ZodType } ? ParamsSchema : z.ZodType>, string>[] } };
+	: { readonly gate: { readonly fields: readonly Extract<keyof StaticEncode<TWorkflow extends { readonly params: infer ParamsSchema extends TSchema } ? ParamsSchema : TSchema>, string>[] } };
 
 export type NornValidatedWorkflowGates<Workflows> = {
 	readonly [Key in keyof Workflows]: NornValidatedWorkflowGate<Workflows[Key]>;
@@ -144,7 +119,7 @@ export type NornQualifiedPluginWorkflow<
 	PluginId extends string,
 	WorkflowKey extends string,
 	TWorkflow extends NornAnyWorkflowDefinition,
-> = TWorkflow extends { readonly params: infer ParamsSchema extends z.ZodType }
+> = TWorkflow extends { readonly params: infer ParamsSchema extends TSchema }
 	? NornWorkflowDeclaration<
 		TWorkflow extends { readonly id: infer ExplicitId extends string } ? ExplicitId : `${PluginId}.${WorkflowKey}`,
 		ParamsSchema,
@@ -157,13 +132,10 @@ export type NornQualifiedPluginWorkflows<PluginId extends string, Workflows exte
 };
 
 export type NornQualifiedPluginStates<PluginId extends string, States, Path extends readonly string[] = []> = {
-	readonly [Key in keyof States]: States[Key] extends z.ZodType
-		? NornWorkflowStateDefinition<z.output<States[Key]>, JoinPath<PluginId, [...Path, Key & string]>>
-		: States[Key] extends NornWorkflowStateDefinitionInput<infer Value>
-			? NornWorkflowStateDefinition<
-				Value,
-				States[Key] extends { readonly id: infer ExplicitId extends string } ? ExplicitId : JoinPath<PluginId, [...Path, Key & string]>
-			>
+	readonly [Key in keyof States]: States[Key] extends NornStateSchema
+		? NornWorkflowStateDefinition<States[Key], JoinPath<PluginId, [...Path, Key & string]>>
+		: States[Key] extends NornWorkflowStateDefinitionInput<infer Schema extends NornStateSchema>
+			? NornWorkflowStateDefinition<Schema, States[Key] extends { readonly id: infer Id extends string } ? Id : JoinPath<PluginId, [...Path, Key & string]>>
 			: States[Key] extends NornWorkflowPluginStateTree
 				? NornQualifiedPluginStates<PluginId, States[Key], [...Path, Key & string]>
 				: never;
@@ -171,7 +143,7 @@ export type NornQualifiedPluginStates<PluginId extends string, States, Path exte
 
 export type NornWorkflowPluginManifest<
 	PluginId extends string = string,
-	ConfigSchema extends z.ZodType | undefined = z.ZodType | undefined,
+	ConfigSchema extends TSchema | undefined = TSchema | undefined,
 	Workflows extends Record<string, NornAnyWorkflowDeclaration> = Record<string, NornAnyWorkflowDeclaration>,
 	States = undefined,
 > = {
@@ -181,19 +153,19 @@ export type NornWorkflowPluginManifest<
 	readonly states: States;
 };
 
-export type NornAnyWorkflowPluginManifest = NornWorkflowPluginManifest<string, z.ZodType | undefined, Record<string, NornAnyWorkflowDeclaration>, unknown>;
+export type NornAnyWorkflowPluginManifest = NornWorkflowPluginManifest<string, TSchema | undefined, Record<string, NornAnyWorkflowDeclaration>, unknown>;
 
-export type NornWorkflowPluginConfigSchema<TManifest extends NornAnyWorkflowPluginManifest> = TManifest extends { readonly config?: infer ConfigSchema extends z.ZodType | undefined }
+export type NornWorkflowPluginConfigSchema<TManifest extends NornAnyWorkflowPluginManifest> = TManifest extends { readonly config?: infer ConfigSchema extends TSchema | undefined }
 	? ConfigSchema
 	: undefined;
 
-export type NornWorkflowPluginConfig<TManifest extends NornAnyWorkflowPluginManifest> = NonNullable<NornWorkflowPluginConfigSchema<TManifest>> extends z.ZodType
-	? z.output<NonNullable<NornWorkflowPluginConfigSchema<TManifest>>>
-	: undefined;
+export type NornWorkflowPluginConfig<TManifest extends NornAnyWorkflowPluginManifest> = NornWorkflowPluginConfigSchema<TManifest> extends undefined
+	? undefined
+	: StaticDecode<NonNullable<NornWorkflowPluginConfigSchema<TManifest>>>;
 
 export type NornDefinePluginManifestInput<
 	PluginId extends string,
-	ConfigSchema extends z.ZodType | undefined,
+	ConfigSchema extends TSchema | undefined,
 	Workflows extends NornWorkflowPluginWorkflows,
 	States extends NornWorkflowPluginStateTree | undefined,
 > = {
@@ -205,7 +177,7 @@ export type NornDefinePluginManifestInput<
 
 export function definePluginManifest<
 	const PluginId extends string,
-	const ConfigSchema extends z.ZodType | undefined = undefined,
+	const ConfigSchema extends TSchema | undefined = undefined,
 	const Workflows extends NornWorkflowPluginWorkflows = NornWorkflowPluginWorkflows,
 	const States extends NornWorkflowPluginStateTree | undefined = undefined,
 >(
@@ -387,12 +359,12 @@ export type NornRunCheckpoint = {
 };
 
 export type NornWorkflowStateReader = {
-	get<T>(state: NornWorkflowStateDefinition<T>): Promise<T>;
-	getOptional<T>(state: NornWorkflowStateDefinition<T>): Promise<T | undefined>;
+	get<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>): Promise<Static<Schema>>;
+	getOptional<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>): Promise<Static<Schema> | undefined>;
 };
 
 export type NornWorkflowState = NornWorkflowStateReader & {
-	set<T>(state: NornWorkflowStateDefinition<T>, value: T): Promise<void>;
+	set<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>, value: NoInfer<Static<Schema>>): Promise<void>;
 };
 
 export type NornWorkflowPluginContext = {
@@ -434,46 +406,30 @@ export type NornCommandRunInput = {
 	readonly timeoutMs?: number;
 };
 
-export const artifactRefSchema = z.object({
-	path: z.string(),
+export const artifactRefSchema = Type.Object({
+	path: Type.String(),
 });
 
-export type NornArtifactRef = z.output<typeof artifactRefSchema>;
-
-const emptyWorkflowRefParamsSchema = z.object({});
-
-export function workflowRefSchema(): z.ZodType<
-	NornWorkflowRefOutput<typeof emptyWorkflowRefParamsSchema>,
-	NornWorkflowRefInput<typeof emptyWorkflowRefParamsSchema>
->;
-export function workflowRefSchema(options: {
-	readonly params?: undefined;
-}): z.ZodType<
-	NornWorkflowRefOutput<typeof emptyWorkflowRefParamsSchema>,
-	NornWorkflowRefInput<typeof emptyWorkflowRefParamsSchema>
->;
-export function workflowRefSchema<ParamsSchema extends z.ZodType>(options: NornWorkflowRefSchemaOptions<ParamsSchema>): z.ZodType<
-	NornWorkflowRefOutput<ParamsSchema>,
-	NornWorkflowRefInput<ParamsSchema>
->;
-export function workflowRefSchema(options?: NornWorkflowRefSchemaOptions): z.ZodType {
-	const contributedParams = options?.params ?? emptyWorkflowRefParamsSchema;
-	const targetSchema = z.union([
-		z.string().min(1),
-		z.object({ id: z.string().min(1) }),
-	]).transform((target) => typeof target === "string" ? target : target.id);
-	return z.union([
-		targetSchema,
-		z.object({ workflow: targetSchema, forwardParams: z.record(z.string(), z.unknown()) }),
-	]).transform((reference) => typeof reference === "string"
-		? { workflow: reference, forwardParams: {} }
-		: reference).meta({
-		"x-norn-workflow-ref": {
-			get contributedParamsSchema() {
-				return z.toJSONSchema(contributedParams, { io: "input" });
-			},
-		},
-	});
+export type NornArtifactRef = StaticDecode<typeof artifactRefSchema>;
+
+const emptyWorkflowRefParamsSchema = Type.Object({});
+const workflowReferenceInputSchema = Type.Union([
+	Type.String({ minLength: 1 }),
+	Type.Object({ workflow: Type.String({ minLength: 1 }), forwardParams: Type.Record(Type.String(), Type.Unknown()) }),
+]);
+
+export function workflowRefSchema<ParamsSchema extends TSchema = typeof emptyWorkflowRefParamsSchema>(options?: NornWorkflowRefSchemaOptions<ParamsSchema>): TCodec<typeof workflowReferenceInputSchema, NornWorkflowRefOutput<ParamsSchema>> {
+	const contributionSchema = options?.params ?? emptyWorkflowRefParamsSchema;
+	return Type.With(Type.Decode(workflowReferenceInputSchema, reference => {
+		const workflowId = typeof reference === "string" ? reference : reference.workflow;
+		const forwardParams = typeof reference === "string" ? {} : reference.forwardParams;
+		return (params: StaticEncode<ParamsSchema> & object): NornRunNext => {
+			Value.Assert(contributionSchema, params);
+			if (!isPlainObject(params)) throw new Error("Workflow reference contributions must be objects");
+			Value.Assert(jsonValueSchema, params);
+			return createWorkflowTransition({ workflowId, params: { ...forwardParams, ...params } });
+		};
+	}), { "x-norn-workflow-ref": { contributedParamsSchema: contributionSchema } });
 }
 
 export type NornLogRef = {
@@ -508,14 +464,14 @@ export type NornAgentCreateSessionInput = {
 	readonly appendSystemPrompt?: readonly string[];
 };
 
-export type NornAgentPromptInput<ResponseSchema extends z.ZodType> = {
+export type NornAgentPromptInput<ResponseSchema extends TSchema> = {
 	readonly prompt: string;
 	readonly response: ResponseSchema;
 	readonly maxAttempts?: number;
 	readonly options?: PromptOptions;
 };
 
-export type NornAgentSinglePromptInput<ResponseSchema extends z.ZodType> = NornAgentCreateSessionInput & NornAgentPromptInput<ResponseSchema>;
+export type NornAgentSinglePromptInput<ResponseSchema extends TSchema> = NornAgentCreateSessionInput & NornAgentPromptInput<ResponseSchema>;
 
 export type NornAgentSessionEvents = EventBus;
 
@@ -600,10 +556,10 @@ export type NornAgentRunRawAttempt = {
 	readonly error?: string;
 };
 
-export type NornAgentRunResult<ResponseSchema extends z.ZodType> = {
+export type NornAgentRunResult<ResponseSchema extends TSchema> = {
 	readonly label: string;
 	readonly cwd: string;
-	readonly response: z.output<ResponseSchema>;
+	readonly response: StaticDecode<ResponseSchema>;
 	readonly usage: NornAgentUsage;
 	readonly raw: {
 		readonly text: string;
@@ -620,7 +576,7 @@ export type NornAgentSession = {
 	readonly label: string;
 	readonly cwd: string;
 	readonly events: NornAgentSessionEvents;
-	prompt<ResponseSchema extends z.ZodType>(input: NornAgentPromptInput<ResponseSchema>): Promise<z.output<ResponseSchema>>;
+	prompt<ResponseSchema extends TSchema>(input: NornAgentPromptInput<ResponseSchema>): Promise<StaticDecode<ResponseSchema>>;
 	dispose(): Promise<void>;
 };
 
@@ -636,7 +592,7 @@ type NornRunBase = {
 	workspace: string;
 	cwd: string;
 	path(relativePath: string): string;
-	next<TWorkflow extends NornWorkflowTarget<any>>(workflow: TWorkflow, params: NornWorkflowTargetParamsInput<TWorkflow>): NornRunNext;
+	next(workflowId: string, params: unknown): NornRunNext;
 	complete(metadata?: NornRunOutcomeMetadata): NornRunComplete;
 	fail(metadata: NornRunOutcomeMetadata & { readonly summary: string }): NornRunFail;
 	resources: import("./resources.ts").NornResources;
@@ -653,7 +609,7 @@ type NornRunBase = {
 	};
 	agents: {
 		createSession(input: NornAgentCreateSessionInput): Promise<NornAgentSession>;
-		prompt<ResponseSchema extends z.ZodType>(input: NornAgentSinglePromptInput<ResponseSchema>): Promise<z.output<ResponseSchema>>;
+		prompt<ResponseSchema extends TSchema>(input: NornAgentSinglePromptInput<ResponseSchema>): Promise<StaticDecode<ResponseSchema>>;
 	};
 };
 
@@ -690,7 +646,7 @@ export type NornPluginDiagnostic = {
 	readonly workflowId: string | null;
 	readonly stage: "import" | "declaration" | "config" | "implementation" | "duplicate" | "schema";
 	readonly message: string;
-	readonly issues: readonly { readonly path: readonly (string | number)[]; readonly code: string; readonly message: string }[];
+	readonly issues: readonly TLocalizedValidationError[];
 };
 
 export type NornProjectLoadStatus = {
@@ -723,7 +679,6 @@ export type NornProjectInfo = {
 	readonly configRoot: string;
 	readonly configFiles: readonly string[];
 	readonly plugins: readonly NornProjectPluginInfo[];
-	readonly seerMode: NornResolvedSeerModeConfig | null;
 };
 
 function assertLocalDeclarationId(id: string, kind: "plugin" | "workflow" | "state"): void {
@@ -752,20 +707,22 @@ function qualifyWorkflow<PluginId extends string, TWorkflow extends NornAnyWorkf
 	declaredIds: Set<string>,
 ): NornQualifiedPluginWorkflow<PluginId, string, TWorkflow> {
 	const id = resolveDeclarationId(pluginId, [key], workflow.id, "workflow", declaredIds);
-	return { kind: WORKFLOW_DECLARATION_KIND, ...workflow, id, isolation: workflow.isolation ?? { mode: "runWorkspace" } } as unknown as NornQualifiedPluginWorkflow<PluginId, string, TWorkflow>;
+	const declaration = (params: unknown): NornRunNext => createWorkflowTransition({ workflowId: id, params });
+	return Object.assign(declaration, { ...workflow, kind: WORKFLOW_DECLARATION_KIND, id, isolation: workflow.isolation ?? { mode: "runWorkspace" } }) as unknown as NornQualifiedPluginWorkflow<PluginId, string, TWorkflow>;
 }
 
-function qualifyStateTree(pluginId: string, node: NornWorkflowPluginStateTreeNode | undefined, path: readonly string[], declaredIds: Set<string>): unknown {
-	if (!node) return undefined;
-	if (isZodSchema(node)) return { id: resolveDeclarationId(pluginId, path, undefined, "state", declaredIds), schema: node };
-	if (isWorkflowStateDefinitionInput(node)) {
+function qualifyStateTree(pluginId: string, node: unknown, path: readonly string[], declaredIds: Set<string>): unknown {
+	if (node === undefined) return undefined;
+	if (isTypeboxSchema(node)) return { id: resolveDeclarationId(pluginId, path, undefined, "state", declaredIds), schema: node };
+	if (path.length > 0 && isWorkflowStateDefinitionInput(node)) {
 		return { ...node, id: resolveDeclarationId(pluginId, path, node.id, "state", declaredIds) };
 	}
+	if (!isPlainObject(node)) throw new Error(`Invalid state declaration: ${[pluginId, ...path].join(".")}`);
 	return Object.fromEntries(Object.entries(node).map(([key, child]) => [key, qualifyStateTree(pluginId, child, [...path, key], declaredIds)]));
 }
 
 export function isWorkflowDeclaration(value: unknown): value is NornAnyWorkflowDeclaration {
-	if (!value || typeof value !== "object") return false;
+	if (typeof value !== "function") return false;
 	const candidate = value as { kind?: unknown; id?: unknown; instructions?: unknown; isEntrypoint?: unknown; params?: unknown; isolation?: { mode?: unknown } };
 	return (
 		candidate.kind === WORKFLOW_DECLARATION_KIND &&
@@ -778,14 +735,13 @@ export function isWorkflowDeclaration(value: unknown): value is NornAnyWorkflowD
 	);
 }
 
-function isWorkflowStateDefinitionInput(value: unknown): value is NornWorkflowStateDefinitionInput<unknown> {
-	if (!value || typeof value !== "object") return false;
-	const candidate = value as { id?: unknown; schema?: unknown };
-	return (candidate.id === undefined || typeof candidate.id === "string") && isZodSchema(candidate.schema);
+function isTypeboxSchema(value: unknown): value is NornStateSchema {
+	return Type.IsUnsafe(value) || Boolean(value && typeof value === "object" && "~kind" in value && typeof value["~kind"] === "string");
 }
 
-function isZodSchema(value: unknown): value is z.ZodType {
-	return Boolean(value && typeof value === "object" && typeof (value as { safeParse?: unknown }).safeParse === "function");
+function isWorkflowStateDefinitionInput(value: unknown): value is NornWorkflowStateDefinitionInput {
+	if (!isPlainObject(value)) return false;
+	return (value.id === undefined || typeof value.id === "string") && isTypeboxSchema(value.schema);
 }
 
 export function isWorkflowPlugin(value: unknown): value is NornWorkflowPlugin {

package/assets/packages/sdk/src/files.ts

@@ -1,18 +1,19 @@
+import { writeTextAtomically } from "@vimhead.dev/norn-core/atomic-files";
+import { isNodeError } from "@vimhead.dev/norn-core/errors";
 import { createHash, randomUUID } from "node:crypto";
 import { lstat, mkdir, mkdtemp, readFile, readdir, realpath, rename, rm, rmdir, unlink, writeFile } from "node:fs/promises";
 import { hostname } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
-import { z } from "zod";
-import { isNodeError } from "@vimhead.dev/norn-core/errors";
-import { writeTextAtomically } from "@vimhead.dev/norn-core/atomic-files";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
 
-const ownerSchema = z.strictObject({
-	token: z.uuid(),
-	pid: z.number().int().positive(),
-	host: z.string(),
-	target: z.string(),
-});
+const ownerSchema = Type.Object({
+	token: Type.String({ format: "uuid" }),
+	pid: Type.Integer({ exclusiveMinimum: 0 }),
+	host: Type.String(),
+	target: Type.String(),
+}, { additionalProperties: false });
 
 export class NornFileCoordinator {
 	private readonly lockRoot: string;
@@ -103,7 +104,7 @@ export class NornFileCoordinator {
 			if (entries.length === 0) return;
 			if (entries.length !== 1) throw new Error(`Invalid file lock ownership: ${input.lockPath}`);
 			const marker = entries[0];
-			const owner = ownerSchema.parse(JSON.parse(await readFile(join(input.lockPath, marker), "utf8")));
+			const owner = Value.Parse(ownerSchema, JSON.parse(await readFile(join(input.lockPath, marker), "utf8")));
 			if (marker !== `${owner.token}.json` || owner.target !== input.target || owner.host !== hostname()) {
 				throw new Error(`Incompatible file lock ownership: ${input.lockPath}`);
 			}

package/assets/packages/sdk/src/index.ts

@@ -3,4 +3,3 @@ export { NornFileCoordinator } from "./files.ts";
 export * from "./resources.ts";
 export * from "./agent-resource-adapter.ts";
 export * from "./state-adapter.ts";
-export * from "./seer/index.ts";

package/assets/packages/sdk/src/resources.ts

@@ -1,5 +1,5 @@
-import type { z } from "zod";
 import type { NornFileCoordinator } from "./files.ts";
+import type { NornJsonValue } from "./schema.ts";
 
 export type NornResourceContext = {
 	readonly mode: "create" | "open";
@@ -10,7 +10,7 @@ export type NornResourceContext = {
 export type NornResourceDefinition<T> = {
 	readonly name: string;
 	readonly kind: string;
-	readonly configuration: z.infer<ReturnType<typeof z.json>>;
+	readonly configuration: NornJsonValue;
 	initialize(context: NornResourceContext): Promise<T>;
 };
 

package/assets/packages/sdk/src/schema.ts

@@ -1,4 +1,46 @@
-import type { NornAnyWorkflowDeclaration } from "./api.ts";
+import { Type, type Static, type TSchema } from "typebox";
+import { Meta } from "typebox/schema";
+import { Value } from "typebox/value";
+import type { NornAnyWorkflowDeclaration, NornJsonSchema } from "./api.ts";
+
+export const jsonValueSchema = Type.Cyclic({
+	Json: Type.Union([
+		Type.Null(), Type.Boolean(), Type.Number(), Type.String(),
+		Type.Array(Type.Ref("Json")),
+		Type.Refine(Type.Record(Type.String(), Type.Ref("Json")), value => Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null),
+	]),
+}, "Json");
+
+export type NornJsonValue = Static<typeof jsonValueSchema>;
+
+export function inspectSchema(schema: TSchema): NornJsonSchema {
+	const inspected: unknown = JSON.parse(JSON.stringify(schema));
+	Value.Assert(Meta["https://json-schema.org/draft/2020-12/schema"], inspected);
+	if (!isPlainObject(inspected)) throw new Error("Norn inspection requires an object schema");
+	assertWorkflowReferenceAnnotations(inspected);
+	return inspected;
+}
+
+function assertWorkflowReferenceAnnotations(schema: unknown): void {
+	if (!isPlainObject(schema)) return;
+	if (Object.hasOwn(schema, "x-norn-workflow-ref")) {
+		const annotation = schema["x-norn-workflow-ref"];
+		if (!isPlainObject(annotation) || !Object.hasOwn(annotation, "contributedParamsSchema")) throw new Error("Invalid workflow reference annotation");
+		Value.Assert(Meta["https://json-schema.org/draft/2020-12/schema"], annotation.contributedParamsSchema);
+		assertWorkflowReferenceAnnotations(annotation.contributedParamsSchema);
+	}
+	for (const keyword of ["properties", "patternProperties", "$defs", "definitions", "dependentSchemas"]) {
+		const schemas = schema[keyword];
+		if (isPlainObject(schemas)) for (const child of Object.values(schemas)) assertWorkflowReferenceAnnotations(child);
+	}
+	for (const keyword of ["allOf", "anyOf", "oneOf", "prefixItems"]) {
+		const schemas = schema[keyword];
+		if (Array.isArray(schemas)) for (const child of schemas) assertWorkflowReferenceAnnotations(child);
+	}
+	for (const keyword of ["additionalProperties", "unevaluatedProperties", "propertyNames", "items", "contains", "not", "if", "then", "else", "unevaluatedItems", "contentSchema"]) {
+		assertWorkflowReferenceAnnotations(schema[keyword]);
+	}
+}
 
 export function assertWorkflowMetadata(workflow: NornAnyWorkflowDeclaration): void {
 	if (workflow.instructions !== undefined && (typeof workflow.instructions !== "string" || workflow.instructions.trim().length === 0)) {
@@ -9,40 +51,22 @@ export function assertWorkflowMetadata(workflow: NornAnyWorkflowDeclaration): vo
 	}
 }
 
-export function unwrapSchema(schema: unknown): unknown {
-	let current = schema;
-	while (true) {
-		const def = schemaDef(current);
-		if (["optional", "nullable", "default", "catch", "readonly", "prefault"].includes(def.type ?? "") && def.innerType) {
-			current = def.innerType;
-			continue;
-		}
-		return current;
-	}
+export function unwrapSchema(schema: TSchema): TSchema {
+	if (!Type.IsUnion(schema)) return schema;
+	const members = schema.anyOf.filter(member => !Type.IsNull(member));
+	return members.length === 1 ? unwrapSchema(members[0]) : schema;
 }
 
-export function schemaShape(schema: unknown): Record<string, unknown> {
-	const shape = schemaDef(unwrapSchema(schema)).shape;
-	if (!shape) return {};
-	return typeof shape === "function" ? shape() as Record<string, unknown> : shape as Record<string, unknown>;
+export function schemaShape(schema: TSchema): Record<string, TSchema> {
+	const unwrapped = unwrapSchema(schema);
+	return Type.IsObject(unwrapped) ? unwrapped.properties : {};
 }
 
-export function schemaType(schema: unknown): string | undefined {
-	return schemaDef(unwrapSchema(schema)).type;
+export function schemaType(schema: TSchema): string | undefined {
+	const unwrapped = unwrapSchema(schema);
+	return "type" in unwrapped && typeof unwrapped.type === "string" ? unwrapped.type : undefined;
 }
 
 export function isPlainObject(value: unknown): value is Record<string, unknown> {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-
-type ZodDef = {
-	readonly type?: string;
-	readonly innerType?: unknown;
-	readonly shape?: unknown;
-};
-
-function schemaDef(schema: unknown): ZodDef {
-	if (!schema || typeof schema !== "object") return {};
-	const candidate = schema as { _def?: ZodDef; def?: ZodDef };
-	return candidate._def ?? candidate.def ?? {};
-}

package/assets/packages/sdk/src/state-adapter.ts

@@ -1,9 +1,9 @@
-import { createHash } from "node:crypto";
 import { defineTool } from "@earendil-works/pi-coding-agent";
+import { createHash } from "node:crypto";
 import { Type } from "typebox";
-import { z } from "zod";
-import type { NornWorkflowState, NornWorkflowStateDefinition } from "./api.ts";
 import type { NornAgentResourceAdapter } from "./agent-resource-adapter.ts";
+import type { NornWorkflowState, NornWorkflowStateDefinition } from "./api.ts";
+import { inspectSchema } from "./schema.ts";
 
 export type NornStateFieldAccess = {
 	readonly field: NornWorkflowStateDefinition;
@@ -34,7 +34,7 @@ export function StateAdapter(input: { readonly state: NornWorkflowState; readonl
 						description: "List only attached workflow-state field IDs, permissions and value schemas. JSON is paginated; use nextOffset until null.",
 						parameters: Type.Object(pageParameters),
 						async execute(_id, params) {
-							return serializePage({ value: [...fields.values()].map(({ field, access }) => ({ id: field.id, access, schema: z.toJSONSchema(field.schema, { io: "input" }) })), ...params });
+							return serializePage({ value: [...fields.values()].map(({ field, access }) => ({ id: field.id, access, schema: inspectSchema(field.schema) })), ...params });
 						},
 					}),
 					defineTool({