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

package/assets/examples/worktree-development-loop/state.ts

@@ -1,12 +1,12 @@
-import { z } from "zod";
 import { artifactRefSchema, type NornWorkflowPluginStateTree } from "@vimhead.dev/norn";
+import { Type } from "typebox";
 import { reviewDecisionSchema } from "./workflows/review/schema.ts";
 
 export const developmentLoopState = {
-	task: z.string(),
-	maxIterations: z.number().int().min(1).max(10),
-	currentIteration: z.number().int().min(1),
-	repositoryPath: z.string(),
+	task: Type.String(),
+	maxIterations: Type.Integer({ minimum: 1, maximum: 10 }),
+	currentIteration: Type.Integer({ minimum: 1 }),
+	repositoryPath: Type.String(),
 } as const satisfies NornWorkflowPluginStateTree;
 
 export const planningState = {
@@ -14,7 +14,7 @@ export const planningState = {
 } as const satisfies NornWorkflowPluginStateTree;
 
 export const implementationState = {
-	implementationSummary: z.string(),
+	implementationSummary: Type.String(),
 } as const satisfies NornWorkflowPluginStateTree;
 
 export const reviewState = {

package/assets/examples/worktree-development-loop/workflows/development-loop/execute.ts

@@ -14,5 +14,5 @@ export async function executeDevelopmentLoopWorkflow(
 	await run.state.set(worktreeDevelopmentLoopManifest.states.developmentLoop.maxIterations, params.maxIterations);
 	await run.state.set(worktreeDevelopmentLoopManifest.states.developmentLoop.currentIteration, 1);
 
-	return run.next(worktreeDevelopmentLoopManifest.workflows.planning, { task: params.task });
+	return worktreeDevelopmentLoopManifest.workflows.planning({ task: params.task });
 }

package/assets/examples/worktree-development-loop/workflows/development-loop/schema.ts

@@ -1,14 +1,14 @@
-import { z } from "zod";
+import { Type, type StaticDecode } from "typebox";
 
-export const developmentLoopConfigSchema = z.object({
-	repositoryRoot: z.string(),
+export const developmentLoopConfigSchema = Type.Object({
+	repositoryRoot: Type.String(),
 });
 
-export const developmentLoopParamsSchema = z.object({
-	task: z.string(),
-	baseRef: z.string().default("HEAD"),
-	maxIterations: z.number().int().min(1).max(10).default(3),
+export const developmentLoopParamsSchema = Type.Object({
+	task: Type.String(),
+	baseRef: Type.String({ default: "HEAD" }),
+	maxIterations: Type.Integer({ minimum: 1, maximum: 10, default: 3 }),
 });
 
-export type DevelopmentLoopConfig = z.output<typeof developmentLoopConfigSchema>;
-export type DevelopmentLoopParams = z.output<typeof developmentLoopParamsSchema>;
+export type DevelopmentLoopConfig = StaticDecode<typeof developmentLoopConfigSchema>;
+export type DevelopmentLoopParams = StaticDecode<typeof developmentLoopParamsSchema>;

package/assets/examples/worktree-development-loop/workflows/implementation/execute.ts

@@ -28,7 +28,7 @@ export async function executeImplementationWorkflow(
 	await ensureCommandSucceeded(status);
 	const statusOutput = await run.logs.read(status.stdoutLog);
 	await run.artifacts.write(`implementation/iteration-${params.iteration}-status.txt`, statusOutput);
-	return run.next(worktreeDevelopmentLoopManifest.workflows.review, {
+	return worktreeDevelopmentLoopManifest.workflows.review({
 		task: params.task,
 		iteration: params.iteration,
 	});

package/assets/examples/worktree-development-loop/workflows/implementation/schema.ts

@@ -1,12 +1,12 @@
-import { z } from "zod";
+import { Type, type StaticDecode } from "typebox";
 
-export const implementationParamsSchema = z.object({
-	task: z.string(),
-	iteration: z.number().int().min(1),
+export const implementationParamsSchema = Type.Object({
+	task: Type.String(),
+	iteration: Type.Integer({ minimum: 1 }),
 });
 
-export const implementationAgentResponseSchema = z.object({
-	summary: z.string(),
+export const implementationAgentResponseSchema = Type.Object({
+	summary: Type.String(),
 });
 
-export type ImplementationParams = z.output<typeof implementationParamsSchema>;
+export type ImplementationParams = StaticDecode<typeof implementationParamsSchema>;

package/assets/examples/worktree-development-loop/workflows/planning/execute.ts

@@ -13,7 +13,7 @@ export async function executePlanningWorkflow(run: NornRun, params: PlanningPara
 	});
 	const planArtifact = await run.artifacts.write("planning/plan.md", planning.plan);
 	await run.state.set(worktreeDevelopmentLoopManifest.states.planning.planArtifact, planArtifact);
-	return run.next(worktreeDevelopmentLoopManifest.workflows.implementation, { task: params.task, iteration: 1 });
+	return worktreeDevelopmentLoopManifest.workflows.implementation({ task: params.task, iteration: 1 });
 }
 
 function buildPlanningPrompt(task: string): string {

package/assets/examples/worktree-development-loop/workflows/planning/schema.ts

@@ -1,12 +1,12 @@
-import { z } from "zod";
+import { Type, type StaticDecode } from "typebox";
 
-export const planningParamsSchema = z.object({
-	task: z.string(),
+export const planningParamsSchema = Type.Object({
+	task: Type.String(),
 });
 
-export const planningAgentResponseSchema = z.object({
-	plan: z.string(),
-	summary: z.string(),
+export const planningAgentResponseSchema = Type.Object({
+	plan: Type.String(),
+	summary: Type.String(),
 });
 
-export type PlanningParams = z.output<typeof planningParamsSchema>;
+export type PlanningParams = StaticDecode<typeof planningParamsSchema>;

package/assets/examples/worktree-development-loop/workflows/review/execute.ts

@@ -24,7 +24,7 @@ export async function executeReviewWorkflow(run: NornRun, params: ReviewParams):
 		response: reviewAgentResponseSchema,
 	});
 	const automatedReviewArtifact = await run.artifacts.write(`review/iteration-${params.iteration}-automated.json`, JSON.stringify(review, null, 2));
-	return run.next(worktreeDevelopmentLoopManifest.workflows.reviewRouter, {
+	return worktreeDevelopmentLoopManifest.workflows.reviewRouter({
 		iteration: params.iteration,
 		decision: review.decision,
 		summary: review.summary,

package/assets/examples/worktree-development-loop/workflows/review/schema.ts

@@ -1,23 +1,23 @@
-import { z } from "zod";
 import { artifactRefSchema } from "@vimhead.dev/norn";
+import { Type, type StaticDecode } from "typebox";
 
-export const reviewDecisionSchema = z.enum(["accept", "revise", "blocked"]);
+export const reviewDecisionSchema = Type.Enum(["accept", "revise", "blocked"]);
 
-export const reviewParamsSchema = z.object({
-	task: z.string(),
-	iteration: z.number().int().min(1),
+export const reviewParamsSchema = Type.Object({
+	task: Type.String(),
+	iteration: Type.Integer({ minimum: 1 }),
 });
 
-export const reviewAgentResponseSchema = z.object({
+export const reviewAgentResponseSchema = Type.Object({
 	decision: reviewDecisionSchema,
-	summary: z.string(),
+	summary: Type.String(),
 });
 
-export const storedReviewSchema = z.object({
+export const storedReviewSchema = Type.Object({
 	decision: reviewDecisionSchema,
-	summary: z.string(),
+	summary: Type.String(),
 	reviewArtifact: artifactRefSchema,
 });
 
-export type ReviewParams = z.output<typeof reviewParamsSchema>;
-export type StoredReview = z.output<typeof storedReviewSchema>;
+export type ReviewParams = StaticDecode<typeof reviewParamsSchema>;
+export type StoredReview = StaticDecode<typeof storedReviewSchema>;

package/assets/examples/worktree-development-loop/workflows/review-router/execute.ts

@@ -47,5 +47,5 @@ export async function executeReviewRouterWorkflow(
 
 	const nextIteration = currentIteration + 1;
 	await run.state.set(worktreeDevelopmentLoopManifest.states.developmentLoop.currentIteration, nextIteration);
-	return run.next(worktreeDevelopmentLoopManifest.workflows.implementation, { task, iteration: nextIteration });
+	return worktreeDevelopmentLoopManifest.workflows.implementation({ task, iteration: nextIteration });
 }

package/assets/examples/worktree-development-loop/workflows/review-router/schema.ts

@@ -1,12 +1,12 @@
-import { z } from "zod";
 import { artifactRefSchema } from "@vimhead.dev/norn";
+import { Type, type StaticDecode } from "typebox";
 import { reviewDecisionSchema } from "../review/schema.ts";
 
-export const reviewRouterParamsSchema = z.object({
-	iteration: z.number().int().min(1),
+export const reviewRouterParamsSchema = Type.Object({
+	iteration: Type.Integer({ minimum: 1 }),
 	decision: reviewDecisionSchema,
-	summary: z.string(),
+	summary: Type.String(),
 	automatedReviewArtifact: artifactRefSchema,
 });
 
-export type ReviewRouterParams = z.output<typeof reviewRouterParamsSchema>;
+export type ReviewRouterParams = StaticDecode<typeof reviewRouterParamsSchema>;

package/assets/package.json

@@ -1 +1 @@
-{"version":"0.1.0-tip.35240723931.1"}
+{"version":"0.1.0-tip.35343816255.1"}

package/assets/packages/cli/src/cli.ts

@@ -1,24 +1,25 @@
-import { spawn } from "node:child_process";
 import { main as runPi } from "@earendil-works/pi-coding-agent";
+import { type DeletedNornRunInfo, type NornAnyWorkflowDeclaration, type NornRunInfo } from "@vimhead.dev/norn";
+import { isNodeError } from "@vimhead.dev/norn-core/errors";
+import { spawn } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import { chmod, mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute, join, resolve } from "node:path";
 import { homedir } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
 import { fileURLToPath } from "node:url";
+import { Value } from "typebox/value";
+import { NORN_BUILD_INFO, type NornBuildInfo, type NornGithubReleaseBinaryBuildInfo } from "./build-info.ts";
 import { renderNornDocumentationIntro, resolveDocumentationCacheRoot, resolveNornDocumentation, type NornDocumentationSource } from "./documentation.ts";
-import { setTimeout as delay } from "node:timers/promises";
-import { discoverNornProject, findNornProject, inspectNornWorkflow, loadNornProject, NORN_PROJECT_FILE_NAME } from "./plugin-loader.ts";
-import { type NornAnyWorkflowDeclaration, type DeletedNornRunInfo, type NornRunInfo } from "@vimhead.dev/norn";
 import { NornEngine } from "./internal/engine.ts";
 import { errorMessage, NornProjectLoadError, NornRunStoppedError } from "./internal/errors.ts";
-import { isNodeError } from "@vimhead.dev/norn-core/errors";
 import { clearRunResumeRequest, readRunLaunchRequest, readRunResumeRequest, writeRunLaunchRequest, writeRunResumeRequest, type NornRunResumeRequest } from "./internal/launch-request.ts";
-import { generateRunName } from "./internal/run-names.ts";
-import { getRunLeaseOwner, NornRunLease } from "./internal/run-lease.ts";
-import { NornRunStore } from "./internal/run-store.ts";
 import { readRunMetrics } from "./internal/metrics.ts";
+import { getRunLeaseOwner, NornRunLease } from "./internal/run-lease.ts";
+import { generateRunName } from "./internal/run-names.ts";
 import { getRunInfo, listRuns, mergeInterruptedWorkflowParams, resolveRunRoot } from "./internal/run-state.ts";
-import { NORN_BUILD_INFO, type NornBuildInfo, type NornGithubReleaseBinaryBuildInfo } from "./build-info.ts";
+import { NornRunStore } from "./internal/run-store.ts";
+import { discoverNornProject, findNornProject, inspectNornWorkflow, loadNornProject, NORN_PROJECT_FILE_NAME } from "./plugin-loader.ts";
 
 const RUNS_ROOT = join(".norn", "runs");
 const RUN_WAIT_INTERVAL_MS = 1000;
@@ -109,7 +110,7 @@ const COMMANDS: readonly CliCommand[] = [
 	{
 		id: "project.inspect",
 		path: ["project", "inspect"],
-		description: "Use when discovering the active Norn project, plugins, workflow sources, and Seer mode.",
+		description: "Use when discovering the active Norn project, plugins, and workflow sources.",
 		usage: "norn project inspect",
 		output: "JSON object with project metadata under project, isComplete, and plugin diagnostics. Incomplete discovery does not permit execution.",
 		examples: ["norn project inspect"],
@@ -118,18 +119,6 @@ const COMMANDS: readonly CliCommand[] = [
 			await inspectProject();
 		},
 	},
-	{
-		id: "seer.inspect",
-		path: ["seer", "inspect"],
-		description: "Use when checking the current project's resolved Seer mode before agent execution.",
-		usage: "norn seer inspect",
-		output: "JSON object with resolved Seer mode under seerMode.",
-		examples: ["norn seer inspect"],
-		execute: async (args) => {
-			assertNoExtraArgs("seer inspect", args);
-			await inspectSeerMode();
-		},
-	},
 	{
 		id: "workflows.list",
 		path: ["workflows", "list"],
@@ -385,7 +374,6 @@ const HELP_COMMAND_ORDER = [
 	"runs.delete",
 	"project.init",
 	"project.inspect",
-	"seer.inspect",
 	"pi",
 	"upgrade",
 	"version",
@@ -413,7 +401,6 @@ const HUMAN_COMMAND_SUMMARIES: Readonly<Record<string, string>> = {
 	"runs.delete": "Delete an inactive run.",
 	"project.init": "Create a Norn project in the current directory.",
 	"project.inspect": "Inspect the Norn project.",
-	"seer.inspect": "Inspect resolved Seer mode.",
 	pi: "Run bundled Pi for authentication, providers, and model setup.",
 	upgrade: "Upgrade the installed Norn CLI.",
 	version: "Print version/build info.",
@@ -781,18 +768,14 @@ async function inspectProject(): Promise<void> {
 	writeJson({ project, isComplete, diagnostics });
 }
 
-async function inspectSeerMode(): Promise<void> {
-	const project = await findNornProject(process.cwd());
-	writeJson({ seerMode: project.seerMode ?? null });
-}
-
 async function startRun(workflowId: string, args: readonly string[]): Promise<void> {
 	assertNoStructuredInputArgs("runs start", args);
 	const project = await loadNornProject(process.cwd());
 	const workflow = project.registry.workflowById(workflowId);
 	if (!workflow) throw new Error(`Unknown workflow: ${workflowId}`);
 	const input = parseStartRunInput(await readStdinJson());
-	const params = workflow.params.parse(input.params ?? {});
+	const params = input.params === undefined ? {} : input.params;
+	Value.Decode(workflow.params, params);
 	const configOverride = input.config;
 	const id = randomUUID();
 	const name = generateRunName(new Set((await listRuns(project.projectRoot)).map((run) => run.name)));
@@ -835,7 +818,7 @@ async function parseResumeParams(runInfo: NornRunInfo, params: unknown): Promise
 		const project = await loadNornProject(process.cwd());
 		const workflow = project.registry.workflowById(runInfo.currentWorkflowId);
 		if (!workflow) throw new Error(`Unknown workflow for resumed run: ${runInfo.currentWorkflowId}`);
-		workflow.params.parse(mergeInterruptedWorkflowParams(runInfo.interruption?.params, params, runInfo.interruption?.fields));
+		Value.Decode(workflow.params, mergeInterruptedWorkflowParams(runInfo.interruption?.params, params, runInfo.interruption?.fields));
 		return params;
 	}
 	if (runInfo.status === "pendingResume") {

package/assets/packages/cli/src/client.ts

@@ -15,7 +15,6 @@ import type {
 import { loadNornProject } from "./plugin-loader.ts";
 import { NornProjectLoadError } from "./internal/errors.ts";
 import type { NornRegisteredWorkflow } from "./internal/workflow-registry.ts";
-import type { NornResolvedSeerModeConfig } from "@vimhead.dev/norn/seer";
 
 export { NornProjectLoadError } from "./internal/errors.ts";
 
@@ -34,9 +33,6 @@ export type NornClient = {
 		entries(): Promise<readonly NornRegisteredWorkflow[]>;
 	};
 	readonly state: NornWorkflowStateReader;
-	readonly seer: {
-		inspect(): Promise<NornResolvedSeerModeConfig | null>;
-	};
 	readonly runs: {
 		start(input: { readonly workflowId: string; readonly params: unknown; readonly configOverride?: unknown }): Promise<NornRunInfo>;
 		resume(input: { readonly run: string; readonly params?: unknown }): Promise<NornRunInfo>;
@@ -66,9 +62,6 @@ export function createNornClient(input: NornClientInput = {}): NornClient {
 			entries: async () => (await catalog.load()).workflows,
 		},
 		state: catalog.state,
-		seer: {
-			inspect: async () => (await processRunner.readJson<{ seerMode: NornResolvedSeerModeConfig | null }>(["seer", "inspect"])).seerMode,
-		},
 		runs: {
 			start: async (startInput) => (await processRunner.readJson<{ run: NornRunInfo }>(["runs", "start", startInput.workflowId], JSON.stringify(runStartInput(startInput)))).run,
 			resume: async (resumeInput) => (await processRunner.readJson<{ run: NornRunInfo }>(["runs", "resume", resumeInput.run], runResumeStdin(resumeInput))).run,

package/assets/packages/cli/src/generated-build-info.ts

@@ -2,8 +2,8 @@ import type { NornBuildInfo } from "./build-info.ts";
 
 export const NORN_GENERATED_BUILD_INFO = {
   "kind": "npm-registry",
-  "version": "0.1.0-tip.35240723931.1",
-  "commit": "f5872d022f9a38d5c0828bf39fa4ad49ca536caa",
+  "version": "0.1.0-tip.35343816255.1",
+  "commit": "c38480c32d1c8ee786f12300bf9e21163440d0a7",
   "packageSpec": "@vimhead.dev/norn-cli@tip",
   "upgrade": {
     "supported": false,

package/assets/packages/cli/src/internal/agent-response-tool.ts

@@ -1,9 +1,9 @@
 import { defineTool, type ToolDefinition } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-import type { z } from "zod";
 import type { NornDispose } from "@vimhead.dev/norn";
 import { AGENT_RESPONSE_TOOL_NAME } from "@vimhead.dev/norn-core/agent-protocol";
-import { zodErrorMessage } from "./errors.ts";
+import { Type, type TSchema } from "typebox";
+import { Value } from "typebox/value";
+import { errorMessage } from "./errors.ts";
 
 export type NornCapturedAgentResponse = {
 	readonly called: boolean;
@@ -12,7 +12,7 @@ export type NornCapturedAgentResponse = {
 
 type PendingAgentResponse = {
 	readonly label: string;
-	readonly responseSchema: z.ZodType;
+	readonly responseSchema: TSchema;
 	called: boolean;
 	response?: unknown;
 };
@@ -28,7 +28,7 @@ type AgentResponseToolDetails = {
 export class NornAgentResponseCollector {
 	private readonly pending = new Map<string, PendingAgentResponse>();
 
-	begin(runId: string, label: string, responseSchema: z.ZodType): NornDispose {
+	begin(runId: string, label: string, responseSchema: TSchema): NornDispose {
 		this.pending.set(runId, { label, responseSchema, called: false });
 		return () => this.pending.delete(runId);
 	}
@@ -40,11 +40,10 @@ export class NornAgentResponseCollector {
 			throw new Error(`Workflow agent response label mismatch: expected ${pending.label}, received ${label}`);
 		}
 		if (pending.called) throw new Error(`Workflow agent response already recorded for ${runId}`);
-		const parsed = pending.responseSchema.safeParse(response);
-		if (!parsed.success) throw new Error(zodErrorMessage(parsed.error));
+		const decoded = Value.Decode(pending.responseSchema, response);
 		pending.called = true;
-		pending.response = parsed.data;
-		return { label: pending.label, response: parsed.data };
+		pending.response = decoded;
+		return { label: pending.label, response: decoded };
 	}
 
 	get(runId: string): NornCapturedAgentResponse {
@@ -81,7 +80,7 @@ export class NornAgentResponseToolFactory {
 						terminate: true,
 					};
 				} catch (error) {
-					return invalidAgentResponseToolResult(error instanceof Error ? error.message : String(error));
+					return invalidAgentResponseToolResult(errorMessage(error));
 				}
 			},
 		});

package/assets/packages/cli/src/internal/agents.ts

@@ -1,27 +1,28 @@
 import {
 	SessionManager,
-	createAgentSessionServices,
 	createAgentSessionFromServices,
+	createAgentSessionServices,
 	createEventBus,
 	type AgentSession,
 	type CreateAgentSessionOptions,
 } from "@earendil-works/pi-coding-agent";
+import type { NornAgentCreateSessionInput, NornAgentPromptInput, NornAgentRunRawAttempt, NornAgentRunResult, NornAgentSession, NornAgentSessionEvents, NornAgentSinglePromptInput, NornAgentUsage } from "@vimhead.dev/norn";
+import { AGENT_RESPONSE_TOOL_NAME } from "@vimhead.dev/norn-core/agent-protocol";
+import { inspectSchema } from "@vimhead.dev/norn/schema";
 import { randomUUID } from "node:crypto";
 import { mkdir } from "node:fs/promises";
 import { homedir } from "node:os";
 import { isAbsolute, relative, resolve, sep } from "node:path";
-import { z } from "zod";
-import type { NornAgentCreateSessionInput, NornAgentPromptInput, NornAgentRunRawAttempt, NornAgentRunResult, NornAgentSessionEvents, NornAgentSession, NornAgentSinglePromptInput, NornAgentUsage } from "@vimhead.dev/norn";
-import { AGENT_RESPONSE_TOOL_NAME } from "@vimhead.dev/norn-core/agent-protocol";
+import { type StaticDecode, type TSchema } from "typebox";
+import { resolveNornAgentDirectory } from "./agent-directory.ts";
 import {
 	NornAgentResponseCollector,
 	NornAgentResponseToolFactory,
 	type NornCapturedAgentResponse,
 } from "./agent-response-tool.ts";
-import { resolveNornAgentDirectory } from "./agent-directory.ts";
 import { errorMessage } from "./errors.ts";
-import type { NornRunLogs } from "./logs.ts";
 import { safeFileName } from "./file-names.ts";
+import type { NornRunLogs } from "./logs.ts";
 import { NornSessionResourceBindings } from "./resource-bindings.ts";
 import type { NornRunLogger } from "./run-log.ts";
 import { agentUsageFromValue, emptyAgentUsage, totalAgentUsage } from "./usage.ts";
@@ -112,7 +113,7 @@ export class NornAgentRunner {
 		}
 	}
 
-	async prompt<ResponseSchema extends z.ZodType>(agentInput: NornAgentSinglePromptInput<ResponseSchema>): Promise<z.output<ResponseSchema>> {
+	async prompt<ResponseSchema extends TSchema>(agentInput: NornAgentSinglePromptInput<ResponseSchema>): Promise<StaticDecode<ResponseSchema>> {
 		const agent = await this.createSession(agentInput);
 		try {
 			return await agent.prompt(agentInput);
@@ -153,11 +154,11 @@ class CreatedNornAgentSession implements NornAgentSession {
 		this.events = input.events;
 	}
 
-	async prompt<ResponseSchema extends z.ZodType>(agentInput: NornAgentPromptInput<ResponseSchema>): Promise<z.output<ResponseSchema>> {
+	async prompt<ResponseSchema extends TSchema>(agentInput: NornAgentPromptInput<ResponseSchema>): Promise<StaticDecode<ResponseSchema>> {
 		return (await this.promptWithResult(agentInput)).response;
 	}
 
-	private async promptWithResult<ResponseSchema extends z.ZodType>(agentInput: NornAgentPromptInput<ResponseSchema>): Promise<NornAgentRunResult<ResponseSchema>> {
+	private async promptWithResult<ResponseSchema extends TSchema>(agentInput: NornAgentPromptInput<ResponseSchema>): Promise<NornAgentRunResult<ResponseSchema>> {
 		if (this.isDisposed) throw new Error(`Workflow agent session is disposed: ${this.label}`);
 		const maxAttempts = Math.max(1, Math.floor(agentInput.maxAttempts ?? DEFAULT_AGENT_ATTEMPTS));
 		const attempts: NornAgentRunRawAttempt[] = [];
@@ -174,7 +175,7 @@ class CreatedNornAgentSession implements NornAgentSession {
 
 				try {
 					if (!raw.responseToolCalled) throw new Error(`Agent did not call ${AGENT_RESPONSE_TOOL_NAME}`);
-					const response = agentInput.response.parse(raw.toolResponse);
+					const response = raw.toolResponse as StaticDecode<ResponseSchema>;
 					const usage = totalAgentUsage(attempts.map((candidate) => candidate.usage));
 					const result: NornAgentRunResult<ResponseSchema> = {
 						label: this.label,
@@ -233,7 +234,7 @@ class CreatedNornAgentSession implements NornAgentSession {
 		await this.input.logger.record({ type: "agent.disposed", label: this.label });
 	}
 
-	private async runAttempt<ResponseSchema extends z.ZodType>(
+	private async runAttempt<ResponseSchema extends TSchema>(
 		agentInput: NornAgentPromptInput<ResponseSchema>,
 		attempt: number,
 		previousError: string | undefined,
@@ -283,7 +284,7 @@ class CreatedNornAgentSession implements NornAgentSession {
 		};
 	}
 
-	private async promptForStructuredResponse<ResponseSchema extends z.ZodType>(
+	private async promptForStructuredResponse<ResponseSchema extends TSchema>(
 		agentInput: NornAgentPromptInput<ResponseSchema>,
 		responseRunId: string,
 		attempt: number,
@@ -318,7 +319,7 @@ function usageFromMessage(message: unknown): NornAgentUsage | undefined {
 
 function withResponseToolInstruction(
 	prompt: string,
-	responseSchema: z.ZodType,
+	responseSchema: TSchema,
 	label: string,
 	responseRunId: string,
 	attempt: number,
@@ -334,13 +335,13 @@ function withResponseToolInstruction(
 		`Pass label exactly as: ${label}`,
 		"Pass the structured workflow response in the tool's response argument.",
 		"The response argument must match this JSON Schema:",
-		JSON.stringify(z.toJSONSchema(responseSchema), null, 2),
+		JSON.stringify(inspectSchema(responseSchema), null, 2),
 		...(attempt > 1 && previousError ? ["", `Previous structured response attempt failed: ${previousError}`] : []),
 	].join("\n");
 }
 
 function withResponseToolFinalizationInstruction(
-	responseSchema: z.ZodType,
+	responseSchema: TSchema,
 	label: string,
 	responseRunId: string,
 	attempt: number,
@@ -354,7 +355,7 @@ function withResponseToolFinalizationInstruction(
 		`Pass label exactly as: ${label}`,
 		"Pass the structured workflow response in the tool's response argument, based on the work you already completed in this session.",
 		"The response argument must match this JSON Schema:",
-		JSON.stringify(z.toJSONSchema(responseSchema), null, 2),
+		JSON.stringify(inspectSchema(responseSchema), null, 2),
 		...(attempt > 1 && previousError ? ["", `Previous structured response attempt failed: ${previousError}`] : []),
 	].join("\n");
 }

package/assets/packages/cli/src/internal/engine.ts

@@ -1,34 +1,35 @@
-import { randomUUID } from "node:crypto";
-import { mkdir } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { initializeRunResources } from "./run-resources.ts";
-import { createRunFileCoordinator } from "@vimhead.dev/norn/files";
 import {
 	type NornAnyWorkflowDeclaration,
 	type NornAnyWorkflowPluginManifest,
 	type NornDispose,
-	type NornRunStartOptions,
 	type NornInterruptedRunResult,
-	type NornRunResult,
 	type NornRunCheckpoint,
 	type NornRunInfo,
+	type NornRunNext,
+	type NornRunResult,
+	type NornRunStartOptions,
 	type NornWorkflowPlugin,
 	type NornWorkflowPluginImplementation,
 	type NornWorkflowPluginImplementationInput,
-	type NornRunNext,
 } from "@vimhead.dev/norn";
+import { createRunFileCoordinator } from "@vimhead.dev/norn/files";
+import { randomUUID } from "node:crypto";
+import { mkdir } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { Value } from "typebox/value";
 import { NornAgentResponseCollector } from "./agent-response-tool.ts";
 import { NornArtifacts } from "./artifacts.ts";
 import { errorMessage, NornRunStoppedError } from "./errors.ts";
-import { NornRunLogs } from "./logs.ts";
 import { clearRunResumeRequest, matchesRunResumeRequest, readOptionalRunResumeRequest, RESUME_START_GRACE_MS, type NornRunResumeRequest } from "./launch-request.ts";
+import { NornRunLogs } from "./logs.ts";
 import { NornRunLease } from "./run-lease.ts";
 import { NornRunLogger } from "./run-log.ts";
+import { initializeRunResources } from "./run-resources.ts";
+import { getRunInfo, mergeInterruptedWorkflowParams, NornRunStateStore, resolveRunRoot, type NornRunState } from "./run-state.ts";
 import { NornRunStore, runCurrentRoot } from "./run-store.ts";
-import { NornRunStateStore, getRunInfo, mergeInterruptedWorkflowParams, resolveRunRoot, type NornRunState } from "./run-state.ts";
 import { NornRunContext } from "./run.ts";
 import { NornMemoryWorkflowState } from "./state-store.ts";
-import { NornWorkflowRegistry, type NornRegisteredWorkflow, type NornWorkflowStepResult } from "./workflow-registry.ts";
+import { decodePluginConfiguration, NornWorkflowRegistry, type NornRegisteredWorkflow, type NornWorkflowStepResult } from "./workflow-registry.ts";
 
 const RUNS_DIR_NAME = ".norn";
 const MANIFEST_FILE_NAME = "manifest.json";
@@ -79,10 +80,11 @@ export class NornEngine {
 	registerPlugin<TManifest extends NornAnyWorkflowPluginManifest>(plugin: NornWorkflowPlugin<TManifest>): NornDispose {
 		this.disposePlugin(plugin.manifest.id);
 		const implementation = this.resolvePluginImplementation(plugin.implementation);
+		const configuration = decodePluginConfiguration({ pluginId: plugin.manifest.id, schema: plugin.manifest.config, value: this.input.config?.[plugin.manifest.id] });
 		const disposers = Object.entries(plugin.manifest.workflows).map(([key, workflow]) => {
 			const workflowImplementation = implementation.workflows[key];
 			if (!workflowImplementation) throw new Error(`Missing implementation for workflow ${plugin.manifest.id}.${key}`);
-			return this.registry.register(workflow, workflowImplementation, { plugin: { id: plugin.manifest.id }, configSchema: plugin.manifest.config, config: this.input.config?.[plugin.manifest.id] });
+			return this.registry.register(workflow, workflowImplementation, { plugin: { id: plugin.manifest.id }, configuration });
 		});
 		this.disposersByPlugin.set(plugin.manifest.id, disposers);
 		return () => {
@@ -170,8 +172,9 @@ export class NornEngine {
 			const workflow = this.registry.workflowById(current.workflowId);
 			if (!workflow) throw new Error(`Unknown workflow for resumed run: ${current.workflowId}`);
 			if (state.status === "interrupted") {
-				const parsedParams = workflow.params.parse(mergeInterruptedWorkflowParams(current.params, params, current.interruption?.fields));
-				await session.state.replaceCurrentParams(parsedParams);
+				const rawParams = mergeInterruptedWorkflowParams(current.params, params, current.interruption?.fields);
+				Value.Decode(workflow.params, rawParams);
+				await session.state.replaceCurrentParams(rawParams);
 				await recordRunEvent(session, { type: "run.resumed", workflowId: workflow.id, cwd: session.run.cwd });
 				const resumedCurrent = session.state.currentState().current;
 				if (!resumedCurrent) throw new Error(`Run is not resumable: ${runRoot}`);
@@ -200,13 +203,12 @@ export class NornEngine {
 				throwIfRunAborted(session.activeRun);
 				const stepRuntime = session.run.forWorkflow(currentStep.workflow);
 				if (shouldPauseForGate(currentStep)) {
-					const parsedParams = currentStep.workflow.params.parse(currentStep.params);
-					const description = await this.registry.describeGate(currentStep.workflow, stepRuntime, parsedParams, session.state.currentState().configOverride);
+					const description = await this.registry.describeGate(currentStep.workflow, stepRuntime, currentStep.params, session.state.currentState().configOverride);
 					const interruption = { description, fields: currentStep.workflow.gate?.fields };
-					await session.state.interruptCurrent(parsedParams, interruption);
+					await session.state.interruptCurrent(currentStep.params, interruption);
 					await recordRunEvent(session, { type: "run.interrupted", workflowId: currentStep.workflow.id });
 					await commitRunBoundary(session, `run interrupted: ${currentStep.workflow.id}`);
-					return interruptedLaunchResult({ id: stepRuntime.id, name: session.state.currentState().name, workspace: stepRuntime.workspace, cwd: stepRuntime.cwd }, currentStep.workflow, parsedParams, interruption);
+					return interruptedLaunchResult({ id: stepRuntime.id, name: session.state.currentState().name, workspace: stepRuntime.workspace, cwd: stepRuntime.cwd }, currentStep.workflow, currentStep.params, interruption);
 				}
 				await session.state.startStep(toRunStateStep(currentStep));
 				const stepResult = await this.executeWorkflowStep(session, currentStep, stepRuntime);

package/assets/packages/cli/src/internal/errors.ts

@@ -1,4 +1,5 @@
 import type { NornPluginDiagnostic } from "@vimhead.dev/norn";
+import { AssertError } from "typebox/value";
 
 export class NornProjectLoadError extends Error {
 	readonly code = "NORN_PROJECT_INVALID";
@@ -22,18 +23,11 @@ export class NornRunStoppedError extends Error {
 	}
 }
 
-export function zodErrorMessage(error: unknown): string {
-	const issues = (error as { issues?: Array<{ path?: unknown[]; message?: string }> }).issues;
-	if (!Array.isArray(issues) || issues.length === 0) return errorMessage(error);
-	return issues
-		.slice(0, 3)
-		.map((issue) => {
-			const path = Array.isArray(issue.path) && issue.path.length > 0 ? `${issue.path.join(".")}: ` : "";
-			return `${path}${issue.message ?? "Invalid workflow response"}`;
-		})
-		.join("; ");
+export function schemaErrorMessage(error: AssertError): string {
+	return error.cause.errors.slice(0, 3).map(issue => `${issue.instancePath || "/"}: ${issue.message}`).join("; ");
 }
 
 export function errorMessage(error: unknown): string {
+	if (error instanceof AssertError) return schemaErrorMessage(error);
 	return error instanceof Error ? error.message : String(error);
 }