git-workspace-bare 0.1.0

package/lib/status.js

@@ -0,0 +1,52 @@
+import fs from 'bare-fs'
+import { spawn } from 'bare-subprocess'
+import list from './list.js'
+import repositoryPath from './repository-path.js'
+import mapConcurrent from './map-concurrent.js'
+
+export default async function status() {
+  return mapConcurrent(list(), async (repository) => {
+    const directory = repositoryPath(repository)
+    let canonical
+    try {
+      canonical = fs.realpathSync(directory)
+    } catch (err) {
+      if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return { repository, state: 'missing' }
+      throw err
+    }
+
+    if (fs.realpathSync(await git(directory, ['rev-parse', '--show-toplevel'])) !== canonical) {
+      throw new Error(`${repository}: not a Git worktree root`)
+    }
+    const changes = await git(directory, [
+      'status',
+      '--porcelain',
+      '--untracked-files=all',
+      '--ignore-submodules=none'
+    ])
+    return { repository, state: changes ? 'modified' : 'clean' }
+  })
+}
+
+function git(directory, args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn('git', ['--no-optional-locks', '-C', directory, ...args], {
+      stdio: ['ignore', 'pipe', 'pipe']
+    })
+    let stdout = ''
+    let stderr = ''
+    child.stdout.setEncoding('utf8')
+    child.stderr.setEncoding('utf8')
+    child.stdout.on('data', (data) => {
+      stdout += data
+    })
+    child.stderr.on('data', (data) => {
+      stderr += data
+    })
+    child.on('error', reject)
+    child.on('close', (code) => {
+      if (code !== 0) reject(new Error(stderr.trim() || 'Git command failed'))
+      else resolve(stdout.replace(/\r?\n$/, ''))
+    })
+  })
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "git-workspace-bare",
+  "version": "0.1.0",
+  "description": "Manage Git worktrees as development workspaces",
+  "type": "module",
+  "bin": {
+    "git-workspace": "./bin/git-workspace.js"
+  },
+  "scripts": {
+    "test": "bare test/lifecycle.js",
+    "format": "prettier . --write",
+    "lint": "lunte"
+  },
+  "license": "Apache-2.0",
+  "dependencies": {
+    "bare-fs": "^4.8.1",
+    "bare-os": "^3.9.3",
+    "bare-path": "^3.1.2",
+    "bare-subprocess": "^6.1.0",
+    "bare-tty": "^5.2.1",
+    "paparam": "^1.13.0"
+  },
+  "devDependencies": {
+    "bare-process": "^4.5.1",
+    "brittle": "^4.2.0",
+    "lunte": "^1.8.4",
+    "prettier": "^3.9.8",
+    "prettier-config-holepunch": "^2.0.0"
+  }
+}

package/test/fixtures/cli.js

@@ -0,0 +1,5 @@
+import os from 'bare-os'
+
+const home = Bare.argv.splice(2, 1)[0]
+os.homedir = () => home
+await import('../../bin/git-workspace.js')

package/test/helpers.js

