git-workspace-bare 0.1.1 → 0.3.1

package/test/lifecycle.js

@@ -2,18 +2,214 @@ import test from 'brittle'
 import fs from 'bare-fs'
 import path from 'bare-path'
 import setup from './helpers.js'
+import './manifest.js'
+import './checkpoint.js'
+import './completion.js'
+import './pull.js'
+import './hooks.js'
+import './add-offline.js'
+import './manifest-push.js'
+
+function manifestEntries(json) {
+  const manifest = JSON.parse(json)
+  return manifest.repositories.flatMap(({ name, worktrees }) => [
+    name,
+    ...worktrees.map(({ branch }) => `${name}@${branch}`)
+  ])
+}
 
 test('clone, list, and remove a root repository', (t) => {
-  const { ok, root, registry } = setup(t)
+  const { ok, git, root, registry } = setup(t)
+  const directory = path.dirname(registry)
   t.is(ok('list'), '', 'empty manifest is empty')
   ok('add', 'owner/repo')
   t.ok(fs.existsSync(path.join(root, '.git')), 'repository cloned')
   t.is(ok('list'), 'owner/repo\n', 'prints repository name outside the checkout')
+  t.is(git('-C', directory, 'log', '-1', '--format=%s'), 'Add owner/repo')
+  t.alike(manifestEntries(git('-C', directory, 'show', 'HEAD:workspace.json')), ['owner/repo'])
+  t.is(git('-C', directory, 'status', '--porcelain'), '', 'manifest committed')
+  const head = git('-C', directory, 'rev-parse', 'HEAD')
   ok('add', 'owner/repo')
-  t.alike(JSON.parse(fs.readFileSync(registry, 'utf8')), ['owner/repo'], 'repeat add is idempotent')
+  t.is(git('-C', directory, 'rev-parse', 'HEAD'), head, 'repeat add makes no commit')
+  t.alike(
+    manifestEntries(fs.readFileSync(registry, 'utf8')),
+    ['owner/repo'],
+    'repeat add is idempotent'
+  )
   ok('remove', 'owner/repo')
   t.absent(fs.existsSync(root), 'checkout deleted')
   t.is(ok('list'), '', 'registry empty after removal')
+  t.is(git('-C', directory, 'log', '-1', '--format=%s'), 'Remove owner/repo')
+  t.alike(manifestEntries(git('-C', directory, 'show', 'HEAD:workspace.json')), [])
+  t.is(git('-C', directory, 'status', '--porcelain'), '', 'removal committed')
+})
+
+test('remove commits a branch removal and preserves unrelated staged work and pushes the manifest', (t) => {
+  const { ok, git, registry, upstream } = setup(t)
+  const directory = path.dirname(registry)
+  ok('add', 'owner/repo@jobs')
+  const remote = path.join(upstream, 'owner/workspace.git')
+  git('clone', '--bare', directory, remote)
+  const other = path.join(directory, 'other.txt')
+  fs.writeFileSync(other, 'staged\n')
+  git('-C', directory, 'add', 'other.txt')
+  fs.writeFileSync(other, 'unstaged\n')
+  const staged = git('-C', directory, 'diff', '--cached')
+  const unstaged = git('-C', directory, 'diff')
+  ok('remove', 'owner/repo@jobs')
+  t.is(git('-C', directory, 'log', '-1', '--format=%s'), 'Remove owner/repo@jobs')
+  t.alike(manifestEntries(git('-C', directory, 'show', 'HEAD:workspace.json')), ['owner/repo'])
+  t.is(git('-C', directory, 'diff', '--cached'), staged, 'staged work preserved')
+  t.is(git('-C', directory, 'diff'), unstaged, 'unstaged work preserved')
+  t.is(
+    git('--git-dir', remote, 'rev-parse', 'HEAD'),
+    git('-C', directory, 'rev-parse', 'HEAD'),
+    'manifest pushed'
+  )
+})
+
+for (const repository of ['owner/repo', 'owner/repo@jobs']) {
+  test(`remove reports commit failure after deleting ${repository}`, (t) => {
+    const { cli, ok, git, registry, root } = setup(t)
+    const directory = path.dirname(registry)
+    ok('add', repository)
+    const head = git('-C', directory, 'rev-parse', 'HEAD')
+    const hooks = path.join(directory, '.git/hooks')
+    git('-C', directory, 'config', 'core.hooksPath', hooks)
+    const hook = path.join(hooks, 'pre-commit')
+    fs.writeFileSync(hook, '#!/bin/sh\necho "test hook rejected commit" >&2\nexit 1\n')
+    fs.chmodSync(hook, 0o755)
+    const result = cli('remove', repository)
+    t.is(result.status, 1)
+    t.ok(result.stderr.includes('test hook rejected commit'))
+    t.ok(result.stderr.includes('checkout is already removed'))
+    t.ok(result.stderr.includes('commit only workspace.json'))
+    t.absent(fs.existsSync(repository.includes('@') ? root + '@jobs' : root))
+    const expected = repository.includes('@') ? ['owner/repo'] : []
+    t.alike(manifestEntries(fs.readFileSync(registry, 'utf8')), expected, 'removal saved')
+    t.is(git('-C', directory, 'rev-parse', 'HEAD'), head, 'no commit on failure')
+    fs.unlinkSync(hook)
+    git('-C', directory, 'commit', '--only', '-m', `Remove ${repository}`, '--', 'workspace.json')
+    t.alike(
+      manifestEntries(git('-C', directory, 'show', 'HEAD:workspace.json')),
+      expected,
+      'manual recovery works'
+    )
+    const recovered = git('-C', directory, 'rev-parse', 'HEAD')
+    t.is(cli('remove', repository).status, 1, 'missing unregistered checkout remains an error')
+    t.is(git('-C', directory, 'rev-parse', 'HEAD'), recovered, 'repeat removal makes no commit')
+  })
+}
+
+test('remove skips commits when deleting an unregistered checkout leaves the manifest unchanged', (t) => {
+  const { ok, git, registry, root, upstream } = setup(t)
+  const directory = path.dirname(registry)
+  git('clone', path.join(upstream, 'owner/repo.git'), root)
+  git('-C', root, 'remote', 'set-url', 'origin', 'git@github.com:owner/repo.git')
+  const head = git('-C', directory, 'rev-parse', 'HEAD')
+  ok('remove', 'owner/repo')
+  t.absent(fs.existsSync(root))
+  t.is(git('-C', directory, 'rev-parse', 'HEAD'), head, 'no empty commit')
+})
+
+test('remove commits unregistering a missing checkout', (t) => {
+  const { ok, git, registry, root } = setup(t)
+  ok('add', 'owner/repo')
+  fs.renameSync(root, root + '-moved')
+  ok('remove', 'owner/repo')
+  t.alike(manifestEntries(git('-C', path.dirname(registry), 'show', 'HEAD:workspace.json')), [])
+  t.ok(fs.existsSync(root + '-moved'), 'relocated checkout untouched')
+})
+
+test('add commits root and branch registrations together and preserves unrelated work', (t) => {
+  const { ok, git, registry, upstream } = setup(t)
+  const directory = path.dirname(registry)
+  const remote = path.join(upstream, 'owner/workspace.git')
+  git('clone', '--bare', directory, remote)
+  const other = path.join(directory, 'other.txt')
+  fs.writeFileSync(other, 'staged\n')
+  git('-C', directory, 'add', 'other.txt')
+  fs.writeFileSync(other, 'unstaged\n')
+  const staged = git('-C', directory, 'diff', '--cached')
+  const unstaged = git('-C', directory, 'diff')
+  ok('add', 'owner/repo@feature/jobs')
+  t.is(
+    git('-C', directory, 'rev-list', '--count', 'HEAD'),
+    '2',
+    'one commit for both registrations'
+  )
+  t.is(git('-C', directory, 'log', '-1', '--format=%s'), 'Add owner/repo@feature/jobs')
+  t.alike(manifestEntries(git('-C', directory, 'show', 'HEAD:workspace.json')), [
+    'owner/repo',
+    'owner/repo@feature/jobs'
+  ])
+  t.is(git('-C', directory, 'diff', '--cached'), staged, 'staged work preserved')
+  t.is(git('-C', directory, 'diff'), unstaged, 'unstaged work preserved')
+  t.is(
+    git('--git-dir', remote, 'rev-parse', 'HEAD'),
+    git('-C', directory, 'rev-parse', 'HEAD'),
+    'manifest pushed'
+  )
+  ok('add', 'owner/repo@feature/jobs')
+  t.is(
+    git('-C', directory, 'rev-list', '--count', 'HEAD'),
+    '2',
+    'repeat branch add makes no commit'
+  )
+})
+
+test('add commits pending manifest edits only after successful registration', (t) => {
+  const { cli, ok, git, registry } = setup(t)
+  const directory = path.dirname(registry)
+  ok('add', 'owner/repo')
+  const head = git('-C', directory, 'rev-parse', 'HEAD')
+  const entries = ['owner/repo', 'other/saved']
+  const edited = JSON.parse(fs.readFileSync(registry, 'utf8'))
+  edited.repositories.push({ id: 'saved-repo', name: 'other/saved', worktrees: [] })
+  fs.writeFileSync(registry, JSON.stringify(edited) + '\n')
+  fs.mkdirSync(path.join(path.dirname(registry), '../missing'), { recursive: true })
+  fs.writeFileSync(path.join(path.dirname(registry), '../missing/keep.txt'), 'existing work\n')
+  t.is(cli('add', 'owner/missing').status, 1, 'occupied non-Git destination fails validation')
+  t.is(git('-C', directory, 'rev-parse', 'HEAD'), head, 'failed add does not commit pending edits')
+  ok('add', 'owner/repo')
+  t.alike(manifestEntries(git('-C', directory, 'show', 'HEAD:workspace.json')), entries)
+  t.is(git('-C', directory, 'status', '--porcelain'), '', 'pending manifest edits committed')
+})
+
+test('add retries a failed manifest commit without duplicate registrations', (t) => {
+  const { cli, ok, git, registry, root } = setup(t)
+  const directory = path.dirname(registry)
+  const hooks = path.join(directory, '.git/hooks')
+  git('-C', directory, 'config', 'core.hooksPath', hooks)
+  const hook = path.join(hooks, 'pre-commit')
+  fs.writeFileSync(hook, '#!/bin/sh\necho "test hook rejected commit" >&2\nexit 1\n')
+  fs.chmodSync(hook, 0o755)
+  const result = cli('add', 'owner/repo@jobs')
+  t.is(result.status, 1)
+  t.ok(result.stderr.includes('test hook rejected commit'))
+  t.ok(result.stderr.includes('rerun git workspace add owner/repo@jobs'))
+  t.ok(fs.existsSync(root + '@jobs'), 'checkout preserved')
+  t.alike(manifestEntries(fs.readFileSync(registry, 'utf8')), ['owner/repo', 'owner/repo@jobs'])
+  t.is(git('-C', directory, 'rev-list', '--count', 'HEAD'), '1', 'no commit on failure')
+  fs.unlinkSync(hook)
+  ok('add', 'owner/repo@jobs')
+  t.is(git('-C', directory, 'rev-list', '--count', 'HEAD'), '2')
+  t.alike(manifestEntries(git('-C', directory, 'show', 'HEAD:workspace.json')), [
+    'owner/repo',
+    'owner/repo@jobs'
+  ])
+})
+
+test('failed branch creation leaves the root registered but uncommitted until retry', (t) => {
+  const { cli, ok, git, registry, root } = setup(t)
+  const directory = path.dirname(registry)
+  fs.mkdirSync(root + '@jobs', { recursive: true })
+  t.is(cli('add', 'owner/repo@jobs').status, 1)
+  t.alike(manifestEntries(fs.readFileSync(registry, 'utf8')), ['owner/repo'])
+  t.is(git('-C', directory, 'rev-list', '--count', 'HEAD'), '1')
+  fs.rmdirSync(root + '@jobs')
+  ok('add', 'owner/repo@jobs')
+  t.is(git('-C', directory, 'rev-list', '--count', 'HEAD'), '2')
 })
 
 test('nested branches and empty parent cleanup', (t) => {
@@ -36,9 +232,10 @@ test('nested branches and empty parent cleanup', (t) => {
 })
 
 test('root removal refuses linked worktrees', (t) => {
-  const { cli, ok, root, registry } = setup(t)
+  const { cli, ok, git, root, registry } = setup(t)
   ok('add', 'owner/repo@jobs')
   const before = fs.readFileSync(registry, 'utf8')
+  const head = git('-C', path.dirname(registry), 'rev-parse', 'HEAD')
   const result = cli('remove', 'owner/repo')
   t.is(result.status, 1)
   t.is(result.stdout, '')
@@ -49,6 +246,11 @@ test('root removal refuses linked worktrees', (t) => {
   t.ok(fs.existsSync(root), 'root preserved')
   t.ok(fs.existsSync(root + '@jobs'), 'linked worktree preserved')
   t.is(fs.readFileSync(registry, 'utf8'), before, 'registry unchanged')
+  t.is(
+    git('-C', path.dirname(registry), 'rev-parse', 'HEAD'),
+    head,
+    'refused removal makes no commit'
+  )
 })
 
 test('dirty worktrees and roots survive failed removal', (t) => {
@@ -99,6 +301,88 @@ test('worktrees are removed along with whichever branch they hold', (t) => {
   t.is(ok('list'), 'owner/repo\n')
 })
 
+for (const rootRename of [false, true]) {
+  const from = rootRename ? 'owner/repo' : 'owner/repo@jobs'
+  const to = rootRename ? 'other/new' : 'owner/repo@fixes'
+  const expected = rootRename ? ['other/new', 'other/new@jobs'] : ['owner/repo', 'owner/repo@fixes']
+
+  test(`rename commits ${from} to ${to} without committing other files and pushes the manifest`, (t) => {
+    const { cli, ok, git, registry, upstream } = setup(t)
+    const directory = path.dirname(registry)
+    ok('add', 'owner/repo@jobs')
+    const remote = path.join(upstream, 'owner/workspace.git')
+    git('clone', '--bare', directory, remote)
+    const other = path.join(directory, 'other.txt')
+    fs.writeFileSync(other, 'staged\n')
+    git('-C', directory, 'add', 'other.txt')
+    fs.writeFileSync(other, 'unstaged\n')
+    const staged = git('-C', directory, 'diff', '--cached')
+    const unstaged = git('-C', directory, 'diff')
+    ok('rename', from, to)
+    t.is(git('-C', directory, 'log', '-1', '--format=%s'), `Rename ${from} to ${to}`)
+    t.alike(manifestEntries(git('-C', directory, 'show', 'HEAD:workspace.json')), expected)
+    t.is(git('-C', directory, 'rev-list', '--count', 'HEAD'), '3', 'one rename commit')
+    t.is(git('-C', directory, 'diff', '--cached'), staged, 'staged work preserved')
+    t.is(git('-C', directory, 'diff'), unstaged, 'unstaged work preserved')
+    t.is(
+      git('--git-dir', remote, 'rev-parse', 'HEAD'),
+      git('-C', directory, 'rev-parse', 'HEAD'),
+      'manifest pushed'
+    )
+    const head = git('-C', directory, 'rev-parse', 'HEAD')
+    t.is(cli('rename', to, to).status, 1, 'same-name rename refused')
+    t.is(git('-C', directory, 'rev-parse', 'HEAD'), head, 'refusal creates no commit')
+  })
+
+  test(`rename keeps completed ${from} to ${to} after commit failure`, (t) => {
+    const { cli, ok, git, home, root, registry } = setup(t)
+    const directory = path.dirname(registry)
+    ok('add', 'owner/repo@jobs')
+    const head = git('-C', directory, 'rev-parse', 'HEAD')
+    const hooks = path.join(directory, '.git/hooks')
+    git('-C', directory, 'config', 'core.hooksPath', hooks)
+    const hook = path.join(hooks, 'pre-commit')
+    fs.writeFileSync(hook, '#!/bin/sh\necho "test hook rejected commit" >&2\nexit 1\n')
+    fs.chmodSync(hook, 0o755)
+    const result = cli('rename', from, to)
+    t.is(result.status, 1)
+    t.ok(result.stderr.includes('test hook rejected commit'))
+    t.ok(result.stderr.includes('rename is already complete'))
+    t.ok(result.stderr.includes('commit only workspace.json'))
+    t.alike(manifestEntries(fs.readFileSync(registry, 'utf8')), expected)
+    t.is(git('-C', directory, 'rev-parse', 'HEAD'), head, 'no commit on failure')
+    t.absent(fs.existsSync(rootRename ? root : root + '@jobs'), 'old path gone')
+    const renamedRoot = rootRename ? path.join(home, 'workspace/other/new') : root
+    const branchPath = rootRename ? renamedRoot + '@jobs' : root + '@fixes'
+    t.is(
+      git('-C', branchPath, 'rev-parse', '--path-format=absolute', '--git-common-dir'),
+      path.join(renamedRoot, '.git'),
+      'worktree links remain repaired'
+    )
+    t.is(git('-C', branchPath, 'symbolic-ref', '--short', 'HEAD'), rootRename ? 'jobs' : 'fixes')
+    t.is(
+      git('-C', renamedRoot, 'config', '--get', 'remote.origin.url'),
+      rootRename ? 'git@github.com:other/new.git' : 'git@github.com:owner/repo.git'
+    )
+    fs.unlinkSync(hook)
+    git(
+      '-C',
+      directory,
+      'commit',
+      '--only',
+      '-m',
+      `Rename ${from} to ${to}`,
+      '--',
+      'workspace.json'
+    )
+    t.alike(
+      manifestEntries(git('-C', directory, 'show', 'HEAD:workspace.json')),
+      expected,
+      'manual recovery works'
+    )
+  })
+}
+
 test('root rename moves dirty checkouts, repairs links, and updates origin locally', (t) => {
   const { ok, git, home, root, upstream } = setup(t)
   ok('add', 'owner/repo@feature/jobs')
@@ -393,7 +677,7 @@ test('commands require init and ignore old registry files', (t) => {
   t.absent(fs.existsSync(root), 'add does not clone before initialization')
 })
 
-test('init creates a local manifest without importing old registries or committing', (t) => {
+test('init commits a new local manifest without importing old registries when the remote is unavailable', (t) => {
   const { cli, ok, git, home, upstream, registry } = setup(t, { initialize: false })
   fs.mkdirSync(path.join(home, '.git-workspace'))
   fs.writeFileSync(path.join(home, '.git-workspace/worktrees.json'), '["/old/workspace/repo"]')
@@ -405,8 +689,10 @@ test('init creates a local manifest without importing old registries or committi
     git('-C', directory, 'config', '--get', 'remote.origin.url'),
     'git@github.com:owner/workspace.git'
   )
-  t.alike(JSON.parse(fs.readFileSync(registry, 'utf8')), [], 'new manifest starts empty')
-  t.is(git('-C', directory, 'status', '--porcelain'), '?? workspace.json')
+  t.alike(manifestEntries(fs.readFileSync(registry, 'utf8')), [], 'new manifest starts empty')
+  t.is(git('-C', directory, 'status', '--porcelain'), '', 'manifest committed')
+  t.is(git('-C', directory, 'log', '-1', '--format=%s'), 'Initialize workspace manifest')
+  t.alike(manifestEntries(git('-C', directory, 'show', 'HEAD:workspace.json')), [])
   t.alike(
     JSON.parse(fs.readFileSync(path.join(home, '.config/git-workspace/config.json'), 'utf8')),
     { manifestRepository: directory },
@@ -414,23 +700,120 @@ test('init creates a local manifest without importing old registries or committi
   )
   t.absent(fs.existsSync(path.join(upstream, 'owner/workspace.git')), 'no remote created')
   ok('add', 'owner/repo@feature/jobs')
-  t.alike(JSON.parse(fs.readFileSync(registry, 'utf8')), ['owner/repo', 'owner/repo@feature/jobs'])
+  t.alike(manifestEntries(fs.readFileSync(registry, 'utf8')), [
+    'owner/repo',
+    'owner/repo@feature/jobs'
+  ])
   ok('remove', 'owner/repo@feature/jobs')
+  const beforeInit = git('-C', directory, 'rev-parse', 'HEAD')
+  const edited = fs.readFileSync(registry, 'utf8') + '\n'
+  fs.writeFileSync(registry, edited)
   ok('init', 'owner/workspace')
+  t.is(fs.readFileSync(registry, 'utf8'), edited, 'manual edit preserved')
+  t.is(git('-C', directory, 'rev-parse', 'HEAD'), beforeInit, 'repeat init does not commit edits')
   t.alike(
-    JSON.parse(fs.readFileSync(registry, 'utf8')),
+    manifestEntries(fs.readFileSync(registry, 'utf8')),
     ['owner/repo'],
     'repeat init preserves edits'
   )
   t.is(cli('init', 'owner/other').status, 1, 'different remote refused')
 })
 
+for (const existingHistory of [false, true]) {
+  test(`init commits only the manifest with existing history: ${existingHistory}`, (t) => {
+    const { ok, git, registry } = setup(t, { initialize: false })
+    const directory = path.dirname(registry)
+    git('init', directory)
+    git('-C', directory, 'remote', 'add', 'origin', 'git@github.com:owner/workspace.git')
+    const other = path.join(directory, 'other.txt')
+    if (existingHistory) {
+      fs.writeFileSync(other, 'original\n')
+      git('-C', directory, 'add', 'other.txt')
+      git('-C', directory, 'commit', '-m', 'Existing history')
+    }
+    fs.writeFileSync(other, 'staged\n')
+    git('-C', directory, 'add', 'other.txt')
+    fs.writeFileSync(other, 'unstaged\n')
+    const staged = git('-C', directory, 'diff', '--cached')
+    const unstaged = git('-C', directory, 'diff')
+    ok('init', 'owner/workspace')
+    t.is(git('-C', directory, 'diff', '--cached'), staged, 'staged changes preserved')
+    t.is(git('-C', directory, 'diff'), unstaged, 'unstaged changes preserved')
+    t.is(git('-C', directory, 'show', '--format=', '--name-only', 'HEAD'), 'workspace.json')
+    t.is(git('-C', directory, 'rev-list', '--count', 'HEAD'), existingHistory ? '2' : '1')
+  })
+}
+
+test('init preserves an existing untracked manifest without committing', (t) => {
+  const { ok, git, registry } = setup(t, { initialize: false })
+  const directory = path.dirname(registry)
+  git('init', directory)
+  git('-C', directory, 'remote', 'add', 'origin', 'git@github.com:owner/workspace.git')
+  fs.writeFileSync(
+    registry,
+    JSON.stringify({
+      version: 1,
+      repositories: [{ id: 'existing', name: 'owner/repo', worktrees: [] }]
+    })
+  )
+  ok('init', 'owner/workspace')
+  t.is(git('-C', directory, 'status', '--porcelain'), '?? workspace.json')
+  t.is(ok('list'), 'owner/repo\n')
+})
+
+test('init reports commit failures and preserves the manifest for recovery', (t) => {
+  const { cli, ok, git, home, registry } = setup(t, { initialize: false })
+  const directory = path.dirname(registry)
+  git('init', directory)
+  git('-C', directory, 'remote', 'add', 'origin', 'git@github.com:owner/workspace.git')
+  const hooks = path.join(directory, '.git/hooks')
+  git('-C', directory, 'config', 'core.hooksPath', hooks)
+  const hook = path.join(hooks, 'pre-commit')
+  fs.writeFileSync(hook, '#!/bin/sh\necho "test hook rejected commit" >&2\nexit 1\n')
+  fs.chmodSync(hook, 0o755)
+  const result = cli('init', 'owner/workspace')
+  t.is(result.status, 1)
+  t.ok(result.stderr.includes('test hook rejected commit'))
+  t.ok(result.stderr.includes('commit only workspace.json'))
+  t.alike(manifestEntries(fs.readFileSync(registry, 'utf8')), [])
+  t.absent(
+    fs.existsSync(path.join(home, '.config/git-workspace/config.json')),
+    'not activated on failure'
+  )
+  fs.unlinkSync(hook)
+  git(
+    '-C',
+    directory,
+    'commit',
+    '--only',
+    '-m',
+    'Initialize workspace manifest',
+    '--',
+    'workspace.json'
+  )
+  ok('init', 'owner/workspace')
+  t.is(ok('list'), '')
+  t.is(git('-C', directory, 'rev-list', '--count', 'HEAD'), '1', 'no duplicate commit')
+})
+
 test('existing manifests are portable and not applied during init', (t) => {
   const { cliAt, ok, git, home, upstream, registry } = setup(t, { initialize: false })
   const source = path.join(home, 'manifest-source')
   git('init', source)
   const entries = ['owner/repo', 'owner/repo@feature/jobs']
-  fs.writeFileSync(path.join(source, 'workspace.json'), JSON.stringify(entries))
+  fs.writeFileSync(
+    path.join(source, 'workspace.json'),
+    JSON.stringify({
+      version: 1,
+      repositories: [
+        {
+          id: 'fixture-repo',
+          name: 'owner/repo',
+          worktrees: [{ id: 'fixture-worktree', branch: 'feature/jobs' }]
+        }
+      ]
+    })
+  )
   git('-C', source, 'add', 'workspace.json')
   git('-C', source, 'commit', '-m', 'Manifest fixture')
   git('clone', '--bare', source, path.join(upstream, 'owner/workspace.git'))
@@ -466,11 +849,8 @@ test('invalid manifests fail without being overwritten', (t) => {
 })
 
 test('active manifest repository cannot be removed', (t) => {
-  const { cli, ok, git, registry } = setup(t)
+  const { cli, ok, registry } = setup(t)
   ok('add', 'owner/workspace')
-  const directory = path.dirname(registry)
-  git('-C', directory, 'add', 'workspace.json')
-  git('-C', directory, 'commit', '-m', 'Manifest')
   const before = fs.readFileSync(registry, 'utf8')
   const result = cli('remove', 'owner/workspace')
   t.is(result.status, 1)

package/test/manifest-push.js

@@ -0,0 +1,135 @@
+import test from 'brittle'
+import fs from 'bare-fs'
+import path from 'bare-path'
+import setup from './helpers.js'
+
+function remote(t) {
+  const context = setup(t)
+  const directory = path.dirname(context.registry)
+  const upstream = path.join(context.upstream, 'owner/workspace.git')
+  context.git('clone', '--bare', directory, upstream)
+  return { ...context, directory, remote: upstream }
+}
+
+test('init pushes its first manifest commit to an empty remote and establishes tracking', (t) => {
+  const { cli, git, upstream, registry } = setup(t, { initialize: false })
+  const destination = path.join(upstream, 'owner/workspace.git')
+  git('init', '--bare', destination)
+  const result = cli('init', 'owner/workspace')
+  t.is(result.status, 0, result.stderr)
+  t.absent(result.stderr.includes('could not push'))
+  const directory = path.dirname(registry)
+  t.is(
+    git('--git-dir', destination, 'rev-parse', 'main'),
+    git('-C', directory, 'rev-parse', 'HEAD')
+  )
+  t.is(git('-C', directory, 'rev-parse', '--abbrev-ref', '@{upstream}'), 'origin/main')
+})
+
+test('failed push retains local results, checkpoint and hook delivery; repeated add retries without a commit', (t) => {
+  const { cli, git, directory, registry, bin, remote: destination } = remote(t)
+  const head = git('-C', directory, 'rev-parse', 'HEAD')
+  const hooks = path.join(destination, 'hooks')
+  git('--git-dir', destination, 'config', 'core.hooksPath', hooks)
+  const reject = path.join(hooks, 'pre-receive')
+  fs.writeFileSync(reject, '#!/bin/sh\necho push-rejected >&2\nexit 1\n', { mode: 0o755 })
+  fs.writeFileSync(
+    path.join(bin, 'git-workspace-hook-add-post-check'),
+    '#!/bin/sh\ncat >/dev/null\necho post-hook-ran >&2\n',
+    { mode: 0o755 }
+  )
+  const added = cli('add', 'owner/repo@jobs')
+  t.is(added.status, 0, added.stderr)
+  t.ok(added.stderr.includes('could not push workspace manifest'))
+  t.ok(added.stderr.includes('push-rejected'))
+  t.ok(added.stderr.includes('changes are saved locally'))
+  t.ok(added.stderr.includes('post-hook-ran'))
+  const committed = git('-C', directory, 'rev-parse', 'HEAD')
+  t.unlike(committed, head)
+  t.is(git('-C', directory, 'rev-parse', 'refs/git-workspace/applied'), committed)
+  t.is(git('--git-dir', destination, 'rev-parse', 'main'), head)
+  t.is(JSON.parse(fs.readFileSync(registry, 'utf8')).repositories[0].worktrees.length, 1)
+  fs.unlinkSync(reject)
+  const retried = cli('add', 'owner/repo@jobs')
+  t.is(retried.status, 0, retried.stderr)
+  t.absent(retried.stderr.includes('could not push'))
+  t.is(git('-C', directory, 'rev-parse', 'HEAD'), committed, 'retry makes no extra commit')
+  t.is(git('--git-dir', destination, 'rev-parse', 'main'), committed)
+})
+
+test('push follows a differently named upstream without publishing other branches, tags or checkout commits', (t) => {
+  const { ok, git, root, directory, upstream, remote: destination } = remote(t)
+  const original = git('--git-dir', destination, 'rev-parse', 'main')
+  git('-C', directory, 'push', 'origin', 'main:team')
+  git('-C', directory, 'config', 'branch.main.remote', 'origin')
+  git('-C', directory, 'config', 'branch.main.merge', 'refs/heads/team')
+  git('-C', directory, 'branch', 'unrelated')
+  git('-C', directory, 'tag', '-a', 'private-tag', '-m', 'Keep local')
+  git('-C', directory, 'config', 'push.followTags', 'true')
+  git('-C', directory, 'config', 'push.default', 'matching')
+  const checkoutRemote = path.join(upstream, 'owner/repo.git')
+  const checkoutHead = git('--git-dir', checkoutRemote, 'rev-parse', 'main')
+  ok('add', 'owner/repo')
+  git('-C', root, 'commit', '--allow-empty', '-m', 'Local project commit')
+  ok('add', 'owner/repo@jobs')
+  t.is(
+    git('--git-dir', destination, 'rev-parse', 'team'),
+    git('-C', directory, 'rev-parse', 'HEAD')
+  )
+  t.is(
+    git('--git-dir', destination, 'rev-parse', 'main'),
+    original,
+    'original branch stays unchanged'
+  )
+  t.is(
+    git(
+      '--git-dir',
+      destination,
+      'for-each-ref',
+      '--format=%(refname)',
+      'refs/tags',
+      'refs/heads/unrelated'
+    ),
+    ''
+  )
+  t.is(
+    git('--git-dir', checkoutRemote, 'rev-parse', 'main'),
+    checkoutHead,
+    'project commits stay local'
+  )
+})
+
+test('non-fast-forward pushes warn without force pushing or merging remote changes', (t) => {
+  const { cli, git, directory, home, remote: destination } = remote(t)
+  const other = path.join(home, 'other-manifest')
+  git('clone', destination, other)
+  fs.appendFileSync(path.join(other, 'workspace.json'), '\n')
+  git('-C', other, 'commit', '-am', 'Remote change')
+  git('-C', other, 'push', 'origin', 'main')
+  const remoteHead = git('--git-dir', destination, 'rev-parse', 'main')
+  const result = cli('add', 'owner/repo')
+  t.is(result.status, 0, result.stderr)
+  t.ok(result.stderr.includes('could not push workspace manifest'))
+  t.is(git('--git-dir', destination, 'rev-parse', 'main'), remoteHead)
+  t.unlike(git('-C', directory, 'rev-parse', 'HEAD'), remoteHead)
+  t.is(git('-C', directory, 'log', '-1', '--format=%s'), 'Add owner/repo')
+  t.is(git('-C', directory, 'rev-list', '--count', 'HEAD'), '2', 'no automatic merge')
+})
+
+test('commit failures never push, and detached manifests warn rather than publishing an arbitrary branch', (t) => {
+  const { cli, git, directory, remote: destination } = remote(t)
+  const head = git('--git-dir', destination, 'rev-parse', 'main')
+  const hooks = path.join(directory, '.git/hooks')
+  git('-C', directory, 'config', 'core.hooksPath', hooks)
+  const reject = path.join(hooks, 'pre-commit')
+  fs.writeFileSync(reject, '#!/bin/sh\nexit 1\n', { mode: 0o755 })
+  t.is(cli('add', 'owner/repo').status, 1)
+  t.is(git('--git-dir', destination, 'rev-parse', 'main'), head)
+  fs.unlinkSync(reject)
+  git('-C', directory, 'checkout', '--detach')
+  const result = cli('add', 'owner/repo')
+  t.is(result.status, 0, result.stderr)
+  t.ok(result.stderr.includes('could not push workspace manifest'))
+  t.ok(result.stderr.includes('detached HEAD'))
+  t.is(git('--git-dir', destination, 'rev-parse', 'main'), head)
+})