@qwen-code/qwen-code 0.24.5-preview.0 → 0.24.5

package/chunks/{chunk-RL2HSTEB.js → chunk-SYZPPX3O.js}

@@ -83,7 +83,7 @@ import {
   worktreeBranchForSlug,
   writeRuntimeStatus,
   writeWorktreeSessionMarker
-} from "./chunk-6N2PJAZG.js";
+} from "./chunk-PX2ZOOGQ.js";
 import {
   SessionArtifactSnapshotAccumulator,
   aggregateTranscriptRecordFragments,
@@ -182,10 +182,10 @@ import {
   stringify,
   validateGoalProposalReason,
   validateSkillName
-} from "./chunk-TFBQ5CKI.js";
+} from "./chunk-QNEBHC2E.js";
 import {
   canUseRipgrep
-} from "./chunk-N4VKU36J.js";
+} from "./chunk-465XOJLQ.js";
 import {
   CODE_MODE_MAX_MEDIA_BYTES,
   CODE_MODE_MAX_MEDIA_ITEMS
@@ -219,7 +219,7 @@ import {
 } from "./chunk-6C3D7BKK.js";
 import {
   isOmniDeliveryActive
-} from "./chunk-BVFBDXI2.js";
+} from "./chunk-TPFV5YZK.js";
 import {
   MediaResourceRegistry,
   evaluateMediaPolicyToolCall,
@@ -283,7 +283,7 @@ import {
   DEFERRED_TOOL_CALL_CANCELLATION_PREFIX,
   DEFERRED_TOOL_CALL_REFUSAL_PREFIX,
   resolveDeferredToolCall
-} from "./chunk-LNUQA3OE.js";
+} from "./chunk-CVRZNFXO.js";
 import {
   EXCLUDED_TOOLS_FOR_SUBAGENTS,
   READ_ONLY_INSPECTION_TOOLS,
@@ -312,7 +312,7 @@ import {
   splitCompoundCommand,
   splitCompoundCommandSegments,
   toolMatchesRuleToolName
-} from "./chunk-47C3HPMW.js";
+} from "./chunk-O5YL6KSX.js";
 import {
   APPROVAL_MODES
 } from "./chunk-JX6XHPTX.js";
