@tomflow/proflow-platform-cli 0.1.16 → 0.1.18

package/dist/src/cli.js

@@ -3,28 +3,24 @@ import { readFile, realpath, stat } from "node:fs/promises";
 import { resolve } from "node:path";
 import { moduleStatusObservationSchema } from "@tomflow/proflow-module-contract";
 import { descriptor as platformCliDescriptor } from "../deployment/descriptor.js";
-import { buildProductionBindings, importRawAdapter, } from "./binding/production-bindings.js";
 import { AutoModuleCatalog, discoverModules } from "./discovery/discover.js";
 import { InstalledModuleCatalog } from "./discovery/installed.js";
-import { aggregateModuleDocs } from "./docs/aggregate.js";
 import { PlatformError } from "./errors.js";
 import { observeWorkspaceInstalledVersion, removeWorkspacePackages, syncWorkspacePackages, } from "./install/package-manager.js";
-import { observeStatuses, preflightAndStartModules, stopModulesThin, } from "./lifecycle/thin.js";
-import { workspacePaths } from "./paths.js";
-import { loadConfig } from "./persistence/config.js";
+import { installModulesThin, observeDocs, observeStatuses, setupModulesThin, startModulesThin, stopModulesThin, uninstallModulesThin, } from "./lifecycle/index.js";
 import { ensureWorkspaceMetadata } from "./persistence/workspace-metadata.js";
 import { discoverRegistryModules, PRO_FLOW_PACKAGE_PREFIX, } from "./registry/index.js";
 const COMMANDS = [
-    "modules",
-    "docs",
     "install",
     "uninstall",
+    "status",
+    "setup",
+    "docs",
     "start",
     "stop",
 ];
 function parseArgs(argv) {
-    let json = false;
-    let workspace;
+    let json = false, workspace, moduleRef, input, inputSeen = false;
     let special;
     const positional = [];
     for (let index = 0; index < argv.length; index += 1) {
@@ -35,24 +31,33 @@ function parseArgs(argv) {
             json = true;
             continue;
         }
-        if (value === "--workspace") {
+        if (value === "--workspace" ||
+            value === "--module" ||
+            value === "--input") {
             const next = argv[index + 1];
-            if (!next || next.startsWith("-")) {
-                throw new PlatformError("INVALID_REQUEST", "--workspace requires a path");
+            if (!next || (value !== "--input" && next.startsWith("-")))
+                throw new PlatformError("INVALID_REQUEST", `${value} requires a value`);
+            if (value === "--workspace")
+                workspace = next;
+            else if (value === "--module")
+                moduleRef = next;
+            else {
+                try {
+                    input = JSON.parse(next);
+                    inputSeen = true;
+                }
+                catch (error) {
+                    throw new PlatformError("INVALID_REQUEST", `--input must be valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+                }
             }
-            workspace = next;
             index += 1;
             continue;
         }
         if (value === "--help" || value === "-h") {
-            if (special !== undefined && special !== "help")
-                throw new PlatformError("INVALID_REQUEST", "help and version flags cannot be combined");
             special = "help";
             continue;
         }
         if (value === "--version" || value === "-v") {
-            if (special !== undefined && special !== "version")
-                throw new PlatformError("INVALID_REQUEST", "help and version flags cannot be combined");
             special = "version";
             continue;
         }
@@ -61,26 +66,32 @@ function parseArgs(argv) {
         positional.push(value);
     }
     if (special !== undefined) {
-        if (workspace !== undefined || positional.length > 0)
-            throw new PlatformError("INVALID_REQUEST", `${special} flag cannot be combined with a command or --workspace`);
+        if (workspace !== undefined ||
+            moduleRef !== undefined ||
+            inputSeen ||
+            positional.length > 0)
+            throw new PlatformError("INVALID_REQUEST", `${special} flag cannot be combined with command options`);
         return { command: special, json };
     }
-    if (positional.length === 0) {
-        if (workspace !== undefined)
-            throw new PlatformError("INVALID_REQUEST", "--workspace is only valid with install");
+    if (positional.length === 0)
         return { command: "help", json };
-    }
     if (positional.length !== 1)
         throw new PlatformError("INVALID_REQUEST", "commands accept no positional arguments");
     const raw = positional[0] ?? "";
     if (!COMMANDS.includes(raw))
         throw new PlatformError("INVALID_REQUEST", `unknown command ${raw}`);
     const command = raw;
-    if (workspace !== undefined && command !== "install")
-        throw new PlatformError("INVALID_REQUEST", "--workspace is only valid with install");
-    return workspace === undefined
-        ? { command, json }
-        : { command, workspace, json };
+    if ((moduleRef !== undefined || inputSeen) && command !== "setup")
+        throw new PlatformError("INVALID_REQUEST", "--module/--input are only valid with setup");
+    if (inputSeen && moduleRef === undefined)
+        throw new PlatformError("INVALID_REQUEST", "--input requires --module");
+    return {
+        command,
+        json,
+        ...(workspace === undefined ? {} : { workspace }),
+        ...(moduleRef === undefined ? {} : { moduleRef }),
+        ...(inputSeen ? { input } : {}),
+    };
 }
 function outcome(command, status, workspaceRoot, data) {
     return {
@@ -99,32 +110,12 @@ async function canonicalWorkspace(cwd, explicit) {
     catch (error) {
         throw new PlatformError("WORKSPACE_NOT_FOUND", `Workspace does not exist: ${candidate} (${error instanceof Error ? error.message : String(error)})`);
     }
-    if (!info.isDirectory()) {
+    if (!info.isDirectory())
         throw new PlatformError("WORKSPACE_NOT_FOUND", `Workspace is not a directory: ${candidate}`);
-    }
     return realpath(candidate);
 }
-async function loadConfigMap(root, modules) {
-    const paths = workspacePaths(root);
-    const configByModuleRef = new Map();
-    for (const module of modules) {
-        const config = await loadConfig(paths, module.moduleRef);
-        if (config === undefined)
-            continue;
-        configByModuleRef.set(module.moduleRef, config);
-    }
-    return configByModuleRef;
-}
 async function buildContext(root) {
-    const discovered = await discoverModules({ workspaceRoot: root });
-    const configByModuleRef = await loadConfigMap(root, discovered);
-    const bindings = await buildProductionBindings({
-        workspaceRoot: root,
-        modules: discovered,
-        configByModuleRef,
-        importAdapter: (packageName, source) => importRawAdapter(packageName, source, root),
-    });
-    const catalog = new AutoModuleCatalog(root, bindings);
+    const catalog = new AutoModuleCatalog(root);
     const modules = await discoverModules({ workspaceRoot: root, catalog });
     return { catalog, modules };
 }
@@ -137,62 +128,69 @@ function statusFromModule(value) {
                 ? "BLOCKED"
                 : "FAILED";
 }
-function failedLifecycleStatus(results) {
-    const last = results.at(-1);
-    return last === undefined
-        ? "SUCCEEDED"
-        : statusFromModule(last.result.status);
+function batchStatus(result) {
+    if (result.completed)
+        return "SUCCEEDED";
+    if (result.blockedBy)
+        return result.blockedBy.setupStatus === "ACTION_REQUIRED"
+            ? "ACTION_REQUIRED"
+            : "FAILED";
+    const statuses = result.results.map((item) => statusFromModule(item.result.status));
+    if (statuses.includes("FAILED"))
+        return "FAILED";
+    if (statuses.includes("BLOCKED"))
+        return "BLOCKED";
+    if (statuses.includes("ACTION_REQUIRED"))
+        return "ACTION_REQUIRED";
+    return "FAILED";
 }
-async function handleModules(root) {
+async function handleStatus(root) {
     const { catalog, modules } = await buildContext(root);
-    const observed = await observeStatuses(catalog, modules);
+    const observed = await observeStatuses(catalog, modules, root);
     const byRef = new Map(modules.map((module) => [module.moduleRef, module]));
     const output = observed.map((item) => {
-        if (item.result.status !== "SUCCEEDED") {
+        if (item.result.status !== "SUCCEEDED")
             throw new PlatformError("COMMAND_FAILED", `module ${item.moduleRef} status observation did not return SUCCEEDED`);
-        }
         const parsed = moduleStatusObservationSchema.safeParse(item.result.data);
-        if (!parsed.success) {
-            throw new PlatformError("COMMAND_FAILED", `module ${item.moduleRef} returned an invalid status observation: ${parsed.error.message}`);
-        }
+        if (!parsed.success)
+            throw new PlatformError("COMMAND_FAILED", `module ${item.moduleRef} returned invalid status: ${parsed.error.message}`);
         const module = byRef.get(item.moduleRef);
-        if (module === undefined)
+        if (!module)
             throw new PlatformError("COMMAND_FAILED", `unknown module ${item.moduleRef}`);
         return {
             moduleRef: item.moduleRef,
             version: module.moduleVersion,
-            configStatus: parsed.data.configStatus,
-            ...(parsed.data.missingConfig === undefined
-                ? {}
-                : { missingConfig: parsed.data.missingConfig }),
+            setupStatus: parsed.data.setupStatus,
             runtimeStatus: parsed.data.runtimeStatus,
         };
     });
-    return outcome("modules", "SUCCEEDED", root, { modules: output });
+    return outcome("status", "SUCCEEDED", root, { modules: output });
 }
 async function handleDocs(root) {
-    const catalog = new AutoModuleCatalog(root);
-    const modules = await discoverModules({ workspaceRoot: root, catalog });
-    const docs = await aggregateModuleDocs(root, catalog, modules);
-    return outcome("docs", "SUCCEEDED", root, { modules: docs });
+    const { catalog, modules } = await buildContext(root);
+    const docs = await observeDocs(catalog, modules, root);
+    const byRef = new Map(modules.map((module) => [module.moduleRef, module]));
+    return outcome("docs", "SUCCEEDED", root, {
+        modules: docs.map((item) => ({
+            moduleRef: item.moduleRef,
+            version: byRef.get(item.moduleRef)?.moduleVersion,
+            docs: item.result.data,
+        })),
+    });
 }
 async function validateInstalledPackageSet(root, candidates, previousManaged) {
     const expectedNames = candidates.map((item) => item.packageName).sort();
     const declaredNames = await workspaceProFlowDependencies(root);
-    if (JSON.stringify(declaredNames) !== JSON.stringify(expectedNames)) {
+    if (JSON.stringify(declaredNames) !== JSON.stringify(expectedNames))
         throw new PlatformError("COMMAND_FAILED", `managed dependency set mismatch: expected ${expectedNames.join(", ")}, observed ${declaredNames.join(", ")}`);
-    }
     for (const candidate of candidates) {
         const observed = await observeWorkspaceInstalledVersion(root, candidate.packageName);
-        if (observed !== candidate.moduleVersion) {
+        if (observed !== candidate.moduleVersion)
             throw new PlatformError("COMMAND_FAILED", `installed version mismatch for ${candidate.packageName}: expected ${candidate.moduleVersion}, observed ${observed ?? "missing"}`);
-        }
     }
-    for (const stale of previousManaged.filter((name) => !expectedNames.includes(name))) {
-        if ((await observeWorkspaceInstalledVersion(root, stale)) !== undefined) {
+    for (const stale of previousManaged.filter((name) => !expectedNames.includes(name)))
+        if ((await observeWorkspaceInstalledVersion(root, stale)) !== undefined)
             throw new PlatformError("COMMAND_FAILED", `stale managed package remains installed after synchronization: ${stale}`);
-        }
-    }
     const catalog = new InstalledModuleCatalog(root);
     const sources = await catalog.sources();
     const modules = await discoverModules({ catalog, sources });
@@ -200,9 +198,8 @@ async function validateInstalledPackageSet(root, candidates, previousManaged) {
     for (const candidate of candidates) {
         const module = byPackage.get(candidate.packageName);
         if (module === undefined ||
-            module.moduleVersion !== candidate.moduleVersion) {
+            module.moduleVersion !== candidate.moduleVersion)
             throw new PlatformError("DESCRIPTOR_INVALID", `installed descriptor mismatch for ${candidate.packageName}@${candidate.moduleVersion}`);
-        }
     }
 }
 async function handleInstall(root, runtime) {
@@ -212,12 +209,10 @@ async function handleInstall(root, runtime) {
             ? {}
             : { runner: runtime.registryRunner }),
     });
-    if (discovered.rejected.length > 0) {
+    if (discovered.rejected.length > 0)
         throw new PlatformError("REGISTRY_RESPONSE_INVALID", `registry contains rejected ProFlow packages: ${discovered.rejected.map((item) => `${item.packageName}:${item.reason}`).join(", ")}`);
-    }
-    if (discovered.candidates.length === 0) {
+    if (discovered.candidates.length === 0)
         throw new PlatformError("PACKAGE_NOT_FOUND", "no ProFlow packages were discovered in the configured scope");
-    }
     const previousManaged = await workspaceProFlowDependencies(root);
     const mutation = await syncWorkspacePackages({
         workspaceRoot: root,
@@ -234,7 +229,9 @@ async function handleInstall(root, runtime) {
     });
     await validateInstalledPackageSet(root, discovered.candidates, previousManaged);
     const metadata = await ensureWorkspaceMetadata(root);
-    return outcome("install", "SUCCEEDED", root, {
+    const { catalog, modules } = await buildContext(root);
+    const moduleInstall = await installModulesThin(catalog, modules, root);
+    return outcome("install", batchStatus(moduleInstall), root, {
         registry: discovered.registry,
         packageManager: mutation.packageManager,
         packages: discovered.candidates.map((item) => ({
@@ -242,7 +239,8 @@ async function handleInstall(root, runtime) {
             version: item.moduleVersion,
         })),
         workspace: metadata,
-        next: "platform modules",
+        modules: moduleInstall,
+        next: "platform status",
     });
 }
 async function workspaceProFlowDependencies(root) {
@@ -256,10 +254,9 @@ async function workspaceProFlowDependencies(root) {
             const value = record[field];
             if (typeof value !== "object" || value === null || Array.isArray(value))
                 continue;
-            for (const name of Object.keys(value)) {
+            for (const name of Object.keys(value))
                 if (name.startsWith(PRO_FLOW_PACKAGE_PREFIX))
                     names.add(name);
-            }
         }
         return [...names].sort();
     }
@@ -273,6 +270,13 @@ async function workspaceProFlowDependencies(root) {
 }
 async function handleUninstall(root, runtime) {
     const packageNames = await workspaceProFlowDependencies(root);
+    const { catalog, modules } = await buildContext(root);
+    const moduleUninstall = await uninstallModulesThin(catalog, modules, root);
+    if (!moduleUninstall.completed)
+        return outcome("uninstall", batchStatus(moduleUninstall), root, {
+            modules: moduleUninstall,
+            removed: [],
+        });
     const mutation = await removeWorkspacePackages({
         workspaceRoot: root,
         packageNames,
@@ -284,26 +288,39 @@ async function handleUninstall(root, runtime) {
             : { executableAvailable: runtime.executableAvailable }),
     });
     return outcome("uninstall", "SUCCEEDED", root, {
+        modules: moduleUninstall,
         packageManager: mutation.packageManager,
         removed: packageNames,
         preserved: [".proflow"],
     });
 }
+async function handleSetup(root, parsed) {
+    const { catalog, modules } = await buildContext(root);
+    const target = parsed.moduleRef === undefined
+        ? undefined
+        : {
+            moduleRef: parsed.moduleRef,
+            ...(Object.hasOwn(parsed, "input") ? { input: parsed.input } : {}),
+        };
+    const result = await setupModulesThin(catalog, modules, root, target);
+    return outcome("setup", batchStatus(result), root, result);
+}
 async function handleStart(root) {
     const { catalog, modules } = await buildContext(root);
-    const result = await preflightAndStartModules(catalog, modules);
-    return outcome("start", result.completed ? "SUCCEEDED" : failedLifecycleStatus(result.results), root, result);
+    const result = await startModulesThin(catalog, modules, root);
+    return outcome("start", batchStatus(result), root, result);
 }
 async function handleStop(root) {
     const { catalog, modules } = await buildContext(root);
-    const result = await stopModulesThin(catalog, modules);
-    return outcome("stop", result.completed ? "SUCCEEDED" : failedLifecycleStatus(result.results), root, result);
+    const result = await stopModulesThin(catalog, modules, root);
+    return outcome("stop", batchStatus(result), root, result);
 }
 function helpOutcome() {
     return outcome("help", "SUCCEEDED", undefined, {
-        usage: "platform <modules|docs|install|uninstall|start|stop> [--json]",
+        usage: "platform <install|uninstall|status|setup|docs|start|stop> [--workspace <path>] [--json]",
         commands: [...COMMANDS],
         install: "platform install [--workspace <path>]",
+        setup: "platform setup [--workspace <path>] [--module <moduleRef> --input '<json>']",
     });
 }
 export async function runCli(argv, runtime = {}) {
@@ -317,24 +334,22 @@ export async function runCli(argv, runtime = {}) {
     try {
         if (parsed.command === "help")
             return JSON.stringify(helpOutcome());
-        if (parsed.command === "version") {
+        if (parsed.command === "version")
             return JSON.stringify(outcome("version", "SUCCEEDED", undefined, {
                 version: platformCliDescriptor.moduleVersion,
             }));
-        }
-        const cwd = await canonicalWorkspace(runtime.cwd ?? process.cwd());
-        const root = parsed.command === "install" && parsed.workspace !== undefined
-            ? await canonicalWorkspace(cwd, parsed.workspace)
-            : cwd;
+        const root = await canonicalWorkspace(runtime.cwd ?? process.cwd(), parsed.workspace);
         switch (parsed.command) {
-            case "modules":
-                return JSON.stringify(await handleModules(root));
-            case "docs":
-                return JSON.stringify(await handleDocs(root));
             case "install":
                 return JSON.stringify(await handleInstall(root, runtime));
             case "uninstall":
                 return JSON.stringify(await handleUninstall(root, runtime));
+            case "status":
+                return JSON.stringify(await handleStatus(root));
+            case "setup":
+                return JSON.stringify(await handleSetup(root, parsed));
+            case "docs":
+                return JSON.stringify(await handleDocs(root));
             case "start":
                 return JSON.stringify(await handleStart(root));
             case "stop":
@@ -346,13 +361,12 @@ export async function runCli(argv, runtime = {}) {
     }
 }
 function errorOutcome(command, error) {
-    if (error instanceof PlatformError) {
+    if (error instanceof PlatformError)
         return {
             command,
             status: "FAILED",
             error: { code: error.code, message: error.message },
         };
-    }
     return {
         command,
         status: "FAILED",
@@ -362,62 +376,81 @@ function errorOutcome(command, error) {
         },
     };
 }
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function renderModules(data) {
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function renderStatus(data) {
     if (!isRecord(data) || !Array.isArray(data.modules))
         return "No modules.";
-    const lines = ["ProFlow Modules", ""];
-    for (const raw of data.modules) {
-        if (!isRecord(raw))
-            continue;
-        const missing = Array.isArray(raw.missingConfig)
-            ? raw.missingConfig
-                .filter((item) => typeof item === "string")
-                .join(",")
-            : "-";
-        lines.push(`${String(raw.moduleRef)}  ${String(raw.version)}  config=${String(raw.configStatus)}  runtime=${String(raw.runtimeStatus)}  missing=${missing}`);
-    }
-    return lines.join("\n");
+    return [
+        "ProFlow Modules",
+        "",
+        ...data.modules
+            .filter(isRecord)
+            .map((raw) => `${String(raw.moduleRef)}  ${String(raw.version)}  setup=${String(raw.setupStatus)}  runtime=${String(raw.runtimeStatus)}`),
+    ].join("\n");
 }
 function renderDocs(data) {
     if (!isRecord(data) || !Array.isArray(data.modules))
         return "No module docs.";
     const lines = ["ProFlow Docs"];
-    for (const raw of data.modules) {
-        if (!isRecord(raw))
+    for (const raw of data.modules)
+        if (isRecord(raw))
+            lines.push("", `## ${String(raw.moduleRef)} @ ${String(raw.version)}`, JSON.stringify(raw.docs ?? {}, null, 2));
+    return lines.join("\n");
+}
+function renderSetup(data) {
+    if (!isRecord(data) || !Array.isArray(data.results))
+        return "No setup actions are required.";
+    const lines = ["ProFlow Setup", ""];
+    let automatic = 0;
+    let pending = 0;
+    for (const raw of data.results) {
+        if (!isRecord(raw) || !isRecord(raw.result))
             continue;
-        lines.push("", `## ${String(raw.moduleRef)} @ ${String(raw.version)}`);
-        if (!Array.isArray(raw.documents))
+        const moduleRef = String(raw.moduleRef ?? raw.result.moduleRef ?? "unknown");
+        const status = String(raw.result.status ?? "UNKNOWN");
+        if (status === "SUCCEEDED") {
+            automatic += 1;
             continue;
-        for (const document of raw.documents) {
-            if (!isRecord(document))
-                continue;
-            lines.push("", `### ${String(document.id)}`, String(document.content ?? ""));
         }
+        pending += 1;
+        lines.push(`## ${moduleRef} — ${status}`);
+        const actionRequired = raw.result.actionRequired;
+        if (isRecord(actionRequired)) {
+            if (actionRequired.action !== undefined)
+                lines.push(`Action: ${String(actionRequired.action)}`);
+            if (actionRequired.description !== undefined)
+                lines.push(String(actionRequired.description));
+        }
+        else if (raw.result.data !== undefined) {
+            lines.push(JSON.stringify(raw.result.data, null, 2));
+        }
+        lines.push("");
     }
-    return lines.join("\n");
+    if (pending === 0)
+        lines.push("All discovered Modules are setup-ready.");
+    if (automatic > 0)
+        lines.push(`Automatically completed in this run: ${automatic}`);
+    return lines.join("\n").trimEnd();
 }
 export function renderHumanResult(result) {
-    if (result.status === "FAILED") {
+    if (result.status === "FAILED")
         return `${result.command.toUpperCase()} FAILED${result.error ? ` [${result.error.code}] ${result.error.message}` : ""}`;
-    }
-    if (result.command === "help") {
+    if (result.command === "help")
         return [
             "ProFlow Platform CLI",
             "",
             ...COMMANDS.map((command) => `platform ${command}`),
             "",
             "platform install --workspace <path>",
+            "platform setup --module <moduleRef> --input '<json>'",
             "append --json for machine-readable output",
         ].join("\n");
-    }
-    if (result.command === "version" && isRecord(result.data)) {
+    if (result.command === "version" && isRecord(result.data))
         return String(result.data.version ?? platformCliDescriptor.moduleVersion);
-    }
-    if (result.command === "modules")
-        return renderModules(result.data);
+    if (result.command === "status")
+        return renderStatus(result.data);
+    if (result.command === "setup")
+        return renderSetup(result.data);
     if (result.command === "docs")
         return renderDocs(result.data);
     return [

package/dist/src/contracts.d.ts

@@ -10,8 +10,6 @@ export interface ResolvedModule {
     requires: ModuleDescriptor["requires"];
     requirements: ModuleRequirement[];
     configSlots: ConfigSlot[];
-    lifecycle: string[];
-    verification: ModuleDescriptor["verification"];
     effects: DeploymentEffect[];
     source: {
         type: "workspace" | "installed";

package/dist/src/discovery/discover.d.ts

@@ -1,4 +1,3 @@
-import type { DeploymentAdapterBinding } from "../binding/production-bindings.ts";
 import type { ResolvedModule } from "../contracts.ts";
 import type { ModuleCatalog, ModuleSource } from "../modules.ts";
 export interface DiscoverOptions {
@@ -9,8 +8,7 @@ export interface DiscoverOptions {
 export declare class AutoModuleCatalog implements ModuleCatalog {
     private readonly workspace;
     private readonly installed;
-    private readonly bindings;
-    constructor(root?: string, bindings?: ReadonlyMap<string, DeploymentAdapterBinding>);
+    constructor(root?: string);
     sources(): Promise<ModuleSource[]>;
     loadDescriptor(source: ModuleSource): Promise<unknown>;
     loadAdapter(source: ModuleSource): Promise<unknown>;

package/dist/src/discovery/discover.js

@@ -7,11 +7,9 @@ import { readPackageJson } from "./workspace.js";
 export class AutoModuleCatalog {
     workspace;
     installed;
-    bindings;
-    constructor(root, bindings) {
+    constructor(root) {
         this.workspace = new WorkspaceModuleCatalog(root);
         this.installed = new InstalledModuleCatalog(root);
-        this.bindings = bindings ?? new Map();
     }
     async sources() {
         const workspaceSources = await this.workspace.sources();
@@ -32,11 +30,6 @@ export class AutoModuleCatalog {
             : this.installed.loadDescriptor(source);
     }
     async loadAdapter(source) {
-        // A production binder may supply a bound adapter for a service module
-        // (createBehaviorAdapter(realService)); it wins over the unbound default.
-        const binding = this.bindings.get(source.packageName);
-        if (binding !== undefined)
-            return binding;
         return source.type === "workspace"
             ? this.workspace.loadAdapter(source)
             : this.installed.loadAdapter(source);
@@ -96,8 +89,6 @@ function toResolvedModule(descriptor, source) {
         requires: descriptor.requires,
         requirements: descriptor.requirements,
         configSlots: descriptor.configSlots,
-        lifecycle: descriptor.lifecycle.supported,
-        verification: descriptor.verification,
         effects: descriptor.effects,
         source: resolvedSource,
     };

package/dist/src/errors.d.ts

@@ -1,4 +1,4 @@
-export declare const platformErrorCodes: readonly ["INVALID_REQUEST", "DESCRIPTOR_INVALID", "DUPLICATE_IDENTITY", "DEPENDENCY_UNRESOLVED", "DEPENDENCY_INCOMPATIBLE", "DEPENDENCY_CYCLE", "CONFIG_INVALID", "WORKSPACE_NOT_FOUND", "WORKSPACE_INSTANCE_INVALID", "PACKAGE_MANAGER_UNSUPPORTED", "PACKAGE_MANAGER_CONFLICT", "PACKAGE_MANAGER_UNAVAILABLE", "LIFECYCLE_UNSUPPORTED", "UNINSTALL_FAILED", "REGISTRY_UNAVAILABLE", "REGISTRY_AUTH_REQUIRED", "REGISTRY_RESPONSE_INVALID", "PACKAGE_NOT_FOUND", "PACKAGE_NOT_PROFLOW", "COMMAND_FAILED"];
+export declare const platformErrorCodes: readonly ["INVALID_REQUEST", "DESCRIPTOR_INVALID", "DUPLICATE_IDENTITY", "DEPENDENCY_UNRESOLVED", "DEPENDENCY_INCOMPATIBLE", "DEPENDENCY_CYCLE", "WORKSPACE_NOT_FOUND", "WORKSPACE_INSTANCE_INVALID", "PACKAGE_MANAGER_UNSUPPORTED", "PACKAGE_MANAGER_CONFLICT", "PACKAGE_MANAGER_UNAVAILABLE", "UNINSTALL_FAILED", "REGISTRY_UNAVAILABLE", "REGISTRY_AUTH_REQUIRED", "REGISTRY_RESPONSE_INVALID", "PACKAGE_NOT_FOUND", "PACKAGE_NOT_PROFLOW", "COMMAND_FAILED"];
 export type PlatformErrorCode = (typeof platformErrorCodes)[number];
 export declare class PlatformError extends Error {
     readonly code: PlatformErrorCode;

package/dist/src/errors.js

@@ -5,13 +5,11 @@ export const platformErrorCodes = [
     "DEPENDENCY_UNRESOLVED",
     "DEPENDENCY_INCOMPATIBLE",
     "DEPENDENCY_CYCLE",
-    "CONFIG_INVALID",
     "WORKSPACE_NOT_FOUND",
     "WORKSPACE_INSTANCE_INVALID",
     "PACKAGE_MANAGER_UNSUPPORTED",
     "PACKAGE_MANAGER_CONFLICT",
     "PACKAGE_MANAGER_UNAVAILABLE",
-    "LIFECYCLE_UNSUPPORTED",
     "UNINSTALL_FAILED",
     "REGISTRY_UNAVAILABLE",
     "REGISTRY_AUTH_REQUIRED",

package/dist/src/index.d.ts

@@ -1,8 +1,6 @@
 export type { CliOutcome, CliRuntimeOptions, CliStatus, } from "./cli.ts";
 export { renderHumanResult, runCli } from "./cli.ts";
 export { AutoModuleCatalog, discoverModules } from "./discovery/discover.ts";
-export type { AggregatedDocument, AggregatedModuleDocs, } from "./docs/aggregate.ts";
-export { aggregateModuleDocs } from "./docs/aggregate.ts";
 export type { PlatformErrorCode } from "./errors.ts";
 export { PlatformError } from "./errors.ts";
 export type { ModuleCatalog, ModuleSource } from "./modules.ts";

package/dist/src/index.js

@@ -1,4 +1,3 @@
 export { renderHumanResult, runCli } from "./cli.js";
 export { AutoModuleCatalog, discoverModules } from "./discovery/discover.js";
-export { aggregateModuleDocs } from "./docs/aggregate.js";
 export { PlatformError } from "./errors.js";

package/dist/src/lifecycle/dispatch.d.ts

@@ -1,17 +1,10 @@
-import { type LifecyclePrimitive, type ModuleOperationResult } from "@tomflow/proflow-module-contract";
+import { type ModuleCommandContext, type ModuleManagementCommand, type ModuleOperationResult } from "@tomflow/proflow-module-contract";
 import type { ResolvedModule } from "../contracts.ts";
 import type { ModuleCatalog } from "../modules.ts";
-export interface LifecycleDispatchResult {
+export interface ModuleDispatchResult {
     moduleRef: string;
-    primitive: LifecyclePrimitive;
+    command: ModuleManagementCommand;
     result: ModuleOperationResult;
     observedEffects: string[];
 }
-/**
- * Dispatches a single lifecycle primitive against one module through its
- * public deployment adapter. The descriptor is the source of truth for what is
- * supported: a primitive not declared in `lifecycle` is rejected with
- * `LIFECYCLE_UNSUPPORTED` rather than faked. The adapter result is always
- * runtime-validated against the Module Operation Result schema.
- */
-export declare function dispatchLifecycle(catalog: ModuleCatalog, module: ResolvedModule, primitive: LifecyclePrimitive): Promise<LifecycleDispatchResult>;
+export declare function dispatchModuleCommand(catalog: ModuleCatalog, module: ResolvedModule, command: ModuleManagementCommand, context: ModuleCommandContext): Promise<ModuleDispatchResult>;