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

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

@@ -3,16 +3,15 @@ import { fileURLToPath } from "node:url";
 import { createInterface } from "node:readline";
 import type {
 	DeletedNornRunInfo,
-	NornPluginDiagnostic,
+	NornWorkflowDiagnostic,
 	NornProjectInspection,
 	NornWorkflowCatalogInfo,
 	NornWorkflowInspection,
 	NornRunCheckpoint,
 	NornRunInfo,
 	NornRunMetrics,
-	NornWorkflowStateReader,
 } from "@vimhead.dev/norn";
-import { loadNornProject } from "./plugin-loader.ts";
+import { loadNornProject } from "./workflow-loader.ts";
 import { NornProjectLoadError } from "./internal/errors.ts";
 import type { NornRegisteredWorkflow } from "./internal/workflow-registry.ts";
 
@@ -32,10 +31,9 @@ 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 configOverride?: unknown }): Promise<NornRunInfo>;
-		resume(input: { readonly run: string; readonly params?: unknown }): Promise<NornRunInfo>;
+		start(input: { readonly workflowId: string; readonly args: unknown; readonly configOverride?: unknown }): Promise<NornRunInfo>;
+		resume(input: { readonly run: string; readonly args?: unknown }): Promise<NornRunInfo>;
 		wait(run: string): Promise<NornRunInfo>;
 		list(): Promise<NornRunInfo[]>;
 		inspect(run: string): Promise<NornRunInfo>;
@@ -61,7 +59,6 @@ export function createNornClient(input: NornClientInput = {}): NornClient {
 			inspect: async (workflowId) => processRunner.readJson<NornWorkflowInspection>(["workflows", "inspect", workflowId]),
 			entries: async () => (await catalog.load()).workflows,
 		},
