@tomflow/proflow-platform-cli 0.1.14 → 0.1.16

package/dist/src/registry/npm-registry.js

@@ -1,10 +1,6 @@
 import { execFile } from "node:child_process";
-import { mkdtemp, readFile, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 import { promisify } from "node:util";
-import { gunzipSync } from "node:zlib";
-import { parseModuleDescriptor, proflowPackageMetadataSchema, } from "@tomflow/proflow-module-contract";
+import { proflowPackageMetadataSchema } from "@tomflow/proflow-module-contract";
 import { PlatformError } from "../errors.js";
 import { versionSatisfies } from "../modules.js";
 const execFileAsync = promisify(execFile);
@@ -60,131 +56,6 @@ export async function discoverRegistryModules(options) {
     rejected.sort((left, right) => left.packageName.localeCompare(right.packageName));
     return { registry, candidates, rejected };
 }
-export async function loadRegistryModuleDescriptor(options) {
-    const runner = options.runner ?? systemNpmRunner();
-    const tempRoot = await mkdtemp(join(tmpdir(), "proflow-registry-manifest-"));
-    try {
-        const packed = await runner.run([
-            "pack",
-            `${options.candidate.packageName}@${options.candidate.moduleVersion}`,
-            "--json",
-            "--ignore-scripts",
-            `--pack-destination=${tempRoot}`,
-            `--registry=${options.candidate.registry}`,
-        ], options.workspaceRoot);
-        const filename = packFilename(packed.stdout, options.candidate.packageName);
-        const archive = await readFile(join(tempRoot, filename));
-        const manifestPath = `package/${options.candidate.manifest.replace(/^\.\//, "")}`;
-        const rawManifest = readTarEntry(archive, manifestPath);
-        const descriptor = parseModuleDescriptor(parseJson(rawManifest.toString("utf8"), `${options.candidate.packageName} module manifest`));
-        if (descriptor.packageName !== options.candidate.packageName ||
-            descriptor.moduleVersion !== options.candidate.moduleVersion) {
-            throw new PlatformError("REGISTRY_RESPONSE_INVALID", `Registry manifest identity/version mismatch for ${options.candidate.packageName}@${options.candidate.moduleVersion}`);
-        }
-        return descriptor;
-    }
-    finally {
-        await rm(tempRoot, { recursive: true, force: true });
-    }
-}
-function packFilename(stdout, packageName) {
-    const parsed = parseJson(stdout, `npm pack ${packageName}`);
-    if (!Array.isArray(parsed) || parsed.length !== 1 || !isRecord(parsed[0])) {
-        throw new PlatformError("REGISTRY_RESPONSE_INVALID", `npm pack response is invalid for ${packageName}`);
-    }
-    const filename = parsed[0].filename;
-    if (typeof filename !== "string" ||
-        filename === "" ||
-        filename.includes("/") ||
-        filename.includes("\\")) {
-        throw new PlatformError("REGISTRY_RESPONSE_INVALID", `npm pack filename is invalid for ${packageName}`);
-    }
-    return filename;
-}
-function readTarEntry(tgz, targetName) {
-    let tar;
-    try {
-        tar = gunzipSync(tgz);
-    }
-    catch {
-        throw new PlatformError("REGISTRY_RESPONSE_INVALID", "npm package tarball is not valid gzip");
-    }
-    for (let offset = 0; offset + 512 <= tar.length;) {
-        const header = tar.subarray(offset, offset + 512);
-        if (header.every((byte) => byte === 0))
-            break;
-        const name = tarString(header, 0, 100);
-        const prefix = tarString(header, 345, 155);
-        const entryName = prefix === "" ? name : `${prefix}/${name}`;
-        const sizeRaw = tarString(header, 124, 12).trim();
-        const size = sizeRaw === "" ? 0 : Number.parseInt(sizeRaw, 8);
-        if (!Number.isSafeInteger(size) || size < 0) {
-            throw new PlatformError("REGISTRY_RESPONSE_INVALID", "npm package tarball has an invalid entry size");
-        }
-        const dataStart = offset + 512;
-        const dataEnd = dataStart + size;
-        if (dataEnd > tar.length) {
-            throw new PlatformError("REGISTRY_RESPONSE_INVALID", "npm package tarball is truncated");
-        }
-        if (entryName === targetName) {
-            if (size > 1024 * 1024) {
-                throw new PlatformError("REGISTRY_RESPONSE_INVALID", "ProFlow module manifest exceeds 1 MiB");
-            }
-            return tar.subarray(dataStart, dataEnd);
-        }
-        offset = dataStart + Math.ceil(size / 512) * 512;
-    }
-    throw new PlatformError("REGISTRY_RESPONSE_INVALID", `npm package tarball does not contain ${targetName}`);
-}
-function tarString(header, start, length) {
-    const field = header.subarray(start, start + length);
-    const end = field.indexOf(0);
-    return field.subarray(0, end < 0 ? field.length : end).toString("utf8");
-}
-export async function discoverRegistryInstallClosure(options) {
-    const runner = options.runner ?? systemNpmRunner();
-    const queue = [validateRequestedPackageName(options.packageName)];
-    const seen = new Set();
-    const candidates = new Map();
-    const rejected = new Map();
-    let registry;
-    while (queue.length > 0) {
-        const packageName = queue.shift();
-        if (!packageName)
-            continue;
-        if (seen.has(packageName))
-            continue;
-        seen.add(packageName);
-        const discovered = await discoverRegistryModules({
-            workspaceRoot: options.workspaceRoot,
-            packageName,
-            runner,
-            ...(options.nodeVersion === undefined
-                ? {}
-                : { nodeVersion: options.nodeVersion }),
-        });
-        registry ??= discovered.registry;
-        for (const item of discovered.rejected)
-            rejected.set(item.packageName, item);
-        const candidate = discovered.candidates[0];
-        if (candidate === undefined) {
-            throw new PlatformError("PACKAGE_NOT_PROFLOW", `package ${packageName} is not an installable ProFlow module`);
-        }
-        candidates.set(candidate.packageName, candidate);
-        for (const dependency of candidate.installRequires) {
-            if (!seen.has(dependency))
-                queue.push(dependency);
-        }
-    }
-    if (registry === undefined) {
-        registry = await resolveScopeRegistry(options.workspaceRoot, runner);
-    }
-    return {
-        registry,
-        candidates: [...candidates.values()].sort((a, b) => a.packageName.localeCompare(b.packageName)),
-        rejected: [...rejected.values()].sort((a, b) => a.packageName.localeCompare(b.packageName)),
-    };
-}
 async function searchPackageNames(workspaceRoot, registry, runner) {
     const result = await runner.run([
         "search",
@@ -273,10 +144,8 @@ function assessManifest(manifest, registry, nodeVersion) {
             ...(typeof manifest.description === "string"
                 ? { description: manifest.description }
                 : {}),
-            installClass: metadata.data.installClass,
             descriptor: metadata.data.descriptor,
             manifest: metadata.data.manifest,
-            installRequires: [...metadata.data.installRequires],
             ...(nodeVersionRange === undefined ? {} : { nodeVersionRange }),
             registry,
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomflow/proflow-platform-cli",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -21,13 +21,13 @@
     "README.md"
   ],
   "dependencies": {
-    "@tomflow/proflow-module-contract": "^0.1.1"
+    "@tomflow/proflow-module-contract": "^0.1.3"
   },
   "devDependencies": {
-    "@tomflow/proflow-deployment-conformance": "^0.1.2",
-    "@tomflow/proflow-module-template": "^0.1.2"
+    "@tomflow/proflow-deployment-conformance": "^0.1.3",
+    "@tomflow/proflow-module-template": "^0.1.3"
   },
-  "description": "Deterministic platform-level deployment discovery, planning, lifecycle and verification CLI.",
+  "description": "Thin Platform CLI for Module discovery, documentation, package synchronization and lifecycle orchestration.",
   "keywords": [
     "proflow",
     "proflow-module",
@@ -35,10 +35,6 @@
   ],
   "proflow": {
     "module": true,
-    "installClass": "core",
-    "installRequires": [
-      "@tomflow/proflow-module-contract"
-    ],
     "descriptor": "./dist/deployment/descriptor.js",
     "manifest": "./proflow.module.json"
   },

package/proflow.module.json

@@ -3,14 +3,13 @@
 	"contractVersion": "1.0.0",
 	"moduleRef": "platform-cli",
 	"packageName": "@tomflow/proflow-platform-cli",
-	"moduleVersion": "0.1.14",
+	"moduleVersion": "0.1.16",
 	"kind": "cli",
 	"templateVersion": "1.0.0",
 	"platformCompatibility": ">=1.0.0 <2.0.0",
-	"installClass": "core",
 	"identity": {
 		"domain": "deployment-governance",
-		"summary": "Deterministic platform-level deployment discovery, planning, lifecycle and verification CLI."
+		"summary": "Thin Platform CLI for Module discovery, documentation, package synchronization and lifecycle orchestration."
 	},
 	"provides": [],
 	"requires": [],

package/CHANGELOG.md

@@ -1,85 +0,0 @@
-# @tomflow/proflow-platform-cli
-
-## 0.1.14
-
-### Patch Changes
-
-- Gate `platform start` on managed preflight, make platform-level `restart` a stop-then-start sequence without an extra preflight, and render lifecycle / verify / doctor results clearly for human users.
-
-## 0.1.13
-
-### Patch Changes
-
-- Fully clean Workspace uninstall artifacts by removing empty ProFlow layout directories and stale pnpm release-age entries across prior managed versions.
-
-## 0.1.12
-
-### Patch Changes
-
-- Clean pnpm release-age and empty-root lockfile artifacts after whole Workspace uninstall, and remove the `.proflow` root only when it is empty while preserving non-deployment data.
-
-## 0.1.11
-
-### Patch Changes
-
-- Use pnpm's global config form to disable scripts during package removal so Workspace uninstall works on pnpm 11.
-
-## 0.1.10
-
-### Patch Changes
-
-- Fail closed on malformed persisted module config instead of treating it as missing configuration.
-
-## 0.1.9
-
-### Patch Changes
-
-- Clarify whole-instance uninstall preservation boundaries in public CLI help and package documentation.
-
-## 0.1.8
-
-### Patch Changes
-
-- Align human-action completion across Apply resume, preflight, and manifest current reality by treating the latest current-version verification PASS as the durable completion proof while preserving append-only deployment history.
-
-## 0.1.7
-
-### Patch Changes
-
-- Rebuild upgrade apply staleness from the current persisted Workspace configuration so unchanged config remains fresh while configuration drift becomes PLAN_STALE instead of being misreported as missing required config.
-
-## 0.1.6
-
-### Patch Changes
-
-- Carry persisted workspace configuration into Registry-backed upgrade planning, with explicit --config values overlaying stored values, so newly published descriptors cannot falsely report existing required configuration as missing before package mutation.
-
-## 0.1.5
-
-### Patch Changes
-
-- Preserve module-provided ACTION_REQUIRED descriptions in startup preflight findings so missing Role readiness tells the user the missing registration fact, next action, and revalidation command.
-
-## 0.1.4
-
-### Patch Changes
-
-- Make upgrade planning emit configuration writes only when a real config target exists, and fail before package mutation when new required configuration is missing.
-
-## 0.1.3
-
-### Patch Changes
-
-- Real-1 final remediation and black-box release closure
-
-## 0.1.2
-
-### Patch Changes
-
-- Close the Real-1 global Platform control-plane contract across every published ProFlow package. Platform CLI now owns one durable global Workspace binding with canonical identity, cross-process operation locking, cwd/`--workspace` install targeting, cross-directory instance commands, whole-instance uninstall/rebind, and deterministic npm/yarn/pnpm Workspace package-manager selection. Every package-owned install entry, including newly generated Module Template packages, delegates to the Shell-global `platform` command and fails closed when that global CLI is unavailable; Deployment Conformance and the formal test plans mechanically enforce the same rule across all 24 packages.
-
-## 0.1.1
-
-### Patch Changes
-
-- Read installed package versions directly from the Workspace `node_modules` package manifest so postcondition checks cannot reuse stale Node module-resolution cache entries after an in-process package upgrade.

package/dist/src/apply/apply.d.ts

@@ -1,26 +0,0 @@
-import type { ApplyResult } from "../contracts.ts";
-import type { ModuleCatalog } from "../modules.ts";
-import { type WorkspacePaths } from "../paths.ts";
-import { type PlanInput } from "../planner/index.ts";
-import type { PackageManagerDriver } from "./driver.ts";
-import type { RealityObserver } from "./reality.ts";
-export interface ApplyContext {
-    paths: WorkspacePaths;
-    planRef: string;
-    catalog: ModuleCatalog;
-    /** Current stable assumptions the plan must still match (staleness gate). */
-    current: PlanInput;
-    driver: PackageManagerDriver;
-    observer?: RealityObserver;
-    /** Rebuilds installed descriptors/bindings after a package mutation. */
-    refreshCatalog?: () => Promise<ModuleCatalog>;
-}
-/**
- * Applies a frozen deployment plan deterministically. Every step is re-checked
- * against current reality before any action: satisfied steps SKIP, human steps
- * and ACTION_REQUIRED mutations persist a structured pendingAction and STOP with
- * ACTION_REQUIRED, a BLOCKED/FAILED mutation STOPs with the matching outcome,
- * and only a fully applied plan is recorded in `lastAppliedPlans`. The exclusive
- * workspace lock is released in all paths.
- */
-export declare function applyPlan(context: ApplyContext): Promise<ApplyResult>;

package/dist/src/apply/apply.js

@@ -1,314 +0,0 @@
-import { PlatformError } from "../errors.js";
-import { ensureLayout } from "../paths.js";
-import { emptyDeploymentState, loadDeploymentState, loadPlan, saveDeploymentState, } from "../persistence/index.js";
-import { checkPlanStale, ExecuteStrategy, evaluateStepCheck, } from "../planner/index.js";
-import { acquireWorkspaceLock } from "../security/index.js";
-import { executeStep } from "./execute.js";
-import { createRealityObserver } from "./reality.js";
-function nowIso() {
-    return new Date().toISOString();
-}
-function failureMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-/**
- * Applies a frozen deployment plan deterministically. Every step is re-checked
- * against current reality before any action: satisfied steps SKIP, human steps
- * and ACTION_REQUIRED mutations persist a structured pendingAction and STOP with
- * ACTION_REQUIRED, a BLOCKED/FAILED mutation STOPs with the matching outcome,
- * and only a fully applied plan is recorded in `lastAppliedPlans`. The exclusive
- * workspace lock is released in all paths.
- */
-export async function applyPlan(context) {
-    const driver = context.driver;
-    let catalog = context.catalog;
-    let observer = context.observer ??
-        createRealityObserver({
-            paths: context.paths,
-            catalog,
-            driver,
-        });
-    await ensureLayout(context.paths);
-    const lock = await acquireWorkspaceLock(context.paths, context.planRef);
-    try {
-        const plan = await loadPlan(context.paths, context.planRef);
-        if (plan === undefined) {
-            throw new PlatformError("PLAN_NOT_FOUND", `plan ${context.planRef} not found`);
-        }
-        const staleness = checkPlanStale(plan, context.current);
-        if (staleness.stale) {
-            return {
-                planRef: plan.planRef,
-                outcome: "BLOCKED",
-                stepResults: [],
-                completedAt: nowIso(),
-            };
-        }
-        const state = (await loadDeploymentState(context.paths)) ?? emptyDeploymentState();
-        const stepResults = [];
-        for (const step of plan.steps) {
-            const reality = await observer.observe(step, plan);
-            if (reality === undefined) {
-                // UNKNOWN: current reality could not be observed. Stop without
-                // replaying any lifecycle/external effect, then doctor/repair.
-                stepResults.push({
-                    stepRef: step.stepRef,
-                    moduleRef: step.moduleRef,
-                    status: "FAILED",
-                    message: `blocked: current reality for ${step.moduleRef} could not be observed`,
-                });
-                state.updatedAt = nowIso();
-                await saveDeploymentState(context.paths, state);
-                return {
-                    planRef: plan.planRef,
-                    outcome: "BLOCKED",
-                    stepResults,
-                    completedAt: nowIso(),
-                };
-            }
-            const check = evaluateStepCheck(step, plan, reality);
-            if (check.status === "SATISFIED") {
-                // A previously-pending action for this step can no longer block a
-                // resume: the step is satisfied in current reality, so clear it.
-                state.pendingActions = state.pendingActions.filter((pending) => !(pending.planRef === plan.planRef &&
-                    pending.stepRef === step.stepRef));
-                stepResults.push({
-                    stepRef: step.stepRef,
-                    moduleRef: step.moduleRef,
-                    status: "SKIP",
-                    message: check.reason,
-                });
-                continue;
-            }
-            if (step.kind === "human") {
-                const completedAt = nowIso();
-                state.pendingActions.push({
-                    planRef: plan.planRef,
-                    stepRef: step.stepRef,
-                    moduleRef: step.moduleRef,
-                    action: step.expectedEffect,
-                    createdAt: completedAt,
-                });
-                state.updatedAt = completedAt;
-                await saveDeploymentState(context.paths, state);
-                stepResults.push({
-                    stepRef: step.stepRef,
-                    moduleRef: step.moduleRef,
-                    status: "ACTION_REQUIRED",
-                    message: check.reason,
-                });
-                return {
-                    planRef: plan.planRef,
-                    outcome: "ACTION_REQUIRED",
-                    stepResults,
-                    completedAt,
-                };
-            }
-            let outcome;
-            try {
-                outcome = await executeStep({ paths: context.paths, catalog, driver }, step, plan);
-            }
-            catch (error) {
-                stepResults.push({
-                    stepRef: step.stepRef,
-                    moduleRef: step.moduleRef,
-                    status: "FAILED",
-                    message: failureMessage(error),
-                });
-                state.updatedAt = nowIso();
-                await saveDeploymentState(context.paths, state);
-                return {
-                    planRef: plan.planRef,
-                    outcome: "FAILED",
-                    stepResults,
-                    completedAt: nowIso(),
-                };
-            }
-            switch (outcome.kind) {
-                case "SUCCEEDED": {
-                    if (step.executeStrategy === ExecuteStrategy.lifecycleUninstall) {
-                        // A lifecycle uninstall is owned by the module adapter. Its typed
-                        // SUCCEEDED result is the authoritative teardown confirmation. An
-                        // idempotent uninstall can legitimately leave status UNBOUND/UNKNOWN,
-                        // so a second status probe must not reinterpret that successful
-                        // teardown as a failed lifecycle:stopped postcondition.
-                        stepResults.push({
-                            stepRef: step.stepRef,
-                            moduleRef: step.moduleRef,
-                            status: "EXECUTED",
-                            message: `${step.moduleRef} owner confirmed lifecycle uninstall`,
-                        });
-                        break;
-                    }
-                    // Postcondition re-check: only a genuinely successful mutation is
-                    // confirmed; an effect that cannot be confirmed stops the apply
-                    // rather than blindly repeating it.
-                    const postReality = await observer.observe(step, plan);
-                    if (postReality === undefined) {
-                        stepResults.push({
-                            stepRef: step.stepRef,
-                            moduleRef: step.moduleRef,
-                            status: "FAILED",
-                            message: `blocked: postcondition reality for ${step.moduleRef} could not be observed`,
-                        });
-                        state.updatedAt = nowIso();
-                        await saveDeploymentState(context.paths, state);
-                        return {
-                            planRef: plan.planRef,
-                            outcome: "BLOCKED",
-                            stepResults,
-                            completedAt: nowIso(),
-                        };
-                    }
-                    const post = evaluateStepCheck(step, plan, postReality);
-                    if (post.status !== "SATISFIED") {
-                        stepResults.push({
-                            stepRef: step.stepRef,
-                            moduleRef: step.moduleRef,
-                            status: "FAILED",
-                            message: `postcondition not satisfied after execution: ${post.reason}`,
-                        });
-                        state.updatedAt = nowIso();
-                        await saveDeploymentState(context.paths, state);
-                        return {
-                            planRef: plan.planRef,
-                            outcome: "FAILED",
-                            stepResults,
-                            completedAt: nowIso(),
-                        };
-                    }
-                    stepResults.push({
-                        stepRef: step.stepRef,
-                        moduleRef: step.moduleRef,
-                        status: "EXECUTED",
-                        message: post.reason,
-                    });
-                    if (step.kind === "package" && context.refreshCatalog !== undefined) {
-                        try {
-                            catalog = await context.refreshCatalog();
-                            if (context.observer === undefined) {
-                                observer = createRealityObserver({
-                                    paths: context.paths,
-                                    catalog,
-                                    driver,
-                                });
-                            }
-                        }
-                        catch (error) {
-                            stepResults.push({
-                                stepRef: step.stepRef,
-                                moduleRef: step.moduleRef,
-                                status: "FAILED",
-                                message: `post-package catalog refresh failed: ${failureMessage(error)}`,
-                            });
-                            state.updatedAt = nowIso();
-                            await saveDeploymentState(context.paths, state);
-                            return {
-                                planRef: plan.planRef,
-                                outcome: "FAILED",
-                                stepResults,
-                                completedAt: nowIso(),
-                            };
-                        }
-                    }
-                    break;
-                }
-                case "ACTION_REQUIRED": {
-                    const completedAt = nowIso();
-                    state.pendingActions.push({
-                        planRef: plan.planRef,
-                        stepRef: step.stepRef,
-                        moduleRef: step.moduleRef,
-                        action: outcome.actionRequired.action,
-                        description: outcome.actionRequired.description,
-                        createdAt: completedAt,
-                    });
-                    state.updatedAt = completedAt;
-                    await saveDeploymentState(context.paths, state);
-                    stepResults.push({
-                        stepRef: step.stepRef,
-                        moduleRef: step.moduleRef,
-                        status: "ACTION_REQUIRED",
-                        message: outcome.actionRequired.action,
-                    });
-                    return {
-                        planRef: plan.planRef,
-                        outcome: "ACTION_REQUIRED",
-                        stepResults,
-                        completedAt,
-                    };
-                }
-                case "BLOCKED": {
-                    stepResults.push({
-                        stepRef: step.stepRef,
-                        moduleRef: step.moduleRef,
-                        status: "FAILED",
-                        message: `blocked: ${outcome.reason}`,
-                    });
-                    state.updatedAt = nowIso();
-                    await saveDeploymentState(context.paths, state);
-                    return {
-                        planRef: plan.planRef,
-                        outcome: "BLOCKED",
-                        stepResults,
-                        completedAt: nowIso(),
-                    };
-                }
-                case "FAILED": {
-                    stepResults.push({
-                        stepRef: step.stepRef,
-                        moduleRef: step.moduleRef,
-                        status: "FAILED",
-                        message: outcome.reason,
-                    });
-                    state.updatedAt = nowIso();
-                    await saveDeploymentState(context.paths, state);
-                    return {
-                        planRef: plan.planRef,
-                        outcome: "FAILED",
-                        stepResults,
-                        completedAt: nowIso(),
-                    };
-                }
-            }
-        }
-        const completedAt = nowIso();
-        if (plan.intent === "uninstall") {
-            const removed = new Set(plan.resolvedModules.map((module) => module.moduleRef));
-            state.selectedModules = state.selectedModules.filter((module) => !removed.has(module.moduleRef));
-        }
-        else if ((plan.intent === "install" || plan.intent === "upgrade") &&
-            plan.resolvedModules.every((module) => module.source.type === "registry")) {
-            const byRef = new Map(state.selectedModules.map((module) => [module.moduleRef, module]));
-            for (const module of plan.resolvedModules) {
-                byRef.set(module.moduleRef, {
-                    moduleRef: module.moduleRef,
-                    moduleVersion: module.moduleVersion,
-                });
-            }
-            state.selectedModules = [...byRef.values()].sort((left, right) => left.moduleRef.localeCompare(right.moduleRef));
-        }
-        else {
-            state.selectedModules = plan.resolvedModules.map((module) => ({
-                moduleRef: module.moduleRef,
-                moduleVersion: module.moduleVersion,
-            }));
-        }
-        state.lastAppliedPlans.push({
-            planRef: plan.planRef,
-            intent: plan.intent,
-            appliedAt: completedAt,
-        });
-        state.updatedAt = completedAt;
-        await saveDeploymentState(context.paths, state);
-        return {
-            planRef: plan.planRef,
-            outcome: "COMPLETE",
-            stepResults,
-            completedAt,
-        };
-    }
-    finally {
-        await lock.release();
-    }
-}

package/dist/src/apply/cleanup.d.ts

@@ -1,12 +0,0 @@
-import type { DeploymentEffect } from "@tomflow/proflow-module-contract";
-/**
- * Removes only package-declared ephemeral filesystem effects under the
- * Workspace-owned `.proflow` state tree. Persistent and explicit-purge effects
- * are never deleted by ordinary uninstall. Paths outside `.proflow` are left to
- * the package-owned uninstall adapter so a descriptor can never turn the
- * platform package manager into an arbitrary recursive-delete primitive.
- */
-export declare function cleanupRemovableFilesystemEffects(input: {
-    workspaceRoot: string;
-    effects: readonly DeploymentEffect[];
-}): Promise<string[]>;