agentera 3.0.0-dev.4 → 3.0.0-dev.46

package/dist/upgrade/migrateArtifactsV2ToV3.js

@@ -1,16 +1,24 @@
 import fs from "node:fs";
 import path from "node:path";
+import YAML from "yaml";
 import { isFile, pathExists, resolvePath } from "../core/paths.js";
+import { loadYamlMapping } from "../core/yaml.js";
+import { loadArtifactRecord, resolveArtifactPath } from "../registries/artifactRegistry.js";
 import { BUNDLE_MARKER } from "../state/installRoot.js";
+import { hasBundleRootEvidence } from "./bundleEvidence.js";
+import { applyAppContentRefreshItems, planAppContentRefreshItems, } from "./appContentRefresh.js";
 import { doctorRoots } from "./appModel.js";
-import { AGENTERA_USER_STATE_NAMES, ROOT_USER_STATE_DIR_NAMES, ROOT_USER_STATE_FILE_NAMES, } from "./doctor.js";
-import { applyV1ArtifactsPhase, planV1ArtifactsPhase, } from "./migrateArtifactsV1ToV2.js";
-import { applyRuntimeMigrationItems, planRuntimeMigrationItems, resolveNpxHookCommands, rewireRuntimeText, } from "./runtimeMigration.js";
+import { AGENTERA_USER_STATE_NAMES, } from "./doctor.js";
+import { appHomeHasUnrecognizedEntriesWithPreflight, handoffCatalogMessage, resolveMigrationUserStatePreflight, } from "../migrate/v2HandoffManifest.js";
+import { applyLegacyAgentCleanupItems, planLegacyAgentCleanupItems, planLegacyCapabilityAgentCleanupItems, } from "./legacyAgentCleanup.js";
+import { applyRuntimeMigrationItems, planRuntimeMigrationItems, } from "./runtimeMigration.js";
+import { writeFileAtomic } from "./atomicWriter.js";
+import { bindMigrationTree, cloneMigrationItem, removeBoundMigrationTree } from "./migrationPublication.js";
+import { applyInstalledHooksRetirementItems, planInstalledHooksRetirementItems, } from "./installedHooksRetirement.js";
 /**
  * v2→v3 migration phases: artifacts (noop for YAML), runtime rewire, cleanup.
- * v1 Markdown→YAML migration stays separate (prime.ts V1_ARTIFACT_PAIRS).
  */
