@bevel-software/platform-core-backend 0.8.0 → 0.9.1

package/src/modules/workspace/workspace.service.ts

@@ -9,7 +9,6 @@ import { BevelIgnoreStack } from './bevel-ignore.js';
 import { assertValidBranchName } from '../workflow/git/branch-name.js';
 import { cloneTrackingConfigArgs, SAFE_IMPLICIT_FETCH_ARGS } from '../workflow/git/clone-config.js';
 import type { IDiffService } from '../diff/diff.interface.js';
-import type { IKbSeedService } from './kb-seed.interface.js';
 
 /**
  * Workspaces are per-branch, not per-user (PLAN §3). One on-disk clone per
@@ -119,22 +118,6 @@ export class WorkspaceService implements IWorkspaceService {
    */
   private readonly inFlightBootstraps = new Map<string, Promise<void>>();
 
-  /**
-   * Branches whose clone already got this process's scaffolding top-up.
-   * Per-process on purpose: each boot of a new build re-offers the top-up
-   * once, which is exactly when an upgrade's migrations must run. Cleared
-   * wherever `branchDirs` forgets a branch (delete, failed bootstrap), so a
-   * re-created clone is offered the top-up again rather than judged by the
-   * fate of one that no longer exists.
-   *
-   * `inFlightTopUps` is the concurrency half: membership in the Set is
-   * claimed BEFORE the (slow, file-moving) top-up finishes, so a concurrent
-   * caller that finds the branch claimed must still await the in-flight run
-   * — returning early would hand out a workspace mid-migration.
-   */
-  private readonly toppedUpBranches = new Set<string>();
-  private readonly inFlightTopUps = new Map<string, Promise<void>>();
-
   /** Per-workspace-dir `git fetch origin` timestamp + in-flight tracker. */
   private readonly lastFetchAt = new Map<string, number>();
   private readonly inFlightFetches = new Map<string, Promise<void>>();
