guito 1.0.4 → 1.0.6

package/bin/guito-server.js

@@ -14,6 +14,7 @@ import { promisify } from 'node:util';
 import { workingTree } from './working-tree.js';
 import { avatarCache } from './avatars.js';
 import { repositoryState } from './repository-state.js';
+import { createAiReviewer, resolveAiReviewConfig, } from './ai-review.js';
 const execFileAsync = promisify(execFile);
 const AZURE_API_VERSION = '5.0-preview';
 export const DEFAULT_PR_BRANCH_NAME_TEMPLATE = 'pr/${randomstring}';
@@ -235,7 +236,7 @@ const azureErrorMessage = (result) => {
         return result.body;
     }
 };
-export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 8080, apiToken, azureDevOpsUrl, prBranchNameTemplate, autoReload, diffViewer, showGraph, showStashes, showTags, showRemoteBranches, issueRegex, issueUrl, allowMerge, fileListView, refListView, sidePanelSectionsExpanded, searchMode, searchCaseSensitive, azureRequestImpl, avatarFetchImpl, onLog, }) {
+export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 8080, apiToken, azureDevOpsUrl, prBranchNameTemplate, autoReload, diffViewer, showGraph, showStashes, showTags, showRemoteBranches, issueRegex, issueUrl, allowMerge, fileListView, refListView, sidePanelSectionsExpanded, searchMode, searchCaseSensitive, aiReview, azureRequestImpl, aiReviewModelImpl, avatarFetchImpl, onLog, }) {
     // Initialize server
     const app = fastify({
         logger: false,
@@ -401,18 +402,99 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
         mutationQueue = result.catch(() => { });
         return result;
     };
+    // ==================== Mutation option helpers ====================
+    // Shared guards for the option fields the Git operation dialogs send.
+    // Every value is allowlisted before it reaches a Git argument array.
+    /** Reads a trimmed string body field; non-strings become ''. */
+    const strField = (value) => (typeof value === 'string' ? value.trim() : '');
+    /** Reads a boolean body field; only an explicit true enables the option. */
+    const boolField = (value) => value === true;
+    /** Sends `{ success: true }`, adding warnings for partially-failed composites. */
+    const mutationResult = (resp, warnings) => resp.type('application/json').send({
+        success: true,
+        ...(warnings.length ? { warnings } : {}),
+    });
+    /**
+     * Resolves the remote a remote-capable action should use: an explicit name
+     * (which must be configured), else "origin", else the first remote.
+     */
+    const resolveRemote = async (requested) => {
+        const names = (await git.raw(['remote']))
+            .split(/\r?\n/)
+            .map((name) => name.trim())
+            .filter(Boolean);
+        if (names.length === 0)
+            throw new Error('No remotes are configured for this repository.');
+        if (requested) {
+            if (!names.includes(requested))
+                throw new Error(`Remote "${requested}" is not configured.`);
+            return requested;
+        }
+        return names.includes('origin') ? 'origin' : names[0];
+    };
+    /** Verifies a branch name Git would accept, before it is used as an argument. */
+    const verifyBranchName = async (name) => {
+        await git.raw(['check-ref-format', '--branch', name]);
+    };
+    /** Verifies a tag name Git would accept (rejects "", "..", "~", "^", ":"...). */
+    const verifyTagName = async (name) => {
+        await git.raw(['check-ref-format', `refs/tags/${name}`]);
+    };
+    /** Parent hashes of a commit, used for merge-commit mainline validation. */
+    const commitParents = async (commit) => {
+        const raw = await git.raw(['rev-list', '--parents', '-n', '1', commit]);
+        return raw.trim().split(/\s+/).slice(1).filter(Boolean);
+    };
+    /** Validates a mainline parent selection for a merge commit. */
+    const mainlineArg = (mainline, parents) => {
+        const parsed = Number(mainline);
+        if (!Number.isInteger(parsed) || parsed < 1 || parsed > parents.length) {
+            throw new Error(`Choose a mainline parent between 1 and ${parents.length}.`);
+        }
+        return String(parsed);
+    };
+    /** Rejects tracked changes that would block a history-rewriting operation. */
+    const requireCleanWorktree = async () => {
+        const status = await git.raw(['status', '--porcelain']);
+        const dirty = status
+            .split(/\r?\n/)
+            .filter(Boolean)
+            .filter((line) => !line.startsWith('??'));
+        if (dirty.length > 0) {
+            throw new Error('The working tree has uncommitted changes. Commit or stash them first.');
+        }
+    };
+    /** Requires HEAD to sit on a branch (not detached), returning its name. */
+    const currentBranch = async () => {
+        // simple-git may swallow the non-zero exit of a detached symbolic-ref, so
+        // parse the output instead of relying on the rejection.
+        let head = '';
+        try {
+            head = await git.raw(['symbolic-ref', '--quiet', 'HEAD']);
+        }
+        catch {
+            head = '';
+        }
+        const branch = head.trim().replace(/^refs\/heads\//, '');
+        if (!branch)
+            throw new Error('HEAD is detached. Check out a branch first.');
+        return branch;
+    };
     const repoRoot = async () => (await git.revparse(['--show-toplevel'])).trim();
     // ==================== Azure DevOps settings ====================
     // Settings live in the repository's git directory so they are per-repo and
     // never committed. The VS Code extension passes its own setting via
     // azureDevOpsUrl, which wins over the file.
     let settingsPath = '';
+    let reviewStorePath = '';
     try {
         const gitDir = (await git.revparse(['--absolute-git-dir'])).trim();
         settingsPath = join(gitDir, 'guito-settings.json');
+        reviewStorePath = join(gitDir, 'guito-ai-reviews.json');
     }
     catch {
         settingsPath = join(repositoryPath, '.git', 'guito-settings.json');
+        reviewStorePath = join(repositoryPath, '.git', 'guito-ai-reviews.json');
     }
     const readSettings = async () => {
         try {
@@ -643,6 +725,7 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
                 ? searchCaseSensitive
                 : (fileSearchCaseSensitive ?? false),
             allowMerge: typeof allowMerge === 'boolean' ? allowMerge : (fileAllowMerge ?? true),
+            aiReview: resolveAiReviewConfig(file.aiReview, aiReview),
             issueLinking,
         };
     };
@@ -794,9 +877,25 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
     });
     app.post('/api/revert', async (req, resp) => {
         try {
-            const { commit } = req.body;
-            await git.revert(commit);
-            return resp.type('application/json').send({ success: true });
+            const hash = strField(req.body?.commit);
+            if (!hash)
+                throw new Error('A commit is required.');
+            const noCommit = boolField(req.body?.noCommit);
+            const signoff = boolField(req.body?.signoff);
+            await mutate(async () => {
+                const parents = await commitParents(hash);
+                const args = ['revert'];
+                // Merge commits must pick the parent the changes are reverted against.
+                if (parents.length > 1)
+                    args.push('--mainline', mainlineArg(req.body?.mainline, parents));
+                if (noCommit)
+                    args.push('--no-commit');
+                if (signoff)
+                    args.push('--signoff');
+                args.push(hash);
+                await git.raw(args);
+            });
+            return mutationResult(resp, []);
         }
         catch (err) {
             return resp.status(400).type('application/json').send({ error: err.message });
@@ -804,8 +903,28 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
     });
     app.post('/api/cherry-pick', async (req, resp) => {
         try {
-            await git.raw(['cherry-pick', req.body.commit]);
-            return resp.type('application/json').send({ success: true });
+            const hash = strField(req.body?.commit);
+            if (!hash)
+                throw new Error('A commit is required.');
+            const noCommit = boolField(req.body?.noCommit);
+            const recordSource = boolField(req.body?.recordSource);
+            const signoff = boolField(req.body?.signoff);
+            await mutate(async () => {
+                const parents = await commitParents(hash);
+                const args = ['cherry-pick'];
+                // Merge commits must pick the parent the changes are picked against.
+                if (parents.length > 1)
+                    args.push('--mainline', mainlineArg(req.body?.mainline, parents));
+                if (noCommit)
+                    args.push('--no-commit');
+                if (recordSource)
+                    args.push('-x');
+                if (signoff)
+                    args.push('--signoff');
+                args.push(hash);
+                await git.raw(args);
+            });
+            return mutationResult(resp, []);
         }
         catch (err) {
             return resp.status(400).type('application/json').send({ error: err.message });
@@ -813,8 +932,32 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
     });
     app.post('/api/commit/drop', async (req, resp) => {
         try {
-            await git.raw(['reset', '--hard', `${req.body.commit}^`]);
-            return resp.type('application/json').send({ success: true });
+            const hash = strField(req.body?.commit);
+            if (!hash)
+                throw new Error('A commit is required.');
+            await mutate(async () => {
+                // Dropping rewrites history: only a clean, branch-bound working tree
+                // can safely replay the descendants of the selected commit.
+                await currentBranch();
+                await requireCleanWorktree();
+                const parents = await commitParents(hash);
+                if (parents.length === 0)
+                    throw new Error('The root commit cannot be dropped.');
+                if (parents.length > 1)
+                    throw new Error('Merge commits cannot be dropped.');
+                // The commit must be part of the current branch's history: when it is
+                // an ancestor of HEAD, it is also the merge base of the two.
+                const base = (await git.raw(['merge-base', hash, 'HEAD'])).trim();
+                if (base !== hash) {
+                    throw new Error('The commit is not reachable from the current branch.');
+                }
+                // Replay every descendant onto the dropped commit's parent, removing
+                // only the selected commit (a hard reset would lose the descendants).
+                // Rebase by branch name: rebasing HEAD detaches it instead of moving
+                // the branch ref.
+                await git.raw(['rebase', '--onto', `${hash}~1`, hash, await currentBranch()]);
+            });
+            return mutationResult(resp, []);
         }
         catch (err) {
             return resp.status(400).type('application/json').send({ error: err.message });
@@ -822,9 +965,12 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
     });
     app.post('/api/reset-commit', async (req, resp) => {
         try {
+            const hash = strField(req.body?.commit);
+            if (!hash)
+                throw new Error('A commit is required.');
             const mode = ['soft', 'mixed', 'hard'].includes(req.body?.mode) ? req.body.mode : 'hard';
-            await git.raw(['reset', `--${mode}`, req.body.commit]);
-            return resp.type('application/json').send({ success: true });
+            await mutate(() => git.raw(['reset', `--${mode}`, hash]));
+            return mutationResult(resp, []);
         }
         catch (err) {
             return resp.status(400).type('application/json').send({ error: err.message });
@@ -905,9 +1051,36 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
     });
     app.post('/api/branch/create', async (req, resp) => {
         try {
-            const { name, startPoint } = req.body;
-            await git.branch([...(startPoint ? [name, startPoint] : [name])]);
-            return resp.type('application/json').send({ success: true });
+            const name = strField(req.body?.name);
+            if (!name)
+                throw new Error('A branch name is required.');
+            await verifyBranchName(name);
+            const startPoint = strField(req.body?.startPoint);
+            const checkout = boolField(req.body?.checkout);
+            const warnings = [];
+            await mutate(async () => {
+                // Resolve the remote up front so a bad configuration fails before any
+                // local branch is created.
+                const publishRemote = boolField(req.body?.publish)
+                    ? await resolveRemote(strField(req.body?.remote))
+                    : '';
+                if (checkout) {
+                    await git.raw(['checkout', '-b', name, ...(startPoint ? [startPoint] : [])]);
+                }
+                else {
+                    await git.branch([...(startPoint ? [name, startPoint] : [name])]);
+                }
+                // Publishing is a follow-up step: keep the created branch when it fails.
+                if (publishRemote) {
+                    try {
+                        await git.push(['-u', publishRemote, name]);
+                    }
+                    catch (err) {
+                        warnings.push(`Branch "${name}" was created but could not be published to "${publishRemote}": ${err.message}`);
+                    }
+                }
+            });
+            return mutationResult(resp, warnings);
         }
         catch (err) {
             return resp.status(400).type('application/json').send({ error: err.message });
@@ -915,9 +1088,29 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
     });
     app.post('/api/branch/delete', async (req, resp) => {
         try {
-            const { name, force } = req.body;
-            await git.deleteLocalBranch(name, force);
-            return resp.type('application/json').send({ success: true });
+            const name = strField(req.body?.name);
+            if (!name)
+                throw new Error('A branch name is required.');
+            const force = boolField(req.body?.force);
+            const warnings = [];
+            await mutate(async () => {
+                // Resolve the remote up front so a bad configuration fails before the
+                // local branch is deleted.
+                const deleteRemote = boolField(req.body?.deleteRemote)
+                    ? await resolveRemote(strField(req.body?.remote))
+                    : '';
+                await git.deleteLocalBranch(name, force);
+                // Deleting on the remote is a follow-up: keep the local deletion when it fails.
+                if (deleteRemote) {
+                    try {
+                        await git.push([deleteRemote, '--delete', `refs/heads/${name}`]);
+                    }
+                    catch (err) {
+                        warnings.push(`Branch "${name}" was deleted locally but could not be deleted on "${deleteRemote}": ${err.message}`);
+                    }
+                }
+            });
+            return mutationResult(resp, warnings);
         }
         catch (err) {
             return resp.status(400).type('application/json').send({ error: err.message });
@@ -925,9 +1118,13 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
     });
     app.post('/api/branch/delete-remote', async (req, resp) => {
         try {
-            const { remote, branch } = req.body;
-            await git.push([remote, '--delete', branch]);
-            return resp.type('application/json').send({ success: true });
+            const remote = strField(req.body?.remote);
+            const branch = strField(req.body?.branch);
+            if (!remote || !branch)
+                throw new Error('A remote and branch are required.');
+            const resolved = await resolveRemote(remote);
+            await mutate(() => git.push([resolved, '--delete', `refs/heads/${branch}`]));
+            return mutationResult(resp, []);
         }
         catch (err) {
             return resp.status(400).type('application/json').send({ error: err.message });
@@ -935,9 +1132,41 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
     });
     app.post('/api/branch/rename', async (req, resp) => {
         try {
-            const { oldName, newName } = req.body;
-            await git.branch(['-m', oldName, newName]);
-            return resp.type('application/json').send({ success: true });
+            const oldName = strField(req.body?.oldName);
+            const newName = strField(req.body?.newName);
+            if (!oldName || !newName)
+                throw new Error('The current and new branch names are required.');
+            await verifyBranchName(newName);
+            const publish = boolField(req.body?.publish);
+            const deleteOld = boolField(req.body?.deleteRemoteOld);
+            const warnings = [];
+            await mutate(async () => {
+                // Resolve the remote up front so a bad configuration fails before the
+                // branch is renamed.
+                const needsRemote = publish || deleteOld;
+                const remote = needsRemote ? await resolveRemote(strField(req.body?.remote)) : '';
+                await git.branch(['-m', oldName, newName]);
+                // Publishing/deleting the old ref are follow-ups: keep the rename when they fail.
+                if (remote) {
+                    if (publish) {
+                        try {
+                            await git.push(['-u', remote, newName]);
+                        }
+                        catch (err) {
+                            warnings.push(`Branch "${newName}" was renamed but could not be published to "${remote}": ${err.message}`);
+                        }
+                    }
+                    if (deleteOld) {
+                        try {
+                            await git.push([remote, '--delete', `refs/heads/${oldName}`]);
+                        }
+                        catch (err) {
+                            warnings.push(`The old branch "${oldName}" was renamed locally but could not be deleted on "${remote}": ${err.message}`);
+                        }
+                    }
+                }
+            });
+            return mutationResult(resp, warnings);
         }
         catch (err) {
             return resp.status(400).type('application/json').send({ error: err.message });
@@ -1039,9 +1268,44 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
     });
     app.post('/api/checkout', async (req, resp) => {
         try {
-            const { ref } = req.body;
-            await git.checkout(ref);
-            return resp.type('application/json').send({ success: true });
+            const ref = strField(req.body?.ref);
+            if (!ref)
+                throw new Error('A ref is required.');
+            const newBranch = strField(req.body?.newBranch);
+            const detach = boolField(req.body?.detach);
+            const track = boolField(req.body?.track);
+            const warnings = [];
+            await mutate(async () => {
+                // Resolve the remote up front so a bad configuration fails before the
+                // checkout happens.
+                const publishRemote = newBranch && boolField(req.body?.publish)
+                    ? await resolveRemote(strField(req.body?.remote))
+                    : '';
+                if (newBranch) {
+                    await verifyBranchName(newBranch);
+                    // --track sets the upstream when checking out a remote-tracking ref.
+                    await git.raw([
+                        'checkout',
+                        '-b',
+                        newBranch,
+                        ...(track ? ['--track'] : []),
+                        ref,
+                    ]);
+                }
+                else {
+                    await git.raw(['checkout', ...(detach ? ['--detach'] : []), ref]);
+                }
+                // Publishing the new branch is a follow-up: keep the checkout when it fails.
+                if (publishRemote) {
+                    try {
+                        await git.push(['-u', publishRemote, newBranch]);
+                    }
+                    catch (err) {
+                        warnings.push(`Branch "${newBranch}" was checked out but could not be published to "${publishRemote}": ${err.message}`);
+                    }
+                }
+            });
+            return mutationResult(resp, warnings);
         }
         catch (err) {
             return resp.status(400).type('application/json').send({ error: err.message });
@@ -1050,9 +1314,28 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
     // ==================== Merge & Rebase ====================
     app.post('/api/merge', async (req, resp) => {
         try {
-            const { branch } = req.body;
-            await git.merge([branch]);
-            return resp.type('application/json').send({ success: true });
+            const branch = strField(req.body?.branch);
+            if (!branch)
+                throw new Error('A branch or commit is required.');
+            const mode = ['default', 'no-ff', 'ff-only', 'squash'].includes(req.body?.mode)
+                ? req.body.mode
+                : 'default';
+            // --no-commit only applies to modes that would create a commit.
+            const noCommit = boolField(req.body?.noCommit) && (mode === 'default' || mode === 'no-ff');
+            const args = ['merge'];
+            if (mode === 'no-ff')
+                args.push('--no-ff');
+            if (mode === 'ff-only')
+                args.push('--ff-only');
+            if (mode === 'squash')
+                args.push('--squash');
+            if (noCommit)
+                args.push('--no-commit');
+            if (boolField(req.body?.autostash))
+                args.push('--autostash');
+            args.push(branch);
+            await mutate(() => git.raw(args));
+            return mutationResult(resp, []);
         }
         catch (err) {
             return resp.status(400).type('application/json').send({ error: err.message });
@@ -1080,9 +1363,18 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
     });
     app.post('/api/rebase', async (req, resp) => {
         try {
-            const { branch } = req.body;
-            await git.rebase([branch]);
-            return resp.type('application/json').send({ success: true });
+            const branch = strField(req.body?.branch);
+            if (!branch)
+                throw new Error('A branch or commit is required.');
+            await mutate(() => git.raw([
+                'rebase',
+                ...(boolField(req.body?.autostash) ? ['--autostash'] : []),
+                // --preserve-merges was removed in Git 2.35+; --rebase-merges is the
+                // supported way to keep merge commits while rebasing.
+                ...(boolField(req.body?.preserveMerges) ? ['--rebase-merges'] : []),
+                branch,
+            ]));
+            return mutationResult(resp, []);
         }
         catch (err) {
             return resp.status(400).type('application/json').send({ error: err.message });
@@ -1131,23 +1423,24 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
     });
     app.post('/api/stash/save', async (req, resp) => {
         try {
-            const { message, scope } = req.body ?? {};
+            const message = strField(req.body?.message);
+            const scope = ['staged', 'unstaged', 'all'].includes(req.body?.scope) ? req.body.scope : 'all';
             // 'staged' → index only (--staged, git ≥ 2.35); 'unstaged' → working tree only
             // (--keep-index leaves staged changes staged); 'all' → index + working tree.
-            // Untracked files ride along for 'all'/'unstaged' since the panel lists them as unstaged.
+            // Untracked files ride along unless includeUntracked opts out (the legacy
+            // callers kept them for 'all'/'unstaged', which stay the defaults).
+            const includeUntracked = typeof req.body?.includeUntracked === 'boolean' ? req.body.includeUntracked : scope !== 'staged';
             const args = ['push'];
-            if (scope === 'staged') {
+            if (scope === 'staged')
                 args.push('--staged');
-            }
-            else {
-                if (scope === 'unstaged')
-                    args.push('--keep-index');
+            if (scope === 'unstaged')
+                args.push('--keep-index');
+            if (includeUntracked)
                 args.push('-u');
-            }
             if (message)
                 args.push('-m', message);
-            await git.stash(args);
-            return resp.type('application/json').send({ success: true });
+            await mutate(() => git.stash(args));
+            return mutationResult(resp, []);
         }
         catch (err) {
             return resp.status(400).type('application/json').send({ error: err.message });
@@ -1155,9 +1448,13 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
     });
     app.post('/api/stash/apply', async (req, resp) => {
         try {
-            const { index } = req.body;
-            await git.stash(['apply', `stash@{${index}}`]);
-            return resp.type('application/json').send({ success: true });
+            const index = Number(req.body?.index);
+            if (!Number.isInteger(index) || index < 0)
+                throw new Error('A stash index is required.');
+            // --index restores the staged/unstaged split recorded by the stash.
+            const args = ['apply', ...(boolField(req.body?.restoreIndex) ? ['--index'] : []), `stash@{${index}}`];
+            await mutate(() => git.stash(args));
+            return mutationResult(resp, []);
         }
         catch (err) {
             return resp.status(400).type('application/json').send({ error: err.message });
@@ -1165,9 +1462,12 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
     });
     app.post('/api/stash/pop', async (req, resp) => {
         try {
-            const { index } = req.body;
-            await git.stash(['pop', `stash@{${index}}`]);
-            return resp.type('application/json').send({ success: true });
+            const index = Number(req.body?.index);
+            if (!Number.isInteger(index) || index < 0)
+                throw new Error('A stash index is required.');
+            const args = ['pop', ...(boolField(req.body?.restoreIndex) ? ['--index'] : []), `stash@{${index}}`];
+            await mutate(() => git.stash(args));
+            return mutationResult(resp, []);
         }
         catch (err) {
             return resp.status(400).type('application/json').send({ error: err.message });
@@ -1176,8 +1476,8 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
     app.post('/api/stash/drop', async (req, resp) => {
         try {
             const { index } = req.body;
-            await git.stash(['drop', `stash@{${index}}`]);
-            return resp.type('application/json').send({ success: true });
+            await mutate(() => git.stash(['drop', `stash@{${index}}`]));
+            return mutationResult(resp, []);
         }
         catch (err) {
             return resp.status(400).type('application/json').send({ error: err.message });
@@ -1217,14 +1517,41 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
     });
     app.post('/api/tag/create', async (req, resp) => {
         try {
-            const { name, message, commit } = req.body;
-            if (message) {
-                await git.tag(['-a', name, '-m', message, ...(commit ? [commit] : [])]);
-            }
-            else {
-                await git.tag([name, ...(commit ? [commit] : [])]);
-            }
-            return resp.type('application/json').send({ success: true });
+            const name = strField(req.body?.name);
+            if (!name)
+                throw new Error('A tag name is required.');
+            await verifyTagName(name);
+            const message = strField(req.body?.message);
+            // A message always produces an annotated tag (legacy callers relied on it);
+            // the dialog sends annotate explicitly and must then include a message.
+            const annotate = boolField(req.body?.annotate) || !!message;
+            if (annotate && !message)
+                throw new Error('An annotated tag requires a message.');
+            const commit = strField(req.body?.commit);
+            const warnings = [];
+            await mutate(async () => {
+                // Resolve the remote up front so a bad configuration fails before the
+                // tag is created.
+                const pushRemote = boolField(req.body?.push)
+                    ? await resolveRemote(strField(req.body?.remote))
+                    : '';
+                if (annotate) {
+                    await git.tag(['-a', name, '-m', message, ...(commit ? [commit] : [])]);
+                }
+                else {
+                    await git.tag([name, ...(commit ? [commit] : [])]);
+                }
+                // Pushing is a follow-up: keep the created tag when it fails.
+                if (pushRemote) {
+                    try {
+                        await git.push([pushRemote, `refs/tags/${name}`]);
+                    }
+                    catch (err) {
+                        warnings.push(`Tag "${name}" was created but could not be pushed to "${pushRemote}": ${err.message}`);
+                    }
+                }
+            });
+            return mutationResult(resp, warnings);
         }
         catch (err) {
             return resp.status(400).type('application/json').send({ error: err.message });
@@ -1232,9 +1559,28 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
     });
     app.post('/api/tag/delete', async (req, resp) => {
         try {
-            const { name } = req.body;
-            await git.tag(['-d', name]);
-            return resp.type('application/json').send({ success: true });
+            const name = strField(req.body?.name);
+            if (!name)
+                throw new Error('A tag name is required.');
+            const warnings = [];
+            await mutate(async () => {
+                // Resolve the remote up front so a bad configuration fails before the
+                // local tag is deleted.
+                const deleteRemote = boolField(req.body?.deleteRemote)
+                    ? await resolveRemote(strField(req.body?.remote))
+                    : '';
+                await git.tag(['-d', name]);
+                // Deleting on the remote is a follow-up: keep the local deletion when it fails.
+                if (deleteRemote) {
+                    try {
+                        await git.push([deleteRemote, '--delete', `refs/tags/${name}`]);
+                    }
+                    catch (err) {
+                        warnings.push(`Tag "${name}" was deleted locally but could not be deleted on "${deleteRemote}": ${err.message}`);
+                    }
+                }
+            });
+            return mutationResult(resp, warnings);
         }
         catch (err) {
             return resp.status(400).type('application/json').send({ error: err.message });
@@ -1242,12 +1588,12 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
     });
     app.post('/api/tag/push', async (req, resp) => {
         try {
-            const { name, remote } = req.body;
-            if (!name) {
-                return resp.status(400).type('application/json').send({ error: 'name required' });
-            }
-            await git.push(remote || 'origin', `refs/tags/${name}`);
-            return resp.type('application/json').send({ success: true });
+            const name = strField(req.body?.name);
+            if (!name)
+                throw new Error('A tag name is required.');
+            const remote = await resolveRemote(strField(req.body?.remote));
+            await mutate(() => git.push([remote, ...(boolField(req.body?.force) ? ['-f'] : []), `refs/tags/${name}`]));
+            return mutationResult(resp, []);
         }
         catch (err) {
             return resp.status(400).type('application/json').send({ error: err.message });
@@ -1266,9 +1612,20 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
     });
     app.post('/api/pull', async (req, resp) => {
         try {
-            const { remote, branch, rebase } = req.body;
-            await git.pull(remote || 'origin', branch || undefined, rebase ? { '--rebase': null } : {});
-            return resp.type('application/json').send({ success: true });
+            const remote = strField(req.body?.remote);
+            const branch = strField(req.body?.branch);
+            // 'mode' supersedes the legacy 'rebase' boolean (kept for older callers).
+            const mode = ['merge', 'rebase', 'ff-only'].includes(req.body?.mode) ? req.body.mode : 'merge';
+            const rebase = boolField(req.body?.rebase) || mode === 'rebase';
+            const ffOnly = mode === 'ff-only';
+            // An explicit remote must be configured; without one, keep the legacy
+            // 'origin' default so upstream-based pulls keep working.
+            const resolvedRemote = remote ? await resolveRemote(remote) : 'origin';
+            await mutate(() => git.pull(resolvedRemote, branch || undefined, {
+                ...(rebase ? { '--rebase': null } : {}),
+                ...(ffOnly ? { '--ff-only': null } : {}),
+            }));
+            return mutationResult(resp, []);
         }
         catch (err) {
             return resp.status(400).type('application/json').send({ error: err.message });
@@ -1466,6 +1823,11 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
             if (typeof body.allowMerge === 'boolean') {
                 settings.allowMerge = body.allowMerge;
             }
+            if (body.aiReview && typeof body.aiReview === 'object') {
+                // Only the keys the user actually sent are stored, so a VS Code
+                // override stays in charge of everything else.
+                settings.aiReview = resolveAiReviewConfig(settings.aiReview, body.aiReview);
+            }
             if ('issueLinking' in body) {
                 if (body.issueLinking === null) {
                     if (body.issueLinkingGlobal) {
@@ -1509,6 +1871,7 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
             }
             await writeSettings(settings);
             const effective = await effectiveSettings();
+            await refreshAiReviewConfig();
             return resp.type('application/json').send(effective);
         }
         catch (err) {
@@ -1838,9 +2201,9 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
     });
     // Pull requests the current user created or reviews ("mine"), merged and
     // de-duplicated. Status defaults to active.
-    app.get('/api/azure-devops/pullrequests', async (req, resp) => {
-        try {
-            const status = String(req.query?.status ?? 'active').trim() || 'active';
+    /** Pull requests the current user created or is a reviewer on. */
+    const azurePrList = async (status) => {
+        {
             const { prefix, remoteUrl } = await azureProjectContext();
             const repo = parseAzureRemoteUrl(remoteUrl).repo;
             const me = await azureMe();
@@ -1868,18 +2231,32 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
                 collect(`reviewerId=${encodeURIComponent(me.id)}`),
             ]);
             const merged = new Map([...created, ...assigned]);
-            const pullRequests = [...merged.values()]
-                .map((request) => mapAzurePullRequest(request, prefix, remoteUrl, me))
+            return [...merged.values()]
+                .map((request) => ({
+                ...mapAzurePullRequest(request, prefix, remoteUrl, me),
+                description: String(request?.description ?? ''),
+                isMine: String(request?.createdBy?.id ?? '') === me.id,
+                isReviewer: (Array.isArray(request?.reviewers) ? request.reviewers : []).some((entry) => String(entry?.id ?? '') === me.id),
+                sourceCommit: String(request?.lastMergeSourceCommit?.commitId ?? ''),
+                targetCommit: String(request?.lastMergeTargetCommit?.commitId ?? ''),
+            }))
                 .sort((a, b) => String(b.createdAt).localeCompare(String(a.createdAt)));
+        }
+    };
+    app.get('/api/azure-devops/pullrequests', async (req, resp) => {
+        try {
+            const status = String(req.query?.status ?? 'active').trim() || 'active';
+            const pullRequests = await azurePrList(status);
             return resp.type('application/json').send({ pullRequests });
         }
         catch (err) {
             return resp.status(400).type('application/json').send({ error: err.message });
         }
     });
-    app.get('/api/azure-devops/pullrequests/:id', async (req, resp) => {
-        try {
-            const { base, prefix, remoteUrl } = await azurePrApiBase(Number(req.params?.id));
+    /** Full detail of one pull request, as the dialog and the reviewer see it. */
+    const azurePrDetail = async (id) => {
+        {
+            const { base, prefix, remoteUrl } = await azurePrApiBase(id);
             const [pr, me] = await Promise.all([
                 azureJson('GET', `${base}?api-version=${AZURE_API_VERSION}`),
                 azureMe(),
@@ -1902,9 +2279,11 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
                     .map((label) => String(label?.name ?? ''))
                     .filter(Boolean);
             }
-            return resp.type('application/json').send({
+            return {
                 ...summary,
                 description: String(pr?.description ?? ''),
+                isMine: String(pr?.createdBy?.id ?? '') === me.id,
+                isReviewer: (Array.isArray(pr?.reviewers) ? pr.reviewers : []).some((entry) => String(entry?.id ?? '') === me.id),
                 autoCompleteSetBy: pr?.autoCompleteSetBy
                     ? {
                         id: String(pr.autoCompleteSetBy.id ?? ''),
@@ -1916,7 +2295,12 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
                 lastMergeTargetCommit: String(pr?.lastMergeTargetCommit?.commitId ?? ''),
                 labels,
                 mergeStatus: azureMergeStatus(pr),
-            });
+            };
+        }
+    };
+    app.get('/api/azure-devops/pullrequests/:id', async (req, resp) => {
+        try {
+            return resp.type('application/json').send(await azurePrDetail(Number(req.params?.id)));
         }
         catch (err) {
             return resp.status(400).type('application/json').send({ error: err.message });
@@ -2068,11 +2452,12 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
             return resp.status(400).type('application/json').send({ error: err.message });
         }
     });
-    app.get('/api/azure-devops/pullrequests/:id/threads', async (req, resp) => {
-        try {
-            const { base } = await azurePrApiBase(Number(req.params?.id));
+    /** Comment threads on a pull request, normalized for the UI and reviewer. */
+    const azurePrThreads = async (id) => {
+        {
+            const { base } = await azurePrApiBase(id);
             const data = await azureJson('GET', `${base}/threads?api-version=${AZURE_API_VERSION}`);
-            const threads = (Array.isArray(data?.value) ? data.value : [])
+            return (Array.isArray(data?.value) ? data.value : [])
                 .filter((thread) => thread?.isDeleted !== true)
                 .map((thread) => {
                 const context = thread?.threadContext ?? {};
@@ -2098,6 +2483,11 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
                     })),
                 };
             });
+        }
+    };
+    app.get('/api/azure-devops/pullrequests/:id/threads', async (req, resp) => {
+        try {
+            const threads = await azurePrThreads(Number(req.params?.id));
             return resp.type('application/json').send({ threads });
         }
         catch (err) {
@@ -2106,27 +2496,31 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
     });
     // Adds a comment: a reply to a thread, a general PR comment, or an inline
     // comment anchored to a file line (thread context).
-    app.post('/api/azure-devops/pullrequests/:id/threads', async (req, resp) => {
-        try {
-            const content = String(req.body?.content ?? '').trim();
+    /**
+     * Adds a comment: a reply to a thread, a general pull request comment, or an
+     * inline comment anchored to a file line. Returns the thread it landed in.
+     */
+    const azurePrComment = async (id, body) => {
+        {
+            const content = String(body?.content ?? '').trim();
             if (!content) {
-                return resp.status(400).type('application/json').send({ error: 'Comment text required.' });
+                throw new Error('Comment text required.');
             }
-            const { base } = await azurePrApiBase(Number(req.params?.id));
-            const threadId = Number(req.body?.threadId ?? 0);
+            const { base } = await azurePrApiBase(id);
+            const threadId = Number(body?.threadId ?? 0);
             if (Number.isInteger(threadId) && threadId > 0) {
                 await azureJson('POST', `${base}/threads/${threadId}/comments?api-version=${AZURE_API_VERSION}`, JSON.stringify({ content }));
-                return resp.type('application/json').send({ ok: true });
+                return { threadId };
             }
             const payload = {
                 status: AZURE_THREAD_STATUSES.active,
                 comments: [{ content, parentCommentId: 0 }],
             };
-            const filePath = String(req.body?.filePath ?? '').trim();
-            const line = Number(req.body?.line ?? 0);
-            const requestedEndLine = Number(req.body?.endLine ?? line);
+            const filePath = String(body?.filePath ?? '').trim();
+            const line = Number(body?.line ?? 0);
+            const requestedEndLine = Number(body?.endLine ?? line);
             const endLine = Number.isInteger(requestedEndLine) && requestedEndLine >= line ? requestedEndLine : line;
-            const left = req.body?.side === 'left';
+            const left = body?.side === 'left';
             if (filePath && Number.isInteger(line) && line > 0) {
                 // Azure anchors a whole-line comment from offset 1 to "end of line".
                 payload.threadContext = {
@@ -2138,8 +2532,14 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
                     },
                 };
             }
-            await azureJson('POST', `${base}/threads?api-version=${AZURE_API_VERSION}`, JSON.stringify(payload));
-            return resp.type('application/json').send({ ok: true });
+            const created = await azureJson('POST', `${base}/threads?api-version=${AZURE_API_VERSION}`, JSON.stringify(payload));
+            return { threadId: Number(created?.id ?? 0) };
+        }
+    };
+    app.post('/api/azure-devops/pullrequests/:id/threads', async (req, resp) => {
+        try {
+            const created = await azurePrComment(Number(req.params?.id), req.body ?? {});
+            return resp.type('application/json').send({ ok: true, ...created });
         }
         catch (err) {
             return resp.status(400).type('application/json').send({ error: err.message });
@@ -2165,17 +2565,31 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
     });
     // Changed files of the latest PR iteration (names and change types only;
     // content is fetched per file on demand by /file-diff).
-    app.get('/api/azure-devops/pullrequests/:id/changes', async (req, resp) => {
-        try {
-            const { base } = await azurePrApiBase(Number(req.params?.id));
+    /**
+     * Changed files of the latest pull request iteration. With sinceCommit, only
+     * the files touched after the iteration that ended at that commit, which is
+     * how a re-review looks at nothing but the new work.
+     */
+    const azurePrChangedFiles = async (id, sinceCommit = '') => {
+        {
+            const { base } = await azurePrApiBase(id);
             const iterations = await azureJson('GET', `${base}/iterations?api-version=${AZURE_API_VERSION}`);
             const list = Array.isArray(iterations?.value) ? iterations.value : [];
             const latest = list.length
                 ? list.reduce((newest, entry) => String(entry?.createdDate ?? '') > String(newest?.createdDate ?? '') ? entry : newest)
                 : null;
             if (!latest) {
-                return resp.type('application/json').send({ files: [] });
+                return [];
             }
+            // Azure compares iterations, not commits, so map the commit onto the
+            // iteration that produced it; an unknown commit falls back to the
+            // full change list rather than silently reviewing nothing.
+            const baseIteration = sinceCommit
+                ? list.find((entry) => String(entry?.sourceRefCommit?.commitId ?? '') === sinceCommit)
+                : null;
+            const compareTo = baseIteration && Number(baseIteration.id) !== Number(latest.id)
+                ? `&$compareTo=${Number(baseIteration.id)}`
+                : '';
             const changeStatus = {
                 add: 'added',
                 edit: 'modified',
@@ -2190,7 +2604,8 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
             const entries = [];
             let skip = 0;
             for (;;) {
-                const data = await azureJson('GET', `${base}/iterations/${latest.id}/changes?$top=1000&$skip=${skip}&api-version=${AZURE_API_VERSION}`);
+                const data = await azureJson('GET', `${base}/iterations/${latest.id}/changes?$top=1000&$skip=${skip}${compareTo}` +
+                    `&api-version=${AZURE_API_VERSION}`);
                 const page = Array.isArray(data?.changeEntries)
                     ? data.changeEntries
                     : Array.isArray(data?.value)
@@ -2208,7 +2623,7 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
                 }
                 break;
             }
-            const files = entries
+            return entries
                 .filter((entry) => entry?.item?.isFolder !== true)
                 .map((entry) => {
                 const path = String(entry?.item?.path ?? '').replace(/^\//, '');
@@ -2219,6 +2634,11 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
                 return { path, oldPath, changeType };
             })
                 .filter((file) => Boolean(file.path));
+        }
+    };
+    app.get('/api/azure-devops/pullrequests/:id/changes', async (req, resp) => {
+        try {
+            const files = await azurePrChangedFiles(Number(req.params?.id), String(req.query?.since ?? ''));
             return resp.type('application/json').send({ files });
         }
         catch (err) {
@@ -2585,16 +3005,17 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
     // Unified diff of one PR file, computed from the Azure item contents at the
     // PR merge commits. source/target are optional overrides; default comes from
     // the pull request detail.
-    app.get('/api/azure-devops/pullrequests/:id/file-diff', async (req, resp) => {
-        try {
-            const path = String(req.query?.path ?? '').replace(/^\//, '');
+    /** One file's diff between the pull request's merge source and target. */
+    const azurePrFileDiff = async (id, query) => {
+        {
+            const path = String(query?.path ?? '').replace(/^\//, '');
             if (!path) {
-                return resp.status(400).type('application/json').send({ error: 'path required' });
+                throw new Error('path required');
             }
-            const oldPath = String(req.query?.oldPath ?? '').replace(/^\//, '');
-            const { base, prefix, repo } = await azurePrApiBase(Number(req.params?.id));
-            let source = String(req.query?.source ?? '');
-            let target = String(req.query?.target ?? '');
+            const oldPath = String(query?.oldPath ?? '').replace(/^\//, '');
+            const { base, prefix, repo } = await azurePrApiBase(id);
+            let source = String(query?.source ?? '');
+            let target = String(query?.target ?? '');
             if (!source || !target) {
                 const pr = await azureJson('GET', `${base}?api-version=${AZURE_API_VERSION}`);
                 source = source || String(pr?.lastMergeSourceCommit?.commitId ?? '');
@@ -2645,7 +3066,7 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
                 fetchContent(path, source),
             ]);
             if (oldFile.binary || newFile.binary) {
-                return resp.type('application/json').send({
+                return {
                     path,
                     oldPath,
                     status: 'binary',
@@ -2653,9 +3074,9 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
                     additions: 0,
                     deletions: 0,
                     lines: [],
-                });
+                };
             }
-            const status = String(req.query?.changeType ?? '') ||
+            const status = String(query?.changeType ?? '') ||
                 (!oldFile.content ? 'added' : !newFile.content ? 'deleted' : 'modified');
             // jsdiff omits the "diff --git" header parseUnifiedDiff expects, and
             // prefixing it lets the same parser serve both local and PR diffs.
@@ -2671,7 +3092,7 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
                     text: 'Diff truncated (file too large).',
                 });
             }
-            return resp.type('application/json').send({
+            return {
                 path,
                 oldPath,
                 status,
@@ -2681,7 +3102,169 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
                 originalContent: oldFile.content,
                 modifiedContent: newFile.content,
                 lines,
+            };
+        }
+    };
+    app.get('/api/azure-devops/pullrequests/:id/file-diff', async (req, resp) => {
+        try {
+            const diff = await azurePrFileDiff(Number(req.params?.id), req.query ?? {});
+            return resp.type('application/json').send(diff);
+        }
+        catch (err) {
+            return resp.status(400).type('application/json').send({ error: err.message });
+        }
+    });
+    // ==================== Automated pull request review ====================
+    // The poller watches the pull requests the user cares about and hands each
+    // new merge source commit to the Claude Code CLI installed on this machine.
+    // Findings are queued locally; posting them to Azure DevOps stays manual.
+    const readReviewStore = async () => {
+        try {
+            const store = JSON.parse(await readFile(reviewStorePath, 'utf8'));
+            return { version: 1, pullRequests: store?.pullRequests ?? {} };
+        }
+        catch {
+            return { version: 1, pullRequests: {} };
+        }
+    };
+    const aiReviewer = createAiReviewer({
+        listPullRequests: async () => (await azurePrList('active')).map((pr) => ({
+            id: pr.id,
+            title: pr.title,
+            description: pr.description,
+            author: pr.author.name,
+            sourceBranch: pr.sourceBranch,
+            targetBranch: pr.targetBranch,
+            isDraft: pr.isDraft,
+            isReviewer: pr.isReviewer,
+            isMine: pr.isMine,
+            sourceCommit: pr.sourceCommit,
+            targetCommit: pr.targetCommit,
+        })),
+        loadPullRequest: async (id) => {
+            const pr = await azurePrDetail(id);
+            return {
+                id: pr.id,
+                title: pr.title,
+                description: pr.description,
+                author: pr.author.name,
+                sourceBranch: pr.sourceBranch,
+                targetBranch: pr.targetBranch,
+                isDraft: pr.isDraft,
+                isReviewer: pr.isReviewer,
+                isMine: pr.isMine,
+                sourceCommit: pr.lastMergeSourceCommit,
+                targetCommit: pr.lastMergeTargetCommit,
+            };
+        },
+        loadChanges: (id, sinceCommit) => azurePrChangedFiles(id, sinceCommit ?? ''),
+        loadFileDiff: async (id, file) => {
+            const diff = await azurePrFileDiff(id, {
+                path: file.path,
+                oldPath: file.oldPath,
+                changeType: file.changeType,
+            });
+            return {
+                path: diff.path,
+                oldPath: diff.oldPath,
+                status: diff.status,
+                binary: diff.binary,
+                lines: diff.lines,
+            };
+        },
+        loadThreads: async (id) => (await azurePrThreads(id)).map((thread) => ({
+            id: thread.id,
+            status: thread.status,
+            filePath: thread.filePath,
+            line: thread.line,
+            comments: thread.comments,
+        })),
+        postComment: (id, comment) => azurePrComment(id, comment),
+        readStore: readReviewStore,
+        writeStore: (store) => writeFile(reviewStorePath, JSON.stringify(store, null, 2) + '\n', 'utf8'),
+        runModel: aiReviewModelImpl,
+        log: (line) => onLog?.(line),
+    }, resolveAiReviewConfig(aiReview), repositoryPath);
+    /** Re-reads the settings file so file-level review settings take effect. */
+    const refreshAiReviewConfig = async () => {
+        const file = await readSettings();
+        const config = resolveAiReviewConfig(file.aiReview, aiReview);
+        aiReviewer.updateConfig(config);
+        return config;
+    };
+    await refreshAiReviewConfig();
+    aiReviewer.start();
+    app.get('/api/azure-devops/ai-review', async (_req, resp) => {
+        try {
+            const overview = await aiReviewer.overview();
+            return resp.type('application/json').send({ ...overview, config: aiReviewer.config() });
+        }
+        catch (err) {
+            return resp.status(400).type('application/json').send({ error: err.message });
+        }
+    });
+    // Runs one poll pass immediately instead of waiting for the interval.
+    app.post('/api/azure-devops/ai-review/poll', async (_req, resp) => {
+        try {
+            const reviewed = await aiReviewer.poll();
+            return resp.type('application/json').send({ reviewed });
+        }
+        catch (err) {
+            return resp.status(400).type('application/json').send({ error: err.message });
+        }
+    });
+    app.get('/api/azure-devops/pullrequests/:id/ai-review', async (req, resp) => {
+        try {
+            const state = await aiReviewer.state(Number(req.params?.id));
+            return resp.type('application/json').send({ state });
+        }
+        catch (err) {
+            return resp.status(400).type('application/json').send({ error: err.message });
+        }
+    });
+    // Reviews the pull request now; "force" re-reviews the whole diff even when
+    // the merge source commit has not moved.
+    app.post('/api/azure-devops/pullrequests/:id/ai-review', async (req, resp) => {
+        try {
+            const state = await aiReviewer.review(Number(req.params?.id), {
+                force: req.body?.force === true,
             });
+            if (state.status === 'error') {
+                return resp.status(400).type('application/json').send({ error: state.error, state });
+            }
+            return resp.type('application/json').send({ state });
+        }
+        catch (err) {
+            return resp.status(400).type('application/json').send({ error: err.message });
+        }
+    });
+    // Posts the selected findings to Azure DevOps as comment threads.
+    app.post('/api/azure-devops/pullrequests/:id/ai-review/post', async (req, resp) => {
+        try {
+            const findingIds = (Array.isArray(req.body?.findingIds) ? req.body.findingIds : []).map((id) => String(id));
+            const state = await aiReviewer.post(Number(req.params?.id), findingIds);
+            return resp.type('application/json').send({ state });
+        }
+        catch (err) {
+            return resp.status(400).type('application/json').send({ error: err.message });
+        }
+    });
+    // Dismisses findings; a dismissed point is never raised again for this PR.
+    app.post('/api/azure-devops/pullrequests/:id/ai-review/dismiss', async (req, resp) => {
+        try {
+            const findingIds = (Array.isArray(req.body?.findingIds) ? req.body.findingIds : []).map((id) => String(id));
+            const state = await aiReviewer.dismiss(Number(req.params?.id), findingIds);
+            return resp.type('application/json').send({ state });
+        }
+        catch (err) {
+            return resp.status(400).type('application/json').send({ error: err.message });
+        }
+    });
+    // Drops everything remembered about a pull request, including dismissals.
+    app.delete('/api/azure-devops/pullrequests/:id/ai-review', async (req, resp) => {
+        try {
+            await aiReviewer.forget(Number(req.params?.id));
+            return resp.type('application/json').send({ ok: true });
         }
         catch (err) {
             return resp.status(400).type('application/json').send({ error: err.message });
@@ -2858,8 +3441,8 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
     // ==================== Working Tree Actions ====================
     app.post('/api/reset', async (_req, resp) => {
         try {
-            await git.raw(['reset', '--hard', 'HEAD']);
-            return resp.type('application/json').send({ ok: true });
+            await mutate(() => git.raw(['reset', '--hard', 'HEAD']));
+            return mutationResult(resp, []);
         }
         catch (err) {
             return resp.status(400).type('application/json').send({ error: err.message });
@@ -2867,8 +3450,8 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
     });
     app.post('/api/clean', async (_req, resp) => {
         try {
-            await git.raw(['clean', '-fd']);
-            return resp.type('application/json').send({ ok: true });
+            await mutate(() => git.raw(['clean', '-fd']));
+            return mutationResult(resp, []);
         }
         catch (err) {
             return resp.status(400).type('application/json').send({ error: err.message });
@@ -2877,7 +3460,11 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
     const address = await app.listen({ port, ...(host ? { host } : {}) });
     return {
         address,
-        close: () => app.close(),
+        aiReview: aiReviewer,
+        close: async () => {
+            aiReviewer.stop();
+            await app.close();
+        },
         updateSettings: (settings) => {
             azureDevOpsUrl = settings.azureDevOpsUrl;
             prBranchNameTemplate = settings.prBranchNameTemplate;
@@ -2894,6 +3481,8 @@ export async function startGuitoServer({ repositoryPath, uiRoot, host, port = 80
             issueRegex = settings.issueRegex;
             issueUrl = settings.issueUrl;
             allowMerge = settings.allowMerge;
+            aiReview = settings.aiReview;
+            void refreshAiReviewConfig();
         },
     };
 }