@treeseed/sdk 0.13.0-rc.8 → 0.13.0-rc.80

package/dist/workflow/operations/workspace-lifecycle/workflow-stage.js

@@ -1,330 +0,0 @@
-import { resolve } from "node:path";
-import { runProof } from "../../../operations/services/guarantees/release-proof-runner.js";
-import { assertFeatureBranch, mergeBranchDownIntoFeature, promoteCommitToBranchWithExpectedHead, remoteBranchExists, remoteHeadCommit, STAGING_BRANCH, syncBranchWithOrigin } from "../../../operations/services/operations/git-workflow.js";
-import { hasMeaningfulChanges, repoRoot } from "../../../operations/services/treedx/workspaces/workspace-save.js";
-import { workspaceRoot } from "../../../operations/services/treedx/workspaces/workspace-tools.js";
-import { resolveWorkflowSession } from "../../session.js";
-import { managedWorkflowWorktreeMetadata } from "../../worktrees.js";
-import { ensureLocalStateExcluded, resolveProjectRootOrThrow, withContextEnv, workflowError } from "../release-support/helpers/run-release-production-guarantees.js";
-import { buildStagePromotionPlan, checkedOutStagePromotionRepos, createStageCandidateManifest, normalizeStageCiMode, normalizeStageCleanupMode, normalizeStageVerifyMode, stageConflictError, stagePreflightBlockers, stagingCandidateWorkflowGates, writeStageCandidateManifest } from "../coordination/staging-candidate-workflow-gates.js";
-import { helpersForCwd, waitForWorkflowGates, worktreePayload } from "../packages/normalize-release-candidate-mode.js";
-import { acquireWorkflowRun, completeWorkflowRun, executeJournalStep, skipJournalStep } from "../packages/prepare-fresh-release-run.js";
-import { createNextSteps } from "../packages/release-admin-message.js";
-import { ensureMessage, toError } from "../support/workflow-helpers.js";
-import { failWorkflowRun } from "../recovery/fail-workflow-run.js";
-import { ensureWorkflowWorkspaceLinks, maybeRunLocalWorkflowCleanup, normalizeSceneArtifactsMode } from "../recovery/workflow-write.js";
-import { findAutoResumableTaskRun, rejectImplicitWorkflowResume } from "../repositories/gates-for-saved-repository-reports.js";
-import { cleanupStageSourceBranches } from "../support/cleanup-stage-source-branches.js";
-import { buildWorkflowResult, normalizeExecutionMode, selectWorkflowApplications } from "../support/create-repo-report.js";
-import { maybeAutoSaveCurrentTaskBranch } from "../support/sync-current-branch-to-origin.js";
-import { workflowSave } from "./workflow-save.js";
-import { integrationGovernanceAuthorityBlockers, validateIntegrationGovernanceAuthorities } from "../coordination/integration-change-set.js";
-async function workflowStage(helpers, input) {
-  try {
-    return await withContextEnv(helpers.context.env, async () => {
-      const tenantRoot = resolveProjectRootOrThrow("stage", helpers.cwd());
-      const root = workspaceRoot(tenantRoot);
-      ensureLocalStateExcluded(root);
-      const executionMode = normalizeExecutionMode(input);
-      const session = resolveWorkflowSession(root);
-      const explicitResumeRunId = helpers.context.workflow?.resumeRunId ?? input.resumeRunId ?? null;
-      const rawAutoResumeRun = executionMode === "execute" && !explicitResumeRunId ? findAutoResumableTaskRun(root, "stage", session.branchName) : null;
-      rejectImplicitWorkflowResume("stage", rawAutoResumeRun);
-      const autoResumeRun = rawAutoResumeRun?.steps.some((step) => step.id === "preflight") ? rawAutoResumeRun : null;
-      const planAutoResumeRun = null;
-      const effectiveInput = autoResumeRun ? autoResumeRun.input : input;
-      const localCleanup = maybeRunLocalWorkflowCleanup(helpers, root, "stage", effectiveInput);
-      const message = ensureMessage("stage", effectiveInput.message, "a resolution message");
-      if (effectiveInput.verifyDeployedResources === true) {
-        workflowError("stage", "validation_failed", "Stage no longer verifies deployed resources. Promote refs with stage, then run staging release/hosting verification separately.");
-      }
-      const verifyMode = normalizeStageVerifyMode(effectiveInput.verifyMode);
-      const ciMode = normalizeStageCiMode(effectiveInput);
-      const cleanupMode = normalizeStageCleanupMode(effectiveInput);
-      const updateFrom = effectiveInput.updateFrom ?? STAGING_BRANCH;
-      if (updateFrom !== STAGING_BRANCH) {
-        workflowError("stage", "validation_failed", `Stage currently supports only --update-from ${STAGING_BRANCH}. Received ${updateFrom}.`);
-      }
-      const applicationSelection = selectWorkflowApplications(root, { packageSelection: session.packageSelection });
-      const featureBranch = executionMode === "execute" ? assertFeatureBranch(root) : session.branchName ?? "";
-      let plan = buildStagePromotionPlan(root, featureBranch, { verifyMode, ciMode, cleanupMode, updateFrom });
-      let blockers = stagePreflightBlockers(root, featureBranch, plan);
-      blockers.push(...await integrationGovernanceAuthorityBlockers(root, helpers.context.validateExecutionAuthorities));
-      const basePayload = {
-        mode: "stage-promotion",
-        branchName: featureBranch,
-        branchRole: session.branchRole,
-        mergeTarget: STAGING_BRANCH,
-        mergeStrategy: "merge-staging-down-then-exact-sha",
-        message,
-        verifyMode,
-        ciMode,
-        cleanupMode,
-        updateFrom,
-        waitForStaging: ciMode === "hosted",
-        sceneArtifacts: normalizeSceneArtifactsMode(effectiveInput.sceneArtifacts),
-        localCleanup,
-        applicationSelection,
-        plan,
-        phases: plan.phases,
-        blockers,
-        autoResumeCandidate: planAutoResumeRun ? {
-          runId: planAutoResumeRun.runId,
-          branch: planAutoResumeRun.session.branchName,
-          failure: planAutoResumeRun.failure
-        } : null,
-        legacyMutationPathDisabled: true,
-        ...worktreePayload(root, effectiveInput.worktreeMode)
-      };
-      if (executionMode === "plan") {
-        return buildWorkflowResult("stage", root, basePayload, {
-          executionMode,
-          summary: blockers.length > 0 ? "Treeseed stage plan blocked." : "Treeseed stage promotion plan ready.",
-          includeFinalState: false,
-          nextSteps: createNextSteps([
-            blockers.length > 0 ? { operation: "status", reason: "Resolve blockers before staging." } : { operation: "stage", reason: "Promote the verified feature branch to staging.", input: { message } }
-          ])
-        });
-      }
-      if (effectiveInput.autoSave === true) {
-        await maybeAutoSaveCurrentTaskBranch(helpers, "stage", {
-          message,
-          autoSave: true,
-          verify: false,
-          preview: false
-        });
-        plan = buildStagePromotionPlan(root, featureBranch, { verifyMode, ciMode, cleanupMode, updateFrom });
-        blockers = stagePreflightBlockers(root, featureBranch, plan);
-        blockers.push(...await integrationGovernanceAuthorityBlockers(root, helpers.context.validateExecutionAuthorities));
-      }
-      if (blockers.length > 0 && !explicitResumeRunId) {
-        workflowError("stage", "validation_failed", `stage is blocked:
-${blockers.map((entry) => `- ${entry}`).join("\n")}`, {
-          details: { blockers, plan }
-        });
-      }
-      const workflowRun = acquireWorkflowRun("stage", resolveWorkflowSession(root), {
-        ...effectiveInput,
-        verifyMode,
-        ciMode,
-        cleanupMode,
-        updateFrom
-      }, [
-        { id: "preflight", description: "Validate clean feature branch before staging", repoName: "@treeseed/market", repoPath: repoRoot(root), branch: featureBranch, resumable: true },
-        { id: "merge-staging-down", description: "Merge staging into feature branches", repoName: "@treeseed/market", repoPath: repoRoot(root), branch: featureBranch, resumable: true },
-        { id: "save-integrated-feature", description: "Save integrated feature state after staging merge-down", repoName: "@treeseed/market", repoPath: repoRoot(root), branch: featureBranch, resumable: true },
-        { id: "verify-integrated-feature", description: "Run local proof before staging mutation", repoName: "@treeseed/market", repoPath: repoRoot(root), branch: featureBranch, resumable: true },
-        { id: "write-stage-candidate", description: "Write exact stage candidate manifest", repoName: "@treeseed/market", repoPath: repoRoot(root), branch: featureBranch, resumable: true },
-        { id: "promote-to-staging", description: "Promote exact verified refs to staging", repoName: "@treeseed/market", repoPath: repoRoot(root), branch: featureBranch, resumable: true },
-        { id: "verify-staging-refs", description: "Verify remote staging refs match promoted commits", repoName: "@treeseed/market", repoPath: repoRoot(root), branch: STAGING_BRANCH, resumable: true },
-        { id: "hosted-ci", description: "Wait for hosted staging CI when explicitly requested", repoName: "@treeseed/market", repoPath: repoRoot(root), branch: STAGING_BRANCH, resumable: true },
-        { id: "workspace-link-restore", description: "Restore local workspace links after stage", repoName: "@treeseed/market", repoPath: repoRoot(root), branch: STAGING_BRANCH, resumable: true },
-        { id: "cleanup-source", description: "Clean up source branches and worktree after successful promotion", repoName: "@treeseed/market", repoPath: repoRoot(root), branch: featureBranch, resumable: true }
-      ], helpers.context);
-      try {
-        await executeJournalStep(root, workflowRun.runId, "preflight", async () => {
-          const currentPlan = buildStagePromotionPlan(root, featureBranch, { verifyMode, ciMode, cleanupMode, updateFrom });
-          const currentBlockers = stagePreflightBlockers(root, featureBranch, currentPlan);
-          currentBlockers.push(...await integrationGovernanceAuthorityBlockers(root, helpers.context.validateExecutionAuthorities));
-          if (currentBlockers.length > 0) {
-            workflowError("stage", "validation_failed", `stage is blocked:
-${currentBlockers.map((entry) => `- ${entry}`).join("\n")}`, {
-              details: { blockers: currentBlockers, plan: currentPlan }
-            });
-          }
-          return { status: "passed", checkedAt: (/* @__PURE__ */ new Date()).toISOString() };
-        });
-        const mergeDown = await executeJournalStep(root, workflowRun.runId, "merge-staging-down", () => {
-          const results = [];
-          try {
-            results.push({
-              name: "@treeseed/market",
-              path: repoRoot(root),
-              ...mergeBranchDownIntoFeature(repoRoot(root), {
-                featureBranch,
-                sourceBranch: STAGING_BRANCH,
-                message: `stage: merge ${STAGING_BRANCH} into ${featureBranch}`,
-                allowGeneratedMetadataAutoResolution: true
-              })
-            });
-            for (const repo of checkedOutStagePromotionRepos(root)) {
-              if (!remoteBranchExists(repo.dir, featureBranch)) {
-                results.push({ name: repo.name, path: repo.dir, skipped: true, reason: "remote-branch-missing" });
-                continue;
-              }
-              results.push({
-                name: repo.name,
-                path: repo.dir,
-                ...mergeBranchDownIntoFeature(repo.dir, {
-                  featureBranch,
-                  sourceBranch: STAGING_BRANCH,
-                  message: `stage: merge ${STAGING_BRANCH} into ${featureBranch}`,
-                  allowGeneratedMetadataAutoResolution: true
-                })
-              });
-            }
-          } catch (error) {
-            const details = error && typeof error === "object" ? error : {};
-            throw stageConflictError(error instanceof Error ? error.message : String(error), {
-              ...details,
-              results,
-              branchName: featureBranch,
-              targetBranch: STAGING_BRANCH
-            });
-          }
-          return { status: "completed", results };
-        });
-        const mergeChanged = Array.isArray(mergeDown?.results) && mergeDown.results.some((entry) => Boolean(entry.merged));
-        const saveResult = mergeChanged || hasMeaningfulChanges(repoRoot(root)) ? await executeJournalStep(root, workflowRun.runId, "save-integrated-feature", () => workflowSave(helpersForCwd({
-          ...helpers,
-          context: { ...helpers.context, workflow: void 0 }
-        }, root), {
-          message: `integrate staging before stage: ${message}`,
-          federated: true,
-          verifyMode: "skip",
-          ciMode: "off",
-          refreshPreview: false,
-          preview: false,
-          workspaceLinks: effectiveInput.workspaceLinks ?? "auto"
-        })) : (skipJournalStep(root, workflowRun.runId, "save-integrated-feature", { skippedReason: "staging already integrated" }), null);
-        const verification = verifyMode === "none" || process.env.TREESEED_RELEASE_CANDIDATE_REHEARSAL_MODE === "skip" ? (skipJournalStep(root, workflowRun.runId, "verify-integrated-feature", { mode: verifyMode, status: "skipped" }), {
-          mode: verifyMode,
-          status: "skipped",
-          completedAt: null
-        }) : await executeJournalStep(root, workflowRun.runId, "verify-integrated-feature", async () => {
-          const proof = await runProof({
-            root,
-            target: "staging",
-            driver: verifyMode === "action" ? "act" : "local",
-            write: (line, stream) => helpers.write(`[stage][verify] ${line}`, stream)
-          });
-          if (proof.failures.length > 0) {
-            const first = proof.failures[0];
-            workflowError("stage", "validation_failed", [
-              "Treeseed stage proof failed.",
-              `- ${first.subject.id}: ${first.invalidationReasons[0] ?? first.status}`,
-              first.result.workflow?.url ? `Run: ${first.result.workflow.url}` : null
-            ].join("\n"), {
-              details: { proof }
-            });
-          }
-          return {
-            mode: verifyMode,
-            status: "passed",
-            completedAt: (/* @__PURE__ */ new Date()).toISOString(),
-            proof
-          };
-        });
-        const governanceAuthority = await validateIntegrationGovernanceAuthorities(root, helpers.context.validateExecutionAuthorities);
-        if (governanceAuthority.status === "failed") workflowError("stage", "validation_failed", `stage governance authority is stale:
-${governanceAuthority.blockers.map((entry) => `- ${entry}`).join("\n")}`, { details: { blockers: governanceAuthority.blockers } });
-        const manifest = await executeJournalStep(root, workflowRun.runId, "write-stage-candidate", () => {
-          const currentPlan = buildStagePromotionPlan(root, featureBranch, { verifyMode, ciMode, cleanupMode, updateFrom });
-          return writeStageCandidateManifest(root, workflowRun.runId, createStageCandidateManifest(root, workflowRun.runId, featureBranch, currentPlan, {
-            mode: verifyMode,
-            status: verification.status,
-            completedAt: verification.completedAt
-          }, governanceAuthority));
-        });
-        const typedManifest = manifest;
-        const promotion = await executeJournalStep(root, workflowRun.runId, "promote-to-staging", () => {
-          const results = [];
-          for (const pkg of typedManifest.packages) {
-            results.push({
-              name: pkg.name,
-              ...promoteCommitToBranchWithExpectedHead(resolve(root, pkg.path), {
-                commitSha: pkg.commit,
-                targetBranch: STAGING_BRANCH,
-                expectedBefore: typedManifest.stagingHeadsBefore[pkg.name] ?? null
-              })
-            });
-          }
-          results.push({
-            name: "@treeseed/market",
-            ...promoteCommitToBranchWithExpectedHead(repoRoot(root), {
-              commitSha: typedManifest.root.commit,
-              targetBranch: STAGING_BRANCH,
-              expectedBefore: typedManifest.stagingHeadsBefore["@treeseed/market"] ?? null
-            })
-          });
-          return { status: "completed", results };
-        });
-        const stagingRefs = await executeJournalStep(root, workflowRun.runId, "verify-staging-refs", () => {
-          const refs = {};
-          for (const pkg of typedManifest.packages) {
-            const observed = remoteHeadCommit(resolve(root, pkg.path), STAGING_BRANCH);
-            if (observed !== pkg.commit) {
-              throw new Error(`${pkg.name} staging ref mismatch: expected ${pkg.commit}, observed ${observed}.`);
-            }
-            refs[pkg.name] = observed;
-          }
-          const rootObserved = remoteHeadCommit(repoRoot(root), STAGING_BRANCH);
-          if (rootObserved !== typedManifest.root.commit) {
-            throw new Error(`@treeseed/market staging ref mismatch: expected ${typedManifest.root.commit}, observed ${rootObserved}.`);
-          }
-          refs["@treeseed/market"] = rootObserved;
-          return { status: "verified", refs };
-        });
-        const hostedCi = ciMode === "hosted" ? await executeJournalStep(root, workflowRun.runId, "hosted-ci", () => waitForWorkflowGates(
-          "stage",
-          stagingCandidateWorkflowGates(root, typedManifest),
-          "hosted",
-          { root, runId: workflowRun.runId, onProgress: (line, stream) => helpers.write(line, stream) }
-        )) : (skipJournalStep(root, workflowRun.runId, "hosted-ci", { skippedReason: "ci off" }), { status: "skipped", reason: "ci off" });
-        const workspaceLinks = await executeJournalStep(root, workflowRun.runId, "workspace-link-restore", () => ensureWorkflowWorkspaceLinks(root, helpers, effectiveInput.workspaceLinks ?? "auto"));
-        if (!managedWorkflowWorktreeMetadata(root)) {
-          for (const repo of checkedOutStagePromotionRepos(root)) {
-            syncBranchWithOrigin(repo.dir, STAGING_BRANCH);
-          }
-          syncBranchWithOrigin(repoRoot(root), STAGING_BRANCH);
-        }
-        const cleanup = cleanupMode === "success" ? await executeJournalStep(root, workflowRun.runId, "cleanup-source", () => cleanupStageSourceBranches(root, featureBranch, typedManifest)) : (skipJournalStep(root, workflowRun.runId, "cleanup-source", { skippedReason: "manual cleanup selected" }), { status: "skipped", reason: "manual cleanup selected" });
-        const payload = {
-          ...basePayload,
-          blockers: [],
-          runId: workflowRun.runId,
-          mergeDown,
-          saveResult,
-          verification,
-          manifest: typedManifest,
-          promotion,
-          stagingRefs,
-          hostedCi,
-          stagingGuarantees: null,
-          cleanup,
-          workspaceLinks,
-          finalBranch: STAGING_BRANCH,
-          summary: ciMode === "hosted" ? `Staging candidate ${typedManifest.candidateId} passed all exact-SHA verification workflows.` : `Staging candidate ${typedManifest.candidateId} was promoted asynchronously; hosted verification is pending.`
-        };
-        completeWorkflowRun(root, workflowRun.runId, payload);
-        return buildWorkflowResult("stage", root, payload, {
-          runId: workflowRun.runId,
-          summary: "Treeseed stage completed successfully.",
-          includeFinalState: false,
-          nextSteps: createNextSteps([
-            { operation: "ci", reason: "Inspect staging CI/CD status after branch promotion.", input: { branch: STAGING_BRANCH, failed: true } }
-          ])
-        });
-      } catch (error) {
-        try {
-          ensureWorkflowWorkspaceLinks(root, helpers, effectiveInput.workspaceLinks ?? "auto");
-        } catch {
-        }
-        failWorkflowRun(root, workflowRun.runId, error, {
-          resumable: true,
-          runId: workflowRun.runId,
-          command: "stage",
-          message: `Resume the interrupted stage for ${featureBranch}.`,
-          recoverCommand: "treeseed recover",
-          resumeCommand: `treeseed resume ${workflowRun.runId}`
-        });
-        throw error;
-      }
-    });
-  } catch (error) {
-    toError("stage", error);
-  }
-}
-export {
-  workflowStage
-};

