git-workspace-bare 0.1.1 → 0.3.1

package/lib/clone-repository.js

@@ -0,0 +1,51 @@
+import fs from 'bare-fs'
+import { spawnSync } from 'bare-subprocess'
+import networkEnvironment from './git-network-environment.js'
+
+export default function cloneRepository(repository, directory, { initialize = false } = {}) {
+  const remote = `git@github.com:${repository}.git`
+  const clone = spawnSync('git', ['clone', remote, directory], {
+    stdio: 'inherit',
+    ...(initialize ? { env: networkEnvironment() } : {})
+  })
+  if (clone.error) throw clone.error
+  // An interrupted command is not a request to create a different repository.
+  if (clone.signal) throw new Error(`Git clone was interrupted by signal ${clone.signal}`)
+  if (clone.status === 0) return
+  if (!initialize) throw new Error(`Could not clone ${repository}`)
+  if (!emptyDestination(directory)) {
+    const err = new Error(
+      `Could not clone ${repository}; destination is not an empty directory: ${directory}`
+    )
+    err.hint = 'the destination was preserved; inspect the failed clone before retrying'
+    throw err
+  }
+
+  git(['init', directory])
+  git(['-C', directory, 'remote', 'add', 'origin', remote])
+  console.error(
+    `warning: could not clone ${repository}; initialized an empty local repository with origin configured`
+  )
+  console.error(
+    'hint: create the GitHub repository or synchronize with its existing history when ready; no project commits were pushed'
+  )
+}
+
+export function emptyDestination(directory) {
+  let entry
+  try {
+    entry = fs.lstatSync(directory)
+  } catch (err) {
+    if (err.code === 'ENOENT') return true
+    throw err
+  }
+  return entry.isDirectory() && !entry.isSymbolicLink() && fs.readdirSync(directory).length === 0
+}
+
+function git(args) {
+  const result = spawnSync('git', args)
+  if (result.error) throw result.error
+  if (result.signal || result.status !== 0) {
+    throw new Error(result.stderr?.toString().trim() || 'Could not initialize local repository')
+  }
+}

package/lib/commit-manifest.js

@@ -0,0 +1,29 @@
+import { spawnSync } from 'bare-subprocess'
+import pushManifest from './push-manifest.js'
+
+export default function commitManifest(directory, message) {
+  git(directory, ['add', '--', 'workspace.json'])
+  const diff = spawnSync('git', [
+    '-C',
+    directory,
+    'diff',
+    '--cached',
+    '--quiet',
+    '--',
+    'workspace.json'
+  ])
+  if (diff.error) throw diff.error
+  if (diff.status !== 0 && diff.status !== 1) {
+    throw new Error(diff.stderr?.toString().trim() || 'Could not inspect manifest changes')
+  }
+  if (diff.status === 1) {
+    git(directory, ['commit', '--only', '-m', message, '--', 'workspace.json'])
+  }
+  pushManifest(directory)
+}
+
+function git(directory, args) {
+  const result = spawnSync('git', ['-C', directory, ...args])
+  if (result.error) throw result.error
+  if (result.status !== 0) throw new Error(result.stderr?.toString().trim() || 'Git command failed')
+}

package/lib/completion.js