@@ -333,7 +333,7 @@ import {
   resolveEffectiveOutputStyle,
   resolveInteractionMode,
   resolveMainSessionOutputStyle
-} from "./chunk-JE3J5HFM.js";
+} from "./chunk-KAOHUUM7.js";
 import {
   NO_EXEC_CONFIG,
   findGitRoot,
@@ -346,11 +346,10 @@ import {
 import {
   InMemoryImagePayloadStore,
   buildReattachParts,
-  clampInlineMediaPart,
   countAllInlineImages,
   replaceImagePayloadsInPlace,
   supportsOpenAIPrefixCaching
-} from "./chunk-QKXZOHHQ.js";
+} from "./chunk-LDURD6EP.js";
 import {
   OMNI_DISCLOSURE_TEXT_PREFIX,
   OMNI_OMISSION_TEXT_PREFIX,
@@ -361,7 +360,7 @@ import {
 import {
   DashScopeOpenAICompatibleProvider,
   selectDashScopeThinkingKnob
-} from "./chunk-GG3MO6NO.js";
+} from "./chunk-PWGMHXIV.js";
 import {
   childLaunchDepth,
   getCurrentAgentConfiguredToolAllowlist,
@@ -386,16 +385,6 @@ import {
   getResponsesMessage,
   sameResponsesMessage
 } from "./chunk-Z72PLR74.js";
-import {
-  DEFAULT_IMAGE_TOKEN_ESTIMATE,
-  TOKEN_TO_CHAR_RATIO,
-  estimateContentChars,
-  getFunctionResponseParts,
-  resolveCompactionTuning,
-  resolveSlimmingConfig,
-  sanitizeMimeForPlaceholder,
-  slimCompactionInput
-} from "./chunk-GC3J5W2O.js";
 import {
   openBrowserSecurely,
   shouldAttemptBrowserLaunch
@@ -446,7 +435,7 @@ import {
   resolveReasoningForModel,
   stripRuntimeSnapshotPrefix,
   validateReasoningCapabilities
-} from "./chunk-OU4ZCLGJ.js";
+} from "./chunk-242INZ6Y.js";
 import {
   addDaemonRequestAttribute
 } from "./chunk-KBVGO6H4.js";
@@ -542,7 +531,7 @@ import {
   updateMCPServerStatus,
   writeLine,
   writeLineSync
-} from "./chunk-MZRJ2JJS.js";
+} from "./chunk-HDSI3RDN.js";
 import {
   Mutex
 } from "./chunk-VBT4BMCQ.js";
@@ -556,7 +545,7 @@ import {
   readTextCursorWindowFromHandle,
   readTextRangeFromHandle,
   setMemoryFilename
-} from "./chunk-NNN2PKPV.js";
+} from "./chunk-PYYPSK6Q.js";
 import {
   extractCodeModeImageContent,
   getCurrentToolCallSource,
@@ -587,6 +576,9 @@ import {
 import {
   runSideQuery
 } from "./chunk-GHKVBSBY.js";
+import {
+  clampInlineMediaPart
+} from "./chunk-Q4FJVWI4.js";
 import {
   getSystemEncoding
 } from "./chunk-GMTJ3YQW.js";
@@ -594,6 +586,16 @@ import {
   getInvocationContext,
   runWithInvocationContext
 } from "./chunk-5ETULJLP.js";
+import {
+  DEFAULT_IMAGE_TOKEN_ESTIMATE,
+  TOKEN_TO_CHAR_RATIO,
+  estimateContentChars,
+  getFunctionResponseParts,
+  resolveCompactionTuning,
+  resolveSlimmingConfig,
+  sanitizeMimeForPlaceholder,
+  slimCompactionInput
+} from "./chunk-GC3J5W2O.js";
 import {
   normalizeMcpToolName,
   sanitizeToolNameForProvider
@@ -622,7 +624,7 @@ import {
   resolveContentGeneratorConfigWithSources,
   setGeneratorReasoningEffort,
   tokenLimit
-} from "./chunk-4FCWKBOC.js";
+} from "./chunk-ALTMZEBU.js";
 import {
   DEFAULT_QWEN_MODEL
 } from "./chunk-XZA32HII.js";
@@ -1444,13 +1446,13 @@ var require_cross_spawn = __commonJS({
     var cp = __require("child_process");
     var parse12 = require_parse();
     var enoent = require_enoent();
-    function spawn7(command, args, options2) {
+    function spawn8(command, args, options2) {
       const parsed = parse12(command, args, options2);
       const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
       enoent.hookChildProcess(spawned, parsed);
       return spawned;
     }
-    __name(spawn7, "spawn");
+    __name(spawn8, "spawn");
     function spawnSync3(command, args, options2) {
       const parsed = parse12(command, args, options2);
       const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
@@ -1458,8 +1460,8 @@ var require_cross_spawn = __commonJS({
       return result;
     }
     __name(spawnSync3, "spawnSync");
-    module2.exports = spawn7;
-    module2.exports.spawn = spawn7;
+    module2.exports = spawn8;
+    module2.exports.spawn = spawn8;
     module2.exports.sync = spawnSync3;
     module2.exports._parse = parse12;
     module2.exports._enoent = enoent;
@@ -15903,10 +15905,10 @@ import {
   mkdir as mkdir2,
   open as open2,
   readFile as readFile3,
-  stat as stat2,
+  stat as stat3,
   unlink as unlink3
 } from "node:fs/promises";
-import { dirname, isAbsolute as isAbsolute2, join as join6, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
+import { dirname, isAbsolute as isAbsolute2, join as join8, relative as relative2, resolve as resolve4, sep as sep2 } from "node:path";
 
 // node_modules/diff/lib/index.mjs
 init_esbuild_shims();
@@ -16750,12 +16752,990 @@ __name(splitLines, "splitLines");
 
 // packages/core/src/utils/gitDiff.ts
 init_esbuild_shims();
-import { execFile } from "node:child_process";
-import { access, lstat as lstat2, open, readFile as readFile2, stat } from "node:fs/promises";
-import * as path5 from "node:path";
+import { execFile as execFile2 } from "node:child_process";
+import { access as access2, lstat as lstat3, open, readFile as readFile2, stat as stat2 } from "node:fs/promises";
+import * as path7 from "node:path";
+import { promisify as promisify2 } from "node:util";
+
+// packages/core/src/utils/git-branches.ts
+init_esbuild_shims();
+import { execFile, spawn } from "node:child_process";
+import * as fs7 from "node:fs";
+import * as path6 from "node:path";
 import { promisify } from "node:util";
+
+// packages/core/src/utils/gitDirect.ts
+init_esbuild_shims();
+import * as fs6 from "node:fs";
+import * as fsPromises from "node:fs/promises";
+import * as path5 from "node:path";
+var SHORT_SHA_LENGTH = 7;
+var debug = createDebugLogger("gitDirect");
+var MAX_REF_COMPONENT_LENGTH = 255;
+var INVALID_REF_CHARS = /[\x00-\x20\x7f-\x9f\u200b-\u200d\u2028\u2029\u202a-\u202e\u2066-\u2069\ufeff~^:?*[\\]/;
+function isValidRefName(name) {
+  if (!name || name === "HEAD") return false;
+  if (name.startsWith("/") || name.endsWith("/")) return false;
+  if (name.startsWith(".") || name.endsWith(".")) return false;
+  if (name.endsWith(".lock")) return false;
+  if (name.includes("..") || name.includes("//")) return false;
+  if (name.includes("/.") || name.includes("./") || name.includes(".lock/")) {
+    return false;
+  }
+  if (name.includes("@{")) return false;
+  if (INVALID_REF_CHARS.test(name)) return false;
+  if (name.split("/").some((c) => c.length > MAX_REF_COMPONENT_LENGTH)) {
+    return false;
+  }
+  return true;
+}
+__name(isValidRefName, "isValidRefName");
+function isValidGitSha(value) {
+  return /^[0-9a-f]{40}$/.test(value) || /^[0-9a-f]{64}$/.test(value);
+}
+__name(isValidGitSha, "isValidGitSha");
+var gitDirCache = /* @__PURE__ */ new Map();
+async function isDir(p2) {
+  try {
+    return (await fsPromises.stat(p2)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+__name(isDir, "isDir");
+async function hasGitStore(dir) {
+  const [objects, refs] = await Promise.all([
+    isDir(path5.join(dir, "objects")),
+    isDir(path5.join(dir, "refs"))
+  ]);
+  return objects && refs;
+}
+__name(hasGitStore, "hasGitStore");
+async function isRealGitDir(gitDir) {
+  if (await hasGitStore(gitDir)) return true;
+  const rel = await readFirstLineNoFollow(path5.join(gitDir, "commondir"));
+  if (!rel) return false;
+  return hasGitStore(path5.resolve(gitDir, rel.trim()));
+}
+__name(isRealGitDir, "isRealGitDir");
+async function resolveTrustedGitDir(cwd) {
+  const gitDir = await resolveGitDir(cwd);
+  if (!gitDir) return null;
+  return await isRealGitDir(gitDir) ? gitDir : null;
+}
+__name(resolveTrustedGitDir, "resolveTrustedGitDir");
+async function getCachedGitDir(cwd) {
+  const key = path5.resolve(cwd);
+  const cached3 = gitDirCache.get(key);
+  if (cached3 !== void 0) return cached3;
+  const gitDir = await resolveTrustedGitDir(key);
+  if (gitDir !== null) gitDirCache.set(key, gitDir);
+  return gitDir;
+}
+__name(getCachedGitDir, "getCachedGitDir");
+async function readGitHead(gitDir) {
+  const firstLine = await readFirstLineNoFollow(path5.join(gitDir, "HEAD"));
+  if (firstLine === null) return null;
+  const content = firstLine.trim();
+  if (content.startsWith("ref:")) {
+    const ref = content.slice(4).trim();
+    if (!ref.startsWith("refs/heads/")) return null;
+    const name = ref.slice("refs/heads/".length);
+    if (!isValidRefName(name)) return null;
+    return { type: "branch", name };
+  }
+  if (isValidGitSha(content)) {
+    return { type: "detached", name: content };
+  }
+  return null;
+}
+__name(readGitHead, "readGitHead");
+async function resolveBranchName(cwd) {
+  const gitDir = await getCachedGitDir(cwd);
+  if (!gitDir) return void 0;
+  const head = await readGitHead(gitDir);
+  if (!head) return void 0;
+  return head.type === "branch" ? head.name : head.name.slice(0, SHORT_SHA_LENGTH);
+}
+__name(resolveBranchName, "resolveBranchName");
+var repoBranchWatches = /* @__PURE__ */ new Map();
+async function watchRepoBranch(cwd, onChange) {
+  const gitDir = await getCachedGitDir(cwd);
+  if (!gitDir) return () => {
+  };
+  let entry = repoBranchWatches.get(gitDir);
+  if (!entry) {
+    const logsHeadPath = path5.join(gitDir, "logs", "HEAD");
+    try {
+      await fsPromises.access(logsHeadPath, fs6.constants?.F_OK ?? 0);
+      if ((await fsPromises.lstat(logsHeadPath)).isSymbolicLink()) {
+        return () => {
+        };
+      }
+    } catch {
+      return () => {
+      };
+    }
+    const existing = repoBranchWatches.get(gitDir);
+    if (existing) {
+      entry = existing;
+    } else {
+      let watcher;
+      try {
+        watcher = fs6.watch(logsHeadPath, (eventType) => {
+          if (eventType === "change" || eventType === "rename") {
+            repoBranchWatches.get(gitDir)?.subscribers.forEach((cb) => {
+              try {
+                cb();
+              } catch {
+              }
+            });
+          }
+        });
+      } catch (err) {
+        debug.warn(`failed to watch reflog for ${gitDir}: ${err}`);
+        return () => {
+        };
+      }
+      watcher.on("error", (err) => {
+        debug.warn(
+          `reflog watcher error for ${gitDir}; branch will no longer auto-update: ${err?.message}`
+        );
+        const current = repoBranchWatches.get(gitDir);
+        if (current?.watcher === watcher) {
+          try {
+            watcher.close();
+          } catch {
+          }
+          repoBranchWatches.delete(gitDir);
+        }
+      });
+      entry = { watcher, subscribers: /* @__PURE__ */ new Set() };
+      repoBranchWatches.set(gitDir, entry);
+    }
+  }
+  entry.subscribers.add(onChange);
+  let disposed = false;
+  return () => {
+    if (disposed) return;
+    disposed = true;
+    const e = repoBranchWatches.get(gitDir);
+    if (!e) return;
+    e.subscribers.delete(onChange);
+    if (e.subscribers.size === 0) {
+      e.watcher.close();
+      repoBranchWatches.delete(gitDir);
+    }
+  };
+}
+__name(watchRepoBranch, "watchRepoBranch");
+
+// packages/core/src/utils/git-branches.ts
+var debugLogger12 = createDebugLogger("GIT_BRANCHES");
 var execFileAsync = promisify(execFile);
-var GIT_TIMEOUT_MS = 5e3;
+var GIT_TIMEOUT_MS = 3e4;
+var MAX_RECENT_BRANCHES = 20;
+var MAX_REFLOG_ENTRIES = 200;
+var GIT_ENV_VARS_TO_CLEAR = [
+  "GIT_DIR",
+  "GIT_WORK_TREE",
+  "GIT_COMMON_DIR",
+  "GIT_INDEX_FILE",
+  "GIT_CONFIG_GLOBAL",
+  "GIT_CONFIG_SYSTEM",
+  "GIT_CONFIG_NOSYSTEM",
+  // Repository selectors that an inherited daemon environment could use to
+  // redirect a trusted-workspace git/gh invocation to a different repository
+  // or object database despite the resolved cwd.
+  "GH_REPO",
+  "GIT_CONFIG_COUNT",
+  "GIT_CONFIG_PARAMETERS",
+  "GIT_OBJECT_DIRECTORY",
+  "GIT_ALTERNATE_OBJECT_DIRECTORIES"
+];
+var GIT_ENV_PREFIXES_TO_CLEAR = ["GIT_CONFIG_KEY_", "GIT_CONFIG_VALUE_"];
+var HELPER_PROTOCOLS = /* @__PURE__ */ new Set(["ext", "fd"]);
+function gitEnv(base) {
+  const env = { ...base ?? process.env };
+  for (const key of GIT_ENV_VARS_TO_CLEAR) {
+    delete env[key];
+  }
+  for (const key of Object.keys(env)) {
+    if (GIT_ENV_PREFIXES_TO_CLEAR.some((prefix) => key.startsWith(prefix))) {
+      delete env[key];
+    }
+  }
+  const inheritedAllow = env["GIT_ALLOW_PROTOCOL"];
+  if (inheritedAllow !== void 0) {
+    env["GIT_ALLOW_PROTOCOL"] = inheritedAllow.split(":").filter((p2) => !HELPER_PROTOCOLS.has(p2.trim().toLowerCase())).join(":");
+  }
+  env["LC_ALL"] = "C";
+  env["LANG"] = "C";
+  return env;
+}
+__name(gitEnv, "gitEnv");
+function streamGitRecords(cwd, args, onRecord, env, options2 = {}) {
+  return new Promise((resolve37, reject) => {
+    const child = spawn("git", args, {
+      cwd,
+      env: gitEnv(env),
+      windowsHide: true
+    });
+    let settled = false;
+    const settle = /* @__PURE__ */ __name((outcome) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      child.kill("SIGKILL");
+      outcome();
+    }, "settle");
+    const subcommand = args.find((arg, i) => !arg.startsWith("-") && args[i - 1] !== "-c") ?? "git";
+    const timer = setTimeout(
+      () => settle(() => reject(new Error(`git ${subcommand} timed out`))),
+      options2.timeoutMs ?? GIT_TIMEOUT_MS
+    );
+    const deliver = /* @__PURE__ */ __name((record4) => {
+      try {
+        if (!onRecord(record4)) return false;
+        settle(() => resolve37(true));
+      } catch (err) {
+        settle(() => reject(err));
+      }
+      return true;
+    }, "deliver");
+    let pending = Buffer.alloc(0);
+    child.stdout.on("data", (chunk) => {
+      if (settled) return;
+      pending = pending.length ? Buffer.concat([pending, chunk]) : chunk;
+      let at2 = pending.indexOf(0);
+      while (at2 !== -1) {
+        const record4 = pending.subarray(0, at2);
+        pending = pending.subarray(at2 + 1);
+        if (deliver(record4)) return;
+        at2 = pending.indexOf(0);
+      }
+    });
+    let stderr = "";
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      if (stderr.length < 8192) stderr += chunk;
+    });
+    child.on("error", (err) => settle(() => reject(err)));
+    child.on("close", (code, signal) => {
+      if (settled) return;
+      if (code !== 0) {
+        settle(
+          () => reject(
+            new Error(
+              stderr.trim() || `git ${subcommand} exited with ${code ?? signal}`
+            )
+          )
+        );
+        return;
+      }
+      if (pending.length > 0 && deliver(pending)) return;
+      settle(() => resolve37(false));
+    });
+  });
+}
+__name(streamGitRecords, "streamGitRecords");
+function runGitCapture(cwd, args, env) {
+  return execFileAsync("git", args, {
+    cwd,
+    timeout: GIT_TIMEOUT_MS,
+    maxBuffer: 10 * 1024 * 1024,
+    env: gitEnv(env)
+  }).then(({ stdout, stderr }) => ({ stdout, stderr }));
+}
+__name(runGitCapture, "runGitCapture");
+function runGit(cwd, args, env) {
+  return runGitCapture(cwd, args, env).then(({ stdout }) => stdout);
+}
+__name(runGit, "runGit");
+var SEPARATOR = "\0";
+async function fetchGitBranches(cwd, env) {
+  await runGit(cwd, ["rev-parse", "--git-dir"], env);
+  const [localRaw, remoteRaw, tagsRaw, headRaw, reflogRaw] = await Promise.all([
+    runGit(
+      cwd,
+      [
+        "for-each-ref",
+        "--format=%(refname:short)%00%(HEAD)%00%(upstream:short)%00%(upstream:track,nobracket)%00%(committerdate:unix)%00%(subject)%00%(symref)%00%(push:short)%00%(push:track,nobracket)",
+        "refs/heads/"
+      ],
+      env
+    ).catch(() => ""),
+    runGit(
+      cwd,
+      [
+        "for-each-ref",
+        "--format=%(refname:short)%00%(HEAD)%00%(upstream:short)%00%(upstream:track,nobracket)%00%(committerdate:unix)%00%(subject)%00%(symref)%00%(push:short)%00%(push:track,nobracket)",
+        "refs/remotes/"
+      ],
+      env
+    ).catch(() => ""),
+    runGit(
+      cwd,
+      [
+        "for-each-ref",
+        "--format=%(refname:short)%00%(creatordate:unix)%00%(subject)",
+        "--sort=-creatordate",
+        "refs/tags/"
+      ],
+      env
+    ).catch(() => ""),
+    runGit(cwd, ["symbolic-ref", "--short", "HEAD"], env).catch(() => ""),
+    runGit(
+      cwd,
+      ["reflog", "show", "--format=%gs", `-${MAX_REFLOG_ENTRIES}`],
+      env
+    ).catch(() => "")
+  ]);
+  const local = parseBranchLines(localRaw);
+  const remote = parseBranchLines(remoteRaw);
+  const tags = parseTagLines(tagsRaw);
+  const recent = parseRecentBranches(reflogRaw, headRaw.trim());
+  const headTrimmed = headRaw.trim();
+  const detached = !headTrimmed;
+  return {
+    local,
+    remote,
+    tags,
+    recent,
+    head: headTrimmed || await getDetachedHead(cwd, env),
+    detached
+  };
+}
+__name(fetchGitBranches, "fetchGitBranches");
+function parseBranchLines(raw) {
+  if (!raw.trim()) return [];
+  return raw.trim().split("\n").filter(Boolean).filter((line) => {
+    const parts2 = line.split(SEPARATOR);
+    return !(parts2[6] ?? "");
+  }).map((line) => {
+    const parts2 = line.split(SEPARATOR);
+    const name = parts2[0] ?? "";
+    const isHead = parts2[1] === "*";
+    const upstream = parts2[2] || void 0;
+    const track = parts2[3] ?? "";
+    const commitDate = parseInt(parts2[4] ?? "0", 10) || 0;
+    const commitSubject = parts2[5] ?? "";
+    let ahead = 0;
+    let behind = 0;
+    const aheadMatch = /ahead (\d+)/.exec(track);
+    const behindMatch = /behind (\d+)/.exec(track);
+    if (aheadMatch) ahead = parseInt(aheadMatch[1], 10);
+    if (behindMatch) behind = parseInt(behindMatch[1], 10);
+    const upstreamGone = upstream !== void 0 && /\bgone\b/.test(track);
+    const pushTarget = parts2[7] || void 0;
+    const pushTrack = parts2[8] ?? "";
+    const pushGone = pushTarget !== void 0 && /\bgone\b/.test(pushTrack);
+    let pushAhead;
+    let pushBehind;
+    if (pushTarget !== void 0 && !pushGone) {
+      const pa = /ahead (\d+)/.exec(pushTrack);
+      const pb = /behind (\d+)/.exec(pushTrack);
+      pushAhead = pa ? parseInt(pa[1], 10) : 0;
+      pushBehind = pb ? parseInt(pb[1], 10) : 0;
+    }
+    return {
+      name,
+      isHead,
+      upstream,
+      ...upstreamGone ? { upstreamGone } : {},
+      ahead,
+      behind,
+      ...pushTarget !== void 0 ? { pushTarget } : {},
+      ...pushAhead !== void 0 ? { pushAhead } : {},
+      ...pushBehind !== void 0 ? { pushBehind } : {},
+      ...pushGone ? { pushGone } : {},
+      commitDate,
+      commitSubject
+    };
+  });
+}
+__name(parseBranchLines, "parseBranchLines");
+function parseTagLines(raw) {
+  if (!raw.trim()) return [];
+  return raw.trim().split("\n").filter(Boolean).map((line) => {
+    const parts2 = line.split(SEPARATOR);
+    return {
+      name: parts2[0] ?? "",
+      date: parseInt(parts2[1] ?? "0", 10) || 0,
+      subject: parts2[2] ?? ""
+    };
+  });
+}
+__name(parseTagLines, "parseTagLines");
+function parseRecentBranches(reflogRaw, currentHead) {
+  if (!reflogRaw.trim()) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const line of reflogRaw.trim().split("\n")) {
+    if (!line.startsWith("checkout: moving from ")) continue;
+    const idx = line.indexOf(" to ");
+    if (idx === -1) continue;
+    const branch = line.slice(idx + 4);
+    if (branch && !seen.has(branch) && branch !== currentHead && !/^[0-9a-f]{7,40}$/.test(branch)) {
+      seen.add(branch);
+      result.push(branch);
+      if (result.length >= MAX_RECENT_BRANCHES) break;
+    }
+  }
+  return result;
+}
+__name(parseRecentBranches, "parseRecentBranches");
+async function getDetachedHead(cwd, env) {
+  try {
+    const sha = await runGit(cwd, ["rev-parse", "--short", "HEAD"], env);
+    return sha.trim();
+  } catch {
+    return "";
+  }
+}
+__name(getDetachedHead, "getDetachedHead");
+function isValidCheckoutRef(value) {
+  const ref = value.trim();
+  if (!ref || ref.startsWith("-")) return false;
+  if (ref === "HEAD") return true;
+  return isValidRefName(ref) || isValidGitSha(ref);
+}
+__name(isValidCheckoutRef, "isValidCheckoutRef");
+async function gitCheckout(cwd, ref, env) {
+  if (!isValidCheckoutRef(ref)) {
+    throw new Error(`invalid checkout ref: ${ref}`);
+  }
+  const isRemoteTracking = await runGit(
+    cwd,
+    ["show-ref", "--verify", "--quiet", `refs/remotes/${ref}`],
+    env
+  ).then(() => true).catch(() => false);
+  if (isRemoteTracking) {
+    const localName = ref.slice(ref.indexOf("/") + 1);
+    if (!isValidCheckoutRef(localName)) {
+      throw new Error(
+        `invalid local branch name derived from remote ref: ${localName}`
+      );
+    }
+    const hasLocal = await runGit(
+      cwd,
+      ["show-ref", "--verify", "--quiet", `refs/heads/${localName}`],
+      env
+    ).then(() => true).catch(() => false);
+    if (hasLocal) {
+      await runGit(cwd, ["checkout", localName, "--"], env);
+    } else {
+      await runGit(cwd, ["checkout", "--track", ref], env);
+    }
+    const head = (await runGit(cwd, ["symbolic-ref", "--short", "HEAD"], env)).trim();
+    return { branch: head, detached: false };
+  }
+  await runGit(cwd, ["checkout", ref, "--"], env);
+  const headRaw = await runGit(
+    cwd,
+    ["symbolic-ref", "--short", "HEAD"],
+    env
+  ).catch(() => "");
+  const trimmed = headRaw.trim();
+  if (trimmed) {
+    return { branch: trimmed, detached: false };
+  }
+  const sha = await runGit(cwd, ["rev-parse", "--short", "HEAD"], env);
+  return { branch: sha.trim(), detached: true };
+}
+__name(gitCheckout, "gitCheckout");
+async function gitCreateBranch(cwd, name, startPoint, env) {
+  if (!isValidRefName(name) || name.startsWith("-")) {
+    throw new Error(`invalid branch name: ${name}`);
+  }
+  const args = ["checkout", "-b", name];
+  if (startPoint) {
+    if (!isValidCheckoutRef(startPoint)) {
+      throw new Error(`invalid start point: ${startPoint}`);
+    }
+    args.push(startPoint);
+  }
+  args.push("--");
+  const originalRef = (await runGit(
+    cwd,
+    ["symbolic-ref", "--quiet", "--short", "HEAD"],
+    env
+  ).catch(() => "")).trim();
+  const originalCommit = originalRef ? "" : (await runGit(cwd, ["rev-parse", "HEAD"], env).catch(() => "")).trim();
+  const startCommit = (await runGit(
+    cwd,
+    ["rev-parse", "--verify", `${startPoint || "HEAD"}^{commit}`],
+    env
+  ).catch(() => "")).trim();
+  try {
+    await runGit(cwd, args, env);
+  } catch (err) {
+    const nowOn = (await runGit(
+      cwd,
+      ["symbolic-ref", "--quiet", "--short", "HEAD"],
+      env
+    ).catch(() => "")).trim();
+    if (nowOn === name) {
+      if (originalRef) {
+        await runGit(cwd, ["checkout", originalRef, "--"], env).catch(() => {
+        });
+      } else if (originalCommit) {
+        await runGit(
+          cwd,
+          ["checkout", "--detach", originalCommit, "--"],
+          env
+        ).catch(() => {
+        });
+      }
+      const newHead = (await runGit(cwd, ["rev-parse", `refs/heads/${name}`], env).catch(
+        () => ""
+      )).trim();
+      if (newHead && newHead !== startCommit) {
+        debugLogger12.warn(
+          `gitCreateBranch: keeping branch "${name}" because it contains commits created after checkout (likely by a failing post-checkout hook)`
+        );
+      } else {
+        await runGit(cwd, ["branch", "-D", name], env).catch(() => {
+        });
+      }
+    }
+    throw err;
+  }
+  return { branch: name, detached: false };
+}
+__name(gitCreateBranch, "gitCreateBranch");
+async function gitPush(cwd, opts, env) {
+  const args = ["push"];
+  if (opts?.force) args.push("--force-with-lease");
+  if (opts?.setUpstream) {
+    let branch;
+    try {
+      branch = (await runGit(cwd, ["symbolic-ref", "--short", "HEAD"], env)).trim();
+    } catch {
+      throw new Error(
+        "cannot push with --set-upstream in detached HEAD state; check out a branch first"
+      );
+    }
+    const hasUpstream = await runGit(
+      cwd,
+      ["rev-parse", "--abbrev-ref", `${branch}@{u}`],
+      env
+    ).catch(() => "");
+    if (hasUpstream.trim()) {
+      const output2 = await runGit(cwd, args, env);
+      return { success: true, output: output2.trim() };
+    }
+    let remote = (await runGit(cwd, ["config", `branch.${branch}.pushRemote`], env).catch(
+      () => ""
+    )).trim();
+    if (!remote) {
+      remote = (await runGit(cwd, ["config", "remote.pushDefault"], env).catch(() => "")).trim();
+    }
+    if (!remote) {
+      remote = (await runGit(cwd, ["config", `branch.${branch}.remote`], env).catch(
+        () => ""
+      )).trim();
+    }
+    if (!remote) {
+      const remotes = (await runGit(cwd, ["remote"], env).catch(() => "")).trim();
+      const remoteList = remotes ? remotes.split("\n") : [];
+      remote = remoteList.length === 1 ? remoteList[0] ?? "origin" : "origin";
+    }
+    args.push("--set-upstream", remote, branch);
+  }
+  const output = await runGit(cwd, args, env);
+  return { success: true, output: output.trim() };
+}
+__name(gitPush, "gitPush");
+var GitPullFailure = class extends Error {
+  static {
+    __name(this, "GitPullFailure");
+  }
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "GitPullFailure";
+    this.code = code;
+  }
+};
+var AUTO_STASH_MESSAGE = "qwen-code: auto-stash before pull";
+var OPERATION_STATE_PATHS = [
+  ["MERGE_HEAD", "merge"],
+  ["CHERRY_PICK_HEAD", "cherry-pick"],
+  ["REVERT_HEAD", "revert"],
+  ["rebase-merge", "rebase"],
+  ["rebase-apply", "rebase or am"]
+];
+function gitDetail(err) {
+  if (err && typeof err === "object" && ("stdout" in err || "stderr" in err)) {
+    const e = err;
+    const detail = `${e.stdout ?? ""}
+${e.stderr ?? ""}`.trim();
+    if (detail) return detail;
+    return "git exited without diagnostic output; a stale lock file (e.g. .git/index.lock) or another git process is the usual cause";
+  }
+  return err instanceof Error ? err.message : String(err);
+}
+__name(gitDetail, "gitDetail");
+function exitCode(err) {
+  const code = err?.code;
+  return typeof code === "number" ? code : void 0;
+}
+__name(exitCode, "exitCode");
+function pullExitCode(err) {
+  const code = exitCode(err);
+  if (code !== void 0) return code;
+  const e = err;
+  if (e && (e.killed === true || typeof e.signal === "string")) return 1;
+  return void 0;
+}
+__name(pullExitCode, "pullExitCode");
+async function gitPaths(cwd, names, env) {
+  const args = ["rev-parse"];
+  for (const name of names) args.push("--git-path", name);
+  return (await runGit(cwd, args, env)).trim().split("\n").map((line) => path6.resolve(cwd, line));
+}
+__name(gitPaths, "gitPaths");
+async function operationInProgress(cwd, env) {
+  const paths = await gitPaths(
+    cwd,
+    OPERATION_STATE_PATHS.map(([statePath]) => statePath),
+    env
+  );
+  for (let i = 0; i < OPERATION_STATE_PATHS.length; i++) {
+    if (fs7.existsSync(paths[i])) return OPERATION_STATE_PATHS[i][1];
+  }
+  return void 0;
+}
+__name(operationInProgress, "operationInProgress");
+async function refuseOperationInProgress(cwd, env) {
+  const operation = await operationInProgress(cwd, env);
+  if (operation) {
+    throw new GitPullFailure(
+      "operation_in_progress",
+      `cannot update: a ${operation} is in progress; finish or abort it from a terminal first`
+    );
+  }
+}
+__name(refuseOperationInProgress, "refuseOperationInProgress");
+async function upstreamSha(cwd, env, ref = "") {
+  try {
+    return (await runGit(
+      cwd,
+      ["rev-parse", "--verify", "--quiet", `${ref}@{upstream}`],
+      env
+    )).trim();
+  } catch {
+    return "";
+  }
+}
+__name(upstreamSha, "upstreamSha");
+function readTrimmed(file) {
+  try {
+    return fs7.readFileSync(file, "utf8").trim();
+  } catch {
+    return "";
+  }
+}
+__name(readTrimmed, "readTrimmed");
+async function abortOwnPullState(cwd, pullExitCode2, env) {
+  if (pullExitCode2 !== 1) return;
+  try {
+    const [mergeHead, rebaseMergeDir, rebaseApplyDir] = await gitPaths(
+      cwd,
+      ["MERGE_HEAD", "rebase-merge", "rebase-apply"],
+      env
+    );
+    if (fs7.existsSync(mergeHead)) {
+      const upstream = await upstreamSha(cwd, env);
+      if (upstream && readTrimmed(mergeHead) === upstream) {
+        await runGit(cwd, ["merge", "--abort"], env);
+      }
+      return;
+    }
+    for (const dir of [rebaseMergeDir, rebaseApplyDir]) {
+      if (!fs7.existsSync(dir)) continue;
+      const headName = readTrimmed(path6.join(dir, "head-name")).replace(
+        /^refs\/heads\//,
+        ""
+      );
+      const upstream = headName ? await upstreamSha(cwd, env, headName) : "";
+      if (upstream && readTrimmed(path6.join(dir, "onto")) === upstream) {
+        await runGit(cwd, ["rebase", "--abort"], env);
+      }
+      return;
+    }
+  } catch {
+  }
+}
+__name(abortOwnPullState, "abortOwnPullState");
+async function stashEntries(cwd, env) {
+  const raw = await runGit(cwd, ["stash", "list", "--format=%H%x00%s"], env);
+  return raw.split("\n").filter((line) => line.includes("\0")).map((line) => {
+    const [sha, subject] = line.split("\0");
+    return { sha, subject: subject ?? "" };
+  });
+}
+__name(stashEntries, "stashEntries");
+function parseDroppedStashSha(output) {
+  const match = /\(([0-9a-f]{40,64})\)\s*$/m.exec(output.trim());
+  return match?.[1];
+}
+__name(parseDroppedStashSha, "parseDroppedStashSha");
+async function restoreStash(cwd, sha, env) {
+  let output = "";
+  try {
+    await runGit(cwd, ["stash", "apply", sha], env);
+  } catch (err) {
+    return { restored: false, output: gitDetail(err) };
+  }
+  let entries;
+  try {
+    entries = await stashEntries(cwd, env);
+  } catch (err) {
+    return {
+      restored: true,
+      output: `restored, but stash entry ${sha} was kept because the stash could not be listed:
+${gitDetail(err)}`
+    };
+  }
+  const index = entries.findIndex((entry) => entry.sha === sha);
+  if (index === -1) return { restored: true, output };
+  const slot = `stash@{${index}}`;
+  let dropped;
+  try {
+    dropped = parseDroppedStashSha(
+      await runGit(cwd, ["stash", "drop", slot], env)
+    );
+  } catch (err) {
+    return {
+      restored: true,
+      output: `restored, but stash entry ${slot} (${sha}) could not be dropped:
+${gitDetail(err)}`
+    };
+  }
+  if (dropped !== void 0 && dropped !== sha) {
+    const subject = (await runGit(cwd, ["log", "-1", "--format=%s", dropped], env).catch(
+      () => ""
+    )).trim();
+    const storeArgs = ["stash", "store", "--quiet"];
+    if (subject) storeArgs.push("-m", subject);
+    storeArgs.push(dropped);
+    const stored = await runGit(cwd, storeArgs, env).then(() => true).catch(() => false);
+    output = stored ? `restored; stash entry ${sha} was kept because the stash changed while dropping it` : `restored; stash entry ${sha} was kept because the stash changed while dropping it, and the displaced entry ${dropped} could not be stored back \u2014 recover it with: git stash store ${dropped}`;
+  }
+  return { restored: true, output };
+}
+__name(restoreStash, "restoreStash");
+function pullArgs(opts) {
+  const args = ["pull"];
+  if (opts?.rebase) args.push("--rebase");
+  return args;
+}
+__name(pullArgs, "pullArgs");
+async function validatedUpstream(cwd, env) {
+  const sha = await upstreamSha(cwd, env);
+  if (sha) return sha;
+  let branch;
+  try {
+    branch = (await runGit(cwd, ["symbolic-ref", "--quiet", "--short", "HEAD"], env)).trim();
+  } catch {
+    throw new GitPullFailure(
+      "pull_failed",
+      "cannot update: HEAD is detached; check out a branch from a terminal first"
+    );
+  }
+  const configured = (await runGit(
+    cwd,
+    ["for-each-ref", "--format=%(upstream)", `refs/heads/${branch}`],
+    env
+  ).catch(() => "")).trim();
+  if (configured) {
+    throw new GitPullFailure(
+      "pull_failed",
+      "cannot update: the upstream branch no longer exists on the remote; nothing was changed"
+    );
+  }
+  await runGit(cwd, ["rev-parse", "--abbrev-ref", "@{upstream}"], env);
+  throw new GitPullFailure(
+    "pull_failed",
+    "cannot update: the upstream branch could not be resolved; nothing was changed"
+  );
+}
+__name(validatedUpstream, "validatedUpstream");
+async function pushAutoStash(cwd, env) {
+  const before = new Set((await stashEntries(cwd, env)).map((e) => e.sha));
+  await refuseOperationInProgress(cwd, env);
+  try {
+    await runGit(
+      cwd,
+      ["stash", "push", "--include-untracked", "-m", AUTO_STASH_MESSAGE],
+      env
+    );
+  } catch (err) {
+    throw new GitPullFailure(
+      "pull_failed",
+      `cannot stash the local changes, so the update was not attempted:
+${gitDetail(err)}`
+    );
+  }
+  let after;
+  try {
+    after = await stashEntries(cwd, env);
+  } catch (err) {
+    throw new GitPullFailure(
+      "pull_failed",
+      `cannot identify the auto-stash entry, so the update was not attempted; your changes are in the entry labelled "${AUTO_STASH_MESSAGE}" in git stash list:
+${gitDetail(err)}`
+    );
+  }
+  const created = after.filter(
+    (e) => !before.has(e.sha) && e.subject.endsWith(AUTO_STASH_MESSAGE)
+  );
+  return created.length > 0 ? created[created.length - 1].sha : void 0;
+}
+__name(pushAutoStash, "pushAutoStash");
+async function stashPull(cwd, opts, env) {
+  await refuseOperationInProgress(cwd, env);
+  await runGit(cwd, ["fetch", "--prune"], env);
+  await validatedUpstream(cwd, env);
+  const stashed = await pushAutoStash(cwd, env);
+  let output;
+  try {
+    output = (await runGit(cwd, pullArgs(opts), env)).trim();
+  } catch (err) {
+    const detail = gitDetail(err);
+    await abortOwnPullState(cwd, pullExitCode(err), env);
+    if (stashed === void 0) {
+      throw new GitPullFailure("pull_failed", `update failed:
+${detail}`);
+    }
+    const restore2 = await restoreStash(cwd, stashed, env);
+    throw new GitPullFailure(
+      "pull_failed",
+      restore2.restored ? `update failed; your local changes were restored${restore2.output ? ` (${restore2.output})` : ""}:
+${detail}` : `update failed and your local changes could not be restored automatically; they are kept in stash entry ${stashed}:
+${restore2.output}
+${detail}`
+    );
+  }
+  if (stashed === void 0) return { success: true, output };
+  const restore = await restoreStash(cwd, stashed, env);
+  if (restore.restored) {
+    if (restore.output === "") return { success: true, output };
+    return {
+      success: true,
+      stashKept: true,
+      stashSha: stashed,
+      output: `${output}
+${restore.output}`.trim()
+    };
+  }
+  return {
+    success: true,
+    stashRestoreConflict: true,
+    stashSha: stashed,
+    output: `${output}
+restoring your local changes failed; they are kept in stash entry ${stashed}:
+${restore.output}`.trim()
+  };
+}
+__name(stashPull, "stashPull");
+async function forcePull(cwd, env) {
+  await refuseOperationInProgress(cwd, env);
+  const toplevel = (await runGit(cwd, ["rev-parse", "--show-toplevel"], env)).trim();
+  if (await fs7.promises.realpath(cwd) !== await fs7.promises.realpath(toplevel)) {
+    throw new GitPullFailure(
+      "force_unsupported",
+      "cannot discard changes: the workspace is a subdirectory of its repository, so discarding would also reset changes outside the workspace; resolve them from a terminal"
+    );
+  }
+  await runGit(cwd, ["fetch", "--prune"], env);
+  const validated = await validatedUpstream(cwd, env);
+  try {
+    await runGit(cwd, ["merge-base", "--is-ancestor", "HEAD", validated], env);
+  } catch (err) {
+    if (exitCode(err) === 1) {
+      throw new GitPullFailure(
+        "diverged",
+        "cannot discard and update: the branch has diverged from its upstream; merge or rebase the local commits from a terminal first"
+      );
+    }
+    throw err;
+  }
+  await refuseOperationInProgress(cwd, env);
+  await runGit(cwd, ["reset", "--hard"], env);
+  await runGit(cwd, ["clean", "-fd"], env);
+  let output;
+  try {
+    output = await runGit(cwd, ["merge", "--ff-only", validated], env);
+  } catch (err) {
+    throw new GitPullFailure(
+      "pull_failed",
+      `discard applied, but the update failed:
+${gitDetail(err)}`
+    );
+  }
+  return { success: true, output: output.trim() };
+}
+__name(forcePull, "forcePull");
+async function gitPull(cwd, opts, env) {
+  if (opts?.stash && opts?.force) {
+    throw new Error("stash and force are mutually exclusive");
+  }
+  if (opts?.fetchOnly && (opts?.stash || opts?.force)) {
+    throw new Error("fetchOnly cannot be combined with stash or force");
+  }
+  if (opts?.fetchOnly) {
+    const output2 = await runGit(cwd, ["fetch", "--all", "--prune"], env);
+    return { success: true, output: output2.trim() };
+  }
+  if (opts?.force) return forcePull(cwd, env);
+  if (opts?.stash) return stashPull(cwd, opts, env);
+  const output = await runGit(cwd, pullArgs(opts), env);
+  return { success: true, output: output.trim() };
+}
+__name(gitPull, "gitPull");
+async function gitCommit(cwd, message, opts, env) {
+  let savedIndex = null;
+  if (opts?.all) {
+    const tree = (await runGit(cwd, ["write-tree"], env).catch(() => "")).trim();
+    if (tree) {
+      savedIndex = tree;
+    } else {
+      const unmerged = (await runGit(cwd, ["ls-files", "--unmerged"], env)).trim();
+      if (unmerged) {
+        throw new Error(
+          "cannot stage all changes: unresolved merge conflicts in the index"
+        );
+      }
+      throw new Error(
+        "cannot stage all changes: failed to snapshot index (write-tree failed)"
+      );
+    }
+  }
+  try {
+    if (opts?.all) {
+      await runGit(cwd, ["add", "-A"], env);
+    }
+    await runGit(cwd, ["commit", "-m", message], env);
+  } catch (err) {
+    if (savedIndex) {
+      await runGit(cwd, ["read-tree", savedIndex], env).catch((rollbackErr) => {
+        console.error("git index rollback failed:", rollbackErr);
+      });
+    }
+    throw err;
+  }
+  const sha = (await runGit(cwd, ["rev-parse", "--short", "HEAD"], env)).trim();
+  const subject = (await runGit(cwd, ["log", "-1", "--format=%s"], env)).trim();
+  return { sha, subject };
+}
+__name(gitCommit, "gitCommit");
+
+// packages/core/src/utils/gitDiff.ts
+var execFileAsync2 = promisify2(execFile2);
+var GIT_TIMEOUT_MS2 = 5e3;
 var MAX_FILES = 50;
 var MAX_DIFF_SIZE_BYTES = 1e6;
 var MAX_LINES_PER_FILE = 400;
@@ -16786,7 +17766,7 @@ async function fetchGitDiff(cwd) {
   if (!gitRoot) return null;
   if (await isInTransientGitState(gitRoot)) return null;
   const [shortstatOut, untrackedOut] = await Promise.all([
-    runGit(
+    runGit2(
       [
         "--no-optional-locks",
         "diff",
@@ -16797,7 +17777,7 @@ async function fetchGitDiff(cwd) {
       ],
       gitRoot
     ),
-    runGit(
+    runGit2(
       [
         "--no-optional-locks",
         "ls-files",
@@ -16820,7 +17800,7 @@ async function fetchGitDiff(cwd) {
     };
   }
   const [numstatOut, nameStatusOut] = await Promise.all([
-    runGit(
+    runGit2(
       [
         "--no-optional-locks",
         "diff",
@@ -16832,7 +17812,7 @@ async function fetchGitDiff(cwd) {
       ],
       gitRoot
     ),
-    runGit(
+    runGit2(
       [
         "--no-optional-locks",
         "diff",
@@ -16859,7 +17839,7 @@ async function fetchGitDiff(cwd) {
     const lineStats = await mapWithConcurrency(
       untrackedPaths,
       MAX_FILES,
-      (relPath) => countUntrackedLines(path5.join(gitRoot, relPath))
+      (relPath) => countUntrackedLines(path7.join(gitRoot, relPath))
     );
     for (const s3 of lineStats) stats.linesAdded += s3.added;
     const remainingSlots = Math.max(0, MAX_FILES - perFileStats.size);
@@ -16887,7 +17867,7 @@ async function fetchGitDiffHunks(cwd) {
   const gitRoot = findGitRoot(cwd);
   if (!gitRoot) return /* @__PURE__ */ new Map();
   if (await isInTransientGitState(gitRoot)) return /* @__PURE__ */ new Map();
-  const diffOut = await runGit(
+  const diffOut = await runGit2(
     ["--no-optional-locks", "diff", "--no-ext-diff", "--no-textconv", "HEAD"],
     gitRoot
   );
@@ -16912,7 +17892,7 @@ async function fetchGitDiffHunksForFile(cwd, filePath, oldPath) {
   diffArgs.push("HEAD", "--");
   if (oldRelPath != null) diffArgs.push(oldRelPath);
   diffArgs.push(relPath);
-  const diffOut = await runGit(diffArgs, gitRoot);
+  const diffOut = await runGit2(diffArgs, gitRoot);
   if (diffOut == null) return null;
   const truncatedPaths = /* @__PURE__ */ new Set();
   const parsed = parseGitDiff(diffOut, truncatedPaths);
@@ -16920,7 +17900,7 @@ async function fetchGitDiffHunksForFile(cwd, filePath, oldPath) {
     const [key, hunks] = parsed.entries().next().value;
     return { hunks: hunks ?? [], truncated: truncatedPaths.has(key) };
   }
-  const untrackedOut = await runGit(
+  const untrackedOut = await runGit2(
     [
       "--no-optional-locks",
       "ls-files",
@@ -16938,7 +17918,7 @@ async function fetchGitDiffHunksForFile(cwd, filePath, oldPath) {
 }
 __name(fetchGitDiffHunksForFile, "fetchGitDiffHunksForFile");
 function toRepoRelativePath(gitRoot, filePath) {
-  if (!path5.isAbsolute(filePath)) {
+  if (!path7.isAbsolute(filePath)) {
     if (filePath.length === 0) return null;
     if (filePath.startsWith("/") || filePath.startsWith("\\")) return null;
     if (/^[A-Za-z]:/.test(filePath)) return null;
@@ -16946,16 +17926,16 @@ function toRepoRelativePath(gitRoot, filePath) {
       return null;
     return filePath;
   }
-  const rel = path5.relative(gitRoot, filePath);
-  if (rel === "" || rel === ".." || rel.startsWith(`..${path5.sep}`) || path5.isAbsolute(rel))
+  const rel = path7.relative(gitRoot, filePath);
+  if (rel === "" || rel === ".." || rel.startsWith(`..${path7.sep}`) || path7.isAbsolute(rel))
     return null;
   return rel;
 }
 __name(toRepoRelativePath, "toRepoRelativePath");
 async function synthesizeUntrackedHunk(gitRoot, filePath) {
-  const absPath = path5.join(gitRoot, filePath);
+  const absPath = path7.join(gitRoot, filePath);
   try {
-    const lst = await lstat2(absPath);
+    const lst = await lstat3(absPath);
     if (!lst.isFile()) return null;
   } catch {
     return null;
@@ -17286,7 +18266,7 @@ __name(splitNulDelimited, "splitNulDelimited");
 async function countUntrackedLines(absPath) {
   let st2;
   try {
-    st2 = await lstat2(absPath);
+    st2 = await lstat3(absPath);
   } catch {
     return { added: 0, isBinary: true, truncated: false };
   }
@@ -17348,16 +18328,16 @@ async function resolveGitDir(cwd) {
 }
 __name(resolveGitDir, "resolveGitDir");
 async function resolveGitDirFromRoot(gitRoot) {
-  const dotGit = path5.join(gitRoot, ".git");
+  const dotGit = path7.join(gitRoot, ".git");
   try {
-    const s3 = await stat(dotGit);
+    const s3 = await stat2(dotGit);
     if (s3.isDirectory()) return dotGit;
     if (!s3.isFile()) return null;
     const content = await readFile2(dotGit, "utf8");
     const match = content.match(/^gitdir:\s*(.+?)\s*$/m);
     if (!match || !match[1]) return null;
     const raw = match[1];
-    return path5.isAbsolute(raw) ? raw : path5.resolve(gitRoot, raw);
+    return path7.isAbsolute(raw) ? raw : path7.resolve(gitRoot, raw);
   } catch {
     return null;
   }
@@ -17375,7 +18355,7 @@ async function isInTransientGitState(gitRoot) {
   ];
   const results = await Promise.all(
     transientPaths.map(
-      (name) => access(path5.join(gitDir, name)).then(() => true).catch(() => false)
+      (name) => access2(path7.join(gitDir, name)).then(() => true).catch(() => false)
     )
   );
   return results.some(Boolean);
@@ -17395,28 +18375,45 @@ async function mapWithConcurrency(items, limit, fn) {
   return results;
 }
 __name(mapWithConcurrency, "mapWithConcurrency");
-async function runGit(args, cwd) {
+async function runGit2(args, cwd, env) {
   const fullArgs = ["-c", "core.quotepath=false", ...NO_EXEC_CONFIG, ...args];
   try {
-    const { stdout } = await execFileAsync("git", fullArgs, {
+    const { stdout } = await execFileAsync2("git", fullArgs, {
       cwd,
-      timeout: GIT_TIMEOUT_MS,
+      timeout: GIT_TIMEOUT_MS2,
       maxBuffer: 64 * 1024 * 1024,
       windowsHide: true,
-      encoding: "utf8"
+      encoding: "utf8",
+      // Given one, the caller's environment and not the process's: a daemon
+      // serving several workspaces runs git for each in that workspace's own
+      // environment, with the variables that would point git at some other
+      // repository taken out. Without one, the process's, as before.
+      ...env ? { env: gitEnv(env) } : {}
     });
     return stdout;
   } catch {
     return null;
   }
 }
-__name(runGit, "runGit");
-async function getGitWorkingTreeStatus(cwd) {
+__name(runGit2, "runGit");
+async function getGitWorkingTreeStatus(cwd, options2 = {}) {
   const gitRoot = findGitRoot(cwd);
   if (!gitRoot) return null;
-  const stdout = await runGit(
-    ["--no-optional-locks", "status", "--porcelain=v1", "--branch", "-z"],
-    gitRoot
+  const stdout = await runGit2(
+    [
+      "--no-optional-locks",
+      // A repository can set `status.showUntrackedFiles = no`, which hides
+      // untracked files from `git status` — and from git's own safety check.
+      // A caller about to destroy the directory asks for them anyway;
+      // `normal` is the default, so the output it gets is the ordinary one.
+      ...options2.countHiddenUntracked ? ["-c", "status.showUntrackedFiles=normal"] : [],
+      "status",
+      "--porcelain=v1",
+      "--branch",
+      "-z"
+    ],
+    gitRoot,
+    options2.env
   );
   if (stdout == null) return null;
   const tokens = stdout.split("\0");
@@ -17522,7 +18519,7 @@ async function detectGitOperation(gitRoot) {
   ];
   for (const [name, op] of checks) {
     try {
-      await access(path5.join(gitDir, name));
+      await access2(path7.join(gitDir, name));
       return op;
     } catch {
     }
@@ -17531,18 +18528,18 @@ async function detectGitOperation(gitRoot) {
 }
 __name(detectGitOperation, "detectGitOperation");
 async function resolveCommonGitDir(gitDir) {
-  const raw = (await readFirstLineNoFollow(path5.join(gitDir, "commondir")))?.trim();
+  const raw = (await readFirstLineNoFollow(path7.join(gitDir, "commondir")))?.trim();
   if (!raw) return gitDir;
-  return path5.isAbsolute(raw) ? raw : path5.resolve(gitDir, raw);
+  return path7.isAbsolute(raw) ? raw : path7.resolve(gitDir, raw);
 }
 __name(resolveCommonGitDir, "resolveCommonGitDir");
 async function countStashEntries(gitRoot) {
   const gitDir = await resolveGitDirFromRoot(gitRoot);
   if (!gitDir) return 0;
   const commonDir = await resolveCommonGitDir(gitDir);
-  const stashLog = path5.join(commonDir, "logs", "refs", "stash");
+  const stashLog = path7.join(commonDir, "logs", "refs", "stash");
   try {
-    const st2 = await lstat2(stashLog);
+    const st2 = await lstat3(stashLog);
     if (!st2.isFile()) return 0;
   } catch {
     return 0;
@@ -17604,7 +18601,7 @@ async function fetchGitLog(cwd, options2) {
   if (search) {
     return searchGitLog(gitRoot, revisions, search, limit, skip);
   }
-  const stdout = await runGit(
+  const stdout = await runGit2(
     [
       "--no-optional-locks",
       "log",
@@ -17620,7 +18617,7 @@ async function fetchGitLog(cwd, options2) {
     gitRoot
   );
   if (stdout === null) {
-    const head = await runGit(["rev-parse", "--verify", "HEAD"], gitRoot);
+    const head = await runGit2(["rev-parse", "--verify", "HEAD"], gitRoot);
     return head === null ? { entries: [], hasMore: false } : null;
   }
   const entries = parseLogRecords(stdout);
@@ -17629,7 +18626,7 @@ async function fetchGitLog(cwd, options2) {
 __name(fetchGitLog, "fetchGitLog");
 async function searchGitLog(gitRoot, revisions, query, limit, skip) {
   const window2 = String(skip + limit + 1);
-  const walk = /* @__PURE__ */ __name((filter) => runGit(
+  const walk = /* @__PURE__ */ __name((filter) => runGit2(
     [
       "--no-optional-locks",
       "log",
@@ -17649,7 +18646,7 @@ async function searchGitLog(gitRoot, revisions, query, limit, skip) {
   const runs = [walk(`--grep=${query}`), walk(`--author=${query}`)];
   if (/^[0-9a-f]{4,40}$/i.test(query)) {
     runs.push(
-      runGit(
+      runGit2(
         [
           "rev-parse",
           "--verify",
@@ -17659,7 +18656,7 @@ async function searchGitLog(gitRoot, revisions, query, limit, skip) {
         ],
         gitRoot
       ).then(
-        (sha) => sha ? runGit(
+        (sha) => sha ? runGit2(
           [
             "--no-optional-locks",
             "log",
@@ -17692,7 +18689,7 @@ async function fetchGitCommitDetail(cwd, sha) {
   if (!/^[0-9a-f]{7,40}$/i.test(sha)) return null;
   const gitRoot = findGitRoot(cwd);
   if (!gitRoot) return null;
-  const metaRaw = await runGit(
+  const metaRaw = await runGit2(
     [
       "--no-optional-locks",
       "log",
@@ -17739,7 +18736,7 @@ async function fetchGitCommitDetail(cwd, sha) {
     "--root",
     sha
   ];
-  const numstatRaw = await runGit(diffTreeArgs, gitRoot);
+  const numstatRaw = await runGit2(diffTreeArgs, gitRoot);
   const files = [];
   let filesCount = 0;
   let linesAdded = 0;
@@ -17779,7 +18776,7 @@ async function fetchGitCommitDetail(cwd, sha) {
 __name(fetchGitCommitDetail, "fetchGitCommitDetail");
 
 // packages/core/src/services/fileHistoryService.ts
-var debugLogger12 = createDebugLogger("FILE_HISTORY");
+var debugLogger13 = createDebugLogger("FILE_HISTORY");
 var MAX_SNAPSHOTS = 100;
 var FILE_HISTORY_DIR = "file-history";
 function serializeSnapshot(s3) {
@@ -17831,7 +18828,7 @@ function isENOENT(e) {
 __name(isENOENT, "isENOENT");
 async function pathExists(filePath) {
   try {
-    await stat2(filePath);
+    await stat3(filePath);
     return true;
   } catch {
     return false;
@@ -17852,12 +18849,12 @@ function getBackupFileName(filePath, version3) {
 }
 __name(getBackupFileName, "getBackupFileName");
 function resolveBackupPath(backupFileName, sessionId) {
-  const baseDir = resolve2(
+  const baseDir = resolve4(
     Storage.getGlobalQwenDir(),
     FILE_HISTORY_DIR,
     sessionId
   );
-  const backupPath = resolve2(baseDir, backupFileName);
+  const backupPath = resolve4(baseDir, backupFileName);
   if (!backupPath.startsWith(baseDir + sep2)) {
     throw new Error(`backupFileName escapes base directory: ${backupFileName}`);
   }
@@ -17882,7 +18879,7 @@ async function createBackup(filePath, version3, sessionId) {
   const backupPath = resolveBackupPath(backupFileName, sessionId);
   let srcStats;
   try {
-    srcStats = await stat2(filePath);
+    srcStats = await stat3(filePath);
   } catch (e) {
     if (isENOENT(e)) {
       return { backupFileName: null, version: version3, backupTime: /* @__PURE__ */ new Date() };
@@ -17901,17 +18898,17 @@ async function restoreBackup(filePath, backupFileName, sessionId) {
   const backupPath = resolveBackupPath(backupFileName, sessionId);
   let backupStats;
   try {
-    backupStats = await stat2(backupPath);
+    backupStats = await stat3(backupPath);
   } catch (e) {
     if (isENOENT(e)) {
-      debugLogger12.error(`FileHistory: Backup file not found: ${backupPath}`);
+      debugLogger13.error(`FileHistory: Backup file not found: ${backupPath}`);
       return false;
     }
     throw e;
   }
   const result = await safeCopyFile(backupPath, filePath);
   if (result === "src-missing") {
-    debugLogger12.error(
+    debugLogger13.error(
       `FileHistory: Backup file disappeared during restore: ${backupPath}`
     );
     return false;
@@ -17925,14 +18922,14 @@ async function checkOriginFileChanged(originalFile, backupFileName, sessionId, o
   let originalStats = originalStatsHint ?? null;
   if (!originalStats) {
     try {
-      originalStats = await stat2(originalFile);
+      originalStats = await stat3(originalFile);
     } catch (e) {
       if (!isENOENT(e)) return true;
     }
   }
   let backupStats;
   try {
-    backupStats = await stat2(backupPath);
+    backupStats = await stat3(backupPath);
   } catch {
     return true;
   }
@@ -17972,7 +18969,7 @@ async function computeDiffStatsForFile(originalFile, backupFileName, sessionId)
       if (c.removed) deletions += c.count || 0;
     }
   } catch (error3) {
-    debugLogger12.error(`FileHistory: Error generating diffStats: ${error3}`);
+    debugLogger13.error(`FileHistory: Error generating diffStats: ${error3}`);
   }
   return { filesChanged, insertions, deletions };
 }
@@ -18000,7 +18997,7 @@ async function readPathWithSizeGuard(path81, kind) {
       }
       return { kind: "unreadable" };
     }
-    debugLogger12.error(`FileHistory: ${kind} open failed for ${path81}: ${e}`);
+    debugLogger13.error(`FileHistory: ${kind} open failed for ${path81}: ${e}`);
     return { kind: "unreadable" };
   }
   try {
@@ -18012,7 +19009,7 @@ async function readPathWithSizeGuard(path81, kind) {
       const text = await fh.readFile("utf-8");
       return { kind: "ok", content: text, exists: true };
     } catch (e) {
-      debugLogger12.error(`FileHistory: ${kind} read failed for ${path81}: ${e}`);
+      debugLogger13.error(`FileHistory: ${kind} read failed for ${path81}: ${e}`);
       return { kind: "unreadable" };
     }
   } finally {
@@ -18074,7 +19071,7 @@ var FileHistoryService = class {
     try {
       this.onSnapshotUpdated?.(snapshot);
     } catch (error3) {
-      debugLogger12.error(`FileHistory: recordSnapshotUpdate failed: ${error3}`);
+      debugLogger13.error(`FileHistory: recordSnapshotUpdate failed: ${error3}`);
     }
   }
   restoreFromSnapshots(snapshots) {
@@ -18115,7 +19112,7 @@ var FileHistoryService = class {
           try {
             backupPath = resolveBackupPath(name, this.sessionId);
           } catch (e) {
-            debugLogger12.error(
+            debugLogger13.error(
               `FileHistory: rejected backupFileName during validation: ${name}: ${e}`
             );
             return false;
@@ -18140,7 +19137,7 @@ var FileHistoryService = class {
     for (const snapshot of affectedSnapshots) {
       this.recordSnapshotUpdate(snapshot);
     }
-    debugLogger12.warn(
+    debugLogger13.warn(
       `FileHistory: ${missing.size} restored backup file(s) missing on disk`
     );
   }
@@ -18149,7 +19146,7 @@ var FileHistoryService = class {
     const trackingPath = this.maybeShortenFilePath(filePath);
     const mostRecent = this.state.snapshots.at(-1);
     if (!mostRecent) {
-      debugLogger12.error("FileHistory: Missing most recent snapshot");
+      debugLogger13.error("FileHistory: Missing most recent snapshot");
       return;
     }
     const existing = mostRecent.trackedFileBackups[trackingPath];
@@ -18161,7 +19158,7 @@ var FileHistoryService = class {
     try {
       backup = await createBackup(filePath, maxVersion + 1, this.sessionId);
     } catch (error3) {
-      debugLogger12.error(`FileHistory: trackEdit failed: ${error3}`);
+      debugLogger13.error(`FileHistory: trackEdit failed: ${error3}`);
       return;
     }
     if (!this.state.snapshots.includes(mostRecent)) {
@@ -18172,7 +19169,7 @@ var FileHistoryService = class {
       mostRecent.trackedFileBackups[trackingPath] = backup;
       this.state.trackedFiles.add(trackingPath);
       this.recordSnapshotUpdate(mostRecent);
-      debugLogger12.debug(
+      debugLogger13.debug(
         `FileHistory: Tracked file modification for ${filePath}`
       );
     }
@@ -18194,7 +19191,7 @@ var FileHistoryService = class {
             const nextVersion = this.getMaxVersion(trackingPath) + 1;
             let fileStats;
             try {
-              fileStats = await stat2(filePath);
+              fileStats = await stat3(filePath);
             } catch (e) {
               if (!isENOENT(e)) throw e;
             }
@@ -18221,7 +19218,7 @@ var FileHistoryService = class {
               this.sessionId
             );
           } catch (error3) {
-            debugLogger12.error(
+            debugLogger13.error(
               `FileHistory: Failed to backup file ${trackingPath}: ${error3}`
             );
             const previous = mostRecent?.trackedFileBackups[trackingPath];
@@ -18252,7 +19249,7 @@ var FileHistoryService = class {
       this.state.snapshots = this.state.snapshots.slice(overflow);
       await this.cleanupOrphanedBackups(removed);
     }
-    debugLogger12.debug(
+    debugLogger13.debug(
       `FileHistory: Added snapshot for ${promptId}, tracking ${this.state.trackedFiles.size} files`
     );
   }
@@ -18262,7 +19259,7 @@ var FileHistoryService = class {
     if (!targetSnapshot) {
       throw new Error("The selected snapshot was not found");
     }
-    debugLogger12.debug(`FileHistory: Rewinding to snapshot for ${promptId}`);
+    debugLogger13.debug(`FileHistory: Rewinding to snapshot for ${promptId}`);
     const result = await this.applySnapshot(targetSnapshot);
     if (truncateHistory && result.filesFailed.length === 0) {
       const targetIdx = this.state.snapshots.indexOf(targetSnapshot);
@@ -18277,7 +19274,7 @@ var FileHistoryService = class {
         await this.cleanupOrphanedBackups(removed);
       }
     }
-    debugLogger12.debug(`FileHistory: Finished rewinding to ${promptId}`);
+    debugLogger13.debug(`FileHistory: Finished rewinding to ${promptId}`);
     return result;
   }
   async getDiffStats(promptId) {
@@ -18305,7 +19302,7 @@ var FileHistoryService = class {
           }
           return null;
         } catch (error3) {
-          debugLogger12.error(
+          debugLogger13.error(
             `FileHistory: Error computing diff stats: ${error3}`
           );
           return null;
@@ -18351,7 +19348,7 @@ var FileHistoryService = class {
       candidatePaths.length - MAX_TURN_DIFF_FILES
     );
     if (filesOmitted > 0) {
-      debugLogger12.warn(
+      debugLogger13.warn(
         `FileHistory: getTurnDiff truncating ${filesOmitted} files for prompt ${promptId} (cap: ${MAX_TURN_DIFF_FILES})`
       );
     }
@@ -18387,7 +19384,7 @@ var FileHistoryService = class {
     try {
       return await this.computeTurnFileDiffUnsafe(trackingPath, before, after);
     } catch (e) {
-      debugLogger12.error(
+      debugLogger13.error(
         `FileHistory: computeTurnFileDiff failed for ${trackingPath}: ${e}`
       );
       return null;
@@ -18414,14 +19411,14 @@ var FileHistoryService = class {
       this.sessionId
     );
     if (beforeRead.kind === "unreadable") {
-      debugLogger12.warn(
+      debugLogger13.warn(
         `FileHistory: skipping turn diff for ${trackingPath}: before backup unreadable`
       );
       return null;
     }
     const afterRead = afterFromWorktree ? await readEndpointContent(void 0, absoluteFilePath, this.sessionId) : await readEndpointContent(afterBackup, void 0, this.sessionId);
     if (afterRead.kind === "unreadable") {
-      debugLogger12.warn(
+      debugLogger13.warn(
         `FileHistory: skipping turn diff for ${trackingPath}: after ${afterFromWorktree ? "worktree" : "backup"} unreadable`
       );
       return null;
@@ -18531,7 +19528,7 @@ var FileHistoryService = class {
         }
         const backupFileName = targetBackup ? targetBackup.backupFileName : this.getBackupFileNameFirstVersion(trackingPath);
         if (backupFileName === void 0) {
-          debugLogger12.error(
+          debugLogger13.error(
             "FileHistory: Error finding the backup file to apply"
           );
           filesFailed.push(filePath);
@@ -18540,7 +19537,7 @@ var FileHistoryService = class {
         if (backupFileName === null) {
           try {
             await unlink3(filePath);
-            debugLogger12.debug(`FileHistory: Deleted ${filePath}`);
+            debugLogger13.debug(`FileHistory: Deleted ${filePath}`);
             filesChanged.push(filePath);
           } catch (e) {
             if (!isENOENT(e)) throw e;
@@ -18554,7 +19551,7 @@ var FileHistoryService = class {
             this.sessionId
           );
           if (restored) {
-            debugLogger12.debug(
+            debugLogger13.debug(
               `FileHistory: Restored ${filePath} from ${backupFileName}`
             );
             filesChanged.push(filePath);
@@ -18563,7 +19560,7 @@ var FileHistoryService = class {
           }
         }
       } catch (error3) {
-        debugLogger12.error(
+        debugLogger13.error(
           `FileHistory: Error restoring file ${trackingPath}: ${error3}`
         );
         filesFailed.push(this.maybeExpandFilePath(trackingPath));
@@ -18615,7 +19612,7 @@ var FileHistoryService = class {
           await unlink3(resolveBackupPath(name, this.sessionId));
         } catch (e) {
           if (!isENOENT(e)) {
-            debugLogger12.error(`FileHistory: cleanup failed for ${name}: ${e}`);
+            debugLogger13.error(`FileHistory: cleanup failed for ${name}: ${e}`);
           }
         }
       })
@@ -18630,7 +19627,7 @@ var FileHistoryService = class {
   }
   maybeExpandFilePath(filePath) {
     if (isAbsolute2(filePath)) return filePath;
-    return join6(this.cwd, filePath);
+    return join8(this.cwd, filePath);
   }
 };
 
@@ -18676,14 +19673,14 @@ var SessionFileHistoryAccumulator = class {
 
 // packages/core/src/utils/sessionStorageUtils.ts
 init_esbuild_shims();
-import fs6 from "node:fs";
+import fs8 from "node:fs";
 var LITE_READ_BUF_SIZE = 64 * 1024;
 function readLatestTailIfGrown(fd, previousSize, buffer) {
-  const currentSize = fs6.fstatSync(fd).size;
+  const currentSize = fs8.fstatSync(fd).size;
   if (currentSize <= previousSize) return void 0;
   const tailLength = Math.min(currentSize, LITE_READ_BUF_SIZE);
   const tailOffset = currentSize - tailLength;
-  const tailBytes = fs6.readSync(fd, buffer, 0, tailLength, tailOffset);
+  const tailBytes = fs8.readSync(fd, buffer, 0, tailLength, tailOffset);
   if (tailBytes <= 0) return void 0;
   return {
     text: buffer.toString("utf-8", 0, tailBytes),
@@ -18897,7 +19894,7 @@ __name(extractJsonStringFieldFromLastMatchingLine, "extractJsonStringFieldFromLa
 function readLastMatchingLineFieldSync(filePath, lineContains, key, scratchBuffer, recordMatches, readRecordField) {
   let fd;
   try {
-    const stats = fs6.statSync(filePath);
+    const stats = fs8.statSync(filePath);
     const fileSize = stats.size;
     if (fileSize === 0) return { matched: false, reason: "absent" };
     fd = openSyncNoFollow(filePath);
@@ -18933,7 +19930,7 @@ function readLastMatchingLineFieldSync(filePath, lineContains, key, scratchBuffe
   } finally {
     if (fd !== void 0) {
       try {
-        fs6.closeSync(fd);
+        fs8.closeSync(fd);
       } catch {
       }
     }
@@ -18969,14 +19966,14 @@ __name(extractLastJsonStringField, "extractLastJsonStringField");
 function readLastJsonStringFieldSync(filePath, key, lineContains, scratchBuffer) {
   let fd;
   try {
-    const stats = fs6.statSync(filePath);
+    const stats = fs8.statSync(filePath);
     const fileSize = stats.size;
     if (fileSize === 0) return void 0;
     fd = openSyncNoFollow(filePath);
     const tailLength = Math.min(fileSize, LITE_READ_BUF_SIZE);
     const tailOffset = fileSize - tailLength;
     const buffer = scratchBuffer && scratchBuffer.length >= LITE_READ_BUF_SIZE ? scratchBuffer : Buffer.alloc(LITE_READ_BUF_SIZE);
-    const tailBytes = fs6.readSync(fd, buffer, 0, tailLength, tailOffset);
+    const tailBytes = fs8.readSync(fd, buffer, 0, tailLength, tailOffset);
     if (tailBytes > 0) {
       const tailText = buffer.toString("utf-8", 0, tailBytes);
       const tailHit = extractLastJsonStringField(tailText, key, lineContains);
@@ -18997,7 +19994,7 @@ function readLastJsonStringFieldSync(filePath, key, lineContains, scratchBuffer)
     }
     if (tailOffset === 0) return void 0;
     const headLength = Math.min(fileSize, LITE_READ_BUF_SIZE);
-    const headBytes = fs6.readSync(fd, buffer, 0, headLength, 0);
+    const headBytes = fs8.readSync(fd, buffer, 0, headLength, 0);
     if (headBytes > 0) {
       const rawHead = buffer.toString("utf-8", 0, headBytes);
       const headText = headBytes < fileSize ? rawHead.slice(0, rawHead.lastIndexOf("\n") + 1) : rawHead;
@@ -19012,7 +20009,7 @@ function readLastJsonStringFieldSync(filePath, key, lineContains, scratchBuffer)
   } finally {
     if (fd !== void 0) {
       try {
-        fs6.closeSync(fd);
+        fs8.closeSync(fd);
       } catch {
       }
     }
@@ -19025,14 +20022,14 @@ function readLastJsonStringFieldsSync(filePath, primaryKey, otherKeys, lineConta
   for (const k2 of otherKeys) emptyResult[k2] = void 0;
   let fd;
   try {
-    const stats = fs6.statSync(filePath);
+    const stats = fs8.statSync(filePath);
     const fileSize = stats.size;
     if (fileSize === 0) return emptyResult;
     fd = openSyncNoFollow(filePath);
     const tailLength = Math.min(fileSize, LITE_READ_BUF_SIZE);
     const tailOffset = fileSize - tailLength;
     const buffer = scratchBuffer && scratchBuffer.length >= LITE_READ_BUF_SIZE ? scratchBuffer : Buffer.alloc(LITE_READ_BUF_SIZE);
-    const tailBytes = fs6.readSync(fd, buffer, 0, tailLength, tailOffset);
+    const tailBytes = fs8.readSync(fd, buffer, 0, tailLength, tailOffset);
     if (tailBytes > 0) {
       const tailText = buffer.toString("utf-8", 0, tailBytes);
       const hit = extractLastJsonStringFields(
@@ -19055,7 +20052,7 @@ function readLastJsonStringFieldsSync(filePath, primaryKey, otherKeys, lineConta
     }
     if (tailOffset === 0) return emptyResult;
     const headLength = Math.min(fileSize, LITE_READ_BUF_SIZE);
-    const headBytes = fs6.readSync(fd, buffer, 0, headLength, 0);
+    const headBytes = fs8.readSync(fd, buffer, 0, headLength, 0);
     if (headBytes > 0) {
       const rawHead = buffer.toString("utf-8", 0, headBytes);
       const headText = headBytes < fileSize ? rawHead.slice(0, rawHead.lastIndexOf("\n") + 1) : rawHead;
@@ -19073,7 +20070,7 @@ function readLastJsonStringFieldsSync(filePath, primaryKey, otherKeys, lineConta
   } finally {
     if (fd !== void 0) {
       try {
-        fs6.closeSync(fd);
+        fs8.closeSync(fd);
       } catch {
       }
     }
@@ -19099,8 +20096,8 @@ __name(readSessionTitleInfoFromFileSync, "readSessionTitleInfoFromFileSync");
 // packages/core/src/services/session-organization-service.ts
 init_esbuild_shims();
 import { randomUUID as randomUUID2 } from "node:crypto";
-import * as fs7 from "node:fs/promises";
-import * as path6 from "node:path";
+import * as fs9 from "node:fs/promises";
+import * as path8 from "node:path";
 var GROUP_COLOR_OPTIONS = [
   "red",
   "orange",
@@ -19243,7 +20240,7 @@ var SessionOrganizationService = class {
   storage;
   readFailed = false;
   getStorePath() {
-    return path6.join(this.storage.getProjectDir(), STORE_FILE);
+    return path8.join(this.storage.getProjectDir(), STORE_FILE);
   }
   async listGroups() {
     const store = await this.readStore();
@@ -19424,7 +20421,7 @@ var SessionOrganizationService = class {
   async readStore() {
     try {
       const raw = JSON.parse(
-        await fs7.readFile(this.getStorePath(), "utf8")
+        await fs9.readFile(this.getStorePath(), "utf8")
       );
       if (!isPlainRecord(raw)) {
         return this.handleUnreadableStore("store root is not an object");
@@ -19484,7 +20481,7 @@ var SessionOrganizationService = class {
     return emptyStore();
   }
   async writeStore(store, options2 = {}) {
-    await fs7.mkdir(path6.dirname(this.getStorePath()), { recursive: true });
+    await fs9.mkdir(path8.dirname(this.getStorePath()), { recursive: true });
     if (this.readFailed) {
       throw new SessionOrganizationError(
         `Cannot update session organization store because it could not be read: ${this.getStorePath()}. Delete the file to reset session organization (group/pin data will be lost), or restore it from backup.`,
@@ -19609,913 +20606,6 @@ import * as path9 from "node:path";
 init_esbuild_shims();
 import { execFile as execFile4 } from "node:child_process";
 
-// packages/core/src/utils/git-branches.ts
-init_esbuild_shims();
-import { execFile as execFile2 } from "node:child_process";
-import * as fs9 from "node:fs";
-import * as path8 from "node:path";
-import { promisify as promisify2 } from "node:util";
-
-// packages/core/src/utils/gitDirect.ts
-init_esbuild_shims();
-import * as fs8 from "node:fs";
-import * as fsPromises from "node:fs/promises";
-import * as path7 from "node:path";
-var SHORT_SHA_LENGTH = 7;
-var debug = createDebugLogger("gitDirect");
-var MAX_REF_COMPONENT_LENGTH = 255;
-var INVALID_REF_CHARS = /[\x00-\x20\x7f-\x9f\u200b-\u200d\u2028\u2029\u202a-\u202e\u2066-\u2069\ufeff~^:?*[\\]/;
-function isValidRefName(name) {
-  if (!name || name === "HEAD") return false;
-  if (name.startsWith("/") || name.endsWith("/")) return false;
-  if (name.startsWith(".") || name.endsWith(".")) return false;
-  if (name.endsWith(".lock")) return false;
-  if (name.includes("..") || name.includes("//")) return false;
-  if (name.includes("/.") || name.includes("./") || name.includes(".lock/")) {
-    return false;
-  }
-  if (name.includes("@{")) return false;
-  if (INVALID_REF_CHARS.test(name)) return false;
-  if (name.split("/").some((c) => c.length > MAX_REF_COMPONENT_LENGTH)) {
-    return false;
-  }
-  return true;
-}
-__name(isValidRefName, "isValidRefName");
-function isValidGitSha(value) {
-  return /^[0-9a-f]{40}$/.test(value) || /^[0-9a-f]{64}$/.test(value);
-}
-__name(isValidGitSha, "isValidGitSha");
-var gitDirCache = /* @__PURE__ */ new Map();
-async function isDir(p2) {
-  try {
-    return (await fsPromises.stat(p2)).isDirectory();
-  } catch {
-    return false;
-  }
-}
-__name(isDir, "isDir");
-async function hasGitStore(dir) {
-  const [objects, refs] = await Promise.all([
-    isDir(path7.join(dir, "objects")),
-    isDir(path7.join(dir, "refs"))
-  ]);
-  return objects && refs;
-}
-__name(hasGitStore, "hasGitStore");
-async function isRealGitDir(gitDir) {
-  if (await hasGitStore(gitDir)) return true;
-  const rel = await readFirstLineNoFollow(path7.join(gitDir, "commondir"));
-  if (!rel) return false;
-  return hasGitStore(path7.resolve(gitDir, rel.trim()));
-}
-__name(isRealGitDir, "isRealGitDir");
-async function resolveTrustedGitDir(cwd) {
-  const gitDir = await resolveGitDir(cwd);
-  if (!gitDir) return null;
-  return await isRealGitDir(gitDir) ? gitDir : null;
-}
-__name(resolveTrustedGitDir, "resolveTrustedGitDir");
-async function getCachedGitDir(cwd) {
-  const key = path7.resolve(cwd);
-  const cached3 = gitDirCache.get(key);
-  if (cached3 !== void 0) return cached3;
-  const gitDir = await resolveTrustedGitDir(key);
-  if (gitDir !== null) gitDirCache.set(key, gitDir);
-  return gitDir;
-}
-__name(getCachedGitDir, "getCachedGitDir");
-async function readGitHead(gitDir) {
-  const firstLine = await readFirstLineNoFollow(path7.join(gitDir, "HEAD"));
-  if (firstLine === null) return null;
-  const content = firstLine.trim();
-  if (content.startsWith("ref:")) {
-    const ref = content.slice(4).trim();
-    if (!ref.startsWith("refs/heads/")) return null;
-    const name = ref.slice("refs/heads/".length);
-    if (!isValidRefName(name)) return null;
-    return { type: "branch", name };
-  }
-  if (isValidGitSha(content)) {
-    return { type: "detached", name: content };
-  }
-  return null;
-}
-__name(readGitHead, "readGitHead");
-async function resolveBranchName(cwd) {
-  const gitDir = await getCachedGitDir(cwd);
-  if (!gitDir) return void 0;
-  const head = await readGitHead(gitDir);
-  if (!head) return void 0;
-  return head.type === "branch" ? head.name : head.name.slice(0, SHORT_SHA_LENGTH);
-}
-__name(resolveBranchName, "resolveBranchName");
-var repoBranchWatches = /* @__PURE__ */ new Map();
-async function watchRepoBranch(cwd, onChange) {
-  const gitDir = await getCachedGitDir(cwd);
-  if (!gitDir) return () => {
-  };
-  let entry = repoBranchWatches.get(gitDir);
-  if (!entry) {
-    const logsHeadPath = path7.join(gitDir, "logs", "HEAD");
-    try {
-      await fsPromises.access(logsHeadPath, fs8.constants?.F_OK ?? 0);
-      if ((await fsPromises.lstat(logsHeadPath)).isSymbolicLink()) {
-        return () => {
-        };
-      }
-    } catch {
-      return () => {
-      };
-    }
-    const existing = repoBranchWatches.get(gitDir);
-    if (existing) {
-      entry = existing;
-    } else {
-      let watcher;
-      try {
-        watcher = fs8.watch(logsHeadPath, (eventType) => {
-          if (eventType === "change" || eventType === "rename") {
-            repoBranchWatches.get(gitDir)?.subscribers.forEach((cb) => {
-              try {
-                cb();
-              } catch {
-              }
-            });
-          }
-        });
-      } catch (err) {
-        debug.warn(`failed to watch reflog for ${gitDir}: ${err}`);
-        return () => {
-        };
-      }
-      watcher.on("error", (err) => {
-        debug.warn(
-          `reflog watcher error for ${gitDir}; branch will no longer auto-update: ${err?.message}`
-        );
-        const current = repoBranchWatches.get(gitDir);
-        if (current?.watcher === watcher) {
-          try {
-            watcher.close();
-          } catch {
-          }
-          repoBranchWatches.delete(gitDir);
-        }
-      });
-      entry = { watcher, subscribers: /* @__PURE__ */ new Set() };
-      repoBranchWatches.set(gitDir, entry);
-    }
-  }
-  entry.subscribers.add(onChange);
-  let disposed = false;
-  return () => {
-    if (disposed) return;
-    disposed = true;
-    const e = repoBranchWatches.get(gitDir);
-    if (!e) return;
-    e.subscribers.delete(onChange);
-    if (e.subscribers.size === 0) {
-      e.watcher.close();
-      repoBranchWatches.delete(gitDir);
-    }
-  };
-}
-__name(watchRepoBranch, "watchRepoBranch");
-
-// packages/core/src/utils/git-branches.ts
-var debugLogger13 = createDebugLogger("GIT_BRANCHES");
-var execFileAsync2 = promisify2(execFile2);
-var GIT_TIMEOUT_MS2 = 3e4;
-var MAX_RECENT_BRANCHES = 20;
-var MAX_REFLOG_ENTRIES = 200;
-var GIT_ENV_VARS_TO_CLEAR = [
-  "GIT_DIR",
-  "GIT_WORK_TREE",
-  "GIT_COMMON_DIR",
-  "GIT_INDEX_FILE",
-  "GIT_CONFIG_GLOBAL",
-  "GIT_CONFIG_SYSTEM",
-  "GIT_CONFIG_NOSYSTEM",
-  // Repository selectors that an inherited daemon environment could use to
-  // redirect a trusted-workspace git/gh invocation to a different repository
-  // or object database despite the resolved cwd.
-  "GH_REPO",
-  "GIT_CONFIG_COUNT",
-  "GIT_CONFIG_PARAMETERS",
-  "GIT_OBJECT_DIRECTORY",
-  "GIT_ALTERNATE_OBJECT_DIRECTORIES"
-];
-var GIT_ENV_PREFIXES_TO_CLEAR = ["GIT_CONFIG_KEY_", "GIT_CONFIG_VALUE_"];
-var HELPER_PROTOCOLS = /* @__PURE__ */ new Set(["ext", "fd"]);
-function gitEnv(base) {
-  const env = { ...base ?? process.env };
-  for (const key of GIT_ENV_VARS_TO_CLEAR) {
-    delete env[key];
-  }
-  for (const key of Object.keys(env)) {
-    if (GIT_ENV_PREFIXES_TO_CLEAR.some((prefix) => key.startsWith(prefix))) {
-      delete env[key];
-    }
-  }
-  const inheritedAllow = env["GIT_ALLOW_PROTOCOL"];
-  if (inheritedAllow !== void 0) {
-    env["GIT_ALLOW_PROTOCOL"] = inheritedAllow.split(":").filter((p2) => !HELPER_PROTOCOLS.has(p2.trim().toLowerCase())).join(":");
-  }
-  env["LC_ALL"] = "C";
-  env["LANG"] = "C";
-  return env;
-}
-__name(gitEnv, "gitEnv");
-function runGit2(cwd, args, env) {
-  return execFileAsync2("git", args, {
-    cwd,
-    timeout: GIT_TIMEOUT_MS2,
-    maxBuffer: 10 * 1024 * 1024,
-    env: gitEnv(env)
-  }).then(({ stdout }) => stdout);
-}
-__name(runGit2, "runGit");
-var SEPARATOR = "\0";
-async function fetchGitBranches(cwd, env) {
-  await runGit2(cwd, ["rev-parse", "--git-dir"], env);
-  const [localRaw, remoteRaw, tagsRaw, headRaw, reflogRaw] = await Promise.all([
-    runGit2(
-      cwd,
-      [
-        "for-each-ref",
-        "--format=%(refname:short)%00%(HEAD)%00%(upstream:short)%00%(upstream:track,nobracket)%00%(committerdate:unix)%00%(subject)%00%(symref)%00%(push:short)%00%(push:track,nobracket)",
-        "refs/heads/"
-      ],
-      env
-    ).catch(() => ""),
-    runGit2(
-      cwd,
-      [
-        "for-each-ref",
-        "--format=%(refname:short)%00%(HEAD)%00%(upstream:short)%00%(upstream:track,nobracket)%00%(committerdate:unix)%00%(subject)%00%(symref)%00%(push:short)%00%(push:track,nobracket)",
-        "refs/remotes/"
-      ],
-      env
-    ).catch(() => ""),
-    runGit2(
-      cwd,
-      [
-        "for-each-ref",
-        "--format=%(refname:short)%00%(creatordate:unix)%00%(subject)",
-        "--sort=-creatordate",
-        "refs/tags/"
-      ],
-      env
-    ).catch(() => ""),
-    runGit2(cwd, ["symbolic-ref", "--short", "HEAD"], env).catch(() => ""),
-    runGit2(
-      cwd,
-      ["reflog", "show", "--format=%gs", `-${MAX_REFLOG_ENTRIES}`],
-      env
-    ).catch(() => "")
-  ]);
-  const local = parseBranchLines(localRaw);
-  const remote = parseBranchLines(remoteRaw);
-  const tags = parseTagLines(tagsRaw);
-  const recent = parseRecentBranches(reflogRaw, headRaw.trim());
-  const headTrimmed = headRaw.trim();
-  const detached = !headTrimmed;
-  return {
-    local,
-    remote,
-    tags,
-    recent,
-    head: headTrimmed || await getDetachedHead(cwd, env),
-    detached
-  };
-}
-__name(fetchGitBranches, "fetchGitBranches");
-function parseBranchLines(raw) {
-  if (!raw.trim()) return [];
-  return raw.trim().split("\n").filter(Boolean).filter((line) => {
-    const parts2 = line.split(SEPARATOR);
-    return !(parts2[6] ?? "");
-  }).map((line) => {
-    const parts2 = line.split(SEPARATOR);
-    const name = parts2[0] ?? "";
-    const isHead = parts2[1] === "*";
-    const upstream = parts2[2] || void 0;
-    const track = parts2[3] ?? "";
-    const commitDate = parseInt(parts2[4] ?? "0", 10) || 0;
-    const commitSubject = parts2[5] ?? "";
-    let ahead = 0;
-    let behind = 0;
-    const aheadMatch = /ahead (\d+)/.exec(track);
-    const behindMatch = /behind (\d+)/.exec(track);
-    if (aheadMatch) ahead = parseInt(aheadMatch[1], 10);
-    if (behindMatch) behind = parseInt(behindMatch[1], 10);
-    const upstreamGone = upstream !== void 0 && /\bgone\b/.test(track);
-    const pushTarget = parts2[7] || void 0;
-    const pushTrack = parts2[8] ?? "";
-    const pushGone = pushTarget !== void 0 && /\bgone\b/.test(pushTrack);
-    let pushAhead;
-    let pushBehind;
-    if (pushTarget !== void 0 && !pushGone) {
-      const pa = /ahead (\d+)/.exec(pushTrack);
-      const pb = /behind (\d+)/.exec(pushTrack);
-      pushAhead = pa ? parseInt(pa[1], 10) : 0;
-      pushBehind = pb ? parseInt(pb[1], 10) : 0;
-    }
-    return {
-      name,
-      isHead,
-      upstream,
-      ...upstreamGone ? { upstreamGone } : {},
-      ahead,
-      behind,
-      ...pushTarget !== void 0 ? { pushTarget } : {},
-      ...pushAhead !== void 0 ? { pushAhead } : {},
-      ...pushBehind !== void 0 ? { pushBehind } : {},
-      ...pushGone ? { pushGone } : {},
-      commitDate,
-      commitSubject
-    };
-  });
-}
-__name(parseBranchLines, "parseBranchLines");
-function parseTagLines(raw) {
-  if (!raw.trim()) return [];
-  return raw.trim().split("\n").filter(Boolean).map((line) => {
-    const parts2 = line.split(SEPARATOR);
-    return {
-      name: parts2[0] ?? "",
-      date: parseInt(parts2[1] ?? "0", 10) || 0,
-      subject: parts2[2] ?? ""
-    };
-  });
-}
-__name(parseTagLines, "parseTagLines");
-function parseRecentBranches(reflogRaw, currentHead) {
-  if (!reflogRaw.trim()) return [];
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  for (const line of reflogRaw.trim().split("\n")) {
-    if (!line.startsWith("checkout: moving from ")) continue;
-    const idx = line.indexOf(" to ");
-    if (idx === -1) continue;
-    const branch = line.slice(idx + 4);
-    if (branch && !seen.has(branch) && branch !== currentHead && !/^[0-9a-f]{7,40}$/.test(branch)) {
-      seen.add(branch);
-      result.push(branch);
-      if (result.length >= MAX_RECENT_BRANCHES) break;
-    }
-  }
-  return result;
-}
-__name(parseRecentBranches, "parseRecentBranches");
-async function getDetachedHead(cwd, env) {
-  try {
-    const sha = await runGit2(cwd, ["rev-parse", "--short", "HEAD"], env);
-    return sha.trim();
-  } catch {
-    return "";
-  }
-}
-__name(getDetachedHead, "getDetachedHead");
-function isValidCheckoutRef(value) {
-  const ref = value.trim();
-  if (!ref || ref.startsWith("-")) return false;
-  if (ref === "HEAD") return true;
-  return isValidRefName(ref) || isValidGitSha(ref);
-}
-__name(isValidCheckoutRef, "isValidCheckoutRef");
-async function gitCheckout(cwd, ref, env) {
-  if (!isValidCheckoutRef(ref)) {
-    throw new Error(`invalid checkout ref: ${ref}`);
-  }
-  const isRemoteTracking = await runGit2(
-    cwd,
-    ["show-ref", "--verify", "--quiet", `refs/remotes/${ref}`],
-    env
-  ).then(() => true).catch(() => false);
-  if (isRemoteTracking) {
-    const localName = ref.slice(ref.indexOf("/") + 1);
-    if (!isValidCheckoutRef(localName)) {
-      throw new Error(
-        `invalid local branch name derived from remote ref: ${localName}`
-      );
-    }
-    const hasLocal = await runGit2(
-      cwd,
-      ["show-ref", "--verify", "--quiet", `refs/heads/${localName}`],
-      env
-    ).then(() => true).catch(() => false);
-    if (hasLocal) {
-      await runGit2(cwd, ["checkout", localName, "--"], env);
-    } else {
-      await runGit2(cwd, ["checkout", "--track", ref], env);
-    }
-    const head = (await runGit2(cwd, ["symbolic-ref", "--short", "HEAD"], env)).trim();
-    return { branch: head, detached: false };
-  }
-  await runGit2(cwd, ["checkout", ref, "--"], env);
-  const headRaw = await runGit2(
-    cwd,
-    ["symbolic-ref", "--short", "HEAD"],
-    env
-  ).catch(() => "");
-  const trimmed = headRaw.trim();
-  if (trimmed) {
-    return { branch: trimmed, detached: false };
-  }
-  const sha = await runGit2(cwd, ["rev-parse", "--short", "HEAD"], env);
-  return { branch: sha.trim(), detached: true };
-}
-__name(gitCheckout, "gitCheckout");
-async function gitCreateBranch(cwd, name, startPoint, env) {
-  if (!isValidRefName(name) || name.startsWith("-")) {
-    throw new Error(`invalid branch name: ${name}`);
-  }
-  const args = ["checkout", "-b", name];
-  if (startPoint) {
-    if (!isValidCheckoutRef(startPoint)) {
-      throw new Error(`invalid start point: ${startPoint}`);
-    }
-    args.push(startPoint);
-  }
-  args.push("--");
-  const originalRef = (await runGit2(
-    cwd,
-    ["symbolic-ref", "--quiet", "--short", "HEAD"],
-    env
-  ).catch(() => "")).trim();
-  const originalCommit = originalRef ? "" : (await runGit2(cwd, ["rev-parse", "HEAD"], env).catch(() => "")).trim();
-  const startCommit = (await runGit2(
-    cwd,
-    ["rev-parse", "--verify", `${startPoint || "HEAD"}^{commit}`],
-    env
-  ).catch(() => "")).trim();
-  try {
-    await runGit2(cwd, args, env);
-  } catch (err) {
-    const nowOn = (await runGit2(
-      cwd,
-      ["symbolic-ref", "--quiet", "--short", "HEAD"],
-      env
-    ).catch(() => "")).trim();
-    if (nowOn === name) {
-      if (originalRef) {
-        await runGit2(cwd, ["checkout", originalRef, "--"], env).catch(() => {
-        });
-      } else if (originalCommit) {
-        await runGit2(
-          cwd,
-          ["checkout", "--detach", originalCommit, "--"],
-          env
-        ).catch(() => {
-        });
-      }
-      const newHead = (await runGit2(cwd, ["rev-parse", `refs/heads/${name}`], env).catch(
-        () => ""
-      )).trim();
-      if (newHead && newHead !== startCommit) {
-        debugLogger13.warn(
-          `gitCreateBranch: keeping branch "${name}" because it contains commits created after checkout (likely by a failing post-checkout hook)`
-        );
-      } else {
-        await runGit2(cwd, ["branch", "-D", name], env).catch(() => {
-        });
-      }
-    }
-    throw err;
-  }
-  return { branch: name, detached: false };
-}
-__name(gitCreateBranch, "gitCreateBranch");
-async function gitPush(cwd, opts, env) {
-  const args = ["push"];
-  if (opts?.force) args.push("--force-with-lease");
-  if (opts?.setUpstream) {
-    let branch;
-    try {
-      branch = (await runGit2(cwd, ["symbolic-ref", "--short", "HEAD"], env)).trim();
-    } catch {
-      throw new Error(
-        "cannot push with --set-upstream in detached HEAD state; check out a branch first"
-      );
-    }
-    const hasUpstream = await runGit2(
-      cwd,
-      ["rev-parse", "--abbrev-ref", `${branch}@{u}`],
-      env
-    ).catch(() => "");
-    if (hasUpstream.trim()) {
-      const output2 = await runGit2(cwd, args, env);
-      return { success: true, output: output2.trim() };
-    }
-    let remote = (await runGit2(cwd, ["config", `branch.${branch}.pushRemote`], env).catch(
-      () => ""
-    )).trim();
-    if (!remote) {
-      remote = (await runGit2(cwd, ["config", "remote.pushDefault"], env).catch(() => "")).trim();
-    }
-    if (!remote) {
-      remote = (await runGit2(cwd, ["config", `branch.${branch}.remote`], env).catch(
-        () => ""
-      )).trim();
-    }
-    if (!remote) {
-      const remotes = (await runGit2(cwd, ["remote"], env).catch(() => "")).trim();
-      const remoteList = remotes ? remotes.split("\n") : [];
-      remote = remoteList.length === 1 ? remoteList[0] ?? "origin" : "origin";
-    }
-    args.push("--set-upstream", remote, branch);
-  }
-  const output = await runGit2(cwd, args, env);
-  return { success: true, output: output.trim() };
-}
-__name(gitPush, "gitPush");
-var GitPullFailure = class extends Error {
-  static {
-    __name(this, "GitPullFailure");
-  }
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "GitPullFailure";
-    this.code = code;
-  }
-};
-var AUTO_STASH_MESSAGE = "qwen-code: auto-stash before pull";
-var OPERATION_STATE_PATHS = [
-  ["MERGE_HEAD", "merge"],
-  ["CHERRY_PICK_HEAD", "cherry-pick"],
-  ["REVERT_HEAD", "revert"],
-  ["rebase-merge", "rebase"],
-  ["rebase-apply", "rebase or am"]
-];
-function gitDetail(err) {
-  if (err && typeof err === "object" && ("stdout" in err || "stderr" in err)) {
-    const e = err;
-    const detail = `${e.stdout ?? ""}
-${e.stderr ?? ""}`.trim();
-    if (detail) return detail;
-    return "git exited without diagnostic output; a stale lock file (e.g. .git/index.lock) or another git process is the usual cause";
-  }
-  return err instanceof Error ? err.message : String(err);
-}
-__name(gitDetail, "gitDetail");
-function exitCode(err) {
-  const code = err?.code;
-  return typeof code === "number" ? code : void 0;
-}
-__name(exitCode, "exitCode");
-function pullExitCode(err) {
-  const code = exitCode(err);
-  if (code !== void 0) return code;
-  const e = err;
-  if (e && (e.killed === true || typeof e.signal === "string")) return 1;
-  return void 0;
-}
-__name(pullExitCode, "pullExitCode");
-async function gitPaths(cwd, names, env) {
-  const args = ["rev-parse"];
-  for (const name of names) args.push("--git-path", name);
-  return (await runGit2(cwd, args, env)).trim().split("\n").map((line) => path8.resolve(cwd, line));
-}
-__name(gitPaths, "gitPaths");
-async function operationInProgress(cwd, env) {
-  const paths = await gitPaths(
-    cwd,
-    OPERATION_STATE_PATHS.map(([statePath]) => statePath),
-    env
-  );
-  for (let i = 0; i < OPERATION_STATE_PATHS.length; i++) {
-    if (fs9.existsSync(paths[i])) return OPERATION_STATE_PATHS[i][1];
-  }
-  return void 0;
-}
-__name(operationInProgress, "operationInProgress");
-async function refuseOperationInProgress(cwd, env) {
-  const operation = await operationInProgress(cwd, env);
-  if (operation) {
-    throw new GitPullFailure(
-      "operation_in_progress",
-      `cannot update: a ${operation} is in progress; finish or abort it from a terminal first`
-    );
-  }
-}
-__name(refuseOperationInProgress, "refuseOperationInProgress");
-async function upstreamSha(cwd, env, ref = "") {
-  try {
-    return (await runGit2(
-      cwd,
-      ["rev-parse", "--verify", "--quiet", `${ref}@{upstream}`],
-      env
-    )).trim();
-  } catch {
-    return "";
-  }
-}
-__name(upstreamSha, "upstreamSha");
-function readTrimmed(file) {
-  try {
-    return fs9.readFileSync(file, "utf8").trim();
-  } catch {
-    return "";
-  }
-}
-__name(readTrimmed, "readTrimmed");
-async function abortOwnPullState(cwd, pullExitCode2, env) {
-  if (pullExitCode2 !== 1) return;
-  try {
-    const [mergeHead, rebaseMergeDir, rebaseApplyDir] = await gitPaths(
-      cwd,
-      ["MERGE_HEAD", "rebase-merge", "rebase-apply"],
-      env
-    );
-    if (fs9.existsSync(mergeHead)) {
-      const upstream = await upstreamSha(cwd, env);
-      if (upstream && readTrimmed(mergeHead) === upstream) {
-        await runGit2(cwd, ["merge", "--abort"], env);
-      }
-      return;
-    }
-    for (const dir of [rebaseMergeDir, rebaseApplyDir]) {
-      if (!fs9.existsSync(dir)) continue;
-      const headName = readTrimmed(path8.join(dir, "head-name")).replace(
-        /^refs\/heads\//,
-        ""
-      );
-      const upstream = headName ? await upstreamSha(cwd, env, headName) : "";
-      if (upstream && readTrimmed(path8.join(dir, "onto")) === upstream) {
-        await runGit2(cwd, ["rebase", "--abort"], env);
-      }
-      return;
-    }
-  } catch {
-  }
-}
-__name(abortOwnPullState, "abortOwnPullState");
-async function stashEntries(cwd, env) {
-  const raw = await runGit2(cwd, ["stash", "list", "--format=%H%x00%s"], env);
-  return raw.split("\n").filter((line) => line.includes("\0")).map((line) => {
-    const [sha, subject] = line.split("\0");
-    return { sha, subject: subject ?? "" };
-  });
-}
-__name(stashEntries, "stashEntries");
-function parseDroppedStashSha(output) {
-  const match = /\(([0-9a-f]{40,64})\)\s*$/m.exec(output.trim());
-  return match?.[1];
-}
-__name(parseDroppedStashSha, "parseDroppedStashSha");
-async function restoreStash(cwd, sha, env) {
-  let output = "";
-  try {
-    await runGit2(cwd, ["stash", "apply", sha], env);
-  } catch (err) {
-    return { restored: false, output: gitDetail(err) };
-  }
-  let entries;
-  try {
-    entries = await stashEntries(cwd, env);
-  } catch (err) {
-    return {
-      restored: true,
-      output: `restored, but stash entry ${sha} was kept because the stash could not be listed:
-${gitDetail(err)}`
-    };
-  }
-  const index = entries.findIndex((entry) => entry.sha === sha);
-  if (index === -1) return { restored: true, output };
-  const slot = `stash@{${index}}`;
-  let dropped;
-  try {
-    dropped = parseDroppedStashSha(
-      await runGit2(cwd, ["stash", "drop", slot], env)
-    );
-  } catch (err) {
-    return {
-      restored: true,
-      output: `restored, but stash entry ${slot} (${sha}) could not be dropped:
-${gitDetail(err)}`
-    };
-  }
-  if (dropped !== void 0 && dropped !== sha) {
-    const subject = (await runGit2(cwd, ["log", "-1", "--format=%s", dropped], env).catch(
-      () => ""
-    )).trim();
-    const storeArgs = ["stash", "store", "--quiet"];
-    if (subject) storeArgs.push("-m", subject);
-    storeArgs.push(dropped);
-    const stored = await runGit2(cwd, storeArgs, env).then(() => true).catch(() => false);
-    output = stored ? `restored; stash entry ${sha} was kept because the stash changed while dropping it` : `restored; stash entry ${sha} was kept because the stash changed while dropping it, and the displaced entry ${dropped} could not be stored back \u2014 recover it with: git stash store ${dropped}`;
-  }
-  return { restored: true, output };
-}
-__name(restoreStash, "restoreStash");
-function pullArgs(opts) {
-  const args = ["pull"];
-  if (opts?.rebase) args.push("--rebase");
-  return args;
-}
-__name(pullArgs, "pullArgs");
-async function validatedUpstream(cwd, env) {
-  const sha = await upstreamSha(cwd, env);
-  if (sha) return sha;
-  let branch;
-  try {
-    branch = (await runGit2(cwd, ["symbolic-ref", "--quiet", "--short", "HEAD"], env)).trim();
-  } catch {
-    throw new GitPullFailure(
-      "pull_failed",
-      "cannot update: HEAD is detached; check out a branch from a terminal first"
-    );
-  }
-  const configured = (await runGit2(
-    cwd,
-    ["for-each-ref", "--format=%(upstream)", `refs/heads/${branch}`],
-    env
-  ).catch(() => "")).trim();
-  if (configured) {
-    throw new GitPullFailure(
-      "pull_failed",
-      "cannot update: the upstream branch no longer exists on the remote; nothing was changed"
-    );
-  }
-  await runGit2(cwd, ["rev-parse", "--abbrev-ref", "@{upstream}"], env);
-  throw new GitPullFailure(
-    "pull_failed",
-    "cannot update: the upstream branch could not be resolved; nothing was changed"
-  );
-}
-__name(validatedUpstream, "validatedUpstream");
-async function pushAutoStash(cwd, env) {
-  const before = new Set((await stashEntries(cwd, env)).map((e) => e.sha));
-  await refuseOperationInProgress(cwd, env);
-  try {
-    await runGit2(
-      cwd,
-      ["stash", "push", "--include-untracked", "-m", AUTO_STASH_MESSAGE],
-      env
-    );
-  } catch (err) {
-    throw new GitPullFailure(
-      "pull_failed",
-      `cannot stash the local changes, so the update was not attempted:
-${gitDetail(err)}`
-    );
-  }
-  let after;
-  try {
-    after = await stashEntries(cwd, env);
-  } catch (err) {
-    throw new GitPullFailure(
-      "pull_failed",
-      `cannot identify the auto-stash entry, so the update was not attempted; your changes are in the entry labelled "${AUTO_STASH_MESSAGE}" in git stash list:
-${gitDetail(err)}`
-    );
-  }
-  const created = after.filter(
-    (e) => !before.has(e.sha) && e.subject.endsWith(AUTO_STASH_MESSAGE)
-  );
-  return created.length > 0 ? created[created.length - 1].sha : void 0;
-}
-__name(pushAutoStash, "pushAutoStash");
-async function stashPull(cwd, opts, env) {
-  await refuseOperationInProgress(cwd, env);
-  await runGit2(cwd, ["fetch", "--prune"], env);
-  await validatedUpstream(cwd, env);
-  const stashed = await pushAutoStash(cwd, env);
-  let output;
-  try {
-    output = (await runGit2(cwd, pullArgs(opts), env)).trim();
-  } catch (err) {
-    const detail = gitDetail(err);
-    await abortOwnPullState(cwd, pullExitCode(err), env);
-    if (stashed === void 0) {
-      throw new GitPullFailure("pull_failed", `update failed:
-${detail}`);
-    }
-    const restore2 = await restoreStash(cwd, stashed, env);
-    throw new GitPullFailure(
-      "pull_failed",
-      restore2.restored ? `update failed; your local changes were restored${restore2.output ? ` (${restore2.output})` : ""}:
-${detail}` : `update failed and your local changes could not be restored automatically; they are kept in stash entry ${stashed}:
-${restore2.output}
-${detail}`
-    );
-  }
-  if (stashed === void 0) return { success: true, output };
-  const restore = await restoreStash(cwd, stashed, env);
-  if (restore.restored) {
-    if (restore.output === "") return { success: true, output };
-    return {
-      success: true,
-      stashKept: true,
-      stashSha: stashed,
-      output: `${output}
-${restore.output}`.trim()
-    };
-  }
-  return {
-    success: true,
-    stashRestoreConflict: true,
-    stashSha: stashed,
-    output: `${output}
-restoring your local changes failed; they are kept in stash entry ${stashed}:
-${restore.output}`.trim()
-  };
-}
-__name(stashPull, "stashPull");
-async function forcePull(cwd, env) {
-  await refuseOperationInProgress(cwd, env);
-  const toplevel = (await runGit2(cwd, ["rev-parse", "--show-toplevel"], env)).trim();
-  if (await fs9.promises.realpath(cwd) !== await fs9.promises.realpath(toplevel)) {
-    throw new GitPullFailure(
-      "force_unsupported",
-      "cannot discard changes: the workspace is a subdirectory of its repository, so discarding would also reset changes outside the workspace; resolve them from a terminal"
-    );
-  }
-  await runGit2(cwd, ["fetch", "--prune"], env);
-  const validated = await validatedUpstream(cwd, env);
-  try {
-    await runGit2(cwd, ["merge-base", "--is-ancestor", "HEAD", validated], env);
-  } catch (err) {
-    if (exitCode(err) === 1) {
-      throw new GitPullFailure(
-        "diverged",
-        "cannot discard and update: the branch has diverged from its upstream; merge or rebase the local commits from a terminal first"
-      );
-    }
-    throw err;
-  }
-  await refuseOperationInProgress(cwd, env);
-  await runGit2(cwd, ["reset", "--hard"], env);
-  await runGit2(cwd, ["clean", "-fd"], env);
-  let output;
-  try {
-    output = await runGit2(cwd, ["merge", "--ff-only", validated], env);
-  } catch (err) {
-    throw new GitPullFailure(
-      "pull_failed",
-      `discard applied, but the update failed:
-${gitDetail(err)}`
-    );
-  }
-  return { success: true, output: output.trim() };
-}
-__name(forcePull, "forcePull");
-async function gitPull(cwd, opts, env) {
-  if (opts?.stash && opts?.force) {
-    throw new Error("stash and force are mutually exclusive");
-  }
-  if (opts?.fetchOnly && (opts?.stash || opts?.force)) {
-    throw new Error("fetchOnly cannot be combined with stash or force");
-  }
-  if (opts?.fetchOnly) {
-    const output2 = await runGit2(cwd, ["fetch", "--all", "--prune"], env);
-    return { success: true, output: output2.trim() };
-  }
-  if (opts?.force) return forcePull(cwd, env);
-  if (opts?.stash) return stashPull(cwd, opts, env);
-  const output = await runGit2(cwd, pullArgs(opts), env);
-  return { success: true, output: output.trim() };
-}
-__name(gitPull, "gitPull");
-async function gitCommit(cwd, message, opts, env) {
-  let savedIndex = null;
-  if (opts?.all) {
-    const tree = (await runGit2(cwd, ["write-tree"], env).catch(() => "")).trim();
-    if (tree) {
-      savedIndex = tree;
-    } else {
-      const unmerged = (await runGit2(cwd, ["ls-files", "--unmerged"], env)).trim();
-      if (unmerged) {
-        throw new Error(
-          "cannot stage all changes: unresolved merge conflicts in the index"
-        );
-      }
-      throw new Error(
-        "cannot stage all changes: failed to snapshot index (write-tree failed)"
-      );
-    }
-  }
-  try {
-    if (opts?.all) {
-      await runGit2(cwd, ["add", "-A"], env);
-    }
-    await runGit2(cwd, ["commit", "-m", message], env);
-  } catch (err) {
-    if (savedIndex) {
-      await runGit2(cwd, ["read-tree", savedIndex], env).catch((rollbackErr) => {
-        console.error("git index rollback failed:", rollbackErr);
-      });
-    }
-    throw err;
-  }
-  const sha = (await runGit2(cwd, ["rev-parse", "--short", "HEAD"], env)).trim();
-  const subject = (await runGit2(cwd, ["log", "-1", "--format=%s"], env)).trim();
-  return { sha, subject };
-}
-__name(gitCommit, "gitCommit");
-
 // packages/core/src/utils/github-prs.ts
 init_esbuild_shims();
 import { execFile as execFile3 } from "node:child_process";
@@ -23028,7 +23118,7 @@ function estimateIndexCacheBytes(index) {
     total += INDEX_ENTRY_BASE_BYTES + estimateStringBytes(gap.childUuid) + estimateStringBytes(gap.missingParentUuid);
   }
   for (const [uuid3, entry] of index.byUuid) {
-    total += INDEX_ENTRY_BASE_BYTES + INDEX_HINT_BASE_BYTES * 2 + INDEX_MAP_ENTRY_BYTES + INDEX_CONTAINER_BASE_BYTES + entry.segments.length * INDEX_CONTAINER_SLOT_BYTES + estimateStringBytes(uuid3) + estimateStringBytes(entry.parentUuid) + estimateStringBytes(entry.type) + estimateStringBytes(entry.subtype) + estimateStringBytes(entry.navigationKind) + estimateStringBytes(entry.turnResultPromptId) + estimateStringBytes(entry.turnHint.turnParentUuid) + estimateStringBytes(entry.turnHint.backgroundNotificationTaskId) + entry.segments.length * INDEX_SEGMENT_BYTES;
+    total += INDEX_ENTRY_BASE_BYTES + INDEX_HINT_BASE_BYTES * 2 + INDEX_MAP_ENTRY_BYTES + INDEX_CONTAINER_BASE_BYTES + entry.segments.length * INDEX_CONTAINER_SLOT_BYTES + estimateStringBytes(uuid3) + estimateStringBytes(entry.parentUuid) + estimateStringBytes(entry.type) + estimateStringBytes(entry.subtype) + estimateStringBytes(entry.navigationKind) + estimateStringBytes(entry.turnResultPromptId) + estimateStringBytes(entry.daemonPromptId) + estimateStringBytes(entry.turnHint.turnParentUuid) + estimateStringBytes(entry.turnHint.backgroundNotificationTaskId) + entry.segments.length * INDEX_SEGMENT_BYTES;
   }
   for (const turn of index.navigationTurns) {
     total += INDEX_HINT_BASE_BYTES + INDEX_CONTAINER_SLOT_BYTES + estimateStringBytes(turn.turnId) + estimateStringBytes(turn.kind) + estimateStringBytes(turn.promptId) + estimateStringBytes(turn.finalAssistantRecordId);
@@ -23368,6 +23458,7 @@ async function buildIndex(params) {
               goalRecoveryCandidate: isGoalRecoveryCandidate(chatRecord),
               turnHint: getSessionTurnRecordHint(chatRecord, sessionId),
               ...navigationKind ? { navigationKind } : {},
+              ...typeof chatRecord.daemonPromptId === "string" ? { daemonPromptId: chatRecord.daemonPromptId } : {},
               navigationTextSuppressed,
               assistantPreviewCandidate: isAssistantPreviewCandidate(chatRecord),
               ...record4.subtype === "turn_result" && isTurnResultRecordPayload(record4.systemPayload) ? { turnResultPromptId: record4.systemPayload.promptId } : {},
@@ -23428,7 +23519,8 @@ async function buildIndex(params) {
       const turn = {
         turnId: uuid3,
         replayPosition: position,
-        kind: entry.navigationKind
+        kind: entry.navigationKind,
+        ...entry.daemonPromptId ? { promptId: entry.daemonPromptId } : {}
       };
       entry.navigationOrdinal = navigationTurns.length;
       navigationTurns.push(turn);
@@ -23445,7 +23537,7 @@ async function buildIndex(params) {
       if (targetTurn) targetTurn.finalAssistantRecordId = uuid3;
     }
     if (entry?.turnResultPromptId && currentPromptTurn) {
-      currentPromptTurn.promptId = entry.turnResultPromptId;
+      currentPromptTurn.promptId ??= entry.turnResultPromptId;
       currentPromptTurn = void 0;
     }
   }
@@ -36235,7 +36327,7 @@ var LlmChat = class {
                 const degradeAttempt = omniMediaDegradeAttempts++;
                 let degradeOutcome;
                 try {
-                  const { degradeOmniMediaAfterServerReject } = await import("./reactive-degrade-URJMXJ7N.js");
+                  const { degradeOmniMediaAfterServerReject } = await import("./reactive-degrade-HPYBJHYA.js");
                   degradeOutcome = await degradeOmniMediaAfterServerReject(
                     self2.config,
                     self2.history,
@@ -44196,6 +44288,15 @@ function extractLastUserPrompt(messages) {
 }
 __name(extractLastUserPrompt, "extractLastUserPrompt");
 var sessionCommitShas = /* @__PURE__ */ new Set();
+var sessionCommitGeneration = 0;
+function getSessionCommitGeneration() {
+  return sessionCommitGeneration;
+}
+__name(getSessionCommitGeneration, "getSessionCommitGeneration");
+function registerSessionCommit(sha) {
+  sessionCommitShas.add(sha.trim());
+}
+__name(registerSessionCommit, "registerSessionCommit");
 function isAmendOfSessionCommit(cwd) {
   if (sessionCommitShas.size === 0) return false;
   try {
@@ -44211,6 +44312,11 @@ function isAmendOfSessionCommit(cwd) {
   }
 }
 __name(isAmendOfSessionCommit, "isAmendOfSessionCommit");
+function clearSessionCommits() {
+  sessionCommitShas.clear();
+  sessionCommitGeneration++;
+}
+__name(clearSessionCommits, "clearSessionCommits");
 function isDestructiveCommand(command, userPrompt, cwd = process.cwd()) {
   const expanded = command + " " + stripShellQuotes(command);
   for (const pattern of DESTRUCTIVE_GIT_PATTERNS) {
@@ -44701,7 +44807,7 @@ async function evaluateAutoMode(input) {
     const destructiveResult = isDestructiveCommand(
       command,
       userPrompt,
-      input.ctx.cwd
+      input.ctx.cwd ?? input.config.getTargetDir?.()
     );
     if (destructiveResult?.blocked) {
       return {
@@ -44743,7 +44849,7 @@ init_esbuild_shims();
 
 // packages/core/src/utils/editor.ts
 init_esbuild_shims();
-import { execSync as execSync2, spawn, spawnSync as spawnSync2 } from "node:child_process";
+import { execSync as execSync2, spawn as spawn2, spawnSync as spawnSync2 } from "node:child_process";
 import { existsSync as existsSync3 } from "node:fs";
 import { homedir } from "node:os";
 import { join as join14 } from "node:path";
@@ -44972,7 +45078,7 @@ async function openDiff(oldPath, newPath, editor, onEditorClose) {
       return;
     }
     return new Promise((resolve37, reject) => {
-      const childProcess2 = spawn(diffCommand.command, diffCommand.args, {
+      const childProcess2 = spawn2(diffCommand.command, diffCommand.args, {
         stdio: "inherit",
         shell: process.platform === "win32"
       });
@@ -47158,14 +47264,46 @@ function parseGitInvocation(tokens) {
   return { subcommand: void 0, changesCwd };
 }
 __name(parseGitInvocation, "parseGitInvocation");
+var COMMIT_RECOGNITION_LEADING_NOISE = /* @__PURE__ */ new Set([
+  "if",
+  "then",
+  "else",
+  "elif",
+  "fi",
+  "while",
+  "until",
+  "for",
+  "do",
+  "done",
+  "time",
+  "!",
+  "{",
+  "}"
+]);
+function skipCommitRecognitionNoise(tokens) {
+  let i = 0;
+  while (i < tokens.length && COMMIT_RECOGNITION_LEADING_NOISE.has(tokens[i])) {
+    i++;
+  }
+  if (i >= tokens.length) return null;
+  return tokens.slice(i);
+}
+__name(skipCommitRecognitionNoise, "skipCommitRecognitionNoise");
+function programBasename(program) {
+  const base = program.split(/[\\/]/).pop();
+  return base.endsWith(".exe") ? base.slice(0, -".exe".length) : base;
+}
+__name(programBasename, "programBasename");
 function gitCommitContext(command) {
   let hasCommit = false;
   let attributable = false;
   let cwdShifted = false;
   for (const sub of splitCommands(command)) {
-    const tokens = tokeniseSegment(sub);
-    if (!tokens || tokens.length === 0) continue;
-    const program = tokens[0];
+    const rawTokens = tokeniseSegment(sub);
+    if (!rawTokens || rawTokens.length === 0) continue;
+    const tokens = skipCommitRecognitionNoise(rawTokens);
+    if (!tokens) continue;
+    const program = programBasename(tokens[0]);
     if (program === "cd" || program === "pushd") {
       if (!hasCommit && cdTargetMayChangeRepo(tokens)) cwdShifted = true;
       continue;
@@ -47263,9 +47401,13 @@ function findAttributableCommitSegment(command) {
     cursor = end;
     const tokens = tokeniseSegment(sub);
     if (!tokens || tokens.length === 0) continue;
-    const program = tokens[0];
+    const looseTokens = skipCommitRecognitionNoise(tokens);
+    if (!looseTokens) continue;
+    const program = programBasename(looseTokens[0]);
     if (program === "cd" || program === "pushd") {
-      if (!cwdShifted && cdTargetMayChangeRepo(tokens)) cwdShifted = true;
+      if (!cwdShifted && cdTargetMayChangeRepo(looseTokens)) {
+        cwdShifted = true;
+      }
       continue;
     }
     if (program === "popd") {
@@ -47273,11 +47415,13 @@ function findAttributableCommitSegment(command) {
       continue;
     }
     if (program === "git") {
-      const { subcommand, changesCwd } = parseGitInvocation(tokens);
+      const { subcommand, changesCwd } = parseGitInvocation(looseTokens);
       if (subcommand === "commit" && !cwdShifted && !changesCwd) {
         return { start, end };
       }
-      if (changesCwd && !cwdShifted) cwdShifted = true;
+      if (subcommand !== "commit" && changesCwd && !cwdShifted) {
+        cwdShifted = true;
+      }
     }
   }
   return null;
@@ -48484,7 +48628,8 @@ var ShellToolInvocation = class extends BaseToolInvocation {
         cwd,
         commandToExecute,
         promoteAbortController,
-        promoteArtifacts
+        promoteArtifacts,
+        preHead
       );
       return promotedToolResult;
     }
@@ -48543,6 +48688,7 @@ ${result.output}`;
     }
     let attributionWarning = null;
     if (!this.config.getShellExecutionSandbox?.() && commitCtx.attributableInCwd) {
+      await this.trackSessionCommit(cwd, preHead);
       const isAmend = isAmendCommit(strippedCommand);
       attributionWarning = await this.attachCommitAttribution(
         cwd,
@@ -48764,8 +48910,14 @@ ${longRunHint}` : ""),
    * `executeForeground`. The `promoteArtifacts` parameter carries the
    * pre-allocated buffer/stream slots that absorb the race between
    * service-side promote-time data flush and this finalizer running.
+   *
+   * `preHead` is the HEAD captured synchronously before spawn (null
+   * unless the command carried a commit recognisable as landing in our
+   * cwd, unsandboxed). A promoted command settles after `execute()`
+   * has returned, so the foreground registration block never runs for
+   * it — registration happens here, at settle (#12514).
    */
-  async handlePromotedForeground(result, cwd, commandToExecute, abortController, promoteArtifacts) {
+  async handlePromotedForeground(result, cwd, commandToExecute, abortController, promoteArtifacts, preHead) {
     const outputDir = path21.join(
       this.config.storage.getProjectTempDir(),
       "background-shells",
@@ -48968,7 +49120,37 @@ ${longRunHint}` : ""),
         registry3.fail(shellId, cls.failMsg, info.endTime);
       }
     }, "transitionRegistry");
+    let promotedCommitRegistration = null;
+    const registrationGeneration = getSessionCommitGeneration();
+    const registerPromotedCommit = /* @__PURE__ */ __name(() => {
+      if (preHead === null || promotedCommitRegistration !== null) return;
+      if (getSessionCommitGeneration() !== registrationGeneration) {
+        debugLogger29.warn(
+          `promote: skipping session-commit registration in ${cwd}: the session-commit registry was cleared (approval-mode transition or session end) after this command was promoted, so the exemption must not carry across that boundary.`
+        );
+        return;
+      }
+      promotedCommitRegistration = this.trackSessionCommit(
+        cwd,
+        preHead,
+        // Lineage, not mere difference. This runs when the backgrounded
+        // child exits — arbitrarily later than the caller's pre-spawn
+        // capture — so a commit anybody else lands in this repository
+        // while the child runs is the newest `commit:` entry by then,
+        // and `head.sha !== preHead` alone would adopt it: the foreign
+        // commit would earn the amend exemption and the promoted one
+        // would lose its own. Requiring that entry to have moved HEAD
+        // *from* `preHead` keeps the registered SHA one this command
+        // created (see `trackSessionCommit`'s `requirePredecessor`).
+        preHead
+      ).catch((err) => {
+        debugLogger29.warn(
+          `promote: session-commit registration failed: ${getErrorMessage(err)}`
+        );
+      });
+    }, "registerPromotedCommit");
     promoteArtifacts.onSettleWired = (info) => {
+      registerPromotedCommit();
       const cls = classifySettle(info);
       postPromoteFinalStatus = cls.status;
       postPromoteSettleObserved = true;
@@ -49002,6 +49184,7 @@ ${longRunHint}` : ""),
       promoteArtifacts.settleQueued = null;
       promoteArtifacts.onSettleWired(queued);
     }
+    await promotedCommitRegistration;
     const statusLine = postPromoteSettleObserved ? `Status: ${postPromoteFinalStatus ?? "settled"}. PID: ${result.pid ?? "(unknown)"}.` : `Status: running. PID: ${result.pid ?? "(unknown)"}.`;
     const statusFileLine = statusFileGuidance(outputPath);
     const inspectLine = `To inspect: \`/tasks\` (text), the Background tasks dialog (\u2193 + Enter on the footer pill), or \`Read\` the output file directly.`;
@@ -49264,6 +49447,122 @@ To inspect: /tasks (text) or the interactive Background tasks dialog (focus the
       return null;
     }
   }
+  /**
+   * Record HEAD in the session registry (`permissions/destructive-commands.ts`)
+   * when a `git commit` put it there, so a later `git commit --amend` of it is
+   * exempt from the Auto-mode destructive-command block.
+   *
+   * The criterion is "the newest HEAD reflog entry is a `commit` verb, and
+   * HEAD moved". Exit code is too strict (`git commit -m x && npm test` can
+   * land the commit and then fail). HEAD movement alone is too loose, and
+   * fail-open: in `git pull && git commit -m x` with nothing staged, the pull
+   * fast-forwards onto somebody else's commit and the commit then exits
+   * non-zero — and because `gitCommitContext` does not treat
+   * `pull`/`checkout`/`merge` as cwd-shifting and the call site has no
+   * exit-code gate, that chain really does reach here. A movement-only test
+   * would register a human's SHA, trading the deterministic Layer-0 block for
+   * the classifier.
+   *
+   * Where the reflog cannot answer at all (`core.logAllRefUpdates` off, reflog
+   * expired, git missing) nothing registers and the amend stays blocked, so
+   * that branch costs a blocked amend and never a lifted one.
+   *
+   * The reflog read does *not* establish that this command's own `git commit`
+   * created HEAD, and no local read can: `preHead` is taken before the spawn
+   * and the reflog after the whole command, so a commit another process lands
+   * in the same repository inside that window is the newest `commit:` entry
+   * and registers instead — degrading the next amend's deterministic Layer-0
+   * block to the L5.3 classifier, and costing the agent its own exemption,
+   * since the foreign entry is the newest one. Binding an entry to this child
+   * needs a signal not derivable from reflog shape, and the cheap candidate is
+   * unsound: a chain-level `GIT_REFLOG_ACTION` stamp rewrites the action of
+   * every reflog-writing git call in the single `/bin/bash -c` child, so a
+   * trailing `checkout` would write a `commit:` verb too. Per-invocation
+   * stamping means changing how the executor spawns. Tracked in #12523.
+   *
+   * No multi-commit guard, unlike {@link attachCommitAttribution}, which has
+   * to *partition* per-file contribution and so bails. In `commit a &&
+   * commit b` HEAD is `b`, created by this command, so registering it is
+   * sound and `a` stays blocked.
+   *
+   * `requirePredecessor` is the promoted path's lineage guard and is
+   * deliberately not applied to the foreground one. There, the window
+   * between the pre-spawn capture and this reflog read is the command's
+   * own duration — the trade-off #12523 tracks and this docblock
+   * discloses. On a Ctrl+B promote the same window is the backgrounded
+   * child's whole (deliberately long) lifetime, so a commit anybody else
+   * lands in this repository meanwhile is not a narrow race but the
+   * expected shape, and difference-from-`preHead` alone would adopt it.
+   * Passing the captured `preHead` here requires the entry that created
+   * HEAD to have moved it *from* that SHA, which only this command's own
+   * commit does. Fail-closed both ways: a foreign commit never earns an
+   * exemption, and a multi-commit promoted chain (`commit a && commit b`,
+   * whose newest entry descends from `a`) loses one it had earned rather
+   * than guessing. The foreground call site passes nothing and keeps the
+   * disclosed window unchanged.
+   */
+  async trackSessionCommit(cwd, preHead, requirePredecessor) {
+    const head = await this.getGitHeadOrigin(cwd);
+    if (head !== null && requirePredecessor !== void 0 && head.predecessor !== requirePredecessor) {
+      debugLogger29.warn(
+        `Session commit not registered in ${cwd}: the newest HEAD reflog entry descends from ${head.predecessor ?? "(no predecessor)"}, not from the pre-spawn HEAD ${requirePredecessor.slice(0, 12)}, so it was not created by this command.`
+      );
+      return;
+    }
+    if (head !== null && head.createdByCommit && head.sha !== preHead) {
+      registerSessionCommit(head.sha);
+    } else if (head === null) {
+      debugLogger29.warn(
+        `Session commit not registered in ${cwd}: the HEAD reflog could not answer, so a later amend stays blocked.`
+      );
+    }
+  }
+  /**
+   * Read HEAD, the reflog action that last moved it, and the SHA that
+   * entry moved it *from*, in one subprocess.
+   *
+   * `--no-show-signature` is required, not cosmetic: with
+   * `log.showSignature=true` git prints the signature verdict ahead of the
+   * formatted output, shifting both fields and making an agent's own signed
+   * commit look uncommitted. Inert when nothing is signed.
+   *
+   * `-2` rather than `-1` so the second entry's SHA is available as the
+   * newest entry's predecessor — the lineage input
+   * {@link trackSessionCommit} requires on the promoted path. It costs one
+   * extra reflog record inside the same 2 s budget.
+   *
+   * Returns `null` when git cannot answer (not a repo, no HEAD, reflog off or
+   * expired, git missing) so every caller fails closed. `predecessor` is
+   * `null` when the reflog holds a single entry (an initial commit, or one
+   * expired down to a single record).
+   */
+  async getGitHeadOrigin(cwd) {
+    return new Promise((resolve37) => {
+      const child = childProcess.execFile(
+        "git",
+        ["log", "-g", "-2", "--no-show-signature", "--format=%H%n%gs", "HEAD"],
+        { cwd, timeout: 2e3, windowsHide: true },
+        (error3, stdout) => {
+          if (error3) {
+            resolve37(null);
+            return;
+          }
+          const [sha, subject, predecessor] = String(stdout).split("\n");
+          if (!sha || !subject) {
+            resolve37(null);
+            return;
+          }
+          resolve37({
+            sha: sha.trim(),
+            createdByCommit: /^commit\b/.test(subject),
+            predecessor: predecessor?.trim() || null
+          });
+        }
+      );
+      child.on("error", () => {
+      });
+    });
+  }
   /**
    * After a successful git commit, attach per-file AI attribution metadata
    * as git notes. Analyzes staged files via `git diff` to calculate real
@@ -57544,6 +57843,7 @@ function withPostToolBatchStop(completedCalls, stopReason) {
     request: lastCall.request,
     tool: lastCall.tool,
     response,
+    startTime: lastCall.startTime,
     durationMs: lastCall.durationMs,
     outcome: void 0
   };
@@ -57635,7 +57935,9 @@ var CoreToolScheduler = class _CoreToolScheduler {
     __name(this, "CoreToolScheduler");
   }
   schedulerOptions;
-  toolRegistry;
+  get toolRegistry() {
+    return this.config.getToolRegistry();
+  }
   toolCalls = [];
   outputUpdateHandler;
   onAllToolCallsComplete;
@@ -57708,7 +58010,6 @@ var CoreToolScheduler = class _CoreToolScheduler {
   constructor(options2) {
     this.schedulerOptions = options2;
     this.config = options2.config;
-    this.toolRegistry = options2.config.getToolRegistry();
     this.outputUpdateHandler = options2.outputUpdateHandler;
     this.onAllToolCallsComplete = options2.onAllToolCallsComplete;
     this.onToolCallsUpdate = options2.onToolCallsUpdate;
@@ -57840,7 +58141,7 @@ var CoreToolScheduler = class _CoreToolScheduler {
     const notices = [];
     let omniProcessed = responseParts;
     if (this.config.isOmniEnabled?.()) {
-      const { processToolResultOmniMedia } = await import("./tool-result-media-OAHUKGRK.js");
+      const { processToolResultOmniMedia } = await import("./tool-result-media-WU6QAREN.js");
       omniProcessed = await processToolResultOmniMedia(
         responseParts,
         this.config,
@@ -57895,6 +58196,7 @@ var CoreToolScheduler = class _CoreToolScheduler {
             status: "success",
             response: auxiliaryData,
             durationMs,
+            ...durationMs !== void 0 ? { startTime: existingStartTime } : {},
             outcome
           };
         }
@@ -57906,6 +58208,7 @@ var CoreToolScheduler = class _CoreToolScheduler {
             tool: toolInstance,
             response: auxiliaryData,
             durationMs,
+            ...durationMs !== void 0 ? { startTime: existingStartTime } : {},
             outcome
           };
         }
@@ -57989,6 +58292,7 @@ var CoreToolScheduler = class _CoreToolScheduler {
             status: "cancelled",
             response,
             durationMs,
+            ...durationMs !== void 0 ? { startTime: existingStartTime } : {},
             outcome
           };
         }
@@ -60986,7 +61290,7 @@ ${body}
           artifacts: toolResult.artifacts
         } : void 0;
         if (policyArtifacts && policyArtifacts.executionOrigin.kind !== "fixed_policy" && scheduledCall.tool.mediaPolicyDescriptor) {
-          const { collectModelPolicyCall } = await import("./model-call-collection-PKDMVCZN.js");
+          const { collectModelPolicyCall } = await import("./model-call-collection-OKUGOY4B.js");
           await collectModelPolicyCall({
             config: this.config,
             batch: policyArtifacts,
@@ -65444,7 +65748,7 @@ import * as fs28 from "fs/promises";
 import * as path27 from "path";
 var debugLogger36 = createDebugLogger("SKILL_LOAD");
 var SKILL_MANIFEST_FILE = "SKILL.md";
-async function loadSkillsFromDir(baseDir) {
+async function loadSkillsFromDir(baseDir, onError) {
   debugLogger36.debug(`Loading skills from directory (skill-load): ${baseDir}`);
   try {
     const entries = await fs28.readdir(baseDir, { withFileTypes: true });
@@ -65465,6 +65769,9 @@ async function loadSkillsFromDir(baseDir) {
       if (isSymlink) {
         const check = await validateSymlinkTarget(skillDir);
         if (!check.ok) {
+          if (check.reason === "invalid" && !(isNodeError(check.error) && check.error.code === "ENOENT")) {
+            onError?.(check.error);
+          }
           if (check.reason === "not-directory") {
             debugLogger36.warn(
               `Skipping symlink ${entry.name} that does not point to a directory`
@@ -65484,6 +65791,7 @@ async function loadSkillsFromDir(baseDir) {
         const config3 = parseSkillContent(content, skillManifest);
         skills.push(config3);
       } catch (error3) {
+        if (!(isNodeError(error3) && error3.code === "ENOENT")) onError?.(error3);
         const errorMessage = error3 instanceof Error ? error3.message : "Unknown error";
         debugLogger36.error(
           `Failed to parse skill at ${skillDir}: ${errorMessage}`
@@ -65493,6 +65801,7 @@ async function loadSkillsFromDir(baseDir) {
     }
     return skills;
   } catch (error3) {
+    if (!(isNodeError(error3) && error3.code === "ENOENT")) onError?.(error3);
     const errorMessage = error3 instanceof Error ? error3.message : "Unknown error";
     debugLogger36.debug(
       `Cannot read skills directory ${baseDir}: ${errorMessage}`
@@ -118061,7 +118370,7 @@ __name(isEnabled, "isEnabled");
 
 // packages/core/src/tools/tool-registry.ts
 init_esbuild_shims();
-import { spawn as spawn5 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 import { StringDecoder } from "node:string_decoder";
 
 // packages/core/src/tools/mcp-client-manager.ts
@@ -120339,7 +120648,7 @@ var DiscoveredToolInvocation = class extends BaseToolInvocation {
   }
   async execute(_signal, _updateOutput) {
     const callCommand = this.config.getToolCallCommand();
-    const child = spawn5(callCommand, [this.toolName], {
+    const child = spawn6(callCommand, [this.toolName], {
       env: normalizePathEnvForWindows(sanitizeChildEnv(process.env))
     });
     child.stdin.write(JSON.stringify(this.params));
@@ -120792,7 +121101,7 @@ var ToolRegistry = class _ToolRegistry {
           "Tool discovery command is empty or contains only whitespace."
         );
       }
-      const proc = spawn5(cmdParts[0], cmdParts.slice(1), {
+      const proc = spawn6(cmdParts[0], cmdParts.slice(1), {
         env: normalizePathEnvForWindows(sanitizeChildEnv(process.env))
       });
       let stdout = "";
@@ -123234,6 +123543,7 @@ var SkillManager = class {
   // `slashCommandProcessor.ts:416`.
   slashReloadSuppressed = false;
   parseErrors = /* @__PURE__ */ new Map();
+  discoveryHasErrors = false;
   watchers = /* @__PURE__ */ new Map();
   watchStarted = false;
   refreshTimer = null;
@@ -123394,6 +123704,10 @@ var SkillManager = class {
     if (this.skillsCache === null) return null;
     return this.collectCachedSkills(level);
   }
+  /** Whether missing entries in the current cache might be discovery failures. */
+  hasDiscoveryErrors() {
+    return this.discoveryHasErrors;
+  }
   collectCachedSkills(level) {
     const skills = [];
     const seenNames = /* @__PURE__ */ new Set();
@@ -123502,10 +123816,17 @@ var SkillManager = class {
     debugLogger81.info("Refreshing skills cache...");
     const skillsCache = /* @__PURE__ */ new Map();
     this.parseErrors.clear();
+    let discoveryHasErrors = false;
+    const onDiscoveryError = /* @__PURE__ */ __name(() => {
+      discoveryHasErrors = true;
+    }, "onDiscoveryError");
     const levels = this.config.isSafeMode() ? ["bundled"] : ["project", "user", "extension", "bundled"];
     const settled = await Promise.allSettled(
       levels.map(async (level) => {
-        const levelSkills = await this.listSkillsAtLevel(level);
+        const levelSkills = await this.listSkillsAtLevel(
+          level,
+          onDiscoveryError
+        );
         debugLogger81.debug(`Loaded ${levelSkills.length} ${level} level skills`);
         return [level, levelSkills];
       })
@@ -123520,12 +123841,14 @@ var SkillManager = class {
         totalSkills += levelSkills.length;
       } else {
         errors.push(result.reason);
+        onDiscoveryError();
         debugLogger81.warn(
           `Failed to load ${levels[i]} level skills:`,
           result.reason
         );
       }
     }
+    this.discoveryHasErrors = discoveryHasErrors;
     this.skillsCache = skillsCache;
     const seenForActivation = /* @__PURE__ */ new Set();
     const eligibleForActivation = [];
@@ -123907,7 +124230,7 @@ var SkillManager = class {
    * @param level - Storage level to scan
    * @returns Array of skill configurations
    */
-  async listSkillsAtLevel(level) {
+  async listSkillsAtLevel(level, onDiscoveryError) {
     if (this.config.getBareMode()) {
       debugLogger81.debug(`Skipping ${level} level skills in bare mode`);
       return [];
@@ -123929,6 +124252,7 @@ var SkillManager = class {
       const extensions = this.config.getActiveExtensions();
       const skills2 = [];
       for (const extension of extensions) {
+        if (extension.skillsDiscoveryHasErrors) onDiscoveryError?.();
         extension.skills?.forEach((skill) => {
           const hasInvalidPriority = skill.priority !== void 0 && (typeof skill.priority !== "number" || !Number.isFinite(skill.priority));
           if (hasInvalidPriority) {
@@ -123961,14 +124285,12 @@ var SkillManager = class {
     }
     if (level === "bundled") {
       const bundledDir = this.bundledSkillsDir;
-      if (!fsSync2.existsSync(bundledDir)) {
-        debugLogger81.warn(
-          `Bundled skills directory not found: ${bundledDir}. This may indicate an incomplete installation.`
-        );
-        return [];
-      }
       debugLogger81.debug(`Loading bundled skills from: ${bundledDir}`);
-      const skills2 = await this.loadSkillsFromDir(bundledDir, "bundled");
+      const skills2 = await this.loadSkillsFromDir(
+        bundledDir,
+        "bundled",
+        onDiscoveryError
+      );
       debugLogger81.debug(`Loaded ${skills2.length} bundled skills`);
       return skills2;
     }
@@ -123976,7 +124298,7 @@ var SkillManager = class {
     const perDirSkills = await Promise.all(
       baseDirs.map((baseDir) => {
         debugLogger81.debug(`Loading ${level} level skills from: ${baseDir}`);
-        return this.loadSkillsFromDir(baseDir, level);
+        return this.loadSkillsFromDir(baseDir, level, onDiscoveryError);
       })
     );
     const skills = [];
@@ -123997,7 +124319,7 @@ var SkillManager = class {
     debugLogger81.debug(`Loaded ${skills.length} ${level} level skills`);
     return skills;
   }
-  async loadSkillsFromDir(baseDir, level) {
+  async loadSkillsFromDir(baseDir, level, onDiscoveryError) {
     debugLogger81.debug(`Loading skills from directory: ${baseDir}`);
     try {
       const entries = await fs48.readdir(baseDir, { withFileTypes: true });
@@ -124018,6 +124340,9 @@ var SkillManager = class {
           if (isSymlink) {
             const check = await validateSymlinkTarget(skillDir);
             if (!check.ok) {
+              if (check.reason === "invalid" && !(isNodeError(check.error) && check.error.code === "ENOENT")) {
+                onDiscoveryError?.();
+              }
               if (check.reason === "not-directory") {
                 debugLogger81.warn(
                   `Skipping symlink ${entry.name} that does not point to a directory`
@@ -124035,6 +124360,9 @@ var SkillManager = class {
             await fs48.access(skillManifest);
             return await this.parseSkillFileInternal(skillManifest, level);
           } catch (error3) {
+            if (!(isNodeError(error3) && error3.code === "ENOENT")) {
+              onDiscoveryError?.();
+            }
             if (error3 instanceof SkillError) {
               debugLogger81.error(
                 `Failed to parse skill at ${skillDir}: ${error3.message}`
@@ -124050,6 +124378,13 @@ var SkillManager = class {
       );
       return loaded.filter((s3) => s3 !== null);
     } catch (error3) {
+      if (!(isNodeError(error3) && error3.code === "ENOENT")) {
+        onDiscoveryError?.();
+      } else if (level === "bundled") {
+        debugLogger81.warn(
+          `Bundled skills directory not found: ${baseDir}. This may indicate an incomplete installation.`
+        );
+      }
       const errorMessage = error3 instanceof Error ? error3.message : "Unknown error";
       debugLogger81.debug(
         `Cannot read skills directory ${baseDir}: ${errorMessage}`
@@ -141383,7 +141718,7 @@ init_esbuild_shims();
 import * as fs71 from "node:fs";
 import * as path72 from "node:path";
 var debugLogger102 = createDebugLogger("AGENT_PLUGINS_V1");
-async function loadAgentPluginSkills(pluginRoot) {
+async function loadAgentPluginSkills(pluginRoot, onError) {
   const skillsPath = path72.join(pluginRoot, "skills");
   let resolvedSkillsPath;
   try {
@@ -141393,7 +141728,8 @@ async function loadAgentPluginSkills(pluginRoot) {
       return [];
     }
   } catch (error3) {
-    if (error3.code === "ENOENT") return [];
+    if (isNodeError(error3) && error3.code === "ENOENT") return [];
+    onError?.(error3);
     debugLogger102.warn(
       `Disabling Agent Plugins skills: ${error3 instanceof Error ? error3.message : String(error3)}`
     );
@@ -141405,6 +141741,7 @@ async function loadAgentPluginSkills(pluginRoot) {
       withFileTypes: true
     });
   } catch (error3) {
+    if (!(isNodeError(error3) && error3.code === "ENOENT")) onError?.(error3);
     debugLogger102.warn(
       `Disabling Agent Plugins skills: ${error3 instanceof Error ? error3.message : String(error3)}`
     );
@@ -141428,6 +141765,7 @@ async function loadAgentPluginSkills(pluginRoot) {
       const content = await fs71.promises.readFile(resolvedManifest, "utf8");
       skills.push(parseAgentPluginSkill(content, resolvedManifest, entry.name));
     } catch (error3) {
+      if (!(isNodeError(error3) && error3.code === "ENOENT")) onError?.(error3);
       debugLogger102.warn(
         `Skipping Agent Plugins skill "${entry.name}": ${error3 instanceof Error ? error3.message : String(error3)}`
       );
@@ -142651,9 +142989,15 @@ var ExtensionManager = class _ExtensionManager {
       const { loadedManifest } = head;
       const config3 = extension.config;
       const effectiveExtensionPath = extension.path;
+      const onSkillsDiscoveryError = /* @__PURE__ */ __name(() => {
+        head.extension.skillsDiscoveryHasErrors = true;
+      }, "onSkillsDiscoveryError");
       if (loadedManifest.format === "agent-plugins-v1") {
         extension.commands = [];
-        extension.skills = await loadAgentPluginSkills(effectiveExtensionPath);
+        extension.skills = await loadAgentPluginSkills(
+          effectiveExtensionPath,
+          onSkillsDiscoveryError
+        );
         extension.agents = [];
         extension.workflows = [];
       } else {
@@ -142664,7 +143008,8 @@ var ExtensionManager = class _ExtensionManager {
           (contextFileName) => path73.join(effectiveExtensionPath, contextFileName)
         ).filter((contextFilePath) => fs72.existsSync(contextFilePath));
         extension.skills = await loadSkillsFromDir(
-          `${effectiveExtensionPath}/skills`
+          `${effectiveExtensionPath}/skills`,
+          onSkillsDiscoveryError
         );
         const agentExecutorRefusals = /* @__PURE__ */ new Map();
         extension.agents = await loadSubagentFromDir(
@@ -144318,7 +144663,7 @@ var HookRegistry = class {
 
 // packages/core/src/hooks/hookRunner.ts
 init_esbuild_shims();
-import { execFile as execFile10, spawn as spawn6 } from "node:child_process";
+import { execFile as execFile10, spawn as spawn7 } from "node:child_process";
 import { randomUUID as randomUUID16 } from "node:crypto";
 import { rmSync as rmSync6, writeFileSync as writeFileSync8 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
@@ -146800,7 +147145,7 @@ var HookRunner = class {
         const supervisorEnv = { ...env };
         delete supervisorEnv["NODE_OPTIONS"];
         try {
-          child = spawn6(
+          child = spawn7(
             process.execPath,
             [
               "--input-type=commonjs",
@@ -146836,7 +147181,7 @@ var HookRunner = class {
         }
       } else {
         resolveSupervisorStarted();
-        child = spawn6(
+        child = spawn7(
           shellConfig.executable,
           [...shellConfig.argsPrefix, command],
           {
@@ -155020,7 +155365,7 @@ var Config = class _Config {
     await this.proxyDispatcherReady;
     options2?.signal?.throwIfAborted();
     if (this.isOmniEnabled()) {
-      const { normalizeDedicatedOmniUploadConfig } = await import("./upload-config-DMZVTDH7.js");
+      const { normalizeDedicatedOmniUploadConfig } = await import("./upload-config-LVVUIKA2.js");
       this.omniUploadConfig = normalizeDedicatedOmniUploadConfig({
         baseUrl: this.omniUploadBaseUrl,
         apiKeyEnv: this.omniUploadApiKeyEnv,
@@ -158421,6 +158766,9 @@ var Config = class _Config {
     }
     if (fromMode !== mode) {
       this.autoModeDenialState = resetDenialState();
+      if (!isDerivedConfig(this) && mode !== "plan" /* PLAN */ && fromMode !== "plan" /* PLAN */) {
+        clearSessionCommits();
+      }
     }
     this.approvalMode = mode;
     if (mode !== "plan" /* PLAN */) this.planExecutionMode = void 0;
@@ -158959,7 +159307,7 @@ var Config = class _Config {
     return this.omniPolicyTools;
   }
   async loadOmniMediaReader() {
-    return import("./omni-3NREMV2Q.js");
+    return import("./omni-DLBHISHC.js");
   }
   /** Normalized `omni.processing` view. Undefined until tool warmup
    * completes (or when omni is disabled). */
@@ -160535,7 +160883,7 @@ var Config = class _Config {
   async registerWorkflowTool(registry3) {
     if (registry3.getAllToolNames().includes(ToolNames.WORKFLOW)) return true;
     await this.registerLazyTool(registry3, ToolNames.WORKFLOW, async () => {
-      const { WorkflowTool } = await import("./workflow-ZZPHI7FK.js");
+      const { WorkflowTool } = await import("./workflow-FRJO5ZUI.js");
       return new WorkflowTool(this);
     });
     return registry3.getAllToolNames().includes(ToolNames.WORKFLOW);
@@ -160584,7 +160932,7 @@ var Config = class _Config {
       return;
     }
     const factory = /* @__PURE__ */ __name(async () => {
-      const { RecordSourceTool } = await import("./record-source-XZCI3IGU.js");
+      const { RecordSourceTool } = await import("./record-source-2VBLKVIE.js");
       return new RecordSourceTool(this);
     }, "factory");
     if (status === "deferred") {
@@ -160615,16 +160963,16 @@ var Config = class _Config {
     const registerGoalWorkerTools = /* @__PURE__ */ __name(async () => {
       if (options2?.forSubAgent) return;
       await registerLazy(ToolNames.GET_GOAL, async () => {
-        const { GetGoalTool: GetGoalTool2 } = await import("./goal-tools-KWGKFUSK.js");
+        const { GetGoalTool: GetGoalTool2 } = await import("./goal-tools-G4RIX4ER.js");
         return new GetGoalTool2(this);
       });
       await registerLazy(ToolNames.UPDATE_GOAL, async () => {
-        const { UpdateGoalTool: UpdateGoalTool2 } = await import("./goal-tools-KWGKFUSK.js");
+        const { UpdateGoalTool: UpdateGoalTool2 } = await import("./goal-tools-G4RIX4ER.js");
         return new UpdateGoalTool2(this);
       });
       if (this.getModelProposedGoals() !== "disabled" && (resolveInteractionMode(this) === "interactive" || this.goalProposalHostSupported)) {
         await registerLazy(ToolNames.PROPOSE_GOAL, async () => {
-          const { ProposeGoalTool: ProposeGoalTool2 } = await import("./goal-tools-KWGKFUSK.js");
+          const { ProposeGoalTool: ProposeGoalTool2 } = await import("./goal-tools-G4RIX4ER.js");
           return new ProposeGoalTool2(this);
         });
       }
@@ -160644,16 +160992,16 @@ var Config = class _Config {
         });
       }
       await registerLazy(ToolNames.WEB_FETCH, async () => {
-        const { WebFetchTool } = await import("./web-fetch-LMCOAHW6.js");
+        const { WebFetchTool } = await import("./web-fetch-3O2DFRE5.js");
         return new WebFetchTool(this);
       });
       const hasExplicitWebSearchBackend = !!this.webSearchSettings?.model?.trim() || !!this.webSearchSettings?.baseUrl;
       if (!this.getBareMode() && !this.isSafeMode() && this.webSearchSettings?.enabled !== false && (this.webSearchSettings?.enabled === true || !hasExplicitWebSearchBackend)) {
-        const { evaluateWebSearchGate } = await import("./web-search-N7RR74LA.js");
+        const { evaluateWebSearchGate } = await import("./web-search-5FS3NB3D.js");
         const gate = evaluateWebSearchGate(this);
         if (gate.ok) {
           await registerLazy(ToolNames.WEB_SEARCH, async () => {
-            const { WebSearchTool } = await import("./web-search-N7RR74LA.js");
+            const { WebSearchTool } = await import("./web-search-5FS3NB3D.js");
             return new WebSearchTool(this);
           });
         } else if (!gate.silent && !this.webSearchNoticeEmitted && !options2?.forSubAgent) {
@@ -160670,8 +161018,8 @@ var Config = class _Config {
         );
       }
       const [{ createExecutionTools }, { wrapExecutionTool }] = await Promise.all([
-        import("./local-execution-environment-IQHCTUJ5.js"),
-        import("./execution-tool-IIEL25CL.js")
+        import("./local-execution-environment-XIQLRMLF.js"),
+        import("./execution-tool-DZ4XSEFZ.js")
       ]);
       for (const [name, tool] of createExecutionTools(this)) {
         if (environment.toolNames && !environment.toolNames.has(name)) continue;
@@ -160682,11 +161030,11 @@ var Config = class _Config {
         );
       }
       await registerLazy(ToolNames.TOOL_CALL, async () => {
-        const { ToolCallTool } = await import("./tool-call-PLSQ34VE.js");
+        const { ToolCallTool } = await import("./tool-call-DUHP6UXC.js");
         return new ToolCallTool(registry3);
       });
       await registerLazy(ToolNames.TOOL_SEARCH, async () => {
-        const { ToolSearchTool } = await import("./tool-search-534QKE2X.js");
+        const { ToolSearchTool } = await import("./tool-search-ET4NH2LK.js");
         return new ToolSearchTool(this);
       });
       if (this.executionEnvironment && !options2?.forSubAgent) {
@@ -160698,7 +161046,7 @@ var Config = class _Config {
     }
     if (this.shellExecutionSandbox) {
       await registerLazy(ToolNames.SHELL, async () => {
-        const { ShellTool: ShellTool2 } = await import("./shell-3V26EVNC.js");
+        const { ShellTool: ShellTool2 } = await import("./shell-THD5EYOK.js");
         return new ShellTool2(this);
       });
       await registerLazy(ToolNames.TASK_STOP, async () => {
@@ -160706,27 +161054,27 @@ var Config = class _Config {
         return new TaskStopTool(this);
       });
       await registerLazy(ToolNames.READ_FILE, async () => {
-        const { ReadFileTool } = await import("./read-file-IM4Q5TKI.js");
+        const { ReadFileTool } = await import("./read-file-SXS2MKDY.js");
         return new ReadFileTool(this);
       });
       await registerLazy(ToolNames.WRITE_FILE, async () => {
-        const { WriteFileTool } = await import("./write-file-CT54LXQL.js");
+        const { WriteFileTool } = await import("./write-file-BATJLBJX.js");
         return new WriteFileTool(this);
       });
       await registerLazy(ToolNames.EDIT, async () => {
-        const { EditTool } = await import("./edit-TQ3CABYP.js");
+        const { EditTool } = await import("./edit-FPIWTN3L.js");
         return new EditTool(this);
       });
       await registerLazy(ToolNames.MONITOR, async () => {
-        const { MonitorTool } = await import("./monitor-ZXRV2DJB.js");
+        const { MonitorTool } = await import("./monitor-7JUZXYZN.js");
         return new MonitorTool(this);
       });
       await registerLazy(ToolNames.AGENT, async () => {
-        const { AgentTool: AgentTool2 } = await import("./agent-75EZNG2Q.js");
+        const { AgentTool: AgentTool2 } = await import("./agent-MTWGIPWC.js");
         return new AgentTool2(this);
       });
       await registerLazy(ToolNames.GLOB, async () => {
-        const { GlobTool } = await import("./glob-OEB4WH3Z.js");
+        const { GlobTool } = await import("./glob-UOKQZHKL.js");
         return new GlobTool(this);
       });
       await registerLazy(ToolNames.LS, async () => {
@@ -160735,7 +161083,7 @@ var Config = class _Config {
       });
       if (resolveInteractionMode(this) !== "headless") {
         await registerLazy(ToolNames.ASK_USER_QUESTION, async () => {
-          const { AskUserQuestionTool: AskUserQuestionTool2 } = await import("./askUserQuestion-2NU6CXK2.js");
+          const { AskUserQuestionTool: AskUserQuestionTool2 } = await import("./askUserQuestion-V4OFZD5D.js");
           return new AskUserQuestionTool2(this);
         });
       }
@@ -160745,19 +161093,19 @@ var Config = class _Config {
     }
     if (this.getBareMode()) {
       await registerLazy(ToolNames.READ_FILE, async () => {
-        const { ReadFileTool } = await import("./read-file-IM4Q5TKI.js");
+        const { ReadFileTool } = await import("./read-file-SXS2MKDY.js");
         return new ReadFileTool(this);
       });
       await registerLazy(ToolNames.EDIT, async () => {
-        const { EditTool } = await import("./edit-TQ3CABYP.js");
+        const { EditTool } = await import("./edit-FPIWTN3L.js");
         return new EditTool(this);
       });
       await registerLazy(ToolNames.NOTEBOOK_EDIT, async () => {
-        const { NotebookEditTool } = await import("./notebook-edit-FBVHAHYM.js");
+        const { NotebookEditTool } = await import("./notebook-edit-IYDACZDW.js");
         return new NotebookEditTool(this);
       });
       await registerLazy(ToolNames.SHELL, async () => {
-        const { ShellTool: ShellTool2 } = await import("./shell-3V26EVNC.js");
+        const { ShellTool: ShellTool2 } = await import("./shell-THD5EYOK.js");
         return new ShellTool2(this);
       });
       await registerGoalWorkerTools();
@@ -160772,11 +161120,11 @@ var Config = class _Config {
     await registerExecIfEnabled();
     await registerGoalWorkerTools();
     await registerLazy(ToolNames.TOOL_CALL, async () => {
-      const { ToolCallTool } = await import("./tool-call-PLSQ34VE.js");
+      const { ToolCallTool } = await import("./tool-call-DUHP6UXC.js");
       return new ToolCallTool(registry3);
     });
     await registerLazy(ToolNames.TOOL_SEARCH, async () => {
-      const { ToolSearchTool } = await import("./tool-search-534QKE2X.js");
+      const { ToolSearchTool } = await import("./tool-search-ET4NH2LK.js");
       return new ToolSearchTool(this);
     });
     await registerLazy(ToolNames.READ_MCP_RESOURCE, async () => {
@@ -160784,7 +161132,7 @@ var Config = class _Config {
       return new ReadMcpResourceTool(this);
     });
     await registerLazy(ToolNames.AGENT, async () => {
-      const { AgentTool: AgentTool2 } = await import("./agent-75EZNG2Q.js");
+      const { AgentTool: AgentTool2 } = await import("./agent-MTWGIPWC.js");
       return new AgentTool2(this);
     });
     await registerLazy(ToolNames.LIST_AGENTS, async () => {
@@ -160796,11 +161144,11 @@ var Config = class _Config {
       return new TaskStopTool(this);
     });
     await registerLazy(ToolNames.SEND_MESSAGE, async () => {
-      const { SendMessageTool } = await import("./send-message-3UM7XRTB.js");
+      const { SendMessageTool } = await import("./send-message-FBU6WDID.js");
       return new SendMessageTool(this);
     });
     await registerLazy(ToolNames.SKILL, async () => {
-      const { SkillTool } = await import("./skill-XP7F3LBV.js");
+      const { SkillTool } = await import("./skill-2D6KXDC5.js");
       return new SkillTool(this);
     });
     if (this.isLsToolEnabled()) {
@@ -160810,11 +161158,11 @@ var Config = class _Config {
       });
     }
     await registerLazy(ToolNames.READ_FILE, async () => {
-      const { ReadFileTool } = await import("./read-file-IM4Q5TKI.js");
+      const { ReadFileTool } = await import("./read-file-SXS2MKDY.js");
       return new ReadFileTool(this);
     });
     await registerLazy(ToolNames.ZOOM_IMAGE, async () => {
-      const { ZoomImageTool } = await import("./zoom-image-EU3PGSZM.js");
+      const { ZoomImageTool } = await import("./zoom-image-5I7DDLQE.js");
       return new ZoomImageTool(this);
     });
     if (this.getUseRipgrep()) {
@@ -160829,7 +161177,7 @@ var Config = class _Config {
       recordStartupEvent("config_initialize_ripgrep_probe_end");
       if (useRipgrep) {
         await registerLazy(ToolNames.GREP, async () => {
-          const { RipGrepTool } = await import("./ripGrep-BG2FEVIV.js");
+          const { RipGrepTool } = await import("./ripGrep-X33VVIN5.js");
           return new RipGrepTool(this);
         });
       } else {
@@ -160855,54 +161203,54 @@ var Config = class _Config {
       });
     }
     await registerLazy(ToolNames.GLOB, async () => {
-      const { GlobTool } = await import("./glob-OEB4WH3Z.js");
+      const { GlobTool } = await import("./glob-UOKQZHKL.js");
       return new GlobTool(this);
     });
     await registerLazy(ToolNames.EDIT, async () => {
-      const { EditTool } = await import("./edit-TQ3CABYP.js");
+      const { EditTool } = await import("./edit-FPIWTN3L.js");
       return new EditTool(this);
     });
     await registerLazy(ToolNames.NOTEBOOK_EDIT, async () => {
-      const { NotebookEditTool } = await import("./notebook-edit-FBVHAHYM.js");
+      const { NotebookEditTool } = await import("./notebook-edit-IYDACZDW.js");
       return new NotebookEditTool(this);
     });
     await registerLazy(ToolNames.WRITE_FILE, async () => {
-      const { WriteFileTool } = await import("./write-file-CT54LXQL.js");
+      const { WriteFileTool } = await import("./write-file-BATJLBJX.js");
       return new WriteFileTool(this);
     });
     await registerLazy(ToolNames.SHELL, async () => {
-      const { ShellTool: ShellTool2 } = await import("./shell-3V26EVNC.js");
+      const { ShellTool: ShellTool2 } = await import("./shell-THD5EYOK.js");
       return new ShellTool2(this);
     });
     await registerLazy(ToolNames.REPORT_FINDINGS, async () => {
-      const { ReportFindingsTool } = await import("./report-findings-MCGXBQFX.js");
+      const { ReportFindingsTool } = await import("./report-findings-D2QUYUOG.js");
       return new ReportFindingsTool();
     });
     const supportsUserInteraction = resolveInteractionMode(this) !== "headless";
     if (supportsUserInteraction) {
       await registerLazy(ToolNames.ASK_USER_QUESTION, async () => {
-        const { AskUserQuestionTool: AskUserQuestionTool2 } = await import("./askUserQuestion-2NU6CXK2.js");
+        const { AskUserQuestionTool: AskUserQuestionTool2 } = await import("./askUserQuestion-V4OFZD5D.js");
         return new AskUserQuestionTool2(this);
       });
     }
     if (!this.sdkMode && (supportsUserInteraction || options2?.forSubAgent)) {
       await registerLazy(ToolNames.EXIT_PLAN_MODE, async () => {
-        const { ExitPlanModeTool: ExitPlanModeTool2 } = await import("./exitPlanMode-PUICCCQ5.js");
+        const { ExitPlanModeTool: ExitPlanModeTool2 } = await import("./exitPlanMode-VIGOD2KP.js");
         return new ExitPlanModeTool2(this);
       });
     }
     if (!this.sdkMode && supportsUserInteraction) {
       await registerLazy(ToolNames.ENTER_PLAN_MODE, async () => {
-        const { EnterPlanModeTool } = await import("./enterPlanMode-JHOWELZO.js");
+        const { EnterPlanModeTool } = await import("./enterPlanMode-GDZVXYB2.js");
         return new EnterPlanModeTool(this);
       });
     }
     await registerLazy(ToolNames.ENTER_WORKTREE, async () => {
-      const { EnterWorktreeTool } = await import("./enter-worktree-J46XVFRS.js");
+      const { EnterWorktreeTool } = await import("./enter-worktree-55OWD4LT.js");
       return new EnterWorktreeTool(this);
     });
     await registerLazy(ToolNames.EXIT_WORKTREE, async () => {
-      const { ExitWorktreeTool } = await import("./exit-worktree-BC4SDZCC.js");
+      const { ExitWorktreeTool } = await import("./exit-worktree-MI6N4OUP.js");
       return new ExitWorktreeTool(this);
     });
     if (resolveInteractionMode(this) === "interactive" && !this.sdkMode && !this.getScreenReader() && !options2?.forSubAgent) {
@@ -160923,7 +161271,7 @@ var Config = class _Config {
     }
     if (this.isRecordArtifactEnabled()) {
       await registerLazy(ToolNames.RECORD_ARTIFACT, async () => {
-        const { RecordArtifactTool } = await import("./record-artifact-K4XSMW4X.js");
+        const { RecordArtifactTool } = await import("./record-artifact-XP3X7RE5.js");
         return new RecordArtifactTool(this);
       });
     }
@@ -160960,7 +161308,7 @@ var Config = class _Config {
     }
     if (this.isAgentTeamEnabled()) {
       await registerLazy(ToolNames.TEAM_CREATE, async () => {
-        const { TeamCreateTool } = await import("./team-create-Z5JUEMB7.js");
+        const { TeamCreateTool } = await import("./team-create-TPCELNBJ.js");
         return new TeamCreateTool(this);
       });
       await registerLazy(ToolNames.TEAM_DELETE, async () => {
@@ -160968,21 +161316,21 @@ var Config = class _Config {
         return new TeamDeleteTool(this);
       });
       await registerLazy(ToolNames.TEAM_PLAN_APPROVAL, async () => {
-        const { TeamPlanApprovalTool } = await import("./team-plan-approval-ZLLHMEQN.js");
+        const { TeamPlanApprovalTool } = await import("./team-plan-approval-RUURGHQL.js");
         return new TeamPlanApprovalTool(this);
       });
       if (!options2?.forSubAgent) {
         await registerLazy(ToolNames.REQUEST_SHUTDOWN, async () => {
-          const { RequestShutdownTool } = await import("./request-shutdown-TT62PREA.js");
+          const { RequestShutdownTool } = await import("./request-shutdown-R5SA5GE3.js");
           return new RequestShutdownTool(this);
         });
       }
       await registerLazy(ToolNames.TASK_CREATE, async () => {
-        const { TaskCreateTool } = await import("./task-create-PEI7AJLE.js");
+        const { TaskCreateTool } = await import("./task-create-PVF66J3R.js");
         return new TaskCreateTool(this);
       });
       await registerLazy(ToolNames.TASK_UPDATE, async () => {
-        const { TaskUpdateTool } = await import("./task-update-MQZRWBGK.js");
+        const { TaskUpdateTool } = await import("./task-update-RSIITTOK.js");
         return new TaskUpdateTool(this);
       });
       await registerLazy(ToolNames.TASK_LIST, async () => {
@@ -161064,7 +161412,7 @@ var Config = class _Config {
       }
     }
     await registerLazy(ToolNames.MONITOR, async () => {
-      const { MonitorTool } = await import("./monitor-ZXRV2DJB.js");
+      const { MonitorTool } = await import("./monitor-7JUZXYZN.js");
       return new MonitorTool(this);
     });
     if (this.pendingMcpBudgetCallback) {
@@ -161789,6 +162137,21 @@ export {
   loadUsageHistoryWithLive,
   getTimeRangeBounds,
   aggregateUsage,
+  isValidRefName,
+  resolveBranchName,
+  watchRepoBranch,
+  gitEnv,
+  streamGitRecords,
+  runGitCapture,
+  runGit,
+  fetchGitBranches,
+  isValidCheckoutRef,
+  gitCheckout,
+  gitCreateBranch,
+  gitPush,
+  GitPullFailure,
+  gitPull,
+  gitCommit,
   MAX_FILES,
   MAX_DIFF_SIZE_BYTES,
   MAX_LINES_PER_FILE,
@@ -161811,19 +162174,6 @@ export {
   GROUP_COLOR_OPTIONS,
   SessionOrganizationError,
   SessionOrganizationService,
-  isValidRefName,
-  resolveBranchName,
-  watchRepoBranch,
-  gitEnv,
-  runGit2 as runGit,
-  fetchGitBranches,
-  isValidCheckoutRef,
-  gitCheckout,
-  gitCreateBranch,
-  gitPush,
-  GitPullFailure,
-  gitPull,
-  gitCommit,
   GITHUB_PR_ERROR_MESSAGE_MAX,
   fetchGitHubPullRequests,
   createGitHubPullRequest,
@@ -161856,6 +162206,8 @@ export {
   SessionTranscriptPageTooLargeError,
   SessionTranscriptCursorCodec,
   encodeSessionTranscriptCursor,
+  navigationKindForRecord,
+  isReplayTurnStartType,
   SessionTranscriptReader,
   SessionWriterError,
   SESSION_WRITER_RPC_CODES,