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

package/assets/tests/workflow-ref.test.ts

@@ -1,113 +1,157 @@
+import { artifactRefSchema, definePluginManifest, isWorkflowDeclaration, isWorkflowPluginManifest, workflowRefSchema, type NornWorkflowRefSchemaOptions } from "@vimhead.dev/norn";
+import { inspectSchema } from "@vimhead.dev/norn/schema";
 import assert from "node:assert/strict";
-import { expect, test } from "vitest";
-import { z } from "zod";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+import { expect, expectTypeOf, test } from "vitest";
 
-import { artifactRefSchema, definePluginManifest, workflowRefSchema } from "@vimhead.dev/norn";
+const manifest = definePluginManifest({
+	id: "refs", workflows: { finish: { isEntrypoint: false, params: Type.Object({ report: Type.String() }) } },
+});
+const target = manifest.workflows.finish;
 
-const target = definePluginManifest({
-	id: "refs", workflows: { finish: { isEntrypoint: false, params: z.object({ report: z.string() }) } },
-}).workflows.finish;
+test("callable declarations retain metadata and construct transitions without execution", () => {
+	expectTypeOf(target.id).toEqualTypeOf<"refs.finish">();
+	assert.equal(isWorkflowDeclaration(target), true);
+	assert.equal(isWorkflowPluginManifest(manifest), true);
+	assert.equal(isWorkflowDeclaration(() => undefined), false);
+	assert.equal(Value.Check(target.params, { report: "done" }), true);
+	assert.deepEqual(target.isolation, { mode: "runWorkspace" });
+	assert.deepEqual(target({ report: "done" }), { type: "next", workflowId: target.id, params: { report: "done" } });
+});
 
