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

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

@@ -1,6 +1,5 @@
 import {
 	type NornAnyWorkflowDeclaration,
-	type NornAnyWorkflowPluginManifest,
 	type NornDispose,
 	type NornInterruptedRunResult,
 	type NornRunCheckpoint,
@@ -8,28 +7,23 @@ import {
 	type NornRunNext,
 	type NornRunResult,
 	type NornRunStartOptions,
-	type NornWorkflowPlugin,
-	type NornWorkflowPluginImplementation,
-	type NornWorkflowPluginImplementationInput,
+	type NornWorkflowPaths,
 } from "@vimhead.dev/norn";
-import { createRunFileCoordinator } from "@vimhead.dev/norn/files";
+import { createRunFileCoordinator } from "./file-coordinator.ts";
 import { randomUUID } from "node:crypto";
 import { mkdir } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { Value } from "typebox/value";
 import { NornAgentResponseCollector } from "./agent-response-tool.ts";
-import { NornArtifacts } from "./artifacts.ts";
 import { errorMessage, NornRunStoppedError } from "./errors.ts";
 import { clearRunResumeRequest, matchesRunResumeRequest, readOptionalRunResumeRequest, RESUME_START_GRACE_MS, type NornRunResumeRequest } from "./launch-request.ts";
 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 { 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";
@@ -45,7 +39,9 @@ export type NornEngineInput = {
 
 type RunSession = {
 	readonly runRoot: string;
+	readonly cwd: string;
 	readonly run: NornRunContext;
+	readonly paths: NornWorkflowPaths;
 	readonly state: NornRunStateStore;
 	readonly lease: NornRunLease;
 	readonly runStore: NornRunStore;
@@ -62,14 +58,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 +71,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 +90,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 +108,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 +125,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,17 +155,17 @@ 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);
-				await recordRunEvent(session, { type: "run.resumed", workflowId: workflow.id, cwd: session.run.cwd });
+				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.cwd });
 				const resumedCurrent = session.state.currentState().current;
 				if (!resumedCurrent) throw new Error(`Run is not resumable: ${runRoot}`);
 				isLeaseOwnedByScheduler = true;
 				return this.runScheduler(session, toWorkflowStep(workflow, resumedCurrent));
 			}
 			if (state.status !== "pendingResume") throw new Error(`Run must be rolled back before resuming: ${runRoot}`);