@@ -0,0 +1,83 @@
+import fs from 'bare-fs'
+import os from 'bare-os'
+import path from 'bare-path'
+import process from 'bare-process'
+import { spawnSync } from 'bare-subprocess'
+
+export default function setup(t, { initialize = true } = {}) {
+  const temporary = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'git-workspace-test-')))
+  t.teardown(() => fs.rmSync(temporary, { recursive: true }), { force: true })
+  const home = path.join(temporary, 'home')
+  const upstream = path.join(temporary, 'upstream')
+  const config = path.join(temporary, 'gitconfig')
+  fs.mkdirSync(home)
+  fs.mkdirSync(path.join(upstream, 'owner'), { recursive: true })
+  fs.mkdirSync(path.join(temporary, 'hooks'))
+  fs.writeFileSync(config, '')
+
+  const env = { ...process.env }
+  for (const key of Object.keys(env)) {
+    if (key.startsWith('GIT_')) delete env[key]
+  }
+  Object.assign(env, {
+    GIT_CONFIG_NOSYSTEM: '1',
+    GIT_CONFIG_GLOBAL: config,
+    GIT_ALLOW_PROTOCOL: 'file',
+    GIT_TERMINAL_PROMPT: '0'
+  })
+
+  function run(file, args) {
+    const result = spawnSync(file, args, { cwd: temporary, env })
+    if (result.error) throw result.error
+    return {
+      status: result.status,
+      stdout: result.stdout.toString(),
+      stderr: result.stderr.toString()
+    }
+  }
+
+  function git(...args) {
+    const result = run('git', args)
+    if (result.status !== 0) throw new Error(result.stderr)
+    return result.stdout.trim()
+  }
+
+  git('config', '--file', config, 'user.name', 'Workspace Test')
+  git('config', '--file', config, 'user.email', 'test@example.com')
+  git('config', '--file', config, 'commit.gpgsign', 'false')
+  git('config', '--file', config, 'init.defaultBranch', 'main')
+  git('config', '--file', config, 'core.hooksPath', path.join(temporary, 'hooks'))
+  git('config', '--file', config, `url.file://${upstream}/.insteadOf`, 'git@github.com:')
+  const source = path.join(temporary, 'source')
+  git('init', source)
+  fs.writeFileSync(path.join(source, 'tracked.txt'), 'original\n')
+  git('-C', source, 'add', 'tracked.txt')
+  git('-C', source, 'commit', '-m', 'Fixture')
+  git('clone', '--bare', source, path.join(upstream, 'owner/repo.git'))
+
+  const runner = fs.realpathSync(new URL('./fixtures/cli.js', import.meta.url))
+  function cli(...args) {
+    return cliAt(home, ...args)
+  }
+  function cliAt(directory, ...args) {
+    return run(os.execPath(), [runner, directory, ...args])
+  }
+  function ok(...args) {
+    const result = cli(...args)
+    if (result.status !== 0) throw new Error(result.stderr)
+    return result.stdout
+  }
+
+  if (initialize) ok('init', 'owner/workspace')
+
+  return {
+    cli,
+    cliAt,
+    ok,
+    git,
+    home,
+    upstream,
+    root: path.join(home, 'workspace/owner/repo'),
+    registry: path.join(home, 'workspace/owner/workspace/workspace.json')
+  }
+}

package/test/lifecycle.js

