@north-light/crouter 0.3.309 → 0.3.310

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

@@ -11,6 +11,7 @@ import { join } from 'node:path';
 import { gitSync } from '../../git.js';
 import { withExclusiveDirectoryLockAsync } from '../../exclusive-lock.js';
 import { createManagedWorktree, closeManagedWorktree, worktreeLockPathForCommonDir } from '../../worktree.js';
+import { abandonManagedWorktreeAsync } from '../../worktree-mutation-async.js';
 import { reconcileManagedWorktree } from '../../worktree-sweep.js';
 import { createApiServer } from '../../../daemon/api/server.js';
 import { ManagedWorktreeSweepReconciler } from '../../../daemon/reconcilers/managed-worktree-sweep.js';
@@ -476,6 +477,36 @@ test('async close yields while an async repository holder runs, keeping API requ
         await server.close();
     }
 });
+test('async abandon retains clean committed work after its base branch is deleted without a remote (#929)', async () => {
+    const repo = mkdtempSync(join(tmpdir(), 'crtr-worktree-929-'));
+    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 nodeId = 'wt-abandon-missing-base';
+        const wt = createManagedWorktree(repo, nodeId);
+        createNode(node(nodeId, { cwd: wt.path, status: 'done', managed_worktree: wt }));
+        writeFileSync(join(wt.path, 'committed.txt'), 'committed work\n');
+        run(['add', 'committed.txt'], wt.path);
+        run(['commit', '-m', 'real work'], wt.path);
+        const tipSha = gitSync(['rev-parse', 'HEAD'], wt.path).stdout.trim();
+        assert.equal(gitSync(['remote'], repo).stdout.trim(), '', 'the repository has no remote that could prove delivery');
+        run(['checkout', '--detach'], repo);
+        run(['branch', '-D', 'main'], repo);
+        const result = await abandonManagedWorktreeAsync(nodeId, 'test-invoker');
+        assert.equal(result.branch_deleted, false, 'without containment proof the committed branch must be retained');
+        assert.equal(result.tip_sha, tipSha, 'abandon must retain the exact committed tip');
+        assert.equal(existsSync(wt.path), false, 'abandon removes only the checkout');
+        assert.equal(gitSync(['rev-parse', wt.branch], repo).stdout.trim(), tipSha, 'the retained branch still reaches the committed work');
+        assert.equal(getNode(nodeId)?.managed_worktree?.state, 'abandoned', 'the node records the abandoned disposition');
+    }
+    finally {
+        rmSync(repo, { recursive: true, force: true });
+    }
+});
 test('abandon preserves committed and dirty work, records its retained tip, and releases finalization', async () => {
     const nodeId = 'wt-abandon';
     const wt = createManagedWorktree(sourceDir, nodeId);

package/dist/core/worktree-mutation-async.js

@@ -247,9 +247,8 @@ export async function abandonManagedWorktreeAsync(nodeId, by) {
                 cleanBase = base;
         }
         catch (error) {
-            if (!(error instanceof WorktreeError) || error.code !== 'missing_base_branch' || head !== current.base_sha)
+            if (!(error instanceof WorktreeError) || error.code !== 'missing_base_branch')
                 throw error;
-            cleanBase = current.base_sha;
         }
         const at = new Date().toISOString();
         const status = await runGit(current.path, ['status', '--porcelain'], 'status_failed', 'Inspect the worktree manually, then retry.');

package/dist/core/worktree.d.ts

@@ -76,7 +76,6 @@ export interface AbandonManagedWorktreeResult {
     worktree_path: string;
     branch_deleted: boolean;
 }
-export declare function abandonManagedWorktree(nodeId: string, by: string): AbandonManagedWorktreeResult;
 /** Recovery guidance for a vanished checkout whose refs do not prove that its
  * work is delivered. This deliberately never recommends `worktree close`:
  * that command cannot operate on the absent checkout. */

package/dist/core/worktree.js

@@ -3,7 +3,6 @@ import { createHash } from 'node:crypto';
 import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { gitAsync, gitSync } from './git.js';
 import { crtrHome } from './canvas/paths.js';
-import { isPidAlive } from './canvas/pid.js';
 import { getNode, updateNode } from './canvas/index.js';
 import { CONFIG_FILE, CRTR_DIR_NAME, STATE_FILE } from '../types.js';
 import { withExclusiveDirectoryLock } from './exclusive-lock.js';
@@ -658,118 +657,6 @@ export function closeManagedWorktree(nodeId) {
     // the child checkout instead of the parent that created it.
     return withRepositoryWorktreeLock(existsSync(wt.path) ? wt.path : wt.repo_root, () => closeManagedWorktreeLocked(nodeId));
 }
-const ABANDON_AUTHOR_NAME = 'crtr-abandon';
-const ABANDON_AUTHOR_EMAIL = 'crtr-abandon@localhost';
-const ABANDON_SUBJECT = 'crtr-abandon';
-function persistAbandonedWorktreeState(nodeId, wt, tipSha, at, by, branch = wt.branch) {
-    updateNode(nodeId, {
-        cwd: wt.repo_root,
-        managed_worktree: {
-            ...wt,
-            state: 'abandoned',
-            abandoned: { branch, tip_sha: tipSha, at, by },
-        },
-    });
-}
-/** The disposal path for `abandon` when the recorded `crtr/*` branch is gone:
- *  ordinary PR work moved this checkout onto a real branch. Abandon never
- *  lands that branch and — unlike the ordinary path above — never invents a
- *  commit on it: a synthetic `crtr-abandon` marker on someone's real PR
- *  branch is not a trade this code may make on their behalf. So this
- *  requires the checkout already clean and not mid-operation, then removes
- *  only the checkout and preserves the actual branch and its commits exactly
- *  as they stand. The caller already confirmed the node is not running. */
-function abandonBranchMovedWorktree(nodeId, wt, actualBranch, by) {
-    if (isRebaseInProgress(wt.path)) {
-        throw new WorktreeError('rebase_in_progress', 'this managed worktree is mid-rebase', `Resolve conflicts in ${wt.path}, run \`git rebase --continue\` there, then rerun \`crtr node worktree abandon\`.`);
-    }
-    const dirty = statusPorcelain(wt.path);
-    if (dirty !== '') {
-        throw new WorktreeError('dirty_worktree', 'managed worktree has uncommitted changes', `The recorded branch ${wt.branch} no longer exists; its checkout is now on ${actualBranch} with uncommitted changes crtr will not commit on your behalf. Commit or stash them in ${wt.path}, then rerun \`crtr node worktree abandon\`.`);
-    }
-    if (registeredWorktree(wt.repo_root, wt.path, actualBranch) !== true) {
-        throw new WorktreeError('wrong_branch', `managed worktree's recorded branch ${wt.branch} no longer exists, and its checkout at ${wt.path} is not registered to ${actualBranch} either`, `Inspect ${wt.path} and its git worktree registration, then ask the user with \`crtr human send\` if you are unsure how to proceed.`);
-    }
-    const actualSha = runGit(wt.path, ['rev-parse', 'HEAD'], 'abandon_tip_failed', 'Inspect the worktree manually, then retry.');
-    // Recheck identity immediately before the destructive step.
-    if (registeredWorktree(wt.repo_root, wt.path, actualBranch) !== true || currentBranch(wt.path) !== actualBranch) {
-        throw new WorktreeError('wrong_branch', `managed worktree at ${wt.path} changed while abandoning`, `Inspect ${wt.path}, then rerun \`crtr node worktree abandon\`.`);
-    }
-    runGit(wt.repo_root, ['worktree', 'remove', wt.path], 'worktree_remove_failed', 'Inspect the worktree manually, then retry.');
-    const at = new Date().toISOString();
-    persistAbandonedWorktreeState(nodeId, wt, actualSha, at, by, actualBranch);
-    return { node_id: nodeId, branch: actualBranch, tip_sha: actualSha, worktree_path: wt.path, branch_deleted: false };
-}
-function createAbandonMarker(wt, parentSha, nodeId, at) {
-    const treeSha = runGit(wt.repo_root, ['rev-parse', `${parentSha}^{tree}`], 'abandon_tree_failed', 'Inspect the branch manually, then retry.');
-    const markerSha = runGit(wt.repo_root, ['-c', `user.name=${ABANDON_AUTHOR_NAME}`, '-c', `user.email=${ABANDON_AUTHOR_EMAIL}`, 'commit-tree', treeSha, '-p', parentSha, '-m', ABANDON_SUBJECT, '-m', `Crtr-Abandon: ${nodeId} ${at}`], 'abandon_commit_failed', 'Inspect the branch manually, then retry.');
-    runGit(wt.repo_root, ['update-ref', `refs/heads/${wt.branch}`, markerSha, parentSha], 'abandon_marker_failed', 'The branch changed while abandon was starting; inspect the worktree, then retry.');
-    return markerSha;
-}
-function abandonManagedWorktreeLocked(nodeId, by) {
-    const node = getNode(nodeId);
-    if (node === null) {
-        throw new WorktreeError('unknown_node', `unknown node: ${nodeId}`, 'Pass a real node id.');
-    }
-    const wt = openManagedWorktreeForNode(nodeId);
-    if (wt === null) {
-        const { message, next } = noManagedWorktreeMessage(nodeId, 'abandon');
-        throw new WorktreeError('no_managed_worktree', message, next);
-    }
-    if (node.status === 'active' || node.status === 'idle' || isPidAlive(node.pi_pid)) {
-        throw new WorktreeError('node_running', `node ${nodeId} is still running`, 'Stop the node before abandoning its managed worktree.');
-    }
-    if (!existsSync(wt.path)) {
-        throw new WorktreeError('worktree_missing', `managed worktree path is missing: ${wt.path}`, missingWorktreeRecoveryHint(wt));
-    }
-    const actualBranch = currentBranch(wt.path);
-    if (actualBranch !== wt.branch) {
-        const recordedRefExists = recordedBranchExists(wt.path, wt.branch);
-        if (recordedRefExists || actualBranch === 'HEAD') {
-            throw new WorktreeError('wrong_branch', `managed worktree is not on its recorded branch (expected ${wt.branch}${actualBranch === 'HEAD' ? ', found detached HEAD' : ''})`, recordedRefExists
-                ? `Check out ${wt.branch} in ${wt.path}, then rerun \`crtr node worktree abandon\`.`
-                : `The recorded branch ${wt.branch} no longer exists, and ${wt.path} is in detached HEAD, so there is no branch to preserve. Check out or create a branch there, then rerun \`crtr node worktree abandon\`.`);
-        }
-        // The recorded crtr/* branch is gone: ordinary PR work moved this checkout
-        // onto a real branch.
-        return abandonBranchMovedWorktree(nodeId, wt, actualBranch, by);
-    }
-    const at = new Date().toISOString();
-    const clean = proveCleanEmptyManagedWorktree(wt);
-    if (clean !== null && clean.branchSha === wt.base_sha) {
-        const markerSha = createAbandonMarker(wt, clean.branchSha, nodeId, at);
-        runGit(wt.repo_root, ['worktree', 'remove', wt.path], 'worktree_remove_failed', 'Inspect the worktree manually, then retry.');
-        const deleted = bestEffortDeleteBranchWithContainmentProof(wt, markerSha, `refs/heads/${wt.base_ref}`, clean.baseSha);
-        if (deleted.branchDeleted) {
-            persistClosedWorktreeState(nodeId, wt, 'complete');
-            return { node_id: nodeId, branch: wt.branch, tip_sha: markerSha, worktree_path: wt.path, branch_deleted: true };
-        }
-        const tipSha = runGit(wt.repo_root, ['rev-parse', `refs/heads/${wt.branch}`], 'abandon_tip_failed', 'Inspect the branch manually, then retry.');
-        persistAbandonedWorktreeState(nodeId, wt, tipSha, at, by);
-        return { node_id: nodeId, branch: wt.branch, tip_sha: tipSha, worktree_path: wt.path, branch_deleted: false };
-    }
-    // A clean branch with committed work already has its complete history. The
-    // abandon record supplies the disposition; an empty provenance commit would
-    // only move the local branch away from an already-pushed tip.
-    if (!isRebaseInProgress(wt.path) && statusPorcelain(wt.path) === '') {
-        runGit(wt.repo_root, ['worktree', 'remove', wt.path], 'worktree_remove_failed', 'Inspect the worktree manually, then retry.');
-        const tipSha = runGit(wt.repo_root, ['rev-parse', `refs/heads/${wt.branch}`], 'abandon_tip_failed', 'Inspect the branch manually, then retry.');
-        persistAbandonedWorktreeState(nodeId, wt, tipSha, at, by);
-        return { node_id: nodeId, branch: wt.branch, tip_sha: tipSha, worktree_path: wt.path, branch_deleted: false };
-    }
-    runGit(wt.path, ['add', '--all'], 'abandon_stage_failed', 'Inspect the worktree manually, then retry.');
-    runGit(wt.path, ['-c', `user.name=${ABANDON_AUTHOR_NAME}`, '-c', `user.email=${ABANDON_AUTHOR_EMAIL}`, 'commit', '--allow-empty', '-m', ABANDON_SUBJECT, '-m', `Crtr-Abandon: ${nodeId} ${at}`], 'abandon_commit_failed', 'Inspect the worktree manually, then retry.');
-    runGit(wt.repo_root, ['worktree', 'remove', wt.path], 'worktree_remove_failed', 'Inspect the worktree manually, then retry.');
-    const tipSha = runGit(wt.repo_root, ['rev-parse', `refs/heads/${wt.branch}`], 'abandon_tip_failed', 'Inspect the branch manually, then retry.');
-    persistAbandonedWorktreeState(nodeId, wt, tipSha, at, by);
-    return { node_id: nodeId, branch: wt.branch, tip_sha: tipSha, worktree_path: wt.path, branch_deleted: false };
-}
-export function abandonManagedWorktree(nodeId, by) {
-    const wt = openManagedWorktreeForNode(nodeId);
-    if (wt === null)
-        return abandonManagedWorktreeLocked(nodeId, by);
-    return withRepositoryWorktreeLock(wt.repo_root, () => abandonManagedWorktreeLocked(nodeId, by));
-}
 // Push-final auto-drop of a clean, zero-commit managed worktree
 /** Delete a source branch only while the ref that proved it already delivered
  *  is still at the exact inspected SHA. `containingRef` can be the recorded

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.309",
+  "version": "0.3.310",
   "description": "crtr — agent runtime with memory, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",

package/runtime.lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.309",
+  "version": "0.3.310",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.309",
+      "version": "0.3.310",
       "hasInstallScript": true,
       "license": "MIT",
       "workspaces": [
@@ -5206,17 +5206,17 @@
     },
     "packages/crouter-api": {
       "name": "@north-light/crouter-api",
-      "version": "0.3.309",
+      "version": "0.3.310",
       "license": "UNLICENSED"
     },
     "packages/crouter-env-docker": {
       "name": "@north-light/crouter-env-docker",
-      "version": "0.3.309",
+      "version": "0.3.310",
       "license": "UNLICENSED"
     },
     "packages/crouter-sdk": {
       "name": "@north-light/crouter-sdk",
-      "version": "0.3.309",
+      "version": "0.3.310",
       "license": "UNLICENSED",
       "dependencies": {
         "@north-light/crouter-api": "^0.3.295"