@lumpcode/core 0.0.15 → 0.1.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { exec, spawn } from 'node:child_process';
+import { execFile, exec, spawn } from 'node:child_process';
 import { promisify } from 'node:util';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
@@ -3403,6 +3403,152 @@ function parseGitLogHashSubjectLines(stdout) {
     });
 }
 
+/** Node-style `code` from a caught unknown error (e.g. `ENOENT`), or undefined. */
+function nodeErrnoCode(error) {
+    if (error && typeof error === 'object' && 'code' in error) {
+        const code = error.code;
+        return typeof code === 'string' ? code : undefined;
+    }
+    return undefined;
+}
+
+/** Returns whether a process id is still running (signal 0 probe). */
+function isProcessAlive(pid, options) {
+    const onProbeError = options?.onProbeError ?? 'throw';
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (nodeErrnoCode(error) === 'ESRCH')
+            return false;
+        if (onProbeError === 'throw')
+            throw error;
+        return onProbeError === 'alive';
+    }
+}
+
+const execFileAsync = promisify(execFile);
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function listUnixProcessTreePids(rootPid) {
+    const { stdout } = await execFileAsync('ps', ['-eo', 'pid=,ppid=']);
+    const childrenByParent = new Map();
+    for (const line of stdout.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const parts = trimmed.split(/\s+/);
+        if (parts.length < 2)
+            continue;
+        const pid = Number.parseInt(parts[0] ?? '', 10);
+        const ppid = Number.parseInt(parts[1] ?? '', 10);
+        if (Number.isNaN(pid) || Number.isNaN(ppid))
+            continue;
+        const siblings = childrenByParent.get(ppid) ?? [];
+        siblings.push(pid);
+        childrenByParent.set(ppid, siblings);
+    }
+    const ordered = [];
+    const queue = [rootPid];
+    while (queue.length > 0) {
+        const pid = queue.shift();
+        if (pid === undefined)
+            break;
+        ordered.push(pid);
+        const children = childrenByParent.get(pid) ?? [];
+        for (const childPid of children) {
+            queue.push(childPid);
+        }
+    }
+    return ordered;
+}
+function killPid(pid, signal) {
+    try {
+        process.kill(pid, signal);
+    }
+    catch (error) {
+        const code = nodeErrnoCode(error);
+        if (code !== 'ESRCH') {
+            throw error;
+        }
+    }
+}
+async function killUnixProcessTreeImmediate(rootPid) {
+    const pids = await listUnixProcessTreePids(rootPid);
+    for (let index = pids.length - 1; index >= 0; index -= 1) {
+        killPid(pids[index], 'SIGKILL');
+    }
+}
+async function killUnixProcessTreeWithGrace(rootPid, graceMs) {
+    const pids = await listUnixProcessTreePids(rootPid);
+    for (let index = pids.length - 1; index >= 0; index -= 1) {
+        killPid(pids[index], 'SIGTERM');
+    }
+    const deadline = Date.now() + graceMs;
+    while (Date.now() < deadline) {
+        const anyAlive = pids.some((pid) => isProcessAlive(pid, { onProbeError: 'dead' }));
+        if (!anyAlive) {
+            return;
+        }
+        await sleep(25);
+    }
+    const remaining = await listUnixProcessTreePids(rootPid);
+    for (let index = remaining.length - 1; index >= 0; index -= 1) {
+        killPid(remaining[index], 'SIGKILL');
+    }
+}
+async function killWindowsProcessTree(rootPid) {
+    try {
+        await execFileAsync('taskkill', ['/PID', String(rootPid), '/T', '/F'], {
+            windowsHide: true,
+        });
+    }
+    catch (error) {
+        const stderr = error && typeof error === 'object' && 'stderr' in error
+            ? String(error.stderr ?? '')
+            : '';
+        const message = error instanceof Error ? error.message : String(error);
+        const combined = `${message}\n${stderr}`;
+        if (/not found|no running instance|ne existe pas|introuvable/i.test(combined)) {
+            return;
+        }
+        // taskkill can fail to terminate some descendants while the root exits (SEA/agent trees).
+        if (!isProcessAlive(rootPid)) {
+            return;
+        }
+        throw error;
+    }
+}
+/**
+ * Kill a process and its descendants.
+ * `graceMs` default 0 → immediate SIGKILL / taskkill /T /F.
+ * When `graceMs > 0` (Unix), SIGTERM first, then SIGKILL after the grace window.
+ */
+async function killProcessTree(input) {
+    const { pid, graceMs = 0 } = input;
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return failure(`Invalid pid: ${pid}`);
+    }
+    try {
+        if (process.platform === 'win32') {
+            await killWindowsProcessTree(pid);
+        }
+        else if (graceMs > 0) {
+            await killUnixProcessTreeWithGrace(pid, graceMs);
+        }
+        else {
+            await killUnixProcessTreeImmediate(pid);
+        }
+        return success(undefined);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return failure(`Could not kill process tree for pid ${pid}: ${message}`);
+    }
+}
+
 const execAsyncBase = promisify(exec);
 async function execAsync(command, options) {
     const { stdout, stderr, hasErrored } = await execAsyncBase(command, { cwd: options?.cwd })
@@ -3432,38 +3578,86 @@ async function execAsync(command, options) {
     });
 }
 
