@workflow-cannon/workspace-kit 0.1.0 → 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Workflow Cannon contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,115 @@
+AI agents: `./.ai/` is the authoritative source of truth; read all files there before any analysis, planning, or code changes, and follow `./.ai/` over `README.md`, `./docs/`, and conflicting existing code patterns.
+
+# Workflow Cannon
+
+Workflow Cannon is the canonical home of `@workflow-cannon/workspace-kit` and the operational docs that drive its evolution.
+
+It is built for developers using VS Code who want safe, reproducible, package-first workflow automation with clear release evidence.
+
+## Table of Contents
+
+- [What This Repository Is](#what-this-repository-is)
+- [Big-Picture Vision](#big-picture-vision)
+- [Current Status](#current-status)
+- [Goals](#goals)
+- [Package](#package)
+- [Repository Map](#repository-map)
+- [Documentation Index](#documentation-index)
+- [License](#license)
+
+## What This Repository Is
+
+Workflow Cannon is the source of truth for:
+
+- The `@workflow-cannon/workspace-kit` package
+- Maintainer planning and execution artifacts
+- Consumer validation and release-readiness evidence
+
+Guiding characteristics:
+
+- Package-first delivery and verification
+- Deterministic, auditable workflows
+- Safe-by-default operations (validation, traceability, rollback-friendly changes)
+
+## Big-Picture Vision
+
+Workflow Cannon is evolving from a package and docs repository into a developer workflow platform that can:
+
+- model planning, tasks, policy, and execution as first-class, versioned contracts
+- run repeatable workflows with deterministic outcomes and evidence capture
+- continuously improve itself based on observed friction and outcome data
+
+The long-term direction in this repository is to close the loop between:
+
+1. **What happened** (transcripts, diffs, run artifacts, diagnostics)
+2. **What should change** (recommendations to templates, rules, process, and config)
+3. **What gets adopted** (human-reviewed approvals, policy checks, safe rollout)
+
+### Enhancement Engine (automatic learning and correction)
+
+The Improvement/Enhancement Engine is intended to detect weak spots in workflows and rules, then generate high-signal fixes with supporting evidence. Instead of hard-coding static process forever, the system should learn from real usage patterns and propose better defaults.
+
+In practice, this means:
+
+- detect recurring failure patterns, manual rework, and template drift
+- emit recommendation items with confidence, deduping, and provenance
+- route recommendations through an approval queue (`accept`, `decline`, `accept edited`)
+- apply approved changes through guarded automation (dry-run, diff, rollback-ready)
+- measure post-change outcomes so future recommendations improve over time
+
+This keeps automation adaptive without sacrificing safety, governance, or developer trust.
+
+## Current Status
+
+- Project tracking has been reset for split-repo execution.
+- Current execution phase is **Phase 0 (foundation)**.
+- Phase 0 opens with `T178` to `T180` for release hardening and consumer cadence definition.
+
+## Goals
+
+- Keep package implementation and release operations centralized here.
+- Preserve independent consumer validation and update cadence.
+- Grow modular capabilities for planning, tasking, configuration, policy, and improvement.
+- Build a human-governed enhancement loop that learns from usage and recommends better workflows/rules.
+- Maintain deterministic and auditable behavior as system complexity increases.
+
+## Package
+
+Install:
+
+```bash
+npm install @workflow-cannon/workspace-kit
+```
+
+## Repository Map
+
+- `README.md` - project entry point
+- `.ai/PRINCIPLES.md` - project goals and decision principles (canonical AI)
+- `docs/maintainers/ROADMAP.md` - roadmap and decision log
+- `docs/maintainers/TASKS.md` - execution tracking
+- `docs/maintainers/ARCHITECTURE.md` - architecture direction
+- `docs/maintainers/DECISIONS.md` - focused design/decision notes
+- `docs/maintainers/RELEASING.md` - release checklist and validation expectations
+- `.ai/module-build.md` - canonical AI module build guidance
+- `docs/maintainers/` - maintainer process and boundary docs
+- `docs/maintainers/module-build-guide.md` - human-readable module build guidance
+- `docs/adr/` - ADR templates and records
+
+## Documentation Index
+
+- Project goals and decision principles: `.ai/PRINCIPLES.md`
+- Strategy and long-range direction: `docs/maintainers/ROADMAP.md`
+- Active execution tasks: `docs/maintainers/TASKS.md`
+- Glossary and agent-guidance terms: `docs/maintainers/TERMS.md`
+- Architecture direction: `docs/maintainers/ARCHITECTURE.md`
+- Project decisions: `docs/maintainers/DECISIONS.md`
+- Contribution guidelines: `docs/maintainers/CONTRIBUTING.md`
+- Release process and gates: `docs/maintainers/RELEASING.md`
+- Canonical AI module build guidance: `.ai/module-build.md`
+- Human module build guide: `docs/maintainers/module-build-guide.md`
+- Security, support, and governance: `docs/maintainers/SECURITY.md`, `docs/maintainers/SUPPORT.md`, `docs/maintainers/GOVERNANCE.md`
+- AI behavior rules and command wrappers: `.cursor/rules/`, `.cursor/commands/`
+
+## License
+
+Licensed under MIT. See `LICENSE`.

package/dist/adapters/index.d.ts

@@ -0,0 +1 @@
+export type AdapterVersion = "0.1";

package/dist/adapters/index.js

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -2,6 +2,13 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
+import { ModuleRegistry } from "./core/module-registry.js";
+import { ModuleCommandRouter } from "./core/module-command-router.js";
+import { documentationModule } from "./modules/documentation/index.js";
+import { taskEngineModule } from "./modules/task-engine/index.js";
+import { approvalsModule } from "./modules/approvals/index.js";
+import { planningModule } from "./modules/planning/index.js";
+import { improvementModule } from "./modules/improvement/index.js";
 const EXIT_SUCCESS = 0;
 const EXIT_VALIDATION_FAILURE = 1;
 const EXIT_USAGE_ERROR = 2;
@@ -305,7 +312,7 @@ export async function runCli(args, options = {}) {
     const writeError = options.writeError ?? console.error;
     const [command] = args;
     if (!command) {
-        writeError("Usage: workspace-kit <init|doctor|check|upgrade>");
+        writeError("Usage: workspace-kit <init|doctor|check|upgrade|drift-check|run>");
         return EXIT_USAGE_ERROR;
     }
     if (command === "init") {
@@ -525,8 +532,59 @@ export async function runCli(args, options = {}) {
         }
         return EXIT_SUCCESS;
     }
+    if (command === "run") {
+        const allModules = [
+            documentationModule,
+            taskEngineModule,
+            approvalsModule,
+            planningModule,
+            improvementModule
+        ];
+        const registry = new ModuleRegistry(allModules);
+        const router = new ModuleCommandRouter(registry);
+        const subcommand = args[1];
+        if (!subcommand) {
+            const commands = router.listCommands();
+            writeLine("Available module commands:");
+            for (const cmd of commands) {
+                const desc = cmd.description ? ` — ${cmd.description}` : "";
+                writeLine(`  ${cmd.name} (${cmd.moduleId})${desc}`);
+            }
+            writeLine("");
+            writeLine("Usage: workspace-kit run <command> [json-args]");
+            return EXIT_SUCCESS;
+        }
+        let commandArgs = {};
+        if (args[2]) {
+            try {
+                const parsed = JSON.parse(args[2]);
+                if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                    commandArgs = parsed;
+                }
+                else {
+                    writeError("Command args must be a JSON object.");
+                    return EXIT_USAGE_ERROR;
+                }
+            }
+            catch {
+                writeError(`Invalid JSON args: ${args[2]}`);
+                return EXIT_USAGE_ERROR;
+            }
+        }
+        const ctx = { runtimeVersion: "0.1", workspacePath: cwd };
+        try {
+            const result = await router.execute(subcommand, commandArgs, ctx);
+            writeLine(JSON.stringify(result, null, 2));
+            return result.ok ? EXIT_SUCCESS : EXIT_VALIDATION_FAILURE;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            writeError(`Module command failed: ${message}`);
+            return EXIT_INTERNAL_ERROR;
+        }
+    }
     if (command !== "doctor") {
-        writeError(`Unknown command '${command}'. Supported commands: init, doctor, check, upgrade, drift-check.`);
+        writeError(`Unknown command '${command}'. Supported commands: init, doctor, check, upgrade, drift-check, run.`);
         return EXIT_USAGE_ERROR;
     }
     const issues = [];

package/dist/contracts/index.d.ts

@@ -0,0 +1 @@
+export type { ModuleCommand, ModuleCommandResult, ModuleCapability, ModuleDocumentContract, ModuleEvent, ModuleInstructionContract, ModuleInstructionEntry, ModuleLifecycleContext, ModuleRegistration, WorkflowModule } from "./module-contract.js";

package/dist/contracts/index.js

@@ -0,0 +1 @@
+export {};

package/dist/contracts/module-contract.d.ts

@@ -0,0 +1,62 @@
+export type ModuleCapability = "documentation" | "task-engine" | "planning" | "improvement" | "approvals" | "diagnostics" | "migration";
+export type ModuleDocumentContract = {
+    path: string;
+    format: "md";
+    description?: string;
+};
+export type ModuleInstructionEntry = {
+    /**
+     * Function-like instruction name, e.g. "document-project".
+     */
+    name: string;
+    /**
+     * Markdown instruction file path under the module instruction directory.
+     */
+    file: string;
+    description?: string;
+};
+export type ModuleInstructionContract = {
+    /**
+     * Directory containing markdown instruction files for this module.
+     */
+    directory: string;
+    entries: ModuleInstructionEntry[];
+};
+export type ModuleEvent = {
+    type: string;
+    payload?: Record<string, unknown>;
+};
+export type ModuleCommand = {
+    name: string;
+    args?: Record<string, unknown>;
+};
+export type ModuleCommandResult = {
+    ok: boolean;
+    code: string;
+    message?: string;
+    data?: Record<string, unknown>;
+};
+export type ModuleLifecycleContext = {
+    runtimeVersion: string;
+    workspacePath: string;
+};
+export type ModuleRegistration = {
+    id: string;
+    version: string;
+    contractVersion: "1";
+    capabilities: ModuleCapability[];
+    dependsOn: string[];
+    enabledByDefault: boolean;
+    config: ModuleDocumentContract;
+    state: ModuleDocumentContract;
+    instructions: ModuleInstructionContract;
+};
+export interface WorkflowModule {
+    registration: ModuleRegistration;
+    onInstall?(ctx: ModuleLifecycleContext): Promise<void>;
+    onConfigChange?(ctx: ModuleLifecycleContext): Promise<void>;
+    onStart?(ctx: ModuleLifecycleContext): Promise<void>;
+    onStop?(ctx: ModuleLifecycleContext): Promise<void>;
+    onEvent?(event: ModuleEvent, ctx: ModuleLifecycleContext): Promise<void>;
+    onCommand?(command: ModuleCommand, ctx: ModuleLifecycleContext): Promise<ModuleCommandResult>;
+}

package/dist/contracts/module-contract.js

@@ -0,0 +1 @@
+export {};

package/dist/core/index.d.ts

@@ -0,0 +1,3 @@
+export { ModuleRegistry, ModuleRegistryError, validateModuleSet, type ModuleRegistryOptions } from "./module-registry.js";
+export { ModuleCommandRouter, ModuleCommandRouterError, type ModuleCommandDescriptor, type ModuleCommandRouterOptions } from "./module-command-router.js";
+export type CoreRuntimeVersion = "0.1";

package/dist/core/index.js

@@ -0,0 +1,2 @@
+export { ModuleRegistry, ModuleRegistryError, validateModuleSet } from "./module-registry.js";
+export { ModuleCommandRouter, ModuleCommandRouterError } from "./module-command-router.js";

package/dist/core/module-command-router.d.ts

@@ -0,0 +1,27 @@
+import type { ModuleCommandResult, ModuleLifecycleContext } from "../contracts/module-contract.js";
+import { ModuleRegistry } from "./module-registry.js";
+export type ModuleCommandDescriptor = {
+    name: string;
+    moduleId: string;
+    instructionFile: string;
+    description?: string;
+};
+export type ModuleCommandRouterOptions = {
+    aliases?: Record<string, string>;
+};
+export declare class ModuleCommandRouterError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare class ModuleCommandRouter {
+    private readonly commands;
+    private readonly aliases;
+    private readonly registry;
+    constructor(registry: ModuleRegistry, options?: ModuleCommandRouterOptions);
+    listCommands(): ModuleCommandDescriptor[];
+    describeCommand(name: string): ModuleCommandDescriptor | undefined;
+    execute(name: string, args: Record<string, unknown> | undefined, ctx: ModuleLifecycleContext): Promise<ModuleCommandResult>;
+    private indexEnabledModuleCommands;
+    private validateAliases;
+    private resolveCommandName;
+}

package/dist/core/module-command-router.js

@@ -0,0 +1,84 @@
+export class ModuleCommandRouterError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "ModuleCommandRouterError";
+        this.code = code;
+    }
+}
+export class ModuleCommandRouter {
+    commands = new Map();
+    aliases;
+    registry;
+    constructor(registry, options) {
+        this.registry = registry;
+        this.aliases = options?.aliases ?? {};
+        this.indexEnabledModuleCommands();
+        this.validateAliases();
+    }
+    listCommands() {
+        return [...this.commands.values()]
+            .map((entry) => entry.descriptor)
+            .sort((a, b) => a.name.localeCompare(b.name));
+    }
+    describeCommand(name) {
+        const commandName = this.resolveCommandName(name);
+        return this.commands.get(commandName)?.descriptor;
+    }
+    async execute(name, args, ctx) {
+        const commandName = this.resolveCommandName(name);
+        const indexed = this.commands.get(commandName);
+        if (!indexed) {
+            const known = this.listCommands()
+                .map((command) => command.name)
+                .join(", ");
+            throw new ModuleCommandRouterError("unknown-command", `Unknown command '${name}'. Known commands: ${known || "none"}`);
+        }
+        if (!this.registry.isModuleEnabled(indexed.descriptor.moduleId)) {
+            throw new ModuleCommandRouterError("disabled-module", `Module '${indexed.descriptor.moduleId}' is disabled for command '${commandName}'`);
+        }
+        if (!indexed.module.onCommand) {
+            throw new ModuleCommandRouterError("command-not-implemented", `Module '${indexed.descriptor.moduleId}' does not implement onCommand for '${commandName}'`);
+        }
+        const command = {
+            name: commandName,
+            args
+        };
+        return indexed.module.onCommand(command, ctx);
+    }
+    indexEnabledModuleCommands() {
+        for (const module of this.registry.getEnabledModules()) {
+            for (const entry of module.registration.instructions.entries) {
+                if (this.commands.has(entry.name)) {
+                    const existing = this.commands.get(entry.name);
+                    throw new ModuleCommandRouterError("duplicate-command", `Command '${entry.name}' is declared by both '${existing?.descriptor.moduleId}' and '${module.registration.id}'`);
+                }
+                this.commands.set(entry.name, {
+                    descriptor: {
+                        name: entry.name,
+                        moduleId: module.registration.id,
+                        instructionFile: `${module.registration.instructions.directory}/${entry.file}`,
+                        description: entry.description
+                    },
+                    module
+                });
+            }
+        }
+    }
+    validateAliases() {
+        for (const [alias, commandName] of Object.entries(this.aliases)) {
+            if (alias === commandName) {
+                throw new ModuleCommandRouterError("invalid-alias", `Alias '${alias}' cannot map to itself`);
+            }
+            if (!this.commands.has(commandName)) {
+                throw new ModuleCommandRouterError("unknown-alias-target", `Alias '${alias}' maps to unknown command '${commandName}'`);
+            }
+            if (this.commands.has(alias)) {
+                throw new ModuleCommandRouterError("alias-conflict", `Alias '${alias}' conflicts with a declared command`);
+            }
+        }
+    }
+    resolveCommandName(name) {
+        return this.aliases[name] ?? name;
+    }
+}

package/dist/core/module-registry.d.ts

@@ -0,0 +1,24 @@
+import type { WorkflowModule } from "../contracts/module-contract.js";
+export declare class ModuleRegistryError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare function validateModuleSet(modules: WorkflowModule[]): void;
+export type ModuleRegistryOptions = {
+    enabledModules?: string[];
+    disabledModules?: string[];
+    workspacePath?: string;
+};
+export declare class ModuleRegistry {
+    private readonly modules;
+    private readonly enabledModules;
+    private readonly sortedModules;
+    private readonly moduleMap;
+    private readonly enabledModuleMap;
+    constructor(modules: WorkflowModule[], options?: ModuleRegistryOptions);
+    getAllModules(): WorkflowModule[];
+    getModuleById(id: string): WorkflowModule | undefined;
+    isModuleEnabled(id: string): boolean;
+    getEnabledModules(): WorkflowModule[];
+    getStartupOrder(): WorkflowModule[];
+}

package/dist/core/module-registry.js

@@ -0,0 +1,183 @@
+import { existsSync, statSync } from "node:fs";
+import { resolve, sep } from "node:path";
+export class ModuleRegistryError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "ModuleRegistryError";
+        this.code = code;
+    }
+}
+function buildModuleMap(modules) {
+    const moduleMap = new Map();
+    for (const module of modules) {
+        const id = module.registration.id;
+        if (moduleMap.has(id)) {
+            throw new ModuleRegistryError("duplicate-module-id", `Duplicate module id: '${id}'`);
+        }
+        moduleMap.set(id, module);
+    }
+    return moduleMap;
+}
+function validateDependencies(moduleMap) {
+    for (const module of moduleMap.values()) {
+        const moduleId = module.registration.id;
+        for (const dependency of module.registration.dependsOn) {
+            if (dependency === moduleId) {
+                throw new ModuleRegistryError("self-dependency", `Module '${moduleId}' cannot depend on itself`);
+            }
+            if (!moduleMap.has(dependency)) {
+                throw new ModuleRegistryError("missing-dependency", `Module '${moduleId}' depends on missing module '${dependency}'`);
+            }
+        }
+    }
+}
+function topologicalSort(moduleMap) {
+    const visited = new Set();
+    const inStack = new Set();
+    const sorted = [];
+    const visit = (id) => {
+        if (visited.has(id)) {
+            return;
+        }
+        if (inStack.has(id)) {
+            throw new ModuleRegistryError("dependency-cycle", `Dependency cycle detected at module '${id}'`);
+        }
+        inStack.add(id);
+        const module = moduleMap.get(id);
+        if (!module) {
+            throw new ModuleRegistryError("missing-module", `Module '${id}' not found`);
+        }
+        for (const dependencyId of module.registration.dependsOn) {
+            visit(dependencyId);
+        }
+        inStack.delete(id);
+        visited.add(id);
+        sorted.push(module);
+    };
+    for (const moduleId of moduleMap.keys()) {
+        visit(moduleId);
+    }
+    return sorted;
+}
+function resolveEnabledModuleIds(modules, options) {
+    const explicitEnabled = options?.enabledModules;
+    const explicitDisabled = new Set(options?.disabledModules ?? []);
+    const enabledIds = new Set();
+    for (const module of modules) {
+        if (module.registration.enabledByDefault) {
+            enabledIds.add(module.registration.id);
+        }
+    }
+    if (explicitEnabled && explicitEnabled.length > 0) {
+        enabledIds.clear();
+        for (const moduleId of explicitEnabled) {
+            enabledIds.add(moduleId);
+        }
+    }
+    for (const moduleId of explicitDisabled) {
+        enabledIds.delete(moduleId);
+    }
+    return enabledIds;
+}
+function buildEnabledModuleMap(moduleMap, enabledModuleIds) {
+    const enabledModuleMap = new Map();
+    for (const moduleId of enabledModuleIds) {
+        const module = moduleMap.get(moduleId);
+        if (!module) {
+            throw new ModuleRegistryError("unknown-enabled-module", `Enabled module '${moduleId}' not found`);
+        }
+        enabledModuleMap.set(moduleId, module);
+    }
+    return enabledModuleMap;
+}
+function validateEnabledDependencies(enabledModuleMap) {
+    for (const module of enabledModuleMap.values()) {
+        for (const dependencyId of module.registration.dependsOn) {
+            if (!enabledModuleMap.has(dependencyId)) {
+                throw new ModuleRegistryError("disabled-required-dependency", `Enabled module '${module.registration.id}' requires disabled module '${dependencyId}'`);
+            }
+        }
+    }
+}
+function isInstructionNameValid(name) {
+    return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name);
+}
+function validateInstructionContracts(moduleMap, workspacePath) {
+    for (const module of moduleMap.values()) {
+        const { id, instructions } = module.registration;
+        const instructionDirectory = resolve(workspacePath, instructions.directory);
+        const seenNames = new Set();
+        const seenFiles = new Set();
+        for (const entry of instructions.entries) {
+            if (!isInstructionNameValid(entry.name)) {
+                throw new ModuleRegistryError("invalid-instruction-name", `Module '${id}' has invalid instruction name '${entry.name}'`);
+            }
+            if (seenNames.has(entry.name)) {
+                throw new ModuleRegistryError("duplicate-instruction-name", `Module '${id}' has duplicate instruction name '${entry.name}'`);
+            }
+            seenNames.add(entry.name);
+            if (!entry.file.endsWith(".md")) {
+                throw new ModuleRegistryError("invalid-instruction-file", `Module '${id}' instruction file '${entry.file}' must end with .md`);
+            }
+            const expectedFileName = `${entry.name}.md`;
+            if (entry.file !== expectedFileName) {
+                throw new ModuleRegistryError("instruction-name-file-mismatch", `Module '${id}' instruction '${entry.name}' must map to '${expectedFileName}'`);
+            }
+            if (seenFiles.has(entry.file)) {
+                throw new ModuleRegistryError("duplicate-instruction-file", `Module '${id}' has duplicate instruction file '${entry.file}'`);
+            }
+            seenFiles.add(entry.file);
+            const instructionFilePath = resolve(instructionDirectory, entry.file);
+            if (instructionFilePath !== instructionDirectory &&
+                !instructionFilePath.startsWith(`${instructionDirectory}${sep}`)) {
+                throw new ModuleRegistryError("instruction-path-escape", `Module '${id}' instruction '${entry.name}' resolves outside instruction directory`);
+            }
+            if (!existsSync(instructionFilePath)) {
+                throw new ModuleRegistryError("missing-instruction-file", `Module '${id}' instruction file '${instructionFilePath}' does not exist`);
+            }
+            if (!statSync(instructionFilePath).isFile()) {
+                throw new ModuleRegistryError("invalid-instruction-file", `Module '${id}' instruction path '${instructionFilePath}' is not a file`);
+            }
+        }
+    }
+}
+export function validateModuleSet(modules) {
+    const moduleMap = buildModuleMap(modules);
+    validateDependencies(moduleMap);
+    validateInstructionContracts(moduleMap, process.cwd());
+    topologicalSort(moduleMap);
+}
+export class ModuleRegistry {
+    modules;
+    enabledModules;
+    sortedModules;
+    moduleMap;
+    enabledModuleMap;
+    constructor(modules, options) {
+        this.moduleMap = buildModuleMap(modules);
+        validateDependencies(this.moduleMap);
+        validateInstructionContracts(this.moduleMap, options?.workspacePath ?? process.cwd());
+        this.modules = [...modules];
+        const enabledModuleIds = resolveEnabledModuleIds(this.modules, options);
+        this.enabledModuleMap = buildEnabledModuleMap(this.moduleMap, enabledModuleIds);
+        validateEnabledDependencies(this.enabledModuleMap);
+        this.sortedModules = topologicalSort(this.enabledModuleMap);
+        this.enabledModules = [...this.sortedModules];
+    }
+    getAllModules() {
+        return [...this.modules];
+    }
+    getModuleById(id) {
+        return this.moduleMap.get(id);
+    }
+    isModuleEnabled(id) {
+        return this.enabledModuleMap.has(id);
+    }
+    getEnabledModules() {
+        return [...this.enabledModules];
+    }
+    getStartupOrder() {
+        return [...this.sortedModules];
+    }
+}

package/dist/index.d.ts

@@ -1 +1,4 @@
 export { defaultWorkspaceKitPaths, parseJsonFile, runCli, type WorkspaceKitCliOptions } from "./cli.js";
+export * from "./core/index.js";
+export * from "./contracts/index.js";
+export * from "./modules/index.js";

package/dist/index.js

@@ -1 +1,4 @@
 export { defaultWorkspaceKitPaths, parseJsonFile, runCli } from "./cli.js";
+export * from "./core/index.js";
+export * from "./contracts/index.js";
+export * from "./modules/index.js";

package/dist/modules/approvals/index.d.ts

@@ -0,0 +1,2 @@
+import type { WorkflowModule } from "../../contracts/module-contract.js";
+export declare const approvalsModule: WorkflowModule;