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

package/dist/internal/workflow-registry.js

@@ -1,39 +1,79 @@
 // src/internal/workflow-registry.ts
-import { isWorkflowComplete, isWorkflowFail, isWorkflowNext } from "@vimhead.dev/norn";
+import { isWorkflowComplete, isWorkflowDeclaration, isWorkflowFail, isWorkflowNext } from "@vimhead.dev/norn";
 import { assertWorkflowMetadata, inspectSchema, isPlainObject, schemaShape, schemaType, unwrapSchema } from "@vimhead.dev/norn/schema";
 import { Value } from "typebox/value";
-function decodePluginConfiguration(input) {
+function decodeConfiguration(input) {
   if (!input.schema) {
-    if (input.value !== void 0) throw new Error(`Norn config provided for plugin without config schema: ${input.pluginId}`);
-    return void 0;
+    if (input.value !== void 0) throw new Error(`Norn config provided without config schema: ${input.key}`);
+    return { key: input.key, schema: void 0, input: void 0, value: void 0 };
+  }
+  const value = input.value === void 0 && schemaType(unwrapSchema(input.schema)) === "object" ? {} : input.value;
+  return { key: input.key, schema: input.schema, input: value, value: Value.Decode(input.schema, value) };
+}
+function assertCompatibleConfigurationOwners(workflows) {
+  const owners = /* @__PURE__ */ new Map();
+  for (const workflow of workflows) {
+    for (const owner of [
+      { key: workflow.id, kind: "workflow", definition: workflow },
+      ...workflow.scope ? [{ key: workflow.scope.id, kind: "scope", definition: workflow.scope }] : []
+    ]) {
+      const previous = owners.get(owner.key);
+      if (previous && previous.kind !== owner.kind) throw new Error(`Ambiguous configuration key: ${owner.key}`);
+      if (previous && owner.kind === "scope" && previous.definition !== owner.definition) throw new Error(`Duplicate workflow scope id: ${owner.key}; import one shared scope definition`);
+      owners.set(owner.key, owner);
+    }
   }
-  const value = defaultConfigInput(input.schema, input.value);
-  return { schema: input.schema, input: value, value: Value.Decode(input.schema, value) };
 }
 var NornWorkflowRegistry = class {
   entries = /* @__PURE__ */ new Map();
-  register(workflow, implementation, metadata = {}) {
+  scopes = /* @__PURE__ */ new Map();
+  register(input) {
+    const { workflow, config, source } = input;
+    assertWorkflowDefinition(workflow);
     if (this.entries.has(workflow.id)) throw new Error(`Workflow already registered: ${workflow.id}`);
+    assertCompatibleConfigurationOwners([...this.sortedEntries().map((entry2) => entry2.workflow), workflow]);
     const entry = {
       workflow,
-      implementation,
-      configuration: metadata.configuration,
-      plugin: metadata.plugin
+      source,
+      scopeId: workflow.scope?.id,
+      configuration: decodeConfiguration({ key: workflow.id, schema: workflow.config, value: configurationInput(config, workflow.id) })
     };
-    assertWorkflowMetadata(workflow);
-    assertGateWorkflow(workflow);
+    if (workflow.scope && !this.scopes.has(workflow.scope.id)) {
+      this.scopes.set(workflow.scope.id, {
+        definition: workflow.scope,
+        configuration: decodeConfiguration({ key: workflow.scope.id, schema: workflow.scope.config, value: configurationInput(config, workflow.scope.id) })
+      });
+    }
     this.entries.set(workflow.id, entry);
     return () => {
-      if (this.entries.get(workflow.id) === entry) this.entries.delete(workflow.id);
+      if (this.entries.get(workflow.id) !== entry) return;
+      this.entries.delete(workflow.id);
+      if (entry.scopeId && ![...this.entries.values()].some((other) => other.scopeId === entry.scopeId)) this.scopes.delete(entry.scopeId);
     };
   }
   list(options = {}) {
-    const entries = options.entrypointsOnly ? this.launchableEntries() : this.sortedEntries();
-    return entries.map((entry) => workflowInfo(entry));
+    return (options.entrypointsOnly ? this.launchableEntries() : this.sortedEntries()).map(workflowInfo);
   }
   inspect(workflowId) {
     const entry = this.entries.get(workflowId);
-    return entry ? inspectedWorkflowInfo(entry) : void 0;
+    const scope = entry?.scopeId ? this.scopes.get(entry.scopeId) : void 0;
+    return entry ? {
+      ...workflowInfo(entry),
+      argsSchema: inspectSchema(entry.workflow.args),
+      configSchema: entry.configuration.schema ? inspectSchema(entry.configuration.schema) : null,
+      scope: scope ? {
+        id: scope.definition.id,
+        configKey: scope.configuration.key,
+        configSchema: scope.configuration.schema ? inspectSchema(scope.configuration.schema) : null
+      } : void 0,
+      gate: gateInfo(entry.workflow)
+    } : void 0;
+  }
+  configurationInfos() {
+    return [
+      ...this.sortedEntries().map((entry) => ({ configuration: entry.configuration, scopeId: null })),
+      ...[...this.scopes.values()].map((scope) => ({ configuration: scope.configuration, scopeId: scope.definition.id }))
+    ].map(({ configuration, scopeId }) => ({ key: configuration.key, scopeId, configSchema: configuration.schema ? inspectSchema(configuration.schema) : null, config: configuration.value }));
   }
   launchableEntries() {
     return this.sortedEntries().filter(({ workflow }) => workflow.isEntrypoint);
@@ -41,80 +81,71 @@ var NornWorkflowRegistry = class {
   workflowById(workflowId) {
     return this.entries.get(workflowId)?.workflow;
   }
-  async describeGate(workflow, run, params, configOverride) {
-    const entry = this.entries.get(workflow.id);
-    if (!entry) throw new Error(`Unknown workflow: ${workflow.id}`);
+  async describeGate(workflow, run, args, configOverride) {
+    const entry = this.requireEntry(workflow.id);
     if (!workflow.gate) throw new Error(`Workflow is not gated: ${workflow.id}`);
-    const parsedParams = Value.Decode(workflow.params, params);
-    const parsedConfig = parseExecutionConfig(entry, configOverride);
-    const description = await entry.implementation.gate?.describe(run, parsedParams, parsedConfig);
-    return validateGateDescription(description ?? workflow.id, workflow.id);
+    const context = this.createExecutionContext({ entry, run, args, configOverride });
+    const description = await entry.workflow.gate?.describe?.(context) ?? workflow.id;
+    if (typeof description !== "string" || description.trim().length === 0) throw new Error(`Workflow gate description must not be empty: ${workflow.id}`);
+    return description.trim();
   }
-  async execute(workflow, run, params, configOverride) {
-    const entry = this.entries.get(workflow.id);
-    if (!entry) throw new Error(`Unknown workflow: ${workflow.id}`);
-    const parsedParams = Value.Decode(workflow.params, params);
-    const parsedConfig = parseExecutionConfig(entry, configOverride);
-    const result = await entry.implementation.execute(run, parsedParams, parsedConfig);
+  async execute(workflow, run, args, configOverride) {
+    const entry = this.requireEntry(workflow.id);
+    const result = await entry.workflow.execute(this.createExecutionContext({ entry, run, args, configOverride }));
     if (isWorkflowNext(result)) return result;
     if (isWorkflowComplete(result)) return { type: "complete", workflow, metadata: result.metadata };
     if (isWorkflowFail(result)) return { type: "fail", workflow, metadata: result.metadata };
     throw new Error(`Workflow returned invalid control result: ${workflow.id}`);
   }
+  createExecutionContext(input) {
+    const { entry, run, configOverride } = input;
+    const scope = entry.scopeId ? this.scopes.get(entry.scopeId) : void 0;
+    return {
+      args: Value.Decode(entry.workflow.args, input.args),
+      config: parseExecutionConfig(entry.configuration, configOverride),
+      ...scope ? { scope: { id: scope.definition.id, config: parseExecutionConfig(scope.configuration, configOverride) } } : {},
+      run
+    };
+  }
+  requireEntry(id) {
+    const entry = this.entries.get(id);
+    if (!entry) throw new Error(`Unknown workflow: ${id}`);
+    return entry;
+  }
   sortedEntries() {
-    return Array.from(this.entries.values()).sort((left, right) => left.workflow.id.localeCompare(right.workflow.id));
+    return [...this.entries.values()].sort((left, right) => left.workflow.id.localeCompare(right.workflow.id));
   }
 };
-function defaultConfigInput(configSchema, config) {
-  if (config !== void 0) return config;
-  return schemaType(unwrapSchema(configSchema)) === "object" ? {} : void 0;
-}
-function parseExecutionConfig(entry, configOverride) {
-  const pluginConfigOverride = pluginConfigOverrideInput(entry, configOverride);
-  if (!entry.configuration) {
-    if (pluginConfigOverride !== void 0) throw new Error(`Run config override provided for plugin without config schema: ${entry.plugin?.id ?? entry.workflow.id}`);
-    return void 0;
-  }
-  if (pluginConfigOverride === void 0) return entry.configuration.value;
-  const rawConfig = isPlainObject(entry.configuration.input) && isPlainObject(pluginConfigOverride) ? deepMerge(entry.configuration.input, pluginConfigOverride) : pluginConfigOverride;
-  return Value.Decode(entry.configuration.schema, rawConfig);
+function configurationInput(config, key) {
+  return Object.hasOwn(config, key) ? config[key] : void 0;
 }
-function pluginConfigOverrideInput(entry, configOverride) {
-  if (configOverride === void 0) return void 0;
-  if (!isPlainObject(configOverride)) throw new Error("Run config override must be an object keyed by plugin id");
-  const pluginId = entry.plugin?.id;
-  return pluginId ? configOverride[pluginId] : void 0;
+function parseExecutionConfig(configuration, overrides) {
+  if (overrides !== void 0 && !isPlainObject(overrides)) throw new Error("Run config override must be an object keyed by workflow or scope id");
+  const override = overrides ? configurationInput(overrides, configuration.key) : void 0;
+  if (override === void 0) return configuration.value;
+  if (!configuration.schema) throw new Error(`Run config override provided without config schema: ${configuration.key}`);
+  const input = isPlainObject(configuration.input) && isPlainObject(override) ? deepMerge(configuration.input, override) : override;
+  return Value.Decode(configuration.schema, input);
 }
 function deepMerge(base, override) {
   const result = { ...base };
-  for (const [key, value] of Object.entries(override)) {
-    const baseValue = result[key];
-    result[key] = isPlainObject(baseValue) && isPlainObject(value) ? deepMerge(baseValue, value) : value;
-  }
+  for (const [key, value] of Object.entries(override)) result[key] = isPlainObject(result[key]) && isPlainObject(value) ? deepMerge(result[key], value) : value;
   return result;
 }
+function assertWorkflowDefinition(workflow) {
+  assertWorkflowMetadata(workflow);
+  if (!isWorkflowDeclaration(workflow)) throw new Error("Invalid workflow definition");
+  assertGateWorkflow(workflow);
+}
 function assertGateWorkflow(workflow) {
   if (!workflow.gate) return;
   if (workflow.gate.enabled !== true) throw new Error(`Workflow gate must be enabled with true: ${workflow.id}`);
+  if (workflow.gate.describe !== void 0 && typeof workflow.gate.describe !== "function") throw new Error(`Invalid gate description callback: ${workflow.id}`);
   if (!workflow.gate.fields) return;
-  const paramsSchema = unwrapSchema(workflow.params);
-  if (schemaType(paramsSchema) !== "object") throw new Error(`Workflow gate fields require object params: ${workflow.id}`);
-  const paramsShape = schemaShape(paramsSchema);
-  for (const field of workflow.gate.fields) {
-    if (!Object.prototype.hasOwnProperty.call(paramsShape, field)) throw new Error(`Unknown workflow gate field ${field}: ${workflow.id}`);
-  }
-}
-function validateGateDescription(description, workflowId) {
-  const trimmed = description.trim();
-  if (trimmed.length === 0) throw new Error(`Workflow gate description must not be empty: ${workflowId}`);
-  return trimmed;
-}
-function inspectedWorkflowInfo(entry) {
-  return {
-    ...workflowInfo(entry),
-    paramsSchema: inspectSchema(entry.workflow.params),
-    gate: gateInfo(entry.workflow)
-  };
+  const argsSchema = unwrapSchema(workflow.args);
+  if (schemaType(argsSchema) !== "object") throw new Error(`Workflow gate fields require object args: ${workflow.id}`);
+  const shape = schemaShape(argsSchema);
+  for (const field of workflow.gate.fields) if (!Object.hasOwn(shape, field)) throw new Error(`Unknown workflow gate field ${field}: ${workflow.id}`);
 }
 function workflowInfo(entry) {
   return {
@@ -122,7 +153,9 @@ function workflowInfo(entry) {
     instructions: entry.workflow.instructions,
     isEntrypoint: entry.workflow.isEntrypoint,
     isolation: entry.workflow.isolation,
-    plugin: entry.plugin
+    source: entry.source,
+    configKey: entry.workflow.id,
+    scope: entry.scopeId ? { id: entry.scopeId } : void 0
   };
 }
 function gateInfo(workflow) {
@@ -130,5 +163,7 @@ function gateInfo(workflow) {
 }
 export {
   NornWorkflowRegistry,
-  decodePluginConfiguration
+  assertCompatibleConfigurationOwners,
+  assertWorkflowDefinition,
+  decodeConfiguration
 };

package/dist/{plugin-loader.d.ts → workflow-loader.d.ts}

@@ -1,19 +1,18 @@
-import { type NornProjectInspection, type NornProjectPluginInfo, type NornWorkflowCatalogInfo, type NornWorkflowInspection, type NornWorkflowPlugin } from "@vimhead.dev/norn";
+import { type NornAnyWorkflowDeclaration, type NornProjectInspection, type NornProjectConfigurationInfo, type NornWorkflowCatalogInfo, type NornWorkflowInspection, type NornWorkflowSource } from "@vimhead.dev/norn";
 import * as typeboxModule from "typebox";
 import { type StaticDecode } from "typebox";
-import { NornMemoryWorkflowState } from "./internal/state-store.ts";
 import { NornWorkflowRegistry, type NornRegisteredWorkflow } from "./internal/workflow-registry.ts";
 export declare const NORN_PROJECT_FILE_NAME = "norn.project.json";
 declare const nornConfigSchema: typeboxModule.TObject<{
-    plugins: typeboxModule.TArray<typeboxModule.TString>;
+    workflows: typeboxModule.TArray<typeboxModule.TString>;
     includes: typeboxModule.TArray<typeboxModule.TString>;
     config: typeboxModule.TRecord<"^.*$", typeboxModule.TUnknown>;
 }>;
 declare const nornProjectConfigSchema: typeboxModule.TObject<{
-    version: typeboxModule.TLiteral<1>;
-    plugins: typeboxModule.TArray<typeboxModule.TString>;
+    workflows: typeboxModule.TArray<typeboxModule.TString>;
     includes: typeboxModule.TArray<typeboxModule.TString>;
     config: typeboxModule.TRecord<"^.*$", typeboxModule.TUnknown>;
+    version: typeboxModule.TLiteral<1>;
 }>;
 type NornConfig = StaticDecode<typeof nornConfigSchema>;
 type NornProjectConfig = StaticDecode<typeof nornProjectConfigSchema>;
@@ -33,11 +32,11 @@ export type NornProject = {
     readonly projectConfig: Record<string, unknown>;
 };
 export type NornLoadedProject = NornProject & {
-    readonly plugins: readonly NornWorkflowPlugin[];
-    readonly pluginInfos: readonly NornProjectPluginInfo[];
+    readonly definitions: readonly NornAnyWorkflowDeclaration[];
+    readonly modules: readonly NornWorkflowSource[];
+    readonly configurations: readonly NornProjectConfigurationInfo[];
     readonly registry: NornWorkflowRegistry;
     readonly workflows: readonly NornRegisteredWorkflow[];
-    readonly state: NornMemoryWorkflowState;
 };
 export declare function loadNornProject(cwd: string): Promise<NornLoadedProject>;
 export declare function discoverNornProject(cwd: string): Promise<NornProjectInspection & NornWorkflowCatalogInfo>;

package/dist/workflow-loader.js

@@ -0,0 +1,235 @@
+// src/workflow-loader.ts
+import * as nornModule from "@vimhead.dev/norn";
+import { isWorkflowDeclaration } from "@vimhead.dev/norn";
+
+// ../core/src/errors.ts
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/workflow-loader.ts
+import * as nornFilesModule from "@vimhead.dev/norn/files";
+import * as nornSchemaModule from "@vimhead.dev/norn/schema";
+import { inspectSchema, isPlainObject } from "@vimhead.dev/norn/schema";
+import { createJiti } from "jiti/static";
+import { access, readdir, readFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, resolve, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+import * as typeboxModule from "typebox";
+import { Type } from "typebox";
+import * as typeboxCompileModule from "typebox/compile";
+import * as typeboxSchemaModule from "typebox/schema";
+import * as typeboxValueModule from "typebox/value";
+import { AssertError, Value } from "typebox/value";
+import { errorMessage, NornProjectLoadError } from "./internal/errors.js";
+import { assertCompatibleConfigurationOwners, assertWorkflowDefinition, NornWorkflowRegistry } from "./internal/workflow-registry.js";
+var NORN_PROJECT_FILE_NAME = "norn.project.json";
+var nornConfigSchema = Type.Object({
+  workflows: Type.Array(Type.String({ minLength: 1 }), { default: [] }),
+  includes: Type.Array(Type.String({ minLength: 1 }), { default: [] }),
+  config: Type.Record(Type.String(), Type.Unknown(), { default: {} })
+});
+var nornProjectConfigSchema = Type.Object({ ...nornConfigSchema.properties, version: Type.Literal(1, { default: 1 }) });
+async function loadNornProject(cwd) {
+  const { project, diagnostics } = await collectNornProject(cwd);
+  if (diagnostics.length) throw new NornProjectLoadError({ diagnostics });
+  return project;
+}
+async function discoverNornProject(cwd) {
+  const { project, diagnostics } = await collectNornProject(cwd);
+  return { project: buildProjectInfo(project), workflows: project.registry.list(), isComplete: diagnostics.length === 0, diagnostics };
+}
+async function inspectNornWorkflow(input) {
+  const { project, diagnostics } = await collectNornProject(input.cwd);
+  const summary = project.registry.list().find((workflow) => workflow.id === input.workflowId);
+  if (!summary) {
+    if (!diagnostics.length) throw new Error(`Unknown workflow: ${input.workflowId}`);
+    return { workflow: null, isComplete: false, diagnostics };
+  }
+  try {
+    return { workflow: project.registry.inspect(input.workflowId) ?? null, isComplete: diagnostics.length === 0, diagnostics };
+  } catch (error) {
+    if (!summary.source) throw error;
+    return { workflow: null, isComplete: false, diagnostics: [...diagnostics, createDiagnostic({ source: summary.source, workflowId: summary.id, scopeId: summary.scope?.id ?? null, stage: "schema", error })] };
+  }
+}
+function buildProjectInfo(project) {
+  return {
+    cwd: project.cwd,
+    projectPath: project.projectPath,
+    projectRoot: project.projectRoot,
+    configPath: project.configPath,
+    configRoot: project.configRoot,
+    configFiles: project.configFiles.map((file) => file.path),
+    modules: project.modules,
+    configurations: project.configurations
+  };
+}
+async function findNornProject(cwd) {
+  const projectPath = await findNearestNornProject(cwd);
+  const projectFile = await readConfigFile({ path: projectPath, isProject: true });
+  const configFiles = await loadConfigTree(projectFile, /* @__PURE__ */ new Set());
+  return {
+    cwd: resolve(cwd),
+    projectPath,
+    projectRoot: projectFile.root,
+    configPath: projectPath,
+    configRoot: projectFile.root,
+    config: projectFile.config,
+    configFiles,
+    projectConfig: mergeProjectConfig(configFiles)
+  };
+}
+async function findNearestNornProject(cwd) {
+  let current = resolve(cwd);
+  while (true) {
+    const path = join(current, NORN_PROJECT_FILE_NAME);
+    try {
+      await access(path);
+      return path;
+    } catch (error) {
+      if (!isNodeError(error) || error.code !== "ENOENT") throw error;
+    }
+    const parent = dirname(current);
+    if (parent === current) throw new Error(`Could not find ${NORN_PROJECT_FILE_NAME} from ${cwd}`);
+    current = parent;
+  }
+}
+async function loadConfigTree(file, visited) {
+  if (visited.has(file.path)) return [];
+  visited.add(file.path);
+  const files = [file];
+  for (const include of file.config.includes) {
+    for (const path of await expandIncludePath(file.root, include)) files.push(...await loadConfigTree(await readConfigFile({ path, isProject: false }), visited));
+  }
+  return files;
+}
+async function readConfigFile(input) {
+  const raw = JSON.parse(await readFile(input.path, "utf8"));
+  if (isPlainObject(raw) && Object.hasOwn(raw, "plugins")) throw new Error(`Replace plugins with workflows in ${input.path}; registration modules must export workflow arrays`);
+  const schema = input.isProject ? nornProjectConfigSchema : nornConfigSchema;
+  const config = Value.Parse(schema, Value.Default(schema, raw));
+  return { path: input.path, root: dirname(input.path), config: { ...config, version: 1 } };
+}
+async function collectNornProject(cwd) {
+  const project = await findNornProject(cwd);
+  const imported = await importWorkflowModules(project);
+  const diagnostics = [...imported.diagnostics];
+  const registry = new NornWorkflowRegistry();
+  const loaded = [];
+  const conflicts = collectModuleConflicts(imported.modules);
+  for (const candidate of imported.modules) {
+    const conflict = conflicts.get(candidate);
+    if (conflict) {
+      diagnostics.push(...conflict);
+      continue;
+    }
+    const unregister = [];
+    const errors = [];
+    for (const workflow of candidate.definitions) {
+      let stage = "schema";
+      try {
+        if (workflow.config) inspectSchema(workflow.config);
+        if (workflow.scope?.config) inspectSchema(workflow.scope.config);
+        stage = "declaration";
+        assertWorkflowDefinition(workflow);
+        stage = "config";
+        unregister.push(registry.register({ workflow, config: project.projectConfig, source: candidate.source }));
+      } catch (error) {
+        errors.push(createDiagnostic({ source: candidate.source, workflowId: workflow.id, scopeId: workflow.scope?.id ?? null, stage, error }));
+      }
+    }
+    if (errors.length) {
+      for (const dispose of unregister) dispose();
+      diagnostics.push(...errors);
+    } else loaded.push(candidate);
+  }
+  const definitions = loaded.flatMap((module) => module.definitions);
+  return { project: { ...project, definitions, modules: loaded.map((module) => module.source), configurations: registry.configurationInfos(), registry, workflows: registry.launchableEntries() }, diagnostics };
+}
+function collectModuleConflicts(modules) {
+  const conflicts = /* @__PURE__ */ new Map();
+  const byId = /* @__PURE__ */ new Map();
+  for (const module of modules) for (const workflow of module.definitions) byId.set(workflow.id, [...byId.get(workflow.id) ?? [], module]);
+  for (const [id, owners] of byId) {
+    if (owners.length < 2) continue;
+    for (const module of new Set(owners)) conflicts.set(module, [...conflicts.get(module) ?? [], createDiagnostic({ source: module.source, workflowId: id, scopeId: null, stage: "duplicate", error: new Error(`Workflow already registered: ${id}`) })]);
+  }
+  for (let index = 0; index < modules.length; index++) {
+    for (let other = index; other < modules.length; other++) {
+      const candidates = [.../* @__PURE__ */ new Set([modules[index], modules[other]])];
+      try {
+        assertCompatibleConfigurationOwners(candidates.flatMap((module) => module.definitions));
+      } catch (error) {
+        for (const module of candidates) conflicts.set(module, [...conflicts.get(module) ?? [], createDiagnostic({ source: module.source, workflowId: null, scopeId: null, stage: "config", error })]);
+      }
+    }
+  }
+  return conflicts;
+}
+async function importWorkflowModules(project) {
+  const modules = [];
+  const diagnostics = [];
+  const jiti = createJiti(pathToFileURL(project.configPath).href, { moduleCache: false, tryNative: false, virtualModules: nornWorkflowVirtualModules() });
+  const cache = /* @__PURE__ */ Object.create(null);
+  for (const file of project.configFiles) for (const path of file.config.workflows) {
+    const source = { configPath: file.path, path: resolveConfigPath(file.root, path) };
+    let stage = "import";
+    try {
+      const cached = cache[source.path];
+      const module = cached?.loaded ? cached.exports : await jiti.evalModule(await readFile(source.path, "utf8"), { filename: source.path, cache, async: true });
+      stage = "declaration";
+      if (!Array.isArray(module?.default) || !Array.from(module.default).every(isWorkflowDeclaration)) throw new Error(`Workflow module must default-export an array of complete workflow definitions: ${source.path}`);
+      modules.push({ definitions: module.default, source });
+    } catch (error) {
+      for (const [path2, module] of Object.entries(cache)) if (!module.loaded) delete cache[path2];
+      diagnostics.push(createDiagnostic({ source, workflowId: null, scopeId: null, stage, error }));
+    }
+  }
+  return { modules, diagnostics };
+}
+function createDiagnostic(input) {
+  return { configPath: input.source.configPath, modulePath: input.source.path, scopeId: input.scopeId, workflowId: input.workflowId, stage: input.stage, message: errorMessage(input.error), issues: input.error instanceof AssertError ? input.error.cause.errors : [] };
+}
+function nornWorkflowVirtualModules() {
+  return { "@vimhead.dev/norn": nornModule, "@vimhead.dev/norn/files": nornFilesModule, "@vimhead.dev/norn/schema": nornSchemaModule, typebox: typeboxModule, "typebox/value": typeboxValueModule, "typebox/compile": typeboxCompileModule, "typebox/schema": typeboxSchemaModule };
+}
+function mergeProjectConfig(files) {
+  const [project, ...reusable] = files;
+  let config = {};
+  for (const file of reusable) config = mergeConfig({ base: config, override: file.config.config, path: ["config"], rejectConflicts: true });
+  return mergeConfig({ base: config, override: project?.config.config ?? {}, path: ["config"], rejectConflicts: false });
+}
+function mergeConfig(input) {
+  const result = { ...input.base };
+  for (const [key, value] of Object.entries(input.override)) {
+    const previous = result[key];
+    const path = [...input.path, key];
+    if (isPlainObject(previous) && isPlainObject(value)) result[key] = mergeConfig({ base: previous, override: value, path, rejectConflicts: input.rejectConflicts });
+    else if (input.rejectConflicts && Object.hasOwn(result, key) && JSON.stringify(previous) !== JSON.stringify(value)) throw new Error(`Conflicting Norn reusable config at ${path.join(".")}`);
+    else result[key] = value;
+  }
+  return result;
+}
+async function expandIncludePath(root, path) {
+  const segments = path.split(/[\\/]+/).filter((segment) => segment.length && segment !== ".");
+  return segments.includes("*") ? expandGlobSegments(isAbsolute(path) ? sep : root, segments) : [resolveConfigPath(root, path)];
+}
+async function expandGlobSegments(root, segments) {
+  if (!segments.length) return [root];
+  const [segment, ...remaining] = segments;
+  if (segment !== "*") return expandGlobSegments(join(root, segment), remaining);
+  const entries = await readdir(root, { withFileTypes: true });
+  return (await Promise.all(entries.filter((entry) => entry.isDirectory()).sort((left, right) => left.name.localeCompare(right.name)).map((entry) => expandGlobSegments(join(root, entry.name), remaining)))).flat();
+}
+function resolveConfigPath(root, path) {
+  if (!path.length) throw new Error("Norn path must not be empty");
+  return isAbsolute(path) ? path : resolve(root, path);
+}
+export {
+  NORN_PROJECT_FILE_NAME,
+  discoverNornProject,
+  findNornProject,
+  inspectNornWorkflow,
+  loadNornProject
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vimhead.dev/norn-cli",
-  "version": "0.1.0-tip.35359392805.1",
+  "version": "0.1.0-tip.35390859630.1",
   "description": "Harness-agnostic runtime for agent-driven and code-driven workflows, built primarily for agents.",
   "type": "module",
   "license": "MIT",
@@ -43,7 +43,7 @@
     "@earendil-works/pi-coding-agent": "0.85.1",
     "jiti": "^2.7.0",
     "typebox": "^1.3.34",
-    "@vimhead.dev/norn": "0.1.0-tip.35359392805.1"
+    "@vimhead.dev/norn": "0.1.0-tip.35390859630.1"
   },
   "scripts": {
     "build": "node ../../scripts/build-package.ts"

package/assets/examples/worktree-development-loop/manifest.ts

@@ -1,26 +0,0 @@
-import { definePluginManifest } from "@vimhead.dev/norn";
-import { developmentLoopState, implementationState, planningState, reviewState } from "./state.ts";
-import { developmentLoopWorkflow } from "./workflows/development-loop/declaration.ts";
-import { developmentLoopConfigSchema } from "./workflows/development-loop/schema.ts";
-import { implementationWorkflow } from "./workflows/implementation/declaration.ts";
-import { planningWorkflow } from "./workflows/planning/declaration.ts";
-import { reviewRouterWorkflow } from "./workflows/review-router/declaration.ts";
-import { reviewWorkflow } from "./workflows/review/declaration.ts";
-
-export const worktreeDevelopmentLoopManifest = definePluginManifest({
-	id: "worktreeDevelopmentLoop",
-	config: developmentLoopConfigSchema,
-	workflows: {
-		planning: planningWorkflow,
-		implementation: implementationWorkflow,
-		review: reviewWorkflow,
-		reviewRouter: reviewRouterWorkflow,
-		developmentLoop: developmentLoopWorkflow,
-	},
-	states: {
-		developmentLoop: developmentLoopState,
-		planning: planningState,
-		implementation: implementationState,
-		review: reviewState,
-	},
-});

package/assets/examples/worktree-development-loop/state.ts

@@ -1,23 +0,0 @@
-import { artifactRefSchema, type NornWorkflowPluginStateTree } from "@vimhead.dev/norn";
-import { Type } from "typebox";
-import { reviewDecisionSchema } from "./workflows/review/schema.ts";
-
-export const developmentLoopState = {
-	task: Type.String(),
-	maxIterations: Type.Integer({ minimum: 1, maximum: 10 }),
-	currentIteration: Type.Integer({ minimum: 1 }),
-	repositoryPath: Type.String(),
-} as const satisfies NornWorkflowPluginStateTree;
-
-export const planningState = {
-	planArtifact: artifactRefSchema,
-} as const satisfies NornWorkflowPluginStateTree;
-
-export const implementationState = {
-	implementationSummary: Type.String(),
-} as const satisfies NornWorkflowPluginStateTree;
-
-export const reviewState = {
-	reviewDecision: reviewDecisionSchema,
-	reviewArtifact: artifactRefSchema,
-} as const satisfies NornWorkflowPluginStateTree;

package/assets/examples/worktree-development-loop/workflows/development-loop/declaration.ts

@@ -1,8 +0,0 @@
-import type { NornWorkflowDefinition } from "@vimhead.dev/norn";
-import { developmentLoopParamsSchema } from "./schema.ts";
-
-export const developmentLoopWorkflow = {
-	isEntrypoint: true,
-	instructions: "Plan once, then loop implementation and review in a workspace repository copy. Call this when a repository task should run through planning, implementation, and review.",
-	params: developmentLoopParamsSchema,
-} as const satisfies NornWorkflowDefinition;

package/assets/examples/worktree-development-loop/workflows/implementation/declaration.ts

@@ -1,8 +0,0 @@
-import type { NornWorkflowDefinition } from "@vimhead.dev/norn";
-import { implementationParamsSchema } from "./schema.ts";
-
-export const implementationWorkflow = {
-	isEntrypoint: false,
-	instructions: "Apply one implementation pass in the current repository.",
-	params: implementationParamsSchema,
-} as const satisfies NornWorkflowDefinition;

package/assets/examples/worktree-development-loop/workflows/planning/declaration.ts

@@ -1,8 +0,0 @@
-import type { NornWorkflowDefinition } from "@vimhead.dev/norn";
-import { planningParamsSchema } from "./schema.ts";
-
-export const planningWorkflow = {
-	isEntrypoint: false,
-	instructions: "Create an implementation plan for a repository task.",
-	params: planningParamsSchema,
-} as const satisfies NornWorkflowDefinition;

package/assets/examples/worktree-development-loop/workflows/review/declaration.ts

@@ -1,8 +0,0 @@
-import type { NornWorkflowDefinition } from "@vimhead.dev/norn";
-import { reviewParamsSchema } from "./schema.ts";
-
-export const reviewWorkflow = {
-	isEntrypoint: false,
-	instructions: "Review the current repository boundary changes.",
-	params: reviewParamsSchema,
-} as const satisfies NornWorkflowDefinition;

package/assets/examples/worktree-development-loop/workflows/review-router/declaration.ts

@@ -1,12 +0,0 @@
-import type { NornWorkflowDefinition } from "@vimhead.dev/norn";
-import { reviewRouterParamsSchema } from "./schema.ts";
-
-export const reviewRouterWorkflow = {
-	isEntrypoint: false,
-	instructions: "Route implementation and review iterations based on the latest review decision.",
-	gate: {
-		enabled: true,
-		fields: ["decision", "summary"] as const,
-	},
-	params: reviewRouterParamsSchema,
-} as const satisfies NornWorkflowDefinition;