@straiffi/archon 1.11.2 → 1.11.3

package/dist/server/lib/git.js

@@ -1,6 +1,6 @@
 import { execFile, execFileSync } from 'child_process';
 import { createHash, randomUUID } from 'crypto';
-import { cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, rmSync, statSync, symlinkSync } from 'fs';
+import { cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readlinkSync, readdirSync, rmSync, statSync, symlinkSync } from 'fs';
 import { cp as cpAsync, lstat as lstatAsync, mkdir as mkdirAsync, stat as statAsync, symlink as symlinkAsync } from 'fs/promises';
 import { tmpdir } from 'os';
 import { dirname, isAbsolute, join, relative, resolve } from 'path';
@@ -15,6 +15,8 @@ const MAX_GIT_OUTPUT_BYTES = 512 * 1024 * 1024;
 const GIT_READ_TIMEOUT_MS = 15_000;
 const GIT_REMOTE_KILL_GRACE_MS = 500;
 const MAX_CONCURRENT_DIFF_PROCESSES = 8;
+const MAX_REBASE_MARKER_SCAN_BYTES = 1024 * 1024;
+const MAX_REBASE_FINGERPRINT_BYTES = 1024 * 1024;
 const lastProjectBranchRemoteRefreshAt = new Map();
 const projectBranchRemoteRefreshes = new Map();
 const resolveCurrentBranchName = (cwd) => {
@@ -33,6 +35,10 @@ const toText = (value) => {
     }
     return value ? value.toString('utf8') : '';
 };
