@vimhead.dev/norn-cli 0.1.0-tip.0

package/dist/internal/run.d.ts

@@ -0,0 +1,51 @@
+import type { CreateAgentSessionOptions } from "@earendil-works/pi-coding-agent";
+import type { NornAnyWorkflowDeclaration, NornProjectRun, NornRunOutcomeMetadata, NornWorkflowIsolationMode, NornWorkflowTarget, NornWorkflowTargetParamsInput, NornRun } from "@vimhead.dev/norn";
+import type { NornAgentResponseCollector } from "./agent-response-tool.ts";
+import type { NornArtifacts } from "./artifacts.ts";
+import type { NornRunLogs } from "./logs.ts";
+import type { NornRunLogger } from "./run-log.ts";
+import type { NornRunResources } from "../resources.ts";
+type DefaultNornRunInput = {
+    readonly id: string;
+    readonly runRoot: string;
+    readonly projectRoot: string;
+    readonly workspace: string;
+    readonly cwd: string;
+    readonly isolationMode: NornWorkflowIsolationMode;
+    readonly signal?: AbortSignal;
+    readonly model?: CreateAgentSessionOptions["model"];
+    readonly thinkingLevel?: CreateAgentSessionOptions["thinkingLevel"];
+    readonly agentDir?: string;
+    readonly responseCollector: NornAgentResponseCollector;
+    readonly resources: NornRunResources;
+    readonly state: NornRun["state"];
+    readonly logger: NornRunLogger;
+    readonly artifacts: NornArtifacts;
+    readonly logs: NornRunLogs;
+};
+export declare class NornRunContext implements NornProjectRun {
+    private readonly input;
+    readonly resources: NornRunResources;
+    readonly state: NornRun["state"];
+    readonly artifacts: NornRun["artifacts"];
+    readonly logs: NornRun["logs"];
+    readonly commands: NornRun["commands"];
+    readonly agents: NornRun["agents"];
+    readonly id: string;
+    readonly workspace: string;
+    readonly projectRoot: string;
+    readonly cwd: string;
+    constructor(input: DefaultNornRunInput);
+    forWorkflow(workflow: NornAnyWorkflowDeclaration): NornRunContext;
+    private get boundaryRoot();
+    private createAgentRunner;
+    path(relativePath: string): string;
+    projectPath(relativePath: string): string;
+    next<TWorkflow extends NornWorkflowTarget<any>>(workflow: TWorkflow, params: NornWorkflowTargetParamsInput<TWorkflow>): ReturnType<NornRun["next"]>;
+    complete(metadata?: NornRunOutcomeMetadata): ReturnType<NornRun["complete"]>;
+    fail(metadata: NornRunOutcomeMetadata & {
+        readonly summary: string;
+    }): ReturnType<NornRun["fail"]>;
+    private resolveFromRoot;
+}
+export {};

package/dist/internal/run.js

