@vimhead.dev/norn-cli 0.1.0-tip.35359392805.1 → 0.1.0-tip.35436871363.1

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

@@ -25,9 +25,9 @@ function assertWorkflowReferenceAnnotations(schema: unknown): void {
 	if (!isPlainObject(schema)) return;
 	if (Object.hasOwn(schema, "x-norn-workflow-ref")) {
 		const annotation = schema["x-norn-workflow-ref"];
-		if (!isPlainObject(annotation) || !Object.hasOwn(annotation, "contributedParamsSchema")) throw new Error("Invalid workflow reference annotation");
-		Value.Assert(Meta["https://json-schema.org/draft/2020-12/schema"], annotation.contributedParamsSchema);
-		assertWorkflowReferenceAnnotations(annotation.contributedParamsSchema);
+		if (!isPlainObject(annotation) || !Object.hasOwn(annotation, "contributedArgsSchema")) throw new Error("Invalid workflow reference annotation");
+		Value.Assert(Meta["https://json-schema.org/draft/2020-12/schema"], annotation.contributedArgsSchema);
+		assertWorkflowReferenceAnnotations(annotation.contributedArgsSchema);
 	}
 	for (const keyword of ["properties", "patternProperties", "$defs", "definitions", "dependentSchemas"]) {
 		const schemas = schema[keyword];

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

@@ -1,39 +1,37 @@
-import { artifactRefSchema, definePluginManifest, isWorkflowDeclaration, isWorkflowPluginManifest, workflowRefSchema, type NornWorkflowRefSchemaOptions } from "@vimhead.dev/norn";
+import { workflow, isWorkflowDeclaration, workflowRefSchema, type NornWorkflowRefSchemaOptions } from "@vimhead.dev/norn";
 import { inspectSchema } from "@vimhead.dev/norn/schema";
 import assert from "node:assert/strict";
 import { Type } from "typebox";
 import { Value } from "typebox/value";
 import { expect, expectTypeOf, test } from "vitest";
 
-const manifest = definePluginManifest({
-	id: "refs", workflows: { finish: { isEntrypoint: false, params: Type.Object({ report: Type.String() }) } },
+const target = workflow({
+	id: "refs.finish", isEntrypoint: false, args: Type.Object({ report: Type.String() }),
+	execute() { throw new Error("A callable must select a transition, not execute it"); },
 });
-const target = manifest.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" } });
+	assert.equal(Value.Check(target.args, { report: "done" }), true);
+	assert.deepEqual(target({ report: "done" }), { type: "next", workflowId: target.id, args: { report: "done" } });
 });
 
 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 options: NornWorkflowRefSchemaOptions<typeof contributions> = { args: contributions };
 		const schema = workflowRefSchema(options);
-		assert.deepEqual(Value.Decode(workflowRefSchema({}), reference)({}), { type: "next", workflowId: "refs.finish", params: {} });
+		assert.deepEqual(Value.Decode(workflowRefSchema({}), reference)({}), { type: "next", workflowId: "refs.finish", args: {} });
 		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 input = { workflow: reference, forwardArgs: { 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.deepEqual(next({ report: "done" }), { type: "next", workflowId: reference, args: { task: "retain", report: "done" } });
+		assert.deepEqual(next({ report: "again" }).args, { task: "retain", report: "again" });
+		assert.deepEqual(input.forwardArgs, { task: "retain", report: "stale" });
 		assert.throws(() => Reflect.apply(next, undefined, [{}]));
 	});
 }
@@ -46,7 +44,7 @@ test("nullable reference inputs retain their required property and input union",
 	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"]);
+	expect(inspected).toHaveProperty("properties.next.anyOf.0.anyOf.1.required", ["workflow", "forwardArgs"]);
 });
 
 test("optional reference properties remain optional in validation and inspection", () => {
@@ -58,39 +56,39 @@ test("optional reference properties remain optional in validation and inspection
 test("inspection advertises encoded contributions and invocation does not decode them", () => {
 	let decodes = 0;
 	const contributions = Type.Object({
-		records: artifactRefSchema,
+		records: Type.String(),
 		count: Type.Decode(Type.String(), value => { decodes++; return Number(value); }),
 		label: Type.Optional(Type.String({ default: "collected" })),
 	});
-	const reference = Type.With(workflowRefSchema({ params: contributions }), { description: "Continue with the collected records" });
+	const reference = Type.With(workflowRefSchema({ args: 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.x-norn-workflow-ref.contributedArgsSchema", inspectSchema(contributions));
 	expect(inspected).toHaveProperty("properties.next.description", "Continue with the collected records");
 	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 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 });
+	expect(inspected).toHaveProperty("properties.next.anyOf.1.properties.forwardArgs.patternProperties", { "^.*$": {} });
+	expect(inspected).toHaveProperty("properties.next.x-norn-workflow-ref.contributedArgsSchema.required", ["records", "count"]);
+	expect(inspected).toHaveProperty("properties.next.x-norn-workflow-ref.contributedArgsSchema.properties.count.type", "string");
+	const forwardArgs = { taskId: "task-42", nested: { labels: ["one", "two"], enabled: false, absent: null } };
+	const next = Value.Decode(schema, { next: { workflow: "refs.finish", forwardArgs } }).next;
+	const contribution = { records: "records.json", count: "2" };
+	assert.deepEqual(next(contribution).args, { ...forwardArgs, ...contribution });
 	assert.equal(decodes, 0);
-	assert.throws(() => Reflect.apply(next, undefined, [{ records: { path: "records.json" }, count: 2 }]));
+	assert.throws(() => Reflect.apply(next, undefined, [{ records: "records.json", count: 2 }]));
 });
 
 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: {} });
+	expect(inspectSchema(reference)).toHaveProperty("x-norn-workflow-ref.contributedArgsSchema", inspectSchema(Type.Object({})));
+	assert.deepEqual(Value.Decode(reference, "refs.finish")({}), { type: "next", workflowId: "refs.finish", args: {} });
 });
 
 test("optional, nullable and array references retain annotations and callable codecs", () => {
-	const reference = workflowRefSchema({ params: Type.Object({ report: Type.String() }) });
+	const reference = workflowRefSchema({ args: 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`, inspectSchema(Type.Object({ report: Type.String() })));
+		expect(inspected).toHaveProperty(`${path}.x-norn-workflow-ref.contributedArgsSchema`, inspectSchema(Type.Object({ report: Type.String() })));
 	}
 	assert.deepEqual(inspected.required, ["nullable", "many"]);
 	const decoded = Value.Decode(schema, { nullable: null, many: ["refs.finish"], optional: "refs.finish" });
@@ -101,56 +99,56 @@ test("optional, nullable and array references retain annotations and callable co
 
 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" });
+	const contributions = Type.Object({ records: Type.String(), next: workflowRefSchema({ args: finalContributions }) });
+	const reference = workflowRefSchema({ args: contributions });
+	expect(inspectSchema(reference)).toHaveProperty("x-norn-workflow-ref.contributedArgsSchema.properties.next.x-norn-workflow-ref.contributedArgsSchema", inspectSchema(finalContributions));
+	const args = { records: "records.json", next: { workflow: "refs.finish", forwardArgs: { batch: 1 } } };
+	const transition = Value.Decode(reference, "intermediate")(args);
+	assert.deepEqual(transition.args, args);
+	assert.deepEqual(Value.Decode(contributions, transition.args).next({ summary: "done" }).args, { batch: 1, summary: "done" });
 });
 
 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);
+	const reference = workflowRefSchema({ args: contributions });
+	expect(inspectSchema(reference)).toHaveProperty("x-norn-workflow-ref.contributedArgsSchema", inspectSchema(contributions));
+	const args = { label: "root", children: [{ label: "leaf", children: [] }] };
+	assert.deepEqual(Value.Decode(reference, "refs.finish")(args).args, args);
 });
 
 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");
+	const union = workflowRefSchema({ args: 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" }).args, { kind: "error", reason: "failed" });
+	const record = workflowRefSchema({ args: Type.Record(Type.String(), Type.Integer()) });
+	assert.deepEqual(Value.Decode(record, "target")({ first: 1 }).args, { first: 1 });
+	const intersection = workflowRefSchema({ args: Type.Intersect([Type.Object({ left: Type.String() }), Type.Object({ right: Type.Integer() })]) });
+	assert.deepEqual(Value.Decode(intersection, "target")({ left: "x", right: 2 }).args, { left: "x", right: 2 });
+	const codec = workflowRefSchema({ args: Type.Decode(Type.Object({ text: Type.String() }), value => value.text) });
+	assert.deepEqual(Value.Decode(codec, "target")({ text: "encoded" }).args, { text: "encoded" });
+	const unknown = Value.Decode(workflowRefSchema({ args: 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() });
+	const reference = workflowRefSchema({ args: Type.BigInt() });
 	assert.equal(typeof Value.Decode(reference, "refs.finish"), "function");
 	assert.throws(() => inspectSchema(reference));
-	const nested = workflowRefSchema({ params: Type.Object({ next: reference }) });
+	const nested = workflowRefSchema({ args: 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 payload = { "x-norn-workflow-ref": { contributedArgsSchema: { 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() });
+	const invalid = workflowRefSchema({ args: 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, {}, { workflow: "refs.finish" }, { workflow: "", forwardParams: {} }, { workflow: "refs.finish", forwardParams: null }, { workflow: target, forwardParams: {} }]) {
+for (const input of [undefined, null, "", 3, {}, { workflow: "refs.finish" }, { workflow: "", forwardArgs: {} }, { workflow: "refs.finish", forwardArgs: null }, { workflow: target, forwardArgs: {} }]) {
 	test(`reference input schema rejects invalid shape without coercion: ${JSON.stringify(input)}`, () => {
 		assert.equal(Value.Check(workflowRefSchema(), input), false);
 	});

package/dist/cli.js

@@ -18,14 +18,16 @@ 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 { resolveNornAgentDirectory } from "./internal/agent-directory.js";
 import { errorMessage, NornProjectLoadError, NornRunStoppedError } from "./internal/errors.js";
 import { clearRunResumeRequest, readRunLaunchRequest, readRunResumeRequest, writeRunLaunchRequest, writeRunResumeRequest } from "./internal/launch-request.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 { assertRunVersion, getRunInfo, listRuns, mergeInterruptedWorkflowArgs, resolveRunRoot } from "./internal/run-state.js";
 import { NornRunStore } from "./internal/run-store.js";
-import { discoverNornProject, findNornProject, inspectNornWorkflow, loadNornProject, NORN_PROJECT_FILE_NAME } from "./plugin-loader.js";
+import { prepareRunWorkerDirectory } from "./internal/worker-directory.js";
+import { discoverNornProject, findNornProject, inspectNornWorkflow, loadNornProject, NORN_PROJECT_FILE_NAME } from "./workflow-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.";
@@ -112,9 +114,9 @@ var COMMANDS = [
   {
     id: "project.inspect",
     path: ["project", "inspect"],
-    description: "Use when discovering the active Norn project, plugins, and workflow sources.",
+    description: "Use when discovering the active Norn project, configuration, 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.",
+    output: "JSON object with project metadata under project, isComplete, and registration diagnostics. Incomplete discovery does not permit execution.",
     examples: ["norn project inspect"],
     execute: async (args) => {
       assertNoExtraArgs("project inspect", args);
@@ -127,17 +129,17 @@ var COMMANDS = [
     description: "Use when selecting a Norn workflow for a user task; defaults to entrypoint workflows.",
     usage: "norn workflows list [--entrypoints|--all]",
     options: ["--entrypoints: list entrypoint workflows", "--all: include internal workflow steps"],
-    output: "JSON object with workflow summaries under workflows, isComplete, and plugin diagnostics. Successful discovery can be incomplete; start/resume remain strict.",
+    output: "JSON object with workflow summaries under workflows, isComplete, and registration diagnostics. Successful discovery can be incomplete; start/resume remain strict.",
     examples: ["norn workflows list", "norn workflows list --all"],
     execute: listWorkflows
   },
   {
     id: "workflows.inspect",
     path: ["workflows", "inspect"],
-    description: "Use when reading a workflow's instructions, params schema, gate contract, and source plugin before starting or editing it.",
+    description: "Use when reading a workflow's instructions, args schema, gate contract, and registration source before starting or editing it.",
     usage: "norn workflows inspect <workflow-id>",
     arguments: ["workflow-id: fully qualified workflow id"],
-    output: "JSON object with workflow details, isComplete, and plugin diagnostics. workflow is null if unavailable in an incomplete catalog or its schema cannot be inspected; an unknown id in a complete catalog is an error.",
+    output: "JSON object with workflow details, isComplete, and registration diagnostics. workflow is null if unavailable in an incomplete catalog or its schema cannot be inspected; an unknown id in a complete catalog is an error.",
     examples: ["norn workflows inspect example.plan"],
     execute: async (args) => {
       const workflowId = requiredArg("workflows inspect", args, 0, "workflow id");
@@ -148,12 +150,12 @@ var COMMANDS = [
   {
     id: "runs.start",
     path: ["runs", "start"],
-    description: "Use when starting a Norn workflow run after the workflow id and params are known.",
+    description: "Use when starting a Norn workflow run after the workflow id and args are known.",
     usage: "norn runs start <workflow-id>",
     arguments: ["workflow-id: fully qualified workflow id to start"],
-    stdin: 'Optional JSON object: {"params":{...},"config":{"pluginId":{...}}}.',
+    stdin: 'Optional JSON object: {"args":{...},"config":{"workflowOrScopeId":{...}}}.',
     output: "JSON object with started run info under run.",
-    examples: [`printf '{"params":{"task":"Add tests"}}' | norn runs start example.plan`],
+    examples: [`printf '{"args":{"task":"Add tests"}}' | norn runs start example.plan`],
     execute: async (args) => {
       const workflowId = requiredArg("runs start", args, 0, "workflow id");
       await startRun(workflowId, args.slice(1));
@@ -165,9 +167,9 @@ var COMMANDS = [
     description: "Use when resuming an interrupted gate or a checkpoint restored for retry.",
     usage: "norn runs resume <run>",
     arguments: ["run: run id, generated name, or run path"],
-    stdin: 'Optional JSON object: {"params":{...}}. Interrupted runs require a patch containing only editable gate fields; pending-resume runs do not accept params.',
+    stdin: 'Optional JSON object: {"args":{...}}. Interrupted runs require a patch containing only editable gate fields; pending-resume runs do not accept args.',
     output: "JSON object with resumed run info under run.",
-    examples: [`printf '{"params":{"decision":"accept"}}' | norn runs resume quiet-river-lantern`],
+    examples: [`printf '{"args":{"decision":"accept"}}' | norn runs resume quiet-river-lantern`],
     execute: async (args) => {
       const run = requiredArg("runs resume", args, 0, "run");
       await resumeRun(run, args.slice(1));
@@ -686,7 +688,7 @@ async function initProject() {
   const projectPath = resolve(projectRoot, NORN_PROJECT_FILE_NAME);
   if (await isFile(projectPath)) throw new Error(`Norn project already exists: ${projectPath}`);
   await mkdir(resolve(projectRoot, RUNS_ROOT), { recursive: true });
-  await writeFile(projectPath, `${JSON.stringify({ version: 1, plugins: [], includes: [], config: {} }, null, 2)}
+  await writeFile(projectPath, `${JSON.stringify({ version: 1, workflows: [], includes: [], config: {} }, null, 2)}
 `, "utf8");
   await ensureGitignoreExcludesRunState(projectRoot);
   writeJson({ project: { path: projectPath, root: projectRoot, runsRoot: resolve(projectRoot, RUNS_ROOT) } });
@@ -699,23 +701,23 @@ async function inspectProject() {
   const { project, isComplete, diagnostics } = await discoverNornProject(process.cwd());
   writeJson({ project, isComplete, diagnostics });
 }
-async function startRun(workflowId, args) {
-  assertNoStructuredInputArgs("runs start", args);
+async function startRun(workflowId, commandArgs) {
+  assertNoStructuredInputArgs("runs start", commandArgs);
   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 = input.params === void 0 ? {} : input.params;
-  Value.Decode(workflow.params, params);
+  const args = input.args === void 0 ? {} : input.args;
+  Value.Decode(workflow.args, args);
   const configOverride = input.config;
   const id = randomUUID();
   const name = generateRunName(new Set((await listRuns(project.projectRoot)).map((run) => run.name)));
   const runRoot = resolve(project.projectRoot, RUNS_ROOT, id);
   await mkdir(runRoot, { recursive: true });
   const createdAt = (/* @__PURE__ */ new Date()).toISOString();
-  await writeRunLaunchRequest(runRoot, { version: 1, type: "run", id, name, workflowId, params, configOverride, createdAt });
+  await writeRunLaunchRequest(runRoot, { version: 2, type: "run", id, name, workflowId, args, configOverride, createdAt });
   await startDetachedExecuteRun(id, project.projectRoot);
-  writeJson({ run: startedRunInfo({ id, name, workflow, runRoot, createdAt }) });
+  writeJson({ run: startedRunInfo({ id, name, workflow, runRoot, projectRoot: project.projectRoot, createdAt }) });
 }
 async function resumeRun(run, args) {
   assertNoStructuredInputArgs("runs resume", args);
@@ -726,8 +728,9 @@ async function resumeRun(run, args) {
   let request;
   try {
     const runInfo = await getRunInfo(runRoot);
-    const params = await parseResumeParams(runInfo, input.params);
-    request = { version: 1, type: "resume", id: runInfo.id, requestId: randomUUID(), params, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
+    assertRunVersion(runInfo.version);
+    const args2 = await parseResumeArgs(runInfo, input.args);
+    request = { version: 2, type: "resume", id: runInfo.id, requestId: randomUUID(), args: args2, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
     await writeRunResumeRequest(runRoot, request);
   } finally {
     await lease.release();
@@ -740,18 +743,18 @@ async function resumeRun(run, args) {
   }
   writeJson({ run: await getRunInfo(runRoot) });
 }
-async function parseResumeParams(runInfo, params) {
+async function parseResumeArgs(runInfo, args) {
   if (runInfo.status === "interrupted") {
-    if (params === void 0) throw new Error(`Interrupted workflow resume requires params: ${runInfo.name}`);
+    if (args === void 0) throw new Error(`Interrupted workflow resume requires args: ${runInfo.name}`);
     if (!runInfo.currentWorkflowId) throw new Error(`Run has no current workflow: ${runInfo.name}`);
     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}`);
-    Value.Decode(workflow.params, mergeInterruptedWorkflowParams(runInfo.interruption?.params, params, runInfo.interruption?.fields));
-    return params;
+    Value.Decode(workflow.args, mergeInterruptedWorkflowArgs(runInfo.interruption?.args, args, runInfo.interruption?.fields));
+    return args;
   }
   if (runInfo.status === "pendingResume") {
-    if (params !== void 0) throw new Error(`Pending-resume workflows do not accept params: ${runInfo.name}`);
+    if (args !== void 0) throw new Error(`Pending-resume workflows do not accept args: ${runInfo.name}`);
     return void 0;
   }
   throw new Error(`Run must be rolled back before resuming: ${runInfo.name}`);
@@ -821,13 +824,15 @@ async function executeRun(runId) {
   const runRoot = resolve(location.projectRoot, RUNS_ROOT, runId);
   const request = await readOptionalRunLaunchRequest(runRoot) ?? await readRunResumeRequest(runRoot);
   try {
-    const project = await loadNornProject(process.cwd());
-    const engine = new NornEngine({ cwd: project.projectRoot, signal: abortController.signal, gateMode: "pause", config: project.projectConfig });
-    for (const plugin of project.plugins) engine.registerPlugin(plugin);
+    const agentDir = resolveNornAgentDirectory({ home: homedir(), environment: process.env });
+    process.chdir(await prepareRunWorkerDirectory(runRoot));
+    const project = await loadNornProject(location.projectRoot);
+    const engine = new NornEngine({ cwd: project.projectRoot, agentDir, signal: abortController.signal, gateMode: "pause", config: project.projectConfig });
+    engine.registerWorkflows(project.definitions);
     if (request.type === "run") {
       const workflow = project.registry.workflowById(request.workflowId);
       if (!workflow) throw new Error(`Unknown workflow: ${request.workflowId}`);
-      await engine.runWorkflow(workflow, request.params, { id: request.id, name: request.name, configOverride: request.configOverride });
+      await engine.runWorkflow(workflow, request.args, { id: request.id, name: request.name, configOverride: request.configOverride });
     } else {
       await engine.resumeRequestedWorkflow({ runRoot, request });
     }
@@ -913,10 +918,11 @@ function detachedExecuteRunArgs(runId) {
 }
 function startedRunInfo(input) {
   return {
-    version: 1,
+    version: 2,
     id: input.id,
     name: input.name,
     path: input.runRoot,
+    paths: { project: input.projectRoot, workspace: join(input.runRoot, "current", "workspace") },
     entrypointWorkflowId: input.workflow.id,
     currentWorkflowId: input.workflow.id,
     status: "running",
@@ -963,14 +969,14 @@ async function readStdin() {
 function parseStartRunInput(value) {
   if (value === void 0) return {};
   const input = parseStructuredInputObject("runs start", value);
-  assertStructuredInputKeys("runs start", input, ["params", "config"]);
-  return { params: input.params, config: input.config };
+  assertStructuredInputKeys("runs start", input, ["args", "config"]);
+  return { args: input.args, config: input.config };
 }
 function parseResumeRunInput(value) {
   if (value === void 0) return {};
   const input = parseStructuredInputObject("runs resume", value);
-  assertStructuredInputKeys("runs resume", input, ["params"]);
-  return { params: input.params };
+  assertStructuredInputKeys("runs resume", input, ["args"]);
+  return { args: input.args };
 }
 function parseStructuredInputObject(command, value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${command} reads a JSON object from stdin`);

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import type { DeletedNornRunInfo, NornProjectInspection, NornWorkflowCatalogInfo, NornWorkflowInspection, NornRunCheckpoint, NornRunInfo, NornRunMetrics, NornWorkflowStateReader } from "@vimhead.dev/norn";
+import type { DeletedNornRunInfo, NornProjectInspection, NornWorkflowCatalogInfo, NornWorkflowInspection, NornRunCheckpoint, NornRunInfo, NornRunMetrics } from "@vimhead.dev/norn";
 import type { NornRegisteredWorkflow } from "./internal/workflow-registry.ts";
 export { NornProjectLoadError } from "./internal/errors.ts";
 export type NornClientInput = {
@@ -16,16 +16,15 @@ export type NornClient = {
         inspect(workflowId: string): Promise<NornWorkflowInspection>;
         entries(): Promise<readonly NornRegisteredWorkflow[]>;
     };
-    readonly state: NornWorkflowStateReader;
     readonly runs: {
         start(input: {
             readonly workflowId: string;
-            readonly params: unknown;
+            readonly args: unknown;
             readonly configOverride?: unknown;
         }): Promise<NornRunInfo>;
         resume(input: {
             readonly run: string;
-            readonly params?: unknown;
+            readonly args?: unknown;
         }): Promise<NornRunInfo>;
         wait(run: string): Promise<NornRunInfo>;
         list(): Promise<NornRunInfo[]>;

package/dist/client.js

@@ -2,7 +2,7 @@
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { createInterface } from "node:readline";
-import { loadNornProject } from "./plugin-loader.js";
+import { loadNornProject } from "./workflow-loader.js";
 import { NornProjectLoadError } from "./internal/errors.js";
 import { NornProjectLoadError as NornProjectLoadError2 } from "./internal/errors.js";
 function createNornClient(input = {}) {
@@ -17,7 +17,6 @@ function createNornClient(input = {}) {
       inspect: async (workflowId) => processRunner.readJson(["workflows", "inspect", workflowId]),
       entries: async () => (await catalog.load()).workflows
     },
-    state: catalog.state,
     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,
@@ -41,10 +40,6 @@ var NornWorkflowCatalog = class {
   }
   cwd;
   loaded;
-  state = {
-    get: async (state) => (await this.load()).state.get(state),
-    getOptional: async (state) => (await this.load()).state.getOptional(state)
-  };
   load() {
     this.loaded ??= loadNornProject(this.cwd).catch((error) => {
       this.loaded = void 0;
@@ -104,10 +99,10 @@ var NornProcessRunner = class {
   }
 };
 function runStartInput(input) {
-  return input.configOverride === void 0 ? { params: input.params } : { params: input.params, config: input.configOverride };
+  return input.configOverride === void 0 ? { args: input.args } : { args: input.args, config: input.configOverride };
 }
 function runResumeStdin(input) {
-  return input.params === void 0 ? void 0 : JSON.stringify({ params: input.params });
+  return input.args === void 0 ? void 0 : JSON.stringify({ args: input.args });
 }
 export {
   NornProjectLoadError2 as NornProjectLoadError,

package/dist/documentation-intro.js

@@ -20,7 +20,7 @@ function renderNornDocumentationIntro(input) {
     "",
     "Live CLI contracts (argument arrays appended to the runtime argv above):",
     '- ["workflows", "list"] \u2014 currently registered entrypoints.',
-    '- ["workflows", "inspect", "<workflow-id>"] \u2014 current instructions, params schema, and source.',
+    '- ["workflows", "inspect", "<workflow-id>"] \u2014 current instructions, args schema, and source.',
     '- ["help"] \u2014 command usage.'
   ].join("\n");
 }

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.35359392805.1";
-    readonly commit: "f958006ca0ae3752060727c5b76b2ac1a008b103";
+    readonly version: "0.1.0-tip.35436871363.1";
+    readonly commit: "49b14d0ed0c9633fc6ee530a557ec7babbf52b22";
     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.35359392805.1",
-  "commit": "f958006ca0ae3752060727c5b76b2ac1a008b103",
+  "version": "0.1.0-tip.35436871363.1",
+  "commit": "49b14d0ed0c9633fc6ee530a557ec7babbf52b22",
   "packageSpec": "@vimhead.dev/norn-cli@tip",
   "upgrade": {
     "supported": false,

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

@@ -52,12 +52,12 @@ var NornAgentResponseToolFactory = class {
         label: Type.String({ description: "The exact workflow agent label provided in the prompt." }),
         response: Type.Unknown({ description: "The structured response object requested by the workflow." })
       }),
-      async execute(_toolCallId, params) {
+      async execute(_toolCallId, args) {
         try {
-          const captured = responseCollector.capture(params.runId, params.label, params.response);
+          const captured = responseCollector.capture(args.runId, args.label, args.response);
           return {
             content: [{ type: "text", text: `Recorded workflow agent response for ${captured.label}.` }],
-            details: { valid: true, runId: params.runId, label: captured.label, response: captured.response },
+            details: { valid: true, runId: args.runId, label: captured.label, response: captured.response },
             terminate: true
           };
         } catch (error) {

package/dist/internal/agents.d.ts

@@ -7,9 +7,6 @@ import type { NornRunLogger } from "./run-log.ts";
 type NornAgentRunnerInput = {
     readonly id: string;
     readonly runRoot: string;
-    readonly boundaryRoot: string;
-    readonly boundaryName: string;
-    readonly cwd: string;
     readonly signal?: AbortSignal;
     readonly model?: CreateAgentSessionOptions["model"];
     readonly thinkingLevel?: CreateAgentSessionOptions["thinkingLevel"];
@@ -24,6 +21,5 @@ export declare class NornAgentRunner {
     constructor(input: NornAgentRunnerInput);
     createSession(agentInput: NornAgentCreateSessionInput): Promise<NornAgentSession>;
     prompt<ResponseSchema extends TSchema>(agentInput: NornAgentSinglePromptInput<ResponseSchema>): Promise<StaticDecode<ResponseSchema>>;
-    private resolveFromCwd;
 }
 export {};