@blxzer/pactile 0.6.0-beta.2 → 0.6.0-beta.4

package/dist/commands/update.js

@@ -9,8 +9,8 @@ import { getMigrationsForVersion, getAllMigrations, getMigrationMetadata, getCon
 import { isWorkflowInitialized, resolveWorkflowDirName, workflowPath, } from "../utils/workflow-dir.js";
 import { loadHashes, saveHashes, updateHashes, isTemplateModified, removeHash, renameHash, computeHash, shouldExcludeFromHash, } from "../utils/template-hash.js";
 import { compareVersions } from "../utils/compare-versions.js";
+import { applyDeferredLiveWrites, captureDeferredLiveWrite, clearDeferredLivePlan, commitDeferredLivePlan, prepareDeferredLivePlan, resumeDeferredLivePlan, } from "../pactile/lifecycle/deferred-live.js";
 import { toPosix } from "../utils/posix.js";
-import { setupProxy } from "../utils/proxy.js";
 import { reportUpdateReadiness, snapshotReadinessForRollout, } from "../utils/readiness.js";
 import { collectProjectCapabilityTemplates, loadProjectCapabilities, } from "../utils/project-capabilities.js";
 import { applyArtifactMigration, applyKernelCreate, planArtifactMigration, planWaveC, scanContractMigration, writeWaveCConfirmed, } from "../core/task/index.js";
@@ -24,15 +24,14 @@ import { collectUserModuleTemplates } from "../templates/extract.js";
 import { frameworkDocs } from "../templates/markdown/index.js";
 import { ALL_MANAGED_DIRS, getConfiguredPlatforms, isManagedPath, isManagedRootDir, } from "../configurators/index.js";
 import { getWorkflowRootTemplateFiles } from "../configurators/workflow.js";
-import { isHostProjectionPath, pruneOrphanManifestKeys } from "../utils/manifest-prune.js";
+import { isHostProjectionPath, pruneOrphanManifestKeys, } from "../utils/manifest-prune.js";
 import { runPostUpdateSmoke } from "../utils/post-update-smoke.js";
-import { cleanupRetiredAlternateClientResidue } from "../pactile/compat/retired-alternate-client.js";
 import { listLegacyPythonScripts } from "../pactile/compat/node-entry-migration.js";
+import { applyLegacyTaskUpdate, inspectLegacyTaskUpdate, } from "../pactile/migration/legacy-task-update.js";
 import { buildFilePlanFromChanges, createBaseRolloutReport, emitRolloutReport, lifecycleResultToSummary, migrationResultToSummary, summarizeMigrationPlan, } from "../utils/update-rollout-report.js";
 import { collectCanonicalGenerationFiles, discoverCanonicalGenerationPaths, installedPactilePlatforms, isCanonicalGenerationPath, materializeCanonicalGeneration, seedCanonicalBuildRoot, runLifecycleCommand, } from "../pactile/lifecycle/index.js";
 import { InstallStateStore } from "../pactile/runtime/stores.js";
 import { filterReadOnlyLegacyMigrationItems } from "../pactile/compat/legacy-migrations.js";
-import { printLegacyCursorSkillResidueNotice, printRetiredAlternateClientNotice, } from "../pactile/compat/update-residue.js";
 import { LEGACY_UPDATE_BLOCK_MESSAGE } from "../pactile/compat/cli-options.js";
 function inspectSafeDeleteTarget(cwd, relativePath) {
     const parts = relativePath.split("/");
@@ -529,7 +528,7 @@ export function collectTemplateFiles(cwd,
  * Bypass `update.skip` when collecting templates. Enable this for breaking
  * releases so new files (e.g. `continue.md` added in 0.5.0) and template
  * updates can land even under skip-protected paths. Without this, users with
- * `.cursor/commands/` in their skip list would silently miss new commands.
+ * a retired host command directory in their skip list would silently miss new commands.
  * Existing user customizations are still guarded at WRITE time via the
  * "Modified by you" conflict prompt — they can skip per-file there.
  */
@@ -823,11 +822,8 @@ const BACKUP_EXCLUDE_PATTERNS = [
     "/middleware/", // User middleware overlay (never managed)
     "/backlog/", // Backlog data (user data)
     "/agent-traces/", // Agent traces (user data, legacy name)
-    // Platform-native worktree dirs — these are full sub-repos the CLI
-    // spawns for parallel sessions. Backing them up on every update would
-    // snapshot the entire nested working tree. Confirmed convention:
-    //   Cursor CLI:  .cursor/worktrees/
-    // Matches any platform using the same convention (future-proof).
+    // Platform-native worktree dirs may contain complete nested checkouts.
+    // Backing them up on every update would snapshot the full working tree.
     "/worktrees/",
     "/worktree/",
 ];
@@ -838,7 +834,7 @@ const BACKUP_EXCLUDE_PATTERNS = [
 export function shouldExcludeFromBackup(relativePath) {
     // Normalize Windows backslashes to forward slashes so patterns like
     // "/worktrees/" / "/tasks/" match regardless of host OS. Without this,
-    // Windows `path.relative` returns `.cursor\worktrees\...` and none of
+    // Windows `path.relative` returns backslash-separated worktree paths and none of
     // the slash-prefixed exclude patterns trigger — which causes
     // `collectAllFiles` to descend into platform worktrees (full nested
     // project copies) and explode the scan. Same normalization pattern
@@ -1512,20 +1508,6 @@ function candidatePath(projectRoot, canonicalBuildRoot, relativePath) {
         : projectRoot;
     return path.join(root, ...relativePath.replace(/\\/g, "/").split("/"));
 }
-/**
- * Apply template writes that are outside the canonical generation only after
- * lifecycle commit. Canonical paths are staged in the OS temporary root; live
- * paths are kept as bytes in memory until ProjectionStore/lifecycle succeeds.
- */
-function applyDeferredLiveWrites(cwd, writes) {
-    for (const [relativePath, write] of writes) {
-        const target = path.join(cwd, ...relativePath.replace(/\\/g, "/").split("/"));
-        fs.mkdirSync(path.dirname(target), { recursive: true });
-        fs.writeFileSync(target, write.content);
-        if (write.executable)
-            fs.chmodSync(target, 0o755);
-    }
-}
 function migrationRoot(item) {
     const paths = [item.from, item.to].filter((value) => typeof value === "string" && value.length > 0);
     const canonical = paths.map(isCanonicalGenerationPath);
@@ -1595,6 +1577,10 @@ async function runUpdateLifecycle(cwd, operation, candidateFiles) {
  */
 export async function update(options) {
     const cwd = process.cwd();
+    if (!options.dryRun) {
+        const active = new InstallStateStore(cwd).read()?.state.generationId ?? null;
+        resumeDeferredLivePlan(cwd, active);
+    }
     const rolloutOpts = rolloutOptionsFromUpdate(options);
     let readinessSnapshot = null;
     let projectVersion = "unknown";
@@ -1651,8 +1637,6 @@ export async function update(options) {
     }
     console.log(chalk.cyan("\nPactile Update"));
     console.log(chalk.cyan("══════════════\n"));
-    // Set up proxy before any network calls (npm version check)
-    setupProxy();
     readinessSnapshot = snapshotReadinessForRollout({
         cwd,
         selected: loadProjectCapabilities(cwd),
@@ -1752,14 +1736,17 @@ export async function update(options) {
     // match the shipped template (dogfood pin absorbed by this release).
     const officialTemplates = collectTemplateFiles(cwd, true);
     const templates = collectTemplateFiles(cwd, breakingBypass);
-    printLegacyCursorSkillResidueNotice(cwd);
     // Load update.skip paths (used for both safe-file-delete and template collection)
     const skipPaths = loadUpdateSkipPaths(cwd);
     const staleSkipPaths = collectStaleUpdateSkipPaths(cwd, skipPaths, officialTemplates);
     // Collect safe-file-delete items from ALL manifests (hash match is the safety net)
     // This runs regardless of version — unknown version still gets safe cleanup
     const allMigrations = getAllMigrations();
-    const safeFileDeletes = collectSafeFileDeletes([...allMigrations, ...retiredPythonMigrations.filter((item) => !allMigrations.some((existing) => existing.type === "safe-file-delete" && existing.from === item.from))], cwd, skipPaths, breakingBypass);
+    const safeFileDeletes = collectSafeFileDeletes([
+        ...allMigrations,
+        ...retiredPythonMigrations.filter((item) => !allMigrations.some((existing) => existing.type === "safe-file-delete" &&
+            existing.from === item.from)),
+    ], cwd, skipPaths, breakingBypass);
     const legacyPythonPaths = listLegacyPythonScripts(cwd);
     const retiredPythonPlanned = new Set(safeFileDeletes
         .filter((item) => item.action === "delete")
@@ -1860,19 +1847,6 @@ export async function update(options) {
     if (safeFileDeletes.length > 0) {
         printSafeFileDeleteSummary(safeFileDeletes);
     }
-    // Preview retired alternate-client cleanup (hash-safe; always considered).
-    const alternateClientResiduePreview = cleanupRetiredAlternateClientResidue(cwd, {
-        dryRun: true,
-    });
-    if (alternateClientResiduePreview.deleted.length > 0) {
-        console.log(chalk.cyan("\nRetired alternate-client cleanup (hash-safe):"));
-        for (const rel of alternateClientResiduePreview.deleted) {
-            console.log(chalk.gray(`  would delete: ${rel}`));
-        }
-    }
-    if (alternateClientResiduePreview.preservedModified.length > 0) {
-        console.log(chalk.yellow(`  preserve (user-modified): ${alternateClientResiduePreview.preservedModified.join(", ")}`));
-    }
     // Analyze changes (pass hashes for modification detection)
     const changes = analyzeChanges(cwd, hashes, templates);
     const missingTemplateHashes = collectMissingTemplateHashes(changes, hashes);
@@ -1957,6 +1931,28 @@ export async function update(options) {
     });
     p36State.report = p36SummaryForRollout(p36Plan);
     printP36Vernacular(p36Plan);
+    const legacyTaskInspection = inspectLegacyTaskUpdate(cwd);
+    if (legacyTaskInspection.status !== "none") {
+        console.log(chalk.cyan("\nLegacy Task import preflight:"));
+        if (legacyTaskInspection.status === "ready") {
+            console.log(`  Ready: ${legacyTaskInspection.import.imported} Task(s), ${legacyTaskInspection.import.needsDefinition} need definition, ${legacyTaskInspection.import.needsCoordination} need dependency coordination, ${legacyTaskInspection.import.archived} archived read-only.`);
+        }
+        else if (legacyTaskInspection.status === "blocked") {
+            console.log(chalk.yellow(`  Blocked: ${legacyTaskInspection.reason ?? "legacy-task-preflight-blocked"}`));
+            for (const finding of legacyTaskInspection.plan.findings.filter((item) => item.severity === "blocker")) {
+                console.log(chalk.gray(`  ${finding.sourcePath}: ${finding.code} — ${finding.detail}`));
+            }
+        }
+        else if (legacyTaskInspection.status === "active-source-drift") {
+            console.log(chalk.yellow("  Existing V2 import remains active; later legacy source edits stay untouched and will not be re-imported automatically."));
+        }
+        else {
+            console.log(chalk.gray(`  ${legacyTaskInspection.status}: batch ${legacyTaskInspection.activeBatchId ?? "none"}`));
+        }
+    }
+    if (!options.dryRun && legacyTaskInspection.status === "blocked") {
+        throw new Error(`Legacy Task migration preflight blocked the update: ${legacyTaskInspection.reason ?? "unknown"}`);
+    }
     // First-time hash tracking hint
     if (isFirstHashTracking && changes.changedFiles.length > 0) {
         console.log(chalk.cyan("ℹ️  First update with hash tracking enabled."));
@@ -1975,6 +1971,7 @@ export async function update(options) {
     const hasOfficialP36 = officialWorkPending(officialPlan);
     const hasMaintainerArtifactWrites = Boolean(options.writeArtifacts) && artifactPlan.writable.length > 0;
     const hasWaveCPending = waveCWorkPending(p36Plan);
+    const hasLegacyTaskUpgrade = legacyTaskInspection.status === "ready";
     if (changes.newFiles.length === 0 &&
         changes.autoUpdateFiles.length === 0 &&
         changes.changedFiles.length === 0 &&
@@ -1982,7 +1979,8 @@ export async function update(options) {
         !hasSafeDeletes &&
         !hasOfficialP36 &&
         !hasMaintainerArtifactWrites &&
-        !hasWaveCPending) {
+        !hasWaveCPending &&
+        !hasLegacyTaskUpgrade) {
         const metadataChanged = prunedManifest || missingTemplateHashes.size > 0 || !isSameVersion;
         let noChangeBackup = null;
         if (!options.dryRun) {
@@ -2114,6 +2112,25 @@ export async function update(options) {
         }
         waveCInteractivelyConfirmed = true;
     }
+    if (legacyTaskInspection.status === "ready") {
+        const taskUpgrade = await applyLegacyTaskUpdate(cwd);
+        if (taskUpgrade.status === "blocked" ||
+            taskUpgrade.status === "interrupted") {
+            const retryGuidance = taskUpgrade.reason?.includes("authority-missing-with-residual-state")
+                ? "Reconcile the missing authority against the preserved migration evidence before retrying."
+                : "Re-run 'pactile update' to recover the journal.";
+            throw new Error(`Legacy Task migration did not commit; update stopped before template writes (${taskUpgrade.reason ?? taskUpgrade.status}). ${retryGuidance}`);
+        }
+        if (taskUpgrade.status === "completed") {
+            console.log(chalk.green(`\n✓ Imported ${taskUpgrade.import.imported} legacy Task(s) into V2; ${taskUpgrade.import.needsDefinition} need definition, ${taskUpgrade.import.needsCoordination} need dependency coordination, ${taskUpgrade.import.archived} remain archived read-only.`));
+        }
+        else if (taskUpgrade.status === "active-source-drift") {
+            console.log(chalk.yellow("\nLegacy source changed after the active V2 import; preserved it without re-import."));
+        }
+        else if (taskUpgrade.status === "already-active") {
+            console.log(chalk.gray("\nLegacy Task migration is already active; no Task state was rewritten."));
+        }
+    }
     // Create complete backup of all managed platform/workflow directories
     const canonicalBuildRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pactile-update-"));
     seedCanonicalBuildRoot(cwd, canonicalBuildRoot);
@@ -2141,7 +2158,7 @@ export async function update(options) {
     const stageTemplateWrite = (relativePath, content) => {
         const executable = relativePath.endsWith(".sh") || relativePath.endsWith(".py");
         if (!isCanonicalGenerationPath(relativePath)) {
-            deferredLiveWrites.set(relativePath, { content, executable });
+            deferredLiveWrites.set(relativePath, captureDeferredLiveWrite(cwd, relativePath, content, executable));
             return;
         }
         const target = candidatePath(cwd, canonicalBuildRoot, relativePath);
@@ -2248,7 +2265,7 @@ export async function update(options) {
                         ? fs.readFileSync(fullPath, "utf-8")
                         : null;
                 })()
-                : deferredLiveWrites.get(file.relativePath)?.content ?? null;
+                : (deferredLiveWrites.get(file.relativePath)?.content ?? null);
             if (staged === file.newContent)
                 filesToHash.set(file.relativePath, file.newContent);
         }
@@ -2257,7 +2274,23 @@ export async function update(options) {
         }
         const activePlatforms = installedPactilePlatforms(new InstallStateStore(cwd).read()?.state ?? null);
         const canonicalCandidate = collectCanonicalGenerationFiles(canonicalBuildRoot, discoverCanonicalGenerationPaths(canonicalBuildRoot), activePlatforms, VERSION);
-        lifecycleResult = await runUpdateLifecycle(cwd, "update", canonicalCandidate);
+        const sourceGenerationId = new InstallStateStore(cwd).read()?.state
+            .generationId;
+        if (!sourceGenerationId)
+            throw new Error("Missing active generation before deferred live update");
+        prepareDeferredLivePlan(cwd, sourceGenerationId, deferredLiveWrites);
+        try {
+            lifecycleResult = await runUpdateLifecycle(cwd, "update", canonicalCandidate);
+            if (lifecycleResult.installState) {
+                commitDeferredLivePlan(cwd, lifecycleResult.installState.state.generationId);
+            }
+        }
+        catch (error) {
+            if (new InstallStateStore(cwd).read()?.state.generationId ===
+                sourceGenerationId)
+                clearDeferredLivePlan(cwd);
+            throw error;
+        }
     }
     finally {
         fs.rmSync(canonicalBuildRoot, { recursive: true, force: true });
@@ -2302,15 +2335,8 @@ export async function update(options) {
         const deleted = executeSafeFileDeletes(deferredLiveSafeDeletes, cwd);
         safeDeleted += deleted;
     }
-    const alternateClientCleanup = cleanupRetiredAlternateClientResidue(cwd);
-    if (alternateClientCleanup.deleted.length > 0) {
-        safeDeleted += alternateClientCleanup.deleted.length;
-        console.log(chalk.cyan(`\nCleaned up ${alternateClientCleanup.deleted.length} retired alternate-client file(s)`));
-    }
-    if (alternateClientCleanup.preservedModified.length > 0) {
-        console.log(chalk.yellow(`Preserved user-modified alternate-client residue: ${alternateClientCleanup.preservedModified.join(", ")}`));
-    }
     applyDeferredLiveWrites(cwd, deferredLiveWrites);
+    clearDeferredLivePlan(cwd);
     if (deferredLiveConfigSections.length > 0) {
         configSectionsAppended += applyConfigSectionsAdded(deferredLiveConfigSections, cwd, templates).appended;
     }
@@ -2400,7 +2426,6 @@ export async function update(options) {
     }
     const actionWord = isDowngrade ? "Downgrade" : "Update";
     console.log(chalk.green(`\n✅ ${actionWord} complete! (${projectVersion} → ${cliVersion})`));
-    printRetiredAlternateClientNotice(cwd);
     if (createdNew > 0) {
         console.log(chalk.gray("\nTip: Review .new files and merge changes manually if needed."));
     }