@@ -145,14 +128,6 @@ export class WorkspaceService implements IWorkspaceService {
    */
   private diffService: IDiffService | null = null;
 
-  /**
-   * Late-bound by the composition root. Awaited once before the first per-branch
-   * clone so the KB remote is guaranteed to carry the protected branches + base
-   * scaffolding — a fresh (or partially-populated) remote is seeded rather than
-   * assumed. Null in tests / setups that pre-provision the remote themselves.
-   */
-  private seedService: IKbSeedService | null = null;
-
   /**
    * Late-bound by the composition root: notified with the workspace id
    * right after a branch's clone is created. The git layer uses this to
@@ -187,10 +162,6 @@ export class WorkspaceService implements IWorkspaceService {
     this.diffService = diffService;
   }
 
-  setSeedService(seedService: IKbSeedService): void {
-    this.seedService = seedService;
-  }
-
   setWorkspaceClonedListener(listener: (workspaceId: string) => void): void {
     this.onWorkspaceCloned = listener;
   }
@@ -354,11 +325,6 @@ export class WorkspaceService implements IWorkspaceService {
       // pulls it. Once per branch per process — the cached paths above return
       // before reaching here.
       await this.normalizeCloneTracking(repoDir, branch);
-      // Same restart-survivor reasoning for the scaffolding top-up: an
-      // UPGRADED deployment reuses this clone, so a top-up bound to fresh
-      // clones alone never runs a new build's scaffolding or migrations —
-      // the Groups→Plugins rename sat out an upgrade exactly this way.
-      await this.topUpScaffolding(repoDir, branch);
       this.branchDirs.set(branch, workspaceDir);
       return this.buildWorkspaceInfo(branch, workspaceDir);
     } catch {
@@ -384,22 +350,14 @@ export class WorkspaceService implements IWorkspaceService {
     this.inFlightBootstraps.set(branch, bootstrap);
 
     try {
-      // Ensure the remote is seeded before the first clone of any branch. A
-      // clone with `-b <branch>` fails outright on an empty remote, so seeding
-      // must happen ahead of it. The seed service is single-flight, so this is
-      // a cheap already-resolved await on every clone after the first.
-      if (this.seedService) {
-        await this.seedService.ensureRemoteSeeded();
-      }
+      // A clone with `-b <branch>` against a never-seeded remote fails
+      // naturally; seeding the remote is the KB startup phase's job, at boot.
       await fs.mkdir(workspaceDir, { recursive: true });
       await this.cloneProcessMapForBranch(workspaceDir, branch);
       this.branchDirs.set(branch, workspaceDir);
       resolveBootstrap();
     } catch (err) {
       this.branchDirs.delete(branch);
-      // The clone was rolled back, and any top-up claim belonged to it — a
-      // retried bootstrap must be offered the top-up afresh.
-      this.toppedUpBranches.delete(branch);
       rejectBootstrap(err);
       throw err;
     } finally {
@@ -444,7 +402,6 @@ export class WorkspaceService implements IWorkspaceService {
       await pending;
     } catch (err) {
       this.branchDirs.delete(branch);
-      this.toppedUpBranches.delete(branch);
       throw err;
     }
   }
@@ -475,44 +432,6 @@ export class WorkspaceService implements IWorkspaceService {
     }
   }
 
-  /**
-   * The ONE spelling of the best-effort scaffolding top-up (three call sites:
-   * the restart-survivor path in `getOrCreateForBranch`, and the
-   * already-cloned / fresh-clone paths in `cloneProcessMapForBranch`). Once
-   * per branch per process, and SINGLE-FLIGHT: the branch is claimed in
-   * `toppedUpBranches` before the run starts, so a concurrent caller that
-   * finds it claimed awaits the in-flight run instead of returning a
-   * workspace the migration is still moving files under. Never throws — a
-   * failed top-up costs the upgrade, not the clone.
-   */
-  private async topUpScaffolding(repoDir: string, branch: string): Promise<void> {
-    const seedService = this.seedService;
-    if (!seedService) return;
-    if (this.toppedUpBranches.has(branch)) {
-      await this.inFlightTopUps.get(branch);
-      return;
-    }
-    this.toppedUpBranches.add(branch);
-    const run = (async () => {
-      try {
-        await seedService.topUpWorkspace(repoDir, branch);
-      } catch (topUpErr) {
-        console.error(
-          `[workspace] scaffolding top-up failed for branch "${branch}" (clone kept):`,
-          redactError(topUpErr),
-        );
-      }
-    })();
-    this.inFlightTopUps.set(branch, run);
-    try {
-      await run;
-    } finally {
-      if (this.inFlightTopUps.get(branch) === run) {
-        this.inFlightTopUps.delete(branch);
-      }
-    }
-  }
-
   private async cloneProcessMapForBranch(workspaceDir: string, branch: string): Promise<void> {
     const targetDir = path.join(workspaceDir, this.kbDirName);
 
@@ -561,11 +480,6 @@ export class WorkspaceService implements IWorkspaceService {
         // it never touches the working tree, and a drifted config is what
         // breaks the next pull.
         await this.normalizeCloneTracking(targetDir, branch);
-        // An upgraded deployment REUSES this persistent clone, so a top-up
-        // bound to fresh clones alone never runs a new build's scaffolding
-        // or migrations here — the Groups→Plugins rename sat out an upgrade
-        // for exactly this reason.
-        await this.topUpScaffolding(targetDir, branch);
         return;
       }
       // Half-built dir — wipe and re-clone.
@@ -606,15 +520,6 @@ export class WorkspaceService implements IWorkspaceService {
           redactError(listenerErr),
         );
       }
-      // Fill in any base scaffolding this branch is missing, now that it's
-      // freshly checked out. Runs on whichever branch the user loaded (not
-      // just protected ones). Best-effort inside the helper — like the
-      // onWorkspaceCloned listener above — so even a future change that lets
-      // it throw can never roll back an otherwise-good clone. (The
-      // once-per-process guard is a formality here: a branch being freshly
-      // cloned was either never topped up or had its claim cleared with the
-      // clone it belonged to.)
-      await this.topUpScaffolding(targetDir, branch);
     } catch (err) {
       const redacted = redactError(err);
       console.error(`[workspace] Failed to clone for branch "${branch}":`, redacted);
@@ -643,10 +548,6 @@ export class WorkspaceService implements IWorkspaceService {
     await fs.rm(workspaceDir, { recursive: true, force: true });
     const branch = branchForWorkspaceId(workspaceId);
     this.branchDirs.delete(branch);
-    // The top-up claim died with the clone it was made against — a branch
-    // re-created later gets a fresh clone and must be offered it again (and
-    // without this, long-lived processes would accumulate dead branch names).
-    this.toppedUpBranches.delete(branch);
   }
 
   async listFiles(workspaceId: string, readFilter?: ReadTreeFilter): Promise<FileTreeEntry> {
@@ -1284,11 +1185,6 @@ export class WorkspaceService implements IWorkspaceService {
       try {
         await fs.rm(dir, { recursive: true, force: true });
         this.branchDirs.delete(branchForWorkspaceId(entry.name));
-        // The top-up claim dies with the clone (same rule as every other
-        // eviction site): a branch re-created after the sweep gets a fresh
-        // clone that must be OFFERED the scaffolding top-up, not judged by
-        // the fate of a directory that no longer exists.
-        this.toppedUpBranches.delete(branchForWorkspaceId(entry.name));
         removed.push(entry.name);
       } catch (err) {
         console.warn(