@@ -0,0 +1,479 @@
+import test from 'brittle'
+import fs from 'bare-fs'
+import path from 'bare-path'
+import setup from './helpers.js'
+
+test('clone, list, and remove a root repository', (t) => {
+  const { ok, root, registry } = setup(t)
+  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')
+  ok('add', 'owner/repo')
+  t.alike(JSON.parse(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')
+})
+
+test('nested branches and empty parent cleanup', (t) => {
+  const { ok, git, root } = setup(t)
+  ok('add', 'owner/repo@feature/jobs')
+  ok('add', 'owner/repo@feature/fixes/deep')
+  t.is(git('-C', root + '@feature/jobs', 'symbolic-ref', '--short', 'HEAD'), 'feature/jobs')
+  t.is(ok('list'), 'owner/repo\nowner/repo@feature/fixes/deep\nowner/repo@feature/jobs\n')
+  ok('remove', 'owner/repo@feature/fixes/deep')
+  t.absent(fs.existsSync(root + '@feature/fixes'), 'empty intermediate directory removed')
+  t.ok(fs.existsSync(root + '@feature/jobs'), 'sibling worktree preserved')
+  ok('remove', 'owner/repo@feature/jobs')
+  t.absent(fs.existsSync(root + '@feature'), 'empty branch parent removed')
+  t.ok(fs.existsSync(path.dirname(root)), 'owner directory preserved')
+  t.is(git('-C', root, 'branch', '--list', 'feature/*'), '', 'local branches deleted')
+  ok('add', 'owner/repo@keep/child')
+  fs.writeFileSync(root + '@keep/note', 'keep')
+  ok('remove', 'owner/repo@keep/child')
+  t.is(fs.readFileSync(root + '@keep/note', 'utf8'), 'keep', 'nonempty parent preserved')
+})
+
+test('root removal refuses linked worktrees', (t) => {
+  const { cli, ok, root, registry } = setup(t)
+  ok('add', 'owner/repo@jobs')
+  const before = fs.readFileSync(registry, 'utf8')
+  const result = cli('remove', 'owner/repo')
+  t.is(result.status, 1)
+  t.is(result.stdout, '')
+  t.is(
+    result.stderr,
+    'error: cannot remove owner/repo: linked worktrees exist\nhint: remove the linked worktrees first\n'
+  )
+  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')
+})
+
+test('dirty worktrees and roots survive failed removal', (t) => {
+  const { cli, ok, git, root, registry } = setup(t)
+  ok('add', 'owner/repo@jobs')
+  const worktree = root + '@jobs'
+  const tracked = path.join(worktree, 'tracked.txt')
+  const before = fs.readFileSync(registry, 'utf8')
+  fs.writeFileSync(tracked, 'changed\n')
+  t.is(cli('remove', 'owner/repo@jobs').status, 1, 'modified tracked file blocks removal')
+  t.is(fs.readFileSync(tracked, 'utf8'), 'changed\n')
+  fs.writeFileSync(tracked, 'original\n')
+  fs.writeFileSync(path.join(worktree, 'untracked'), 'keep')
+  t.is(cli('remove', 'owner/repo@jobs').status, 1, 'untracked file blocks removal')
+  t.is(fs.readFileSync(registry, 'utf8'), before)
+  t.is(git('-C', worktree, 'symbolic-ref', '--short', 'HEAD'), 'jobs', 'branch preserved')
+  fs.unlinkSync(path.join(worktree, 'untracked'))
+  git('-C', worktree, 'commit', '--allow-empty', '-m', 'Unmerged commit')
+  ok('remove', 'owner/repo@jobs')
+  t.is(git('-C', root, 'branch', '--list', 'jobs'), '', 'clean unmerged branch is force-deleted')
+  fs.writeFileSync(path.join(root, 'tracked.txt'), 'root changes\n')
+  t.is(cli('remove', 'owner/repo').status, 1, 'dirty root is protected')
+  t.is(fs.readFileSync(path.join(root, 'tracked.txt'), 'utf8'), 'root changes\n')
+  t.is(ok('list'), 'owner/repo\n')
+})
+
+test('worktrees are removed along with whichever branch they hold', (t) => {
+  const { ok, git, root } = setup(t)
+  ok('add', 'owner/repo@jobs')
+  const worktree = root + '@jobs'
+  git('-C', worktree, 'switch', '-c', 'renamed')
+  git('-C', root, 'branch', '-D', 'jobs')
+  ok('remove', 'owner/repo@jobs')
+  t.absent(fs.existsSync(worktree), 'worktree removed despite the branch mismatch')
+  t.is(git('-C', root, 'branch', '--list', 'renamed'), '', 'checked-out branch deleted')
+  t.is(ok('list'), 'owner/repo\n', 'entry unregistered')
+
+  ok('add', 'owner/repo@detached')
+  const second = root + '@detached'
+  git('-C', second, 'checkout', '--detach')
+  ok('remove', 'owner/repo@detached')
+  t.absent(fs.existsSync(second), 'detached worktree removed')
+  t.is(
+    git('-C', root, 'branch', '--list', 'detached').trim(),
+    'detached',
+    'detached HEAD leaves the branch alone'
+  )
+  t.is(ok('list'), 'owner/repo\n')
+})
+
+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')
+  const external = path.join(home, 'external')
+  git('-C', root, 'worktree', 'add', '-b', 'external', external)
+  git('-C', root, 'config', '--add', 'remote.origin.pushurl', 'https://github.com/owner/repo.git')
+  git('-C', root, 'config', '--add', 'remote.origin.pushurl', 'git@github.com:other/mirror.git')
+  fs.writeFileSync(path.join(root, 'untracked.txt'), 'keep root work')
+  fs.writeFileSync(path.join(root + '@feature/jobs', 'tracked.txt'), 'keep branch work')
+  const head = git('-C', root, 'rev-parse', 'HEAD')
+  ok('rename', 'owner/repo', 'owner/renamed')
+  const renamed = path.join(path.dirname(root), 'renamed')
+  t.absent(fs.existsSync(root), 'root moved')
+  t.absent(fs.existsSync(root + '@feature'), 'empty branch parent removed')
+  t.is(ok('list'), 'owner/renamed\nowner/renamed@feature/jobs\n')
+  t.is(fs.readFileSync(path.join(renamed, 'untracked.txt'), 'utf8'), 'keep root work')
+  t.is(
+    fs.readFileSync(path.join(renamed + '@feature/jobs', 'tracked.txt'), 'utf8'),
+    'keep branch work'
+  )
+  t.is(git('-C', renamed + '@feature/jobs', 'symbolic-ref', '--short', 'HEAD'), 'feature/jobs')
+  t.is(git('-C', renamed, 'rev-parse', 'HEAD'), head, 'no commits')
+  t.is(
+    git('-C', external, 'rev-parse', '--path-format=absolute', '--git-common-dir'),
+    path.join(renamed, '.git')
+  )
+  t.is(
+    git('-C', renamed, 'config', '--get', 'remote.origin.url'),
+    'git@github.com:owner/renamed.git'
+  )
+  t.is(
+    git('-C', renamed, 'config', '--get-all', 'remote.origin.pushurl'),
+    'https://github.com/owner/renamed.git\ngit@github.com:other/mirror.git'
+  )
+  t.ok(fs.existsSync(path.join(upstream, 'owner/repo.git')), 'remote untouched')
+  t.absent(fs.existsSync(path.join(upstream, 'owner/renamed.git')), 'no remote created')
+  ok('add', 'owner/renamed')
+  git('-C', renamed + '@feature/jobs', 'restore', 'tracked.txt')
+  ok('remove', 'owner/renamed@feature/jobs')
+  t.absent(fs.existsSync(renamed + '@feature/jobs'), 'worktree remains usable')
+})
+
+test('root rename moves checkouts to a different owner locally', (t) => {
+  const { ok, git, home, root, upstream } = setup(t)
+  ok('add', 'owner/repo@feature/jobs')
+  const renamed = path.join(home, 'workspace/other/new')
+  ok('rename', 'owner/repo', 'other/new')
+  t.absent(fs.existsSync(root), 'old root moved')
+  t.absent(fs.existsSync(root + '@feature'), 'old branch parents cleaned up')
+  t.is(ok('list'), 'other/new\nother/new@feature/jobs\n')
+  t.is(git('-C', renamed, 'config', '--get', 'remote.origin.url'), 'git@github.com:other/new.git')
+  t.is(
+    git('-C', renamed + '@feature/jobs', 'rev-parse', '--path-format=absolute', '--git-common-dir'),
+    path.join(renamed, '.git')
+  )
+  t.is(git('-C', renamed + '@feature/jobs', 'symbolic-ref', '--short', 'HEAD'), 'feature/jobs')
+  t.ok(fs.existsSync(path.join(upstream, 'owner/repo.git')), 'remote unchanged')
+  ok('add', 'other/new')
+  ok('remove', 'other/new@feature/jobs')
+  t.is(ok('list'), 'other/new\n', 'worktree removal still works')
+})
+
+test('root rename accepts an origin already updated manually and preserves URL style', (t) => {
+  const { ok, git, root } = setup(t)
+  ok('add', 'owner/repo')
+  git('-C', root, 'config', 'remote.origin.url', 'ssh://git@github.com/owner/new.git')
+  ok('rename', 'owner/repo', 'owner/new')
+  const renamed = path.join(path.dirname(root), 'new')
+  t.is(
+    git('-C', renamed, 'config', '--get', 'remote.origin.url'),
+    'ssh://git@github.com/owner/new.git'
+  )
+  ok('rename', 'owner/new', 'owner/repo')
+  t.is(
+    git('-C', root, 'config', '--get', 'remote.origin.url'),
+    'ssh://git@github.com/owner/repo.git'
+  )
+})
+
+test('root rename refuses unsafe destinations and linked worktrees before moving', (t) => {
+  const { cli, ok, git, root, registry } = setup(t)
+  ok('add', 'owner/repo@jobs')
+  const before = fs.readFileSync(registry, 'utf8')
+  const renamed = path.join(path.dirname(root), 'new')
+  fs.symlinkSync(path.join(root, 'absent'), renamed)
+  t.is(cli('rename', 'owner/repo', 'owner/new').status, 1, 'dangling destination symlink')
+  fs.unlinkSync(renamed)
+  fs.mkdirSync(renamed + '@jobs')
+  t.is(cli('rename', 'owner/repo', 'owner/new').status, 1, 'branch destination conflict')
+  fs.rmdirSync(renamed + '@jobs')
+  git('-C', root, 'worktree', 'lock', root + '@jobs')
+  t.is(cli('rename', 'owner/repo', 'owner/new').status, 1, 'locked worktree')
+  git('-C', root, 'worktree', 'unlock', root + '@jobs')
+  const head = git('-C', root, 'rev-parse', 'HEAD')
+  git('-C', root + '@jobs', 'update-index', '--add', '--cacheinfo', `160000,${head},module`)
+  t.is(cli('rename', 'owner/repo', 'owner/new').status, 1, 'linked submodule')
+  git('-C', root + '@jobs', 'reset', 'HEAD')
+  fs.renameSync(root + '@jobs', root + '@missing')
+  t.is(cli('rename', 'owner/repo', 'owner/new').status, 1, 'missing linked worktree')
+  fs.renameSync(root + '@missing', root + '@jobs')
+  git('-C', root, 'config', 'remote.origin.url', 'git@github.com:other/repo.git')
+  t.is(cli('rename', 'owner/repo', 'owner/new').status, 1, 'wrong origin')
+  t.is(fs.readFileSync(registry, 'utf8'), before, 'manifest unchanged')
+  t.ok(fs.existsSync(root), 'root unchanged')
+  t.ok(fs.existsSync(root + '@jobs'), 'worktree unchanged')
+})
+
+test('root rename restores local paths and Git links on failure', (t) => {
+  const { cli, ok, git, root, registry } = setup(t)
+  ok('add', 'owner/repo@jobs')
+  const before = fs.readFileSync(registry, 'utf8')
+  fs.writeFileSync(path.join(root, '.git/config.lock'), '')
+  t.is(cli('rename', 'owner/repo', 'owner/new').status, 1, 'config write fails')
+  t.is(fs.readFileSync(registry, 'utf8'), before)
+  t.is(
+    git('-C', root + '@jobs', 'rev-parse', '--path-format=absolute', '--git-common-dir'),
+    path.join(root, '.git')
+  )
+  t.is(git('-C', root, 'config', '--get', 'remote.origin.url'), 'git@github.com:owner/repo.git')
+  fs.unlinkSync(path.join(root, '.git/config.lock'))
+  ok('rename', 'owner/repo', 'owner/new')
+  t.is(ok('list'), 'owner/new\nowner/new@jobs\n', 'retry works')
+})
+
+test('root rename refuses the active manifest repository', (t) => {
+  const { cli, ok, registry } = setup(t)
+  ok('add', 'owner/workspace')
+  const result = cli('rename', 'owner/workspace', 'owner/new')
+  t.is(result.status, 1)
+  t.ok(result.stderr.includes('Cannot rename the active manifest repository'))
+  t.ok(fs.existsSync(registry))
+})
+
+test('rename moves a worktree and its branch together', (t) => {
+  const { ok, git, root } = setup(t)
+  ok('add', 'owner/repo@jobs')
+  git('-C', root, 'branch', '--set-upstream-to=origin/main', 'jobs')
+  fs.writeFileSync(path.join(root + '@jobs', 'tracked.txt'), 'in progress\n')
+  ok('rename', 'owner/repo@jobs', 'owner/repo@fixes')
+  t.absent(fs.existsSync(root + '@jobs'), 'old directory gone')
+  t.is(
+    fs.readFileSync(path.join(root + '@fixes', 'tracked.txt'), 'utf8'),
+    'in progress\n',
+    'uncommitted work carried along'
+  )
+  t.is(git('-C', root + '@fixes', 'symbolic-ref', '--short', 'HEAD'), 'fixes', 'branch renamed')
+  t.is(git('-C', root, 'branch', '--list', 'jobs'), '', 'old branch gone')
+  t.is(ok('list'), 'owner/repo\nowner/repo@fixes\n', 'manifest updated')
+  t.is(
+    git('-C', root, 'config', '--get', 'branch.fixes.merge'),
+    'refs/heads/fixes',
+    'upstream retargeted to the new name'
+  )
+  t.is(git('-C', root, 'config', '--get', 'branch.fixes.remote'), 'origin', 'remote preserved')
+})
+
+test('rename realigns a worktree switched to another branch', (t) => {
+  const { ok, git, root } = setup(t)
+  ok('add', 'owner/repo@jobs')
+  git('-C', root + '@jobs', 'switch', '-c', 'wandered')
+  ok('rename', 'owner/repo@jobs', 'owner/repo@wandered')
+  t.absent(fs.existsSync(root + '@jobs'), 'stale directory gone')
+  t.is(git('-C', root + '@wandered', 'symbolic-ref', '--short', 'HEAD'), 'wandered')
+  t.is(ok('list'), 'owner/repo\nowner/repo@wandered\n', 'name matches the branch again')
+  t.is(
+    git('-C', root, 'branch', '--list', 'jobs').trim(),
+    'jobs',
+    'branch left behind by the\n    switch is untouched'
+  )
+})
+
+test('rename handles nested names and refuses unsafe targets', (t) => {
+  const { cli, ok, git, root } = setup(t)
+  ok('add', 'owner/repo@feature/jobs')
+  ok('add', 'owner/repo@taken')
+  ok('rename', 'owner/repo@feature/jobs', 'owner/repo@plain')
+  t.absent(fs.existsSync(root + '@feature'), 'empty parent cleaned up')
+  t.is(git('-C', root + '@plain', 'symbolic-ref', '--short', 'HEAD'), 'plain')
+  ok('rename', 'owner/repo@plain', 'owner/repo@deep/nest')
+  t.is(git('-C', root + '@deep/nest', 'symbolic-ref', '--short', 'HEAD'), 'deep/nest')
+
+  const before = ok('list')
+  t.is(cli('rename', 'owner/repo@deep/nest', 'owner/repo@taken').status, 1, 'existing branch')
+  t.is(cli('rename', 'owner/repo@deep/nest', 'other/repo@x').status, 1, 'cross repository')
+  t.is(cli('rename', 'owner/repo@deep/nest', 'owner/repo').status, 1, 'root target')
+  t.is(cli('rename', 'owner/repo', 'owner/repo@x').status, 1, 'root source')
+  t.is(cli('rename', 'owner/repo@missing', 'owner/repo@x').status, 1, 'absent worktree')
+  git('-C', root + '@deep/nest', 'checkout', '--detach')
+  t.is(cli('rename', 'owner/repo@deep/nest', 'owner/repo@x').status, 1, 'detached HEAD')
+  t.is(ok('list'), before, 'manifest unchanged by refusals')
+  t.ok(fs.existsSync(root + '@deep/nest'), 'worktree preserved by refusals')
+})
+
+test('status reports sorted clean, modified, and missing checkouts without writes', (t) => {
+  const { ok, git, root, registry } = setup(t)
+  t.is(ok('status'), '', 'empty manifest is silent')
+  ok('add', 'owner/repo@z/missing')
+  ok('add', 'owner/repo@a/changed')
+  fs.writeFileSync(path.join(root, '.git/info/exclude'), 'ignored\n')
+  fs.writeFileSync(path.join(root, 'ignored'), 'ignored data')
+  const changed = root + '@a/changed'
+  const tracked = path.join(changed, 'tracked.txt')
+  fs.writeFileSync(tracked, 'changed\n')
+  fs.renameSync(root + '@z/missing', root + '@moved')
+  const before = fs.readFileSync(registry, 'utf8')
+  const index = fs.readFileSync(path.join(root, '.git/index'))
+  t.is(
+    ok('status'),
+    'owner/repo            clean\nowner/repo@a/changed  modified\nowner/repo@z/missing  missing\n'
+  )
+  t.alike(fs.readFileSync(path.join(root, '.git/index')), index, 'root index unchanged')
+  git('-C', changed, 'add', 'tracked.txt')
+  t.ok(ok('status').includes('owner/repo@a/changed  modified'), 'staged change detected')
+  git('-C', changed, 'commit', '-m', 'Change')
+  fs.writeFileSync(path.join(changed, 'untracked'), 'keep')
+  t.ok(ok('status').includes('owner/repo@a/changed  modified'), 'untracked file detected')
+  t.is(fs.readFileSync(registry, 'utf8'), before, 'registry unchanged')
+  t.is(fs.readFileSync(tracked, 'utf8'), 'changed\n', 'working files unchanged')
+})
+
+test('status reports invalid existing checkouts as errors', (t) => {
+  const { cli, ok, root, registry } = setup(t)
+  ok('add', 'owner/repo')
+  fs.renameSync(path.join(root, '.git'), path.join(root, 'saved-git'))
+  const before = fs.readFileSync(registry, 'utf8')
+  const result = cli('status')
+  t.is(result.status, 1)
+  t.is(result.stdout, '', 'no misleading status output')
+  t.ok(result.stderr.startsWith('error: '))
+  t.is(fs.readFileSync(registry, 'utf8'), before)
+})
+
+test('bounded workers overlap, preserve order, and drain on failure', async (t) => {
+  const { default: mapConcurrent } = await import('../lib/map-concurrent.js')
+  let active = 0
+  let peak = 0
+  const release = []
+  let secondBatch
+  const started = new Promise((resolve) => {
+    secondBatch = resolve
+  })
+  const result = mapConcurrent([0, 1, 2, 3, 4, 5, 6, 7], async (item) => {
+    active++
+    peak = Math.max(peak, active)
+    await new Promise((resolve) => {
+      release[item] = resolve
+      if (item === 7) secondBatch()
+    })
+    active--
+    return item
+  })
+  t.is(active, 4, 'starts four concurrent checks')
+  for (const resolve of release.slice().reverse()) resolve()
+  await started
+  t.is(active, 4, 'refills workers without exceeding limit')
+  for (const resolve of release.slice(4).reverse()) resolve()
+  t.alike(await result, [0, 1, 2, 3, 4, 5, 6, 7], 'completion order does not affect output')
+  t.is(peak, 4)
+
+  let finish
+  let calls = 0
+  let drained = false
+  const failure = new Error('failed check')
+  const pending = mapConcurrent(
+    [0, 1, 2],
+    async (item) => {
+      calls++
+      if (item === 0) throw failure
+      await new Promise((resolve) => {
+        finish = resolve
+      })
+      drained = true
+    },
+    2
+  )
+  await Promise.resolve()
+  t.is(calls, 2, 'does not start queued checks after failure')
+  finish()
+  await t.exception(pending, /failed check/)
+  t.ok(drained, 'active work finishes before rejection')
+})
+
+test('commands require init and ignore old registry files', (t) => {
+  const { cli, home, root } = setup(t, { initialize: false })
+  fs.mkdirSync(path.join(home, '.git-workspace'))
+  fs.writeFileSync(path.join(home, '.git-workspace/worktrees.json'), JSON.stringify([root]))
+  for (const args of [['list'], ['status'], ['add', 'owner/repo'], ['remove', 'owner/repo']]) {
+    const result = cli(...args)
+    t.is(result.status, 1)
+    t.ok(result.stderr.includes('git workspace init owner/repo'))
+  }
+  t.absent(fs.existsSync(root), 'add does not clone before initialization')
+})
+
+test('init creates a local manifest without importing old registries or committing', (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"]')
+  const result = cli('init', 'owner/workspace')
+  t.is(result.status, 0)
+  t.ok(result.stderr.includes('initialized locally'))
+  const directory = path.dirname(registry)
+  t.is(
+    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(
+    JSON.parse(fs.readFileSync(path.join(home, '.config/git-workspace/config.json'), 'utf8')),
+    { manifestRepository: directory },
+    'config points to repo in workspace'
+  )
+  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'])
+  ok('remove', 'owner/repo@feature/jobs')
+  ok('init', 'owner/workspace')
+  t.alike(
+    JSON.parse(fs.readFileSync(registry, 'utf8')),
+    ['owner/repo'],
+    'repeat init preserves edits'
+  )
+  t.is(cli('init', 'owner/other').status, 1, 'different remote refused')
+})
+
+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))
+  git('-C', source, 'add', 'workspace.json')
+  git('-C', source, 'commit', '-m', 'Manifest fixture')
+  git('clone', '--bare', source, path.join(upstream, 'owner/workspace.git'))
+  ok('init', 'owner/workspace')
+  t.is(ok('list'), entries.join('\n') + '\n')
+  t.absent(fs.existsSync(path.join(home, 'workspace/owner/repo')), 'no managed repos cloned')
+  t.is(git('-C', path.dirname(registry), 'status', '--porcelain'), '', 'clone unchanged')
+  const secondHome = path.join(home, 'second-machine')
+  fs.mkdirSync(secondHome)
+  t.is(cliAt(secondHome, 'init', 'owner/workspace').status, 0)
+  t.is(cliAt(secondHome, 'list').stdout, entries.join('\n') + '\n')
+  t.ok(
+    cliAt(secondHome, 'status')
+      .stdout.split('\n')
+      .filter(Boolean)
+      .every((line) => line.endsWith('missing'))
+  )
+})
+
+test('invalid manifests fail without being overwritten', (t) => {
+  const { cli, git, home, upstream, registry } = setup(t, { initialize: false })
+  t.is(cli('init', 'owner/workspace@branch').status, 1)
+  const source = path.join(home, 'bad-manifest')
+  git('init', source)
+  const invalid = '["/another/machine/path"]'
+  fs.writeFileSync(path.join(source, 'workspace.json'), invalid)
+  git('-C', source, 'add', 'workspace.json')
+  git('-C', source, 'commit', '-m', 'Invalid manifest')
+  git('clone', '--bare', source, path.join(upstream, 'owner/workspace.git'))
+  t.is(cli('init', 'owner/workspace').status, 1)
+  t.is(cli('list').status, 1)
+  t.is(fs.readFileSync(registry, 'utf8'), invalid)
+})
+
+test('active manifest repository cannot be removed', (t) => {
+  const { cli, ok, git, 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)
+  t.ok(result.stderr.includes('Cannot remove the active manifest repository'))
+  t.is(fs.readFileSync(registry, 'utf8'), before)
+})