-function execBinary(binaryPath, args, timeoutMillis = 1000 * 60 * 10, options) {
+function execBinary(input) {
+    const { binaryPath, args, timeoutMillis = 1000 * 60 * 10, cwd, env, stdio, signal, killGraceMs = 5000, } = input;
     return new Promise((resolve) => {
         let settled = false;
+        let canceling = false;
+        let child;
+        let stdout = '';
+        let stderr = '';
+        let timeout;
         const finish = (result) => {
             if (settled)
                 return;
             settled = true;
-            clearTimeout(timeout);
+            if (timeout !== undefined)
+                clearTimeout(timeout);
+            if (signal) {
+                signal.removeEventListener('abort', onAbort);
+            }
             resolve(result);
         };
-        const timeout = setTimeout(() => {
+        const cancelWith = async (reason, message) => {
+            if (settled || canceling)
+                return;
+            canceling = true;
+            const pid = child?.pid;
+            if (pid != null) {
+                await killProcessTree({ pid, graceMs: killGraceMs });
+            }
             finish(failure({
-                message: `Process timed out after ${timeoutMillis} milliseconds`,
+                message,
                 binaryPath,
                 args,
+                stdout,
+                stderr,
+                reason,
             }));
-        }, timeoutMillis);
+        };
+        const onAbort = () => {
+            void cancelWith('aborted', 'Process aborted');
+        };
+        if (signal?.aborted) {
+            void cancelWith('aborted', 'Process aborted');
+            return;
+        }
+        if (signal) {
+            signal.addEventListener('abort', onAbort, { once: true });
+        }
         const { executable: resolvedExecutable, args: resolvedArgs } = resolveSpawnExecutable(binaryPath, args);
-        const child = spawn(resolvedExecutable, resolvedArgs, options || {});
-        let stdout = '', stderr = '';
+        const spawnOptions = {
+            ...(cwd !== undefined ? { cwd } : {}),
+            ...(env !== undefined ? { env } : {}),
+            ...(stdio !== undefined ? { stdio } : {}),
+        };
+        child = spawn(resolvedExecutable, resolvedArgs, spawnOptions);
+        // Start the timeout only after the OS has spawned the process so
+        // timeoutMillis measures command runtime, not spawn/setup overhead.
+        child.on('spawn', () => {
+            if (settled || canceling)
+                return;
+            timeout = setTimeout(() => {
+                void cancelWith('timeout', `Process timed out after ${timeoutMillis} milliseconds`);
+            }, timeoutMillis);
+        });
         child.stdout?.on('data', (data) => { stdout += data; });
         child.stderr?.on('data', (data) => { stderr += data; });
         child.on('error', (err) => {
+            if (settled || canceling)
+                return;
             finish(failure({
                 message: err.message,
                 binaryPath,
                 args,
                 stdout,
                 stderr,
+                reason: 'spawn',
             }));
         });
         child.on('close', (code) => {
+            if (settled || canceling)
+                return;
             if (code === 0) {
                 finish(success({ stdout, stderr }));
                 return;
@@ -3475,6 +3669,7 @@ function execBinary(binaryPath, args, timeoutMillis = 1000 * 60 * 10, options) {
                 code: code ?? undefined,
                 stdout,
                 stderr,
+                reason: 'exit',
             }));
         });
     });
@@ -3550,7 +3745,28 @@ async function collectStepsForContext(params) {
     return collectedSteps;
 }
 
-async function executeStepsForContextList({ baseBranch, branchFn, lumpVariables, contextList, gitAddCommandFn, gitCommitCommandFn, gitPushCommandFn, gitCommitMessageFn, projectRoot, steps, setupFn, setupWorkspaceFn, teardownFn, teardownWorkspaceFn, getKeepHistoryFilePathFn, logger: loggerInput, }) {
+async function runOptionalGitCommand(input) {
+    const { label, getCommand, cwd, logger } = input;
+    try {
+        const command = await getCommand();
+        if (command == null || command === '') {
+            return 'ok';
+        }
+        const result = await execAsync(command, { cwd });
+        logger.verbose(`${label} ${JSON.stringify(result)}`);
+        if (!result.success) {
+            logger.error(formatExecFailureMessage({ label, failure: result }));
+            return 'failed';
+        }
+        return 'ok';
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error(`Failed to run ${label}: ${message}`);
+        return 'failed';
+    }
+}
+async function executeStepsForContextList({ baseBranch, branchFn, lumpVariables, contextList, gitAddCommandFn, gitCommitCommandFn, gitPushCommandFn, gitCommitMessageFn, projectRoot, steps, setupFn, setupWorkspaceFn, teardownFn, teardownWorkspaceFn, getKeepHistoryFilePathFn, logger: loggerInput, signal, }) {
     const logger = loggerInput ?? createConsoleLogger({});
     const contextNames = contextList.map(context => context.name);
     logger.verbose(`contextNames ${JSON.stringify(contextNames)}`);
@@ -3585,180 +3801,232 @@ async function executeStepsForContextList({ baseBranch, branchFn, lumpVariables,
     const gitStatusCommand = await execAsync(`git status`, { cwd: workspacePath });
     logger.verbose(`gitStatusCommand ${JSON.stringify(gitStatusCommand.data)}`);
     injectedGitAndWorkspaceFnsInput.workspacePath = workspacePath;
-    for (let i = 0; i < contextList.length; i++) {
-        const context = contextList[i];
-        logger.info(contextList.length > 1
-            ? `Running context "${context.name}" (${i + 1}/${contextList.length})`
-            : `Running context "${context.name}"`);
-        const setupResult = await setupFn({
-            contextList,
-            lumpVariables,
-            currentContextIndex: i,
-        });
-        const contextRunState = setupResult?.contextRunState || {};
-        let stepWalkFailure;
-        async function walkAndExecuteSteps(stepsToExec, currStepIndex) {
-            for (let stepIndex = 0; stepIndex < stepsToExec.length; stepIndex++) {
-                if (stepWalkFailure) {
-                    return;
-                }
-                const step = stepsToExec[stepIndex];
-                const nextCallHeadIndex = [...currStepIndex, stepIndex];
-                const compositeStepIndex = nextCallHeadIndex.length === 1 ? nextCallHeadIndex[0] : nextCallHeadIndex;
-                if (typeof step === 'function' || Array.isArray(step)) {
-                    let subSteps = [];
-                    if (typeof step === 'function') {
-                        subSteps = await step({
+    let runFailure;
+    try {
+        for (let i = 0; i < contextList.length; i++) {
+            const context = contextList[i];
+            logger.info(contextList.length > 1
+                ? `Running context "${context.name}" (${i + 1}/${contextList.length})`
+                : `Running context "${context.name}"`);
+            const setupResult = await setupFn({
+                contextList,
+                lumpVariables,
+                currentContextIndex: i,
+            });
+            const contextRunState = setupResult?.contextRunState || {};
+            let stepWalkFailure;
+            async function walkAndExecuteSteps(stepsToExec, currStepIndex) {
+                for (let stepIndex = 0; stepIndex < stepsToExec.length; stepIndex++) {
+                    if (stepWalkFailure) {
+                        return;
+                    }
+                    const step = stepsToExec[stepIndex];
+                    const nextCallHeadIndex = [...currStepIndex, stepIndex];
+                    const compositeStepIndex = nextCallHeadIndex.length === 1 ? nextCallHeadIndex[0] : nextCallHeadIndex;
+                    if (typeof step === 'function' || Array.isArray(step)) {
+                        let subSteps = [];
+                        if (typeof step === 'function') {
+                            subSteps = await step({
+                                context,
+                                stepIndex: compositeStepIndex,
+                                contextRunState,
+                                lumpVariables,
+                            });
+                        }
+                        else {
+                            subSteps = step;
+                        }
+                        await walkAndExecuteSteps(subSteps, nextCallHeadIndex);
+                        continue;
+                    }
+                    logger.verbose(`step ${JSON.stringify(step)}`);
+                    const { commandFn = () => null, stepVariables, promptFn, postCommandExecFn, continueOnError, timeoutMillis = 1000 * 60 * 30, } = step;
+                    const prompt = promptFn
+                        ? await promptFn({
                             context,
                             stepIndex: compositeStepIndex,
                             contextRunState,
                             lumpVariables,
-                        });
-                    }
-                    else {
-                        subSteps = step;
-                    }
-                    await walkAndExecuteSteps(subSteps, nextCallHeadIndex);
-                    continue;
-                }
-                logger.verbose(`step ${JSON.stringify(step)}`);
-                const { commandFn = () => null, stepVariables, promptFn, postCommandExecFn, continueOnError, timeoutMillis = 1000 * 60 * 30, } = step;
-                const prompt = promptFn
-                    ? await promptFn({
+                            stepVariables,
+                        })
+                        : '';
+                    const command = await commandFn({
                         context,
+                        prompt,
                         stepIndex: compositeStepIndex,
                         contextRunState,
                         lumpVariables,
                         stepVariables,
-                    })
-                    : '';
-                const command = await commandFn({
-                    context,
-                    prompt,
-                    stepIndex: compositeStepIndex,
-                    contextRunState,
-                    lumpVariables,
-                    stepVariables,
-                    projectRoot,
-                    workspacePath,
-                });
-                let commandResult = '';
-                let commandSucceeded = true;
-                if (command != null) {
-                    const { executable, args, env } = command;
-                    logger.verbose(`command for prompt ${executable} ${args.join(' ')}`);
-                    if (env != null) {
-                        logger.verbose(`command env overrides ${JSON.stringify(env)}`);
-                    }
-                    logger.verbose(`workspacePath ${workspacePath}`);
-                    const commandExec = await execBinary(executable, args, timeoutMillis, {
-                        stdio: ['inherit', 'pipe', 'pipe'],
-                        cwd: workspacePath,
-                        ...(env != null ? { env: { ...process.env, ...env } } : {}),
+                        projectRoot,
+                        workspacePath,
                     });
-                    logger.verbose(`commandExec ${JSON.stringify(commandExec)}`);
-                    if (!commandExec.success) {
-                        if (!continueOnError) {
-                            stepWalkFailure = set(commandExec, ['data', 'message'], `Failed to run the command: ${commandExec.data.message}. Command: ${executable} ${args.join(' ')}`);
-                            return;
+                    let commandResult = '';
+                    let commandSucceeded = true;
+                    if (command != null) {
+                        const { executable, args, env } = command;
+                        logger.verbose(`command for prompt ${executable} ${args.join(' ')}`);
+                        if (env != null) {
+                            logger.verbose(`command env overrides ${JSON.stringify(env)}`);
+                        }
+                        logger.verbose(`workspacePath ${workspacePath}`);
+                        const commandExec = await execBinary({
+                            binaryPath: executable,
+                            args,
+                            timeoutMillis,
+                            stdio: ['inherit', 'pipe', 'pipe'],
+                            cwd: workspacePath,
+                            signal,
+                            ...(env != null ? { env: { ...process.env, ...env } } : {}),
+                        });
+                        logger.verbose(`commandExec ${JSON.stringify(commandExec)}`);
+                        if (!commandExec.success) {
+                            const aborted = commandExec.data.reason === 'aborted';
+                            if (aborted || !continueOnError) {
+                                stepWalkFailure = {
+                                    success: false,
+                                    data: {
+                                        message: `Failed to run the command: ${commandExec.data.message}. Command: ${executable} ${args.join(' ')}`,
+                                        reason: 'stepWalkFailed',
+                                    },
+                                };
+                                return;
+                            }
+                            commandSucceeded = false;
+                            commandResult = (commandExec.data.stdout
+                                || commandExec.data.stderr
+                                || commandExec.data.message
+                                || '').toString();
+                            logger.verbose(`commandResult ${commandResult}`);
+                        }
+                        else {
+                            commandResult = (commandExec.data.stdout || commandExec.data.stderr || '').toString();
+                            logger.verbose(`commandResult ${commandResult}`);
+                        }
+                        if (commandSucceeded) {
+                            const gitStatusAfterCommand = await execAsync(`git status`, { cwd: workspacePath });
+                            logger.verbose(`gitStatusCommand ${JSON.stringify(gitStatusAfterCommand.data)}`);
                         }
-                        commandSucceeded = false;
-                        commandResult = (commandExec.data.stdout
-                            || commandExec.data.stderr
-                            || commandExec.data.message
-                            || '').toString();
-                        logger.verbose(`commandResult ${commandResult}`);
                     }
-                    else {
-                        commandResult = (commandExec.data.stdout || commandExec.data.stderr || '').toString();
-                        logger.verbose(`commandResult ${commandResult}`);
+                    const postCommandExecFnInput = {
+                        commandResult,
+                        commandSucceeded,
+                        context,
+                        prompt,
+                        stepIndex: compositeStepIndex,
+                        contextRunState,
+                        lumpVariables,
+                        stepVariables,
+                        projectRoot,
+                    };
+                    logger.verbose(`context is ${JSON.stringify(context)}`);
+                    const keepHistoryFilePath = getKeepHistoryFilePathFn(context) || '';
+                    logger.verbose(`keepHistoryFilePath ${keepHistoryFilePath}`);
+                    if (!!command && keepHistoryFilePath.length > 0) {
+                        const appendResult = await appendHistoryEntry({
+                            filePath: keepHistoryFilePath,
+                            entry: postCommandExecFnInput,
+                        });
+                        if (!appendResult.success) {
+                            // TODO: sanitize history appending to avoid this warning for certain commands outputs
+                            logger.warn(`Failed to append history entry to ${keepHistoryFilePath}: ${appendResult.data}`);
+                        }
                     }
-                    if (commandSucceeded) {
-                        const gitStatusAfterCommand = await execAsync(`git status`, { cwd: workspacePath });
-                        logger.verbose(`gitStatusCommand ${JSON.stringify(gitStatusAfterCommand.data)}`);
+                    if (postCommandExecFn) {
+                        const returnedSteps = await postCommandExecFn(postCommandExecFnInput);
+                        if (returnedSteps != null && returnedSteps.length > 0) {
+                            await walkAndExecuteSteps(returnedSteps, nextCallHeadIndex);
+                        }
                     }
                 }
-                const postCommandExecFnInput = {
-                    commandResult,
-                    commandSucceeded,
-                    context,
-                    prompt,
-                    stepIndex: compositeStepIndex,
-                    contextRunState,
-                    lumpVariables,
-                    stepVariables,
-                    projectRoot,
-                };
-                logger.verbose(`context is ${JSON.stringify(context)}`);
-                const keepHistoryFilePath = getKeepHistoryFilePathFn(context) || '';
-                logger.verbose(`keepHistoryFilePath ${keepHistoryFilePath}`);
-                if (!!command && keepHistoryFilePath.length > 0) {
-                    const appendResult = await appendHistoryEntry({
-                        filePath: keepHistoryFilePath,
-                        entry: postCommandExecFnInput,
+            }
+            try {
+                await walkAndExecuteSteps(steps, []);
+            }
+            finally {
+                try {
+                    await teardownFn({
+                        lumpVariables,
+                        contextList,
+                        currentContextIndex: i,
+                        contextRunState,
                     });
-                    if (!appendResult.success) {
-                        // TODO: sanitize history appending to avoid this warning for certain commands outputs
-                        logger.warn(`Failed to append history entry to ${keepHistoryFilePath}: ${appendResult.data}`);
-                    }
                 }
-                if (postCommandExecFn) {
-                    const returnedSteps = await postCommandExecFn(postCommandExecFnInput);
-                    if (returnedSteps != null && returnedSteps.length > 0) {
-                        await walkAndExecuteSteps(returnedSteps, nextCallHeadIndex);
-                    }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    logger.error(`Failed to run teardownFn: ${message}`);
                 }
             }
-        }
-        await walkAndExecuteSteps(steps, []);
-        if (stepWalkFailure) {
-            return stepWalkFailure;
-        }
-        await teardownFn({
-            lumpVariables,
-            contextList,
-            currentContextIndex: i,
-            contextRunState,
-        });
-        const perContextInput = {
-            ...injectedGitAndWorkspaceFnsInput,
-            context,
-        };
-        const gitAddCommand = await execAsync(gitAddCommandFn(perContextInput), { cwd: workspacePath });
-        logger.verbose(`gitAddCommand ${JSON.stringify(gitAddCommand)}`);
-        if (!gitAddCommand.success) {
-            return set(gitAddCommand, ['data', 'message'], `Failed to add the changes for context ${context.name}: ${gitAddCommand.data.message}`);
-        }
-        const commitMessage = gitCommitMessageFn({ context, lumpVariables, baseBranch });
-        const commitCommand = await execAsync(gitCommitCommandFn({
-            ...perContextInput,
-            commitMessage,
-        }), { cwd: workspacePath });
-        logger.verbose(`commitCommand ${JSON.stringify(commitCommand)}`);
-        if (!commitCommand.success) {
-            logger.error(formatExecFailureMessage({
+            if (stepWalkFailure) {
+                runFailure = stepWalkFailure;
+                break;
+            }
+            const perContextInput = {
+                ...injectedGitAndWorkspaceFnsInput,
+                context,
+            };
+            const addOutcome = await runOptionalGitCommand({
+                label: `git add for context ${context.name}`,
+                getCommand: () => gitAddCommandFn(perContextInput),
+                cwd: workspacePath,
+                logger,
+            });
+            if (addOutcome === 'failed') {
+                runFailure = {
+                    success: false,
+                    data: {
+                        message: `Failed to add the changes for context ${context.name}`,
+                    },
+                };
+                break;
+            }
+            const commitMessage = gitCommitMessageFn({ context, lumpVariables, baseBranch });
+            await runOptionalGitCommand({
                 label: `git commit for context ${context.name}`,
-                failure: commitCommand,
-            }));
+                getCommand: () => gitCommitCommandFn({
+                    ...perContextInput,
+                    commitMessage,
+                }),
+                cwd: workspacePath,
+                logger,
+            });
+        }
+        if (!runFailure) {
+            await runOptionalGitCommand({
+                label: `git push on branch ${branchName}`,
+                getCommand: () => gitPushCommandFn(injectedGitAndWorkspaceFnsInput),
+                cwd: workspacePath,
+                logger,
+            });
         }
     }
-    const pushCommand = await execAsync(gitPushCommandFn(injectedGitAndWorkspaceFnsInput), { cwd: workspacePath });
-    logger.verbose(`pushCommand ${JSON.stringify(pushCommand)}`);
-    if (!pushCommand.success) {
-        logger.error(formatExecFailureMessage({
-            label: `git push on branch ${branchName}`,
-            failure: pushCommand,
-        }));
-    }
-    const teardownWorkspaceCommand = await teardownWorkspaceFn(injectedGitAndWorkspaceFnsInput);
-    logger.verbose(`teardownWorkspaceCommand ${teardownWorkspaceCommand}`);
-    if (teardownWorkspaceCommand) {
-        const teardownWorkspaceCommandExec = await execAsync(teardownWorkspaceCommand, { cwd: workspacePath });
-        logger.verbose(`teardownWorkspaceCommandExec ${JSON.stringify(teardownWorkspaceCommandExec)}`);
-        if (!teardownWorkspaceCommandExec.success) {
-            return set(teardownWorkspaceCommandExec, ['data', 'message'], `Failed to teardown the workspace: ${teardownWorkspaceCommandExec.data.message}`);
+    finally {
+        const teardownWorkspaceCommand = await teardownWorkspaceFn(injectedGitAndWorkspaceFnsInput);
+        logger.verbose(`teardownWorkspaceCommand ${teardownWorkspaceCommand}`);
+        if (teardownWorkspaceCommand) {
+            const teardownWorkspaceCommandExec = await execAsync(teardownWorkspaceCommand, { cwd: workspacePath });
+            logger.verbose(`teardownWorkspaceCommandExec ${JSON.stringify(teardownWorkspaceCommandExec)}`);
+            if (!teardownWorkspaceCommandExec.success) {
+                if (runFailure) {
+                    logger.error(formatExecFailureMessage({
+                        label: 'teardown workspace',
+                        failure: teardownWorkspaceCommandExec,
+                    }));
+                }
+                else {
+                    runFailure = {
+                        success: false,
+                        data: {
+                            message: `Failed to teardown the workspace: ${teardownWorkspaceCommandExec.data.message}`,
+                            reason: 'workspaceTeardownFailed',
+                        },
+                    };
+                }
+            }
         }
     }
+    if (runFailure) {
+        return runFailure;
+    }
     return success({
         branchName,
         contextNames,
@@ -3844,17 +4112,32 @@ async function scanDirectory({ dirPath, allPaths, gitignoresMap, projectRoot, lo
     }
 }
 
+/**
+ * Refreshes remote-tracking refs for status / planning (one network fetch).
+ * Uses `--no-write-fetch-head` so concurrent preflight/pull paths are safer.
+ */
+const refreshRemoteTrackingRefs = async (input) => {
+    const { projectRoot, remoteName = 'origin' } = input;
+    const result = await execAsync(`git fetch --prune --no-write-fetch-head ${remoteName}`, { cwd: projectRoot });
+    if (!result.success) {
+        return failure(result.data.message);
+    }
+    return success(undefined);
+};
+
 async function getContextStatus(params) {
-    const { contextName, gitCommitMessageFn, projectRoot, baseBranch, lumpVariables: lumpVariablesInput, contextVariables = {}, remoteName = "origin", logger, } = params;
+    const { contextName, gitCommitMessageFn, projectRoot, baseBranch, lumpVariables: lumpVariablesInput, contextVariables = {}, remoteName = "origin", logger, skipFetch = false, } = params;
     const lumpVariables = (lumpVariablesInput ?? {});
     const commitMessage = gitCommitMessageFn({
         context: { name: contextName, variables: contextVariables },
         lumpVariables,
         baseBranch,
     });
-    const fetchAll = await execAsync(`git fetch --all --prune`, { cwd: projectRoot });
-    if (!fetchAll.success)
-        return 'toDo';
+    if (!skipFetch) {
+        const fetchResult = await refreshRemoteTrackingRefs({ projectRoot, remoteName });
+        if (!fetchResult.success)
+            return 'toDo';
+    }
     const logResult = await execAsync(`git log --remotes=${remoteName} -F --grep=${shellSingleQuote(commitMessage)} --format=${shellSingleQuote('%H %s')}`, { cwd: projectRoot });
     if (!logResult.success)
         return 'toDo';
@@ -3863,6 +4146,7 @@ async function getContextStatus(params) {
     const matchingHashes = parseGitLogHashSubjectLines(logResultOutput)
         .filter((entry) => entry.subject === commitMessage)
         .map((entry) => entry.hash);
+    logger?.verbose(`contextName ${contextName}`);
     logger?.verbose(`remoteName ${remoteName}`);
     logger?.verbose(`baseBranch ${baseBranch}`);
     logger?.verbose(`commitMessage ${commitMessage}`);
@@ -3917,7 +4201,7 @@ function validateContextListNames(contextList) {
 }
 
 async function getToDoContextList(params) {
-    const { getContextListFn, lumpVariables, gitCommitMessageFn, projectRoot, baseBranch, logger } = params;
+    const { getContextListFn, lumpVariables, gitCommitMessageFn, projectRoot, baseBranch, logger, refreshRemoteTrackingRefsFn = refreshRemoteTrackingRefs, } = params;
     const codeBasePathsResult = await getCodeBasePaths({ cwd: projectRoot, logger });
     if (!codeBasePathsResult.success) {
         return failure({
@@ -3935,21 +4219,28 @@ async function getToDoContextList(params) {
     const allCtxNames = contextList.flatMap(context => [context.name, ...(context.options?.dependsOnContexts ?? [])]);
     const allCtxNamesSet = new Set(allCtxNames);
     const allCtxNamesList = Array.from(allCtxNamesSet);
-    const contextStatusList = await Promise.all(allCtxNamesList.map((contextName) => {
-        return getContextStatus({
-            contextName: contextName,
+    const refreshResult = await refreshRemoteTrackingRefsFn({ projectRoot });
+    let contextStatusMap;
+    if (!refreshResult.success) {
+        logger?.warn(`Failed to refresh remote-tracking refs for context status; treating contexts as toDo: ${refreshResult.data}`);
+        contextStatusMap = new Map(allCtxNamesList.map((name) => [name, 'toDo']));
+    }
+    else {
+        const contextStatusList = await Promise.all(allCtxNamesList.map((contextName) => getContextStatus({
+            contextName,
             contextVariables: {}, // TODO: Remove contextVariables from getContextStatus, really not needed
             gitCommitMessageFn,
             lumpVariables,
             projectRoot,
             baseBranch,
             logger,
-        });
-    }));
-    const contextStatusMap = new Map(allCtxNamesList.map((contextName, i) => [contextName, contextStatusList[i]]));
+            skipFetch: true,
+        })));
+        contextStatusMap = new Map(allCtxNamesList.map((contextName, i) => [contextName, contextStatusList[i]]));
+    }
     const contextListToDo = contextList
-        .filter((context, contextIndex) => {
-        const contextStatus = contextStatusList[contextIndex];
+        .filter((context) => {
+        const contextStatus = contextStatusMap.get(context.name);
         if (contextStatus && contextStatus !== 'toDo')
             return false;
         const deps = context.options?.dependsOnContexts;
@@ -4015,7 +4306,7 @@ const defaultSetupWorkspaceFnWithWorktree = async (input) => {
 };
 
 async function runLump(input) {
-    const { baseBranch, branchFn, lumpVariables: lumpVariablesInput, getContextListFn, gitAddCommandFn = defaultGitAddCommandFn, gitCommitCommandFn = defaultGitCommitCommandFn, gitCommitMessageFn = defaultGitCommitMessageFn, gitPushCommandFn = defaultGitPushCommandFn, numberOfContextsPerBranch = 1, projectRoot, steps, setupFn = () => ({ contextRunState: {} }), setupWorkspaceFn = defaultSetupWorkspaceFn, teardownFn = () => undefined, teardownWorkspaceFn = defaultTeardownWorkspaceFn, getKeepHistoryFilePathFn = () => undefined, logger: loggerInput, } = input;
+    const { baseBranch, branchFn, lumpVariables: lumpVariablesInput, getContextListFn, gitAddCommandFn = defaultGitAddCommandFn, gitCommitCommandFn = defaultGitCommitCommandFn, gitCommitMessageFn = defaultGitCommitMessageFn, gitPushCommandFn = defaultGitPushCommandFn, numberOfContextsPerBranch = 1, projectRoot, steps, setupFn = () => ({ contextRunState: {} }), setupWorkspaceFn = defaultSetupWorkspaceFn, teardownFn = () => undefined, teardownWorkspaceFn = defaultTeardownWorkspaceFn, getKeepHistoryFilePathFn = () => undefined, logger: loggerInput, signal, refreshRemoteTrackingRefsFn, } = input;
     const lumpVariables = (lumpVariablesInput ?? {});
     const logger = loggerInput ?? createConsoleLogger({});
     const contextListToDoResult = await getToDoContextList({
@@ -4025,6 +4316,7 @@ async function runLump(input) {
         baseBranch,
         gitCommitMessageFn,
         logger,
+        refreshRemoteTrackingRefsFn,
     });
     if (!contextListToDoResult.success) {
         return set(contextListToDoResult, ['data', 'message'], "Error in runLump: Failed to get to do context list. Original Error: " + contextListToDoResult.data.message);
@@ -4061,6 +4353,7 @@ async function runLump(input) {
         teardownWorkspaceFn,
         logger,
         getKeepHistoryFilePathFn,
+        signal,
     });
     if (!executeStepsResult.success) {
         return set(executeStepsResult, ['data', 'message'], "Error in runLump: Failed to execute steps for context list. Original Error: " + executeStepsResult.data.message);
@@ -4070,5 +4363,5 @@ async function runLump(input) {
     });
 }
 
-export { appendHistoryEntry, collectStepsForContext, contextStatus, createConsoleLogger, defaultGitAddCommandFn, defaultGitCommitCommandFn, defaultGitCommitMessageFn, defaultGitPushCommandFn, defaultSetupWorkspaceFn, defaultSetupWorkspaceFnWithWorktree, defaultTeardownWorkspaceFn, defaultTeardownWorkspaceFnWithWorktree, execAsync, execBinary, executeStepsForContextList, failure, formatExecFailureMessage, getCodeBasePaths, getContextStatus, getToDoContextList, historyFormatFromPath, parseGitLogHashSubjectLines, pathExists, readHistoryFile, resolveSpawnExecutable, runLump, set, shellSingleQuote, success, validateContextListNames, windowsNpmCmdShimBody, writeHistoryFile };
+export { appendHistoryEntry, collectStepsForContext, contextStatus, createConsoleLogger, defaultGitAddCommandFn, defaultGitCommitCommandFn, defaultGitCommitMessageFn, defaultGitPushCommandFn, defaultSetupWorkspaceFn, defaultSetupWorkspaceFnWithWorktree, defaultTeardownWorkspaceFn, defaultTeardownWorkspaceFnWithWorktree, execAsync, execBinary, executeStepsForContextList, failure, formatExecFailureMessage, getCodeBasePaths, getContextStatus, getToDoContextList, historyFormatFromPath, isProcessAlive, killProcessTree, nodeErrnoCode, parseGitLogHashSubjectLines, pathExists, readHistoryFile, refreshRemoteTrackingRefs, resolveSpawnExecutable, runLump, set, shellSingleQuote, success, validateContextListNames, windowsNpmCmdShimBody, writeHistoryFile };
 //# sourceMappingURL=index.js.map