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

package/dist/internal/errors.d.ts

@@ -1,4 +1,5 @@
 import type { NornPluginDiagnostic } from "@vimhead.dev/norn";
+import { AssertError } from "typebox/value";
 export declare class NornProjectLoadError extends Error {
     readonly code = "NORN_PROJECT_INVALID";
     readonly isComplete = false;
@@ -10,5 +11,5 @@ export declare class NornProjectLoadError extends Error {
 export declare class NornRunStoppedError extends Error {
     constructor();
 }
-export declare function zodErrorMessage(error: unknown): string;
+export declare function schemaErrorMessage(error: AssertError): string;
 export declare function errorMessage(error: unknown): string;

package/dist/internal/errors.js

@@ -1,4 +1,5 @@
 // src/internal/errors.ts
+import { AssertError } from "typebox/value";
 var NornProjectLoadError = class extends Error {
   code = "NORN_PROJECT_INVALID";
   isComplete = false;
@@ -19,20 +20,16 @@ var NornRunStoppedError = class extends Error {
     this.name = "NornRunStoppedError";
   }
 };
-function zodErrorMessage(error) {
-  const issues = error.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("; ");
+function schemaErrorMessage(error) {
+  return error.cause.errors.slice(0, 3).map((issue) => `${issue.instancePath || "/"}: ${issue.message}`).join("; ");
 }
 function errorMessage(error) {
+  if (error instanceof AssertError) return schemaErrorMessage(error);
   return error instanceof Error ? error.message : String(error);
 }
 export {
   NornProjectLoadError,
   NornRunStoppedError,
   errorMessage,
-  zodErrorMessage
+  schemaErrorMessage
 };

package/dist/internal/run-state.js

@@ -41,6 +41,8 @@ async function writeTextAtomically(path, content) {
 // src/internal/run-state.ts
 import { createRunFileCoordinator } from "@vimhead.dev/norn/files";
 import { runCurrentRoot } from "./run-store.js";
+import { jsonValueSchema } from "@vimhead.dev/norn/schema";
+import { Value } from "typebox/value";
 var RUN_STATE_FILE_NAME = "run-state.json";
 var LEGACY_RUN_STATE_FILE_NAME = "runtime-state.json";
 function mergeInterruptedWorkflowParams(currentParams, params, fields) {
@@ -165,11 +167,13 @@ var NornRunStateStore = class _NornRunStateStore {
     await this.files.withExclusiveLock(this.path, async (path) => {
       const current = parseNornRunState(await readRunStateFile({ path, legacyPath: join(dirname2(this.path), LEGACY_RUN_STATE_FILE_NAME) }));
       const next = { ...current, ...patch, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+      if (next.current?.params !== void 0) Value.Assert(jsonValueSchema, next.current.params);
       await writeJsonAtomically(path, next);
       this.state = next;
     });
   }
   async write() {
+    if (this.state.current?.params !== void 0) Value.Assert(jsonValueSchema, this.state.current.params);
     await mkdir2(dirname2(this.path), { recursive: true });
     await this.files.withExclusiveLock(this.path, (path) => writeJsonAtomically(path, this.state));
   }

package/dist/internal/run.d.ts

@@ -1,5 +1,5 @@
 import type { CreateAgentSessionOptions } from "@earendil-works/pi-coding-agent";
-import type { NornAnyWorkflowDeclaration, NornProjectRun, NornRunOutcomeMetadata, NornWorkflowIsolationMode, NornWorkflowTarget, NornWorkflowTargetParamsInput, NornRun } from "@vimhead.dev/norn";
+import type { NornAnyWorkflowDeclaration, NornProjectRun, NornRunOutcomeMetadata, NornWorkflowIsolationMode, NornRun } from "@vimhead.dev/norn";
 import type { NornAgentResponseCollector } from "./agent-response-tool.ts";
 import type { NornArtifacts } from "./artifacts.ts";
 import type { NornRunLogs } from "./logs.ts";
@@ -41,7 +41,7 @@ export declare class NornRunContext implements NornProjectRun {
     private createAgentRunner;
     path(relativePath: string): string;
     projectPath(relativePath: string): string;
-    next<TWorkflow extends NornWorkflowTarget<any>>(workflow: TWorkflow, params: NornWorkflowTargetParamsInput<TWorkflow>): ReturnType<NornRun["next"]>;
+    next(workflowId: string, params: unknown): ReturnType<NornRun["next"]>;
     complete(metadata?: NornRunOutcomeMetadata): ReturnType<NornRun["complete"]>;
     fail(metadata: NornRunOutcomeMetadata & {
         readonly summary: string;

package/dist/internal/run.js

@@ -1,5 +1,13 @@
 // src/internal/run.ts
 import { isAbsolute, relative, resolve, sep } from "node:path";
+
+// ../core/src/workflow-transition.ts
+function createWorkflowTransition(input) {
+  if (typeof input.workflowId !== "string" || input.workflowId.trim().length === 0) throw new Error("Workflow transition requires a nonempty workflow ID");
+  return { type: "next", workflowId: input.workflowId, params: input.params };
+}
+
+// src/internal/run.ts
 import { NornAgentRunner } from "./agents.js";
 import { NornCommandRunner } from "./commands.js";
 var NornRunContext = class _NornRunContext {
@@ -74,12 +82,8 @@ var NornRunContext = class _NornRunContext {
   projectPath(relativePath) {
     return this.resolveFromRoot(this.projectRoot, this.projectRoot, relativePath);
   }
-  next(workflow, params) {
-    return {
-      type: "next",
-      workflowId: typeof workflow === "string" ? workflow : workflow.id,
-      params
-    };
+  next(workflowId, params) {
+    return createWorkflowTransition({ workflowId, params });
   }
   complete(metadata) {
     return { type: "complete", metadata };

package/dist/internal/state-store.d.ts

@@ -1,10 +1,11 @@
-import type { NornWorkflowStateDefinition, NornWorkflowState } from "@vimhead.dev/norn";
+import type { NornWorkflowState, NornWorkflowStateDefinition } from "@vimhead.dev/norn";
 import type { NornFileCoordinator } from "@vimhead.dev/norn/files";
+import type { Static, TSchema } from "typebox";
 export declare class NornMemoryWorkflowState implements NornWorkflowState {
     private readonly data;
-    get<T>(state: NornWorkflowStateDefinition<T>): Promise<T>;
-    getOptional<T>(state: NornWorkflowStateDefinition<T>): Promise<T | undefined>;
-    set<T>(state: NornWorkflowStateDefinition<T>, value: T): Promise<void>;
+    get<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>): Promise<Static<Schema>>;
+    getOptional<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>): Promise<Static<Schema> | undefined>;
+    set<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>, value: NoInfer<Static<Schema>>): Promise<void>;
 }
 export declare class NornJsonWorkflowState implements NornWorkflowState {
     private readonly input;
@@ -15,8 +16,8 @@ export declare class NornJsonWorkflowState implements NornWorkflowState {
         readonly coordinateMutation: <T>(path: string, operation: () => Promise<T>) => Promise<T>;
     });
     initialize(mode: "create" | "open"): Promise<void>;
-    get<T>(state: NornWorkflowStateDefinition<T>): Promise<T>;
-    getOptional<T>(state: NornWorkflowStateDefinition<T>): Promise<T | undefined>;
-    set<T>(state: NornWorkflowStateDefinition<T>, value: T): Promise<void>;
+    get<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>): Promise<Static<Schema>>;
+    getOptional<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>): Promise<Static<Schema> | undefined>;
+    set<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>, value: NoInfer<Static<Schema>>): Promise<void>;
     private readStateFile;
 }

package/dist/internal/state-store.js

@@ -1,5 +1,7 @@
-// src/internal/state-store.ts
-import { readFile } from "node:fs/promises";
+// ../core/src/atomic-files.ts
+import { randomUUID } from "node:crypto";
+import { chmod, mkdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
 
 // ../core/src/errors.ts
 function isNodeError(error) {
@@ -7,9 +9,6 @@ function isNodeError(error) {
 }
 
 // ../core/src/atomic-files.ts
-import { randomUUID } from "node:crypto";
-import { chmod, mkdir, rename, rm, stat, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
 async function writeJsonAtomically(path, value) {
   await writeTextAtomically(path, `${JSON.stringify(value, null, 2)}
 `);
@@ -34,6 +33,13 @@ async function writeTextAtomically(path, content) {
 }
 
 // src/internal/state-store.ts
+import { jsonValueSchema } from "@vimhead.dev/norn/schema";
+import { readFile } from "node:fs/promises";
+import { Value } from "typebox/value";
+function copyStateValue(schema, value) {
+  Value.Assert(jsonValueSchema, value);
+  return structuredClone(Value.Parse(schema, value));
+}
 var NornMemoryWorkflowState = class {
   data = /* @__PURE__ */ new Map();
   async get(state) {
@@ -43,10 +49,10 @@ var NornMemoryWorkflowState = class {
   }
   async getOptional(state) {
     if (!this.data.has(state.id)) return void 0;
-    return state.schema.parse(this.data.get(state.id));
+    return copyStateValue(state.schema, this.data.get(state.id));
   }
   async set(state, value) {
-    this.data.set(state.id, state.schema.parse(value));
+    this.data.set(state.id, copyStateValue(state.schema, value));
   }
 };
 var NornJsonWorkflowState = class {
@@ -74,10 +80,10 @@ var NornJsonWorkflowState = class {
   async getOptional(state) {
     const data = await this.input.files.withExclusiveLock(this.stateFile, (path) => this.readStateFile(path));
     if (!Object.prototype.hasOwnProperty.call(data, state.id)) return void 0;
-    return state.schema.parse(data[state.id]);
+    return copyStateValue(state.schema, data[state.id]);
   }
   async set(state, value) {
-    const parsedValue = state.schema.parse(value);
+    const parsedValue = copyStateValue(state.schema, value);
     await this.input.coordinateMutation(this.stateFile, () => this.input.files.withExclusiveLock(this.stateFile, async (path) => {
       const data = await this.readStateFile(path);
       Object.defineProperty(data, state.id, { value: parsedValue, enumerable: true, configurable: true, writable: true });

package/dist/internal/workflow-registry.d.ts

@@ -1,12 +1,21 @@
-import { z } from "zod";
-import { type NornAnyWorkflowDeclaration, type NornInspectedWorkflowInfo, type NornRegisteredWorkflowInfo, type NornRunComplete, type NornDispose, type NornRunFail, type NornWorkflowImplementation, type NornRunNext, type NornRunFor, type NornWorkflowPluginInfo } from "@vimhead.dev/norn";
+import { type NornAnyWorkflowDeclaration, type NornDispose, type NornInspectedWorkflowInfo, type NornRegisteredWorkflowInfo, type NornRunComplete, type NornRunFail, type NornRunFor, type NornRunNext, type NornWorkflowImplementation, type NornWorkflowPluginInfo } from "@vimhead.dev/norn";
+import { type TSchema } from "typebox";
 export type NornRegisteredWorkflow = {
     workflow: NornAnyWorkflowDeclaration;
     implementation: NornWorkflowImplementation<NornAnyWorkflowDeclaration, unknown>;
-    configSchema?: z.ZodType;
-    config: unknown;
+    configuration?: NornRegisteredConfiguration;
     plugin?: NornWorkflowPluginInfo;
 };
+export type NornRegisteredConfiguration = {
+    readonly schema: TSchema;
+    readonly input: unknown;
+    readonly value: unknown;
+};
+export declare function decodePluginConfiguration(input: {
+    readonly pluginId: string;
+    readonly schema: TSchema | undefined;
+    readonly value: unknown;
+}): NornRegisteredConfiguration | undefined;
 export type NornWorkflowStepResult = NornRunNext | {
     readonly type: "complete";
     readonly workflow: NornAnyWorkflowDeclaration;
@@ -20,8 +29,7 @@ export declare class NornWorkflowRegistry {
     private readonly entries;
     register<TWorkflow extends NornAnyWorkflowDeclaration>(workflow: TWorkflow, implementation: NornWorkflowImplementation<TWorkflow, unknown>, metadata?: {
         readonly plugin?: NornWorkflowPluginInfo;
-        readonly configSchema?: z.ZodType;
-        readonly config?: unknown;
+        readonly configuration?: NornRegisteredConfiguration;
     }): NornDispose;
     list(options?: {
         readonly entrypointsOnly?: boolean;

package/dist/internal/workflow-registry.js

@@ -1,7 +1,15 @@
 // src/internal/workflow-registry.ts
-import { z } from "zod";
 import { isWorkflowComplete, isWorkflowFail, isWorkflowNext } from "@vimhead.dev/norn";
-import { assertWorkflowMetadata, isPlainObject, schemaShape, schemaType, unwrapSchema } from "@vimhead.dev/norn/schema";
+import { assertWorkflowMetadata, inspectSchema, isPlainObject, schemaShape, schemaType, unwrapSchema } from "@vimhead.dev/norn/schema";
+import { Value } from "typebox/value";
+function decodePluginConfiguration(input) {
+  if (!input.schema) {
+    if (input.value !== void 0) throw new Error(`Norn config provided for plugin without config schema: ${input.pluginId}`);
+    return void 0;
+  }
+  const value = defaultConfigInput(input.schema, input.value);
+  return { schema: input.schema, input: value, value: Value.Decode(input.schema, value) };
+}
 var NornWorkflowRegistry = class {
   entries = /* @__PURE__ */ new Map();
   register(workflow, implementation, metadata = {}) {
@@ -9,8 +17,7 @@ var NornWorkflowRegistry = class {
     const entry = {
       workflow,
       implementation,
-      configSchema: metadata.configSchema,
-      config: metadata.configSchema ? metadata.configSchema.parse(defaultConfigInput(metadata.configSchema, metadata.config)) : void 0,
+      configuration: metadata.configuration,
       plugin: metadata.plugin
     };
     assertWorkflowMetadata(workflow);
@@ -38,7 +45,7 @@ var NornWorkflowRegistry = class {
     const entry = this.entries.get(workflow.id);
     if (!entry) throw new Error(`Unknown workflow: ${workflow.id}`);
     if (!workflow.gate) throw new Error(`Workflow is not gated: ${workflow.id}`);
-    const parsedParams = workflow.params.parse(params);
+    const parsedParams = Value.Decode(workflow.params, params);
     const parsedConfig = parseExecutionConfig(entry, configOverride);
     const description = await entry.implementation.gate?.describe(run, parsedParams, parsedConfig);
     return validateGateDescription(description ?? workflow.id, workflow.id);
@@ -46,7 +53,7 @@ var NornWorkflowRegistry = class {
   async execute(workflow, run, params, configOverride) {
     const entry = this.entries.get(workflow.id);
     if (!entry) throw new Error(`Unknown workflow: ${workflow.id}`);
-    const parsedParams = workflow.params.parse(params);
+    const parsedParams = Value.Decode(workflow.params, params);
     const parsedConfig = parseExecutionConfig(entry, configOverride);
     const result = await entry.implementation.execute(run, parsedParams, parsedConfig);
     if (isWorkflowNext(result)) return result;
@@ -64,13 +71,13 @@ function defaultConfigInput(configSchema, config) {
 }
 function parseExecutionConfig(entry, configOverride) {
   const pluginConfigOverride = pluginConfigOverrideInput(entry, configOverride);
-  if (!entry.configSchema) {
+  if (!entry.configuration) {
     if (pluginConfigOverride !== void 0) throw new Error(`Run config override provided for plugin without config schema: ${entry.plugin?.id ?? entry.workflow.id}`);
     return void 0;
   }
-  if (pluginConfigOverride === void 0) return entry.config;
-  const rawConfig = isPlainObject(entry.config) && isPlainObject(pluginConfigOverride) ? deepMerge(entry.config, pluginConfigOverride) : pluginConfigOverride;
-  return entry.configSchema.parse(rawConfig);
+  if (pluginConfigOverride === void 0) return entry.configuration.value;
+  const rawConfig = isPlainObject(entry.configuration.input) && isPlainObject(pluginConfigOverride) ? deepMerge(entry.configuration.input, pluginConfigOverride) : pluginConfigOverride;
+  return Value.Decode(entry.configuration.schema, rawConfig);
 }
 function pluginConfigOverrideInput(entry, configOverride) {
   if (configOverride === void 0) return void 0;
@@ -105,7 +112,7 @@ function validateGateDescription(description, workflowId) {
 function inspectedWorkflowInfo(entry) {
   return {
     ...workflowInfo(entry),
-    paramsSchema: jsonSchema(entry.workflow.params),
+    paramsSchema: inspectSchema(entry.workflow.params),
     gate: gateInfo(entry.workflow)
   };
 }
@@ -121,9 +128,7 @@ function workflowInfo(entry) {
 function gateInfo(workflow) {
   return workflow.gate ? { enabled: true, fields: workflow.gate.fields } : null;
 }
-function jsonSchema(schema) {
-  return z.toJSONSchema(schema, { io: "input" });
-}
 export {
-  NornWorkflowRegistry
+  NornWorkflowRegistry,
+  decodePluginConfiguration
 };

package/dist/plugin-loader.d.ts

@@ -1,27 +1,22 @@
-import { z } from "zod";
 import { type NornProjectInspection, type NornProjectPluginInfo, type NornWorkflowCatalogInfo, type NornWorkflowInspection, type NornWorkflowPlugin } from "@vimhead.dev/norn";
+import * as typeboxModule from "typebox";
+import { type StaticDecode } from "typebox";
 import { NornMemoryWorkflowState } from "./internal/state-store.ts";
 import { NornWorkflowRegistry, type NornRegisteredWorkflow } from "./internal/workflow-registry.ts";
-import { type NornResolvedSeerModeConfig } from "@vimhead.dev/norn/seer";
 export declare const NORN_PROJECT_FILE_NAME = "norn.project.json";
-declare const nornConfigSchema: z.ZodObject<{
-    plugins: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    includes: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>;
-declare const nornProjectConfigSchema: z.ZodObject<{
-    plugins: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    includes: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    version: z.ZodDefault<z.ZodLiteral<1>>;
-    seerMode: z.ZodOptional<z.ZodObject<{
-        writableRoots: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-type NornConfig = z.output<typeof nornConfigSchema> & {
-    readonly seerMode?: never;
-};
-type NornProjectConfig = z.output<typeof nornProjectConfigSchema>;
+declare const nornConfigSchema: typeboxModule.TObject<{
+    plugins: typeboxModule.TArray<typeboxModule.TString>;
+    includes: typeboxModule.TArray<typeboxModule.TString>;
+    config: typeboxModule.TRecord<"^.*$", typeboxModule.TUnknown>;
+}>;
+declare const nornProjectConfigSchema: typeboxModule.TObject<{
+    version: typeboxModule.TLiteral<1>;
+    plugins: typeboxModule.TArray<typeboxModule.TString>;
+    includes: typeboxModule.TArray<typeboxModule.TString>;
+    config: typeboxModule.TRecord<"^.*$", typeboxModule.TUnknown>;
+}>;
+type NornConfig = StaticDecode<typeof nornConfigSchema>;
+type NornProjectConfig = StaticDecode<typeof nornProjectConfigSchema>;
 type NornConfigFile = {
     readonly path: string;
     readonly root: string;
@@ -36,7 +31,6 @@ export type NornProject = {
     readonly config: NornProjectConfig;
     readonly configFiles: readonly NornConfigFile[];
     readonly projectConfig: Record<string, unknown>;
-    readonly seerMode?: NornResolvedSeerModeConfig;
 };
 export type NornLoadedProject = NornProject & {
     readonly plugins: readonly NornWorkflowPlugin[];

package/dist/plugin-loader.js

@@ -1,17 +1,6 @@
 // src/plugin-loader.ts
-import { access, readFile, readdir } from "node:fs/promises";
-import { dirname, isAbsolute, join, resolve, sep } from "node:path";
-import { pathToFileURL } from "node:url";
-import { createJiti } from "jiti/static";
-import * as typeboxModule from "typebox";
-import { z } from "zod";
-import * as zodModule from "zod";
 import * as nornModule from "@vimhead.dev/norn";
-import * as nornFilesModule from "@vimhead.dev/norn/files";
-import * as nornSchemaModule from "@vimhead.dev/norn/schema";
-import * as nornSeerModule from "@vimhead.dev/norn/seer";
 import { isWorkflowPlugin } from "@vimhead.dev/norn";
-import { errorMessage, NornProjectLoadError } from "./internal/errors.js";
 
 // ../core/src/errors.ts
 function isNodeError(error) {
@@ -19,22 +8,31 @@ function isNodeError(error) {
 }
 
 // src/plugin-loader.ts
+import * as nornFilesModule from "@vimhead.dev/norn/files";
+import * as nornSchemaModule from "@vimhead.dev/norn/schema";
+import { inspectSchema } from "@vimhead.dev/norn/schema";
+import { createJiti } from "jiti/static";
+import { access, readdir, readFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, resolve, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+import * as typeboxModule from "typebox";
+import { Type } from "typebox";
+import * as typeboxCompileModule from "typebox/compile";
+import * as typeboxSchemaModule from "typebox/schema";
+import * as typeboxValueModule from "typebox/value";
+import { AssertError, Value } from "typebox/value";
+import { errorMessage, NornProjectLoadError } from "./internal/errors.js";
 import { NornMemoryWorkflowState } from "./internal/state-store.js";
-import { NornWorkflowRegistry } from "./internal/workflow-registry.js";
-import { schemaType, unwrapSchema } from "@vimhead.dev/norn/schema";
-import { resolveSeerModeConfig } from "@vimhead.dev/norn/seer";
+import { decodePluginConfiguration, NornWorkflowRegistry } from "./internal/workflow-registry.js";
 var NORN_PROJECT_FILE_NAME = "norn.project.json";
-var seerModeConfigSchema = z.object({
-  writableRoots: z.array(z.string().min(1)).min(1)
+var nornConfigSchema = Type.Object({
+  plugins: Type.Array(Type.String({ minLength: 1 }), { default: [] }),
+  includes: Type.Array(Type.String({ minLength: 1 }), { default: [] }),
+  config: Type.Record(Type.String(), Type.Unknown(), { default: {} })
 });
-var nornConfigSchema = z.object({
-  plugins: z.array(z.string().min(1)).default([]),
-  includes: z.array(z.string().min(1)).default([]),
-  config: z.record(z.string(), z.unknown()).default({})
-});
-var nornProjectConfigSchema = nornConfigSchema.extend({
-  version: z.literal(1).default(1),
-  seerMode: seerModeConfigSchema.optional()
+var nornProjectConfigSchema = Type.Object({
+  ...nornConfigSchema.properties,
+  version: Type.Literal(1, { default: 1 })
 });
 async function loadNornProject(cwd) {
   const { project, diagnostics } = await collectNornProject(cwd);
@@ -73,8 +71,7 @@ function buildProjectInfo(project) {
     configPath: project.configPath,
     configRoot: project.configRoot,
     configFiles: project.configFiles.map((file) => file.path),
-    plugins: project.pluginInfos,
-    seerMode: project.seerMode ?? null
+    plugins: project.pluginInfos
   };
 }
 async function findNornProject(cwd) {
@@ -89,8 +86,7 @@ async function findNornProject(cwd) {
     configRoot: projectRootConfig.root,
     config: projectRootConfig.config,
     configFiles,
-    projectConfig: mergeProjectConfig(configFiles),
-    seerMode: resolveSeerModeConfig({ configPath: projectRootConfig.path, configRoot: projectRootConfig.root, seerMode: projectRootConfig.config.seerMode })
+    projectConfig: mergeProjectConfig(configFiles)
   };
 }
 async function findNearestNornProject(cwd) {
@@ -127,11 +123,11 @@ async function loadNornConfigTree(configFile, visitedPaths) {
   return [configFile, ...descendants.flat()];
 }
 async function readNornProjectConfigFile(path) {
-  const config = nornProjectConfigSchema.parse(JSON.parse(await readFile(path, "utf8")));
+  const config = Value.Parse(nornProjectConfigSchema, Value.Default(nornProjectConfigSchema, JSON.parse(await readFile(path, "utf8"))));
   return { path, root: dirname(path), config };
 }
 async function readNornConfigFile(path) {
-  const config = nornConfigSchema.parse(JSON.parse(await readFile(path, "utf8")));
+  const config = Value.Parse(nornConfigSchema, Value.Default(nornConfigSchema, JSON.parse(await readFile(path, "utf8"))));
   return { path, root: dirname(path), config };
 }
 function createProjectConfigEntry(projectFile) {
@@ -227,15 +223,14 @@ function registerProjectPlugin(input) {
   let stage = "config";
   try {
     const configInput = input.project.projectConfig[plugin.manifest.id];
-    if (!plugin.manifest.config && configInput !== void 0) throw new Error(`Norn config provided for plugin without config schema: ${plugin.manifest.id}`);
-    const config = plugin.manifest.config ? plugin.manifest.config.parse(defaultConfigInput(plugin.manifest.config, configInput)) : void 0;
+    const configuration = decodePluginConfiguration({ pluginId: plugin.manifest.id, schema: plugin.manifest.config, value: configInput });
     stage = "schema";
     const info = {
       id: plugin.manifest.id,
       path: source.pluginPath,
       configPath: source.configPath,
-      configSchema: plugin.manifest.config ? z.toJSONSchema(plugin.manifest.config, { io: "input" }) : null,
-      config
+      configSchema: plugin.manifest.config ? inspectSchema(plugin.manifest.config) : null,
+      config: configuration?.value
     };
     stage = "implementation";
     const implementation = typeof plugin.implementation === "function" ? plugin.implementation({ cwd: input.project.cwd, state: input.state }) : plugin.implementation;
@@ -247,9 +242,9 @@ function registerProjectPlugin(input) {
         stage = "duplicate";
         if (input.registry.workflowById(workflow.id)) throw new Error(`Workflow already registered: ${workflow.id}`);
         stage = "declaration";
-        unregister.push(input.registry.register(workflow, workflowImplementation, { plugin: workflowPluginInfo(info), configSchema: plugin.manifest.config, config }));
+        unregister.push(input.registry.register(workflow, workflowImplementation, { plugin: workflowPluginInfo(info), configuration }));
       } catch (error) {
-        diagnostics.push(createPluginDiagnostic({ source, workflowId: workflow.id, stage: error instanceof z.ZodError ? "config" : stage, error }));
+        diagnostics.push(createPluginDiagnostic({ source, workflowId: workflow.id, stage, error }));
       }
     }
     if (diagnostics.length === 0) return { loaded: { plugin, info }, diagnostics };
@@ -265,11 +260,7 @@ function createPluginDiagnostic(input) {
     workflowId: input.workflowId,
     stage: input.stage,
     message: errorMessage(input.error),
-    issues: input.error instanceof z.ZodError ? input.error.issues.map((issue) => ({
-      path: issue.path.map((part) => typeof part === "symbol" ? String(part) : part),
-      code: issue.code,
-      message: issue.message
-    })) : []
+    issues: input.error instanceof AssertError ? input.error.cause.errors : []
   };
 }
 function workflowPluginInfo(info) {
@@ -280,9 +271,10 @@ function nornWorkflowVirtualModules() {
     "@vimhead.dev/norn": nornModule,
     "@vimhead.dev/norn/files": nornFilesModule,
     "@vimhead.dev/norn/schema": nornSchemaModule,
-    "@vimhead.dev/norn/seer": nornSeerModule,
     typebox: typeboxModule,
-    zod: zodModule
+    "typebox/value": typeboxValueModule,
+    "typebox/compile": typeboxCompileModule,
+    "typebox/schema": typeboxSchemaModule
   };
 }
 function mergeProjectConfig(configFiles) {
@@ -315,10 +307,6 @@ function mergeProjectConfigObjects(base, override) {
 function isPlainObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-function defaultConfigInput(configSchema, config) {
-  if (config !== void 0) return config;
-  return schemaType(unwrapSchema(configSchema)) === "object" ? {} : void 0;
-}
 async function expandIncludePath(configRoot, includePath) {
   const resolvedIncludePath = resolveConfigPath(configRoot, includePath);
   if (!hasGlobSegment(includePath)) return [resolvedIncludePath];

package/dist/resources.d.ts

@@ -1,5 +1,5 @@
-import { type NornFileCoordinator } from "@vimhead.dev/norn/files";
 import type { NornResourceDefinition, NornResources } from "@vimhead.dev/norn";
+import { type NornFileCoordinator } from "@vimhead.dev/norn/files";
 export declare class NornRunResources implements NornResources {
     private readonly runRoot;
     readonly files: NornFileCoordinator;

package/dist/resources.js

@@ -1,9 +1,7 @@
-// src/resources.ts
-import { mkdir as mkdir2, readFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
-import { isDeepStrictEqual } from "node:util";
-import { z } from "zod";
-import { createRunFileCoordinator } from "@vimhead.dev/norn/files";
+// ../core/src/atomic-files.ts
+import { randomUUID } from "node:crypto";
+import { chmod, mkdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
 
 // ../core/src/errors.ts
 function isNodeError(error) {
@@ -11,9 +9,6 @@ function isNodeError(error) {
 }
 
 // ../core/src/atomic-files.ts
-import { randomUUID } from "node:crypto";
-import { chmod, mkdir, rename, rm, stat, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
 async function writeJsonAtomically(path, value) {
   await writeTextAtomically(path, `${JSON.stringify(value, null, 2)}
 `);
@@ -38,8 +33,15 @@ async function writeTextAtomically(path, content) {
 }
 
 // src/resources.ts
-var definitionSchema = z.strictObject({ name: z.string(), kind: z.string().min(1), configuration: z.json() });
-var recordSchema = definitionSchema.extend({ isInitialized: z.boolean() });
+import { createRunFileCoordinator } from "@vimhead.dev/norn/files";
+import { jsonValueSchema } from "@vimhead.dev/norn/schema";
+import { mkdir as mkdir2, readFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { isDeepStrictEqual } from "node:util";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var definitionSchema = Type.Object({ name: Type.String(), kind: Type.String({ minLength: 1 }), configuration: jsonValueSchema }, { additionalProperties: false });
+var recordSchema = Type.Object({ ...definitionSchema.properties, isInitialized: Type.Boolean() }, { additionalProperties: false });
 var NornRunResources = class _NornRunResources {
   constructor(runRoot) {
     this.runRoot = runRoot;
@@ -55,7 +57,7 @@ var NornRunResources = class _NornRunResources {
   }
   async ensure(definition) {
     if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(definition.name)) throw new Error(`Invalid resource name: ${definition.name}`);
-    const identity = definitionSchema.parse({ name: definition.name, kind: definition.kind, configuration: definition.configuration });
+    const identity = structuredClone(Value.Parse(definitionSchema, { name: definition.name, kind: definition.kind, configuration: definition.configuration }));
     const existing = this.entries.get(definition.name);
     if (existing) {
       if (!isDeepStrictEqual(existing.definition, identity)) throw new Error(`Incompatible resource definition: ${definition.name}`);
@@ -77,7 +79,7 @@ var NornRunResources = class _NornRunResources {
     return this.files.withExclusiveLock(join(directory, "definition.json"), async (path) => {
       let stored;
       try {
-        stored = recordSchema.parse(JSON.parse(await readFile(path, "utf8")));
+        stored = Value.Parse(recordSchema, JSON.parse(await readFile(path, "utf8")));
       } catch (error) {
         if (!isNodeError(error) || error.code !== "ENOENT") throw error;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vimhead.dev/norn-cli",
-  "version": "0.1.0-tip.35240723931.1",
+  "version": "0.1.0-tip.35343816255.1",
   "description": "Harness-agnostic runtime for agent-driven and code-driven workflows, built primarily for agents.",
   "type": "module",
   "license": "MIT",
@@ -42,9 +42,8 @@
   "dependencies": {
     "@earendil-works/pi-coding-agent": "0.85.1",
     "jiti": "^2.7.0",
-    "typebox": "^1.3.17",
-    "zod": "^4.4.3",
-    "@vimhead.dev/norn": "0.1.0-tip.35240723931.1"
+    "typebox": "^1.3.33",
+    "@vimhead.dev/norn": "0.1.0-tip.35343816255.1"
   },
   "scripts": {
     "build": "node ../../scripts/build-package.ts"