package/dist/workflow/operations/workspace-lifecycle/workflow-switch.d.ts

@@ -1,35 +0,0 @@
-import type { SwitchInput, UpdateInput } from "../../../operations/workflow.js";
-import { WorkflowOperationHelpers } from '../recovery/workflow-write.js';
-export declare function workflowSwitch(helpers: WorkflowOperationHelpers, input: SwitchInput): any;
-export type UpdateStrategy = 'merge' | 'ff-only';
-export type UpdateRepoAction = 'planned' | 'up-to-date' | 'merged' | 'fast-forwarded' | 'pushed' | 'blocked';
-export type UpdateRepoResult = {
-    name: string;
-    path: string;
-    branch: string;
-    sourceRef: string;
-    action: UpdateRepoAction;
-    beforeHead: string | null;
-    afterHead: string | null;
-    pushed: boolean;
-    changedFiles: string[];
-    blockers: string[];
-    ahead?: number | null;
-    behind?: number | null;
-    status?: 'up-to-date' | 'merge-needed' | 'fast-forward' | 'blocked';
-    sourceAvailable?: boolean;
-};
-export type UpdateConflict = {
-    repo: string;
-    path: string;
-    files: string[];
-};
-export declare function normalizeUpdateStrategy(strategy: UpdateInput['strategy']): UpdateStrategy;
-export declare function normalizeUpdateSource(source: string | undefined): string;
-export declare function gitOutput(args: string[], cwd: string, allowFailure?: boolean): string;
-export declare function updateHead(repoDir: string): string | null;
-export declare function updateStatusLines(repoDir: string): string[];
-export declare function updateChangedFiles(repoDir: string): string[];
-export declare function updateConflictedFiles(repoDir: string): string[];
-export declare function sourceBranchExists(repoDir: string, sourceBranch: string): boolean;
-export declare function localRemoteRefExists(repoDir: string, sourceBranch: string): boolean;