-			await recordRunEvent(session, { type: "run.resumed", workflowId: workflow.id, cwd: session.run.cwd });
+			await recordRunEvent(session, { type: "run.resumed", workflowId: workflow.id, cwd: session.cwd });
 			isLeaseOwnedByScheduler = true;
 			return this.runScheduler(session, toWorkflowStep(workflow, current));
 		} finally {
@@ -201,28 +184,27 @@ export class NornEngine {
 		try {
 			for (let step = 1; step <= 1_000; step++) {
 				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({ workflow: currentStep.workflow, run: session.run, paths: session.paths, args: currentStep.args, configOverride: 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: session.run.id, name: session.state.currentState().name, workspace: session.paths.workspace, cwd: session.cwd }, currentStep.workflow, currentStep.args, interruption);
 				}
 				await session.state.startStep(toRunStateStep(currentStep));
-				const stepResult = await this.executeWorkflowStep(session, currentStep, stepRuntime);
+				const stepResult = await this.executeWorkflowStep(session, currentStep);
 				throwIfRunAborted(session.activeRun);
 				if (stepResult.type === "complete") {
 					await session.state.completeRun(stepResult.workflow.id, stepResult.metadata);
 					await recordRunEvent(session, { type: "run.completed", workflowId: stepResult.workflow.id, metadata: stepResult.metadata });
 					await commitRunBoundary(session, `run completed: ${stepResult.workflow.id}`);
-					return { status: "completed", id: stepRuntime.id, name: session.state.currentState().name, workspace: stepRuntime.workspace, cwd: stepRuntime.cwd, workflowId: stepResult.workflow.id, metadata: stepResult.metadata };
+					return { status: "completed", id: session.run.id, name: session.state.currentState().name, workspace: session.paths.workspace, cwd: session.cwd, workflowId: stepResult.workflow.id, metadata: stepResult.metadata };
 				}
 				if (stepResult.type === "fail") {
 					await session.state.failRun(stepResult.workflow.id, stepResult.metadata);
 					await recordRunEvent(session, { type: "run.failed", workflowId: stepResult.workflow.id, metadata: stepResult.metadata });
-					return { status: "failed", id: stepRuntime.id, name: session.state.currentState().name, workspace: stepRuntime.workspace, cwd: stepRuntime.cwd, workflowId: stepResult.workflow.id, metadata: stepResult.metadata };
+					return { status: "failed", id: session.run.id, name: session.state.currentState().name, workspace: session.paths.workspace, cwd: session.cwd, workflowId: stepResult.workflow.id, metadata: stepResult.metadata };
 				}
 				const nextStep = this.nextWorkflowStep(stepResult);
 				await session.state.completeWithNext(currentStep.workflow.id, toRunStateStep(nextStep));
@@ -235,7 +217,7 @@ export class NornEngine {
 			if (isRunStopped(session, error)) {
 				await session.state.stopCurrent();
 				await recordRunEvent(session, { type: "run.stopped", workflowId: currentStep.workflow.id });
-				return { status: "stopped", id: session.run.id, name: session.state.currentState().name, workspace: session.run.workspace, cwd: session.run.cwd, workflowId: currentStep.workflow.id };
+				return { status: "stopped", id: session.run.id, name: session.state.currentState().name, workspace: session.paths.workspace, cwd: session.cwd, workflowId: currentStep.workflow.id };
 			}
 			await session.state.failCurrent(errorMessage(error));
 			await recordRunEvent(session, { type: "run.failed", workflowId: currentStep.workflow.id, error: errorMessage(error) });
@@ -246,13 +228,13 @@ export class NornEngine {
 		}
 	}
 
-	private async executeWorkflowStep(session: RunSession, step: WorkflowStep, run: NornRunContext): Promise<NornWorkflowStepResult> {
+	private async executeWorkflowStep(session: RunSession, step: WorkflowStep): Promise<NornWorkflowStepResult> {
 		const startedAtMs = Date.now();
 		try {
-			await assertWorkspaceBoundary(session, run.workspace);
+			await assertWorkspaceBoundary(session, session.paths.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);
-			await assertWorkspaceBoundary(session, run.workspace);
+			const result = await this.registry.execute({ workflow: step.workflow, run: session.run, paths: session.paths, args: step.args, configOverride: session.state.currentState().configOverride });
+			await assertWorkspaceBoundary(session, session.paths.workspace);
 			const durationMs = Date.now() - startedAtMs;
 			if (result.type === "complete") await recordRunEvent(session, { type: "workflow.completed", workflowId: result.workflow.id, durationMs, metadata: result.metadata });
 			else if (result.type === "fail") await recordRunEvent(session, { type: "workflow.failed", 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();
@@ -289,7 +271,8 @@ export class NornEngine {
 		const runRoot = defaultRunRoot(this.input.cwd, id);
 		const currentRoot = runCurrentRoot(runRoot);
 		const workspace = join(currentRoot, "workspace");
-		const cwd = workflowDefaultCwd(this.input.cwd, workspace, workflow);
+		const paths: NornWorkflowPaths = { project: resolve(this.input.cwd), workspace: workspace };
+		const cwd = process.cwd();
 		const startedAt = new Date().toISOString();
 		await mkdir(runRoot, { recursive: true });
 		const lease = await NornRunLease.acquire(runRoot);
@@ -306,20 +289,21 @@ export class NornEngine {
 				initialCwd: cwd,
 				startedAt,
 			} });
-			const run = await this.buildRun({ id, currentRoot, workspace, cwd, isolationMode: workflow.isolation.mode, signal: activeRun.controller.signal, logger });
+			const run = await this.buildRun({ id, currentRoot, paths, signal: activeRun.controller.signal, logger });
 			const state = await NornRunStateStore.create(runRoot, {
+				projectRoot: paths.project,
 				id,
 				name,
 				entrypointWorkflowId: workflow.id,
 				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,
 			});
-			const session = { runRoot, run, state, lease, runStore, logger, activeRun };
+			const session = { runRoot, cwd, run, paths, state, lease, runStore, logger, activeRun };
 			await logger.record({ type: "run.started", workflowId: workflow.id, cwd, workspace });
 			await commitRunBoundary(session, `run started: ${workflow.id}`);
 			return session;
@@ -339,11 +323,9 @@ export class NornEngine {
 			const runStore = await NornRunStore.open(runRoot);
 			const currentRoot = runCurrentRoot(runRoot);
 			const logger = await NornRunLogger.load(join(currentRoot, MANIFEST_FILE_NAME), createRunFileCoordinator(runRoot));
-			const workflow = currentState.current ? this.registry.workflowById(currentState.current.workflowId) : undefined;
-			const isolationMode = workflow?.isolation.mode ?? "runWorkspace";
-			const cwd = workflowDefaultCwd(this.input.cwd, currentState.workspace, workflow);
-			const run = await this.buildRun({ id: currentState.id, currentRoot, workspace: currentState.workspace, cwd, isolationMode, signal: activeRun.controller.signal, logger });
-			return { runRoot, run, state, lease, runStore, logger, activeRun };
+			const paths: NornWorkflowPaths = { project: currentState.projectRoot ?? resolve(runRoot, "../../.."), workspace: currentState.workspace };
+			const run = await this.buildRun({ id: currentState.id, currentRoot, paths, signal: activeRun.controller.signal, logger });
+			return { runRoot, cwd: process.cwd(), run, paths, state, lease, runStore, logger, activeRun };
 		} catch (error) {
 			this.failActiveRun(runRoot, activeRun);
 			throw error;
@@ -353,33 +335,22 @@ export class NornEngine {
 	private async buildRun(input: {
 		readonly id: string;
 		readonly currentRoot: string;
-		readonly workspace: string;
-		readonly cwd: string;
-		readonly isolationMode: "runWorkspace" | "project";
+		readonly paths: NornWorkflowPaths;
 		readonly signal: AbortSignal;
 		readonly logger: NornRunLogger;
 	}): Promise<NornRunContext> {
-		const artifactsRoot = join(input.currentRoot, "artifacts");
 		const logsRoot = join(input.currentRoot, "logs");
-		await mkdir(input.workspace, { recursive: true });
-		await mkdir(artifactsRoot, { recursive: true });
+		await mkdir(input.paths.workspace, { recursive: true });
 		await mkdir(logsRoot, { recursive: true });
-		const { resources, state } = await initializeRunResources(dirname(input.currentRoot));
+		const files = createRunFileCoordinator(dirname(input.currentRoot));
 		return new NornRunContext({
 			id: input.id,
 			runRoot: input.currentRoot,
-			workspace: input.workspace,
-			projectRoot: this.input.cwd,
-			cwd: input.cwd,
-			isolationMode: input.isolationMode,
 			signal: input.signal,
 			agentDir: this.input.agentDir,
 			responseCollector: this.responseCollector,
-			resources,
-			state,
 			logger: input.logger,
-			artifacts: new NornArtifacts(artifactsRoot, resources.files),
-			logs: new NornRunLogs(logsRoot, resources.files),
+			logs: new NornRunLogs(logsRoot, files),
 		});
 	}
 
@@ -416,25 +387,16 @@ 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 {
-	return join(cwd, RUNS_DIR_NAME, "runs", id);
-}
-
-function workflowDefaultCwd(projectRoot: string, workspace: string, workflow: NornAnyWorkflowDeclaration | undefined): string {
-	return workflow?.isolation.mode === "project" ? projectRoot : workspace;
+	return join(resolve(cwd), RUNS_DIR_NAME, "runs", id);
 }
 
 function toWorkflowStep(workflow: NornAnyWorkflowDeclaration, step: NonNullable<NornRunState["current"]>): WorkflowStep {
 	return {
 		workflow,
-		params: step.params,
+		args: step.args,
 		interruption: step.interruption,
 	};
 }
@@ -442,7 +404,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 +426,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 +436,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/logs.ts

@@ -1,6 +1,6 @@
 import { createWriteStream, type WriteStream } from "node:fs";
 import { mkdir } from "node:fs/promises";
-import type { NornFileCoordinator } from "@vimhead.dev/norn/files";
+import type { NornFileCoordinator } from "./file-coordinator.ts";
 import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import type { NornLogRef } from "@vimhead.dev/norn";
 

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

@@ -1,5 +1,5 @@
 import { readFile } from "node:fs/promises";
-import type { NornFileCoordinator } from "@vimhead.dev/norn/files";
+import type { NornFileCoordinator } from "./file-coordinator.ts";
 import { isNodeError } from "@vimhead.dev/norn-core/errors";
 import { writeJsonAtomically } from "@vimhead.dev/norn-core/atomic-files";