@@ -0,0 +1,93 @@
+import { spawnSync } from 'bare-subprocess'
+import { readManifest } from './registry.js'
+import { manifestNames } from './manifest.js'
+import repositoryPath from './repository-path.js'
+
+// The last word is the partial word at the cursor, including an empty word.
+// Never parse this request as a command: completing a mutation must only read.
+export default function completion(words, definition) {
+  const current = words.at(-1) || ''
+  const previous = words.slice(0, -1)
+  let command = definition
+  let name = null
+  const args = []
+  let positional = false
+
+  for (const word of previous) {
+    if (!positional && word === '--') {
+      positional = true
+    } else if (!positional && word.startsWith('-')) {
+      // Current flags are booleans; help/version terminate the invocation.
+      if (['-h', '--help', '--version'].includes(word)) return []
+      const flags = Object.keys(command.flags).flatMap((flag) => flag.split('|'))
+      if (!flags.includes(word)) return []
+    } else if (name === null) {
+      if (!Object.hasOwn(definition.commands, word)) return []
+      name = word
+      command = definition.commands[name]
+    } else {
+      args.push(word)
+    }
+  }
+
+  let candidates = []
+  if (!positional && current.startsWith('-')) {
+    candidates = Object.keys(command.flags).flatMap((flag) => flag.split('|'))
+  } else if (name === null) {
+    candidates = Object.keys(definition.commands)
+  } else if (name === 'hook' && args.length === 0) {
+    candidates = Object.keys(command.commands)
+  } else if (name === 'completion' && args.length === 0) {
+    candidates = ['bash']
+  } else if (name === 'rename' && args.length === 1) {
+    // The target is a new name. Offer the required prefix, not existing targets.
+    if (args[0].includes('@')) candidates = [args[0].split('@')[0] + '@']
+  } else if (args.length === 0 && ['add', 'remove', 'rename'].includes(name)) {
+    try {
+      const manifest = readManifest()
+      if (name !== 'add') {
+        candidates = manifestNames(manifest)
+      } else if (current.includes('@')) {
+        const root = current.split('@')[0]
+        if (manifest.repositories.some(({ name }) => name === root)) {
+          candidates = branches(root).map((branch) => `${root}@${branch}`)
+        }
+      } else {
+        candidates = manifest.repositories.map(({ name }) => name)
+      }
+    } catch {
+      // Tab must stay quiet for an uninitialized, missing, or invalid workspace.
+      return []
+    }
+  }
+
+  return [...new Set(candidates)].filter((candidate) => candidate.startsWith(current)).sort()
+}
+
+function branches(repository) {
+  const result = spawnSync('git', [
+    '--no-optional-locks',
+    '-C',
+    repositoryPath(repository),
+    'for-each-ref',
+    '--format=%(refname) %(symref)',
+    'refs/heads/',
+    'refs/remotes/origin/'
+  ])
+  if (result.error || result.status !== 0) return []
+  return result.stdout
+    .toString()
+    .split('\n')
+    .flatMap((line) => {
+      const [ref, symbolic] = line.trim().split(' ')
+      if (!ref || symbolic) return []
+      const branch = ref.replace(/^refs\/(?:heads|remotes\/origin)\//, '')
+      try {
+        // Only suggest branch names that the workspace CLI accepts.
+        repositoryPath(`${repository}@${branch}`)
+        return [branch]
+      } catch {
+        return []
+      }
+    })
+}

package/lib/git-network-environment.js

@@ -0,0 +1,31 @@
+import env from 'bare-env'
+import { spawnSync } from 'bare-subprocess'
+
+export default function networkEnvironment(directory) {
+  const environment = { ...env, GIT_TERMINAL_PROMPT: '0' }
+  // Preserve custom SSH programs. Supply bounded, noninteractive connection
+  // defaults only for ordinary OpenSSH, including offline manifest pushes.
+  if (
+    env.GIT_SSH_COMMAND !== undefined ||
+    env.GIT_SSH !== undefined ||
+    config(directory, 'core.sshCommand') !== null
+  ) {
+    return environment
+  }
+  const variant = env.GIT_SSH_VARIANT || config(directory, 'ssh.variant')
+  if (variant && !['ssh', 'auto'].includes(variant)) return environment
+  environment.GIT_SSH_COMMAND = 'ssh -o ConnectTimeout=5 -o ConnectionAttempts=1 -o BatchMode=yes'
+  return environment
+}
+
+function config(directory, key) {
+  const args = directory ? ['-C', directory] : []
+  const result = spawnSync('git', [...args, 'config', '--get', key])
+  if (result.error) throw result.error
+  if (result.signal) throw new Error(`Git config was interrupted by signal ${result.signal}`)
+  if (result.status === 1) return null
+  if (result.status !== 0) {
+    throw new Error(result.stderr?.toString().trim() || 'Could not read Git config')
+  }
+  return result.stdout.toString().replace(/\r?\n$/, '')
+}

package/lib/hook-context.js

@@ -0,0 +1,239 @@
+import fs from 'bare-fs'
+import os from 'bare-os'
+import path from 'bare-path'
+import { randomUUID } from 'bare-crypto'
+import { spawnSync } from 'bare-subprocess'
+import { readManifest, registryPath } from './registry.js'
+import repositoryPath from './repository-path.js'
+import Hooks from './hooks.js'
+
+// Hook metadata is observational: failure to collect it must not change the command outcome.
+export function observe(fn) {
+  try {
+    return fn()
+  } catch (err) {
+    console.error(`warning: could not prepare post hook context: ${err.message}`)
+    return null
+  }
+}
+
+export function withPostHooks(command, input, options, fn) {
+  for (const name of Object.values(input)) repositoryPath(name)
+  const hooks = new Hooks(options)
+  const operation = hooks.has(command)
+    ? observe(() => beginOperation(command, input, readManifest()))
+    : null
+  let error = null
+  try {
+    return fn()
+  } catch (err) {
+    error = err
+    throw err
+  } finally {
+    if (operation) hooks.run(observe(() => finishOperation(operation, readManifest(), error)))
+  }
+}
+
+export function beginOperation(
+  command,
+  input,
+  manifest,
+  { source = 'cli', known = manifest } = {}
+) {
+  const names = [input.repository || input.from]
+  if (command === 'add' && input.repository.includes('@')) {
+    names.unshift(input.repository.split('@')[0])
+  }
+  if (command === 'rename' && !input.from.includes('@')) {
+    const root = manifest.repositories.find((repo) => repo.name === input.from)
+    for (const entry of root?.worktrees || []) names.push(`${input.from}@${entry.branch}`)
+    // Root renames also move unregistered linked worktrees in the workspace layout.
+    const prefix = repositoryPath(input.from) + '@'
+    const linked = git(repositoryPath(input.from), ['worktree', 'list', '--porcelain', '-z'])
+    for (const field of (linked || '').split('\0')) {
+      if (field.startsWith('worktree ' + prefix)) {
+        names.push(input.from + field.slice('worktree '.length + prefix.length - 1))
+      }
+    }
+  }
+  const targets = [...new Set(names)].map((from) => {
+    const to = command === 'rename' ? input.to + from.slice(input.from.length) : from
+    return {
+      from,
+      to,
+      destinationExisted: exists(checkoutPath(to)),
+      before: checkout(from, manifest, identity(from, known))
+    }
+  })
+  return {
+    context: {
+      version: 1,
+      command,
+      phase: 'post',
+      operation: { id: randomUUID(), source, resumed: false },
+      workspace: { root: path.join(os.homedir(), 'workspace'), manifest: registryPath() },
+      input
+    },
+    targets
+  }
+}
+
+export function finishOperation(operation, manifest, error = null) {
+  const { context, targets } = operation
+  const checkouts = targets.map(({ from, to, destinationExisted, before }) => {
+    // On a failed rename, an occupied destination is not the checkout we moved.
+    const moved =
+      from !== to && !destinationExisted && !exists(checkoutPath(from)) && exists(checkoutPath(to))
+    const name = moved ? to : from
+    const after = checkout(name, manifest, before)
+    return { before, after }
+  })
+  const changed = checkouts.some(
+    ({ before, after }) => JSON.stringify(before) !== JSON.stringify(after)
+  )
+  return {
+    ...context,
+    result: {
+      status: error ? (changed ? 'partial' : 'error') : 'ok',
+      data: { changed, checkouts },
+      error: error ? { message: error.message, code: error.code || null } : null
+    }
+  }
+}
+
+export function validateHookProgress(state, actions) {
+  const validContext = (context, action) => {
+    const input =
+      action?.type === 'rename'
+        ? { from: action.from, to: action.to }
+        : { repository: action?.from || action?.to }
+    return (
+      action &&
+      context?.version === 1 &&
+      context.phase === 'post' &&
+      context.command === action.type &&
+      JSON.stringify(context.input) === JSON.stringify(input) &&
+      typeof context.operation?.id === 'string' &&
+      /^[a-z0-9-]+$/i.test(context.operation.id) &&
+      context.operation.source === 'pull' &&
+      typeof context.operation.resumed === 'boolean' &&
+      context.workspace?.root === path.join(os.homedir(), 'workspace') &&
+      context.workspace.manifest === registryPath()
+    )
+  }
+  const validCheckout = (entry) => {
+    if (!entry || typeof entry.name !== 'string') return false
+    return (
+      entry.path === checkoutPath(entry.name) &&
+      ['repository', 'worktree'].includes(entry.kind) &&
+      (entry.id === null || typeof entry.id === 'string') &&
+      typeof entry.exists === 'boolean' &&
+      typeof entry.registered === 'boolean' &&
+      typeof entry.repository?.name === 'string' &&
+      entry.repository.path === repositoryPath(entry.repository.name) &&
+      (entry.repository.id === null || typeof entry.repository.id === 'string')
+    )
+  }
+  const active = state.hookOperation
+  const post = state.postHook
+  let valid = true
+  try {
+    if (active) {
+      const action = actions[state.completed]
+      valid =
+        state.pending &&
+        validContext(active.context, action) &&
+        Array.isArray(active.targets) &&
+        active.targets.length > 0 &&
+        active.targets.every((target) => {
+          const from = action.from || action.to
+          const expected =
+            action.type === 'rename' ? action.to + target.from.slice(from.length) : target.from
+          return (
+            typeof target.from === 'string' &&
+            typeof target.to === 'string' &&
+            (target.from === from ||
+              (!from.includes('@') && target.from.startsWith(from + '@')) ||
+              (action.type === 'add' && target.from === from.split('@')[0])) &&
+            target.to === expected &&
+            typeof target.destinationExisted === 'boolean' &&
+            validCheckout(target.before) &&
+            target.before.name === target.from
+          )
+        })
+    }
+    if (post) {
+      valid =
+        valid &&
+        validContext(post, actions[state.pending ? state.completed : state.completed - 1]) &&
+        (state.pending
+          ? ['partial', 'error'].includes(post.result?.status)
+          : post.result?.status === 'ok') &&
+        (!active || active.context.operation.id === post.operation.id) &&
+        typeof post.result?.data?.changed === 'boolean' &&
+        Array.isArray(post.result.data.checkouts) &&
+        post.result.data.checkouts.length > 0 &&
+        post.result.data.checkouts.every(
+          ({ before, after }) => validCheckout(before) && validCheckout(after)
+        )
+    }
+  } catch {
+    valid = false
+  }
+  if (!valid) throw new Error('Invalid hook progress; inspect .git/workspace-pull.json')
+}
+
+function identity(name, manifest) {
+  const [base] = name.split('@')
+  const branch = name.includes('@') ? name.slice(base.length + 1) : null
+  const root = manifest.repositories.find((repo) => repo.name === base)
+  const entry = branch !== null ? root?.worktrees.find((entry) => entry.branch === branch) : root
+  return { id: entry?.id || null, repository: { id: root?.id || null } }
+}
+
+function checkout(name, manifest, known) {
+  const [base] = name.split('@')
+  const requested = name.includes('@') ? name.slice(base.length + 1) : null
+  const directory = checkoutPath(name)
+  const root = repositoryPath(base)
+  const entry = identity(name, manifest)
+  const present = exists(directory)
+  return {
+    id: entry.id || known.id,
+    kind: requested !== null ? 'worktree' : 'repository',
+    name,
+    path: directory,
+    repository: { id: entry.repository.id || known.repository.id, name: base, path: root },
+    exists: present,
+    registered: entry.id !== null,
+    branch: present ? git(directory, ['symbolic-ref', '--quiet', '--short', 'HEAD']) : null,
+    // Retain the requested local ref even when the worktree directory has disappeared.
+    ref: requested ? git(root, ['rev-parse', '--verify', `refs/heads/${requested}`]) : null,
+    origin: requested !== null ? null : git(root, ['config', '--get', 'remote.origin.url'])
+  }
+}
+
+function checkoutPath(name) {
+  // A root rename can also move unregistered worktrees made with ordinary Git.
+  // Their suffixes may use characters the CLI does not accept as input names.
+  const [base] = name.split('@')
+  const directory = repositoryPath(base) + name.slice(base.length)
+  if (path.normalize(directory) !== directory) throw new Error('Invalid checkout path')
+  return directory
+}
+
+function exists(directory) {
+  try {
+    fs.lstatSync(directory)
+    return true
+  } catch (err) {
+    if (err.code !== 'ENOENT' && err.code !== 'ENOTDIR') throw err
+    return false
+  }
+}
+
+function git(directory, args) {
+  const result = spawnSync('git', ['--no-optional-locks', '-C', directory, ...args])
+  if (result.error) throw result.error
+  return result.status === 0 ? result.stdout.toString().replace(/\r?\n$/, '') : null
+}

package/lib/hooks.js

@@ -0,0 +1,87 @@
+import fs from 'bare-fs'
+import path from 'bare-path'
+import os from 'bare-os'
+import env from 'bare-env'
+import { spawnSync } from 'bare-subprocess'
+
+export function discoverHooks() {
+  const found = new Map()
+  for (const directory of (env.PATH || '').split(path.delimiter)) {
+    let names
+    try {
+      names = fs.readdirSync(directory || '.')
+    } catch {
+      continue
+    }
+    for (const executable of names) {
+      const match = /^git-workspace-hook-(add|remove|rename)-post-([a-z0-9][a-z0-9_-]*)$/.exec(
+        executable
+      )
+      if (!match || found.has(executable)) continue
+      const file = path.resolve(directory || '.', executable)
+      try {
+        if (!fs.statSync(file).isFile()) continue
+        fs.accessSync(file, fs.constants.X_OK)
+      } catch {
+        continue
+      }
+      found.set(executable, { command: match[1], name: match[2], executable, path: file })
+    }
+  }
+  return [...found.values()].sort((a, b) => (a.executable < b.executable ? -1 : 1))
+}
+
+export default class Hooks {
+  constructor({ noHooks = false } = {}) {
+    this.entries = noHooks || env.GIT_WORKSPACE_HOOK ? [] : discoverHooks()
+  }
+
+  has(command) {
+    return this.entries.some((hook) => hook.command === command)
+  }
+
+  run(context) {
+    if (!context) return
+    for (const hook of this.entries.filter((hook) => hook.command === context.command)) {
+      let input
+      try {
+        input = openInput(context)
+        const result = spawnSync(hook.path, [context.command, 'post'], {
+          cwd: context.workspace.root,
+          env: { ...env, GIT_WORKSPACE_HOOK: '1' },
+          stdio: [input === 0 ? 'inherit' : input, 2, 2]
+        })
+        if (result.error) throw result.error
+        if (result.signal || result.status !== 0) {
+          throw new Error(
+            result.signal ? `signal ${result.signal}` : `exit status ${result.status}`
+          )
+        }
+      } catch (err) {
+        console.error(`warning: hook ${hook.executable} failed: ${err.message}`)
+      } finally {
+        if (input !== undefined) fs.closeSync(input)
+      }
+    }
+  }
+}
+
+function openInput(context) {
+  // bare-subprocess 6.x does not write/close spawnSync's input pipe. An unlinked
+  // read-only file descriptor provides the same stdin protocol, including EOF,
+  // without pipe limits or temporary files left behind if a hook kills the CLI.
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'git-workspace-hook-'))
+  const file = path.join(directory, 'input.json')
+  let input
+  try {
+    fs.writeFileSync(file, JSON.stringify(context) + '\n', { mode: 0o600 })
+    input = fs.openSync(file, 'r')
+    fs.unlinkSync(file)
+    fs.rmdirSync(directory)
+    return input
+  } catch (err) {
+    if (input !== undefined) fs.closeSync(input)
+    fs.rmSync(directory, { recursive: true, force: true })
+    throw err
+  }
+}