-export const MIGRATION_STATUSES = ["pending", "applied", "noop", "blocked", "failed", "skipped"];
+export const MIGRATION_STATUSES = ["pending", "applied", "noop", "blocked", "failed"];
 export const V1_ARTIFACT_PAIRS = [
     [".agentera/PROGRESS.md", ".agentera/progress.yaml"],
     [".agentera/PLAN.md", ".agentera/plan.yaml"],
@@ -19,15 +27,133 @@ export const V1_ARTIFACT_PAIRS = [
     [".agentera/DOCS.md", ".agentera/docs.yaml"],
     ["VISION.md", ".agentera/vision.yaml"],
 ];
-/** Default development-channel npm entrypoint for tests and legacy imports. */
-export const NPX_CLI_ENTRYPOINT = "npx -y agentera@next";
-export const NPX_HOOK_VALIDATE = `${NPX_CLI_ENTRYPOINT} hook validate-artifact`;
-export const NPX_HOOK_CURSOR_SESSION_START = `${NPX_CLI_ENTRYPOINT} hook cursor-session-start`;
-export const NPX_HOOK_CURSOR_SESSION_STOP = `${NPX_CLI_ENTRYPOINT} hook session-stop`;
-export const NPX_HOOK_CURSOR_PRE_TOOL = `${NPX_CLI_ENTRYPOINT} hook cursor-pre-tool-use`;
-export { rewireRuntimeText, resolveNpxHookCommands };
+const PLAN_ARCHIVE_FILE = /^PLAN-.+\.ya?ml$/i;
+const PLAN_LIFECYCLE_ACTION = "normalize-plan-lifecycle";
+function isMapping(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function relativeToProject(project, artifactPath) {
+    return path.relative(project, artifactPath);
+}
+function planTaskList(data) {
+    if (Array.isArray(data.tasks))
+        return data.tasks;
+    if (Array.isArray(data.entries))
+        return data.entries;
+    return null;
+}
+function completedTasksOnly(tasks) {
+    return tasks.every((task) => isMapping(task) && (task.status === "complete" || task.status === "completed"));
+}
+function rewritePlanStatus(text, status) {
+    const document = YAML.parseDocument(text);
+    if (document.errors.length > 0) {
+        throw new Error(document.errors.map((error) => error.message).join("; "));
+    }
+    document.setIn(["header", "status"], status);
+    return document.toString();
+}
+function lifecycleMigrationItem(project, artifactPath) {
+    const source = relativeToProject(project, artifactPath);
+    try {
+        const text = fs.readFileSync(artifactPath, "utf8");
+        const data = loadYamlMapping(text);
+        const header = isMapping(data.header) ? data.header : null;
+        const tasks = planTaskList(data);
+        if (!header || tasks === null) {
+            return {
+                status: "blocked",
+                action: PLAN_LIFECYCLE_ACTION,
+                source,
+                target: source,
+                message: "plan requires a header mapping and a tasks or entries array before lifecycle migration",
+            };
+        }
+        const status = typeof header.status === "string" ? header.status : "";
+        if (status === "open" || status === "complete") {
+            return {
+                status: "noop",
+                action: PLAN_LIFECYCLE_ACTION,
+                source,
+                target: source,
+                preserved: ["all plan fields"],
+                message: "plan lifecycle is already canonical",
+            };
+        }
+        if (status !== "active" && status !== "completed") {
+            return {
+                status: "blocked",
+                action: PLAN_LIFECYCLE_ACTION,
+                source,
+                target: source,
+                message: `plan header.status must be active, completed, open, or complete; received ${status || "missing"}`,
+            };
+        }
+        const collisions = [];
+        const targetStatus = status === "active" || !completedTasksOnly(tasks)
+            ? "open"
+            : "complete";
+        if (status === "completed" && targetStatus === "open") {
+            collisions.push("header.status=completed conflicts with unfinished task evidence; preserving task evidence and migrating status to open");
+        }
+        return {
+            status: "pending",
+            action: PLAN_LIFECYCLE_ACTION,
+            source,
+            target: source,
+            preserved: ["all plan fields except header.status"],
+            ...(collisions.length > 0 ? { collisions } : {}),
+            newText: rewritePlanStatus(text, targetStatus),
+            message: `will migrate plan lifecycle ${status} to ${targetStatus}`,
+        };
+    }
+    catch (error) {
+        return {
+            status: "blocked",
+            action: PLAN_LIFECYCLE_ACTION,
+            source,
+            target: source,
+            message: `cannot migrate plan lifecycle: ${error.message}`,
+        };
+    }
+}
+function lifecyclePlanArtifacts(project) {
+    const root = resolvePath(project);
+    let activePath;
+    try {
+        const record = loadArtifactRecord("plan");
+        if (!record)
+            throw new Error("plan artifact is not registered");
+        activePath = resolveArtifactPath(record, root, { strictWrite: true });
+    }
+    catch (error) {
+        return [{
+                status: "blocked",
+                action: PLAN_LIFECYCLE_ACTION,
+                message: `cannot resolve docs-mapped plan path: ${error.message}`,
+            }];
+    }
+    const artifacts = isFile(activePath) ? [activePath] : [];
+    const archiveDirectory = path.join(path.dirname(activePath), "archive");
+    try {
+        for (const name of fs.readdirSync(archiveDirectory).sort()) {
+            if (!PLAN_ARCHIVE_FILE.test(name))
+                continue;
+            const archivePath = path.join(archiveDirectory, name);
+            if (isFile(archivePath))
+                artifacts.push(archivePath);
+        }
+    }
+    catch {
+        // A missing archive directory is normal before the first archive.
+    }
+    return artifacts.map((artifactPath) => lifecycleMigrationItem(root, artifactPath));
+}
+export function hasPendingPlanLifecycleMigration(project) {
+    return lifecyclePlanArtifacts(project).some((item) => item.status === "pending");
+}
 function emptySummary() {
-    return { pending: 0, applied: 0, noop: 0, blocked: 0, failed: 0, skipped: 0 };
+    return { pending: 0, applied: 0, noop: 0, blocked: 0, failed: 0 };
 }
 export function summarizePhase(name, items, message = "") {
     const summary = emptySummary();
@@ -47,9 +173,6 @@ export function summarizePhase(name, items, message = "") {
     else if (summary.applied > 0) {
         status = "applied";
     }
-    else if (summary.skipped > 0 && summary.noop === 0 && summary.applied === 0) {
-        status = "skipped";
-    }
     else {
         status = "noop";
     }
@@ -96,35 +219,88 @@ export function planArtifactsPhase(project) {
         ]);
     }
     const v1Pairs = detectV1ArtifactPairs(root);
-    if (v1Pairs.length > 0) {
-        return planV1ArtifactsPhase(root);
-    }
+    const v1Items = v1Pairs.map((source) => ({
+        status: "blocked",
+        action: "manual-v1-handoff",
+        source,
+        message: "v1 Markdown state is unsupported; convert it with a v2 CLI before running the v2-to-v3 upgrade",
+    }));
     const yamlArtifacts = listV2YamlArtifacts(root);
-    if (yamlArtifacts.length === 0) {
+    const lifecycleItems = lifecyclePlanArtifacts(root);
+    if (yamlArtifacts.length === 0 && v1Items.length === 0 && lifecycleItems.length === 0) {
         return summarizePhase("artifacts", [], "no project artifacts found");
     }
-    const items = yamlArtifacts.map((source) => ({
-        status: "noop",
-        action: "preserve",
-        source,
-        message: "v2 YAML artifact preserved; no v2→v3 schema migration required",
-    }));
+    const lifecycleSources = new Set(lifecycleItems.flatMap((item) => item.source ? [item.source] : []));
+    const items = [
+        ...v1Items,
+        ...yamlArtifacts.filter((source) => !lifecycleSources.has(source)).map((source) => ({
+            status: "noop",
+            action: "preserve",
+            source,
+            message: "v2 YAML artifact preserved; no v2→v3 schema migration required",
+        })),
+        ...lifecycleItems,
+    ];
     return summarizePhase("artifacts", items);
 }
-export function applyArtifactsPhase(phase, project, force = false) {
+export function applyArtifactsPhase(phase, project, _force = false) {
     const root = resolvePath(project);
-    const hasV1Migration = phase.items.some((item) => item.action === "migrate");
-    if (hasV1Migration) {
-        applyV1ArtifactsPhase(phase, root, force);
-        return;
+    for (const item of phase.items) {
+        if (item.status !== "pending" || item.action !== PLAN_LIFECYCLE_ACTION || !item.source)
+            continue;
+        const sourcePath = path.join(root, item.source);
+        const current = lifecycleMigrationItem(root, sourcePath);
+        if (current.status !== "pending") {
+            item.status = current.status;
+            item.message = current.message;
+            item.collisions = current.collisions;
+            continue;
+        }
+        if (current.newText !== item.newText) {
+            item.status = "blocked";
+            item.message = "plan changed after migration preview; rerun dry-run before applying";
+            continue;
+        }
+        try {
+            writeFileAtomic(sourcePath, current.newText, "utf8");
+            item.status = "applied";
+            item.message = "migrated plan lifecycle without changing retained evidence";
+        }
+        catch (error) {
+            item.status = "failed";
+            item.message = `plan lifecycle migration failed: ${error.message}`;
+        }
+    }
+    const updated = summarizePhase("artifacts", phase.items, phase.message);
+    phase.status = updated.status;
+    phase.summary = updated.summary;
+}
+export function delegatePlanLifecycleToEntityCutover(phase) {
+    for (const item of phase.items) {
+        if (item.status !== "pending" || item.action !== PLAN_LIFECYCLE_ACTION)
+            continue;
+        item.status = "noop";
+        item.message = "entity cutover normalizes plan lifecycle while retaining the legacy source as recovery evidence";
     }
-    phase.status = summarizePhase("artifacts", phase.items, phase.message).status;
+    const updated = summarizePhase("artifacts", phase.items, phase.message);
+    phase.status = updated.status;
+    phase.summary = updated.summary;
 }
-export function planRuntimeRewirePhase(ctx) {
+export function planRuntimeRetirementPhase(ctx, _resolvedChannel) {
     const items = planRuntimeMigrationItems(ctx);
-    return summarizePhase("runtime", items, items.length === 0 ? "no runtime configs with Python managed app-home references found" : "");
+    const blockedPaths = new Set(items
+        .filter((item) => item.status === "blocked")
+        .flatMap((item) => [item.source, item.target])
+        .filter((value) => typeof value === "string"));
+    for (const item of items) {
+        if (item.status !== "pending" || ![item.source, item.target].some((value) => value && blockedPaths.has(value)))
+            continue;
+        item.status = "blocked";
+        item.message = "action required before Agentera can modify this runtime resource";
+    }
+    return summarizePhase("runtime", items, items.length === 0 ? "no retired native Agentera hooks found" : "");
 }
-export function applyRuntimeRewirePhase(phase, ctx) {
+export function applyRuntimeRetirementPhase(phase, ctx) {
     if (ctx) {
         applyRuntimeMigrationItems(phase.items, ctx);
     }
@@ -139,60 +315,74 @@ export function applyRuntimeRewirePhase(phase, ctx) {
     phase.status = updated.status;
     phase.summary = updated.summary;
 }
-function agenteraUserStateDirIsRecognized(dir) {
-    if (!pathExists(dir) || !fs.statSync(dir).isDirectory()) {
-        return false;
-    }
-    for (const entry of fs.readdirSync(dir)) {
-        const full = path.join(dir, entry);
-        const st = fs.statSync(full);
-        if (AGENTERA_USER_STATE_NAMES.has(entry) && st.isFile()) {
-            continue;
-        }
-        if (entry === "optimera" && st.isDirectory()) {
-            continue;
-        }
+/** Whether `app/` under app-home still carries a managed bundle worth removing during v2→v3 cleanup. */
+export function hasManagedBundleEvidence(managedAppRoot) {
+    const marker = path.join(managedAppRoot, BUNDLE_MARKER);
+    if (!isFile(marker))
         return false;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(marker, "utf8"));
+        return parsed.schemaVersion === "agentera.bundle.v1" && typeof parsed.version === "string";
     }
-    return true;
-}
-function isPreservedUserStateEntry(appHome, entry) {
-    const full = path.join(appHome, entry);
-    if (!pathExists(full)) {
+    catch {
         return false;
     }
-    const st = fs.statSync(full);
-    if (ROOT_USER_STATE_FILE_NAMES.has(entry) && st.isFile()) {
-        return true;
-    }
-    if (ROOT_USER_STATE_DIR_NAMES.has(entry) && st.isDirectory()) {
-        return true;
-    }
-    if (entry === ".agentera" && agenteraUserStateDirIsRecognized(full)) {
-        return true;
-    }
-    return false;
 }
-function listPreservedUserStatePaths(appHome) {
-    const preserved = [];
-    for (const entry of listPreservedUserState(appHome)) {
-        const full = path.join(appHome, entry);
-        preserved.push(full);
-        if (entry === ".agentera" && pathExists(full) && fs.statSync(full).isDirectory()) {
-            for (const name of AGENTERA_USER_STATE_NAMES) {
-                const nested = path.join(full, name);
-                if (isFile(nested)) {
-                    preserved.push(nested);
-                }
-            }
+const SUPPORTED_V2_BUNDLE_INVENTORY_BY_MAJOR = {
+    "2": {
+        [BUNDLE_MARKER]: "file",
+        "registry.json": "file",
+        scripts: "directory",
+        "scripts/agentera": "file",
+        skills: "directory",
+        "skills/agentera": "directory",
+        "skills/agentera/SKILL.md": "file",
+    },
+};
+function markedBundleInventoryViolations(managedAppRoot) {
+    let version;
+    try {
+        const marker = JSON.parse(fs.readFileSync(path.join(managedAppRoot, BUNDLE_MARKER), "utf8"));
+        version = typeof marker.version === "string" ? marker.version : "";
+    }
+    catch {
+        return ["bundle marker is unreadable"];
+    }
+    const inventory = SUPPORTED_V2_BUNDLE_INVENTORY_BY_MAJOR[version.split(".")[0] ?? ""];
+    if (!inventory)
+        return [`bundle version ${version || "missing"} has no supported cleanup inventory`];
+    const actual = new Map();
+    const walk = (directory, prefix = "") => {
+        for (const name of fs.readdirSync(directory).sort()) {
+            const destination = path.join(directory, name);
+            const relative = prefix ? `${prefix}/${name}` : name;
+            const stat = fs.lstatSync(destination);
+            const kind = stat.isSymbolicLink()
+                ? "symlink"
+                : stat.isFile()
+                    ? "file"
+                    : stat.isDirectory()
+                        ? "directory"
+                        : "other";
+            actual.set(relative, kind);
+            if (kind === "directory")
+                walk(destination, relative);
         }
-    }
-    return preserved.sort();
-}
-function hasManagedBundleEvidence(managedAppRoot) {
-    return (isFile(path.join(managedAppRoot, BUNDLE_MARKER)) ||
-        (isFile(path.join(managedAppRoot, "scripts", "agentera")) &&
-            isFile(path.join(managedAppRoot, "skills", "agentera", "SKILL.md"))));
+    };
+    walk(managedAppRoot);
+    const violations = [];
+    for (const [relative, kind] of actual) {
+        const expected = inventory[relative];
+        if (!expected)
+            violations.push(`unknown ${kind} ${relative}`);
+        else if (expected !== kind)
+            violations.push(`${relative} must be ${expected}, found ${kind}`);
+    }
+    for (const [relative, kind] of Object.entries(inventory)) {
+        if (!actual.has(relative))
+            violations.push(`missing ${kind} ${relative}`);
+    }
+    return violations.sort();
 }
 function listManagedBundlePreview(managedAppRoot, limit = 20) {
     if (!pathExists(managedAppRoot)) {
@@ -218,88 +408,117 @@ function listManagedBundlePreview(managedAppRoot, limit = 20) {
     walk(managedAppRoot, "");
     return out;
 }
-function appHomeHasUnrecognizedEntries(appHome) {
-    if (!pathExists(appHome)) {
-        return [];
-    }
-    const unknown = [];
-    for (const entry of fs.readdirSync(appHome)) {
-        if (entry === "app") {
-            continue;
-        }
-        if (!isPreservedUserStateEntry(appHome, entry)) {
-            unknown.push(entry);
-        }
-    }
-    return unknown;
-}
 export function planCleanupPhase(ctx) {
     const appHome = resolvePath(ctx.appHome);
     const roots = doctorRoots(appHome);
     const managedAppRoot = roots.managedAppRoot;
-    const preserved = listPreservedUserStatePaths(appHome);
-    const unknown = appHomeHasUnrecognizedEntries(appHome);
+    const preflight = resolveMigrationUserStatePreflight(appHome, {
+        home: ctx.home,
+        env: ctx.env,
+    });
+    const preserved = preflight.preservedAbsolutePaths;
+    const installedHookItems = planInstalledHooksRetirementItems(ctx).filter((item) => item.status !== "noop"
+        && item.source !== undefined
+        && !item.source.startsWith(`${managedAppRoot}${path.sep}`));
+    const hasOwnedRootHooks = installedHookItems.some((item) => item.source?.startsWith(`${path.join(appHome, "hooks")}${path.sep}`));
+    const unknown = appHomeHasUnrecognizedEntriesWithPreflight(appHome, preflight)
+        .filter((name) => !(name === "hooks" && hasOwnedRootHooks));
+    const managedBundle = hasManagedBundleEvidence(managedAppRoot);
+    const refreshAuthorized = managedBundle
+        || hasBundleRootEvidence(roots.activeBundleRoot)
+        || (pathExists(appHome) && fs.readdirSync(appHome).length === 0);
+    const appRootUnknown = managedBundle ? markedBundleInventoryViolations(managedAppRoot) : [];
+    const items = [
+        ...preflight.handoffCatalog.map((entry) => ({
+            status: "noop",
+            action: "catalog-handoff",
+            source: entry.root,
+            preserved: entry.entries,
+            message: handoffCatalogMessage(entry),
+        })),
+        ...planLegacyAgentCleanupItems(ctx),
+        ...planLegacyCapabilityAgentCleanupItems(ctx),
+        ...installedHookItems,
+        ...(refreshAuthorized
+            ? planAppContentRefreshItems(ctx).filter((item) => item.action === "refresh-app-content")
+            : []),
+    ];
     if (unknown.length > 0 && !ctx.force) {
-        return summarizePhase("cleanup", [
-            {
-                status: "blocked",
-                action: "remove-managed-app-home",
-                source: appHome,
-                preserved,
-                message: "app home contains unrecognized entries outside preserved user state; cleanup blocked without --force",
-            },
-        ]);
-    }
-    if (!hasManagedBundleEvidence(managedAppRoot)) {
-        return summarizePhase("cleanup", [], "no managed Python app-home bundle to remove");
+        items.push({
+            status: "blocked",
+            action: "remove-managed-app-home",
+            source: appHome,
+            preserved,
+            message: `app home has unrecognized entries (not preserved user state or managed app content): ${unknown.join(", ")}; cleanup blocked without --force`,
+        });
+        return summarizePhase("cleanup", items);
     }
-    const removedPreview = listManagedBundlePreview(managedAppRoot);
-    return summarizePhase("cleanup", [
-        {
-            status: "pending",
+    if (appRootUnknown.length > 0) {
+        items.push({
+            status: "blocked",
             action: "remove-managed-app-home",
             source: managedAppRoot,
             target: appHome,
-            preserved,
-            removedPreview,
-            message: "will remove managed Python app-home bundle under app/ while preserving user state at app-home root",
-        },
-    ]);
-}
-function listPreservedUserState(appHome) {
-    if (!pathExists(appHome)) {
-        return [];
+            preserved: [managedAppRoot],
+            message: `managed app bundle does not match the supported v2 recursive inventory (${appRootUnknown.slice(0, 10).join(", ")}${appRootUnknown.length > 10 ? `; ${appRootUnknown.length - 10} more` : ""}); cleanup preserved the entire app directory for manual review`,
+        });
+        return summarizePhase("cleanup", items);
     }
-    const preserved = [];
-    for (const entry of fs.readdirSync(appHome)) {
-        if (entry === "app") {
-            continue;
+    if (!managedBundle) {
+        if (pathExists(managedAppRoot)) {
+            items.push({
+                status: "blocked",
+                action: "remove-managed-app-home",
+                source: managedAppRoot,
+                target: appHome,
+                message: `app directory preserved because ${BUNDLE_MARKER} ownership evidence is missing or invalid; review it manually`,
+            });
+            return summarizePhase("cleanup", items);
         }
-        if (isPreservedUserStateEntry(appHome, entry)) {
-            preserved.push(entry);
+        if (items.length === 0) {
+            return summarizePhase("cleanup", [], "no managed Python app-home bundle to remove");
         }
+        return summarizePhase("cleanup", items);
     }
-    return preserved.sort();
-}
-function removeDirectoryRecursive(dir) {
-    if (!pathExists(dir)) {
-        return;
+    const removedPreview = listManagedBundlePreview(managedAppRoot);
+    const cleanupItem = {
+        status: "pending",
+        action: "remove-managed-app-home",
+        source: managedAppRoot,
+        target: appHome,
+        preserved,
+        removedPreview,
+        message: "will remove managed Python app-home bundle under app/ while preserving user state at app-home root",
+    };
+    const evidenceError = bindMigrationTree(cleanupItem, managedAppRoot, [appHome]);
+    if (evidenceError) {
+        cleanupItem.status = "blocked";
+        cleanupItem.message = `managed app cleanup preserved the bundle: ${evidenceError}; review the unsafe path manually`;
     }
-    fs.rmSync(dir, { recursive: true, force: true });
+    items.push(cleanupItem);
+    return summarizePhase("cleanup", items);
 }
-export function applyCleanupPhase(phase) {
+export function applyCleanupPhase(phase, ctx) {
+    if (ctx) {
+        applyLegacyAgentCleanupItems(phase.items, ctx);
+        applyInstalledHooksRetirementItems(phase.items, ctx);
+        applyAppContentRefreshItems(phase.items, ctx);
+    }
     for (const item of phase.items) {
-        if (item.status !== "pending" || !item.source) {
+        if (item.status !== "pending" || item.action !== "remove-managed-app-home" || !item.source) {
             continue;
         }
         try {
-            removeDirectoryRecursive(item.source);
+            if (process.env.NODE_ENV === "test" && process.env.AGENTERA_FAULT_INJECT_V2_CLEANUP_FAILURE === "1") {
+                throw new Error("simulated post-marker cleanup failure");
+            }
+            removeBoundMigrationTree(item);
             item.status = "applied";
             item.message = "managed Python app-home bundle removed; user state preserved";
         }
         catch (exc) {
-            item.status = "failed";
-            item.message = `cleanup failed: ${exc.message}`;
+            item.status = "blocked";
+            item.message = `cleanup preserved the managed app bundle: ${exc.message}; rerun migration and review it manually`;
         }
     }
     const updated = summarizePhase("cleanup", phase.items, phase.message);
@@ -309,25 +528,24 @@ export function applyCleanupPhase(phase) {
 export function dryRunMigration(ctx) {
     return {
         artifacts: planArtifactsPhase(ctx.project),
-        runtime: planRuntimeRewirePhase(ctx),
+        runtime: planRuntimeRetirementPhase(ctx),
         cleanup: planCleanupPhase(ctx),
     };
 }
 export function applyMigrationPhases(ctx, preview, only = ["artifacts", "runtime", "cleanup"]) {
     const result = {
-        artifacts: { ...preview.artifacts, items: preview.artifacts.items.map((item) => ({ ...item })) },
-        runtime: { ...preview.runtime, items: preview.runtime.items.map((item) => ({ ...item })) },
-        cleanup: { ...preview.cleanup, items: preview.cleanup.items.map((item) => ({ ...item })) },
+        artifacts: { ...preview.artifacts, items: preview.artifacts.items.map(cloneMigrationItem) },
+        runtime: { ...preview.runtime, items: preview.runtime.items.map(cloneMigrationItem) },
+        cleanup: { ...preview.cleanup, items: preview.cleanup.items.map(cloneMigrationItem) },
     };
     if (only.includes("artifacts")) {
         applyArtifactsPhase(result.artifacts, ctx.project, ctx.force);
     }
     if (only.includes("runtime")) {
-        applyRuntimeRewirePhase(result.runtime, ctx);
+        applyRuntimeRetirementPhase(result.runtime, ctx);
     }
     if (only.includes("cleanup")) {
-        applyCleanupPhase(result.cleanup);
+        applyCleanupPhase(result.cleanup, ctx);
     }
     return result;
 }
-//# sourceMappingURL=migrateArtifactsV2ToV3.js.map