@@ -0,0 +1,101 @@
+// src/internal/run.ts
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { NornAgentRunner } from "./agents.js";
+import { NornCommandRunner } from "./commands.js";
+var NornRunContext = class _NornRunContext {
+  constructor(input) {
+    this.input = input;
+    this.id = input.id;
+    this.workspace = input.workspace;
+    this.projectRoot = input.projectRoot;
+    this.cwd = input.cwd;
+    this.resources = input.resources;
+    this.state = input.state;
+    this.artifacts = input.artifacts;
+    this.logs = {
+      read: (log) => this.input.logs.read(log)
+    };
+    this.commands = {
+      run: (commandInput) => new NornCommandRunner({
+        boundaryRoot: this.boundaryRoot,
+        boundaryName: this.input.isolationMode,
+        cwd: this.cwd,
+        signal: this.input.signal,
+        logs: this.input.logs,
+        logger: this.input.logger
+      }).run(commandInput)
+    };
+    this.agents = {
+      createSession: (agentInput) => this.createAgentRunner().createSession(agentInput),
+      prompt: (agentInput) => this.createAgentRunner().prompt(agentInput)
+    };
+  }
+  input;
+  resources;
+  state;
+  artifacts;
+  logs;
+  commands;
+  agents;
+  id;
+  workspace;
+  projectRoot;
+  cwd;
+  forWorkflow(workflow) {
+    const isolationMode = workflow.isolation.mode;
+    return new _NornRunContext({
+      ...this.input,
+      isolationMode,
+      cwd: isolationMode === "project" ? this.projectRoot : this.workspace
+    });
+  }
+  get boundaryRoot() {
+    return this.input.isolationMode === "project" ? this.projectRoot : this.workspace;
+  }
+  createAgentRunner() {
+    return new NornAgentRunner({
+      id: this.id,
+      runRoot: this.input.runRoot,
+      boundaryRoot: this.boundaryRoot,
+      boundaryName: this.input.isolationMode,
+      cwd: this.cwd,
+      signal: this.input.signal,
+      model: this.input.model,
+      thinkingLevel: this.input.thinkingLevel,
+      agentDir: this.input.agentDir,
+      logs: this.input.logs,
+      logger: this.input.logger,
+      responseCollector: this.input.responseCollector
+    });
+  }
+  path(relativePath) {
+    return this.resolveFromRoot(this.cwd, this.boundaryRoot, relativePath);
+  }
+  projectPath(relativePath) {
+    return this.resolveFromRoot(this.projectRoot, this.projectRoot, relativePath);
+  }
+  next(workflow, params) {
+    return {
+      type: "next",
+      workflowId: typeof workflow === "string" ? workflow : workflow.id,
+      params
+    };
+  }
+  complete(metadata) {
+    return { type: "complete", metadata };
+  }
+  fail(metadata) {
+    return { type: "fail", metadata };
+  }
+  resolveFromRoot(root, boundaryRoot, path) {
+    const resolvedPath = isAbsolute(path) ? path : resolve(root, path);
+    const pathFromBoundary = relative(boundaryRoot, resolvedPath);
+    if (pathFromBoundary === ".." || pathFromBoundary.startsWith(`..${sep}`) || isAbsolute(pathFromBoundary)) {
+      throw new Error(`Workflow path escapes ${this.input.isolationMode} isolation: ${path}`);
+    }
+    return resolvedPath;
+  }
+};
+export {
+  NornRunContext
+};

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

@@ -0,0 +1,22 @@
+import type { NornWorkflowStateDefinition, NornWorkflowState } from "@vimhead.dev/norn";
+import type { NornFileCoordinator } from "@vimhead.dev/norn/files";
+export declare class NornMemoryWorkflowState implements NornWorkflowState {
+    private readonly data;
+    get<T>(state: NornWorkflowStateDefinition<T>): Promise<T>;
+    getOptional<T>(state: NornWorkflowStateDefinition<T>): Promise<T | undefined>;
+    set<T>(state: NornWorkflowStateDefinition<T>, value: T): Promise<void>;
+}
+export declare class NornJsonWorkflowState implements NornWorkflowState {
+    private readonly input;
+    readonly stateFile: string;
+    constructor(input: {
+        readonly stateFile: string;
+        readonly files: NornFileCoordinator;
+        readonly coordinateMutation: <T>(path: string, operation: () => Promise<T>) => Promise<T>;
+    });
+    initialize(mode: "create" | "open"): Promise<void>;
+    get<T>(state: NornWorkflowStateDefinition<T>): Promise<T>;
+    getOptional<T>(state: NornWorkflowStateDefinition<T>): Promise<T | undefined>;
+    set<T>(state: NornWorkflowStateDefinition<T>, value: T): Promise<void>;
+    private readStateFile;
+}

package/dist/internal/state-store.js