-		state: catalog.state,
 		runs: {
 			start: async (startInput) => (await processRunner.readJson<{ run: NornRunInfo }>(["runs", "start", startInput.workflowId], JSON.stringify(runStartInput(startInput)))).run,
 			resume: async (resumeInput) => (await processRunner.readJson<{ run: NornRunInfo }>(["runs", "resume", resumeInput.run], runResumeStdin(resumeInput))).run,
@@ -82,10 +79,6 @@ export function createNornClient(input: NornClientInput = {}): NornClient {
 
 class NornWorkflowCatalog {
 	private loaded: ReturnType<typeof loadNornProject> | undefined;
-	readonly state: NornWorkflowStateReader = {
-		get: async (state) => (await this.load()).state.get(state),
-		getOptional: async (state) => (await this.load()).state.getOptional(state),
-	};
 
 	constructor(private readonly cwd: string) {}
 
@@ -107,7 +100,7 @@ class NornProcessRunner {
 
 	async readJson<T>(args: readonly string[], stdin?: string): Promise<T> {
 		const result = await this.spawn(args, stdin);
-		const parsed = JSON.parse(result.stdout) as T | { error?: { code?: string; message?: string; diagnostics?: NornPluginDiagnostic[] } };
+		const parsed = JSON.parse(result.stdout) as T | { error?: { code?: string; message?: string; diagnostics?: NornWorkflowDiagnostic[] } };
 		if (parsed && typeof parsed === "object" && "error" in parsed) {
 			if (parsed.error?.code === "NORN_PROJECT_INVALID" && Array.isArray(parsed.error.diagnostics)) throw new NornProjectLoadError({ diagnostics: parsed.error.diagnostics });
 			throw new Error(parsed.error?.message ?? "Norn command failed");
@@ -151,10 +144,10 @@ class NornProcessRunner {
 	}
 }
 
-function runStartInput(input: { readonly params: unknown; readonly configOverride?: unknown }): { readonly params: unknown; readonly config?: unknown } {
-	return input.configOverride === undefined ? { params: input.params } : { params: input.params, config: input.configOverride };
+function runStartInput(input: { readonly args: unknown; readonly configOverride?: unknown }): { readonly args: unknown; readonly config?: unknown } {
+	return input.configOverride === undefined ? { args: input.args } : { args: input.args, config: input.configOverride };
 }
 
-function runResumeStdin(input: { readonly params?: unknown }): string | undefined {
-	return input.params === undefined ? undefined : JSON.stringify({ params: input.params });
+function runResumeStdin(input: { readonly args?: unknown }): string | undefined {
+	return input.args === undefined ? undefined : JSON.stringify({ args: input.args });
 }

package/assets/packages/cli/src/documentation-intro.ts

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

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

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

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

@@ -71,12 +71,12 @@ export class NornAgentResponseToolFactory {
 				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 } as AgentResponseToolDetails,
+						details: { valid: true, runId: args.runId, label: captured.label, response: captured.response } as AgentResponseToolDetails,
 						terminate: true,
 					};
 				} catch (error) {

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

@@ -1,6 +1,5 @@
 import {
 	type NornAnyWorkflowDeclaration,
-	type NornAnyWorkflowPluginManifest,
 	type NornDispose,
 	type NornInterruptedRunResult,
 	type NornRunCheckpoint,
@@ -8,9 +7,6 @@ import {
 	type NornRunNext,
 	type NornRunResult,
 	type NornRunStartOptions,
-	type NornWorkflowPlugin,
-	type NornWorkflowPluginImplementation,
-	type NornWorkflowPluginImplementationInput,
 } from "@vimhead.dev/norn";
 import { createRunFileCoordinator } from "@vimhead.dev/norn/files";
 import { randomUUID } from "node:crypto";
@@ -24,12 +20,11 @@ import { clearRunResumeRequest, matchesRunResumeRequest, readOptionalRunResumeRe
 import { NornRunLogs } from "./logs.ts";
 import { NornRunLease } from "./run-lease.ts";
 import { NornRunLogger } from "./run-log.ts";
-import { initializeRunResources } from "./run-resources.ts";
-import { getRunInfo, mergeInterruptedWorkflowParams, NornRunStateStore, resolveRunRoot, type NornRunState } from "./run-state.ts";
+import { NornRunResources } from "../resources.ts";
+import { assertRunVersion, getRunInfo, mergeInterruptedWorkflowArgs, NornRunStateStore, resolveRunRoot, type NornRunState } from "./run-state.ts";
 import { NornRunStore, runCurrentRoot } from "./run-store.ts";
 import { NornRunContext } from "./run.ts";
-import { NornMemoryWorkflowState } from "./state-store.ts";
-import { decodePluginConfiguration, NornWorkflowRegistry, type NornRegisteredWorkflow, type NornWorkflowStepResult } from "./workflow-registry.ts";
+import { NornWorkflowRegistry, type NornRegisteredWorkflow, type NornWorkflowStepResult } from "./workflow-registry.ts";
 
 const RUNS_DIR_NAME = ".norn";
 const MANIFEST_FILE_NAME = "manifest.json";
@@ -62,14 +57,12 @@ type ActiveRun = {
 
 type WorkflowStep = {
 	readonly workflow: NornAnyWorkflowDeclaration;
-	readonly params: unknown;
+	readonly args: unknown;
 	readonly interruption?: NonNullable<NornRunState["current"]>["interruption"];
 };
 
 export class NornEngine {
 	private readonly registry = new NornWorkflowRegistry();
-	private readonly registrarState = new NornMemoryWorkflowState();
-	private readonly disposersByPlugin = new Map<string, NornDispose[]>();
 	private readonly responseCollector: NornAgentResponseCollector;
 	private readonly activeRuns = new Map<string, ActiveRun>();
 
@@ -77,19 +70,15 @@ export class NornEngine {
 		this.responseCollector = input.responseCollector ?? new NornAgentResponseCollector();
 	}
 
-	registerPlugin<TManifest extends NornAnyWorkflowPluginManifest>(plugin: NornWorkflowPlugin<TManifest>): NornDispose {
-		this.disposePlugin(plugin.manifest.id);
-		const implementation = this.resolvePluginImplementation(plugin.implementation);
-		const configuration = decodePluginConfiguration({ pluginId: plugin.manifest.id, schema: plugin.manifest.config, value: this.input.config?.[plugin.manifest.id] });
-		const disposers = Object.entries(plugin.manifest.workflows).map(([key, workflow]) => {
-			const workflowImplementation = implementation.workflows[key];
-			if (!workflowImplementation) throw new Error(`Missing implementation for workflow ${plugin.manifest.id}.${key}`);
-			return this.registry.register(workflow, workflowImplementation, { plugin: { id: plugin.manifest.id }, configuration });
-		});
-		this.disposersByPlugin.set(plugin.manifest.id, disposers);
-		return () => {
-			if (this.disposersByPlugin.get(plugin.manifest.id) === disposers) this.disposePlugin(plugin.manifest.id);
-		};
+	registerWorkflows(workflows: readonly NornAnyWorkflowDeclaration[]): NornDispose {
+		const disposers: NornDispose[] = [];
+		try {
+			for (const workflow of workflows) disposers.push(this.registry.register({ workflow, config: this.input.config ?? {}, source: undefined }));
+		} catch (error) {
+			for (const dispose of disposers.reverse()) dispose();
+			throw error;
+		}
+		return () => { for (const dispose of disposers) dispose(); };
 	}
 
 	listWorkflows() {
@@ -100,20 +89,12 @@ export class NornEngine {
 		return this.registry.launchableEntries();
 	}
 
-	private resolvePluginImplementation<TManifest extends NornAnyWorkflowPluginManifest>(
-		implementationInput: NornWorkflowPluginImplementationInput<TManifest>,
-	): NornWorkflowPluginImplementation<TManifest> {
-		return typeof implementationInput === "function"
-			? implementationInput({ cwd: this.input.cwd, state: this.registrarState })
-			: implementationInput;
-	}
-
 	async runWorkflow<TWorkflow extends NornAnyWorkflowDeclaration>(
 		workflow: TWorkflow,
-		params: unknown,
+		args: unknown,
 		options: NornRunStartOptions | undefined,
 	): Promise<NornRunResult> {
-		const session = await this.createRunSession(workflow, params, 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));
@@ -126,6 +107,7 @@ export class NornEngine {
 
 	async rollbackRun(path: string, checkpointId: string): Promise<NornRunInfo> {
 		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);
@@ -142,21 +124,21 @@ export class NornEngine {
 		}
 	}
 
-	async resumeWorkflow(path: string, params?: unknown): Promise<NornRunResult> {
-		return this.resumeWorkflowExecution({ path, params, expectedRequest: undefined });
+	async resumeWorkflow(path: string, args?: unknown): Promise<NornRunResult> {
+		return this.resumeWorkflowExecution({ path, args, expectedRequest: undefined });
 	}
 
 	async resumeRequestedWorkflow(input: { readonly runRoot: string; readonly request: NornRunResumeRequest }): Promise<NornRunResult> {
-		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 });
 	}
 
-	private async resumeWorkflowExecution(input: { readonly path: string; readonly params: unknown; readonly expectedRequest: NornRunResumeRequest | undefined }): Promise<NornRunResult> {
-		const { params, expectedRequest } = input;
+	private async resumeWorkflowExecution(input: { readonly path: string; readonly args: unknown; readonly expectedRequest: NornRunResumeRequest | undefined }): Promise<NornRunResult> {
+		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 === undefined) throw new Error(`Interrupted workflow resume requires params: ${runRoot}`);
-		if (initialState.status === "pendingResume" && params !== undefined) throw new Error(`Pending-resume workflows do not accept params: ${runRoot}`);
+		if (initialState.status === "interrupted" && args === undefined) throw new Error(`Interrupted workflow resume requires args: ${runRoot}`);
+		if (initialState.status === "pendingResume" && args !== undefined) 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);
@@ -172,9 +154,9 @@ export class NornEngine {
 			const workflow = this.registry.workflowById(current.workflowId);
 			if (!workflow) throw new Error(`Unknown workflow for resumed run: ${current.workflowId}`);
 			if (state.status === "interrupted") {
-				const 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}`);
@@ -203,12 +185,12 @@ export class NornEngine {
 				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);
@@ -251,7 +233,7 @@ export class NornEngine {
 		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 });
@@ -274,14 +256,14 @@ export class NornEngine {
 		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" } : undefined,
 		};
 	}
 
 	private async createRunSession<TWorkflow extends NornAnyWorkflowDeclaration>(
 		workflow: TWorkflow,
-		params: unknown,
+		args: unknown,
 		options: NornRunStartOptions | undefined,
 	): Promise<RunSession> {
 		const id = options?.id ?? randomUUID();
@@ -314,7 +296,7 @@ export class NornEngine {
 				workspace,
 				configOverride: options?.configOverride,
 				current: {
-					workflowId: workflow.id, params, cwd, env: {},
+					workflowId: workflow.id, args, cwd, env: {},
 					interruption: this.input.gateMode === "pause" && workflow.gate ? { status: "pending" } : undefined,
 				},
 				startedAt,
@@ -364,7 +346,7 @@ export class NornEngine {
 		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,
@@ -376,7 +358,6 @@ export class NornEngine {
 			agentDir: this.input.agentDir,
 			responseCollector: this.responseCollector,
 			resources,
-			state,
 			logger: input.logger,
 			artifacts: new NornArtifacts(artifactsRoot, resources.files),
 			logs: new NornRunLogs(logsRoot, resources.files),
@@ -416,11 +397,6 @@ export class NornEngine {
 		activeRun.finish();
 	}
 
-	private disposePlugin(pluginId: string): void {
-		const disposers = this.disposersByPlugin.get(pluginId) ?? [];
-		for (const dispose of [...disposers].reverse()) dispose();
-		this.disposersByPlugin.delete(pluginId);
-	}
 }
 
 function defaultRunRoot(cwd: string, id: string): string {
@@ -434,7 +410,7 @@ function workflowDefaultCwd(projectRoot: string, workspace: string, workflow: No
 function toWorkflowStep(workflow: NornAnyWorkflowDeclaration, step: NonNullable<NornRunState["current"]>): WorkflowStep {
 	return {
 		workflow,
-		params: step.params,
+		args: step.args,
 		interruption: step.interruption,
 	};
 }
@@ -442,7 +418,7 @@ function toWorkflowStep(workflow: NornAnyWorkflowDeclaration, step: NonNullable<
 function toRunStateStep(step: WorkflowStep): NonNullable<NornRunState["current"]> {
 	return {
 		workflowId: step.workflow.id,
-		params: step.params,
+		args: step.args,
 		cwd: "",
 		env: {},
 		interruption: step.interruption,
@@ -464,7 +440,7 @@ function isRunStopped(session: RunSession, error: unknown): boolean {
 	return error instanceof NornRunStoppedError || session.activeRun.controller.signal.reason instanceof NornRunStoppedError;
 }
 
-function interruptedLaunchResult(run: RunIdentity, workflow: NornAnyWorkflowDeclaration, params: unknown, interruption: { readonly description?: string; readonly fields?: readonly string[] }): NornInterruptedRunResult {
+function interruptedLaunchResult(run: RunIdentity, workflow: NornAnyWorkflowDeclaration, args: unknown, interruption: { readonly description?: string; readonly fields?: readonly string[] }): NornInterruptedRunResult {
 	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 {
@@ -474,7 +450,7 @@ function interruptedLaunchResult(run: RunIdentity, workflow: NornAnyWorkflowDecl
 		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 },
 	};
 }
 

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

@@ -1,14 +1,14 @@
-import type { NornPluginDiagnostic } from "@vimhead.dev/norn";
+import type { NornWorkflowDiagnostic } from "@vimhead.dev/norn";
 import { AssertError } from "typebox/value";
 
 export 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[] }) {
+	constructor(input: { readonly diagnostics: readonly NornWorkflowDiagnostic[] }) {
 		const details = input.diagnostics.map(diagnostic =>
-			`${diagnostic.stage}: ${diagnostic.pluginPath} (declared in ${diagnostic.configPath}${diagnostic.workflowId ? `; workflow ${diagnostic.workflowId}` : ""}): ${diagnostic.message}`,
+			`${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.\n${details.join("\n")}`);
 		this.name = "NornProjectLoadError";

package/assets/packages/cli/src/internal/launch-request.ts

@@ -10,22 +10,22 @@ export const RESUME_REQUEST_FILE_NAME = "resume-request.json";
 export const RESUME_START_GRACE_MS = 60_000;
 
 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;
 };
 
@@ -75,7 +75,7 @@ export async function clearRunResumeRequest(input: { readonly runRoot: string; r
 function parseRunLaunchRequest(value: unknown): NornRunLaunchRequest {
 	if (!value || typeof value !== "object") throw new Error("Invalid workflow launch request");
 	const request = value as Partial<NornRunLaunchRequest>;
-	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");
@@ -86,7 +86,7 @@ function parseRunLaunchRequest(value: unknown): NornRunLaunchRequest {
 function parseRunResumeRequest(value: unknown): NornRunResumeRequest {
 	if (!value || typeof value !== "object") throw new Error("Invalid workflow resume request");
 	const request = value as Partial<NornRunResumeRequest>;
-	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 !== undefined && (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/assets/packages/cli/src/internal/run-state.ts

@@ -13,19 +13,19 @@ import { Value } from "typebox/value";
 export const RUN_STATE_FILE_NAME = "run-state.json";
 const LEGACY_RUN_STATE_FILE_NAME = "runtime-state.json";
 
-export function mergeInterruptedWorkflowParams(currentParams: unknown, params: unknown, fields: readonly string[] | undefined): unknown {
-	if (!isRecord(currentParams) || !isRecord(params)) return params;
+export function mergeInterruptedWorkflowArgs(currentArgs: unknown, args: unknown, fields: readonly string[] | undefined): unknown {
+	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 };
 }
-const RUN_STATE_VERSION = 1;
+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;
@@ -58,7 +58,7 @@ type NornRunWorkflowOutcome = {
 };
 
 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;
@@ -119,7 +119,7 @@ export class NornRunStateStore {
 	static async load(runRoot: string): Promise<NornRunStateStore> {
 		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 });
 	}
 
@@ -163,11 +163,11 @@ export class NornRunStateStore {
 		});
 	}
 
-	async interruptCurrent(params: unknown, interruption: { readonly description: string; readonly fields?: readonly string[] }): Promise<void> {
+	async interruptCurrent(args: unknown, interruption: { readonly description: string; readonly fields?: readonly string[] }): Promise<void> {
 		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,
 		});
@@ -185,11 +185,11 @@ export class NornRunStateStore {
 		await this.update({ status: "stopped", outcome: null, failed: null });
 	}
 
-	async replaceCurrentParams(params: unknown): Promise<void> {
+	async replaceCurrentArgs(args: unknown): Promise<void> {
 		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,
 		});
@@ -208,16 +208,16 @@ export class NornRunStateStore {
 
 	private async update(patch: Partial<NornRunState>): Promise<void> {
 		await this.files.withExclusiveLock(this.path, async (path) => {
-			const current = parseNornRunState(await readRunStateFile({ path, legacyPath: join(dirname(this.path), LEGACY_RUN_STATE_FILE_NAME) }));
+			const current = parseNornRunState(await readRunStateFile({ path, legacyPath: join(dirname(this.path), LEGACY_RUN_STATE_FILE_NAME) }), "execute");
 			const next = { ...current, ...patch, updatedAt: new Date().toISOString() };
-			if (next.current?.params !== undefined) Value.Assert(jsonValueSchema, next.current.params);
+			if (next.current?.args !== undefined) Value.Assert(jsonValueSchema, next.current.args);
 			await writeJsonAtomically(path, next);
 			this.state = next;
 		});
 	}
 
 	private async write(): Promise<void> {
-		if (this.state.current?.params !== undefined) Value.Assert(jsonValueSchema, this.state.current.params);
+		if (this.state.current?.args !== undefined) Value.Assert(jsonValueSchema, this.state.current.args);
 		await mkdir(dirname(this.path), { recursive: true });
 		await this.files.withExclusiveLock(this.path, (path) => writeJsonAtomically(path, this.state));
 	}
@@ -239,8 +239,14 @@ export async function listRuns(sessionCwd: string): Promise<NornRunInfo[]> {
 
 export async function getRunInfo(runRoot: string): Promise<NornRunInfo> {
 	try {
-		const resumeRequest = await readOptionalRunResumeRequest(runRoot);
-		const state = parseNornRunState(await readRunStateJson(runCurrentRoot(runRoot)));
+		// Read the request first so a completed handoff cannot revive an old interruption.
+		const pendingResume = await readOptionalRunResumeRequest(runRoot).then(
+			request => ({ status: "fulfilled" as const, request }),
+			(error: unknown) => ({ status: "rejected" as const, 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 : undefined;
 		return {
 			version: state.version,
 			id: state.id,
@@ -337,10 +343,14 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 	return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
-function parseNornRunState(value: unknown): NornRunState {
+export function assertRunVersion(version: unknown): void {
+	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: unknown, mode: "execute" | "inspect"): NornRunState {
 	if (!value || typeof value !== "object") throw new Error("Invalid run state");
 	const state = value as Partial<NornRunState> & { rootWorkflowId?: unknown };
-	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 as { name?: string; entrypointWorkflowId?: unknown; rootWorkflowId?: unknown };
 	if (typeof normalizedState.name !== "string" || normalizedState.name.length === 0) normalizedState.name = state.id;
@@ -369,7 +379,7 @@ function runInterruption(state: NornRunState): NornRunInterruption | undefined {
 	if (state.status !== "interrupted" || !state.current?.interruption) return undefined;
 	return {
 		workflowId: state.current.workflowId,
-		params: state.current.params,
+		args: state.version === 1 ? (state.current as { readonly params?: unknown }).params : state.current.args,
 		description: state.current.interruption.description ?? "",
 		fields: state.current.interruption.fields,
 	};

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

@@ -23,7 +23,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;
@@ -31,7 +30,6 @@ type DefaultNornRunInput = {
 
 export class NornRunContext implements NornProjectRun {
 	readonly resources: NornRunResources;
-	readonly state: NornRun["state"];
 	readonly artifacts: NornRun["artifacts"];
 	readonly logs: NornRun["logs"];
 	readonly commands: NornRun["commands"];
@@ -47,7 +45,6 @@ export class NornRunContext implements NornProjectRun {
 		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),
@@ -107,8 +104,8 @@ export class NornRunContext implements NornProjectRun {
 		return this.resolveFromRoot(this.projectRoot, this.projectRoot, relativePath);
 	}
 
-	next(workflowId: string, params: unknown): ReturnType<NornRun["next"]> {
-		return createWorkflowTransition({ workflowId, params });
+	next(workflowId: string, args: unknown): ReturnType<NornRun["next"]> {
+		return createWorkflowTransition({ workflowId, args });
 	}
 
 	complete(metadata?: NornRunOutcomeMetadata): ReturnType<NornRun["complete"]> {