-for (const reference of ["refs.finish", { id: "refs.finish" }, target]) {
-	test(`workflow references normalize ${typeof reference === "string" ? "strings" : "kind" in reference ? "declarations" : "id objects"}`, () => {
-		const schema = workflowRefSchema({ params: z.object({ report: z.string() }) });
-		assert.deepEqual(schema.parse(reference), { workflow: "refs.finish", forwardParams: {} });
-		assert.deepEqual(schema.parse({ workflow: reference, forwardParams: { task: "retain" } }), {
-			workflow: "refs.finish", forwardParams: { task: "retain" },
-		});
+for (const reference of ["refs.finish", target.id]) {
+	test("workflow references decode into contribution-taking transition builders", () => {
+		const contributions = Type.Object({ report: Type.String() });
+		const options: NornWorkflowRefSchemaOptions<typeof contributions> = { params: contributions };
+		const schema = workflowRefSchema(options);
+		assert.deepEqual(Value.Decode(workflowRefSchema({}), reference)({}), { type: "next", workflowId: "refs.finish", params: {} });
+		interface Report { report: string }
+		const report: Report = { report: "done" };
+		assert.deepEqual(Value.Decode(schema, reference)(report), target(report));
+		const input = { workflow: reference, forwardParams: { task: "retain", report: "stale" } };
+		const next = Value.Decode(schema, input);
+		assert.deepEqual(next({ report: "done" }), { type: "next", workflowId: reference, params: { task: "retain", report: "done" } });
+		assert.deepEqual(next({ report: "again" }).params, { task: "retain", report: "again" });
+		assert.deepEqual(input.forwardParams, { task: "retain", report: "stale" });
+		assert.throws(() => Reflect.apply(next, undefined, [{}]));
 	});
 }
 
-test("required and nullable reference inputs remain required in JSON inspection", () => {
-	const schema = z.object({ next: workflowRefSchema().nullable() });
-	const inspected = z.toJSONSchema(schema, { io: "input" });
+test("nullable reference inputs retain their required property and input union", () => {
+	const schema = Type.Object({ next: Type.Union([workflowRefSchema(), Type.Null()]) });
+	const inspected = inspectSchema(schema);
 	assert.deepEqual(inspected.required, ["next"]);
-	assert.equal(schema.safeParse({}).success, false);
-	assert.equal(schema.safeParse({ next: null }).success, true);
-	assert.equal(schema.safeParse({ next: "refs.finish" }).success, true);
-	expect(inspected).toHaveProperty("properties.next.anyOf.0.anyOf.0.anyOf.0.type", "string");
+	assert.equal(Value.Check(schema, {}), false);
+	assert.equal(Value.Check(schema, { next: null }), true);
+	assert.equal(Value.Check(schema, { next: "refs.finish" }), true);
+	expect(inspected).toHaveProperty("properties.next.anyOf.0.anyOf.0.type", "string");
 	expect(inspected).toHaveProperty("properties.next.anyOf.0.anyOf.1.required", ["workflow", "forwardParams"]);
 });
 
-test("optional reference inputs are optional in both validation and inspection", () => {
-	const schema = z.object({ next: workflowRefSchema().optional() });
-	assert.deepEqual(schema.parse({}), {});
-	assert.equal(z.toJSONSchema(schema, { io: "input" }).required?.includes("next") ?? false, false);
+test("optional reference properties remain optional in validation and inspection", () => {
+	const schema = Type.Object({ next: Type.Optional(workflowRefSchema()) });
+	assert.deepEqual(Value.Decode(schema, {}), {});
+	assert.equal(inspectSchema(schema).required, undefined);
 });
 
-test("inspection advertises contributions alongside the unchanged reference and forward-params input schema", () => {
-	const contributions = z.object({
+test("inspection advertises encoded contributions and invocation does not decode them", () => {
+	let decodes = 0;
+	const contributions = Type.Object({
 		records: artifactRefSchema,
-		count: z.string().transform(Number),
-		label: z.string().default("collected"),
+		count: Type.Decode(Type.String(), value => { decodes++; return Number(value); }),
+		label: Type.Optional(Type.String({ default: "collected" })),
 	});
-	const reference = workflowRefSchema({ params: contributions }).describe("Continue with the collected records");
-	const schema = z.object({ next: reference });
-	const inspected = z.toJSONSchema(schema, { io: "input" });
-	expect(inspected).toHaveProperty("properties.next.x-norn-workflow-ref.contributedParamsSchema", z.toJSONSchema(contributions, { io: "input" }));
+	const reference = Type.With(workflowRefSchema({ params: contributions }), { description: "Continue with the collected records" });
+	const schema = Type.Object({ next: reference });
+	const inspected = inspectSchema(schema);
+	expect(inspected).toHaveProperty("properties.next.x-norn-workflow-ref.contributedParamsSchema", inspectSchema(contributions));
 	expect(inspected).toHaveProperty("properties.next.description", "Continue with the collected records");
-	expect(inspected).toHaveProperty("properties.next.anyOf", z.toJSONSchema(workflowRefSchema(), { io: "input" }).anyOf);
-	expect(inspected).toHaveProperty("properties.next.anyOf.1.properties.forwardParams.type", "object");
-	expect(inspected).toHaveProperty("properties.next.anyOf.1.properties.forwardParams.additionalProperties", {});
-	expect(inspected).toHaveProperty("properties.next.anyOf.1.required", ["workflow", "forwardParams"]);
+	expect(inspected).toHaveProperty("properties.next.anyOf", inspectSchema(workflowRefSchema()).anyOf);
+	expect(inspected).toHaveProperty("properties.next.anyOf.1.properties.forwardParams.patternProperties", { "^.*$": {} });
 	expect(inspected).toHaveProperty("properties.next.x-norn-workflow-ref.contributedParamsSchema.required", ["records", "count"]);
 	expect(inspected).toHaveProperty("properties.next.x-norn-workflow-ref.contributedParamsSchema.properties.count.type", "string");
 	const forwardParams = { taskId: "task-42", nested: { labels: ["one", "two"], enabled: false, absent: null } };
-	const input = { next: { workflow: "refs.finish", forwardParams } };
-	assert.deepEqual(schema.parse(input), input);
+	const next = Value.Decode(schema, { next: { workflow: "refs.finish", forwardParams } }).next;
+	const contribution = { records: { path: "records.json" }, count: "2" };
+	assert.deepEqual(next(contribution).params, { ...forwardParams, ...contribution });
+	assert.equal(decodes, 0);
+	assert.throws(() => Reflect.apply(next, undefined, [{ records: { path: "records.json" }, count: 2 }]));
 });
 
-test("references without declared contributions advertise an empty contribution schema", () => {
-	for (const reference of [workflowRefSchema(), workflowRefSchema({ params: undefined })]) {
-		expect(z.toJSONSchema(reference, { io: "input" })).toHaveProperty("x-norn-workflow-ref.contributedParamsSchema", z.toJSONSchema(z.object({}), { io: "input" }));
-		assert.deepEqual(reference.parse("refs.finish"), { workflow: "refs.finish", forwardParams: {} });
-	}
+test("references without contributions advertise an empty object schema", () => {
+	const reference = workflowRefSchema();
+	expect(inspectSchema(reference)).toHaveProperty("x-norn-workflow-ref.contributedParamsSchema", inspectSchema(Type.Object({})));
+	assert.deepEqual(Value.Decode(reference, "refs.finish")({}), { type: "next", workflowId: "refs.finish", params: {} });
 });
 
-test("optional, nullable and array references retain their contribution annotations", () => {
-	const reference = workflowRefSchema({ params: z.object({ report: z.string() }) });
-	const schema = z.object({ optional: reference.optional(), nullable: reference.nullable(), many: z.array(reference) });
-	const inspected = z.toJSONSchema(schema, { io: "input" });
-	const expected = z.toJSONSchema(z.object({ report: z.string() }), { io: "input" });
+test("optional, nullable and array references retain annotations and callable codecs", () => {
+	const reference = workflowRefSchema({ params: Type.Object({ report: Type.String() }) });
+	const schema = Type.Object({ optional: Type.Optional(reference), nullable: Type.Union([reference, Type.Null()]), many: Type.Array(reference) });
+	const inspected = inspectSchema(schema);
 	for (const path of ["properties.optional", "properties.nullable.anyOf.0", "properties.many.items"]) {
-		expect(inspected).toHaveProperty(`${path}.x-norn-workflow-ref.contributedParamsSchema`, expected);
+		expect(inspected).toHaveProperty(`${path}.x-norn-workflow-ref.contributedParamsSchema`, inspectSchema(Type.Object({ report: Type.String() })));
 	}
 	assert.deepEqual(inspected.required, ["nullable", "many"]);
-	assert.deepEqual(schema.parse({ nullable: null, many: ["refs.finish"] }), { nullable: null, many: [{ workflow: "refs.finish", forwardParams: {} }] });
+	const decoded = Value.Decode(schema, { nullable: null, many: ["refs.finish"], optional: "refs.finish" });
+	assert.equal(decoded.nullable, null);
+	assert.deepEqual(decoded.many[0]({ report: "array" }), target({ report: "array" }));
+	assert.deepEqual(decoded.optional!({ report: "optional" }), target({ report: "optional" }));
 });
 
-test("nested continuation schemas retain their own contribution and forwarding contracts", () => {
-	const finalContributions = z.object({ summary: z.string() });
-	const contributions = z.object({
-		records: artifactRefSchema,
-		next: workflowRefSchema({ params: finalContributions }),
-	});
-	const inspected = z.toJSONSchema(workflowRefSchema({ params: contributions }), { io: "input" });
-	const path = "x-norn-workflow-ref.contributedParamsSchema.properties.next";
-	expect(inspected).toHaveProperty(`${path}.x-norn-workflow-ref.contributedParamsSchema`, z.toJSONSchema(finalContributions, { io: "input" }));
-	expect(inspected).toHaveProperty(`${path}.anyOf.1.properties.forwardParams.type`, "object");
-	expect(inspected).toHaveProperty(`${path}.anyOf.1.properties.forwardParams.additionalProperties`, {});
+test("nested references retain encoded payloads in contributed parameters", () => {
+	const finalContributions = Type.Object({ summary: Type.String() });
+	const contributions = Type.Object({ records: artifactRefSchema, next: workflowRefSchema({ params: finalContributions }) });
+	const reference = workflowRefSchema({ params: contributions });
+	expect(inspectSchema(reference)).toHaveProperty("x-norn-workflow-ref.contributedParamsSchema.properties.next.x-norn-workflow-ref.contributedParamsSchema", inspectSchema(finalContributions));
+	const params = { records: { path: "records.json" }, next: { workflow: "refs.finish", forwardParams: { batch: 1 } } };
+	const transition = Value.Decode(reference, "intermediate")(params);
+	assert.deepEqual(transition.params, params);
+	assert.deepEqual(Value.Decode(contributions, transition.params).next({ summary: "done" }).params, { batch: 1, summary: "done" });
 });
 
-test("lazy recursive contribution schemas are resolved during inspection, not reference construction", () => {
-	type Contribution = { label: string; children: Contribution[] };
-	let contributions: z.ZodType<Contribution>;
-	const lazyContributions = z.lazy(() => contributions);
-	const reference = workflowRefSchema({ params: lazyContributions });
-	contributions = z.object({ label: z.string(), children: z.array(z.lazy(() => contributions)) });
-	const inspected = z.toJSONSchema(reference, { io: "input" });
-	expect(inspected).toHaveProperty("x-norn-workflow-ref.contributedParamsSchema", z.toJSONSchema(lazyContributions, { io: "input" }));
-	assert.deepEqual(reference.parse("refs.finish"), { workflow: "refs.finish", forwardParams: {} });
+test("recursive contributions use native TypeBox definitions", () => {
+	const contributions = Type.Cyclic({ Contribution: Type.Object({ label: Type.String(), children: Type.Array(Type.Ref("Contribution")) }) }, "Contribution");
+	const reference = workflowRefSchema({ params: contributions });
+	expect(inspectSchema(reference)).toHaveProperty("x-norn-workflow-ref.contributedParamsSchema", inspectSchema(contributions));
+	const params = { label: "root", children: [{ label: "leaf", children: [] }] };
+	assert.deepEqual(Value.Decode(reference, "refs.finish")(params).params, params);
 });
 
-test("an unrepresentable contribution schema does not change reference parsing", () => {
-	const reference = workflowRefSchema({ params: z.custom(() => true) });
-	assert.deepEqual(reference.parse("refs.finish"), { workflow: "refs.finish", forwardParams: {} });
-	assert.throws(() => z.toJSONSchema(reference, { io: "input" }));
+test("object-valued unions, records, intersections and root codecs can contribute", () => {
+	const union = workflowRefSchema({ params: Type.Union([Type.Object({ kind: Type.Literal("ok"), report: Type.String() }), Type.Object({ kind: Type.Literal("error"), reason: Type.String() })]) });
+	assert.deepEqual(Value.Decode(union, "target")({ kind: "error", reason: "failed" }).params, { kind: "error", reason: "failed" });
+	const record = workflowRefSchema({ params: Type.Record(Type.String(), Type.Integer()) });
+	assert.deepEqual(Value.Decode(record, "target")({ first: 1 }).params, { first: 1 });
+	const intersection = workflowRefSchema({ params: Type.Intersect([Type.Object({ left: Type.String() }), Type.Object({ right: Type.Integer() })]) });
+	assert.deepEqual(Value.Decode(intersection, "target")({ left: "x", right: 2 }).params, { left: "x", right: 2 });
+	const codec = workflowRefSchema({ params: Type.Decode(Type.Object({ text: Type.String() }), value => value.text) });
+	assert.deepEqual(Value.Decode(codec, "target")({ text: "encoded" }).params, { text: "encoded" });
+	const unknown = Value.Decode(workflowRefSchema({ params: Type.Unknown() }), "target");
+	for (const value of [null, [], "text", 1]) assert.throws(() => Reflect.apply(unknown, undefined, [value]), /contributions must be objects/);
+	for (const value of [new Date(), { callback: () => undefined }]) assert.throws(() => Reflect.apply(unknown, undefined, [value]));
+});
+
+test("non-JSON contributions fail explicit inspection without preventing construction", () => {
+	const reference = workflowRefSchema({ params: Type.BigInt() });
+	assert.equal(typeof Value.Decode(reference, "refs.finish"), "function");
+	assert.throws(() => inspectSchema(reference));
+	const nested = workflowRefSchema({ params: Type.Object({ next: reference }) });
+	assert.throws(() => inspectSchema(Type.Object({ next: Type.Optional(Type.Array(nested)) })));
+});
+
+test("inspection traverses schema positions, not defaults, examples or property-name maps", () => {
+	const payload = { "x-norn-workflow-ref": { contributedParamsSchema: { type: "bigint" } } };
+	const schema = Type.Object({ "x-norn-workflow-ref": Type.String() }, { default: payload, examples: [payload] });
+	assert.doesNotThrow(() => inspectSchema(schema));
+	const invalid = workflowRefSchema({ params: Type.BigInt() });
+	for (const wrapper of [Type.Record(Type.String(), invalid), Type.Tuple([invalid]), Type.Object({}, { additionalProperties: invalid }), Type.Cyclic({ Root: Type.Object({ child: invalid }) }, "Root")]) {
+		assert.throws(() => inspectSchema(wrapper));
+	}
 });
 
-for (const input of [undefined, null, "", 3, {}, { id: "" }, { workflow: "refs.finish" }, { workflow: "", forwardParams: {} }, { workflow: "refs.finish", forwardParams: null }]) {
-	test(`invalid workflow reference is rejected: ${JSON.stringify(input)}`, () => {
-		assert.equal(workflowRefSchema().safeParse(input).success, false);
+for (const input of [undefined, null, "", 3, {}, { workflow: "refs.finish" }, { workflow: "", forwardParams: {} }, { workflow: "refs.finish", forwardParams: null }, { workflow: target, forwardParams: {} }]) {
+	test(`reference input schema rejects invalid shape without coercion: ${JSON.stringify(input)}`, () => {
+		assert.equal(Value.Check(workflowRefSchema(), input), false);
 	});
 }

package/dist/cli.js

@@ -1,16 +1,5 @@
 // src/cli.ts
-import { spawn } from "node:child_process";
 import { main as runPi } from "@earendil-works/pi-coding-agent";
-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 { fileURLToPath } from "node:url";
-import { renderNornDocumentationIntro, resolveDocumentationCacheRoot, resolveNornDocumentation } from "./documentation.js";
-import { setTimeout as delay } from "node:timers/promises";
-import { discoverNornProject, findNornProject, inspectNornWorkflow, loadNornProject, NORN_PROJECT_FILE_NAME } from "./plugin-loader.js";
-import { NornEngine } from "./internal/engine.js";
-import { errorMessage, NornProjectLoadError, NornRunStoppedError } from "./internal/errors.js";
 
 // ../core/src/errors.ts
 function isNodeError(error) {
@@ -18,13 +7,25 @@ function isNodeError(error) {
 }
 
 // src/cli.ts
+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 { 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 } from "./build-info.js";
+import { renderNornDocumentationIntro, resolveDocumentationCacheRoot, resolveNornDocumentation } from "./documentation.js";
+import { NornEngine } from "./internal/engine.js";
+import { errorMessage, NornProjectLoadError, NornRunStoppedError } from "./internal/errors.js";
 import { clearRunResumeRequest, readRunLaunchRequest, readRunResumeRequest, writeRunLaunchRequest, writeRunResumeRequest } from "./internal/launch-request.js";
-import { generateRunName } from "./internal/run-names.js";
-import { getRunLeaseOwner, NornRunLease } from "./internal/run-lease.js";
-import { NornRunStore } from "./internal/run-store.js";
 import { readRunMetrics } from "./internal/metrics.js";
+import { getRunLeaseOwner, NornRunLease } from "./internal/run-lease.js";
+import { generateRunName } from "./internal/run-names.js";
 import { getRunInfo, listRuns, mergeInterruptedWorkflowParams, resolveRunRoot } from "./internal/run-state.js";
-import { NORN_BUILD_INFO } from "./build-info.js";
+import { NornRunStore } from "./internal/run-store.js";
+import { discoverNornProject, findNornProject, inspectNornWorkflow, loadNornProject, NORN_PROJECT_FILE_NAME } from "./plugin-loader.js";
 var RUNS_ROOT = join(".norn", "runs");
 var RUN_WAIT_INTERVAL_MS = 1e3;
 var CLI_DESCRIPTION = "Norn is a harness-agnostic runtime for agent-driven and code-driven workflows, built primarily for agents. Build workflows with the Norn SDK; use this JSON-native CLI to discover workflows, start or resume runs, inspect evidence, and manage the installed runtime.";
@@ -111,7 +112,7 @@ var COMMANDS = [
   {
     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"],
@@ -120,18 +121,6 @@ var COMMANDS = [
       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"],
@@ -386,7 +375,6 @@ var HELP_COMMAND_ORDER = [
   "runs.delete",
   "project.init",
   "project.inspect",
-  "seer.inspect",
   "pi",
   "upgrade",
   "version",
@@ -413,7 +401,6 @@ var HUMAN_COMMAND_SUMMARIES = {
   "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.",
@@ -712,17 +699,14 @@ async function inspectProject() {
   const { project, isComplete, diagnostics } = await discoverNornProject(process.cwd());
   writeJson({ project, isComplete, diagnostics });
 }
-async function inspectSeerMode() {
-  const project = await findNornProject(process.cwd());
-  writeJson({ seerMode: project.seerMode ?? null });
-}
 async function startRun(workflowId, args) {
   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 === void 0 ? {} : 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)));
@@ -763,7 +747,7 @@ async function parseResumeParams(runInfo, params) {
     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/dist/client.d.ts

@@ -1,6 +1,5 @@
 import type { DeletedNornRunInfo, NornProjectInspection, NornWorkflowCatalogInfo, NornWorkflowInspection, NornRunCheckpoint, NornRunInfo, NornRunMetrics, NornWorkflowStateReader } from "@vimhead.dev/norn";
 import type { NornRegisteredWorkflow } from "./internal/workflow-registry.ts";
-import type { NornResolvedSeerModeConfig } from "@vimhead.dev/norn/seer";
 export { NornProjectLoadError } from "./internal/errors.ts";
 export type NornClientInput = {
     readonly spawnCwd?: string;
@@ -18,9 +17,6 @@ export type NornClient = {
         entries(): Promise<readonly NornRegisteredWorkflow[]>;
     };
     readonly state: NornWorkflowStateReader;
-    readonly seer: {
-        inspect(): Promise<NornResolvedSeerModeConfig | null>;
-    };
     readonly runs: {
         start(input: {
             readonly workflowId: string;

package/dist/client.js

@@ -18,9 +18,6 @@ function createNornClient(input = {}) {
       entries: async () => (await catalog.load()).workflows
     },
     state: catalog.state,
-    seer: {
-      inspect: async () => (await processRunner.readJson(["seer", "inspect"])).seerMode
-    },
     runs: {
       start: async (startInput) => (await processRunner.readJson(["runs", "start", startInput.workflowId], JSON.stringify(runStartInput(startInput)))).run,
       resume: async (resumeInput) => (await processRunner.readJson(["runs", "resume", resumeInput.run], runResumeStdin(resumeInput))).run,

package/dist/generated-build-info.d.ts

@@ -1,7 +1,7 @@
 export declare const NORN_GENERATED_BUILD_INFO: {
     readonly kind: "npm-registry";
-    readonly version: "0.1.0-tip.35240723931.1";
-    readonly commit: "f5872d022f9a38d5c0828bf39fa4ad49ca536caa";
+    readonly version: "0.1.0-tip.35343816255.1";
+    readonly commit: "c38480c32d1c8ee786f12300bf9e21163440d0a7";
     readonly packageSpec: "@vimhead.dev/norn-cli@tip";
     readonly upgrade: {
         readonly supported: false;

package/dist/generated-build-info.js

@@ -1,8 +1,8 @@
 // src/generated-build-info.ts
 var 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/dist/internal/agent-response-tool.d.ts

@@ -1,13 +1,13 @@
 import { type ToolDefinition } from "@earendil-works/pi-coding-agent";
-import type { z } from "zod";
 import type { NornDispose } from "@vimhead.dev/norn";
+import { type TSchema } from "typebox";
 export type NornCapturedAgentResponse = {
     readonly called: boolean;
     readonly response?: unknown;
 };
 export declare class NornAgentResponseCollector {
     private readonly pending;
-    begin(runId: string, label: string, responseSchema: z.ZodType): NornDispose;
+    begin(runId: string, label: string, responseSchema: TSchema): NornDispose;
     capture(runId: string, label: string, response: unknown): {
         label: string;
         response: unknown;

package/dist/internal/agent-response-tool.js

@@ -1,12 +1,13 @@
 // src/internal/agent-response-tool.ts
 import { defineTool } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
 
 // ../core/src/agent-protocol.ts
 var AGENT_RESPONSE_TOOL_NAME = "pi_workflows_agent_response";
 
 // src/internal/agent-response-tool.ts
-import { zodErrorMessage } from "./errors.js";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+import { errorMessage } from "./errors.js";
 var NornAgentResponseCollector = class {
   pending = /* @__PURE__ */ new Map();
   begin(runId, label, responseSchema) {
@@ -20,11 +21,10 @@ var NornAgentResponseCollector = class {
       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) {
     const pending = this.pending.get(runId);
@@ -61,7 +61,7 @@ var NornAgentResponseToolFactory = class {
             terminate: true
           };
         } catch (error) {
-          return invalidAgentResponseToolResult(error instanceof Error ? error.message : String(error));
+          return invalidAgentResponseToolResult(errorMessage(error));
         }
       }
     });

package/dist/internal/agents.d.ts

@@ -1,6 +1,6 @@
 import { type CreateAgentSessionOptions } from "@earendil-works/pi-coding-agent";
-import { z } from "zod";
 import type { NornAgentCreateSessionInput, NornAgentSession, NornAgentSinglePromptInput } from "@vimhead.dev/norn";
+import { type StaticDecode, type TSchema } from "typebox";
 import { NornAgentResponseCollector } from "./agent-response-tool.ts";
 import type { NornRunLogs } from "./logs.ts";
 import type { NornRunLogger } from "./run-log.ts";
@@ -23,7 +23,7 @@ export declare class NornAgentRunner {
     private readonly responseToolFactory;
     constructor(input: NornAgentRunnerInput);
     createSession(agentInput: NornAgentCreateSessionInput): Promise<NornAgentSession>;
-    prompt<ResponseSchema extends z.ZodType>(agentInput: NornAgentSinglePromptInput<ResponseSchema>): Promise<z.output<ResponseSchema>>;
+    prompt<ResponseSchema extends TSchema>(agentInput: NornAgentSinglePromptInput<ResponseSchema>): Promise<StaticDecode<ResponseSchema>>;
     private resolveFromCwd;
 }
 export {};

package/dist/internal/agents.js

@@ -1,24 +1,24 @@
 // src/internal/agents.ts
 import {
   SessionManager,
-  createAgentSessionServices,
   createAgentSessionFromServices,
+  createAgentSessionServices,
   createEventBus
 } from "@earendil-works/pi-coding-agent";
-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";
 
 // ../core/src/agent-protocol.ts
 var AGENT_RESPONSE_TOOL_NAME = "pi_workflows_agent_response";
 
 // src/internal/agents.ts
+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 { resolveNornAgentDirectory } from "./agent-directory.js";
 import {
   NornAgentResponseToolFactory
 } from "./agent-response-tool.js";
-import { resolveNornAgentDirectory } from "./agent-directory.js";
 import { errorMessage } from "./errors.js";
 import { safeFileName } from "./file-names.js";
 import { NornSessionResourceBindings } from "./resource-bindings.js";
@@ -163,7 +163,7 @@ var CreatedNornAgentSession = class {
         attempts.push(rawAttempt);
         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;
           const usage = totalAgentUsage(attempts.map((candidate) => candidate.usage));
           const result = {
             label: this.label,
@@ -310,7 +310,7 @@ function withResponseToolInstruction(prompt, responseSchema, label, responseRunI
     `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");
 }
@@ -323,7 +323,7 @@ function withResponseToolFinalizationInstruction(responseSchema, label, response
     `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/dist/internal/engine.d.ts

@@ -1,4 +1,4 @@
-import { type NornAnyWorkflowDeclaration, type NornAnyWorkflowPluginManifest, type NornDispose, type NornRunStartOptions, type NornRunResult, type NornRunCheckpoint, type NornRunInfo, type NornWorkflowPlugin } from "@vimhead.dev/norn";
+import { type NornAnyWorkflowDeclaration, type NornAnyWorkflowPluginManifest, type NornDispose, type NornRunCheckpoint, type NornRunInfo, type NornRunResult, type NornRunStartOptions, type NornWorkflowPlugin } from "@vimhead.dev/norn";
 import { NornAgentResponseCollector } from "./agent-response-tool.ts";
 import { type NornRunResumeRequest } from "./launch-request.ts";
 import { type NornRegisteredWorkflow } from "./workflow-registry.ts";

package/dist/internal/engine.js

@@ -1,21 +1,22 @@
 // src/internal/engine.ts
+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 { initializeRunResources } from "./run-resources.js";
-import { createRunFileCoordinator } from "@vimhead.dev/norn/files";
+import { Value } from "typebox/value";
 import { NornAgentResponseCollector } from "./agent-response-tool.js";
 import { NornArtifacts } from "./artifacts.js";
 import { errorMessage, NornRunStoppedError } from "./errors.js";
-import { NornRunLogs } from "./logs.js";
 import { clearRunResumeRequest, matchesRunResumeRequest, readOptionalRunResumeRequest, RESUME_START_GRACE_MS } from "./launch-request.js";
+import { NornRunLogs } from "./logs.js";
 import { NornRunLease } from "./run-lease.js";
 import { NornRunLogger } from "./run-log.js";
+import { initializeRunResources } from "./run-resources.js";
+import { getRunInfo, mergeInterruptedWorkflowParams, NornRunStateStore, resolveRunRoot } from "./run-state.js";
 import { NornRunStore, runCurrentRoot } from "./run-store.js";
-import { NornRunStateStore, getRunInfo, mergeInterruptedWorkflowParams, resolveRunRoot } from "./run-state.js";
 import { NornRunContext } from "./run.js";
 import { NornMemoryWorkflowState } from "./state-store.js";
-import { NornWorkflowRegistry } from "./workflow-registry.js";
+import { decodePluginConfiguration, NornWorkflowRegistry } from "./workflow-registry.js";
 var RUNS_DIR_NAME = ".norn";
 var MANIFEST_FILE_NAME = "manifest.json";
 var NornEngine = class {
@@ -32,10 +33,11 @@ var NornEngine = class {
   registerPlugin(plugin) {
     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 () => {
@@ -105,8 +107,9 @@ var NornEngine = class {
       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}`);
@@ -134,13 +137,12 @@ var NornEngine = class {
         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);