@@ -0,0 +1,97 @@
+// src/internal/state-store.ts
+import { readFile } from "node:fs/promises";
+
+// ../core/src/errors.ts
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// ../core/src/atomic-files.ts
+import { randomUUID } from "node:crypto";
+import { chmod, mkdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+async function writeJsonAtomically(path, value) {
+  await writeTextAtomically(path, `${JSON.stringify(value, null, 2)}
+`);
+}
+async function writeTextAtomically(path, content) {
+  await mkdir(dirname(path), { recursive: true });
+  let existingMode;
+  try {
+    existingMode = (await stat(path)).mode & 511;
+  } catch (error) {
+    if (!isNodeError(error) || error.code !== "ENOENT") throw error;
+  }
+  const tmpPath = `${path}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(tmpPath, content, { encoding: "utf8", mode: existingMode });
+    if (existingMode !== void 0) await chmod(tmpPath, existingMode);
+    await rename(tmpPath, path);
+  } catch (error) {
+    await rm(tmpPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+
+// src/internal/state-store.ts
+var NornMemoryWorkflowState = class {
+  data = /* @__PURE__ */ new Map();
+  async get(state) {
+    const value = await this.getOptional(state);
+    if (value === void 0) throw new Error(`Missing workflow state: ${state.id}`);
+    return value;
+  }
+  async getOptional(state) {
+    if (!this.data.has(state.id)) return void 0;
+    return state.schema.parse(this.data.get(state.id));
+  }
+  async set(state, value) {
+    this.data.set(state.id, state.schema.parse(value));
+  }
+};
+var NornJsonWorkflowState = class {
+  constructor(input) {
+    this.input = input;
+    this.stateFile = input.stateFile;
+  }
+  input;
+  stateFile;
+  async initialize(mode) {
+    await this.input.files.withExclusiveLock(this.stateFile, async (path) => {
+      try {
+        await this.readStateFile(path);
+      } catch (error) {
+        if (mode !== "create" || !isNodeError(error) || error.code !== "ENOENT") throw error;
+        await writeJsonAtomically(path, {});
+      }
+    });
+  }
+  async get(state) {
+    const value = await this.getOptional(state);
+    if (value === void 0) throw new Error(`Missing workflow state: ${state.id}`);
+    return value;
+  }
+  async getOptional(state) {
+    const data = await this.input.files.withExclusiveLock(this.stateFile, (path) => this.readStateFile(path));
+    if (!Object.prototype.hasOwnProperty.call(data, state.id)) return void 0;
+    return state.schema.parse(data[state.id]);
+  }
+  async set(state, value) {
+    const parsedValue = state.schema.parse(value);
+    await this.input.coordinateMutation(this.stateFile, () => this.input.files.withExclusiveLock(this.stateFile, async (path) => {
+      const data = await this.readStateFile(path);
+      Object.defineProperty(data, state.id, { value: parsedValue, enumerable: true, configurable: true, writable: true });
+      await writeJsonAtomically(path, data);
+    }));
+  }
+  async readStateFile(path) {
+    const content = await readFile(path, "utf8");
+    const parsed = JSON.parse(content);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+    throw new Error(`Invalid workflow state document: ${path}`);
+  }
+};
+export {
+  NornJsonWorkflowState,
+  NornMemoryWorkflowState
+};

package/dist/internal/usage.d.ts

@@ -0,0 +1,5 @@
+import type { NornAgentUsage } from "@vimhead.dev/norn";
+export declare function agentUsageFromValue(value: unknown): NornAgentUsage | undefined;
+export declare function totalAgentUsage(usages: readonly NornAgentUsage[]): NornAgentUsage;
+export declare function addAgentUsage(left: NornAgentUsage, right: NornAgentUsage): NornAgentUsage;
+export declare function emptyAgentUsage(): NornAgentUsage;

package/dist/internal/usage.js

@@ -0,0 +1,70 @@
+// src/internal/usage.ts
+function agentUsageFromValue(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const usage = value;
+  const input = numberField(usage.input);
+  const output = numberField(usage.output);
+  const cacheRead = numberField(usage.cacheRead);
+  const cacheWrite = numberField(usage.cacheWrite);
+  const reasoning = optionalNumberField(usage.reasoning);
+  const totalTokens = numberField(usage.totalTokens) || input + output + cacheRead + cacheWrite;
+  const costValue = usage.cost && typeof usage.cost === "object" ? usage.cost : {};
+  return {
+    input,
+    output,
+    cacheRead,
+    cacheWrite,
+    ...reasoning === void 0 ? {} : { reasoning },
+    totalTokens,
+    cost: {
+      input: numberField(costValue.input),
+      output: numberField(costValue.output),
+      cacheRead: numberField(costValue.cacheRead),
+      cacheWrite: numberField(costValue.cacheWrite),
+      total: numberField(costValue.total)
+    }
+  };
+}
+function totalAgentUsage(usages) {
+  return usages.reduce(addAgentUsage, emptyAgentUsage());
+}
+function addAgentUsage(left, right) {
+  const reasoning = left.reasoning === void 0 && right.reasoning === void 0 ? void 0 : (left.reasoning ?? 0) + (right.reasoning ?? 0);
+  return {
+    input: left.input + right.input,
+    output: left.output + right.output,
+    cacheRead: left.cacheRead + right.cacheRead,
+    cacheWrite: left.cacheWrite + right.cacheWrite,
+    ...reasoning === void 0 ? {} : { reasoning },
+    totalTokens: left.totalTokens + right.totalTokens,
+    cost: {
+      input: left.cost.input + right.cost.input,
+      output: left.cost.output + right.cost.output,
+      cacheRead: left.cost.cacheRead + right.cost.cacheRead,
+      cacheWrite: left.cost.cacheWrite + right.cost.cacheWrite,
+      total: left.cost.total + right.cost.total
+    }
+  };
+}
+function emptyAgentUsage() {
+  return {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 0,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+  };
+}
+function numberField(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function optionalNumberField(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+export {
+  addAgentUsage,
+  agentUsageFromValue,
+  emptyAgentUsage,
+  totalAgentUsage
+};

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

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { type NornAnyWorkflowDeclaration, type NornInspectedWorkflowInfo, type NornRegisteredWorkflowInfo, type NornRunComplete, type NornDispose, type NornRunFail, type NornWorkflowImplementation, type NornRunNext, type NornRunFor, type NornWorkflowPluginInfo } from "@vimhead.dev/norn";
+export type NornRegisteredWorkflow = {
+    workflow: NornAnyWorkflowDeclaration;
+    implementation: NornWorkflowImplementation<NornAnyWorkflowDeclaration, unknown>;
+    configSchema?: z.ZodType;
+    config: unknown;
+    plugin?: NornWorkflowPluginInfo;
+};
+export type NornWorkflowStepResult = NornRunNext | {
+    readonly type: "complete";
+    readonly workflow: NornAnyWorkflowDeclaration;
+    readonly metadata?: NornRunComplete["metadata"];
+} | {
+    readonly type: "fail";
+    readonly workflow: NornAnyWorkflowDeclaration;
+    readonly metadata: NornRunFail["metadata"];
+};
+export declare class NornWorkflowRegistry {
+    private readonly entries;
+    register<TWorkflow extends NornAnyWorkflowDeclaration>(workflow: TWorkflow, implementation: NornWorkflowImplementation<TWorkflow, unknown>, metadata?: {
+        readonly plugin?: NornWorkflowPluginInfo;
+        readonly configSchema?: z.ZodType;
+        readonly config?: unknown;
+    }): NornDispose;
+    list(options?: {
+        readonly entrypointsOnly?: boolean;
+    }): NornRegisteredWorkflowInfo[];
+    inspect(workflowId: string): NornInspectedWorkflowInfo | undefined;
+    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>;
+    private sortedEntries;
+}

package/dist/internal/workflow-registry.js

@@ -0,0 +1,129 @@
+// src/internal/workflow-registry.ts
+import { z } from "zod";
+import { isWorkflowComplete, isWorkflowFail, isWorkflowNext } from "@vimhead.dev/norn";
+import { assertWorkflowMetadata, isPlainObject, schemaShape, schemaType, unwrapSchema } from "@vimhead.dev/norn/schema";
+var NornWorkflowRegistry = class {
+  entries = /* @__PURE__ */ new Map();
+  register(workflow, implementation, metadata = {}) {
+    if (this.entries.has(workflow.id)) throw new Error(`Workflow already registered: ${workflow.id}`);
+    const entry = {
+      workflow,
+      implementation,
+      configSchema: metadata.configSchema,
+      config: metadata.configSchema ? metadata.configSchema.parse(defaultConfigInput(metadata.configSchema, metadata.config)) : void 0,
+      plugin: metadata.plugin
+    };
+    assertWorkflowMetadata(workflow);
+    assertGateWorkflow(workflow);
+    this.entries.set(workflow.id, entry);
+    return () => {
+      if (this.entries.get(workflow.id) === entry) this.entries.delete(workflow.id);
+    };
+  }
+  list(options = {}) {
+    const entries = options.entrypointsOnly ? this.launchableEntries() : this.sortedEntries();
+    return entries.map((entry) => workflowInfo(entry));
+  }
+  inspect(workflowId) {
+    const entry = this.entries.get(workflowId);
+    return entry ? inspectedWorkflowInfo(entry) : void 0;
+  }
+  launchableEntries() {
+    return this.sortedEntries().filter(({ workflow }) => workflow.isEntrypoint);
+  }
+  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}`);
+    if (!workflow.gate) throw new Error(`Workflow is not gated: ${workflow.id}`);
+    const parsedParams = workflow.params.parse(params);
+    const parsedConfig = parseExecutionConfig(entry, configOverride);
+    const description = await entry.implementation.gate?.describe(run, parsedParams, parsedConfig);
+    return validateGateDescription(description ?? workflow.id, workflow.id);
+  }
+  async execute(workflow, run, params, configOverride) {
+    const entry = this.entries.get(workflow.id);
+    if (!entry) throw new Error(`Unknown workflow: ${workflow.id}`);
+    const parsedParams = workflow.params.parse(params);
+    const parsedConfig = parseExecutionConfig(entry, configOverride);
+    const result = await entry.implementation.execute(run, parsedParams, parsedConfig);
+    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}`);
+  }
+  sortedEntries() {
+    return Array.from(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.configSchema) {
+    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.config;
+  const rawConfig = isPlainObject(entry.config) && isPlainObject(pluginConfigOverride) ? deepMerge(entry.config, pluginConfigOverride) : pluginConfigOverride;
+  return entry.configSchema.parse(rawConfig);
+}
+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 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;
+  }
+  return result;
+}
+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.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: jsonSchema(entry.workflow.params),
+    gate: gateInfo(entry.workflow)
+  };
+}
+function workflowInfo(entry) {
+  return {
+    id: entry.workflow.id,
+    instructions: entry.workflow.instructions,
+    isEntrypoint: entry.workflow.isEntrypoint,
+    isolation: entry.workflow.isolation,
+    plugin: entry.plugin
+  };
+}
+function gateInfo(workflow) {
+  return workflow.gate ? { enabled: true, fields: workflow.gate.fields } : null;
+}
+function jsonSchema(schema) {
+  return z.toJSONSchema(schema, { io: "input" });
+}
+export {
+  NornWorkflowRegistry
+};

package/dist/plugin-loader.d.ts

@@ -0,0 +1,55 @@
+import { z } from "zod";
+import { type NornProjectInspection, type NornProjectPluginInfo, type NornWorkflowCatalogInfo, type NornWorkflowInspection, type NornWorkflowPlugin } from "@vimhead.dev/norn";
+import { NornMemoryWorkflowState } from "./internal/state-store.ts";
+import { NornWorkflowRegistry, type NornRegisteredWorkflow } from "./internal/workflow-registry.ts";
+import { type NornResolvedSeerModeConfig } from "@vimhead.dev/norn/seer";
+export declare const NORN_PROJECT_FILE_NAME = "norn.project.json";
+declare const nornConfigSchema: z.ZodObject<{
+    plugins: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    includes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const nornProjectConfigSchema: z.ZodObject<{
+    plugins: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    includes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    version: z.ZodDefault<z.ZodLiteral<1>>;
+    seerMode: z.ZodOptional<z.ZodObject<{
+        writableRoots: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type NornConfig = z.output<typeof nornConfigSchema> & {
+    readonly seerMode?: never;
+};
+type NornProjectConfig = z.output<typeof nornProjectConfigSchema>;
+type NornConfigFile = {
+    readonly path: string;
+    readonly root: string;
+    readonly config: NornConfig;
+};
+export type NornProject = {
+    readonly cwd: string;
+    readonly projectPath: string;
+    readonly projectRoot: string;
+    readonly configPath: string;
+    readonly configRoot: string;
+    readonly config: NornProjectConfig;
+    readonly configFiles: readonly NornConfigFile[];
+    readonly projectConfig: Record<string, unknown>;
+    readonly seerMode?: NornResolvedSeerModeConfig;
+};
+export type NornLoadedProject = NornProject & {
+    readonly plugins: readonly NornWorkflowPlugin[];
+    readonly pluginInfos: readonly NornProjectPluginInfo[];
+    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>;
+export declare function inspectNornWorkflow(input: {
+    readonly cwd: string;
+    readonly workflowId: string;
+}): Promise<NornWorkflowInspection>;
+export declare function findNornProject(cwd: string): Promise<NornProject>;
+export {};