@north-light/crouter 0.3.317 → 0.3.319

package/dist/core/__tests__/integration/worktree-land.test.js

@@ -1,607 +0,0 @@
-// Managed worktrees: create, and the land/close half — base-ref recording,
-// rebase-onto-captured-SHA, the dirty gate, and what close is allowed to touch.
-// Split from its reap half (worktree-reap.test.ts) only so the two run as two
-// parallel files; they share the fixture shape, not state.
-import { test, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, existsSync, statSync, writeFileSync, readFileSync, chmodSync } from 'node:fs';
-import { spawn } from 'node:child_process';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { gitSync } from '../../git.js';
-import { createManagedWorktree, closeManagedWorktree, managedWorktreePath, rollbackManagedWorktree } from '../../worktree.js';
-import { closeManagedWorktreeAsync } from '../../worktree-close.js';
-import { reconcileManagedWorktree } from '../../worktree-sweep.js';
-import { createNode, getNode } from '../../canvas/canvas.js';
-import { closeDb, migrate, openDb } from '../../canvas/db.js';
-import { resetSession } from '../../canvas/sessions.js';
-let home;
-let remoteDir;
-let sourceDir;
-function run(args, cwd) {
-    const res = gitSync(args, cwd);
-    if (res.status !== 0) {
-        throw new Error(`git ${args.join(' ')} failed in ${cwd}: ${res.stderr || res.stdout}`);
-    }
-}
-function node(id, over = {}) {
-    return {
-        node_id: id,
-        name: id,
-        created: new Date().toISOString(),
-        cwd: '/tmp/work',
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-        ...over,
-    };
-}
-before(() => {
-    // NOT realpath'd on purpose: the macOS tmpdir is reached through the
-    // `/var` → `/private/var` symlink, so the recorded managed-worktree path and
-    // git's canonical `worktree list` output differ as strings while naming one
-    // directory. Every path-ownership check must judge identity, not spelling.
-    home = mkdtempSync(join(tmpdir(), 'crtr-worktree-home-'));
-    process.env['CRTR_HOME'] = home;
-    // Bare "remote" wired up as origin so the test can prove landing NEVER pushes
-    // to it (managed worktrees are based on and land onto local `main` only).
-    remoteDir = mkdtempSync(join(tmpdir(), 'crtr-worktree-remote-'));
-    run(['init', '--bare'], remoteDir);
-    sourceDir = mkdtempSync(join(tmpdir(), 'crtr-worktree-source-'));
-    run(['init', '-b', 'main'], sourceDir);
-    run(['config', 'user.email', 'test@example.com'], sourceDir);
-    run(['config', 'user.name', 'Test'], sourceDir);
-    writeFileSync(join(sourceDir, 'README.md'), 'hello\n');
-    run(['add', '.'], sourceDir);
-    run(['commit', '-m', 'init'], sourceDir);
-    run(['remote', 'add', 'origin', remoteDir], sourceDir);
-    run(['push', '-u', 'origin', 'main'], sourceDir);
-});
-beforeEach(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    process.env['CRTR_HOME'] = home;
-    migrate(openDb());
-});
-after(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    rmSync(remoteDir, { recursive: true, force: true });
-    rmSync(sourceDir, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-});
-// Regression for #710: close lands from a live caller, so it must preserve the
-// caller checkout rather than starting Git's recursive removal beneath it.
-test('closeManagedWorktree leaves the active caller checkout intact with named deferred cleanup', () => {
-    const nodeId = 'wt-close-1';
-    const wt = createManagedWorktree(sourceDir, nodeId);
-    assert.equal(wt.base_ref, 'main', 'default base must remain backward-compatible with persisted main worktrees');
-    assert.equal(wt.path, managedWorktreePath(nodeId));
-    assert.ok(existsSync(wt.path), 'worktree checkout should exist after create');
-    const sessionDir = join(home, 'sessions');
-    mkdirSync(sessionDir, { recursive: true });
-    const sessionFile = join(sessionDir, 'session.jsonl');
-    writeFileSync(sessionFile, `${JSON.stringify({ type: 'session', version: 3, id: 'wt-session', cwd: wt.path })}\n`);
-    createNode(node(nodeId, { cwd: wt.path, managed_worktree: wt }));
-    resetSession(nodeId, { sessionId: 'wt-session', transcriptPath: sessionFile });
-    const result = closeManagedWorktree(nodeId);
-    assert.equal(result.worktree_removed, false);
-    assert.match(result.worktree_remove_error ?? '', /cleanup pending/);
-    assert.ok(existsSync(join(wt.path, 'README.md')), 'the caller checkout keeps its tracked files');
-    assert.ok(statSync(wt.path).isDirectory(), 'the caller cwd remains a directory');
-    const list = gitSync(['worktree', 'list', '--porcelain'], sourceDir);
-    assert.ok(list.stdout.includes(wt.path), 'Git keeps the intact caller checkout registered');
-    const meta = getNode(nodeId);
-    assert.equal(meta?.managed_worktree?.state, 'closed');
-    assert.equal(meta?.managed_worktree?.cleanup, 'pending');
-    assert.equal(meta?.cwd, wt.repo_root, 'a later revive uses the durable base checkout');
-    assert.equal(meta?.pi_session_id, null, 'the live transcript remains sole-writer-owned, so close invalidates its stale resume identity');
-    assert.equal(meta?.pi_session_file, null, 'a later revive launches fresh rather than loading the header that still names this checkout');
-    return reconcileManagedWorktree(nodeId, { stillEligible: () => true }).then((outcome) => {
-        assert.equal(outcome.status, 'complete', 'the daemon-owned sweep consumes pending cleanup after the caller exits');
-        assert.equal(existsSync(wt.path), false, 'the sweep removes the deferred caller checkout');
-        assert.equal(gitSync(['show-ref', '--verify', '--quiet', `refs/heads/${wt.branch}`], sourceDir).status, 1, 'the sweep deletes the now-contained managed branch');
-        const swept = getNode(nodeId)?.managed_worktree;
-        assert.deepEqual({ state: swept?.state, cleanup: swept?.cleanup }, { state: 'closed', cleanup: 'complete' });
-    });
-});
-test('close lands underneath disjoint tracked changes in the base checkout', () => {
-    const nodeId = 'wt-close-disjoint-base-dirt';
-    writeFileSync(join(sourceDir, 'base-local.txt'), 'base version\n');
-    run(['add', 'base-local.txt'], sourceDir);
-    run(['commit', '-m', 'base local file'], sourceDir);
-    const wt = createManagedWorktree(sourceDir, nodeId);
-    createNode(node(nodeId, { cwd: wt.path, managed_worktree: wt }));
-    writeFileSync(join(wt.path, 'incoming-disjoint.txt'), 'child work\n');
-    run(['add', 'incoming-disjoint.txt'], wt.path);
-    run(['-c', 'user.email=test@example.com', '-c', 'user.name=Test', 'commit', '-m', 'disjoint child work'], wt.path);
-    writeFileSync(join(sourceDir, 'base-local.txt'), 'base local edit\n');
-    const result = closeManagedWorktree(nodeId);
-    assert.equal(gitSync(['rev-parse', 'main'], sourceDir).stdout.trim(), result.landed_sha, 'the child commit fast-forwards main despite disjoint local dirt');
-    assert.equal(readFileSync(join(sourceDir, 'base-local.txt'), 'utf8'), 'base local edit\n', 'the base checkout local edit survives untouched');
-    assert.match(gitSync(['status', '--porcelain'], sourceDir).stdout, /M base-local.txt/, 'the base local edit remains uncommitted');
-    assert.equal(gitSync(['rev-parse', '--verify', '--quiet', 'refs/stash'], sourceDir).status, 1, 'disjoint changes require no stash');
-    run(['reset', '--hard'], sourceDir);
-});
-test('close stashes and restores overlapping tracked changes without leaving a stash', () => {
-    const nodeId = 'wt-close-overlap-base-dirt';
-    // The child commit and the base local edit touch the SAME file (so landing
-    // takes the stash path) but in far-apart regions, so the stash re-apply
-    // merges cleanly rather than conflicting.
-    const original = Array.from({ length: 20 }, (_, i) => `line ${i + 1}`).join('\n') + '\n';
-    writeFileSync(join(sourceDir, 'overlap.txt'), original);
-    run(['add', 'overlap.txt'], sourceDir);
-    run(['commit', '-m', 'overlap base file'], sourceDir);
-    const wt = createManagedWorktree(sourceDir, nodeId);
-    createNode(node(nodeId, { cwd: wt.path, managed_worktree: wt }));
-    const childEdit = original.replace('line 1\n', 'line 1 child-changed\n');
-    writeFileSync(join(wt.path, 'overlap.txt'), childEdit);
-    run(['add', 'overlap.txt'], wt.path);
-    run(['-c', 'user.email=test@example.com', '-c', 'user.name=Test', 'commit', '-m', 'overlap child work'], wt.path);
-    const baseEdit = original.replace('line 20\n', 'line 20 base-changed\n');
-    writeFileSync(join(sourceDir, 'overlap.txt'), baseEdit);
-    const result = closeManagedWorktree(nodeId);
-    assert.equal(gitSync(['rev-parse', 'main'], sourceDir).stdout.trim(), result.landed_sha, 'the child commit fast-forwards main under the local edit');
-    const landed = childEdit.replace('line 20\n', 'line 20 base-changed\n');
-    assert.equal(readFileSync(join(sourceDir, 'overlap.txt'), 'utf8'), landed, 'the disjoint local edit is restored over the landed child change');
-    assert.equal(result.base_checkout_stash, undefined, 'a clean stash apply leaves no preserved-stash note');
-    assert.match(gitSync(['status', '--porcelain'], sourceDir).stdout, /M overlap.txt/, 'the restored base edit remains uncommitted');
-    assert.equal(gitSync(['rev-parse', '--verify', '--quiet', 'refs/stash'], sourceDir).status, 1, 'a clean stash apply drops the temporary stash');
-    run(['reset', '--hard'], sourceDir);
-});
-test('close refuses an incoming path that collides with an untracked base file', () => {
-    const nodeId = 'wt-close-untracked-collision';
-    const wt = createManagedWorktree(sourceDir, nodeId);
-    createNode(node(nodeId, { cwd: wt.path, managed_worktree: wt }));
-    writeFileSync(join(wt.path, 'incoming-collision.txt'), 'child work\n');
-    run(['add', 'incoming-collision.txt'], wt.path);
-    run(['-c', 'user.email=test@example.com', '-c', 'user.name=Test', 'commit', '-m', 'incoming collision'], wt.path);
-    writeFileSync(join(sourceDir, 'incoming-collision.txt'), 'base untracked work\n');
-    assert.throws(() => closeManagedWorktree(nodeId), (error) => error instanceof Error && 'code' in error && error.code === 'land_base_failed', 'close must refuse rather than overwrite an untracked base file');
-    assert.equal(readFileSync(join(sourceDir, 'incoming-collision.txt'), 'utf8'), 'base untracked work\n', 'the base untracked file remains intact');
-    assert.equal(getNode(nodeId)?.managed_worktree?.state, 'open', 'a refused land remains unreconciled');
-    assert.ok(getNode(nodeId)?.managed_worktree?.land_intent, 'the blocked close records the intent the sweep may later finish');
-    rmSync(join(sourceDir, 'incoming-collision.txt'));
-});
-test('two concurrent creates from linked worktrees serialize on their shared repository', async () => {
-    const worktreeModule = new URL('../../worktree.ts', import.meta.url).href;
-    const createFrom = (cwd, nodeId) => new Promise((resolve, reject) => {
-        const script = `import { createManagedWorktree } from ${JSON.stringify(worktreeModule)}; createManagedWorktree(${JSON.stringify(cwd)}, ${JSON.stringify(nodeId)});`;
-        const child = spawn(process.execPath, ['--import', 'tsx/esm', '--input-type=module', '--eval', script], { env: { ...process.env, CRTR_HOME: home }, stdio: 'pipe' });
-        let stderr = '';
-        child.stderr.on('data', (chunk) => { stderr += chunk; });
-        child.on('error', reject);
-        child.on('exit', (code) => code === 0 ? resolve() : reject(new Error(`concurrent create exited ${code}: ${stderr}`)));
-    });
-    const linkedCheckout = mkdtempSync(join(tmpdir(), 'crtr-worktree-linked-'));
-    rmSync(linkedCheckout, { recursive: true, force: true });
-    run(['worktree', 'add', '-b', 'wt-concurrent-source', linkedCheckout], sourceDir);
-    try {
-        await Promise.all([createFrom(sourceDir, 'wt-concurrent-1'), createFrom(linkedCheckout, 'wt-concurrent-2')]);
-        for (const nodeId of ['wt-concurrent-1', 'wt-concurrent-2']) {
-            const path = managedWorktreePath(nodeId);
-            assert.ok(existsSync(path), `${nodeId} checkout should exist`);
-            assert.equal(gitSync(['rev-parse', '--abbrev-ref', 'HEAD'], path).stdout.trim(), `crtr/${nodeId}`);
-            rollbackManagedWorktree({
-                state: 'open', path, branch: `crtr/${nodeId}`, repo_root: sourceDir, base_ref: 'main',
-                base_sha: gitSync(['rev-parse', 'main'], sourceDir).stdout.trim(), created: new Date().toISOString(),
-            });
-        }
-    }
-    finally {
-        run(['worktree', 'remove', '--force', linkedCheckout], sourceDir);
-        run(['branch', '-D', 'wt-concurrent-source'], sourceDir);
-    }
-});
-test('failure after branch creation removes only the failed attempt resources', () => {
-    // A file at the managed-worktree root makes `git worktree add` fail only
-    // after this attempt created its branch. No checkout can be registered.
-    mkdirSync(home, { recursive: true });
-    writeFileSync(join(home, 'worktrees'), 'blocked');
-    const nodeId = 'wt-failed-checkout';
-    assert.throws(() => createManagedWorktree(sourceDir, nodeId));
-    assert.equal(gitSync(['show-ref', '--verify', '--quiet', `refs/heads/crtr/${nodeId}`], sourceDir).status, 1, 'failed attempt branch must be removed');
-    assert.ok(!gitSync(['worktree', 'list', '--porcelain'], sourceDir).stdout.includes(`crtr/${nodeId}`), 'failed attempt must not leave a worktree registration');
-    assert.ok(!existsSync(managedWorktreePath(nodeId)), 'failed attempt must not leave a checkout directory');
-});
-// Landing is purely local: a commit made in the managed worktree must advance
-// the source repo's LOCAL main to that commit, and origin/main must stay put
-// (close never pushes to origin).
-test('closeManagedWorktree fast-forwards local main to the worktree tip without touching origin', () => {
-    const nodeId = 'wt-close-2';
-    const originMainBefore = gitSync(['rev-parse', 'origin/main'], sourceDir).stdout.trim();
-    const wt = createManagedWorktree(sourceDir, nodeId);
-    createNode(node(nodeId, { cwd: wt.path, managed_worktree: wt }));
-    // Commit real work inside the managed worktree.
-    writeFileSync(join(wt.path, 'feature.txt'), 'work\n');
-    run(['add', '.'], wt.path);
-    run(['-c', 'user.email=test@example.com', '-c', 'user.name=Test', 'commit', '-m', 'feature'], wt.path);
-    const workSha = gitSync(['rev-parse', 'HEAD'], wt.path).stdout.trim();
-    const result = closeManagedWorktree(nodeId);
-    assert.equal(result.landed_sha, workSha, 'landed_sha should be the committed work');
-    // Local main in the source (primary) checkout advanced to the work.
-    const localMainAfter = gitSync(['rev-parse', 'main'], sourceDir).stdout.trim();
-    assert.equal(localMainAfter, workSha, 'local main must fast-forward to the worktree tip');
-    // origin/main is untouched — nothing was pushed.
-    const originMainAfter = gitSync(['rev-parse', 'origin/main'], sourceDir).stdout.trim();
-    assert.equal(originMainAfter, originMainBefore, 'origin/main must not move — landing is local-only');
-});
-test('async close leaves an upstream-contained tip and a diverged local base byte-for-byte unchanged (#958)', async () => {
-    const repo = mkdtempSync(join(tmpdir(), 'crtr-worktree-contained-close-'));
-    const remote = mkdtempSync(join(tmpdir(), 'crtr-worktree-contained-close-remote-'));
-    try {
-        run(['init', '-b', 'main'], repo);
-        run(['config', 'user.email', 'test@example.com'], repo);
-        run(['config', 'user.name', 'Test'], repo);
-        writeFileSync(join(repo, 'README.md'), 'initial\n');
-        run(['add', '.'], repo);
-        run(['commit', '-m', 'initial'], repo);
-        run(['init', '--bare'], remote);
-        run(['remote', 'add', 'origin', remote], repo);
-        run(['push', '-u', 'origin', 'main'], repo);
-        const nodeId = 'wt-contained-diverged-base';
-        const wt = createManagedWorktree(repo, nodeId);
-        createNode(node(nodeId, { cwd: wt.path, managed_worktree: wt }));
-        writeFileSync(join(wt.path, 'delivered.txt'), 'already delivered\n');
-        run(['add', '.'], wt.path);
-        run(['commit', '-m', 'delivered work'], wt.path);
-        const deliveredHead = gitSync(['rev-parse', 'HEAD'], wt.path).stdout.trim();
-        run(['push', 'origin', `${wt.branch}:main`], wt.path);
-        run(['fetch', 'origin'], repo);
-        writeFileSync(join(repo, 'local-only.txt'), 'must not receive a replay\n');
-        run(['add', '.'], repo);
-        run(['commit', '-m', 'independent local base work'], repo);
-        const before = {
-            childHead: gitSync(['rev-parse', 'HEAD'], wt.path).stdout,
-            baseRef: gitSync(['rev-parse', 'refs/heads/main'], repo).stdout,
-            baseHead: gitSync(['rev-parse', 'HEAD'], repo).stdout,
-            status: gitSync(['status', '--porcelain=v1'], repo).stdout,
-            worktree: gitSync(['worktree', 'list', '--porcelain'], repo).stdout,
-            index: readFileSync(join(repo, '.git', 'index')),
-        };
-        const result = await closeManagedWorktreeAsync(nodeId);
-        assert.equal(result.landed_sha, deliveredHead);
-        assert.deepEqual({
-            childHead: gitSync(['rev-parse', 'HEAD'], wt.path).stdout,
-            baseRef: gitSync(['rev-parse', 'refs/heads/main'], repo).stdout,
-            baseHead: gitSync(['rev-parse', 'HEAD'], repo).stdout,
-            status: gitSync(['status', '--porcelain=v1'], repo).stdout,
-            worktree: gitSync(['worktree', 'list', '--porcelain'], repo).stdout,
-            index: readFileSync(join(repo, '.git', 'index')),
-        }, before, 'a delivered child must not rebase or move the divergent local base');
-    }
-    finally {
-        rmSync(repo, { recursive: true, force: true });
-        rmSync(remote, { recursive: true, force: true });
-    }
-});
-test('custom local base is recorded and fast-forwarded without touching main or origin', () => {
-    const nodeId = 'wt-custom-base';
-    run(['branch', 'feature/custom-base'], sourceDir);
-    const baseSha = gitSync(['rev-parse', 'feature/custom-base'], sourceDir).stdout.trim();
-    const mainBefore = gitSync(['rev-parse', 'main'], sourceDir).stdout.trim();
-    const originMainBefore = gitSync(['rev-parse', 'origin/main'], sourceDir).stdout.trim();
-    const wt = createManagedWorktree(sourceDir, nodeId, 'feature/custom-base');
-    assert.equal(wt.base_ref, 'feature/custom-base');
-    assert.equal(wt.base_sha, baseSha);
-    assert.equal(gitSync(['rev-parse', 'HEAD'], wt.path).stdout.trim(), baseSha, 'dedicated branch starts at the custom base');
-    assert.equal(gitSync(['rev-parse', '--abbrev-ref', 'HEAD'], wt.path).stdout.trim(), `crtr/${nodeId}`, 'the worktree checks out its own dedicated crtr/<node-id> branch, not the base branch');
-    createNode(node(nodeId, { cwd: wt.path, managed_worktree: wt }));
-    writeFileSync(join(wt.path, 'custom-base.txt'), 'work\n');
-    run(['add', '.'], wt.path);
-    run(['-c', 'user.email=test@example.com', '-c', 'user.name=Test', 'commit', '-m', 'custom base work'], wt.path);
-    // The base can advance while the child works. Close must rebase onto that
-    // new tip before atomically advancing the base to the child work.
-    run(['checkout', 'feature/custom-base'], sourceDir);
-    writeFileSync(join(sourceDir, 'base-advance.txt'), 'base work\n');
-    run(['add', '.'], sourceDir);
-    run(['-c', 'user.email=test@example.com', '-c', 'user.name=Test', 'commit', '-m', 'base advance'], sourceDir);
-    const advancedBaseSha = gitSync(['rev-parse', 'HEAD'], sourceDir).stdout.trim();
-    run(['checkout', 'main'], sourceDir);
-    const originalWorkSha = gitSync(['rev-parse', 'HEAD'], wt.path).stdout.trim();
-    const result = closeManagedWorktree(nodeId);
-    assert.equal(gitSync(['merge-base', '--is-ancestor', originalWorkSha, result.landed_sha], sourceDir).status, 1, 'rebasing onto an advanced base must rewrite the child commit');
-    assert.equal(gitSync(['merge-base', '--is-ancestor', advancedBaseSha, result.landed_sha], sourceDir).status, 0, 'landed work must be rebased onto the latest base tip');
-    assert.equal(gitSync(['rev-parse', 'feature/custom-base'], sourceDir).stdout.trim(), result.landed_sha, 'custom base must fast-forward to the worktree tip');
-    assert.equal(gitSync(['rev-parse', 'main'], sourceDir).stdout.trim(), mainBefore, 'main must remain untouched');
-    assert.equal(gitSync(['rev-parse', 'origin/main'], sourceDir).stdout.trim(), originMainBefore, 'origin/main must remain untouched');
-});
-test('refuses a custom-base close when its unchecked base advances after rebase', () => {
-    const nodeId = 'wt-custom-base-cas-race';
-    const base = 'feature/cas-race-base';
-    run(['branch', base], sourceDir);
-    const baseSha = gitSync(['rev-parse', base], sourceDir).stdout.trim();
-    const wt = createManagedWorktree(sourceDir, nodeId, base);
-    createNode(node(nodeId, { cwd: wt.path, managed_worktree: wt }));
-    writeFileSync(join(wt.path, 'cas-child.txt'), 'child work\n');
-    run(['add', '.'], wt.path);
-    run(['-c', 'user.email=test@example.com', '-c', 'user.name=Test', 'commit', '-m', 'cas child work'], wt.path);
-    // Pre-create the other writer's commit, then reset the base so the rebase
-    // begins from baseSha. A test-only git wrapper advances it when close calls
-    // its final update-ref CAS, immediately before the real git receives that
-    // CAS request.
-    run(['checkout', base], sourceDir);
-    writeFileSync(join(sourceDir, 'cas-base.txt'), 'base work\n');
-    run(['add', '.'], sourceDir);
-    run(['-c', 'user.email=test@example.com', '-c', 'user.name=Test', 'commit', '-m', 'cas base work'], sourceDir);
-    const advancedBaseSha = gitSync(['rev-parse', 'HEAD'], sourceDir).stdout.trim();
-    run(['checkout', 'main'], sourceDir);
-    run(['update-ref', `refs/heads/${base}`, baseSha], sourceDir);
-    const wrapperDir = mkdtempSync(join(tmpdir(), 'crtr-git-wrapper-'));
-    const wrapperPath = join(wrapperDir, 'git');
-    const originalPath = process.env['PATH'] ?? '';
-    writeFileSync(wrapperPath, `#!/bin/sh
-if [ "$1" = "update-ref" ] && [ "$2" = "refs/heads/${base}" ] && [ "$4" = "${baseSha}" ]; then
-  PATH="$CRTR_TEST_REAL_PATH" git -C "${sourceDir}" update-ref "refs/heads/${base}" "${advancedBaseSha}"
-fi
-PATH="$CRTR_TEST_REAL_PATH" exec git "$@"
-`);
-    chmodSync(wrapperPath, 0o755);
-    process.env['CRTR_TEST_REAL_PATH'] = originalPath;
-    process.env['PATH'] = `${wrapperDir}:${originalPath}`;
-    try {
-        assert.throws(() => closeManagedWorktree(nodeId), (error) => error instanceof Error && 'code' in error && error.code === 'land_base_failed');
-    }
-    finally {
-        process.env['PATH'] = originalPath;
-        delete process.env['CRTR_TEST_REAL_PATH'];
-        rmSync(wrapperDir, { recursive: true, force: true });
-    }
-    assert.equal(gitSync(['rev-parse', base], sourceDir).stdout.trim(), advancedBaseSha, 'CAS failure must preserve the concurrent base advance');
-    assert.equal(getNode(nodeId)?.managed_worktree?.state, 'open', 'failed landing must leave the worktree open for retry or human resolution');
-});
-test('rebases onto the captured SHA when an unchecked base advances before rebase starts', () => {
-    const nodeId = 'wt-custom-base-rebase-race';
-    const base = 'feature/rebase-race-base';
-    run(['branch', base], sourceDir);
-    const baseSha = gitSync(['rev-parse', base], sourceDir).stdout.trim();
-    const wt = createManagedWorktree(sourceDir, nodeId, base);
-    createNode(node(nodeId, { cwd: wt.path, managed_worktree: wt }));
-    writeFileSync(join(wt.path, 'rebase-race-child.txt'), 'child work\n');
-    run(['add', '.'], wt.path);
-    run(['-c', 'user.email=test@example.com', '-c', 'user.name=Test', 'commit', '-m', 'rebase race child work'], wt.path);
-    // Prepare another writer's commit, then move the unchecked base back to the
-    // SHA close will capture. The wrapper advances the base immediately before
-    // the real rebase starts. Close must still rebase onto its captured SHA, not
-    // resolve the now-advanced symbolic branch, and the stale landing CAS fails.
-    run(['checkout', base], sourceDir);
-    writeFileSync(join(sourceDir, 'rebase-race-base.txt'), 'base work\n');
-    run(['add', '.'], sourceDir);
-    run(['-c', 'user.email=test@example.com', '-c', 'user.name=Test', 'commit', '-m', 'rebase race base work'], sourceDir);
-    const advancedBaseSha = gitSync(['rev-parse', 'HEAD'], sourceDir).stdout.trim();
-    run(['checkout', 'main'], sourceDir);
-    run(['update-ref', `refs/heads/${base}`, baseSha], sourceDir);
-    const wrapperDir = mkdtempSync(join(tmpdir(), 'crtr-git-wrapper-'));
-    const wrapperPath = join(wrapperDir, 'git');
-    const originalPath = process.env['PATH'] ?? '';
-    writeFileSync(wrapperPath, `#!/bin/sh
-if [ "$1" = "rebase" ] && [ "$2" = "${baseSha}" ]; then
-  PATH="$CRTR_TEST_REAL_PATH" git -C "${sourceDir}" update-ref "refs/heads/${base}" "${advancedBaseSha}"
-fi
-PATH="$CRTR_TEST_REAL_PATH" exec git "$@"
-`);
-    chmodSync(wrapperPath, 0o755);
-    process.env['CRTR_TEST_REAL_PATH'] = originalPath;
-    process.env['PATH'] = `${wrapperDir}:${originalPath}`;
-    try {
-        assert.throws(() => closeManagedWorktree(nodeId), (error) => error instanceof Error && 'code' in error && error.code === 'land_base_failed');
-    }
-    finally {
-        process.env['PATH'] = originalPath;
-        delete process.env['CRTR_TEST_REAL_PATH'];
-        rmSync(wrapperDir, { recursive: true, force: true });
-    }
-    const rebasedChildSha = gitSync(['rev-parse', 'HEAD'], wt.path).stdout.trim();
-    assert.equal(gitSync(['rev-parse', base], sourceDir).stdout.trim(), advancedBaseSha, 'CAS failure must preserve the advance that raced with rebase');
-    assert.equal(gitSync(['merge-base', '--is-ancestor', advancedBaseSha, rebasedChildSha], sourceDir).status, 1, 'the child must not rebase onto a symbolic base advance after baseSha was captured');
-    assert.equal(getNode(nodeId)?.managed_worktree?.state, 'open', 'failed landing must leave the worktree open for retry or human resolution');
-});
-test('refuses to land when a checked-out base is reset after its SHA is captured', () => {
-    const nodeId = 'wt-custom-base-checked-out-reset-race';
-    const base = 'feature/checked-out-reset-race-base';
-    run(['checkout', '-b', base], sourceDir);
-    const resetSha = gitSync(['rev-parse', 'HEAD'], sourceDir).stdout.trim();
-    writeFileSync(join(sourceDir, 'checked-out-reset-base.txt'), 'base work\n');
-    run(['add', '.'], sourceDir);
-    run(['-c', 'user.email=test@example.com', '-c', 'user.name=Test', 'commit', '-m', 'checked out reset base work'], sourceDir);
-    const baseSha = gitSync(['rev-parse', 'HEAD'], sourceDir).stdout.trim();
-    const wt = createManagedWorktree(sourceDir, nodeId, base);
-    createNode(node(nodeId, { cwd: wt.path, managed_worktree: wt }));
-    writeFileSync(join(wt.path, 'checked-out-reset-child.txt'), 'child work\n');
-    run(['add', '.'], wt.path);
-    run(['-c', 'user.email=test@example.com', '-c', 'user.name=Test', 'commit', '-m', 'checked out reset child work'], wt.path);
-    // Reset the checked-out base backward immediately before the child rebases.
-    // The real rebase still targets captured baseSha, so only the explicit HEAD
-    // equality check can prevent an ff-only merge from restoring discarded work.
-    const wrapperDir = mkdtempSync(join(tmpdir(), 'crtr-git-wrapper-'));
-    const wrapperPath = join(wrapperDir, 'git');
-    const originalPath = process.env['PATH'] ?? '';
-    writeFileSync(wrapperPath, `#!/bin/sh
-if [ "$1" = "rebase" ] && [ "$2" = "${baseSha}" ]; then
-  PATH="$CRTR_TEST_REAL_PATH" git -C "${sourceDir}" reset --hard "${resetSha}"
-fi
-PATH="$CRTR_TEST_REAL_PATH" exec git "$@"
-`);
-    chmodSync(wrapperPath, 0o755);
-    process.env['CRTR_TEST_REAL_PATH'] = originalPath;
-    process.env['PATH'] = `${wrapperDir}:${originalPath}`;
-    try {
-        assert.throws(() => closeManagedWorktree(nodeId), (error) => error instanceof Error && 'code' in error && error.code === 'land_base_failed');
-    }
-    finally {
-        process.env['PATH'] = originalPath;
-        delete process.env['CRTR_TEST_REAL_PATH'];
-        rmSync(wrapperDir, { recursive: true, force: true });
-    }
-    assert.equal(gitSync(['rev-parse', 'HEAD'], sourceDir).stdout.trim(), resetSha, 'failed landing must leave the checked-out base at the concurrent reset SHA');
-    assert.equal(gitSync(['rev-parse', base], sourceDir).stdout.trim(), resetSha, 'failed landing must not restore discarded base commits');
-    assert.equal(getNode(nodeId)?.managed_worktree?.state, 'open', 'failed landing must leave the worktree open for retry or human resolution');
-    run(['checkout', 'main'], sourceDir);
-});
-test('close fast-forwards a custom base in its checked-out worktree', () => {
-    const nodeId = 'wt-custom-base-checked-out';
-    run(['checkout', '-b', 'feature/checked-out-base'], sourceDir);
-    const wt = createManagedWorktree(sourceDir, nodeId, 'feature/checked-out-base');
-    createNode(node(nodeId, { cwd: wt.path, managed_worktree: wt }));
-    writeFileSync(join(wt.path, 'checked-out-base.txt'), 'work\n');
-    run(['add', '.'], wt.path);
-    run(['-c', 'user.email=test@example.com', '-c', 'user.name=Test', 'commit', '-m', 'checked out base work'], wt.path);
-    const workSha = gitSync(['rev-parse', 'HEAD'], wt.path).stdout.trim();
-    closeManagedWorktree(nodeId);
-    assert.equal(gitSync(['rev-parse', 'feature/checked-out-base'], sourceDir).stdout.trim(), workSha);
-    assert.equal(gitSync(['rev-parse', 'HEAD'], sourceDir).stdout.trim(), workSha, 'checked-out base worktree must advance with its ref');
-    run(['checkout', 'main'], sourceDir);
-});
-test('rejects remote and nonexistent worktree bases before creating any resources', () => {
-    for (const [nodeId, base] of [['wt-remote-base', 'origin/main'], ['wt-bogus-base', 'feature/does-not-exist']]) {
-        assert.throws(() => createManagedWorktree(sourceDir, nodeId, base), (error) => error instanceof Error
-            && 'code' in error
-            && error.code === 'missing_base_branch'
-            && error.message.includes(base));
-        assert.ok(!existsSync(managedWorktreePath(nodeId)), `${base} must not leave a worktree directory`);
-        assert.equal(gitSync(['show-ref', '--verify', '--quiet', `refs/heads/crtr/${nodeId}`], sourceDir).status, 1, `${base} must not leave a dedicated branch`);
-    }
-});
-test('refuses to close a committed worktree when the recorded base was deleted', () => {
-    const nodeId = 'wt-deleted-base';
-    run(['branch', 'feature/deleted-base'], sourceDir);
-    const mainBefore = gitSync(['rev-parse', 'main'], sourceDir).stdout.trim();
-    const wt = createManagedWorktree(sourceDir, nodeId, 'feature/deleted-base');
-    createNode(node(nodeId, { cwd: wt.path, managed_worktree: wt }));
-    writeFileSync(join(wt.path, 'deleted-base.txt'), 'work\n');
-    run(['add', '.'], wt.path);
-    run(['-c', 'user.email=test@example.com', '-c', 'user.name=Test', 'commit', '-m', 'deleted base work'], wt.path);
-    run(['branch', '-D', 'feature/deleted-base'], sourceDir);
-    assert.throws(() => closeManagedWorktree(nodeId), (error) => error instanceof Error && 'code' in error && error.code === 'missing_base_branch');
-    assert.equal(getNode(nodeId)?.managed_worktree?.state, 'open', 'a missing base with committed work must remain open for a human decision');
-    assert.ok(existsSync(wt.path), 'the worktree must remain available for a human decision');
-    assert.equal(gitSync(['rev-parse', 'main'], sourceDir).stdout.trim(), mainBefore, 'missing base must never auto-land onto main');
-});
-// NL-153/NL-154: the parent can land and finish before its clean child. Its
-// checkout and branch then disappear, leaving `repo_root` as an empty path;
-// the child itself still resolves the shared repository and is exactly at its
-// recorded creation SHA, so close is a no-op with only deferred cleanup left.
-test('close concludes a clean child after parent-first closure removes its checkout and base branch', () => {
-    const repo = mkdtempSync(join(tmpdir(), 'crtr-worktree-parent-first-'));
-    try {
-        run(['init', '-b', 'main'], repo);
-        run(['config', 'user.email', 'test@example.com'], repo);
-        run(['config', 'user.name', 'Test'], repo);
-        writeFileSync(join(repo, 'README.md'), 'hello\n');
-        run(['add', '.'], repo);
-        run(['commit', '-m', 'init'], repo);
-        const parent = createManagedWorktree(repo, 'wt-parent-first-parent');
-        createNode(node('wt-parent-first-parent', { cwd: parent.path, managed_worktree: parent }));
-        // Creation now refuses a managed worktree as its base (`managed_worktree_base`),
-        // so the child is cut from the real repository against the parent's BRANCH, and
-        // its record carries the parent checkout as `repo_root` — the exact legacy shape
-        // this case is about, still on disk for every record created before that guard.
-        const child = createManagedWorktree(repo, 'wt-parent-first-child', parent.branch);
-        const childRecord = { ...child, repo_root: parent.path };
-        createNode(node('wt-parent-first-child', { cwd: child.path, managed_worktree: childRecord }));
-        assert.equal(gitSync(['rev-parse', 'HEAD'], child.path).stdout.trim(), child.base_sha, 'the child must be a clean zero-commit checkout at its recorded base');
-        closeManagedWorktree('wt-parent-first-parent');
-        run(['worktree', 'remove', parent.path], repo);
-        run(['branch', '-D', parent.branch], repo);
-        mkdirSync(parent.path, { recursive: true });
-        assert.notEqual(gitSync(['rev-parse', '--git-dir'], parent.path).status, 0, 'the recorded parent path must be an empty non-Git directory');
-        assert.equal(gitSync(['show-ref', '--verify', '--quiet', `refs/heads/${parent.branch}`], child.path).status, 1, 'the parent base branch must be gone');
-        const result = closeManagedWorktree('wt-parent-first-child');
-        assert.equal(result.landed_sha, child.base_sha, 'a no-op close reports the recorded creation SHA');
-        assert.equal(result.worktree_removed, false, 'the live caller checkout remains for deferred cleanup');
-        assert.equal(getNode('wt-parent-first-child')?.managed_worktree?.state, 'closed');
-        run(['worktree', 'remove', child.path], repo);
-        run(['branch', '-D', child.branch], repo);
-    }
-    finally {
-        rmSync(repo, { recursive: true, force: true });
-    }
-});
-// A failed ref inspection is not proof that a clean child has nothing to
-// land: only show-ref's completed absent-ref result may take that no-op path.
-test('close surfaces a failed base ref inspection instead of closing a clean worktree', () => {
-    const nodeId = 'wt-base-ref-inspection-failure';
-    const wt = createManagedWorktree(sourceDir, nodeId);
-    createNode(node(nodeId, { cwd: wt.path, managed_worktree: wt }));
-    const wrapperDir = mkdtempSync(join(tmpdir(), 'crtr-git-wrapper-'));
-    const wrapperPath = join(wrapperDir, 'git');
-    const originalPath = process.env['PATH'] ?? '';
-    writeFileSync(wrapperPath, `#!/bin/sh
-if [ "$1" = "show-ref" ] && [ "$2" = "--verify" ] && [ "$3" = "--quiet" ] && [ "$4" = "refs/heads/main" ]; then
-  echo "simulated unreadable ref store" >&2
-  exit 128
-fi
-PATH="$CRTR_TEST_REAL_PATH" exec git "$@"
-`);
-    chmodSync(wrapperPath, 0o755);
-    process.env['CRTR_TEST_REAL_PATH'] = originalPath;
-    process.env['PATH'] = `${wrapperDir}:${originalPath}`;
-    try {
-        assert.throws(() => closeManagedWorktree(nodeId), (error) => error instanceof Error
-            && 'code' in error
-            && error.code === 'base_branch_inspection_failed'
-            && 'detail' in error
-            && typeof error.detail === 'string'
-            && error.detail.includes('status: 128')
-            && error.detail.includes('stderr: simulated unreadable ref store'));
-    }
-    finally {
-        process.env['PATH'] = originalPath;
-        delete process.env['CRTR_TEST_REAL_PATH'];
-        rmSync(wrapperDir, { recursive: true, force: true });
-        run(['worktree', 'remove', wt.path], sourceDir);
-        run(['branch', '-D', wt.branch], sourceDir);
-    }
-    assert.equal(getNode(nodeId)?.managed_worktree?.state, 'open', 'the failed inspection must not mark a clean worktree closed');
-    assert.ok(!existsSync(wt.path), 'the test must clean up its temporary checkout');
-});
-// Regression for #330/#331: crtr's own untracked `.crouter/config.json` /
-// `state.json` bookkeeping (written by ordinary project-scope init) must
-// never block `close`'s dirty check — Fix A seeds `.git/info/exclude` for
-// exactly those two filenames at worktree-creation time.
-test('close ignores crtr\'s own untracked .crouter/config.json and state.json bookkeeping', () => {
-    const nodeId = 'wt-crtr-bookkeeping';
-    const wt = createManagedWorktree(sourceDir, nodeId);
-    createNode(node(nodeId, { cwd: wt.path, managed_worktree: wt }));
-    mkdirSync(join(wt.path, '.crouter'), { recursive: true });
-    writeFileSync(join(wt.path, '.crouter', 'config.json'), '{}\n');
-    writeFileSync(join(wt.path, '.crouter', 'state.json'), '{}\n');
-    // The seeded exclude is on the SHARED common git dir — assert git itself
-    // reports a clean tree, not just that close happens not to notice.
-    assert.equal(gitSync(['status', '--porcelain'], wt.path).stdout.trim(), '', 'git status must already be clean with only crtr bookkeeping present');
-    const result = closeManagedWorktree(nodeId);
-    assert.equal(result.worktree_removed, false);
-    assert.match(result.worktree_remove_error ?? '', /cleanup pending/);
-});
-// The exclude must be narrow: it must NEVER hide real, committable node work
-// that merely happens to live under `.crouter/` — this mirrors crouter's OWN
-// repo, which tracks `.crouter/memory/`. Set up a dedicated repo (not the
-// shared sourceDir, which never tracks `.crouter/`) that already tracks a
-// memory doc, then prove BOTH a modification to it and a brand-new untracked
-// doc beside it still block close exactly as before Fix A.
-test('close still blocks on real .crouter/memory/ work — a tracked-file edit and a new untracked doc', () => {
-    const memoryRepo = mkdtempSync(join(tmpdir(), 'crtr-worktree-memoryrepo-'));
-    run(['init', '-b', 'main'], memoryRepo);
-    run(['config', 'user.email', 'test@example.com'], memoryRepo);
-    run(['config', 'user.name', 'Test'], memoryRepo);
-    mkdirSync(join(memoryRepo, '.crouter', 'memory'), { recursive: true });
-    writeFileSync(join(memoryRepo, '.crouter', 'memory', 'tracked.md'), 'tracked memory doc\n');
-    run(['add', '.'], memoryRepo);
-    run(['commit', '-m', 'init with tracked memory'], memoryRepo);
-    const editNodeId = 'wt-real-crouter-memory-edit';
-    const editWt = createManagedWorktree(memoryRepo, editNodeId);
-    createNode(node(editNodeId, { cwd: editWt.path, managed_worktree: editWt }));
-    writeFileSync(join(editWt.path, '.crouter', 'memory', 'tracked.md'), 'edited tracked memory doc\n');
-    const editStatus = gitSync(['status', '--porcelain'], editWt.path).stdout;
-    assert.ok(editStatus.includes('M .crouter/memory/tracked.md'), 'a tracked .crouter/memory/ edit must still show as modified — exclude can never hide a tracked-file change');
-    assert.throws(() => closeManagedWorktree(editNodeId), (error) => error instanceof Error && 'code' in error && error.code === 'dirty_worktree');
-    const newDocNodeId = 'wt-real-crouter-memory-new-doc';
-    const newDocWt = createManagedWorktree(memoryRepo, newDocNodeId);
-    createNode(node(newDocNodeId, { cwd: newDocWt.path, managed_worktree: newDocWt }));
-    writeFileSync(join(newDocWt.path, '.crouter', 'memory', 'new-doc.md'), 'a legitimate new memory doc\n');
-    const newDocStatus = gitSync(['status', '--porcelain'], newDocWt.path).stdout;
-    assert.ok(newDocStatus.includes('.crouter/memory/new-doc.md'), 'a brand-new untracked doc under an already-tracked .crouter/memory/ must still show as dirty');
-    assert.throws(() => closeManagedWorktree(newDocNodeId), (error) => error instanceof Error && 'code' in error && error.code === 'dirty_worktree');
-    rmSync(memoryRepo, { recursive: true, force: true });
-});

package/dist/core/__tests__/integration/worktree-reap.test.d.ts

@@ -1 +0,0 @@
-export {};