dsh-easygit-plugin 0.2.3 → 0.3.0

package/lib/index.js

@@ -424,6 +424,14 @@ async function dispatchRepositoryAction(action, sessionId, body, context, depend
   if (!context) return { ok: false, code: "SESSION_NOT_FOUND", message: "\u65E0\u6CD5\u786E\u5B9A\u5F53\u524D\u4F1A\u8BDD\u7684\u4ED3\u5E93\u76EE\u5F55" };
   const repository = dependencies.repository;
   const base = { sessionId, workdir: context.workdir, operationId: body.operationId, sandboxPolicy: context.policy };
+  if (action === "get-commit-edit-state") return repository.conflictAction(action, context.workdir, body, void 0, context.policy);
+  if (action === "amend-message" || action === "amend-commit" || action === "undo-commit" || action === "revert-commit") {
+    return repository.conflictAction(action, context.workdir, body, base);
+  }
+  if (action === "get-conflicts" || action === "get-conflict" || action === "get-merge-preview") return repository.conflictAction(action, context.workdir, body, void 0, context.policy);
+  if (action === "save-conflict" || action === "resolve-conflict" || action === "start-operation" || action === "finish-operation" || action === "merge-branch") {
+    return repository.conflictAction(action, context.workdir, body, base);
+  }
   if (action === "get-summary") return repository.getSummary(context.workdir, void 0, context.policy);
   if (action === "get-diff") return repository.getDiff(context.workdir, body.path, body.staged === true, void 0, context.policy);
   if (action === "get-branches") return repository.getBranches(context.workdir, void 0, context.policy);
@@ -431,6 +439,12 @@ async function dispatchRepositoryAction(action, sessionId, body, context, depend
   if (action === "get-commit-detail") return repository.getCommitDetail(context.workdir, body.hash, void 0, context.policy);
   if (action === "get-commit-diff") return repository.getCommitDiff(context.workdir, body.hash, void 0, context.policy);
   if (action === "get-stashes") return repository.getStashes(context.workdir, void 0, context.policy);
+  if (action === "get-stash-detail") return repository.getStashDetail(context.workdir, body.selector, body.hash, void 0, context.policy);
+  if (action === "get-stash-diff") return repository.getStashDiff(context.workdir, body.selector, body.hash, body.path, body.untracked === true, void 0, context.policy);
+  if (action === "create-stash") return repository.createStash(base, body.message, body.paths, body.includeUntracked === true);
+  if (action === "apply-stash" || action === "pop-stash" || action === "drop-stash" || action === "branch-stash") {
+    return repository.mutateStash(base, action, body.selector, body.hash, body.name, body.confirmRisk === true);
+  }
   if (action === "get-sync-state") return repository.getSyncState(context.workdir, void 0, context.policy);
   if (action === "stage-paths") return repository.stagePaths(base, body.paths);
   if (action === "unstage-paths") return repository.unstagePaths(base, body.paths);
@@ -517,7 +531,7 @@ async function dispatchProposalAction(action, sessionId, body, dependencies) {
     const result = await dependencies.executeProposal(
       dependencies.shell,
       proposal,
-      dependencies.resolveExecutionPolicy(sessionId),
+      await dependencies.resolveExecutionPolicy(sessionId),
       () => dependencies.flushProposal(sessionId)
     );
     console.log("easygit HTTP execute", proposal.proposalId, "ok=", result.ok);
@@ -525,12 +539,21 @@ async function dispatchProposalAction(action, sessionId, body, dependencies) {
   }
   return { status: 400, data: { ok: false, error: "unknown action: " + action } };
 }
-function registerEasyGitActions(webServer, dependencies) {
+function registerEasyGitActions(webServer, dependencies, connection) {
   if (!webServer) return void 0;
   return webServer.register({
     kind: "prefix",
     path: "/easygit",
     handler: async (req, res) => {
+      if (!connection) {
+        sendJson(res, 503, { ok: false, error: "connection service unavailable" });
+        return;
+      }
+      const rejection = connection.requestRejection(req);
+      if (rejection !== void 0) {
+        sendJson(res, rejection, { ok: false, error: rejection === 401 ? "unauthorized" : "forbidden" });
+        return;
+      }
       if (req.method !== "POST") {
         sendJson(res, 405, { ok: false, error: "method not allowed" });
         return;
@@ -565,7 +588,7 @@ function registerEasyGitActions(webServer, dependencies) {
       try {
         await dependencies.proposalStorageReady;
         if (isRepositoryAction(action)) {
-          const context = dependencies.repositoryContext(sessionId);
+          const context = await dependencies.repositoryContext(sessionId);
           const result = await dispatchRepositoryAction(action, sessionId, body, context, dependencies);
           sendJson(res, 200, await attachRepositoryRecovery(action, sessionId, body, result, context, dependencies));
           return;
@@ -585,6 +608,19 @@ var init_actions = __esm({
     "use strict";
     init_command_policy();
     REPOSITORY_ACTIONS = [
+      "get-commit-edit-state",
+      "amend-message",
+      "amend-commit",
+      "undo-commit",
+      "revert-commit",
+      "get-merge-preview",
+      "merge-branch",
+      "get-conflicts",
+      "get-conflict",
+      "save-conflict",
+      "resolve-conflict",
+      "start-operation",
+      "finish-operation",
       "get-summary",
       "get-diff",
       "get-branches",
@@ -592,6 +628,13 @@ var init_actions = __esm({
       "get-commit-detail",
       "get-commit-diff",
       "get-stashes",
+      "get-stash-detail",
+      "get-stash-diff",
+      "create-stash",
+      "apply-stash",
+      "pop-stash",
+      "drop-stash",
+      "branch-stash",
       "get-sync-state",
       "stage-paths",
       "unstage-paths",
@@ -772,7 +815,416 @@ var init_proposal_service = __esm({
   }
 });
 
+// src/host/conflict-worker.ts
+function conflictWorkerCommand(action, payload) {
+  const data = { ...payload };
+  if (typeof data.content === "string") {
+    data.contentBase64 = Buffer.from(data.content).toString("base64");
+    delete data.content;
+  }
+  return quoteShellArg(process.execPath) + " -e " + quoteShellArg(worker) + " " + quoteShellArg(Buffer.from(JSON.stringify({ ...data, action })).toString("base64"));
+}
+var worker;
+var init_conflict_worker = __esm({
+  "src/host/conflict-worker.ts"() {
+    "use strict";
+    init_command_policy();
+    worker = String.raw`
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { execFileSync } = require('node:child_process');
+const input = JSON.parse(Buffer.from(process.argv[1], 'base64').toString('utf8'));
+const LIMIT = 48 * 1024;
+const fail = (message, code = 'STATE_CONFLICT') => { throw Object.assign(new Error(message), { code }); };
+const git = (...args) => execFileSync('git', args, { encoding: 'utf8', maxBuffer: 8 * 1024 * 1024, stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env, GIT_TERMINAL_PROMPT: '0', GIT_EDITOR: 'true', GIT_SEQUENCE_EDITOR: 'true' } });
+const hash = value => crypto.createHash('sha256').update(value).digest('hex');
+const exists = file => fs.existsSync(file);
+const gitPath = name => git('rev-parse', '--git-path', name).trim();
+function squashState() {
+  const file = gitPath('easygit-squash.json');
+  if (!exists(file) || !exists(gitPath('SQUASH_MSG'))) return null;
+  const saved = JSON.parse(fs.readFileSync(file, 'utf8'));
+  // A commit or branch switch outside the workbench ends our ownership.
+  if (saved.head !== git('rev-parse', 'HEAD').trim() || saved.branch !== 'refs/heads/' + git('branch', '--show-current').trim()) return null;
+  return saved;
+}
+function operationState() {
+  const dir = name => git('rev-parse', '--git-path', name).trim();
+  const names = ['rebase-merge', 'rebase-apply', 'MERGE_HEAD', 'CHERRY_PICK_HEAD', 'sequencer', 'REVERT_HEAD'];
+  const paths = names.map(dir);
+  const squash = squashState();
+  const todo = exists(path.join(paths[4], 'todo')) ? fs.readFileSync(path.join(paths[4], 'todo'), 'utf8') : '';
+  const operation = exists(paths[0]) || exists(paths[1]) ? 'rebase' : exists(paths[2]) ? 'merge' : exists(paths[3]) || /^pick /m.test(todo) ? 'cherry-pick' : exists(paths[5]) || /^revert /m.test(todo) ? 'revert' : squash ? 'merge' : null;
+  const meta = ['HEAD', 'MERGE_HEAD', 'CHERRY_PICK_HEAD', 'REVERT_HEAD', 'rebase-merge/head-name', 'rebase-merge/onto', 'rebase-merge/msgnum', 'rebase-merge/stopped-sha', 'rebase-apply/next', 'rebase-apply/orig-head', 'sequencer/todo'].map(name => {
+    const file = dir(name); return exists(file) ? fs.readFileSync(file).toString('base64') : '';
+  });
+  let head;
+  try { head = git('rev-parse', '--verify', 'HEAD').trim(); }
+  catch (error) {
+    const branch = git('symbolic-ref', '--quiet', 'HEAD').trim();
+    if (exists(dir(branch))) throw error;
+    head = 'unborn:' + branch;
+  }
+  return { operation, ...(squash && operation === 'merge' ? { mergeMode: 'squash' } : {}), operationToken: hash(JSON.stringify([operation, meta, head, squash])) };
+}
+function mergeSnapshot() {
+  if (typeof input.target !== 'string' || !/^refs\/(heads|remotes)\/.+/.test(input.target) || /[\0\r\n]/.test(input.target)) fail('请选择本地或远程源分支', 'INVALID_ARGUMENT');
+  git('check-ref-format', input.target);
+  const name = git('branch', '--show-current').trim();
+  if (!name) fail('分离 HEAD 状态不能合并分支，请先切换到本地分支');
+  const branch = 'refs/heads/' + name;
+  if (branch === input.target) fail('不能将当前分支合并到自身');
+  const head = git('rev-parse', '--verify', 'HEAD').trim();
+  const sourceHead = git('rev-parse', '--verify', '--end-of-options', input.target + '^{commit}').trim();
+  return { branch: branch.slice('refs/heads/'.length), target: input.target, head, sourceHead, token: hash(JSON.stringify([branch, input.target, head, sourceHead])) };
+}
+function ancestor(a, b) {
+  try { git('merge-base', '--is-ancestor', a, b); return true; }
+  catch (error) { if (error.status === 1) return false; throw error; }
+}
+function previewMerge() {
+  const snapshot = mergeSnapshot();
+  const { head, sourceHead } = snapshot;
+  let base;
+  try { base = git('merge-base', head, sourceHead).trim(); }
+  catch (error) { if (error.status === 1) fail('两个分支没有共同祖先，不支持合并无关历史'); throw error; }
+  const fields = git('log', '--no-color', '--max-count=201', '--format=%H%x00%s%x00%an%x00%aI%x00', head + '..' + sourceHead).split('\0');
+  const commits = [];
+  for (let i = 0; i + 3 < fields.length; i += 4) commits.push({ hash: fields[i].trim(), subject: fields[i + 1], author: fields[i + 2], date: fields[i + 3] });
+  const files = git('diff', '--name-only', '-z', base, sourceHead, '--').split('\0').filter(Boolean);
+  let diff, overflow = false;
+  try { diff = git('-c', 'core.quotePath=false', 'diff', '--no-ext-diff', '--no-textconv', '--no-color', base, sourceHead, '--'); }
+  catch (error) { if (error.code !== 'ENOBUFS') throw error; diff = String(error.stdout || ''); overflow = true; }
+  return { ...snapshot, base, canFastForward: ancestor(head, sourceHead), alreadyMerged: ancestor(sourceHead, head), commits: commits.slice(0, 200), commitsTruncated: commits.length > 200, files: files.slice(0, 500), filesTruncated: files.length > 500, diff: diff.slice(0, 180000), diffTruncated: overflow || diff.length > 180000 };
+}
+function entries() {
+  return git('ls-files', '--unmerged', '-z').split('\0').filter(Boolean).map(row => {
+    const match = /^(\d+) ([0-9a-f]+) ([123])\t([\s\S]*)$/.exec(row);
+    if (!match) fail('无法读取完整冲突索引');
+    return { mode: match[1], oid: match[2], stage: Number(match[3]), path: match[4] };
+  });
+}
+function state() {
+  const grouped = new Map();
+  for (const entry of entries()) {
+    if (!grouped.has(entry.path)) grouped.set(entry.path, []);
+    grouped.get(entry.path).push(entry.stage);
+  }
+  return { ...operationState(), files: [...grouped].map(([file, stages]) => ({ path: file, stages, kind: !stages.includes(1) ? '双方新增' : !stages.includes(2) || !stages.includes(3) ? '删除 / 修改' : '双方修改' })) };
+}
+function safePath(file) {
+  if (typeof file !== 'string' || !file || file.includes('\0') || path.isAbsolute(file) || file.split(/[\\/]/).some(part => part === '..' || part.toLowerCase() === '.git')) fail('无效的仓库相对路径', 'INVALID_ARGUMENT');
+  let current = process.cwd();
+  const parts = file.split('/');
+  for (let i = 0; i < parts.length; i++) {
+    current = path.join(current, parts[i]);
+    try {
+      const stat = fs.lstatSync(current);
+      if (stat.isSymbolicLink()) fail('符号链接冲突请在外部工具中处理');
+      if (i < parts.length - 1 && !stat.isDirectory()) fail('路径包含非目录节点');
+    } catch (error) { if (error.code !== 'ENOENT') throw error; }
+  }
+  return current;
+}
+function version(buffer, mode = null) {
+  if (buffer === null) return { exists: false, text: null, mode, reason: null };
+  const text = buffer.toString('utf8');
+  const reason = !['100644', '100755', null].includes(mode) ? '符号链接或子模块，请使用外部工具处理' : buffer.length > LIMIT ? '文件超过 48 KiB，请使用外部工具处理' : buffer.includes(0) || !Buffer.from(text).equals(buffer) ? '二进制或非 UTF-8 文件，可选择整份一方版本' : null;
+  return { exists: true, text: reason ? null : text, mode, reason };
+}
+function detail(file) {
+  const rows = entries().filter(row => row.path === file);
+  if (!rows.length) fail('该文件已不在冲突列表中，请刷新');
+  const full = safePath(file);
+  let working = null;
+  try {
+    const stat = fs.lstatSync(full);
+    if (!stat.isFile()) fail('目录、符号链接或子模块冲突请在外部工具中处理');
+    if (stat.size > 8 * 1024 * 1024) fail('文件过大，请使用外部工具处理');
+    working = fs.readFileSync(full);
+  } catch (error) { if (error.code !== 'ENOENT') throw error; }
+  const versions = [1, 2, 3].map(stage => {
+    const row = rows.find(row => row.stage === stage);
+    if (!row) return version(null);
+    if (!['100644', '100755'].includes(row.mode)) return { exists: true, text: null, mode: row.mode, reason: '符号链接或子模块，请使用外部工具处理' };
+    const size = Number(git('cat-file', '-s', row.oid).trim());
+    if (size > LIMIT) return { exists: true, text: null, mode: row.mode, reason: '文件超过 48 KiB，请使用外部工具处理' };
+    return version(execFileSync('git', ['cat-file', 'blob', row.oid], { maxBuffer: LIMIT + 1024 }), row.mode);
+  });
+  const op = operationState();
+  const squash = op.mergeMode === 'squash' ? squashState() : null;
+  for (const [index, ref] of [[1, 'HEAD'], [2, op.operation === 'merge' ? 'MERGE_HEAD' : op.operation === 'rebase' ? 'REBASE_HEAD' : op.operation === 'cherry-pick' ? 'CHERRY_PICK_HEAD' : null]]) {
+    const row = rows.find(row => row.stage === index + 1);
+    versions[index].source = row ? '索引 stage ' + (index + 1) + ' · blob ' + row.oid.slice(0, 12) : '该方无文件';
+    if (ref && op.operation) {
+      try { versions[index].source = ref + ' · ' + git('rev-parse', '--verify', ref + '^{commit}').trim().slice(0, 12); } catch {}
+    }
+    if (index === 2 && squash) versions[index].source = '压缩合并源 · ' + squash.sourceHead.slice(0, 12);
+  }
+  const result = version(working);
+  const attr = git('check-attr', '-z', 'conflict-marker-size', '--', file).split('\0')[2];
+  const markerSize = /^\d+$/.test(attr || '') ? Number(attr) : 7;
+  if (markerSize < 1 || markerSize > 1024) fail('冲突标记长度不受支持，请使用外部工具处理');
+  return { path: file, operation: op.operation, token: hash(JSON.stringify([rows, op.operationToken, working === null ? null : working.toString('base64')])), base: versions[0], ours: versions[1], theirs: versions[2], result, editable: versions.every(v => !v.reason) && !result.reason, special: !versions[1].exists || !versions[2].exists || versions.some(v => !!v.reason) || !!result.reason, markerSize };
+}
+function markers(text, size) {
+  return text.split(/\r?\n/).some(line => ['<', '|', '=', '>'].some(c =>
+    line.startsWith(c.repeat(size)) && (line.length === size || /^[ \t]/.test(line.slice(size)))
+  ));
+}
+function commitEditState() {
+  const head = git('rev-parse', '--verify', 'HEAD').trim();
+  const branch = git('branch', '--show-current').trim();
+  const op = operationState();
+  const index = git('ls-files', '--stage', '-z');
+  return {
+    head, branch, message: git('show', '-s', '--format=%B', head).replace(/\n$/, ''),
+    parents: git('show', '-s', '--format=%P', head).trim().split(' ').filter(Boolean),
+    staged: !!git('diff', '--cached', '--name-only', '-z'),
+    dirty: !!git('status', '--porcelain', '--untracked-files=all'),
+    blocked: !!op.operation || !!entries().length,
+    token: hash(JSON.stringify([head, branch, index, op.operationToken])),
+  };
+}
+function editCommit() {
+  if (input.confirmRisk !== true) fail('请先确认提交操作的影响', 'PERMISSION_DENIED');
+  const snapshot = commitEditState();
+  if (snapshot.blocked) fail('请先完成或中止当前 Git 操作并解决冲突');
+  if (!snapshot.branch) fail('请先切换到本地分支');
+  if (input.token !== snapshot.token) fail('分支、最近提交或暂存区已变化，请刷新后重新确认');
+  if (input.action === 'amend-message') {
+    if (typeof input.message !== 'string' || !input.message.trim() || Buffer.byteLength(input.message) > LIMIT || /[\0\r]/.test(input.message)) fail('提交说明必须是 48 KiB 以内的非空文本，不得包含 NUL 或回车', 'INVALID_ARGUMENT');
+    // --only without paths amends the message while preserving the real index.
+    git('commit', '--amend', '--only', '--allow-empty', '--cleanup=verbatim', '-m', input.message);
+  } else if (input.action === 'amend-commit') {
+    if (!snapshot.staged) fail('没有已暂存的改动，请先暂存需要补充的文件');
+    git('commit', '--amend', '--no-edit', '--cleanup=verbatim');
+  } else if (input.action === 'undo-commit') {
+    if (!snapshot.parents.length) fail('根提交没有父提交，无法执行保留暂存区的撤销');
+    git('reset', '--soft', snapshot.parents[0]);
+  } else {
+    if (snapshot.dirty) fail('Revert 前请先提交或贮藏工作区改动');
+    if (typeof input.hash !== 'string' || !/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i.test(input.hash)) fail('请选择完整的提交 SHA', 'INVALID_ARGUMENT');
+    if (!ancestor(input.hash, snapshot.head)) fail('目标提交不在当前分支历史中');
+    const parents = git('show', '-s', '--format=%P', input.hash).trim().split(' ').filter(Boolean);
+    if (parents.length > 1) {
+      if (!Number.isInteger(input.mainline) || input.mainline < 1 || input.mainline > parents.length) fail('Revert 合并提交前必须选择主线父提交', 'INVALID_ARGUMENT');
+    } else if (input.mainline !== undefined) fail('普通提交无需选择主线父提交', 'INVALID_ARGUMENT');
+    git('revert', '--no-edit', ...(parents.length > 1 ? ['-m', String(input.mainline)] : []), input.hash);
+  }
+  return state();
+}
+function main() {
+  process.chdir(git('rev-parse', '--show-toplevel').trim());
+  if (input.action === 'get-commit-edit-state') return commitEditState();
+  if (['amend-message', 'amend-commit', 'undo-commit', 'revert-commit'].includes(input.action)) return editCommit();
+  if (input.action === 'get-merge-preview') return previewMerge();
+  if (input.action === 'merge-branch') {
+    if (!['normal', 'ff-only', 'squash'].includes(input.mode)) fail('无效的合并方式', 'INVALID_ARGUMENT');
+    if (state().operation || entries().length) fail('请先完成或中止当前 Git 操作');
+    if (git('status', '--porcelain', '--untracked-files=all').trim()) fail('合并前请先提交或贮藏工作区改动');
+    const snapshot = mergeSnapshot();
+    if (snapshot.token !== input.token) fail('分支已变化，请重新预览后合并');
+    if (ancestor(snapshot.sourceHead, snapshot.head)) return state();
+    if (input.mode === 'squash') {
+      fs.writeFileSync(gitPath('easygit-squash.json'), JSON.stringify({ head: snapshot.head, branch: 'refs/heads/' + snapshot.branch, sourceHead: snapshot.sourceHead }));
+    }
+    // Explicit flags keep user merge.ff / branch mergeOptions from changing the selected mode.
+    try {
+      git('-c', 'merge.autoStash=false', 'merge', '--no-edit', '--no-autostash', '--no-overwrite-ignore', ...(input.mode === 'squash' ? ['--squash', '--ff', '--no-commit'] : input.mode === 'ff-only' ? ['--ff-only', '--no-squash', '--commit'] : ['--ff', '--no-squash', '--commit']), snapshot.sourceHead);
+    } catch (error) {
+      if (input.mode === 'squash' && !entries().length && !git('status', '--porcelain').trim()) fs.unlinkSync(gitPath('easygit-squash.json'));
+      throw error;
+    }
+    return state();
+  }
+  if (input.action === 'get-conflicts') return state();
+  if (input.action === 'get-conflict') return detail(input.path);
+  if (input.action === 'save-conflict' || input.action === 'resolve-conflict') {
+    const before = detail(input.path);
+    if (typeof input.token !== 'string' || input.token !== before.token) fail('文件或冲突状态已被外部修改，请刷新后重新处理');
+    const full = safePath(input.path);
+    if (input.action === 'save-conflict') {
+      if (!before.editable) fail('该文件不支持文本编辑');
+      const content = Buffer.from(input.contentBase64, 'base64');
+      if (content.length > LIMIT || content.includes(0)) fail('结果必须是 48 KiB 以内的 UTF-8 文本', 'INVALID_ARGUMENT');
+      const parent = path.dirname(full);
+      fs.mkdirSync(parent, { recursive: true });
+      const mode = exists(full) ? fs.statSync(full).mode : parseInt(before.ours.mode || before.theirs.mode || '100644', 8);
+      const temp = path.join(parent, '.easygit-' + crypto.randomUUID());
+      try {
+        fs.writeFileSync(temp, content, { flag: 'wx', mode });
+        if (detail(input.path).token !== before.token) fail('保存前文件发生变化，请刷新');
+        fs.renameSync(temp, full);
+      } finally { if (exists(temp)) fs.unlinkSync(temp); }
+      return detail(input.path);
+    }
+    if (!['result', 'ours', 'theirs', 'delete'].includes(input.choice)) fail('无效的解决方式', 'INVALID_ARGUMENT');
+    if (['ours', 'theirs'].includes(input.choice)) {
+      const selected = before[input.choice];
+      if (!selected.exists) fail('该方版本不存在，请明确选择删除文件');
+      if (selected.reason && !selected.reason.startsWith('二进制')) fail(selected.reason);
+      if (selected.text !== null && markers(selected.text, before.markerSize)) fail('所选版本仍包含冲突标记，请手动编辑');
+      git('checkout', '--' + input.choice, '--', ':(literal)' + input.path);
+    } else if (input.choice === 'delete') {
+      if (exists(full)) fs.unlinkSync(full);
+    } else {
+      if (before.result.text === null) fail('请明确选择一方、删除文件或在外部工具中处理');
+      if (markers(before.result.text, before.markerSize)) fail('结果中仍有冲突标记，请先逐块解决并保存');
+    }
+    git('add', '--', ':(literal)' + input.path);
+    return state();
+  }
+  if (input.action === 'start-operation') {
+    if (!['merge', 'rebase', 'cherry-pick'].includes(input.kind)) fail('不支持的 Git 操作', 'INVALID_ARGUMENT');
+    if (input.confirmRisk !== true) fail('请先确认 Git 操作风险', 'PERMISSION_DENIED');
+    if (state().operation || entries().length) fail('请先完成或中止当前 Git 操作');
+    if (git('status', '--porcelain').trim()) fail('请先提交或贮藏工作区改动');
+    if (typeof input.target !== 'string' || !input.target || input.target.startsWith('-') || /[\0\r\n]/.test(input.target)) fail('无效的目标引用', 'INVALID_ARGUMENT');
+    const oid = git('rev-parse', '--verify', '--end-of-options', input.target + '^{commit}').trim();
+    git(...(input.kind === 'merge' ? ['merge', '--no-edit', oid] : [input.kind, oid]));
+    return state();
+  }
+  if (input.action === 'finish-operation') {
+    const current = state();
+    if (input.confirmRisk !== true) fail('请先确认继续、中止或跳过的风险', 'PERMISSION_DENIED');
+    if (!current.operation || current.operation !== input.kind || current.operationToken !== input.token) fail('Git 操作状态已改变，请刷新');
+    if (!['continue', 'abort', 'skip'].includes(input.mode) || (input.mode === 'skip' && input.kind === 'merge')) fail('不支持的后续操作', 'INVALID_ARGUMENT');
+    if (input.mode === 'continue' && current.files.length) fail('仍有未标记解决的冲突文件');
+    if (current.mergeMode === 'squash') {
+      const saved = squashState();
+      if (input.mode === 'abort') git('reset', '--merge', saved.head);
+      else git('commit', '--no-edit', '-F', gitPath('SQUASH_MSG'));
+      fs.unlinkSync(gitPath('easygit-squash.json'));
+      if (exists(gitPath('SQUASH_MSG'))) fs.unlinkSync(gitPath('SQUASH_MSG'));
+    } else git(input.kind, '--' + input.mode);
+    return state();
+  }
+  fail('无效操作', 'INVALID_ARGUMENT');
+}
+try { console.log(JSON.stringify({ ok: true, data: main() })); }
+catch (error) {
+  let pending = null;
+  try { pending = state(); } catch {}
+  // A new conflict is an expected stop in a multi-step Git operation.
+  if ((input.action === 'start-operation' || input.action === 'merge-branch' || input.action === 'revert-commit' || (input.action === 'finish-operation' && input.mode !== 'abort')) && error.status && pending && pending.operation === (input.action === 'merge-branch' ? 'merge' : input.action === 'revert-commit' ? 'revert' : input.kind) && (pending.files.length || input.action === 'revert-commit')) {
+    console.log(JSON.stringify({ ok: true, data: pending }));
+  } else console.log(JSON.stringify({ ok: false, code: ['STATE_CONFLICT', 'INVALID_ARGUMENT', 'PERMISSION_DENIED'].includes(error.code) ? error.code : 'GIT_FAILED', message: error.status ? 'Git 操作未完成，请查看详情' : error.message, diagnostics: [error.stdout, error.stderr].filter(Boolean).map(value => value.toString()).join('\n') || undefined }));
+}
+`;
+  }
+});
+
+// src/host/stash-worker.ts
+function createStashCommand(message, paths, includeUntracked) {
+  const payload = Buffer.from(JSON.stringify({ message, paths, includeUntracked })).toString("base64");
+  return "node -e " + quoteShellArg(worker2) + " " + quoteShellArg(payload);
+}
+var worker2;
+var init_stash_worker = __esm({
+  "src/host/stash-worker.ts"() {
+    "use strict";
+    init_command_policy();
+    worker2 = String.raw`
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+const input = JSON.parse(Buffer.from(process.argv[1], 'base64').toString('utf8'));
+const env = { ...process.env };
+const literal = names => names.map(name => ':(literal)' + name);
+const git = (args, extra = {}) => execFileSync('git', args, { encoding: 'utf8', maxBuffer: 16 * 1024 * 1024, stdio: ['pipe', 'pipe', 'pipe'], env, ...extra });
+let temporary;
+try {
+  process.chdir(git(['rev-parse', '--show-toplevel']).trim());
+  const records = git(['status', '--porcelain=v1', '--untracked-files=all', '-z']).split('\0');
+  const changes = [];
+  for (let i = 0; i < records.length - 1; i++) {
+    const row = records[i];
+    const status = row.slice(0, 2);
+    const file = { path: row.slice(3), status };
+    if (/[RC]/.test(status)) file.originalPath = records[++i];
+    if (status.includes('U') || status === 'AA' || status === 'DD') throw new Error('请先解决冲突，再创建贮藏');
+    changes.push(file);
+  }
+  const eligible = changes.filter(file => input.includeUntracked || file.status !== '??');
+  const selected = input.paths ? [...new Set(input.paths)].flatMap(name => {
+    const files = eligible.filter(file => file.path === name);
+    if (!files.length) throw new Error('所选文件已变化或未启用包含未跟踪文件，请刷新：' + name);
+    return files;
+  }) : eligible;
+  if (!selected.length) throw new Error('没有可贮藏的改动');
+  const args = ['stash', 'push'];
+  if (input.includeUntracked) args.push('--include-untracked');
+  if (input.message.trim()) args.push('--message', input.message.trim());
+  if (!input.paths) {
+    git(args);
+  } else {
+    // Native path-limited stash also captures unrelated staged files, and
+    // staged deletions can fail during its cleanup. Build the standard stash
+    // trees in a temporary index, store them, then restore only selected paths.
+    const tracked = selected.filter(file => file.status !== '??');
+    const untracked = selected.filter(file => file.status === '??');
+    const paths = [...new Set(tracked.flatMap(file => file.originalPath && file.status.includes('R') ? [file.path, file.originalPath] : [file.path]))];
+    if (paths.some(name => changes.some(file => file.path === name && file.status === '??') && !untracked.some(file => file.path === name))) {
+      throw new Error('已删除或重命名的路径上存在未跟踪文件，请同时选择该文件并包含未跟踪文件');
+    }
+    temporary = fs.mkdtempSync(path.join(os.tmpdir(), 'easygit-stash-'));
+    const isolated = { ...env, GIT_INDEX_FILE: path.join(temporary, 'index') };
+    const base = git(['rev-parse', 'HEAD']).trim();
+    git(['read-tree', base], { env: isolated });
+    const intentPaths = tracked.filter(file => file.status === ' A').map(file => file.path);
+    if (paths.length) {
+      // Copy object IDs/modes directly; a textual diff can be altered by user
+      // color, prefix or whitespace settings. Missing entries represent deletes.
+      const entries = git(['ls-files', '--stage', '-z', '--', ...literal(paths)]).split('\0')
+        .filter(row => row && !intentPaths.includes(row.slice(row.indexOf('\t') + 1)));
+      const removed = paths.map(name => '0 ' + '0'.repeat(base.length) + '\t' + name);
+      git(['update-index', '-z', '--index-info'], { env: isolated, input: [...removed, ...entries].join('\0') + '\0' });
+    }
+    const indexTree = git(['write-tree'], { env: isolated }).trim();
+    if (intentPaths.length) git(['add', '--', ...literal(intentPaths)], { env: isolated });
+    // -u records tracked worktree edits/deletions without absorbing untracked files.
+    const indexed = git(['ls-files', '-z'], { env: isolated }).split('\0');
+    const workPaths = paths.filter(name => indexed.includes(name));
+    if (workPaths.length) git(['add', '-u', '--', ...literal(workPaths)], { env: isolated });
+    const workTree = git(['write-tree'], { env: isolated }).trim();
+    const indexCommit = git(['commit-tree', indexTree, '-p', base], { input: 'index for selected stash\n' }).trim();
+    const parents = ['-p', base, '-p', indexCommit];
+    if (untracked.length) {
+      git(['read-tree', '--empty'], { env: isolated });
+      git(['add', '--', ...literal(untracked.map(file => file.path))], { env: isolated });
+      const tree = git(['write-tree'], { env: isolated }).trim();
+      parents.push('-p', git(['commit-tree', tree], { input: 'untracked files for selected stash\n' }).trim());
+    }
+    const branch = git(['branch', '--show-current']).trim() || '(detached HEAD)';
+    const message = 'On ' + branch + ': ' + (input.message.trim() || 'selected changes');
+    const stash = git(['commit-tree', workTree, ...parents], { input: message + '\n' }).trim();
+    git(['stash', 'store', '--message', message, stash]);
+    // All selected versions are durable before changing the working files/index.
+    if (paths.length) git(['restore', '--source=' + base, '--staged', '--worktree', '--', ...literal(paths)]);
+    for (const file of untracked) {
+      // A recreated, previously tracked path has just been restored from HEAD.
+      if (!paths.includes(file.path)) fs.unlinkSync(file.path);
+    }
+  }
+  process.stdout.write(JSON.stringify({ ok: true }));
+} catch (error) {
+  process.stdout.write(JSON.stringify({ ok: false, code: 'GIT_FAILED', message: '创建贮藏失败；请刷新确认当前状态', diagnostics: String(error.stderr || error.message) }));
+} finally {
+  if (temporary) fs.rmSync(temporary, { recursive: true, force: true });
+}
+`;
+  }
+});
+
 // src/host/git-repository-service.ts
+async function runShell(shell, specification) {
+  if (shell.execute) return (await shell.execute(specification)).result();
+  if (shell.run) return shell.run(specification);
+  throw new Error("shell \u670D\u52A1\u4E0D\u652F\u6301\u6267\u884C\u547D\u4EE4");
+}
 function errorResult(code, message, diagnostics, reason) {
   return {
     ok: false,
@@ -791,13 +1243,17 @@ function mutationErrorCode(result) {
 }
 function parseStatus(status) {
   const files = [];
-  for (const line of status.split("\n")) {
-    if (!line || line.startsWith("## ") || line.length < 4) continue;
-    const indexStatus = line[0] ?? " ";
-    const workTreeStatus = line[1] ?? " ";
-    const rawPath = line.slice(3);
-    const renameAt = rawPath.indexOf(" -> ");
-    files.push(renameAt >= 0 ? { indexStatus, workTreeStatus, path: rawPath.slice(renameAt + 4), originalPath: rawPath.slice(0, renameAt) } : { indexStatus, workTreeStatus, path: rawPath });
+  const records = status.split("\0");
+  for (let index = 0; index < records.length - 1; index++) {
+    const record = records[index];
+    if (record.startsWith("## ") || record.length < 4) continue;
+    const indexStatus = record[0];
+    const workTreeStatus = record[1];
+    const path = record.slice(3);
+    if (/[RC]/.test(indexStatus + workTreeStatus)) {
+      if (index + 1 >= records.length - 1) break;
+      files.push({ indexStatus, workTreeStatus, path, originalPath: records[++index] });
+    } else files.push({ indexStatus, workTreeStatus, path });
   }
   return files;
 }
@@ -821,6 +1277,9 @@ function conflictCount(files) {
 function validCommitHash(hash) {
   return typeof hash === "string" && /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i.test(hash);
 }
+function validStashPath(path) {
+  return typeof path === "string" && path.length > 0 && path.length <= 4096 && !path.includes("\0") && !path.startsWith("/") && !/^[A-Za-z]:[\\/]/.test(path) && !path.split(/[\\/]/).some((part) => part === "..");
+}
 function parseCommitFiles(nameStatus, numstat) {
   const statusRows = nameStatus.split("\n").filter(Boolean);
   const statRows = numstat.split("\n").filter(Boolean);
@@ -859,10 +1318,12 @@ function parseCommitFiles(nameStatus, numstat) {
     totals: { files: statusRows.length, additions, deletions, binary }
   };
 }
-var MUTATION_OUTPUT_MAX_CHARS, DIFF_MAX_CHARS, COMMIT_DETAIL_MAX_CHARS, COMMIT_DIFF_MAX_CHARS, COMMIT_FILE_MAX, STASH_MAX, MAX_PATHS, OPERATION_TTL_MS, GitRepositoryService;
+var MUTATION_OUTPUT_MAX_CHARS, DIFF_MAX_CHARS, COMMIT_DETAIL_MAX_CHARS, COMMIT_DIFF_MAX_CHARS, COMMIT_FILE_MAX, STASH_MAX, MAX_PATHS, OPERATION_TTL_MS, repositoryLocks, GitRepositoryService;
 var init_git_repository_service = __esm({
   "src/host/git-repository-service.ts"() {
     "use strict";
+    init_conflict_worker();
+    init_stash_worker();
     init_command_policy();
     MUTATION_OUTPUT_MAX_CHARS = 1e5;
     DIFF_MAX_CHARS = 2e5;
@@ -872,17 +1333,18 @@ var init_git_repository_service = __esm({
     STASH_MAX = 100;
     MAX_PATHS = 100;
     OPERATION_TTL_MS = 24 * 60 * 60 * 1e3;
+    repositoryLocks = /* @__PURE__ */ new Map();
     GitRepositoryService = class {
       constructor(shell) {
         this.shell = shell;
       }
-      locks = /* @__PURE__ */ new Map();
+      locks = repositoryLocks;
       operations = /* @__PURE__ */ new Map();
       async run(workdir, command, timeoutMs = 2e4, stdoutMaxBytes = 3e4, signal, sandboxPolicy) {
         if (!this.shell) return { exitCode: -1, stderr: { text: "shell \u670D\u52A1\u4E0D\u53EF\u7528" } };
         try {
           const specification = this.shell.resolve({ command, workdir, timeoutMs, stdoutMaxBytes, signal, ...sandboxPolicy ? { sandboxPolicy } : {} });
-          return await this.shell.run(specification);
+          return await runShell(this.shell, specification);
         } catch (error) {
           return { exitCode: -1, stderr: { text: error instanceof Error ? error.message : String(error) } };
         }
@@ -901,13 +1363,14 @@ var init_git_repository_service = __esm({
         const [branchResult, headResult, statusResult] = await Promise.all([
           this.run(workdir, "git branch --show-current", 15e3, 4096, signal, sandboxPolicy),
           this.run(workdir, "git rev-parse --short HEAD", 15e3, 4096, signal, sandboxPolicy),
-          this.run(workdir, "git status --porcelain=v1 --branch --untracked-files=all", 15e3, 5e4, signal, sandboxPolicy)
+          this.run(workdir, "git status --porcelain=v1 --branch --untracked-files=all -z", 15e3, 5e4, signal, sandboxPolicy)
         ]);
         if (branchResult.exitCode !== 0 || headResult.exitCode !== 0 || statusResult.exitCode !== 0) {
           return errorResult("GIT_FAILED", "\u65E0\u6CD5\u8BFB\u53D6 Git \u4ED3\u5E93\u6458\u8981", redactAndLimit(outputOf(branchResult) + "\n" + outputOf(headResult) + "\n" + outputOf(statusResult), 8192));
         }
-        const status = redactAndLimit(statusResult.stdout?.text ?? "", 5e4);
-        const files = parseStatus(status);
+        const rawStatus = statusResult.stdout?.text ?? "";
+        const files = parseStatus(rawStatus);
+        const status = redactAndLimit(rawStatus.replace(/\0/g, "\n"), 5e4);
         return {
           ok: true,
           data: {
@@ -944,7 +1407,7 @@ var init_git_repository_service = __esm({
       async getBranches(workdir, signal, sandboxPolicy) {
         const topLevel = await this.getTopLevel(workdir, signal, sandboxPolicy);
         if (!topLevel.ok) return topLevel;
-        const branchFormat = "%(HEAD)%09%(refname:short)%09%(upstream:short)";
+        const branchFormat = "%(HEAD)%09%(refname:lstrip=2)%09%(upstream:short)";
         const referenceFormat = "%(refname)%09%(refname:short)%09%(objectname:short)%09%(*objectname:short)%09%(subject)";
         const [branchResult, referenceResult] = await Promise.all([
           this.run(workdir, "git branch --format=" + quoteShellArg(branchFormat), 15e3, 3e4, signal, sandboxPolicy),
@@ -962,7 +1425,9 @@ var init_git_repository_service = __esm({
         for (const line of (referenceResult.stdout?.text ?? "").split("\n").filter(Boolean)) {
           const [fullName = "", shortName = "", objectHash = "", peeledHash = "", subject = ""] = line.split("	");
           const entry = {
-            name: redactAndLimit(shortName, 512),
+            // Git's :short adds heads/ or remotes/ when references collide.
+            // The UI already distinguishes namespaces, so keep the actual name.
+            name: redactAndLimit(fullName.startsWith("refs/remotes/") ? fullName.slice(13) : shortName, 512),
             hash: redactAndLimit(peeledHash || objectHash, 128),
             subject: redactAndLimit(subject, 4096)
           };
@@ -1101,6 +1566,102 @@ var init_git_repository_service = __esm({
         });
         return { ok: true, data: stashes };
       }
+      async resolveStash(workdir, selector, hash, signal, sandboxPolicy) {
+        if (typeof selector !== "string" || !/^stash@\{\d{1,9}\}$/.test(selector) || !validCommitHash(hash)) {
+          return errorResult("INVALID_ARGUMENT", "\u5FC5\u987B\u63D0\u4F9B\u6709\u6548\u7684\u8D2E\u85CF\u7F16\u53F7\u548C\u5B8C\u6574\u54C8\u5E0C");
+        }
+        const root = await this.getTopLevel(workdir, signal, sandboxPolicy);
+        if (!root.ok) return root;
+        const resolved = await this.run(root.data.topLevel, "git rev-parse --verify " + quoteShellArg(selector), 15e3, 4096, signal, sandboxPolicy);
+        if (resolved.exitCode !== 0 || (resolved.stdout?.text ?? "").trim() !== hash) {
+          return errorResult("STATE_CONFLICT", "\u8D2E\u85CF\u5217\u8868\u5DF2\u7ECF\u53D8\u5316\uFF0C\u8BF7\u5237\u65B0\u540E\u91CD\u65B0\u9009\u62E9");
+        }
+        const metadata = await this.run(root.data.topLevel, "git show -s --format=%P " + quoteShellArg(hash), 15e3, 4096, signal, sandboxPolicy);
+        const parents = (metadata.stdout?.text ?? "").trim().split(" ").filter(validCommitHash);
+        if (metadata.exitCode !== 0 || parents.length < 2) return errorResult("GIT_FAILED", "\u65E0\u6CD5\u8BFB\u53D6\u8D2E\u85CF\u7236\u8282\u70B9");
+        return { ok: true, data: { topLevel: root.data.topLevel, hash, parents } };
+      }
+      async getStashDetail(workdir, selector, hash, signal, sandboxPolicy) {
+        const stash = await this.resolveStash(workdir, selector, hash, signal, sandboxPolicy);
+        if (!stash.ok) return stash;
+        const { topLevel, parents } = stash.data;
+        const commands = ["git diff --no-ext-diff --no-textconv --no-renames --name-status -z " + quoteShellArg(parents[0]) + " " + quoteShellArg(stash.data.hash) + " --"];
+        if (parents[2]) commands.push("git diff-tree --root --no-commit-id --no-renames --name-status -r -z " + quoteShellArg(parents[2]) + " --");
+        const results = await Promise.all(commands.map((command) => this.run(topLevel, command, 2e4, COMMIT_DETAIL_MAX_CHARS, signal, sandboxPolicy)));
+        const failure = results.find((result) => result.exitCode !== 0);
+        if (failure) return errorResult("GIT_FAILED", "\u65E0\u6CD5\u8BFB\u53D6\u8D2E\u85CF\u6587\u4EF6", redactAndLimit(outputOf(failure), 8192));
+        const files = [];
+        let filesTruncated = false;
+        results.forEach((result, index) => {
+          const raw = result.stdout?.text ?? "";
+          const parts = raw.split("\0");
+          if (raw.length >= COMMIT_DETAIL_MAX_CHARS || raw && !raw.endsWith("\0")) filesTruncated = true;
+          for (let i = 0; i + 2 < parts.length; i += 2) {
+            if (files.length >= COMMIT_FILE_MAX) {
+              filesTruncated = true;
+              break;
+            }
+            files.push({ status: parts[i], path: parts[i + 1], untracked: index === 1 });
+          }
+        });
+        return { ok: true, data: { hash: stash.data.hash, files, filesTruncated } };
+      }
+      async getStashDiff(workdir, selector, hash, path, untracked, signal, sandboxPolicy) {
+        if (!validStashPath(path)) return errorResult("INVALID_ARGUMENT", "\u8BF7\u9009\u62E9\u4ED3\u5E93\u5185\u7684\u6587\u4EF6\u8DEF\u5F84");
+        const stash = await this.resolveStash(workdir, selector, hash, signal, sandboxPolicy);
+        if (!stash.ok) return stash;
+        const { topLevel, parents } = stash.data;
+        if (untracked && !parents[2]) return errorResult("INVALID_ARGUMENT", "\u8BE5\u8D2E\u85CF\u4E0D\u5305\u542B\u672A\u8DDF\u8E2A\u6587\u4EF6");
+        const common = "--no-color --no-ext-diff --no-textconv --no-renames --patch ";
+        const command = untracked ? "git --literal-pathspecs diff-tree --root --no-commit-id -r " + common + quoteShellArg(parents[2]) : "git --literal-pathspecs diff " + common + quoteShellArg(parents[0]) + " " + quoteShellArg(stash.data.hash);
+        const result = await this.run(topLevel, command + " -- " + quoteShellArg(path), 3e4, DIFF_MAX_CHARS + 1024, signal, sandboxPolicy);
+        if (result.exitCode !== 0) return errorResult("GIT_FAILED", "\u65E0\u6CD5\u8BFB\u53D6\u8D2E\u85CF Diff", redactAndLimit(outputOf(result), 8192));
+        const raw = redactSecrets(result.stdout?.text ?? "");
+        return { ok: true, data: { path, staged: false, diff: raw.slice(0, DIFF_MAX_CHARS), truncated: raw.length > DIFF_MAX_CHARS } };
+      }
+      async createStash(request, message, paths, includeUntracked) {
+        if (typeof message !== "string" || message.length > 4096 || message.includes("\0")) return errorResult("INVALID_ARGUMENT", "\u8D2E\u85CF\u8BF4\u660E\u4E0D\u80FD\u8D85\u8FC7 4096 \u5B57\u7B26\u6216\u5305\u542B\u7A7A\u5B57\u7B26");
+        if (paths !== void 0 && (!Array.isArray(paths) || !paths.length || paths.length > 500 || !paths.every(validStashPath))) {
+          return errorResult("INVALID_ARGUMENT", "\u8BF7\u9009\u62E9 1\u2013500 \u4E2A\u6587\u4EF6\uFF0C\u6216\u8D2E\u85CF\u5168\u90E8\u6587\u4EF6");
+        }
+        return this.withMutation(request, async () => {
+          const result = await this.run(request.workdir, createStashCommand(message, paths, includeUntracked), 12e4, MUTATION_OUTPUT_MAX_CHARS, request.signal, request.sandboxPolicy);
+          if (result.exitCode !== 0) return errorResult(mutationErrorCode(result), "\u521B\u5EFA\u8D2E\u85CF\u5931\u8D25\uFF0C\u8BF7\u5237\u65B0\u786E\u8BA4\u5F53\u524D\u72B6\u6001", redactAndLimit(outputOf(result), 8192));
+          try {
+            const response = JSON.parse(result.stdout?.text ?? "");
+            if (!response.ok) return errorResult(response.code, response.message, redactAndLimit(response.diagnostics ?? "", 8192));
+          } catch {
+            return errorResult("GIT_FAILED", "\u65E0\u6CD5\u786E\u8BA4\u8D2E\u85CF\u521B\u5EFA\u7ED3\u679C\uFF0C\u8BF7\u5237\u65B0");
+          }
+          const summary = await this.getSummary(request.workdir, request.signal, request.sandboxPolicy);
+          return summary.ok ? { ...summary, operationId: String(request.operationId) } : summary;
+        });
+      }
+      async mutateStash(request, action, selector, hash, name, confirmRisk = false) {
+        if (action === "drop-stash" && !confirmRisk) return errorResult("PERMISSION_DENIED", "\u5220\u9664\u8D2E\u85CF\u524D\u5FC5\u987B\u786E\u8BA4\u5176\u4E2D\u7684\u6539\u52A8\u53EF\u80FD\u4E22\u5931");
+        if (action === "branch-stash" && !validBranchName(name)) return errorResult("INVALID_ARGUMENT", "\u8BF7\u8F93\u5165\u6709\u6548\u7684\u65B0\u5206\u652F\u540D");
+        return this.withMutation(request, async () => {
+          const stash = await this.resolveStash(request.workdir, selector, hash, request.signal, request.sandboxPolicy);
+          if (!stash.ok) return stash;
+          const root = stash.data.topLevel;
+          if (action !== "drop-stash") {
+            const state = await this.conflictAction("get-conflicts", root, {}, void 0, request.sandboxPolicy);
+            if (!state.ok) return state;
+            const data = state.data;
+            if (data.operation || data.files.length) return errorResult("STATE_CONFLICT", "\u8BF7\u5148\u5B8C\u6210\u5F53\u524D Git \u64CD\u4F5C\u5E76\u89E3\u51B3\u51B2\u7A81");
+            if (action === "branch-stash") {
+              const summary2 = await this.getSummary(root, request.signal, request.sandboxPolicy);
+              if (!summary2.ok) return summary2;
+              if (summary2.data.files.length) return errorResult("STATE_CONFLICT", "\u4ECE\u8D2E\u85CF\u521B\u5EFA\u5206\u652F\u524D\uFF0C\u8BF7\u5148\u63D0\u4EA4\u6216\u8D2E\u85CF\u5F53\u524D\u6539\u52A8", void 0, "DIRTY_WORKTREE");
+            }
+          }
+          const command = action === "branch-stash" ? "git -c apply.whitespace=nowarn stash branch " + quoteShellArg(name) + " " + quoteShellArg(selector) : "git stash " + { "apply-stash": "apply", "pop-stash": "pop", "drop-stash": "drop" }[action] + " " + quoteShellArg(action === "apply-stash" ? stash.data.hash : selector);
+          const result = await this.run(root, command, 12e4, MUTATION_OUTPUT_MAX_CHARS, request.signal, request.sandboxPolicy);
+          if (result.exitCode !== 0) return errorResult(mutationErrorCode(result), "\u8D2E\u85CF\u64CD\u4F5C\u672A\u5B8C\u6210\uFF1B\u5982\u6709\u51B2\u7A81\uFF0C\u8BF7\u5728\u201C\u51B2\u7A81\u89E3\u51B3\u201D\u4E2D\u5904\u7406\u3002\u5931\u8D25\u7684\u5F39\u51FA\u4F1A\u4FDD\u7559\u8D2E\u85CF\u3002", redactAndLimit(outputOf(result), 8192));
+          const summary = await this.getSummary(root, request.signal, request.sandboxPolicy);
+          return summary.ok ? { ...summary, operationId: String(request.operationId) } : summary;
+        });
+      }
       async getSyncState(workdir, signal, sandboxPolicy) {
         const summary = await this.getSummary(workdir, signal, sandboxPolicy);
         if (!summary.ok) return summary;
@@ -1276,6 +1837,40 @@ var init_git_repository_service = __esm({
         return this.mutateAndRead(request, command, failureMessage, false, () => this.getSyncState(request.workdir, request.signal, request.sandboxPolicy));
       }
       async mutateAndRead(request, command, failureMessage, requiresStagedContent, readResult) {
+        return this.withMutation(request, async () => {
+          if (requiresStagedContent) {
+            const staged = await this.run(request.workdir, "git diff --cached --quiet", 15e3, 4096, request.signal, request.sandboxPolicy);
+            if (staged.exitCode === 0) return errorResult("STATE_CONFLICT", "\u6CA1\u6709\u5DF2\u6682\u5B58\u7684\u6539\u52A8\uFF0C\u65E0\u6CD5\u63D0\u4EA4");
+            if (staged.exitCode !== 1) return errorResult("GIT_FAILED", "\u65E0\u6CD5\u68C0\u67E5\u6682\u5B58\u533A", redactAndLimit(outputOf(staged), 8192));
+          }
+          const executed = await this.run(request.workdir, command, 12e4, MUTATION_OUTPUT_MAX_CHARS, request.signal, request.sandboxPolicy);
+          if (executed.exitCode !== 0) return errorResult(mutationErrorCode(executed), failureMessage, redactAndLimit(outputOf(executed), 8192));
+          const result = await readResult();
+          return result.ok ? { ...result, operationId: String(request.operationId) } : result;
+        });
+      }
+      async conflictAction(action, workdir, payload, request, sandboxPolicy) {
+        if (action === "amend-message" && (typeof payload.message !== "string" || Buffer.byteLength(payload.message) > 48 * 1024)) {
+          return errorResult("INVALID_ARGUMENT", "\u63D0\u4EA4\u8BF4\u660E\u5FC5\u987B\u662F 48 KiB \u4EE5\u5185\u7684\u6587\u672C");
+        }
+        if (action === "save-conflict" && (typeof payload.content !== "string" || Buffer.byteLength(payload.content) > 48 * 1024)) {
+          return errorResult("INVALID_ARGUMENT", "\u7ED3\u679C\u5FC5\u987B\u662F 48 KiB \u4EE5\u5185\u7684\u6587\u672C");
+        }
+        const run = async () => {
+          const result = await this.run(workdir, conflictWorkerCommand(action, payload), 12e4, 2 * 1024 * 1024, request?.signal, request?.sandboxPolicy ?? sandboxPolicy);
+          if (result.exitCode !== 0) return errorResult(mutationErrorCode(result), "\u51B2\u7A81\u64CD\u4F5C\u5931\u8D25", redactAndLimit(outputOf(result), 8192));
+          try {
+            const response = JSON.parse(result.stdout?.text ?? "");
+            if (!response.ok && response.diagnostics) response.diagnostics = redactAndLimit(response.diagnostics, 8192);
+            if (!response.ok) response.message = redactAndLimit(response.message, 8192);
+            return response;
+          } catch {
+            return errorResult("GIT_FAILED", "\u65E0\u6CD5\u8BFB\u53D6\u5B8C\u6574\u7684\u51B2\u7A81\u6570\u636E");
+          }
+        };
+        return request ? this.withMutation(request, run) : run();
+      }
+      async withMutation(request, task) {
         if (!request.sessionId || !request.workdir) return errorResult("SESSION_NOT_FOUND", "\u65E0\u6CD5\u786E\u5B9A\u5F53\u524D\u4F1A\u8BDD\u7684\u4ED3\u5E93\u76EE\u5F55");
         if (typeof request.operationId !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(request.operationId)) {
           return errorResult("INVALID_ARGUMENT", "operationId \u5FC5\u987B\u662F 1\u2013128 \u4E2A\u5B89\u5168\u5B57\u7B26");
@@ -1286,7 +1881,7 @@ var init_git_repository_service = __esm({
         const key = request.sessionId + "\0" + repository.data.topLevel + "\0" + request.operationId;
         const existing = this.operations.get(key);
         if (existing) return existing.result;
-        const lockKey = request.sessionId + "\0" + repository.data.topLevel;
+        const lockKey = repository.data.topLevel;
         const previous = this.locks.get(lockKey) ?? Promise.resolve();
         let release = () => {
         };
@@ -1297,15 +1892,7 @@ var init_git_repository_service = __esm({
         this.locks.set(lockKey, queued);
         const result = previous.then(async () => {
           try {
-            if (requiresStagedContent) {
-              const staged = await this.run(request.workdir, "git diff --cached --quiet", 15e3, 4096, request.signal, request.sandboxPolicy);
-              if (staged.exitCode === 0) return errorResult("STATE_CONFLICT", "\u6CA1\u6709\u5DF2\u6682\u5B58\u7684\u6539\u52A8\uFF0C\u65E0\u6CD5\u63D0\u4EA4");
-              if (staged.exitCode !== 1) return errorResult("GIT_FAILED", "\u65E0\u6CD5\u68C0\u67E5\u6682\u5B58\u533A", redactAndLimit(outputOf(staged), 8192));
-            }
-            const executed = await this.run(request.workdir, command, 12e4, MUTATION_OUTPUT_MAX_CHARS, request.signal, request.sandboxPolicy);
-            if (executed.exitCode !== 0) return errorResult(mutationErrorCode(executed), failureMessage, redactAndLimit(outputOf(executed), 8192));
-            const result2 = await readResult();
-            return result2.ok ? { ...result2, operationId: String(request.operationId) } : result2;
+            return await task();
           } finally {
             release();
             if (this.locks.get(lockKey) === queued) this.locks.delete(lockKey);
@@ -1358,23 +1945,36 @@ var require_plugin = __commonJS({
       }
       return void 0;
     }
-    function repositoryContextForSession(ctx, sandboxPolicy, sessionId) {
+    async function repositoryContextForSession(ctx, sandboxPolicy, sessionId) {
       try {
         const agents = ctx.get("agents");
         const agent = agents && agents.get(sessionId);
-        if (!agent) return null;
-        const workdir = sessionWorkdir({ agent }, {}, ctx);
-        if (!workdir) return null;
-        const policy = sandboxPolicy ? sandboxPolicy.resolve({ session: agent.session }) : void 0;
-        return { workdir, policy };
-      } catch (e) {
+        const session = agent?.session ?? ctx.get("sessions")?.get(sessionId);
+        if (session) {
+          const workdir = sessionWorkdir({ agent: { session } }, {}, ctx);
+          if (!workdir) return null;
+          return { workdir, policy: sandboxPolicy?.resolve({ session }) };
+        }
+        const query = ctx.get("sessionQuery");
+        if (!query) return null;
+        const observation = await query.observeSession(sessionId);
+        try {
+          const workdir = observation.header.cwd;
+          if (!workdir || !observation.projections) return null;
+          const mode = observation.projections.values.sandboxMode ?? void 0;
+          const policy = sandboxPolicy ? { ...sandboxPolicy.resolve({ mode }), workspaceRoot: workdir, sessionId } : void 0;
+          return { workdir, policy };
+        } finally {
+          observation[Symbol.dispose]();
+        }
+      } catch (error) {
         return null;
       }
     }
     async function runGit(shell, workdir, command, timeoutMs, stdoutMaxBytes, signal, policy) {
       try {
         const spec = shell.resolve({ command, workdir, timeoutMs, stdoutMaxBytes, signal, ...policy ? { sandboxPolicy: policy } : {} });
-        return await shell.run(spec);
+        return await runShell(shell, spec);
       } catch (err) {
         return { exitCode: -1, signal: null, timedOut: false, aborted: false, stdout: { text: "" }, stderr: { text: errorMessage2(err) } };
       }
@@ -1962,7 +2562,7 @@ var require_plugin = __commonJS({
             }
           });
         }
-        const registerWebServer = (webServer) => registerEasyGitActions(webServer, {
+        const registerWebServer = (webServer, connection) => registerEasyGitActions(webServer, {
           repository,
           proposalStorageReady,
           shell,
@@ -1987,16 +2587,16 @@ var require_plugin = __commonJS({
             errorCode,
             reason
           ),
-          resolveExecutionPolicy: (sessionId) => {
-            const agents = ctx.get("agents");
-            const agent = agents ? agents.get(sessionId) : void 0;
-            return sandboxPolicy ? sandboxPolicy.resolve({ session: agent?.session }) : void 0;
+          resolveExecutionPolicy: async (sessionId) => {
+            const context = await repositoryContextForSession(ctx, sandboxPolicy, sessionId);
+            if (!context) throw new Error("\u65E0\u6CD5\u786E\u5B9A\u5F53\u524D\u4F1A\u8BDD\u7684\u4ED3\u5E93\u76EE\u5F55");
+            return context.policy;
           }
-        });
+        }, connection);
         if (typeof ctx.inject === "function") {
-          ctx.inject(["webServer"], (webCtx) => registerWebServer(webCtx.get("webServer")));
+          ctx.inject(["webServer", "connection"], (webCtx) => registerWebServer(webCtx.get("webServer"), webCtx.get("connection")));
         } else {
-          registerWebServer(ctx.get("webServer"));
+          registerWebServer(ctx.get("webServer"), ctx.get("connection"));
         }
       }
     };