package/dist/workflow/operations/workspace-lifecycle/workflow-switch.js

@@ -1,295 +0,0 @@
-import { classifyGitMode, runGitOk, runRepositoryGit } from "../../../operations/services/operations/git-runner.js";
-import { assertCleanWorktree, branchExists, checkoutNewTaskBranchWithChanges, checkoutTaskBranchFromStaging, headCommit, PRODUCTION_BRANCH, reconcileCleanDetachedSubmodules, remoteBranchExists, STAGING_BRANCH } from "../../../operations/services/operations/git-workflow.js";
-import { checkedOutManagedWorkflowRepos } from "../../../operations/services/support/managed-repositories.js";
-import { currentBranch, hasMeaningfulChanges } from "../../../operations/services/treedx/workspaces/workspace-save.js";
-import { workspaceRoot } from "../../../operations/services/treedx/workspaces/workspace-tools.js";
-import { resolveWorkflowState } from "../../../operations/workflow-state.js";
-import { resolveWorkflowSession } from "../../session.js";
-import { effectiveWorkflowWorktreeMode, ensureManagedWorkflowWorktree, plannedManagedWorkflowWorktreePath } from "../../worktrees.js";
-import { resolveProjectRootOrThrow, withContextEnv, workflowError } from "../release-support/helpers/run-release-production-guarantees.js";
-import { assertSessionBranchSafety, branchPreviewInitialized, reconcileBranchPreview, reconcileWorkflowBranchPreview } from "../packages/collect-published-release-artifact-checks.js";
-import { helpersForCwd, shouldDispatchSwitchToManagedWorktree, worktreePayload } from "../packages/normalize-release-candidate-mode.js";
-import { acquireWorkflowRun, completeWorkflowRun, executeJournalStep } from "../packages/prepare-fresh-release-run.js";
-import { createNextSteps } from "../packages/release-admin-message.js";
-import { toError } from "../support/workflow-helpers.js";
-import { failWorkflowRun } from "../recovery/fail-workflow-run.js";
-import { ensureWorkflowWorkspaceLinks } from "../recovery/workflow-write.js";
-import { assertWorkspaceClean, buildWorkflowResult, createManagedWorkflowRepoReports, createWorkspaceRootRepoReport, findReportByName, normalizeExecutionMode } from "../support/create-repo-report.js";
-import { reattachRepairablePackageRepos } from "../support/sync-current-branch-to-origin.js";
-async function workflowSwitch(helpers, input) {
-  try {
-    return await withContextEnv(helpers.context.env, async () => {
-      const tenantRoot = resolveProjectRootOrThrow("switch", helpers.cwd());
-      const root = workspaceRoot(tenantRoot);
-      const branchName = String(input.branch ?? input.branchName ?? "").trim();
-      if (!branchName) {
-        workflowError("switch", "validation_failed", "Treeseed switch requires a branch name.");
-      }
-      const executionMode = normalizeExecutionMode(input);
-      if (executionMode !== "plan") reconcileCleanDetachedSubmodules(root);
-      reattachRepairablePackageRepos(root, [branchName, STAGING_BRANCH, PRODUCTION_BRANCH], {
-        operation: "switch",
-        onProgress: (line, stream) => helpers.write(line, stream),
-        throwOnBlocker: true
-      });
-      const session = resolveWorkflowSession(root);
-      const preview = input.preview === true;
-      const adoptChanges = input.adoptChanges === true;
-      if (executionMode !== "plan" && !adoptChanges && shouldDispatchSwitchToManagedWorktree(root, input, helpers.context.env)) {
-        const managed = ensureManagedWorkflowWorktree({
-          root,
-          branchName,
-          mode: input.worktreeMode,
-          env: helpers.context.env
-        });
-        const result = await workflowSwitch(helpersForCwd(helpers, managed.worktreePath), {
-          ...input,
-          worktreeMode: "off"
-        });
-        return {
-          ...result,
-          payload: {
-            ...result.payload,
-            worktreeMode: input.worktreeMode ?? "auto",
-            worktreePath: managed.worktreePath,
-            managedWorktree: managed
-          }
-        };
-      }
-      const mode = session.mode;
-      const repoDir = session.gitRoot;
-      const rootRepo = createWorkspaceRootRepoReport(root);
-      const packageReports = createManagedWorkflowRepoReports(root);
-      let previewResult = null;
-      const dirtyRepos = [rootRepo, ...packageReports].filter((repo) => repo.dirty).map((repo) => repo.name);
-      if (executionMode === "plan") {
-        for (const report of [rootRepo, ...packageReports]) {
-          const local = branchExists(report.path, branchName);
-          const remote = remoteBranchExists(report.path, branchName);
-          report.created = !local && !remote;
-          report.resumed = local || remote;
-        }
-        const previewPlan = preview ? await reconcileBranchPreview({
-          root,
-          branch: branchName,
-          planOnly: true,
-          execute: false,
-          initialize: !branchPreviewInitialized(root, branchName),
-          env: helpers.context.env
-        }) : null;
-        return buildWorkflowResult(
-          "switch",
-          root,
-          {
-            mode,
-            branchName,
-            rootRepo,
-            repos: packageReports,
-            previewRequested: preview,
-            worktreeMode: input.worktreeMode ?? "auto",
-            worktreePath: effectiveWorkflowWorktreeMode(input.worktreeMode, helpers.context.env) === "on" ? plannedManagedWorkflowWorktreePath(root, branchName) : null,
-            blockers: !adoptChanges && dirtyRepos.length > 0 ? [`Clean worktrees required: ${dirtyRepos.join(", ")}`] : [],
-            plannedSteps: [
-              { id: "switch-root", description: `Switch market repo to ${branchName}` },
-              ...packageReports.map((report) => ({ id: `switch-${report.name}`, description: `Mirror ${branchName} into ${report.name}` })),
-              { id: "workspace-link", description: "Apply local workspace links for integrated development" },
-              ...preview ? [{ id: "preview", description: `Provision or refresh preview for ${branchName}` }] : []
-            ],
-            previewPlan
-          },
-          {
-            executionMode,
-            nextSteps: createNextSteps([
-              { operation: "switch", reason: "Run without --plan to create or resume the task branch.", input: { branch: branchName, preview } }
-            ])
-          }
-        );
-      }
-      if (adoptChanges) {
-        const reports = [rootRepo, ...packageReports];
-        const existingTargets = reports.filter((report) => branchExists(report.path, branchName) || remoteBranchExists(report.path, branchName));
-        if (existingTargets.length > 0) {
-          workflowError("switch", "validation_failed", `--adopt-changes requires a new branch; ${branchName} already exists in ${existingTargets.map((report) => report.name).join(", ")}.`);
-        }
-        const unsafeDirtyRepos = reports.filter((report) => report.dirty && currentBranch(report.path) !== STAGING_BRANCH);
-        if (unsafeDirtyRepos.length > 0) {
-          workflowError("switch", "validation_failed", `--adopt-changes only accepts dirty staging repositories: ${unsafeDirtyRepos.map((report) => report.name).join(", ")}.`);
-        }
-      } else if (mode === "recursive-workspace") {
-        assertWorkspaceClean(root);
-        assertSessionBranchSafety("switch", session);
-      } else {
-        assertCleanWorktree(root);
-      }
-      const workflowRun = acquireWorkflowRun(
-        "switch",
-        session,
-        { branch: branchName, preview, adoptChanges, worktreeMode: input.worktreeMode ?? "auto" },
-        [
-          { id: "switch-root", description: `Switch market repo to ${branchName}`, repoName: rootRepo.name, repoPath: rootRepo.path, branch: branchName, resumable: true },
-          ...packageReports.map((report) => ({
-            id: `switch-${report.name}`,
-            description: `Mirror ${branchName} into ${report.name}`,
-            repoName: report.name,
-            repoPath: report.path,
-            branch: branchName,
-            resumable: true
-          })),
-          { id: "workspace-link", description: "Apply local workspace links", repoName: rootRepo.name, repoPath: rootRepo.path, branch: branchName, resumable: true },
-          ...preview ? [{ id: "preview", description: `Provision or refresh preview ${branchName}`, repoName: rootRepo.name, repoPath: rootRepo.path, branch: branchName, resumable: true }] : []
-        ],
-        helpers.context
-      );
-      try {
-        const rootSwitch = await executeJournalStep(
-          root,
-          workflowRun.runId,
-          "switch-root",
-          () => (adoptChanges ? checkoutNewTaskBranchWithChanges : checkoutTaskBranchFromStaging)(repoDir, branchName, {
-            createIfMissing: input.createIfMissing !== false,
-            pushIfCreated: true
-          })
-        );
-        rootRepo.branch = currentBranch(repoDir) || branchName;
-        rootRepo.created = rootSwitch.created;
-        rootRepo.resumed = rootSwitch.resumed;
-        rootRepo.commitSha = headCommit(repoDir);
-        rootRepo.pushed = rootSwitch.created;
-        for (const managedRepo of checkedOutManagedWorkflowRepos(root)) {
-          const report = findReportByName(packageReports, managedRepo.name);
-          if (!report) {
-            continue;
-          }
-          const shouldAdoptRepoChanges = adoptChanges && hasMeaningfulChanges(managedRepo.dir);
-          const packageSwitch = await executeJournalStep(
-            root,
-            workflowRun.runId,
-            `switch-${report.name}`,
-            () => (shouldAdoptRepoChanges ? checkoutNewTaskBranchWithChanges : checkoutTaskBranchFromStaging)(managedRepo.dir, branchName, {
-              createIfMissing: input.createIfMissing !== false,
-              pushIfCreated: false
-            })
-          );
-          report.branch = currentBranch(managedRepo.dir) || branchName;
-          report.created = packageSwitch.created;
-          report.resumed = packageSwitch.resumed;
-          report.commitSha = headCommit(managedRepo.dir);
-          report.dirty = hasMeaningfulChanges(managedRepo.dir);
-        }
-        const workspaceLinks = await executeJournalStep(root, workflowRun.runId, "workspace-link", () => ensureWorkflowWorkspaceLinks(root, helpers, input.workspaceLinks ?? "auto"));
-        const stateAfterSwitch = resolveWorkflowState(root);
-        if (preview) {
-          previewResult = await executeJournalStep(
-            root,
-            workflowRun.runId,
-            "preview",
-            () => reconcileWorkflowBranchPreview(root, branchName, helpers.context, { initialize: !stateAfterSwitch.preview.enabled })
-          ) ?? null;
-        }
-        const state = resolveWorkflowState(root);
-        const payload = {
-          mode,
-          branchName,
-          created: rootRepo.created,
-          resumed: rootRepo.resumed,
-          repos: packageReports,
-          rootRepo,
-          previewRequested: preview,
-          preview: {
-            enabled: state.preview.enabled,
-            url: state.preview.url,
-            lastDeploymentTimestamp: state.preview.lastDeploymentTimestamp
-          },
-          previewResult,
-          workspaceLinks,
-          ...worktreePayload(root, input.worktreeMode),
-          preconditions: {
-            cleanWorktreeRequired: !adoptChanges,
-            adoptedDirtyStagingChanges: adoptChanges,
-            baseBranch: STAGING_BRANCH
-          }
-        };
-        completeWorkflowRun(root, workflowRun.runId, payload);
-        return buildWorkflowResult(
-          "switch",
-          root,
-          payload,
-          {
-            runId: workflowRun.runId,
-            nextSteps: createNextSteps([
-              state.preview.enabled ? { operation: "save", reason: "Persist and verify the current task branch, then refresh its preview deployment.", input: { message: "describe your change", preview: true } } : { operation: "dev", reason: "Start the local development environment for this task branch." },
-              { operation: "stage", reason: "Merge the task into staging once the task branch is verified.", input: { message: "describe the resolution" } }
-            ])
-          }
-        );
-      } catch (error) {
-        failWorkflowRun(root, workflowRun.runId, error, {
-          resumable: true,
-          runId: workflowRun.runId,
-          command: "switch",
-          message: `Resume the interrupted switch for ${branchName}.`,
-          recoverCommand: "treeseed recover",
-          resumeCommand: `treeseed resume ${workflowRun.runId}`
-        });
-        throw error;
-      }
-    });
-  } catch (error) {
-    toError("switch", error);
-  }
-}
-function normalizeUpdateStrategy(strategy) {
-  return strategy === "ff-only" ? "ff-only" : "merge";
-}
-function normalizeUpdateSource(source) {
-  const normalized = String(source ?? STAGING_BRANCH).trim();
-  return normalized || STAGING_BRANCH;
-}
-function gitOutput(args, cwd, allowFailure = false) {
-  return runRepositoryGit(args, {
-    cwd,
-    mode: classifyGitMode(args),
-    allowFailure
-  }).stdout.trim();
-}
-function updateHead(repoDir) {
-  return gitOutput(["rev-parse", "HEAD"], repoDir, true) || null;
-}
-function updateStatusLines(repoDir) {
-  const output = gitOutput(["status", "--porcelain"], repoDir, true);
-  return output ? output.split(/\r?\n/u).filter(Boolean) : [];
-}
-function updateChangedFiles(repoDir) {
-  return updateStatusLines(repoDir).map((line) => line[1] === " " && line[2] !== " " ? line.slice(2).trim() : line.slice(3).trim()).filter(Boolean);
-}
-function updateConflictedFiles(repoDir) {
-  return updateStatusLines(repoDir).filter((line) => {
-    const status = line.slice(0, 2);
-    return status.includes("U") || ["AA", "DD"].includes(status);
-  }).map((line) => line.slice(3).trim()).filter(Boolean);
-}
-function sourceBranchExists(repoDir, sourceBranch) {
-  return runRepositoryGit(["ls-remote", "--exit-code", "--heads", "origin", sourceBranch], {
-    cwd: repoDir,
-    mode: "read",
-    allowFailure: true
-  }).status === 0;
-}
-function localRemoteRefExists(repoDir, sourceBranch) {
-  return runGitOk(["show-ref", "--verify", `refs/remotes/origin/${sourceBranch}`], {
-    cwd: repoDir,
-    mode: "read"
-  });
-}
-export {
-  gitOutput,
-  localRemoteRefExists,
-  normalizeUpdateSource,
-  normalizeUpdateStrategy,
-  sourceBranchExists,
-  updateChangedFiles,
-  updateConflictedFiles,
-  updateHead,
-  updateStatusLines,
-  workflowSwitch
-};