package/lib/init.js

@@ -2,10 +2,15 @@ import fs from 'bare-fs'
 import path from 'bare-path'
 import { spawnSync } from 'bare-subprocess'
 import repositoryPath from './repository-path.js'
-import { configPath, manifestDirectory, readRegistry } from './registry.js'
+import { configPath, manifestDirectory, readManifest } from './registry.js'
+import commitManifest from './commit-manifest.js'
+import { emptyManifest } from './manifest.js'
+import { refreshCheckpoint } from './checkpoint.js'
+import { assertNoPendingPull } from './pull-state.js'
 
 export default function init(repository) {
   const directory = repositoryPath(repository)
+  assertNoPendingPull(directory)
   if (repository.includes('@')) throw new Error('Expected a manifest repository in owner/repo form')
 
   if (fs.existsSync(configPath()) && manifestDirectory() !== directory) {
@@ -60,10 +65,17 @@ export default function init(repository) {
     hasManifest = false
   }
   if (!hasManifest) {
-    fs.writeFileSync(manifest, '[]\n')
-  } else {
-    readRegistry(manifest)
+    fs.writeFileSync(manifest, JSON.stringify(emptyManifest(), null, 2) + '\n')
+    try {
+      commitManifest(directory, 'Initialize workspace manifest')
+    } catch (err) {
+      err.message = `Created ${manifest}, but could not commit it: ${err.message}`
+      err.hint =
+        'resolve the Git error, commit only workspace.json in the manifest repository, then rerun init'
+      throw err
+    }
   }
+  if (hasManifest) readManifest(manifest)
   fs.mkdirSync(path.dirname(configPath()), { recursive: true })
   const lock = configPath() + '.lock'
   fs.mkdirSync(lock)
@@ -75,6 +87,7 @@ export default function init(repository) {
     if (fs.existsSync(pending)) fs.unlinkSync(pending)
     fs.rmdirSync(lock)
   }
+  refreshCheckpoint(directory)
 }
 
 function git(args, options) {

package/lib/manifest.js

@@ -0,0 +1,102 @@
+import { randomUUID } from 'bare-crypto'
+import repositoryPath from './repository-path.js'
+
+export function emptyManifest() {
+  return { version: 1, repositories: [] }
+}
+
+export function manifestNames(manifest) {
+  validateManifest(manifest)
+  return manifest.repositories.flatMap(({ name, worktrees }) => [
+    name,
+    ...worktrees.map(({ branch }) => `${name}@${branch}`)
+  ])
+}
+
+export function validateManifest(manifest) {
+  if (!manifest || manifest.version !== 1 || !Array.isArray(manifest.repositories)) {
+    throw new Error('Invalid workspace manifest: expected version 1 and a repositories array')
+  }
+  const ids = new Set()
+  const names = []
+  const checkId = (entry) => {
+    if (!entry || typeof entry.id !== 'string' || !/^[a-z0-9_-]+$/i.test(entry.id)) {
+      throw new Error('Invalid workspace manifest: every repository and worktree needs an ID')
+    }
+    if (ids.has(entry.id)) throw new Error(`Duplicate manifest ID: ${entry.id}`)
+    ids.add(entry.id)
+  }
+  for (const repository of manifest.repositories) {
+    checkId(repository)
+    if (
+      typeof repository.name !== 'string' ||
+      repository.name.includes('@') ||
+      !Array.isArray(repository.worktrees)
+    ) {
+      throw new Error('Invalid manifest repository: expected owner/repo and a worktrees array')
+    }
+    names.push(repository.name)
+    for (const worktree of repository.worktrees) {
+      checkId(worktree)
+      if (typeof worktree.branch !== 'string' || !worktree.branch) {
+        throw new Error('Invalid manifest worktree: expected a branch')
+      }
+      names.push(`${repository.name}@${worktree.branch}`)
+    }
+  }
+  validateNames(names)
+}
+
+function validateNames(names) {
+  const unique = new Set()
+  for (const name of names) {
+    if (typeof name !== 'string') {
+      throw new Error('Invalid manifest entry: expected a repository name')
+    }
+    repositoryPath(name)
+    if (unique.has(name)) throw new Error(`Duplicate manifest name: ${name}`)
+    unique.add(name)
+  }
+  for (const name of names) {
+    const [root, branch] = name.split('@')
+    if (branch && !unique.has(root)) {
+      throw new Error(`Manifest worktree ${name} needs a root entry for ${root}`)
+    }
+  }
+}
+
+export function updateManifest(previous, names, rename) {
+  validateManifest(previous)
+  validateNames(names)
+  const renamed = (name) => {
+    if (!rename) return name
+    if (name === rename.from) return rename.to
+    if (!rename.from.includes('@') && name.startsWith(rename.from + '@')) {
+      return rename.to + name.slice(rename.from.length)
+    }
+    return name
+  }
+  const repositories = new Map()
+  const worktrees = new Map()
+  for (const repository of previous.repositories) {
+    repositories.set(renamed(repository.name), repository)
+    for (const worktree of repository.worktrees) {
+      worktrees.set(renamed(`${repository.name}@${worktree.branch}`), worktree)
+    }
+  }
+  const next = emptyManifest()
+  const roots = new Map()
+  for (const name of names.filter((name) => !name.includes('@'))) {
+    const existing = repositories.get(name)
+    const entry = { id: existing?.id || randomUUID(), name, worktrees: [] }
+    next.repositories.push(entry)
+    roots.set(name, entry)
+  }
+  for (const name of names.filter((name) => name.includes('@'))) {
+    const [root, branch] = name.split('@')
+    const existing = worktrees.get(name)
+    roots.get(root).worktrees.push({ id: existing?.id || randomUUID(), branch })
+  }
+  validateManifest(next)
+  return next
+}