git-workspace-bare 0.1.1 → 0.3.0

package/test/pull.js

@@ -0,0 +1,696 @@
+import test from 'brittle'
+import fs from 'bare-fs'
+import path from 'bare-path'
+import os from 'bare-os'
+import setup from './helpers.js'
+import { changes } from '../lib/plan-pull.js'
+
+function machines(t, initial = ['owner/repo@jobs']) {
+  const context = setup(t)
+  const { ok, git, registry, home, upstream, cliAt } = context
+  for (const name of initial) ok('add', name)
+  const directory = path.dirname(registry)
+  git('clone', '--bare', directory, path.join(upstream, 'owner/workspace.git'))
+  const second = path.join(home, 'second')
+  fs.mkdirSync(second)
+  const cli = (...args) => cliAt(second, ...args)
+  const success = (...args) => {
+    const result = cli(...args)
+    if (result.status !== 0) throw new Error(result.stderr)
+    return result.stdout
+  }
+  success('init', 'owner/workspace')
+  for (const name of initial) success('add', name)
+  const local = path.join(second, 'workspace/owner/workspace')
+  const root = path.join(second, 'workspace/owner/repo')
+  const push = () => git('-C', directory, 'push', 'origin', 'main')
+  const head = () => git('-C', local, 'rev-parse', 'HEAD')
+  const applied = () => git('-C', local, 'rev-parse', 'refs/git-workspace/applied')
+  return { ...context, second, directory, cli, success, local, root, push, head, applied }
+}
+
+const repo = (id, name, worktrees = []) => ({ id, name, worktrees })
+const manifest = (...repositories) => ({ version: 1, repositories })
+
+function progress(directory) {
+  return JSON.parse(fs.readFileSync(path.join(directory, '.git/workspace-pull.json'), 'utf8'))
+}
+
+function interruptedPull(context, pattern, after = false) {
+  const { run, second } = context
+  const shim = path.join(second, 'git-shim')
+  fs.mkdirSync(shim)
+  const quote = (value) => "'" + value.replace(/'/g, "'\\''") + "'"
+  const realGit = quote(run('which', ['git']).stdout.trim())
+  const interrupt = after
+    ? `${realGit} "$@"\nresult=$?\nif [ "$result" = 0 ]; then kill -KILL "$PPID"; fi\nexit "$result"`
+    : 'kill -KILL "$PPID"\nexit 99'
+  fs.writeFileSync(
+    path.join(shim, 'git'),
+    `#!/bin/sh\ncase "$*" in\n  *${quote(pattern)}*)\n${interrupt}\n;;\nesac\nexec ${realGit} "$@"\n`,
+    { mode: 0o755 }
+  )
+  const runner = fs.realpathSync(new URL('./fixtures/cli.js', import.meta.url))
+  return run(os.execPath(), [runner, second, 'pull'], {
+    env: { PATH: shim + ':' + context.env.PATH }
+  })
+}
+
+test('pull plans IDs in dependency order, including root and branch renames', (t) => {
+  const previous = manifest(
+    repo('a', 'old/repo', [
+      { id: 'keep', branch: 'jobs' },
+      { id: 'remove', branch: 'retired' }
+    ]),
+    repo('b', 'owner/gone', [{ id: 'child', branch: 'child' }])
+  )
+  const desired = manifest(
+    repo('a', 'new/repo', [
+      { id: 'keep', branch: 'fixes' },
+      { id: 'new', branch: 'new' }
+    ]),
+    repo('c', 'owner/added', [{ id: 'added-child', branch: 'new' }])
+  )
+  const plan = changes(previous, desired)
+  t.alike(plan.blockers, [])
+  t.alike(
+    plan.actions.map(({ type, from, to }) => [type, from, to]),
+    [
+      ['remove', 'old/repo@retired', undefined],
+      ['remove', 'owner/gone@child', undefined],
+      ['remove', 'owner/gone', undefined],
+      ['rename', 'old/repo', 'new/repo'],
+      ['rename', 'new/repo@jobs', 'new/repo@fixes'],
+      ['add', undefined, 'owner/added'],
+      ['add', undefined, 'new/repo@new'],
+      ['add', undefined, 'owner/added@new']
+    ]
+  )
+  t.alike(changes(previous, previous).actions, [], 'unchanged IDs and names have no operations')
+  const rootOnly = changes(
+    previous,
+    manifest(repo('a', 'new/repo', previous.repositories[0].worktrees), previous.repositories[1])
+  )
+  t.is(rootOnly.actions.length, 1, 'root rename includes unchanged worktree names')
+})
+
+test('reused names are replacements and worktree identities cannot change parents or entry types', (t) => {
+  const before = manifest(repo('a', 'owner/repo', [{ id: 'w', branch: 'jobs' }]))
+  const replacement = changes(
+    before,
+    manifest(repo('b', 'owner/repo', [{ id: 'new-w', branch: 'jobs' }]))
+  )
+  t.alike(
+    replacement.actions.map(({ type }) => type),
+    ['remove', 'remove', 'add', 'add']
+  )
+  const moved = changes(
+    before,
+    manifest(repo('a', 'owner/repo'), repo('b', 'owner/new', [{ id: 'w', branch: 'jobs' }]))
+  )
+  t.ok(moved.blockers[0].includes('parent repository'))
+  const changedType = changes(before, manifest(repo('w', 'owner/new')))
+  t.ok(changedType.blockers[0].includes('entry type'))
+})
+
+test('two machines preview a root and branch rename without changing either checkout or applied state', (t) => {
+  const { ok, git, registry, root, local, second, cli, push, head, applied } = machines(t)
+  fs.writeFileSync(path.join(root, 'tracked.txt'), 'dirty root\n')
+  fs.writeFileSync(path.join(root + '@jobs', 'tracked.txt'), 'dirty worktree\n')
+  git('-C', root, 'add', 'tracked.txt')
+  const rootIndex = fs.readFileSync(path.join(root, '.git/index'))
+  const manifestIndex = fs.readFileSync(path.join(local, '.git/index'))
+  const before = head()
+  const checkpoint = applied()
+  const contents = fs.readFileSync(path.join(local, 'workspace.json'), 'utf8')
+  ok('rename', 'owner/repo', 'other/new')
+  ok('rename', 'other/new@jobs', 'other/new@fixes')
+  ok('add', 'other/new@feature/new')
+  push()
+  const result = cli('pull', '--dry-run')
+  t.is(result.status, 0, result.stderr)
+  t.ok(result.stdout.includes('Would fast-forward the manifest'))
+  t.ok(result.stdout.includes('rename owner/repo -> other/new'))
+  t.ok(result.stdout.includes('rename other/new@jobs -> other/new@fixes'))
+  t.ok(result.stdout.includes('add other/new@feature/new'))
+  t.absent(
+    result.stdout.includes('rename owner/repo@jobs'),
+    'no redundant root-induced branch rename'
+  )
+  t.is(head(), before)
+  t.is(applied(), checkpoint)
+  t.is(fs.readFileSync(path.join(local, 'workspace.json'), 'utf8'), contents)
+  t.alike(fs.readFileSync(path.join(root, '.git/index')), rootIndex)
+  t.alike(fs.readFileSync(path.join(local, '.git/index')), manifestIndex)
+  t.is(fs.readFileSync(path.join(root, 'tracked.txt'), 'utf8'), 'dirty root\n')
+  t.is(fs.readFileSync(path.join(root + '@jobs', 'tracked.txt'), 'utf8'), 'dirty worktree\n')
+  t.absent(fs.existsSync(path.join(second, 'workspace/other')), 'no destination parents created')
+  t.is(git('-C', root, 'config', '--get', 'remote.origin.url'), 'git@github.com:owner/repo.git')
+  t.absent(
+    fs.existsSync(path.join(root, '.git/FETCH_HEAD')),
+    'managed repositories are not fetched'
+  )
+  t.is(
+    git('-C', local, 'rev-parse', 'origin/main'),
+    git('-C', path.dirname(registry), 'rev-parse', 'HEAD'),
+    'fetch updates remote metadata'
+  )
+  t.is(cli('pull', '--dry-run').stdout, result.stdout, 'repeated preview is stable')
+})
+
+test('clean removals are planned child first, while dirty removals report blockers and keep all files', (t) => {
+  const { ok, root, cli, push, head, applied } = machines(t)
+  ok('remove', 'owner/repo@jobs')
+  ok('remove', 'owner/repo')
+  push()
+  const before = head()
+  const checkpoint = applied()
+  const clean = cli('pull', '--dry-run')
+  t.is(clean.status, 0, clean.stderr)
+  t.ok(clean.stdout.indexOf('remove owner/repo@jobs') < clean.stdout.indexOf('remove owner/repo\n'))
+  fs.writeFileSync(path.join(root, 'untracked.txt'), 'keep root\n')
+  fs.writeFileSync(path.join(root + '@jobs', 'tracked.txt'), 'keep worktree\n')
+  const dirty = cli('pull', '--dry-run')
+  t.is(dirty.status, 1)
+  t.ok(dirty.stdout.includes('blocked: remove owner/repo@jobs: Local changes'))
+  t.ok(dirty.stdout.includes('blocked: remove owner/repo: Local changes'))
+  t.is(head(), before)
+  t.is(applied(), checkpoint)
+  t.is(fs.readFileSync(path.join(root, 'untracked.txt'), 'utf8'), 'keep root\n')
+  t.is(fs.readFileSync(path.join(root + '@jobs', 'tracked.txt'), 'utf8'), 'keep worktree\n')
+})
+
+test('root rename reports occupied destinations, locked worktrees and invalid parent paths', (t) => {
+  const { ok, root, second, cli, push, git } = machines(t)
+  ok('rename', 'owner/repo', 'other/new')
+  push()
+  const owner = path.join(second, 'workspace/other')
+  fs.mkdirSync(owner)
+  const destination = path.join(owner, 'new')
+  fs.symlinkSync(path.join(second, 'absent'), destination)
+  t.ok(cli('pull', '--dry-run').stdout.includes('Destination already exists'))
+  fs.unlinkSync(destination)
+  fs.rmdirSync(owner)
+  fs.writeFileSync(owner, 'blocking parent')
+  t.ok(cli('pull', '--dry-run').stdout.includes('Destination parent is not a directory'))
+  fs.unlinkSync(owner)
+  git('-C', root, 'worktree', 'lock', root + '@jobs')
+  t.ok(cli('pull', '--dry-run').stdout.includes('Worktree is locked'))
+  git('-C', root, 'worktree', 'unlock', root + '@jobs')
+  git('-C', root, 'remote', 'set-url', 'origin', 'git@github.com:other/new.git')
+  t.is(cli('pull', '--dry-run').status, 0, 'origin may already be renamed manually')
+})
+
+test('missing and mismatched checkouts block preview even when no manifest changes are needed', (t) => {
+  const { cli, root, git } = machines(t)
+  t.is(cli('pull', '--dry-run').status, 0)
+  fs.renameSync(root + '@jobs', root + '@missing')
+  const missing = cli('pull', '--dry-run')
+  t.is(missing.status, 1)
+  t.ok(missing.stdout.includes('Missing checkout: owner/repo@jobs'))
+  fs.renameSync(root + '@missing', root + '@jobs')
+  git('-C', root + '@jobs', 'switch', '-c', 'different')
+  t.ok(cli('pull', '--dry-run').stdout.includes('not on branch jobs'))
+  git('-C', root + '@jobs', 'switch', 'jobs')
+  git('-C', root, 'remote', 'set-url', 'origin', 'git@github.com:wrong/repo.git')
+  t.ok(cli('pull', '--dry-run').stdout.includes('unexpected origin'))
+})
+
+test('existing branch targets and outside linked worktrees block unsafe operations', (t) => {
+  const { ok, root, second, cli, push, git } = machines(t)
+  ok('rename', 'owner/repo@jobs', 'owner/repo@fixes')
+  push()
+  git('-C', root, 'branch', 'fixes')
+  t.ok(cli('pull', '--dry-run').stdout.includes('Branch fixes already exists'))
+  git('-C', root, 'branch', '-D', 'fixes')
+  ok('remove', 'owner/repo@fixes')
+  ok('remove', 'owner/repo')
+  push()
+  const outside = path.join(second, 'outside')
+  git('-C', root, 'worktree', 'add', '-b', 'outside', outside)
+  t.ok(cli('pull', '--dry-run').stdout.includes('Linked worktree would remain'))
+})
+
+test('manifest working edits, staged edits and detached HEAD are rejected before fetch', (t) => {
+  const { cli, local, git, head, applied } = machines(t)
+  const before = head()
+  const checkpoint = applied()
+  const file = path.join(local, 'workspace.json')
+  const contents = fs.readFileSync(file, 'utf8')
+  fs.writeFileSync(file, contents + '\n')
+  t.ok(cli('pull', '--dry-run').stderr.includes('uncommitted changes'))
+  git('-C', local, 'add', 'workspace.json')
+  fs.writeFileSync(file, contents)
+  t.ok(cli('pull', '--dry-run').stderr.includes('uncommitted changes'))
+  git('-C', local, 'restore', '--staged', 'workspace.json')
+  git('-C', local, 'checkout', '--detach')
+  t.ok(cli('pull', '--dry-run').stderr.includes('detached HEAD'))
+  t.absent(fs.existsSync(path.join(local, '.git/FETCH_HEAD')))
+  t.is(head(), before)
+  t.is(applied(), checkpoint)
+})
+
+test('pull uses local ahead state and refuses divergent histories without changing HEAD', (t) => {
+  const { cli, local, directory, git, push, head, applied } = machines(t)
+  git('-C', local, 'commit', '--allow-empty', '-m', 'Local work')
+  const before = head()
+  const checkpoint = applied()
+  const ahead = cli('pull', '--dry-run')
+  t.is(ahead.status, 0, ahead.stderr)
+  t.ok(ahead.stdout.includes('ahead of the remote'))
+  t.ok(ahead.stdout.includes('No layout changes planned'))
+  git('-C', directory, 'commit', '--allow-empty', '-m', 'Other machine work')
+  push()
+  const divergent = cli('pull', '--dry-run')
+  t.is(divergent.status, 1)
+  t.ok(divergent.stderr.includes('histories have diverged'))
+  t.is(head(), before)
+  t.is(applied(), checkpoint)
+})
+
+test('first machine setup plans additions and adopts matching local roots without recording a baseline', (t) => {
+  const context = setup(t)
+  const { ok, git, home, upstream, registry, cliAt, checkAt } = context
+  ok('add', 'owner/repo@jobs')
+  git('clone', '--bare', path.dirname(registry), path.join(upstream, 'owner/workspace.git'))
+  const second = path.join(home, 'fresh')
+  fs.mkdirSync(second)
+  t.is(cliAt(second, 'init', 'owner/workspace').status, 0)
+  const initial = cliAt(second, 'pull', '--dry-run')
+  t.is(initial.status, 0, initial.stderr)
+  t.ok(initial.stdout.includes('add owner/repo\nadd owner/repo@jobs'))
+  const root = path.join(second, 'workspace/owner/repo')
+  git('clone', path.join(upstream, 'owner/repo.git'), root)
+  git('-C', root, 'remote', 'set-url', 'origin', 'git@github.com:owner/repo.git')
+  const partial = cliAt(second, 'pull', '--dry-run')
+  t.is(partial.status, 0, partial.stderr)
+  t.ok(partial.stdout.includes('adopt owner/repo\nadd owner/repo@jobs'))
+  t.is(checkAt(second, '--show').stdout, 'No applied checkpoint\n')
+  t.absent(fs.existsSync(root + '@jobs'))
+})
+
+test('configured upstream is fetched and unsupported remote manifests never replace the local one', (t) => {
+  const { cli, local, directory, git, head, applied } = machines(t)
+  git('-C', directory, 'push', 'origin', 'main:team')
+  git('-C', local, 'config', 'branch.main.merge', 'refs/heads/team')
+  t.ok(cli('pull', '--dry-run').stdout.includes('Manifest: origin/team'))
+  const before = head()
+  const checkpoint = applied()
+  fs.writeFileSync(path.join(directory, 'workspace.json'), '{"version":2,"repositories":[]}\n')
+  git('-C', directory, 'add', 'workspace.json')
+  git('-C', directory, 'commit', '-m', 'Unsupported manifest')
+  git('-C', directory, 'push', 'origin', 'main:team')
+  const invalid = cli('pull', '--dry-run')
+  t.is(invalid.status, 1)
+  t.ok(invalid.stderr.includes('Invalid workspace manifest'))
+  t.is(head(), before)
+  t.is(applied(), checkpoint)
+})
+
+test('pull requires a reachable manifest remote and always releases its lock', (t) => {
+  const { cli, ok, registry, git } = setup(t)
+  const directory = path.dirname(registry)
+  t.is(cli('pull').status, 1)
+  const missing = cli('pull', '--dry-run')
+  t.is(missing.status, 1)
+  t.absent(fs.existsSync(path.join(directory, '.git/workspace.lock')))
+  git('clone', '--bare', directory, path.join(path.dirname(directory), 'remote.git'))
+  git(
+    '-C',
+    directory,
+    'remote',
+    'set-url',
+    'origin',
+    path.join(path.dirname(directory), 'remote.git')
+  )
+  t.ok(
+    ok('pull', '--dry-run').includes('Manifest is up to date'),
+    'origin/current-branch fallback works'
+  )
+})
+
+test('replacing a worktree name during a root rename is an addition after removal, never adoption', (t) => {
+  const { ok, cli, push } = machines(t)
+  ok('remove', 'owner/repo@jobs')
+  ok('rename', 'owner/repo', 'other/new')
+  ok('add', 'other/new@jobs')
+  push()
+  const result = cli('pull', '--dry-run')
+  t.is(result.status, 0, result.stderr)
+  t.ok(result.stdout.includes('remove owner/repo@jobs'))
+  t.ok(result.stdout.includes('rename owner/repo -> other/new'))
+  t.ok(result.stdout.includes('add other/new@jobs'))
+  t.absent(result.stdout.includes('adopt other/new@jobs'))
+})
+
+test('stale worktree records and branches checked out elsewhere are reported without repair', (t) => {
+  const { ok, root, cli, push, directory, git } = machines(t)
+  ok('remove', 'owner/repo@jobs')
+  const file = path.join(directory, 'workspace.json')
+  const desired = JSON.parse(fs.readFileSync(file, 'utf8'))
+  desired.repositories[0].worktrees.push({ id: 'main-test', branch: 'main' })
+  fs.writeFileSync(file, JSON.stringify(desired) + '\n')
+  git('-C', directory, 'add', 'workspace.json')
+  git('-C', directory, 'commit', '-m', 'Request main worktree')
+  push()
+  fs.renameSync(root + '@jobs', root + '@saved')
+  const result = cli('pull', '--dry-run')
+  t.is(result.status, 1)
+  t.ok(result.stdout.includes('Missing worktree still has a Git record'))
+  t.ok(result.stdout.includes('Branch main is already checked out'))
+  t.ok(fs.existsSync(root + '@saved'))
+})
+
+test('nested destinations, branch namespaces and invalid Git branch names are blocked', (t) => {
+  const { root, cli, push, directory, git } = machines(t)
+  const file = path.join(directory, 'workspace.json')
+  const desired = JSON.parse(fs.readFileSync(file, 'utf8'))
+  const update = (branch) => {
+    desired.repositories[0].worktrees[0].branch = branch
+    fs.writeFileSync(file, JSON.stringify(desired) + '\n')
+    git('-C', directory, 'add', 'workspace.json')
+    git('-C', directory, 'commit', '-m', `Request ${branch}`)
+    push()
+    return cli('pull', '--dry-run')
+  }
+  t.ok(update('jobs/new').stdout.includes('Destination is inside another worktree'))
+  git('-C', root, 'branch', 'feature')
+  t.ok(update('feature/new').stdout.includes('conflicts with existing branch feature'))
+  const invalid = update('invalid.lock')
+  t.is(invalid.status, 1)
+  t.ok(invalid.stdout.includes('not a valid branch name'))
+  t.ok(fs.existsSync(root + '@jobs'))
+})
+
+test('a remote manifest cannot remove the active manifest checkout', (t) => {
+  const { directory, local, cli, push, git, head } = machines(t, [
+    'owner/repo@jobs',
+    'owner/workspace'
+  ])
+  const before = head()
+  const file = path.join(directory, 'workspace.json')
+  const desired = JSON.parse(fs.readFileSync(file, 'utf8'))
+  desired.repositories = desired.repositories.filter(({ name }) => name !== 'owner/workspace')
+  fs.writeFileSync(file, JSON.stringify(desired) + '\n')
+  git('-C', directory, 'add', 'workspace.json')
+  git('-C', directory, 'commit', '-m', 'Remove manifest checkout entry')
+  push()
+  const result = cli('pull', '--dry-run')
+  t.is(result.status, 1)
+  t.ok(result.stdout.includes('Cannot remove or rename the active manifest repository'))
+  t.ok(fs.existsSync(local))
+  t.is(head(), before)
+})
+
+test('pull applies root and branch renames and additions, preserving dirty work and manifest history', (t) => {
+  const { ok, git, root, local, second, cli, push, head, applied, directory } = machines(t)
+  fs.writeFileSync(path.join(root, 'tracked.txt'), 'staged root\n')
+  git('-C', root, 'add', 'tracked.txt')
+  fs.writeFileSync(path.join(root + '@jobs', 'tracked.txt'), 'dirty worktree\n')
+  const index = fs.readFileSync(path.join(root, '.git/index'))
+  const worktreeHead = git('-C', root + '@jobs', 'rev-parse', 'HEAD')
+  ok('rename', 'owner/repo', 'other/new')
+  ok('rename', 'other/new@jobs', 'other/new@fixes')
+  ok('add', 'other/new@feature/new')
+  push()
+  const target = git('-C', directory, 'rev-parse', 'HEAD')
+  const result = cli('pull')
+  t.is(result.status, 0, result.stderr)
+  t.ok(result.stdout.includes('Fast-forwarded the manifest'))
+  t.is(head(), target, 'fast-forward creates no extra manifest commit')
+  t.is(applied(), target)
+  const renamed = path.join(second, 'workspace/other/new')
+  t.absent(fs.existsSync(root))
+  t.absent(fs.existsSync(root + '@jobs'))
+  t.alike(fs.readFileSync(path.join(renamed, '.git/index')), index)
+  t.is(fs.readFileSync(path.join(renamed + '@fixes', 'tracked.txt'), 'utf8'), 'dirty worktree\n')
+  t.is(git('-C', renamed + '@fixes', 'rev-parse', 'HEAD'), worktreeHead)
+  t.is(git('-C', renamed + '@fixes', 'symbolic-ref', '--short', 'HEAD'), 'fixes')
+  t.is(git('-C', renamed, 'config', 'remote.origin.url'), 'git@github.com:other/new.git')
+  t.ok(fs.existsSync(renamed + '@feature/new'))
+  t.absent(
+    fs.existsSync(path.join(renamed, '.git/FETCH_HEAD')),
+    'existing repositories are not fetched'
+  )
+  t.is(git('-C', local, 'status', '--porcelain'), '')
+  t.absent(fs.existsSync(path.join(local, '.git/workspace-pull.json')))
+  t.absent(
+    git('-C', local, 'for-each-ref', '--format=%(refname)', 'refs/git-workspace/pull-target')
+  )
+  const repeat = cli('pull')
+  t.is(repeat.status, 0, repeat.stderr)
+  t.ok(repeat.stdout.includes('No layout changes planned'))
+  t.is(head(), target)
+})
+
+test('pull refuses blockers before fast-forwarding or saving progress, then performs clean removals', (t) => {
+  const { ok, root, local, cli, push, head, applied, git } = machines(t)
+  ok('remove', 'owner/repo@jobs')
+  ok('remove', 'owner/repo')
+  push()
+  const before = head()
+  fs.writeFileSync(path.join(root + '@jobs', 'tracked.txt'), 'keep\n')
+  t.is(cli('pull').status, 1)
+  t.is(head(), before)
+  t.is(applied(), before)
+  t.absent(fs.existsSync(path.join(local, '.git/workspace-pull.json')))
+  git('-C', root + '@jobs', 'restore', 'tracked.txt')
+  const result = cli('pull')
+  t.is(result.status, 0, result.stderr)
+  t.absent(fs.existsSync(root + '@jobs'))
+  t.absent(fs.existsSync(root))
+  t.is(applied(), head())
+})
+
+test('first pull adopts a matching root, creates its worktrees and retains the remote IDs', (t) => {
+  const { ok, git, home, upstream, registry, cliAt, checkAt } = setup(t)
+  ok('add', 'owner/repo@jobs')
+  git('clone', '--bare', path.dirname(registry), path.join(upstream, 'owner/workspace.git'))
+  const second = path.join(home, 'fresh')
+  fs.mkdirSync(second)
+  t.is(cliAt(second, 'init', 'owner/workspace').status, 0)
+  const root = path.join(second, 'workspace/owner/repo')
+  git('clone', path.join(upstream, 'owner/repo.git'), root)
+  git('-C', root, 'remote', 'set-url', 'origin', 'git@github.com:owner/repo.git')
+  fs.writeFileSync(path.join(root, 'untracked'), 'keep\n')
+  const result = cliAt(second, 'pull')
+  t.is(result.status, 0, result.stderr)
+  t.ok(result.stdout.includes('adopt owner/repo'))
+  t.ok(fs.existsSync(root + '@jobs'))
+  t.is(fs.readFileSync(path.join(root, 'untracked'), 'utf8'), 'keep\n')
+  const local = path.join(second, 'workspace/owner/workspace')
+  t.is(
+    fs.readFileSync(path.join(local, 'workspace.json'), 'utf8'),
+    fs.readFileSync(registry, 'utf8')
+  )
+  t.is(checkAt(second, '--show').stdout.trim(), git('-C', local, 'rev-parse', 'HEAD'))
+})
+
+test('pull replaces reused root and worktree names and verifies the new identities', (t) => {
+  const { ok, cli, root, push, head, applied, git, directory } = machines(t)
+  const previous = git('-C', root + '@jobs', 'rev-parse', 'HEAD')
+  git('-C', root + '@jobs', 'commit', '--allow-empty', '-m', 'Local old identity')
+  ok('remove', 'owner/repo@jobs')
+  ok('remove', 'owner/repo')
+  ok('add', 'owner/repo@jobs')
+  push()
+  const result = cli('pull')
+  t.is(result.status, 0, result.stderr)
+  t.is(
+    git('-C', root + '@jobs', 'rev-parse', 'HEAD'),
+    previous,
+    'replacement is created from the requested repository'
+  )
+  t.is(applied(), head())
+  t.is(head(), git('-C', directory, 'rev-parse', 'HEAD'))
+  t.is(cli('pull').status, 0)
+})
+
+test('a failed clone resumes the saved target and blocks ordinary manifest mutations meanwhile', (t) => {
+  const { ok, cli, local, root, upstream, directory, git, push, head, applied } = machines(t)
+  const before = applied()
+  ok('rename', 'owner/repo@jobs', 'owner/repo@fixes')
+  const file = path.join(directory, 'workspace.json')
+  const desired = JSON.parse(fs.readFileSync(file, 'utf8'))
+  desired.repositories.push(
+    repo('missing-root', 'owner/missing', [{ id: 'missing-child', branch: 'new' }])
+  )
+  fs.writeFileSync(file, JSON.stringify(desired) + '\n')
+  git('-C', directory, 'add', 'workspace.json')
+  git('-C', directory, 'commit', '-m', 'Add unavailable repository')
+  push()
+  const target = git('-C', directory, 'rev-parse', 'HEAD')
+  const failed = cli('pull')
+  t.is(failed.status, 1)
+  t.ok(failed.stderr.includes('rerun git workspace pull'))
+  t.is(head(), target)
+  t.is(applied(), before)
+  t.is(progress(local).completed, 1)
+  t.is(progress(local).pending, true)
+  t.absent(
+    fs.existsSync(path.join(path.dirname(root), 'missing/.git')),
+    'pull never initializes an empty replacement for an unavailable remote'
+  )
+  t.ok(fs.existsSync(root + '@fixes'))
+  for (const args of [
+    ['add', 'owner/repo'],
+    ['remove', 'owner/repo@fixes'],
+    ['rename', 'owner/repo', 'other/new'],
+    ['init', 'owner/workspace']
+  ]) {
+    t.ok(cli(...args).stderr.includes('interrupted workspace pull is pending'))
+  }
+  t.is(cli('list').status, 0)
+  t.is(cli('pull', '--dry-run').status, 0)
+  t.is(progress(local).completed, 1, 'preview does not advance progress')
+  git('clone', '--bare', root, path.join(upstream, 'owner/missing.git'))
+  git('-C', directory, 'commit', '--allow-empty', '-m', 'Later remote commit')
+  push()
+  const resumed = cli('pull')
+  t.is(resumed.status, 0, resumed.stderr)
+  t.ok(resumed.stdout.includes('Resuming saved pull'))
+  t.is(head(), target, 'retry completes the pinned target before fetching newer changes')
+  t.is(applied(), target)
+  t.is(cli('pull').status, 0)
+  t.is(head(), git('-C', directory, 'rev-parse', 'HEAD'))
+})
+
+test('pull resumes a branch rename that moved the worktree before a Git config failure', (t) => {
+  const { ok, root, local, cli, push, git, run, applied, head } = machines(t)
+  const before = applied()
+  ok('rename', 'owner/repo@jobs', 'owner/repo@fixes')
+  push()
+  git('-C', root, 'config', 'branch.jobs.remote', 'origin')
+  git('-C', root, 'config', 'branch.jobs.merge', 'refs/heads/jobs')
+  const lock = path.join(root, '.git/config.lock')
+  fs.writeFileSync(lock, '')
+  t.is(cli('pull').status, 1)
+  t.absent(fs.existsSync(root + '@jobs'))
+  t.ok(fs.existsSync(root + '@fixes'))
+  t.is(progress(local).pending, true)
+  t.is(applied(), before)
+  const preview = cli('pull', '--dry-run')
+  t.is(preview.status, 1)
+  t.ok(preview.stdout.includes('Interrupted rename needs repair'))
+  fs.unlinkSync(lock)
+  const result = cli('pull')
+  t.is(result.status, 0, result.stderr)
+  t.is(git('-C', root + '@fixes', 'symbolic-ref', '--short', 'HEAD'), 'fixes')
+  t.is(git('-C', root, 'config', 'branch.fixes.merge'), 'refs/heads/fixes')
+  t.is(run('git', ['-C', root, 'config', '--get-regexp', '^branch\\.jobs\\.']).status, 1)
+  t.is(applied(), head())
+})
+
+test('pull retries branch deletion after the worktree has already been removed', (t) => {
+  const { ok, root, local, cli, push, applied, head } = machines(t)
+  const before = applied()
+  ok('remove', 'owner/repo@jobs')
+  push()
+  const lock = path.join(root, '.git/refs/heads/jobs.lock')
+  fs.writeFileSync(lock, '')
+  t.is(cli('pull').status, 1)
+  t.absent(fs.existsSync(root + '@jobs'))
+  t.is(progress(local).completed, 0)
+  t.is(applied(), before)
+  fs.unlinkSync(lock)
+  const result = cli('pull')
+  t.is(result.status, 0, result.stderr)
+  t.is(applied(), head())
+})
+
+test('pull repairs a root rename after the process dies between directory moves and Git repair', (t) => {
+  const context = machines(t)
+  const { ok, root, second, local, cli, push, applied, head, git } = context
+  const before = applied()
+  fs.writeFileSync(path.join(root + '@jobs', 'tracked.txt'), 'keep dirty\n')
+  ok('rename', 'owner/repo', 'other/new')
+  ok('rename', 'other/new@jobs', 'other/new@fixes')
+  push()
+  interruptedPull(context, 'worktree repair')
+  const renamed = path.join(second, 'workspace/other/new')
+  t.absent(fs.existsSync(root))
+  t.ok(fs.existsSync(renamed + '@jobs'))
+  t.is(progress(local).pending, true)
+  t.is(applied(), before)
+  const result = cli('pull')
+  t.is(result.status, 0, result.stderr)
+  t.is(git('-C', renamed + '@fixes', 'symbolic-ref', '--short', 'HEAD'), 'fixes')
+  t.is(fs.readFileSync(path.join(renamed + '@fixes', 'tracked.txt'), 'utf8'), 'keep dirty\n')
+  t.is(git('-C', renamed, 'config', 'remote.origin.url'), 'git@github.com:other/new.git')
+  t.is(applied(), head())
+})
+
+test('pull never repeats removal when a replacement was created before the process died', (t) => {
+  const context = machines(t)
+  const { ok, root, second, local, cli, push, applied, head } = context
+  const before = applied()
+  ok('remove', 'owner/repo@jobs')
+  ok('rename', 'owner/repo', 'other/new')
+  ok('add', 'other/new@jobs')
+  push()
+  interruptedPull(context, 'worktree add', true)
+  const renamed = path.join(second, 'workspace/other/new')
+  t.is(progress(local).completed, 2)
+  t.is(progress(local).pending, true)
+  t.is(applied(), before)
+  t.absent(fs.existsSync(root))
+  fs.writeFileSync(path.join(renamed + '@jobs', 'untracked'), 'keep replacement\n')
+  const result = cli('pull')
+  t.is(result.status, 0, result.stderr)
+  t.is(fs.readFileSync(path.join(renamed + '@jobs', 'untracked'), 'utf8'), 'keep replacement\n')
+  t.is(applied(), head())
+})
+
+test('pull retries final checkpoint failure without replaying completed changes', (t) => {
+  const { ok, root, local, cli, push, applied, head } = machines(t)
+  const before = applied()
+  ok('remove', 'owner/repo@jobs')
+  ok('add', 'owner/repo@jobs')
+  push()
+  const lock = path.join(local, '.git/refs/git-workspace/applied.lock')
+  fs.writeFileSync(lock, '')
+  const failed = cli('pull')
+  t.is(failed.status, 1)
+  t.ok(failed.stderr.includes('applied.lock'))
+  t.is(progress(local).completed, 2)
+  t.is(progress(local).pending, false)
+  t.is(applied(), before)
+  fs.writeFileSync(path.join(root + '@jobs', 'untracked'), 'keep replacement\n')
+  fs.unlinkSync(lock)
+  const result = cli('pull')
+  t.is(result.status, 0, result.stderr)
+  t.is(fs.readFileSync(path.join(root + '@jobs', 'untracked'), 'utf8'), 'keep replacement\n')
+  t.is(applied(), head())
+})
+
+test('a crash after advancing the checkpoint only needs verification and progress cleanup', (t) => {
+  const context = machines(t)
+  const { ok, root, local, cli, push, applied, head } = context
+  ok('remove', 'owner/repo@jobs')
+  ok('add', 'owner/repo@jobs')
+  push()
+  interruptedPull(context, 'update-ref --no-deref refs/git-workspace/applied', true)
+  t.is(applied(), head(), 'checkpoint already advanced')
+  t.is(progress(local).completed, 2)
+  fs.writeFileSync(path.join(root + '@jobs', 'untracked'), 'keep replacement\n')
+  const result = cli('pull')
+  t.is(result.status, 0, result.stderr)
+  t.is(fs.readFileSync(path.join(root + '@jobs', 'untracked'), 'utf8'), 'keep replacement\n')
+  t.absent(fs.existsSync(path.join(local, '.git/workspace-pull.json')))
+})
+
+test('pull leaves live, unowned and symbolic locks intact', (t) => {
+  const { cli, local } = machines(t)
+  const lock = path.join(local, '.git/workspace.lock')
+  fs.mkdirSync(lock)
+  t.is(cli('pull').status, 1, 'ordinary command lock is not reclaimed')
+  const owner = path.join(lock, 'pull-owner')
+  fs.writeFileSync(owner, String(os.pid()))
+  t.is(cli('pull').status, 1, 'live pull lock is not reclaimed')
+  t.is(fs.readFileSync(owner, 'utf8'), String(os.pid()))
+  fs.unlinkSync(owner)
+  fs.rmdirSync(lock)
+  fs.symlinkSync(path.join(local, '.git'), lock)
+  t.is(cli('pull').status, 1)
+  t.ok(fs.lstatSync(lock).isSymbolicLink())
+})