+const getGitErrorMessage = (error) => {
+    const failed = error;
+    return toText(failed.stderr).trim() || toText(failed.stdout).trim() || (error instanceof Error ? error.message : String(error));
+};
 const createTextSignature = (value) => {
     let hash = 5381;
     for (let index = 0; index < value.length; index += 1) {
@@ -416,6 +422,272 @@ const getGitOperationState = (cwd) => {
     }
     return 'idle';
 };
+const readGitPath = (cwd, name) => {
+    const path = runGitText(['rev-parse', '--git-path', name], cwd).trim();
+    return path ? resolve(cwd, path) : null;
+};
+const readOptionalFile = (path) => {
+    if (!path || !existsSync(path)) {
+        return null;
+    }
+    try {
+        return readFileSync(path, 'utf8').trim() || null;
+    }
+    catch {
+        return null;
+    }
+};
+const parsePositiveInteger = (value) => {
+    const parsed = Number.parseInt(value ?? '', 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+};
+const normalizeRebaseBaseBranch = (value) => {
+    if (!value) {
+        return null;
+    }
+    return value
+        .replace(/^refs\/remotes\/origin\//, '')
+        .replace(/^refs\/heads\//, '')
+        .replace(/^origin\//, '');
+};
+const getActiveRebaseDirectory = (cwd) => {
+    const mergeDir = readGitPath(cwd, 'rebase-merge');
+    if (mergeDir && existsSync(mergeDir)) {
+        return mergeDir;
+    }
+    const applyDir = readGitPath(cwd, 'rebase-apply');
+    return applyDir && existsSync(applyDir) ? applyDir : null;
+};
+export const getActiveRebaseBranch = (cwd) => {
+    if (getGitOperationState(cwd) !== 'rebase') {
+        return null;
+    }
+    const rebaseDir = getActiveRebaseDirectory(cwd);
+    return readOptionalFile(rebaseDir ? join(rebaseDir, 'head-name') : null)?.replace(/^refs\/heads\//, '') ?? null;
+};
+const getRemainingRebaseOwnedPaths = (cwd) => {
+    const rebaseDir = getActiveRebaseDirectory(cwd);
+    const todo = readOptionalFile(rebaseDir ? join(rebaseDir, 'git-rebase-todo') : null);
+    const paths = new Set();
+    if (!todo) {
+        return paths;
+    }
+    const commitCommands = new Set(['pick', 'p', 'reword', 'r', 'edit', 'e', 'squash', 's', 'fixup', 'f']);
+    for (const line of todo.split('\n')) {
+        const [command, commit] = line.trim().split(/\s+/, 3);
+        if (!command || !commit || !commitCommands.has(command)) {
+            continue;
+        }
+        try {
+            const output = runGitText(['diff-tree', '--root', '--no-commit-id', '--name-only', '-r', '-z', commit], cwd);
+            for (const path of output.split('\0').filter(Boolean)) {
+                paths.add(path);
+            }
+        }
+        catch {
+            // Git will remain authoritative and reject a conflicting later application.
+        }
+    }
+    return paths;
+};
+const parseRebaseConflictStages = (output) => {
+    const stagesByPath = new Map();
+    for (const entry of output.split('\0').filter(Boolean)) {
+        const separatorIndex = entry.indexOf('\t');
+        if (separatorIndex === -1) {
+            continue;
+        }
+        const path = entry.slice(separatorIndex + 1);
+        const stage = Number(entry.slice(0, separatorIndex).trim().split(/\s+/).at(-1));
+        if (!Number.isInteger(stage)) {
+            continue;
+        }
+        const stages = stagesByPath.get(path) ?? new Set();
+        stages.add(stage);
+        stagesByPath.set(path, stages);
+    }
+    return stagesByPath;
+};
+const hasCustomConflictMarkerSize = (cwd, path) => {
+    try {
+        const value = runGitText(['check-attr', '-z', 'conflict-marker-size', '--', path], cwd).split('\0')[2];
+        return Boolean(value && value !== 'unspecified' && value !== 'unset' && value !== '7');
+    }
+    catch {
+        return false;
+    }
+};
+const getRebaseResolution = (cwd, path, conflicted, conflictStages) => {
+    if (!conflicted) {
+        return { resolution: 'ready', resolution_reason: null };
+    }
+    if (conflictStages && conflictStages.has(2) !== conflictStages.has(3)) {
+        return { resolution: 'acknowledgement_required', resolution_reason: 'delete_modify' };
+    }
+    if (hasCustomConflictMarkerSize(cwd, path)) {
+        return { resolution: 'acknowledgement_required', resolution_reason: 'marker_override' };
+    }
+    const absolutePath = resolve(cwd, path);
+    if (!existsSync(absolutePath)) {
+        return { resolution: 'acknowledgement_required', resolution_reason: 'deleted' };
+    }
+    try {
+        const fileStatus = lstatSync(absolutePath);
+        if (fileStatus.isSymbolicLink()) {
+            return { resolution: 'acknowledgement_required', resolution_reason: 'symlink' };
+        }
+        if (!fileStatus.isFile()) {
+            return { resolution: 'acknowledgement_required', resolution_reason: 'unreadable' };
+        }
+        if (fileStatus.size > MAX_REBASE_MARKER_SCAN_BYTES) {
+            return { resolution: 'acknowledgement_required', resolution_reason: 'oversized' };
+        }
+        const content = readFileSync(absolutePath);
+        if (content.includes(0)) {
+            return { resolution: 'acknowledgement_required', resolution_reason: 'binary' };
+        }
+        const text = content.toString('utf8');
+        const hasConflictMarkers = /^(<<<<<<<(?: |$)|=======$|>>>>>>>[ \t])/m.test(text);
+        return hasConflictMarkers
+            ? { resolution: 'acknowledgement_required', resolution_reason: 'conflict_markers' }
+            : { resolution: 'ready', resolution_reason: null };
+    }
+    catch {
+        return { resolution: 'acknowledgement_required', resolution_reason: 'unreadable' };
+    }
+};
+const getWorkingTreeFingerprint = (cwd, path) => {
+    const absolutePath = resolve(cwd, path);
+    try {
+        const status = lstatSync(absolutePath);
+        if (status.isSymbolicLink()) {
+            return `symlink:${createHash('sha256').update(readlinkSync(absolutePath)).digest('hex')}`;
+        }
+        if (!status.isFile()) {
+            return `other:${status.mode}`;
+        }
+        if (status.size > MAX_REBASE_FINGERPRINT_BYTES) {
+            return `oversized:${status.mode}:${status.size}:${status.mtimeMs}:${status.ctimeMs}`;
+        }
+        return `file:${status.mode}:${status.size}:${createHash('sha256').update(readFileSync(absolutePath)).digest('hex')}`;
+    }
+    catch (error) {
+        if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
+            return 'missing';
+        }
+        return 'unreadable';
+    }
+};
+const getWorkingTreeFingerprints = (cwd, paths) => paths
+    .map(path => [path, getWorkingTreeFingerprint(cwd, path)]);
+const getRebaseStepCoordinates = (cwd) => {
+    const rebaseDir = getActiveRebaseDirectory(cwd);
+    return {
+        stoppedCommitSha: (() => {
+            try {
+                return runGitText(['rev-parse', '--verify', 'REBASE_HEAD^{commit}'], cwd).trim();
+            }
+            catch {
+                return null;
+            }
+        })(),
+        currentStep: parsePositiveInteger(readOptionalFile(rebaseDir ? join(rebaseDir, 'msgnum') : null))
+            ?? parsePositiveInteger(readOptionalFile(rebaseDir ? join(rebaseDir, 'next') : null)),
+        totalSteps: parsePositiveInteger(readOptionalFile(rebaseDir ? join(rebaseDir, 'end') : null))
+            ?? parsePositiveInteger(readOptionalFile(rebaseDir ? join(rebaseDir, 'last') : null)),
+    };
+};
+const getRebaseContinuationFingerprint = (cwd, status, selectedPaths) => {
+    if (status.operation_state !== 'rebase' || !status.rebase_step) {
+        return null;
+    }
+    const selectedPathStates = [...selectedPaths].sort().map(path => {
+        const pathStatus = status.rebase_step?.paths.find(candidate => candidate.path === path);
+        return pathStatus
+            ? [path, pathStatus.index_state, pathStatus.resolution, pathStatus.resolution_reason]
+            : [path, 'missing'];
+    });
+    return createHash('sha256').update(JSON.stringify({
+        ...getRebaseStepCoordinates(cwd),
+        stagedIndexEntries: runGitText(['diff', '--cached', '--raw', '--abbrev=40', '-z'], cwd),
+        unmergedEntries: runGitText(['ls-files', '--unmerged', '-z'], cwd),
+        resolveUndoEntries: runGitText(['ls-files', '--resolve-undo', '-z'], cwd),
+        selectedPathStates,
+    })).digest('hex');
+};
+const getRebaseStepStatus = (cwd, fallbackBaseBranch) => {
+    if (getGitOperationState(cwd) !== 'rebase') {
+        return null;
+    }
+    const rebaseDir = getActiveRebaseDirectory(cwd);
+    const stoppedCommitSha = (() => {
+        try {
+            return runGitText(['rev-parse', '--verify', 'REBASE_HEAD^{commit}'], cwd).trim() || null;
+        }
+        catch {
+            return null;
+        }
+    })();
+    const stoppedCommitSubject = stoppedCommitSha
+        ? runGitText(['show', '-s', '--format=%s', stoppedCommitSha], cwd).trim() || null
+        : null;
+    const ownedPaths = new Set(stoppedCommitSha
+        ? runGitText(['diff-tree', '--root', '--no-commit-id', '--name-only', '-r', '-z', stoppedCommitSha], cwd).split('\0').filter(Boolean)
+        : []);
+    const stagedPaths = new Set(runGitText(['diff', '--cached', '--name-only', '-z'], cwd).split('\0').filter(Boolean));
+    const unmergedOutput = runGitText(['ls-files', '--unmerged', '-z'], cwd);
+    const unmergedStagesByPath = parseRebaseConflictStages(unmergedOutput);
+    const unmergedPaths = new Set(unmergedStagesByPath.keys());
+    const resolveUndoOutput = runGitText(['ls-files', '--resolve-undo', '-z'], cwd);
+    const resolveUndoStagesByPath = parseRebaseConflictStages(resolveUndoOutput);
+    const formerlyConflictedPaths = new Set(resolveUndoStagesByPath.keys());
+    const workspacePaths = parseGitStatusOutput(runGitText(['status', '--porcelain=v2', '--untracked-files=all', '-z'], cwd)).parsedEntries.map(entry => entry.path);
+    const allPaths = [...new Set([...stagedPaths, ...unmergedPaths, ...formerlyConflictedPaths, ...workspacePaths])].sort();
+    const paths = allPaths.map(path => {
+        const conflicted = unmergedPaths.has(path);
+        const staged = stagedPaths.has(path);
+        const rebaseOwned = ownedPaths.has(path);
+        return {
+            path,
+            rebase_owned: rebaseOwned,
+            index_state: conflicted ? 'unmerged' : staged ? 'staged' : 'unstaged',
+            selection_required: conflicted || formerlyConflictedPaths.has(path) || (rebaseOwned && staged),
+            ...getRebaseResolution(cwd, path, conflicted || formerlyConflictedPaths.has(path), unmergedStagesByPath.get(path) ?? resolveUndoStagesByPath.get(path)),
+        };
+    });
+    const currentStep = parsePositiveInteger(readOptionalFile(rebaseDir ? join(rebaseDir, 'msgnum') : null))
+        ?? parsePositiveInteger(readOptionalFile(rebaseDir ? join(rebaseDir, 'next') : null));
+    const totalSteps = parsePositiveInteger(readOptionalFile(rebaseDir ? join(rebaseDir, 'end') : null))
+        ?? parsePositiveInteger(readOptionalFile(rebaseDir ? join(rebaseDir, 'last') : null));
+    const baseBranch = normalizeRebaseBaseBranch(readOptionalFile(rebaseDir ? join(rebaseDir, 'onto_name') : null)) ?? fallbackBaseBranch;
+    const stagedIndexEntries = runGitText(['diff', '--cached', '--raw', '-z'], cwd);
+    const headSha = runGitText(['rev-parse', '--verify', 'HEAD^{commit}'], cwd).trim();
+    const workingTreeFingerprints = getWorkingTreeFingerprints(cwd, allPaths);
+    const signature = createHash('sha256')
+        .update(JSON.stringify({ headSha, stoppedCommitSha, currentStep, totalSteps, unmergedOutput, resolveUndoOutput, stagedIndexEntries, workingTreeFingerprints }))
+        .digest('hex');
+    return {
+        step_signature: signature,
+        current_step: currentStep,
+        total_steps: totalSteps,
+        stopped_commit_sha: stoppedCommitSha,
+        stopped_commit_subject: stoppedCommitSubject,
+        base_branch: baseBranch,
+        paths,
+    };
+};
+const MAX_REBASE_STAGED_DIFF_BYTES = 512 * 1024;
+export const getRebaseStagedDiff = (cwd) => {
+    const diff = runGitText(['diff', '--cached', '--no-ext-diff', '--no-textconv'], cwd);
+    const bytes = Buffer.byteLength(diff);
+    if (bytes <= MAX_REBASE_STAGED_DIFF_BYTES) {
+        return { diff, truncated: false };
+    }
+    return {
+        diff: Buffer.from(diff).subarray(0, MAX_REBASE_STAGED_DIFF_BYTES).toString('utf8'),
+        truncated: true,
+    };
+};
 const hasActiveGitOperation = (cwd) => {
     if (getGitOperationState(cwd) !== 'idle') {
         return true;
@@ -1495,6 +1767,206 @@ export const rebaseGitBranchOntoBase = async (cwd, branch = null, project = null
         });
     }
 };
+const finalizeRebaseWorktreeBase = (cwd, branch, project, baseBranch) => {
+    if (!project || resolve(cwd) === getRepoPath(project) || !baseBranch) {
+        return;
+    }
+    const nextBaseCommit = resolveCommitBaseFromBaseRef(resolveNamedBranchRef(baseBranch, cwd), cwd);
+    saveWorktreeBase(branch, project, { baseBranch, baseCommit: nextBaseCommit });
+};
+const getRebaseActionStatus = (cwd, branch, project) => getGitStatus(cwd, branch, project);
+const rejectRebaseAction = (outcome, error, status) => ({ outcome, error, status });
+const getLiteralPathspec = (path) => `:(literal)${path}`;
+export const continueGitRebase = async (cwd, targetBranch, project, options) => {
+    const status = getRebaseActionStatus(cwd, targetBranch ?? options.branch, project);
+    if (status.operation_state !== 'rebase' || !status.rebase_step) {
+        return rejectRebaseAction('stale_step', 'There is no active rebase step. Refresh and try again.', status);
+    }
+    if (!targetBranch || !options.branch || options.branch !== targetBranch) {
+        return rejectRebaseAction('stale_step', 'The active target branch changed. Refresh and try again.', status);
+    }
+    if (options.expectedStepSignature !== status.rebase_step.step_signature) {
+        return rejectRebaseAction('stale_step', 'The rebase step or index changed. Review the refreshed status and try again.', status);
+    }
+    const pathsByName = new Map(status.rebase_step.paths.map(path => [path.path, path]));
+    const selectedPaths = [...new Set(options.selectedPaths)];
+    const acknowledgedPaths = new Set(options.acknowledgedPaths);
+    const unknownPath = selectedPaths.find(path => !pathsByName.has(path));
+    if (unknownPath) {
+        return rejectRebaseAction('rejected', `Path "${unknownPath}" is not part of the current rebase status.`, status);
+    }
+    const unknownAcknowledgement = [...acknowledgedPaths].find(path => !pathsByName.has(path));
+    if (unknownAcknowledgement) {
+        return rejectRebaseAction('rejected', `Acknowledged path "${unknownAcknowledgement}" is not part of the current rebase status.`, status);
+    }
+    const missingMandatoryPath = status.rebase_step.paths.find(path => path.selection_required && !selectedPaths.includes(path.path));
+    if (missingMandatoryPath) {
+        return rejectRebaseAction('rejected', `Path "${missingMandatoryPath.path}" is required for this rebase step.`, status);
+    }
+    const missingAcknowledgement = status.rebase_step.paths.find(path => (selectedPaths.includes(path.path)
+        && path.resolution === 'acknowledgement_required'
+        && !acknowledgedPaths.has(path.path)));
+    if (missingAcknowledgement) {
+        return rejectRebaseAction('rejected', `Acknowledge the resolution state for "${missingAcknowledgement.path}" before continuing.`, status);
+    }
+    const expectedSelectedFingerprints = new Map(getWorkingTreeFingerprints(cwd, selectedPaths));
+    const excludedOptionalPaths = status.rebase_step.paths
+        .filter(path => !path.selection_required && !selectedPaths.includes(path.path))
+        .map(path => path.path);
+    const excludedStagedPaths = status.rebase_step.paths
+        .filter(path => excludedOptionalPaths.includes(path.path) && path.index_state === 'staged')
+        .map(path => path.path);
+    try {
+        for (const path of excludedStagedPaths) {
+            await runGitTextAsync(['restore', '--staged', '--', getLiteralPathspec(path)], cwd);
+        }
+    }
+    catch (error) {
+        const failedPath = excludedStagedPaths.find(path => {
+            try {
+                return runGitText(['diff', '--cached', '--name-only', '-z', '--', getLiteralPathspec(path)], cwd).includes(path);
+            }
+            catch {
+                return true;
+            }
+        });
+        return rejectRebaseAction('rejected', failedPath
+            ? `Unable to safely remove "${failedPath}" from the index while preserving its working-tree content.`
+            : getGitErrorMessage(error), getRebaseActionStatus(cwd, targetBranch, project));
+    }
+    const changedSelectedPath = getWorkingTreeFingerprints(cwd, selectedPaths)
+        .find(([path, fingerprint]) => expectedSelectedFingerprints.get(path) !== fingerprint)?.[0];
+    if (changedSelectedPath) {
+        return rejectRebaseAction('stale_step', `Selected path "${changedSelectedPath}" changed before it could be staged. Review the refreshed status and try again.`, getRebaseActionStatus(cwd, targetBranch, project));
+    }
+    const pathsToStage = status.rebase_step.paths
+        .filter(path => selectedPaths.includes(path.path) && path.index_state !== 'staged')
+        .map(path => getLiteralPathspec(path.path));
+    if (pathsToStage.length > 0) {
+        try {
+            await runGitTextAsync(['add', '--', ...pathsToStage], cwd);
+        }
+        catch (error) {
+            return rejectRebaseAction('rejected', getGitErrorMessage(error) || 'Unable to stage the selected rebase paths.', getRebaseActionStatus(cwd, targetBranch, project));
+        }
+    }
+    const refreshed = getRebaseActionStatus(cwd, targetBranch, project);
+    if (refreshed.operation_state !== 'rebase' || !refreshed.rebase_step) {
+        return rejectRebaseAction('stale_step', 'The rebase ended while its index was being prepared. Refresh and try again.', refreshed);
+    }
+    const refreshedStagedPaths = new Set(refreshed.rebase_step.paths.filter(path => path.index_state === 'staged').map(path => path.path));
+    const refreshedFormerlyConflictedPaths = new Set(runGitText(['ls-files', '--resolve-undo', '-z'], cwd)
+        .split('\0')
+        .filter(Boolean)
+        .map(entry => entry.slice(entry.indexOf('\t') + 1)));
+    const stillStagedExcludedPath = excludedOptionalPaths.find(path => refreshedStagedPaths.has(path));
+    if (stillStagedExcludedPath) {
+        return rejectRebaseAction('rejected', `Excluded path "${stillStagedExcludedPath}" is still staged; the rebase was not continued.`, refreshed);
+    }
+    const expectedStagedPaths = new Set(selectedPaths.filter(path => refreshedStagedPaths.has(path)));
+    const unexpectedStagedPath = [...refreshedStagedPaths].find(path => !expectedStagedPaths.has(path));
+    const missingSelectedPath = selectedPaths.find(path => (!refreshedStagedPaths.has(path) && !refreshedFormerlyConflictedPaths.has(path)));
+    if (unexpectedStagedPath || missingSelectedPath) {
+        const changedPath = unexpectedStagedPath ?? missingSelectedPath;
+        return rejectRebaseAction('stale_step', `The staged path set changed at "${changedPath}". Review the refreshed status and try again.`, refreshed);
+    }
+    if (refreshedStagedPaths.size === 0) {
+        return { outcome: 'empty_step', status: refreshed };
+    }
+    const expectedContinuationFingerprint = getRebaseContinuationFingerprint(cwd, refreshed, selectedPaths);
+    if (!expectedContinuationFingerprint) {
+        return rejectRebaseAction('stale_step', 'The rebase ended while its index was being verified. Refresh and try again.', refreshed);
+    }
+    const baseBranch = status.rebase_step.base_branch;
+    const trackedExcludedPaths = excludedOptionalPaths.filter(path => {
+        try {
+            return runGitText(['ls-files', '--error-unmatch', '--', getLiteralPathspec(path)], cwd).trim() !== '';
+        }
+        catch {
+            return false;
+        }
+    });
+    const remainingRebaseOwnedPaths = getRemainingRebaseOwnedPaths(cwd);
+    const futureOwnedExcludedPath = excludedOptionalPaths.find(path => remainingRebaseOwnedPaths.has(path));
+    if (futureOwnedExcludedPath) {
+        return rejectRebaseAction('rejected', `Excluded working-tree changes in "${futureOwnedExcludedPath}" overlap a later rebase step. Handle that path before continuing.`, refreshed);
+    }
+    let continueError = null;
+    try {
+        if (trackedExcludedPaths.length > 0) {
+            await runGitTextAsync(['update-index', '--assume-unchanged', '--', ...trackedExcludedPaths], cwd);
+        }
+        const finalStatus = getRebaseActionStatus(cwd, targetBranch, project);
+        const finalStagedPaths = new Set(finalStatus.rebase_step?.paths
+            .filter(path => path.index_state === 'staged')
+            .map(path => path.path) ?? []);
+        const finalUnexpectedPath = [...finalStagedPaths].find(path => !expectedStagedPaths.has(path))
+            ?? [...expectedStagedPaths].find(path => !finalStagedPaths.has(path));
+        const finalContinuationFingerprint = getRebaseContinuationFingerprint(cwd, finalStatus, selectedPaths);
+        const continuationChanged = finalContinuationFingerprint !== expectedContinuationFingerprint;
+        if (finalStatus.operation_state !== 'rebase' || !finalStatus.rebase_step || finalUnexpectedPath || continuationChanged) {
+            return rejectRebaseAction('stale_step', finalUnexpectedPath
+                ? `The staged path set changed at "${finalUnexpectedPath}" immediately before continue. Review the refreshed status and try again.`
+                : continuationChanged
+                    ? 'The staged content, resolution state, or rebase step changed immediately before continue. Review the refreshed status and try again.'
+                    : 'The rebase ended while its staged paths were being verified. Refresh and try again.', finalStatus);
+        }
+        await runGitTextAsync(['rebase', '--continue'], cwd, {
+            env: { GIT_EDITOR: 'true', GIT_SEQUENCE_EDITOR: 'true' },
+        });
+    }
+    catch (error) {
+        continueError = error;
+    }
+    finally {
+        if (trackedExcludedPaths.length > 0) {
+            try {
+                await runGitTextAsync(['update-index', '--no-assume-unchanged', '--', ...trackedExcludedPaths], cwd);
+            }
+            catch {
+                // Status below remains authoritative if Git removed a path while advancing the rebase.
+            }
+        }
+    }
+    const nextStatus = getRebaseActionStatus(cwd, targetBranch, project);
+    if (continueError) {
+        if (nextStatus.operation_state === 'rebase' && nextStatus.rebase_step?.step_signature !== refreshed.rebase_step.step_signature) {
+            return { outcome: 'paused', status: nextStatus };
+        }
+        return rejectRebaseAction('rejected', getGitErrorMessage(continueError) || 'Git could not continue the current rebase step.', nextStatus);
+    }
+    if (nextStatus.operation_state === 'rebase') {
+        return { outcome: 'paused', status: nextStatus };
+    }
+    finalizeRebaseWorktreeBase(cwd, targetBranch, project, baseBranch);
+    return { outcome: 'completed', status: getRebaseActionStatus(cwd, targetBranch, project) };
+};
+export const skipGitRebaseStep = async (cwd, targetBranch, project, expectedStepSignature, branch) => {
+    const status = getRebaseActionStatus(cwd, targetBranch ?? branch, project);
+    if (status.operation_state !== 'rebase' || !status.rebase_step || !targetBranch || branch !== targetBranch) {
+        return rejectRebaseAction('stale_step', 'The active rebase target changed. Refresh and try again.', status);
+    }
+    if (expectedStepSignature !== status.rebase_step.step_signature) {
+        return rejectRebaseAction('stale_step', 'The rebase step or index changed. Review the refreshed status and try again.', status);
+    }
+    const baseBranch = status.rebase_step.base_branch;
+    try {
+        await runGitTextAsync(['rebase', '--skip'], cwd, { env: { GIT_EDITOR: 'true', GIT_SEQUENCE_EDITOR: 'true' } });
+    }
+    catch (error) {
+        const nextStatus = getRebaseActionStatus(cwd, targetBranch, project);
+        if (nextStatus.operation_state === 'rebase' && nextStatus.rebase_step?.step_signature !== status.rebase_step.step_signature) {
+            return { outcome: 'paused', status: nextStatus };
+        }
+        return rejectRebaseAction('rejected', getGitErrorMessage(error) || 'Git could not skip the current rebase step.', nextStatus);
+    }
+    const nextStatus = getRebaseActionStatus(cwd, targetBranch, project);
+    if (nextStatus.operation_state === 'rebase') {
+        return { outcome: 'paused', status: nextStatus };
+    }
+    finalizeRebaseWorktreeBase(cwd, targetBranch, project, baseBranch);
+    return { outcome: 'completed', status: getRebaseActionStatus(cwd, targetBranch, project) };
+};
 export const abortGitOperation = async (cwd) => {
     const operationState = getGitOperationState(cwd);
     if (operationState === 'merge') {
@@ -1646,14 +2118,17 @@ const getRebaseDisabledReason = (status, baseBranch = status.base_branch) => {
 const applyGitActionState = (status, options) => {
     const operationState = getGitOperationState(options.cwd);
     const baseBranch = resolveTargetBaseBranch(options.branch, options.project, options.recordedBase ?? null);
+    const rebaseStep = operationState === 'rebase' ? getRebaseStepStatus(options.cwd, baseBranch) : null;
     const nextStatus = {
         ...status,
+        branch: status.branch ?? options.branch,
         operation_state: operationState,
         can_abort: operationState !== 'idle',
         can_force_push_with_lease: status.has_upstream && status.ahead > 0 && status.behind > 0 && operationState === 'idle',
         base_branch: baseBranch,
         pull_disabled_reason: null,
         rebase_disabled_reason: null,
+        ...(rebaseStep ? { rebase_step: rebaseStep, base_branch: rebaseStep.base_branch } : {}),
     };
     return {
         ...nextStatus,
@@ -1868,6 +2343,7 @@ export const getGitStatusAsync = async (cwd, branch = null, project = null, opti
         const baseBranch = effectiveBase?.baseBranch && effectiveBase.baseBranch !== resolvedBranch
             ? effectiveBase.baseBranch
             : null;
+        const rebaseStep = operationState === 'rebase' ? getRebaseStepStatus(cwd, baseBranch) : null;
         const workspaceSignature = options.includeWorkspaceSignature === false
             ? null
             : await getWorkspaceSignatureAsync(output, cwd, parsedOutput.parsedEntries);
@@ -1879,9 +2355,10 @@ export const getGitStatusAsync = async (cwd, branch = null, project = null, opti
             operation_state: operationState,
             can_abort: operationState !== 'idle',
             can_force_push_with_lease: branchState.hasUpstream && branchState.ahead > 0 && branchState.behind > 0 && operationState === 'idle',
-            base_branch: baseBranch,
+            base_branch: rebaseStep?.base_branch ?? baseBranch,
             pull_disabled_reason: null,
             rebase_disabled_reason: null,
+            ...(rebaseStep ? { rebase_step: rebaseStep } : {}),
             workspace_signature: workspaceSignature,
             is_dirty: parsedOutput.parsedEntries.length > 0,
             has_staged_changes: parsedOutput.parsedEntries.some(entry => entry.staged),