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

package/dist/internal/engine.js

@@ -11,12 +11,11 @@ import { clearRunResumeRequest, matchesRunResumeRequest, readOptionalRunResumeRe
 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 { NornRunResources } from "../resources.js";
+import { assertRunVersion, getRunInfo, mergeInterruptedWorkflowArgs, NornRunStateStore, resolveRunRoot } from "./run-state.js";
 import { NornRunStore, runCurrentRoot } from "./run-store.js";
 import { NornRunContext } from "./run.js";
-import { NornMemoryWorkflowState } from "./state-store.js";
-import { decodePluginConfiguration, NornWorkflowRegistry } from "./workflow-registry.js";
+import { NornWorkflowRegistry } from "./workflow-registry.js";
 var RUNS_DIR_NAME = ".norn";
 var MANIFEST_FILE_NAME = "manifest.json";
 var NornEngine = class {
@@ -26,22 +25,18 @@ var NornEngine = class {
   }
   input;
   registry = new NornWorkflowRegistry();
-  registrarState = new NornMemoryWorkflowState();
-  disposersByPlugin = /* @__PURE__ */ new Map();
   responseCollector;
   activeRuns = /* @__PURE__ */ new Map();
-  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 }, configuration });
-    });
-    this.disposersByPlugin.set(plugin.manifest.id, disposers);
+  registerWorkflows(workflows) {
+    const disposers = [];
+    try {
+      for (const workflow of workflows) disposers.push(this.registry.register({ workflow, config: this.input.config ?? {}, source: void 0 }));
+    } catch (error) {
+      for (const dispose of disposers.reverse()) dispose();
+      throw error;
+    }
     return () => {
-      if (this.disposersByPlugin.get(plugin.manifest.id) === disposers) this.disposePlugin(plugin.manifest.id);
+      for (const dispose of disposers) dispose();
     };
   }
   listWorkflows() {
@@ -50,11 +45,8 @@ var NornEngine = class {
   visibleWorkflowEntries() {
     return this.registry.launchableEntries();
   }
-  resolvePluginImplementation(implementationInput) {
-    return typeof implementationInput === "function" ? implementationInput({ cwd: this.input.cwd, state: this.registrarState }) : implementationInput;
-  }
-  async runWorkflow(workflow, params, options) {
-    const session = await this.createRunSession(workflow, params, options);
+  async runWorkflow(workflow, args, options) {
+    const session = await this.createRunSession(workflow, args, options);
     const current = session.state.currentState().current;
     if (!current) throw new Error("New run is missing its initial workflow step");
     return this.runScheduler(session, toWorkflowStep(workflow, current));
@@ -65,6 +57,7 @@ var NornEngine = class {
   }
   async rollbackRun(path, checkpointId) {
     const runRoot = await resolveRunRoot(this.input.cwd, path);
+    assertRunVersion((await getRunInfo(runRoot)).version);
     const lease = await NornRunLease.acquire(runRoot);
     try {
       const pendingRequest = await readOptionalRunResumeRequest(runRoot);
@@ -80,19 +73,19 @@ var NornEngine = class {
       await lease.release();
     }
   }
-  async resumeWorkflow(path, params) {
-    return this.resumeWorkflowExecution({ path, params, expectedRequest: void 0 });
+  async resumeWorkflow(path, args) {
+    return this.resumeWorkflowExecution({ path, args, expectedRequest: void 0 });
   }
   async resumeRequestedWorkflow(input) {
-    return this.resumeWorkflowExecution({ path: input.runRoot, params: input.request.params, expectedRequest: input.request });
+    return this.resumeWorkflowExecution({ path: input.runRoot, args: input.request.args, expectedRequest: input.request });
   }
   async resumeWorkflowExecution(input) {
-    const { params, expectedRequest } = input;
+    const { args, expectedRequest } = input;
     const runRoot = await resolveRunRoot(this.input.cwd, input.path);
     const initialStateStore = await NornRunStateStore.load(runRoot);
     const initialState = initialStateStore.currentState();
-    if (initialState.status === "interrupted" && params === void 0) throw new Error(`Interrupted workflow resume requires params: ${runRoot}`);
-    if (initialState.status === "pendingResume" && params !== void 0) throw new Error(`Pending-resume workflows do not accept params: ${runRoot}`);
+    if (initialState.status === "interrupted" && args === void 0) throw new Error(`Interrupted workflow resume requires args: ${runRoot}`);
+    if (initialState.status === "pendingResume" && args !== void 0) throw new Error(`Pending-resume workflows do not accept args: ${runRoot}`);
     if (initialState.status !== "interrupted" && initialState.status !== "pendingResume") throw new Error(`Run must be rolled back before resuming: ${runRoot}`);
     const lease = await NornRunLease.acquire(runRoot);
     let isLeaseOwnedByScheduler = false;
@@ -107,9 +100,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 rawParams = mergeInterruptedWorkflowParams(current.params, params, current.interruption?.fields);
-        Value.Decode(workflow.params, rawParams);
-        await session.state.replaceCurrentParams(rawParams);
+        const rawArgs = mergeInterruptedWorkflowArgs(current.args, args, current.interruption?.fields);
+        Value.Decode(workflow.args, rawArgs);
+        await session.state.replaceCurrentArgs(rawArgs);
         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}`);
@@ -137,12 +130,12 @@ var NornEngine = class {
         throwIfRunAborted(session.activeRun);
         const stepRuntime = session.run.forWorkflow(currentStep.workflow);
         if (shouldPauseForGate(currentStep)) {
-          const description = await this.registry.describeGate(currentStep.workflow, stepRuntime, currentStep.params, session.state.currentState().configOverride);
+          const description = await this.registry.describeGate(currentStep.workflow, stepRuntime, currentStep.args, session.state.currentState().configOverride);
           const interruption = { description, fields: currentStep.workflow.gate?.fields };
-          await session.state.interruptCurrent(currentStep.params, interruption);
+          await session.state.interruptCurrent(currentStep.args, 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, currentStep.params, interruption);
+          return interruptedLaunchResult({ id: stepRuntime.id, name: session.state.currentState().name, workspace: stepRuntime.workspace, cwd: stepRuntime.cwd }, currentStep.workflow, currentStep.args, interruption);
         }
         await session.state.startStep(toRunStateStep(currentStep));
         const stepResult = await this.executeWorkflowStep(session, currentStep, stepRuntime);
@@ -184,7 +177,7 @@ var NornEngine = class {
     try {
       await assertWorkspaceBoundary(session, run.workspace);
       await recordRunEvent(session, { type: "workflow.started", workflowId: step.workflow.id });
-      const result = await this.registry.execute(step.workflow, run, step.params, session.state.currentState().configOverride);
+      const result = await this.registry.execute(step.workflow, run, step.args, session.state.currentState().configOverride);
       await assertWorkspaceBoundary(session, run.workspace);
       const durationMs = Date.now() - startedAtMs;
       if (result.type === "complete") await recordRunEvent(session, { type: "workflow.completed", workflowId: result.workflow.id, durationMs, metadata: result.metadata });
@@ -206,11 +199,11 @@ var NornEngine = class {
     if (!workflow) throw new Error(`Unknown next workflow: ${next.workflowId}`);
     return {
       workflow,
-      params: next.params,
+      args: next.args,
       interruption: this.input.gateMode === "pause" && workflow.gate ? { status: "pending" } : void 0
     };
   }
-  async createRunSession(workflow, params, options) {
+  async createRunSession(workflow, args, options) {
     const id = options?.id ?? randomUUID();
     const name = options?.name ?? id;
     const runRoot = defaultRunRoot(this.input.cwd, id);
@@ -242,7 +235,7 @@ var NornEngine = class {
         configOverride: options?.configOverride,
         current: {
           workflowId: workflow.id,
-          params,
+          args,
           cwd,
           env: {},
           interruption: this.input.gateMode === "pause" && workflow.gate ? { status: "pending" } : void 0
@@ -284,7 +277,7 @@ var NornEngine = class {
     await mkdir(input.workspace, { recursive: true });
     await mkdir(artifactsRoot, { recursive: true });
     await mkdir(logsRoot, { recursive: true });
-    const { resources, state } = await initializeRunResources(dirname(input.currentRoot));
+    const resources = await NornRunResources.initialize(dirname(input.currentRoot));
     return new NornRunContext({
       id: input.id,
       runRoot: input.currentRoot,
@@ -296,7 +289,6 @@ var NornEngine = class {
       agentDir: this.input.agentDir,
       responseCollector: this.responseCollector,
       resources,
-      state,
       logger: input.logger,
       artifacts: new NornArtifacts(artifactsRoot, resources.files),
       logs: new NornRunLogs(logsRoot, resources.files)
@@ -332,11 +324,6 @@ var NornEngine = class {
     activeRun.dispose();
     activeRun.finish();
   }
-  disposePlugin(pluginId) {
-    const disposers = this.disposersByPlugin.get(pluginId) ?? [];
-    for (const dispose of [...disposers].reverse()) dispose();
-    this.disposersByPlugin.delete(pluginId);
-  }
 };
 function defaultRunRoot(cwd, id) {
   return join(cwd, RUNS_DIR_NAME, "runs", id);
@@ -347,14 +334,14 @@ function workflowDefaultCwd(projectRoot, workspace, workflow) {
 function toWorkflowStep(workflow, step) {
   return {
     workflow,
-    params: step.params,
+    args: step.args,
     interruption: step.interruption
   };
 }
 function toRunStateStep(step) {
   return {
     workflowId: step.workflow.id,
-    params: step.params,
+    args: step.args,
     cwd: "",
     env: {},
     interruption: step.interruption
@@ -372,7 +359,7 @@ function throwIfRunAborted(activeRun) {
 function isRunStopped(session, error) {
   return error instanceof NornRunStoppedError || session.activeRun.controller.signal.reason instanceof NornRunStoppedError;
 }
-function interruptedLaunchResult(run, workflow, params, interruption) {
+function interruptedLaunchResult(run, workflow, args, interruption) {
   if (!workflow.gate) throw new Error(`Workflow is not gated: ${workflow.id}`);
   if (!interruption.description) throw new Error(`Interrupted workflow is missing description: ${workflow.id}`);
   return {
@@ -382,7 +369,7 @@ function interruptedLaunchResult(run, workflow, params, interruption) {
     workspace: run.workspace,
     cwd: run.cwd,
     workflowId: workflow.id,
-    interruption: { workflowId: workflow.id, params, description: interruption.description, fields: interruption.fields }
+    interruption: { workflowId: workflow.id, args, description: interruption.description, fields: interruption.fields }
   };
 }
 async function recordRunEvent(session, event) {

package/dist/internal/errors.d.ts

@@ -1,11 +1,11 @@
-import type { NornPluginDiagnostic } from "@vimhead.dev/norn";
+import type { NornWorkflowDiagnostic } from "@vimhead.dev/norn";
 import { AssertError } from "typebox/value";
 export declare class NornProjectLoadError extends Error {
     readonly code = "NORN_PROJECT_INVALID";
     readonly isComplete = false;
-    readonly diagnostics: readonly NornPluginDiagnostic[];
+    readonly diagnostics: readonly NornWorkflowDiagnostic[];
     constructor(input: {
-        readonly diagnostics: readonly NornPluginDiagnostic[];
+        readonly diagnostics: readonly NornWorkflowDiagnostic[];
     });
 }
 export declare class NornRunStoppedError extends Error {

package/dist/internal/errors.js

@@ -6,7 +6,7 @@ var NornProjectLoadError = class extends Error {
   diagnostics;
   constructor(input) {
     const details = input.diagnostics.map(
-      (diagnostic) => `${diagnostic.stage}: ${diagnostic.pluginPath} (declared in ${diagnostic.configPath}${diagnostic.workflowId ? `; workflow ${diagnostic.workflowId}` : ""}): ${diagnostic.message}`
+      (diagnostic) => `${diagnostic.stage}: ${diagnostic.modulePath} (declared in ${diagnostic.configPath}${diagnostic.workflowId ? `; workflow ${diagnostic.workflowId}` : ""}): ${diagnostic.message}`
     );
     super(`Norn project is incomplete (${input.diagnostics.length} diagnostics); execution is blocked.
 ${details.join("\n")}`);

package/dist/internal/launch-request.d.ts

@@ -3,21 +3,21 @@ export declare const LAUNCH_REQUEST_FILE_NAME = "launch-request.json";
 export declare const RESUME_REQUEST_FILE_NAME = "resume-request.json";
 export declare const RESUME_START_GRACE_MS = 60000;
 export type NornRunLaunchRequest = {
-    readonly version: 1;
+    readonly version: 2;
     readonly type: "run";
     readonly id: string;
     readonly name: string;
     readonly workflowId: string;
-    readonly params: unknown;
+    readonly args: unknown;
     readonly configOverride?: unknown;
     readonly createdAt: string;
 };
 export type NornRunResumeRequest = {
-    readonly version: 1;
+    readonly version: 2;
     readonly type: "resume";
     readonly id: string;
     readonly requestId?: string;
-    readonly params?: unknown;
+    readonly args?: unknown;
     readonly createdAt: string;
 };
 export declare function writeRunLaunchRequest(runRoot: string, request: NornRunLaunchRequest): Promise<void>;

package/dist/internal/launch-request.js

@@ -80,7 +80,7 @@ async function clearRunResumeRequest(input) {
 function parseRunLaunchRequest(value) {
   if (!value || typeof value !== "object") throw new Error("Invalid workflow launch request");
   const request = value;
-  if (request.version !== 1 || request.type !== "run") throw new Error("Unsupported workflow launch request");
+  if (request.version !== 2 || request.type !== "run") throw new Error("Unsupported workflow launch request");
   if (typeof request.id !== "string" || request.id.length === 0) throw new Error("Invalid workflow launch request id");
   if (typeof request.name !== "string" || request.name.length === 0) throw new Error("Invalid workflow launch request name");
   if (typeof request.workflowId !== "string" || request.workflowId.length === 0) throw new Error("Invalid workflow launch request workflow id");
@@ -90,7 +90,7 @@ function parseRunLaunchRequest(value) {
 function parseRunResumeRequest(value) {
   if (!value || typeof value !== "object") throw new Error("Invalid workflow resume request");
   const request = value;
-  if (request.version !== 1 || request.type !== "resume") throw new Error("Unsupported workflow resume request");
+  if (request.version !== 2 || request.type !== "resume") throw new Error("Unsupported workflow resume request");
   if (typeof request.id !== "string" || request.id.length === 0) throw new Error("Invalid workflow resume request id");
   if (request.requestId !== void 0 && (typeof request.requestId !== "string" || request.requestId.length === 0)) throw new Error("Invalid workflow resume request token");
   if (typeof request.createdAt !== "string" || Number.isNaN(Date.parse(request.createdAt))) throw new Error("Invalid workflow resume request timestamp");

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

@@ -1,10 +1,10 @@
 import type { NornRunStatus, NornRunOutcomeMetadata, NornRunInfo } from "@vimhead.dev/norn";
 export declare const RUN_STATE_FILE_NAME = "run-state.json";
-export declare function mergeInterruptedWorkflowParams(currentParams: unknown, params: unknown, fields: readonly string[] | undefined): unknown;
-declare const RUN_STATE_VERSION = 1;
+export declare function mergeInterruptedWorkflowArgs(currentArgs: unknown, args: unknown, fields: readonly string[] | undefined): unknown;
+declare const RUN_STATE_VERSION = 2;
 type NornRunWorkflowStep = {
     readonly workflowId: string;
-    readonly params: unknown;
+    readonly args: unknown;
     readonly cwd: string;
     readonly env: Record<string, string>;
     readonly interruption?: RuntimeInterruption;
@@ -39,7 +39,7 @@ type NornRunWorkflowOutcome = {
     readonly metadata?: NornRunOutcomeMetadata;
 };
 export type NornRunState = {
-    readonly version: typeof RUN_STATE_VERSION;
+    readonly version: 1 | typeof RUN_STATE_VERSION;
     readonly id: string;
     readonly name: string;
     readonly entrypointWorkflowId: string;
@@ -76,20 +76,21 @@ export declare class NornRunStateStore {
     failRun(workflowId: string, metadata: NornRunOutcomeMetadata & {
         readonly summary: string;
     }): Promise<void>;
-    interruptCurrent(params: unknown, interruption: {
+    interruptCurrent(args: unknown, interruption: {
         readonly description: string;
         readonly fields?: readonly string[];
     }): Promise<void>;
     prepareForResumeAfterRollback(): Promise<void>;
     stopCurrent(): Promise<void>;
-    replaceCurrentParams(params: unknown): Promise<void>;
-    failCurrent(errorOrMetadata: string | NornRunOutcomeMetadata & {
+    replaceCurrentArgs(args: unknown): Promise<void>;
+    failCurrent(errorOrMetadata: string | (NornRunOutcomeMetadata & {
         readonly summary: string;
-    }): Promise<void>;
+    })): Promise<void>;
     private update;
     private write;
 }
 export declare function listRuns(sessionCwd: string): Promise<NornRunInfo[]>;
 export declare function getRunInfo(runRoot: string): Promise<NornRunInfo>;
 export declare function resolveRunRoot(sessionCwd: string, run: string): Promise<string>;
+export declare function assertRunVersion(version: unknown): void;
 export {};

package/dist/internal/run-state.js

@@ -45,15 +45,15 @@ 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) {
-  if (!isRecord(currentParams) || !isRecord(params)) return params;
+function mergeInterruptedWorkflowArgs(currentArgs, args, fields) {
+  if (!isRecord(currentArgs) || !isRecord(args)) return args;
   if (fields) {
-    const unsupportedFields = Object.keys(params).filter((field) => !fields.includes(field));
-    if (unsupportedFields.length > 0) throw new Error(`Interrupted workflow params cannot update non-gate fields: ${unsupportedFields.join(", ")}`);
+    const unsupportedFields = Object.keys(args).filter((field) => !fields.includes(field));
+    if (unsupportedFields.length > 0) throw new Error(`Interrupted workflow args cannot update non-gate fields: ${unsupportedFields.join(", ")}`);
   }
-  return { ...currentParams, ...params };
+  return { ...currentArgs, ...args };
 }
-var RUN_STATE_VERSION = 1;
+var RUN_STATE_VERSION = 2;
 var NornRunStateStore = class _NornRunStateStore {
   path;
   state;
@@ -87,7 +87,7 @@ var NornRunStateStore = class _NornRunStateStore {
   static async load(runRoot) {
     const currentRoot = runCurrentRoot(runRoot);
     const files = createRunFileCoordinator(runRoot);
-    const state = await files.withExclusiveLock(join(currentRoot, RUN_STATE_FILE_NAME), async (path) => parseNornRunState(await readRunStateFile({ path, legacyPath: join(currentRoot, LEGACY_RUN_STATE_FILE_NAME) })));
+    const state = await files.withExclusiveLock(join(currentRoot, RUN_STATE_FILE_NAME), async (path) => parseNornRunState(await readRunStateFile({ path, legacyPath: join(currentRoot, LEGACY_RUN_STATE_FILE_NAME) }), "execute"));
     return new _NornRunStateStore({ path: join(currentRoot, RUN_STATE_FILE_NAME), state, files });
   }
   currentState() {
@@ -125,11 +125,11 @@ var NornRunStateStore = class _NornRunStateStore {
       failed: { workflowId, error: metadata.summary, metadata, failedAt }
     });
   }
-  async interruptCurrent(params, interruption) {
+  async interruptCurrent(args, interruption) {
     if (!this.state.current) throw new Error("Cannot interrupt run without current step");
     await this.update({
       status: "interrupted",
-      current: { ...this.state.current, params, interruption: { status: "pending", ...interruption } },
+      current: { ...this.state.current, args, interruption: { status: "pending", ...interruption } },
       outcome: null,
       failed: null
     });
@@ -144,11 +144,11 @@ var NornRunStateStore = class _NornRunStateStore {
     if (!this.state.current) throw new Error("Cannot stop run without current step");
     await this.update({ status: "stopped", outcome: null, failed: null });
   }
-  async replaceCurrentParams(params) {
+  async replaceCurrentArgs(args) {
     if (!this.state.current) throw new Error("Cannot resume run without current step");
     await this.update({
       status: "running",
-      current: { ...this.state.current, params, interruption: { ...this.state.current.interruption, status: "satisfied" } },
+      current: { ...this.state.current, args, interruption: { ...this.state.current.interruption, status: "satisfied" } },
       outcome: null,
       failed: null
     });
@@ -165,15 +165,15 @@ var NornRunStateStore = class _NornRunStateStore {
   }
   async update(patch) {
     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 current = parseNornRunState(await readRunStateFile({ path, legacyPath: join(dirname2(this.path), LEGACY_RUN_STATE_FILE_NAME) }), "execute");
       const next = { ...current, ...patch, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-      if (next.current?.params !== void 0) Value.Assert(jsonValueSchema, next.current.params);
+      if (next.current?.args !== void 0) Value.Assert(jsonValueSchema, next.current.args);
       await writeJsonAtomically(path, next);
       this.state = next;
     });
   }
   async write() {
-    if (this.state.current?.params !== void 0) Value.Assert(jsonValueSchema, this.state.current.params);
+    if (this.state.current?.args !== void 0) Value.Assert(jsonValueSchema, this.state.current.args);
     await mkdir2(dirname2(this.path), { recursive: true });
     await this.files.withExclusiveLock(this.path, (path) => writeJsonAtomically(path, this.state));
   }
@@ -192,8 +192,13 @@ async function listRuns(sessionCwd) {
 }
 async function getRunInfo(runRoot) {
   try {
-    const resumeRequest = await readOptionalRunResumeRequest(runRoot);
-    const state = parseNornRunState(await readRunStateJson(runCurrentRoot(runRoot)));
+    const pendingResume = await readOptionalRunResumeRequest(runRoot).then(
+      (request) => ({ status: "fulfilled", request }),
+      (error) => ({ status: "rejected", error })
+    );
+    const state = parseNornRunState(await readRunStateJson(runCurrentRoot(runRoot)), "inspect");
+    if (state.version === RUN_STATE_VERSION && pendingResume.status === "rejected") throw pendingResume.error;
+    const resumeRequest = state.version === RUN_STATE_VERSION && pendingResume.status === "fulfilled" ? pendingResume.request : void 0;
     return {
       version: state.version,
       id: state.id,
@@ -277,10 +282,13 @@ async function readRunStateFile(input) {
 function isRecord(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
-function parseNornRunState(value) {
+function assertRunVersion(version) {
+  if (version !== RUN_STATE_VERSION) throw new Error(`Incompatible saved run state version ${String(version)}; this alpha requires version ${RUN_STATE_VERSION}. Use the original Norn version to resume this run, or start a new run. Saved files have not been migrated.`);
+}
+function parseNornRunState(value, mode) {
   if (!value || typeof value !== "object") throw new Error("Invalid run state");
   const state = value;
-  if (state.version !== RUN_STATE_VERSION) throw new Error(`Unsupported run state version: ${String(state.version)}`);
+  if (mode === "execute" || state.version !== 1) assertRunVersion(state.version);
   if (typeof state.id !== "string" || state.id.length === 0) throw new Error("Invalid run state id");
   const normalizedState = state;
   if (typeof normalizedState.name !== "string" || normalizedState.name.length === 0) normalizedState.name = state.id;
@@ -306,7 +314,7 @@ function runInterruption(state) {
   if (state.status !== "interrupted" || !state.current?.interruption) return void 0;
   return {
     workflowId: state.current.workflowId,
-    params: state.current.params,
+    args: state.version === 1 ? state.current.params : state.current.args,
     description: state.current.interruption.description ?? "",
     fields: state.current.interruption.fields
   };
@@ -320,8 +328,9 @@ function runFailure(state) {
 export {
   NornRunStateStore,
   RUN_STATE_FILE_NAME,
+  assertRunVersion,
   getRunInfo,
   listRuns,
-  mergeInterruptedWorkflowParams,
+  mergeInterruptedWorkflowArgs,
   resolveRunRoot
 };

package/dist/internal/run.d.ts

@@ -18,7 +18,6 @@ type DefaultNornRunInput = {
     readonly agentDir?: string;
     readonly responseCollector: NornAgentResponseCollector;
     readonly resources: NornRunResources;
-    readonly state: NornRun["state"];
     readonly logger: NornRunLogger;
     readonly artifacts: NornArtifacts;
     readonly logs: NornRunLogs;
@@ -26,7 +25,6 @@ type DefaultNornRunInput = {
 export declare class NornRunContext implements NornProjectRun {
     private readonly input;
     readonly resources: NornRunResources;
-    readonly state: NornRun["state"];
     readonly artifacts: NornRun["artifacts"];
     readonly logs: NornRun["logs"];
     readonly commands: NornRun["commands"];
@@ -41,7 +39,7 @@ export declare class NornRunContext implements NornProjectRun {
     private createAgentRunner;
     path(relativePath: string): string;
     projectPath(relativePath: string): string;
-    next(workflowId: string, params: unknown): ReturnType<NornRun["next"]>;
+    next(workflowId: string, args: unknown): ReturnType<NornRun["next"]>;
     complete(metadata?: NornRunOutcomeMetadata): ReturnType<NornRun["complete"]>;
     fail(metadata: NornRunOutcomeMetadata & {
         readonly summary: string;

package/dist/internal/run.js

@@ -4,7 +4,7 @@ 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 };
+  return { type: "next", workflowId: input.workflowId, args: input.args };
 }
 
 // src/internal/run.ts
@@ -18,7 +18,6 @@ var NornRunContext = class _NornRunContext {
     this.projectRoot = input.projectRoot;
     this.cwd = input.cwd;
     this.resources = input.resources;
-    this.state = input.state;
     this.artifacts = input.artifacts;
     this.logs = {
       read: (log) => this.input.logs.read(log)
@@ -40,7 +39,6 @@ var NornRunContext = class _NornRunContext {
   }
   input;
   resources;
-  state;
   artifacts;
   logs;
   commands;
@@ -82,8 +80,8 @@ var NornRunContext = class _NornRunContext {
   projectPath(relativePath) {
     return this.resolveFromRoot(this.projectRoot, this.projectRoot, relativePath);
   }
-  next(workflowId, params) {
-    return createWorkflowTransition({ workflowId, params });
+  next(workflowId, args) {
+    return createWorkflowTransition({ workflowId, args });
   }
   complete(metadata) {
     return { type: "complete", metadata };

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

@@ -1,21 +1,23 @@
-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>;
-    configuration?: NornRegisteredConfiguration;
-    plugin?: NornWorkflowPluginInfo;
-};
+import { type NornAnyWorkflowDeclaration, type NornDispose, type NornInspectedWorkflowInfo, type NornRegisteredWorkflowInfo, type NornRunComplete, type NornRunFail, type NornRunFor, type NornRunNext, type NornWorkflowSource, type NornProjectConfigurationInfo } from "@vimhead.dev/norn";
+import type { TSchema } from "typebox";
 export type NornRegisteredConfiguration = {
-    readonly schema: TSchema;
+    readonly key: string;
+    readonly schema: TSchema | undefined;
     readonly input: unknown;
     readonly value: unknown;
 };
-export declare function decodePluginConfiguration(input: {
-    readonly pluginId: string;
+export type NornRegisteredWorkflow = {
+    readonly workflow: NornAnyWorkflowDeclaration;
+    readonly configuration: NornRegisteredConfiguration;
+    readonly scopeId: string | undefined;
+    readonly source: NornWorkflowSource | undefined;
+};
+export declare function decodeConfiguration(input: {
+    readonly key: string;
     readonly schema: TSchema | undefined;
     readonly value: unknown;
-}): NornRegisteredConfiguration | undefined;
+}): NornRegisteredConfiguration;
+export declare function assertCompatibleConfigurationOwners(workflows: readonly NornAnyWorkflowDeclaration[]): void;
 export type NornWorkflowStepResult = NornRunNext | {
     readonly type: "complete";
     readonly workflow: NornAnyWorkflowDeclaration;
@@ -27,17 +29,23 @@ export type NornWorkflowStepResult = NornRunNext | {
 };
 export declare class NornWorkflowRegistry {
     private readonly entries;
-    register<TWorkflow extends NornAnyWorkflowDeclaration>(workflow: TWorkflow, implementation: NornWorkflowImplementation<TWorkflow, unknown>, metadata?: {
-        readonly plugin?: NornWorkflowPluginInfo;
-        readonly configuration?: NornRegisteredConfiguration;
+    private readonly scopes;
+    register(input: {
+        readonly workflow: NornAnyWorkflowDeclaration;
+        readonly config: Readonly<Record<string, unknown>>;
+        readonly source: NornWorkflowSource | undefined;
     }): NornDispose;
     list(options?: {
         readonly entrypointsOnly?: boolean;
     }): NornRegisteredWorkflowInfo[];
     inspect(workflowId: string): NornInspectedWorkflowInfo | undefined;
+    configurationInfos(): NornProjectConfigurationInfo[];
     launchableEntries(): NornRegisteredWorkflow[];
     workflowById(workflowId: string): NornAnyWorkflowDeclaration | undefined;
-    describeGate<TWorkflow extends NornAnyWorkflowDeclaration>(workflow: TWorkflow, run: NornRunFor<TWorkflow>, params: unknown, configOverride?: unknown): Promise<string>;
-    execute<TWorkflow extends NornAnyWorkflowDeclaration>(workflow: TWorkflow, run: NornRunFor<TWorkflow>, params: unknown, configOverride?: unknown): Promise<NornWorkflowStepResult>;
+    describeGate<TWorkflow extends NornAnyWorkflowDeclaration>(workflow: TWorkflow, run: NornRunFor<TWorkflow>, args: unknown, configOverride?: unknown): Promise<string>;
+    execute<TWorkflow extends NornAnyWorkflowDeclaration>(workflow: TWorkflow, run: NornRunFor<TWorkflow>, args: unknown, configOverride?: unknown): Promise<NornWorkflowStepResult>;
+    private createExecutionContext;
+    private requireEntry;
     private sortedEntries;
 }
+export declare function assertWorkflowDefinition(workflow: NornAnyWorkflowDeclaration): void;