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

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

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

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,88 +81,83 @@ 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(input) {
+    const { workflow } = input;
+    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({ ...input, entry });
+    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(input) {
+    const { workflow } = input;
+    const entry = this.requireEntry(workflow.id);
+    const result = await entry.workflow.execute(this.createExecutionContext({ ...input, entry }));
     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, paths, 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) } } : {},
+      paths,
+      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 {
     id: entry.workflow.id,
     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 +165,7 @@ function gateInfo(workflow) {
 }
 export {
   NornWorkflowRegistry,
-  decodePluginConfiguration
+  assertCompatibleConfigurationOwners,
+  assertWorkflowDefinition,
+  decodeConfiguration
 };

package/dist/internal/working-directory.d.ts

@@ -0,0 +1 @@
+export declare function requireAbsoluteWorkingDirectory(cwd: string): string;

package/dist/internal/working-directory.js

@@ -0,0 +1,9 @@
+// src/internal/working-directory.ts
+import { isAbsolute, resolve } from "node:path";
+function requireAbsoluteWorkingDirectory(cwd) {
+  if (typeof cwd !== "string" || !isAbsolute(cwd)) throw new Error("Working directory (cwd) must be an absolute path");
+  return resolve(cwd);
+}
+export {
+  requireAbsoluteWorkingDirectory
+};

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,234 @@
+// 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 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/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.35436871363.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.35436871363.1"
   },
   "scripts": {
     "build": "node ../../scripts/build-package.ts"