@quantiya/codevibe-codex-plugin 2.0.61 → 2.0.63

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/cli.js

@@ -8529,7 +8529,12 @@ function renderLocalGemmaPlannerPrompt(input, options) {
     'User: "Can you code in Rust?" -> {"action":"advisory_response","rationale":"capability question, no repo context","advisory_summary":"Yes \u2014 I can write and review Rust code across libraries, CLIs, and web services."}',
     'User: "That sounds like a summary, I am looking for your thoughts" (a web page was read earlier in this session) -> {"action":"advisory_response","rationale":"opinion follow-up on the page read earlier","advisory_summary":"<your own analysis of that page>"}',
     'User: "what do you think about that article?" -> {"action":"advisory_response","rationale":"opinion follow-up on earlier content","advisory_summary":"<your view on the article>"}',
-    options?.isSubprocessRunner ? 'User: "what did the last task change?" -> {"action":"summarize_current_status","rationale":"status question"}' : 'User: "what did the last task change?" -> {"action":"advisory_response","rationale":"status question; the shell attaches the status record"}',
+    options?.isSubprocessRunner ? 'User: "what did the last task change?" -> {"action":"summarize_current_status","rationale":"status question"}' : [
+      'User: "what did the last task change?" -> {"action":"advisory_response","rationale":"status question; the shell attaches the status record"}',
+      'User: "Show me the diff of the most recent commit on this branch" -> {"action":"advisory_response","rationale":"inspect commit diff status"}',
+      'User: "Are there any untracked or modified files in the working tree right now?" -> {"action":"advisory_response","rationale":"inspect working tree status"}'
+    ].join(`
+`),
     'User: "What kind of applications can you implement?" -> {"action":"advisory_response","rationale":"capability question","advisory_summary":"I can implement CLIs, web apps, APIs, libraries, scripts, data pipelines, and tests across most popular languages."}',
     'User: "What is this [path]\\n\\n[The user attached 1 image(s).]" -> {"action":"advisory_response","rationale":"describe the attached image"}',
     'User: "describe this\\n\\n[The user attached 1 image(s).]" -> {"action":"advisory_response","rationale":"describe the attached image"}',
@@ -8972,12 +8977,12 @@ function requestOllamaGenerateStream(config, promptText, opts) {
       num_ctx: numCtx
     }
   }), url = new URL("/api/generate", config.host), timeoutMs = opts?.timeoutMs ?? config.timeoutMs;
-  return new Promise((resolve24, reject) => {
-    let settled = !1, responseBytes = 0, buffer = "", decoder = new import_string_decoder.StringDecoder("utf8"), out = { text: "" }, emptyRun = 0, chunks = 0, sawDone = !1, lastDone, ndjson = !1, idleTimer = null, activeRes = null, clearIdle = () => {
+  return opts?.signal?.aborted ? Promise.reject(new Error("Ollama generation aborted by signal")) : new Promise((resolve24, reject) => {
+    let settled = !1, responseBytes = 0, buffer = "", decoder = new import_string_decoder.StringDecoder("utf8"), out = { text: "" }, emptyRun = 0, chunks = 0, sawDone = !1, lastDone, ndjson = !1, timeout = null, idleTimer = null, activeRes = null, clearIdle = () => {
       idleTimer && (clearTimeout(idleTimer), idleTimer = null);
     }, finish = (fn) => {
       if (!settled) {
-        settled = !0, clearTimeout(timeout), clearIdle();
+        settled = !0, timeout && clearTimeout(timeout), clearIdle();
         try {
           fn();
         } catch (err) {
@@ -9078,10 +9083,19 @@ function requestOllamaGenerateStream(config, promptText, opts) {
           }
         }));
       }
-    ), timeout = setTimeout(() => {
+    );
+    if (req.on("error", (err) => finish(() => reject(err))), timeout = setTimeout(() => {
       req.destroy(new Error(`Ollama request timed out after ${timeoutMs}ms`));
-    }, timeoutMs);
-    req.on("error", (err) => finish(() => reject(err))), req.end(body);
+    }, timeoutMs), opts?.signal) {
+      if (opts.signal.aborted) {
+        finish(() => reject(new Error("Ollama generation aborted by signal"))), req.destroy();
+        return;
+      }
+      opts.signal.addEventListener("abort", () => {
+        finish(() => reject(new Error("Ollama generation aborted by signal"))), req.destroy(), activeRes?.destroy();
+      }, { once: !0 });
+    }
+    req.end(body);
   });
 }
 function describeRecordError(value) {
@@ -9184,6 +9198,7 @@ function requestOllamaPull(config, onProgress = () => {
 var OllamaGemmaPlannerRunner = class {
   constructor(config) {
     this.config = config;
+    this.providerKind = "local";
     this.runtimeLabel = `local-gemma-ollama:${config.model}`;
   }
   classify(promptText, options) {
@@ -9195,7 +9210,8 @@ var OllamaGemmaPlannerRunner = class {
       numPredict,
       // #618 — advisory generations (long prompts, big output budgets) get the
       // advisory timeout floor; classify keeps the fast-fail config timeout.
-      timeoutMs: advisoryTimeoutMs(this.config.timeoutMs),
+      timeoutMs: options?.timeoutMs ?? advisoryTimeoutMs(this.config.timeoutMs),
+      ...options?.signal ? { signal: options.signal } : {},
       // IMAGE-ATTACHMENT-DESIGN.md §6: forward RAW base64 images (multimodal
       // answerer). Only the shell's `routeAdvisory`/image-brainstorm passes these
       // with `responseFormat:'text'`; the classifier never does (forced-JSON).
@@ -67548,7 +67564,1008 @@ function chronologicalSupervisionEvents(newestFirstEvents) {
 // src/orchestration-shell/git-status-summary.ts
 var path64 = __toESM(require("path")), import_child_process5 = require("child_process"), import_util3 = require("util");
 init_env_scrub();
-var defaultExecFileAsync = (0, import_util3.promisify)(import_child_process5.execFile), GIT_QUERY_PATTERN = /\b(git\s+(?:status|log|diff|show|branch)|commit\s+history|recent\s+commits)\b/i, IGNORED_TARGET_NAMES = /* @__PURE__ */ new Set([
+init_logger2();
+var defaultExecFileAsync = (0, import_util3.promisify)(import_child_process5.execFile), GIT_QUERY_PATTERN = /\b(git\s+(?:status|log|diff|show|branch)|commit\s+history|recent\s+commits)\b/i;
+var COMMIT_DIFF_PATTERN = /\b(?:diff\s+of\s+(?:the\s+)?(?:most\s+recent|last|latest|current|head)\s+commit\b|(?:most\s+recent|last|latest|current|head)\s+commit(?:'s)?\s+diff\b|(?:show|view|see)\s+(?:the\s+)?diff\s+of\s+(?:the\s+)?(?:most\s+recent|last|latest|current)\b|(?:what\s+changed\s+in|changes?\s+in)\s+(?:the\s+)?(?:most\s+recent|last|latest|current|head)\s+commit\b|(?:show|view|see)\s+what\s+changed\s+in\s+(?:the\s+)?(?:latest|last|most\s+recent)\s+commit\b|(?:show|view|see|inspect|print|display|what\s+is)\s+(?:the\s+)?(?:most\s+recent|last|latest|current)\s+commit\b|[0-9a-f]{7,40}(?:[~^][A-Za-z0-9_/@~^-]*)?'s\s+diff\b|diff\s+of\s+(?:commit\s+)?(?![^\s;,?]*\.\.[a-zA-Z0-9_/@~^-])([0-9a-f]{7,40}(?:[~^][A-Za-z0-9_/@~^-]*)?)(?![0-9a-zA-Z_/@~^-]))/i;
+var SAFE_REF_PATTERN = /^[A-Za-z0-9_./@~^-]+$/, SAFE_REPO_NAME_PATTERN = /^[A-Za-z0-9_.-]+$/;
+function stripSentencePunctuation(token, options) {
+  let stripped = token.trim().replace(/^['"`“‘«‹「『(\[（《【]+/u, "");
+  return options?.preserveRangeDots && /\.{2,3}[,;:!?'"`”’»›」』)\]）》】]*$/u.test(stripped) ? stripped.replace(/[,;:!?'"`”’»›」』)\]）》】]+$/u, "") : (stripped = stripped.replace(/[.,;:!?'"`”’»›」』)\]）》】]+$/u, ""), stripped);
+}
+function extractBranchOrRefTarget(prompt) {
+  let positivePrompt = prompt.replace(
+    /\b(?:that\s+is\s+|which\s+is\s+)?(?:not|except|excluding|without|instead\s+of)\s+(?:on|in|for|from|to|into)\s+(?:the\s+)?(?:branch\s+[A-Za-z0-9_./@~^-]+|[A-Za-z0-9_./@~^-]+\s+branch|current\s+branch|active\s+branch|this\s+branch)\b/gi,
+    ""
+  ).replace(
+    /\b(?:that\s+is\s+|which\s+is\s+)?(?:not|except|excluding|without|instead\s+of)\s+(?:the\s+)?(?:current|active|this)\s+branch\b/gi,
+    ""
+  );
+  if (/(?:^|[\s,;])(?:on|in|for|from)\s+(?:the\s+|this\s+|current\s+|my\s+|our\s+|active\s+)?(?:this|current|active)\s+branch(?:\s+(?:in\s+detail|and\s+|please|now|here|summary|json))?[\s;,?.]*$/i.test(positivePrompt) || /^(?:this|current|active)\s+branch(?:\s+(?:in\s+detail|and\s+|please|now|here|summary|json))?[\s;,?.]*$/i.test(positivePrompt) || /\b(?:what|which)\s+branch\s+(?:am\s+i|is\s+this)\b/i.test(positivePrompt))
+    return;
+  let explicitPrefixMatch = positivePrompt.match(
+    /(?:(?<![\w-])(?:on|in|for|from|to|into)\s+(?:the\s+)?branch(?:\s+(?:named|called)\s+|:\s*|\s+)|(?<![\w-])(?:the\s+)?branch\s+(?:named|called)\s+|(?<![\w-])branch:\s*|(?<![\w-])(?:named|called)\s+branch\s+)([A-Za-z0-9_./@~^-]+)(?=[\s;,?.]|$)/i
+  );
+  if (explicitPrefixMatch) {
+    let candidate = stripSentencePunctuation(explicitPrefixMatch[1]), lower = candidate.toLowerCase();
+    if (!(/* @__PURE__ */ new Set([
+      "this",
+      "that",
+      "the",
+      "my",
+      "our",
+      "a",
+      "an",
+      "current",
+      "active",
+      "and",
+      "or",
+      "but",
+      "then",
+      "so",
+      "in",
+      "to",
+      "for",
+      "with",
+      "from",
+      "of",
+      "by",
+      "about",
+      "at",
+      "as",
+      "into",
+      "onto",
+      "please",
+      "now",
+      "here",
+      "there",
+      "name",
+      "names",
+      "named",
+      "called",
+      "what",
+      "which",
+      "how",
+      "who",
+      "where",
+      "why",
+      "am",
+      "is",
+      "are"
+    ])).has(lower) && SAFE_REF_PATTERN.test(candidate))
+      return candidate;
+  }
+  let suffixBranchMatch = positivePrompt.match(
+    /(?<![\w-])(?:on|in|for|from)\s+(?:the\s+)?([A-Za-z0-9_./@~^-]+)\s+branch\b/i
+  );
+  if (suffixBranchMatch) {
+    let candidate = stripSentencePunctuation(suffixBranchMatch[1]), lower = candidate.toLowerCase();
+    if (!(/* @__PURE__ */ new Set(["this", "that", "the", "my", "our", "a", "an", "current", "active", "which", "what", "each", "every"])).has(lower) && SAFE_REF_PATTERN.test(candidate))
+      return candidate;
+  }
+  let standaloneMatch = positivePrompt.match(
+    /(?:^|[,;(]\s*)branch\s+([A-Za-z0-9_./@~^-]+)(?=[\s;,?.]|$)/i
+  );
+  if (standaloneMatch) {
+    let candidate = stripSentencePunctuation(standaloneMatch[1]), lower = candidate.toLowerCase();
+    if (!(/* @__PURE__ */ new Set([
+      "this",
+      "that",
+      "the",
+      "my",
+      "our",
+      "a",
+      "an",
+      "current",
+      "active",
+      "and",
+      "or",
+      "but",
+      "then",
+      "so",
+      "in",
+      "to",
+      "for",
+      "with",
+      "from",
+      "of",
+      "by",
+      "about",
+      "at",
+      "as",
+      "into",
+      "onto",
+      "please",
+      "now",
+      "here",
+      "there",
+      "name",
+      "names",
+      "named",
+      "called",
+      "what",
+      "which",
+      "how",
+      "who",
+      "where",
+      "why",
+      "am",
+      "is",
+      "are"
+    ])).has(lower) && SAFE_REF_PATTERN.test(candidate))
+      return candidate;
+  }
+  let stopwords = /* @__PURE__ */ new Set([
+    "this",
+    "that",
+    "the",
+    "our",
+    "my",
+    "a",
+    "an",
+    "current",
+    "active",
+    "latest",
+    "recent",
+    "most",
+    "head",
+    "commit",
+    "commits",
+    "working",
+    "tree",
+    "directory",
+    "copy",
+    "repo",
+    "repository",
+    "status",
+    "diff",
+    "log",
+    "show",
+    "please",
+    "now",
+    "thanks",
+    "first",
+    "here",
+    "and",
+    "then",
+    "all",
+    "review",
+    "branches",
+    "branch",
+    "detail",
+    "details",
+    "depth",
+    "brief",
+    "short",
+    "summary",
+    "general",
+    "plain",
+    "text",
+    "markdown",
+    "terminal",
+    "json",
+    "name",
+    "names"
+    // Note: 'named' and 'called' removed from stopwords per Codex R12-F5 so
+    // "Show the latest commit on named" correctly resolves to "named"
+  ]), qualifiedMatch = positivePrompt.match(/\b(?:commit|diff|changes?|log|inspect|show)\s+(?:on|in|for|from)\s+(?:the\s+)?(?:branch\s+)?([A-Za-z0-9_./@~^-]+)(?:\s+branch)?(?=[\s;,?.]|$)/i);
+  if (qualifiedMatch) {
+    let candidate = stripSentencePunctuation(qualifiedMatch[1]);
+    if (!stopwords.has(candidate.toLowerCase()) && SAFE_REF_PATTERN.test(candidate))
+      return candidate;
+  }
+  let matches = [...positivePrompt.matchAll(/\b(?:on|in|for|from)\s+(?:the\s+)?(?:branch\s+)?([A-Za-z0-9_./@~^-]+)(?:\s+branch)?(?=[\s;,?.]|$)/gi)];
+  for (let m of matches) {
+    let candidate = stripSentencePunctuation(m[1]), lower = candidate.toLowerCase();
+    if (!stopwords.has(lower) && SAFE_REF_PATTERN.test(candidate))
+      return candidate;
+  }
+}
+function hasRefSyntax(ref) {
+  let lower = ref.toLowerCase();
+  return !!(["head", "main", "master"].includes(lower) || /^[0-9a-f]{7,40}$/i.test(ref) || /[~^@/]|\.{2,3}/.test(ref) || /^v\d+(?:\.\d+)*$/i.test(ref));
+}
+function isLastTokenInPrompt(prompt, token) {
+  let escaped = token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), cleaned = prompt.replace(/(?:[\s,;]+(?:please|thanks|thank\s+you|now|for\s+me))+[\s.!?;,:]*$/i, "");
+  return new RegExp(`(?:^|\\s)${escaped}[\\s.!?;,:]*$`, "i").test(cleaned);
+}
+var PURPOSE_VERBS = /* @__PURE__ */ new Set([
+  "review",
+  "compare",
+  "inspect",
+  "check",
+  "examine",
+  "see",
+  "view",
+  "verify",
+  "read",
+  "understand",
+  "share",
+  "make",
+  "study",
+  "test",
+  "explain",
+  "commit",
+  "push",
+  "merge",
+  "stage",
+  "apply",
+  "approve"
+]), PRESENTATION_WORDS = /* @__PURE__ */ new Set([
+  "stat",
+  "stats",
+  "statistics",
+  "context",
+  "color",
+  "colors",
+  "detail",
+  "details",
+  "line",
+  "lines",
+  "number",
+  "numbers",
+  "comment",
+  "comments",
+  "whitespace",
+  "whitespaces",
+  "explanation",
+  "explanations",
+  "message",
+  "messages",
+  "history",
+  "hash",
+  "hashes",
+  "info",
+  "information"
+]), NON_GIT_SOFTWARE_LIBRARIES = /* @__PURE__ */ new Set([
+  "node",
+  "nodejs",
+  "python",
+  "java",
+  "react",
+  "vue",
+  "angular",
+  "rust",
+  "go",
+  "golang",
+  "ruby",
+  "rails",
+  "django",
+  "spring",
+  "postgres",
+  "postgresql",
+  "mysql",
+  "sqlite",
+  "redis",
+  "docker",
+  "kubernetes",
+  "k8s"
+]), TEMPORAL_WORDS = /* @__PURE__ */ new Set([
+  "monday",
+  "tuesday",
+  "wednesday",
+  "thursday",
+  "friday",
+  "saturday",
+  "sunday",
+  "yesterday",
+  "today",
+  "tomorrow",
+  "tonight",
+  "morning",
+  "afternoon",
+  "evening",
+  "recent",
+  "week",
+  "month",
+  "year",
+  "day",
+  "hour",
+  "minute",
+  "before",
+  "after",
+  "prior",
+  "earlier",
+  "previous"
+]), EXPLICIT_STRUCTURAL_EXCLUDED = /* @__PURE__ */ new Set([
+  "working",
+  "tree",
+  "copy",
+  "index",
+  "staging",
+  "cache",
+  "repo",
+  "repository",
+  "it",
+  "me",
+  "us",
+  "them",
+  "this",
+  "that",
+  "the",
+  "a",
+  "an",
+  "my",
+  "our",
+  "your",
+  "their"
+]), COMMAND_FUNCTION_EXCLUDED = /* @__PURE__ */ new Set([
+  "and",
+  "then",
+  "so",
+  "or",
+  "but",
+  "for",
+  "in",
+  "of",
+  "on",
+  "with",
+  "from",
+  "to",
+  "into",
+  "at",
+  "by",
+  "about",
+  "between",
+  "against",
+  "since",
+  "what",
+  "which",
+  "how",
+  "who",
+  "where",
+  "why",
+  "please",
+  "now",
+  "right",
+  "here",
+  "there",
+  "yesterday",
+  "today",
+  "tomorrow",
+  "week",
+  "month",
+  "year",
+  "last",
+  "past",
+  "recent",
+  "working",
+  "tree",
+  "copy",
+  "index",
+  "staging",
+  "cache",
+  "repo",
+  "repository",
+  "it",
+  "me",
+  "us",
+  "them",
+  "this",
+  "that",
+  "the",
+  "a",
+  "an",
+  "my",
+  "our",
+  "your",
+  "their"
+]), REQUIRED_VALUE_SHORT_OPTIONS = /* @__PURE__ */ new Set(["-S", "-G", "-O", "-l", "-I"]), REQUIRED_VALUE_LONG_OPTIONS = /* @__PURE__ */ new Set([
+  "--output",
+  "--src-prefix",
+  "--dst-prefix",
+  "--line-prefix",
+  "--diff-filter",
+  "--color-moved-ws",
+  "--word-diff-regex",
+  "--ignore-matching-lines",
+  "--anchored",
+  "--find-object",
+  "--diff-algorithm",
+  "--inter-hunk-context",
+  "--stat-width",
+  "--stat-name-width",
+  "--stat-count",
+  "--stat-graph-width",
+  "--ws-error-highlight",
+  "--rotate-to",
+  "--skip-to",
+  "--output-indicator-new",
+  "--output-indicator-old",
+  "--output-indicator-context"
+]);
+function tokenizeShellArgs(str, baseOffset = 0) {
+  let tokens = [], i = 0, n = str.length;
+  for (; i < n; ) {
+    for (; i < n && str[i] !== `
+` && /\s/.test(str[i]); )
+      i++;
+    if (i >= n) break;
+    let tokenStart = i;
+    if (str[i] === ";" || str[i] === "&" || str[i] === "|" || str[i] === `
+`) {
+      let ctrl = str[i++];
+      if (ctrl === `
+`)
+        for (; i < n && (str[i] === `
+` || str[i] === "\r"); )
+          i++;
+      else i < n && str[i] === ctrl && (ctrl === "&" || ctrl === "|" || ctrl === ";") && (ctrl += str[i++]);
+      tokens.push({
+        token: ctrl,
+        raw: ctrl,
+        isQuoted: !1,
+        isControl: !0,
+        start: tokenStart + baseOffset,
+        end: i + baseOffset
+      });
+      continue;
+    }
+    let token = "", hasQuote = !1;
+    for (; i < n && !/\s/.test(str[i]); ) {
+      let ch = str[i];
+      if (ch === ";" || ch === "&" || ch === "|" || ch === `
+`)
+        break;
+      if (ch === "\\")
+        i++, i < n && (str[i] === `
+` ? i++ : token += str[i++]);
+      else if (ch === "'") {
+        for (hasQuote = !0, i++; i < n && str[i] !== "'"; )
+          token += str[i++];
+        i < n && str[i] === "'" && i++;
+      } else if (ch === '"') {
+        for (hasQuote = !0, i++; i < n && str[i] !== '"'; )
+          if (str[i] === "\\" && i + 1 < n) {
+            let next = str[i + 1];
+            next === `
+` ? i += 2 : ((next === '"' || next === "\\" || next === "$" || next === "`") && i++, token += str[i++]);
+          } else
+            token += str[i++];
+        i < n && str[i] === '"' && i++;
+      } else if (ch === "`") {
+        for (hasQuote = !0, i++; i < n && str[i] !== "`"; )
+          str[i] === "\\" && i + 1 < n && i++, token += str[i++];
+        i < n && str[i] === "`" && i++;
+      } else
+        token += str[i++];
+    }
+    if (i === tokenStart) {
+      i++;
+      continue;
+    }
+    if (!hasQuote && token === "")
+      continue;
+    let raw = str.slice(tokenStart, i);
+    tokens.push({
+      token,
+      raw,
+      isQuoted: hasQuote,
+      start: tokenStart + baseOffset,
+      end: i + baseOffset
+    });
+  }
+  return tokens;
+}
+function parseGitDiffTokens(tokens) {
+  for (let i = 0; i < tokens.length; i++) {
+    let tok = tokens[i], { token } = tok;
+    if (tok.isControl || token === "--")
+      break;
+    if (token.startsWith("-") && token !== "-") {
+      if (token.includes("="))
+        continue;
+      if (REQUIRED_VALUE_SHORT_OPTIONS.has(token)) {
+        i + 1 < tokens.length && !tokens[i + 1].isControl && tokens[i + 1].token !== "--" && i++;
+        continue;
+      }
+      if (token.length > 2 && REQUIRED_VALUE_SHORT_OPTIONS.has(token.slice(0, 2)))
+        continue;
+      if (REQUIRED_VALUE_LONG_OPTIONS.has(token)) {
+        i + 1 < tokens.length && !tokens[i + 1].isControl && tokens[i + 1].token !== "--" && i++;
+        continue;
+      }
+      continue;
+    }
+    return tok;
+  }
+}
+function extractComparisonBaseRefInfo(prompt, options) {
+  let startIdx = 0;
+  for (; startIdx < prompt.length && /\s/.test(prompt[startIdx]); )
+    startIdx++;
+  let endIdx = prompt.length - 1;
+  for (; endIdx >= startIdx && /\s/.test(prompt[endIdx]); )
+    endIdx--;
+  let promptIndices = [], normalized = "";
+  for (let i = startIdx; i <= endIdx; i++) {
+    let ch = prompt[i];
+    ch !== "`" && ch !== "'" && ch !== '"' && (promptIndices.push(i), normalized += ch);
+  }
+  function makeRefInfo(ref, isExplicit, matchIndex, matchLength, isDirectPromptMatch) {
+    let res = { ref, isExplicit };
+    if (options?.includeSpan && matchIndex !== void 0 && matchLength !== void 0 && matchIndex >= 0) {
+      let start, end;
+      if (isDirectPromptMatch)
+        start = matchIndex, end = matchIndex + matchLength;
+      else {
+        start = promptIndices[matchIndex] ?? matchIndex;
+        let endNormIdx = matchIndex + matchLength - 1;
+        end = (promptIndices[endNormIdx] ?? endNormIdx) + 1;
+      }
+      start > 0 && /[`'"]/.test(prompt[start - 1]) && start--, end < prompt.length && /[`'"]/.test(prompt[end]) && end++, res.span = { start, end };
+    }
+    return res;
+  }
+  let quotedDiffOfRangeMatch = prompt.match(/\b(?:show|view|see)?\s*(?:the\s+)?(?:working\s+(?:tree|copy)\s+)?diff\s+of\s+(?:commit\s+)?([`'"])((?:[A-Za-z0-9_/@~^-]+(?:\.[A-Za-z0-9_/@~^-]+)*)?\.{2,3}(?:[A-Za-z0-9_/@~^-]+(?:\.[A-Za-z0-9_/@~^-]+)*)?)\1/i);
+  if (quotedDiffOfRangeMatch) {
+    let raw = stripSentencePunctuation(quotedDiffOfRangeMatch[2], { preserveRangeDots: !0 });
+    if ((raw.includes("..") || raw.includes("...")) && SAFE_REF_PATTERN.test(raw) && !raw.startsWith("-"))
+      return makeRefInfo(raw, !0, quotedDiffOfRangeMatch.index, quotedDiffOfRangeMatch[0].length, !0);
+  }
+  let diffOfRangeMatch = normalized.match(/\b(?:show|view|see)?\s*(?:the\s+)?(?:working\s+(?:tree|copy)\s+)?diff\s+of\s+(?:commit\s+)?((?:[A-Za-z0-9_/@~^-]+(?:\.[A-Za-z0-9_/@~^-]+)*)?\.{2,3}[A-Za-z0-9_/@~^-]+(?:\.[A-Za-z0-9_/@~^-]+)*)(?![0-9A-Za-z_/@~^-]|\.[0-9A-Za-z_/@~^-])/i);
+  if (diffOfRangeMatch) {
+    let raw = stripSentencePunctuation(diffOfRangeMatch[1], { preserveRangeDots: !0 });
+    if ((raw.includes("..") || raw.includes("...")) && SAFE_REF_PATTERN.test(raw) && !raw.startsWith("-"))
+      return makeRefInfo(raw, !0, diffOfRangeMatch.index, diffOfRangeMatch[0].length, !1);
+  }
+  let quotedBetweenMatch = prompt.match(/\b(?:difference|diff)\s+between\s+(?:my\s+|the\s+)?working\s+(?:tree|copy)\s+and\s+(?:(?:the\s+)?commit\s+)?([`'"])([^`'"]+)\1/i) || prompt.match(/\b(?:difference|diff)\s+between\s+(?:(?:the\s+)?commit\s+)?([`'"])([^`'"]+)\1\s+and\s+(?:my\s+|the\s+)?working\s+(?:tree|copy)/i);
+  if (quotedBetweenMatch) {
+    let raw = stripSentencePunctuation(quotedBetweenMatch[2].trim(), { preserveRangeDots: !0 }), lower = raw.toLowerCase();
+    if (!EXPLICIT_STRUCTURAL_EXCLUDED.has(lower) && SAFE_REF_PATTERN.test(raw) && !raw.startsWith("-") && raw !== "--")
+      return makeRefInfo(lower === "head" ? "HEAD" : raw, !0, quotedBetweenMatch.index, quotedBetweenMatch[0].length, !0);
+  }
+  let betweenMatch = normalized.match(/\b(?:difference|diff)\s+between\s+(?:my\s+|the\s+)?working\s+(?:tree|copy)\s+and\s+(?:\b(?:the\s+)?(?<mod>commit)\s+(?!(?:and|or|then|vs|but|so|also|with|to|for|from|please|pls|kindly|in)(?![a-zA-Z0-9_/@~^-]|\.+[a-zA-Z0-9_/@~^-])))?(?<ref>[a-zA-Z0-9_./@~^-]+)(?![0-9A-Za-z_/@~^-]|\.+[0-9A-Za-z_/@~^-])/i) || normalized.match(/\b(?:difference|diff)\s+between\s+(?:\b(?:the\s+)?(?<mod>commit)\s+(?!(?:and|or|then|vs|but|so|also|with|to|for|from)(?![a-zA-Z0-9_/@~^-]|\.+[a-zA-Z0-9_/@~^-])))?(?<ref>[a-zA-Z0-9_./@~^-]+)\s+and\s+(?:my\s+|the\s+)?working\s+(?:tree|copy)\b/i);
+  if (betweenMatch) {
+    let raw = stripSentencePunctuation(betweenMatch.groups?.ref || betweenMatch[1]), lower = raw.toLowerCase();
+    if (!EXPLICIT_STRUCTURAL_EXCLUDED.has(lower) && SAFE_REF_PATTERN.test(raw) && !raw.startsWith("-")) {
+      let isExplicit = !!betweenMatch.groups?.mod ? hasRefSyntax(raw) : !0;
+      return makeRefInfo(lower === "head" ? "HEAD" : raw, isExplicit, betweenMatch.index, betweenMatch[0].length, !1);
+    }
+  }
+  let quotedDiffAgainstMatch = prompt.match(/\b(?:show|view|see)?\s*(?:the\s+)?(?:working\s+(?:tree|copy)\s+)?diff\s+against\s+(?:(?:the\s+)?commit\s+)?([`'"])([^`'"]+)\1/i);
+  if (quotedDiffAgainstMatch) {
+    let raw = stripSentencePunctuation(quotedDiffAgainstMatch[2], { preserveRangeDots: !0 }), lower = raw.toLowerCase();
+    if (!EXPLICIT_STRUCTURAL_EXCLUDED.has(lower) && SAFE_REF_PATTERN.test(raw) && !raw.startsWith("-"))
+      return makeRefInfo(lower === "head" ? "HEAD" : raw, !0, quotedDiffAgainstMatch.index, quotedDiffAgainstMatch[0].length, !0);
+  }
+  let diffAgainstMatch = normalized.match(/\bdiff\s+against\s+(?:\b(?:the\s+)?(?<mod>commit)\s+(?!(?:and|or|then|vs|but|so|also|with|to|for|from|please|pls|kindly|in)(?![a-zA-Z0-9_/@~^-]|\.+[a-zA-Z0-9_/@~^-])))?(?<ref>[a-zA-Z0-9_./@~^-]+)(?![0-9A-Za-z_/@~^-]|\.+[0-9A-Za-z_/@~^-])/i);
+  if (diffAgainstMatch) {
+    let raw = stripSentencePunctuation(diffAgainstMatch.groups?.ref || diffAgainstMatch[1]), lower = raw.toLowerCase();
+    if (!EXPLICIT_STRUCTURAL_EXCLUDED.has(lower) && SAFE_REF_PATTERN.test(raw) && !raw.startsWith("-")) {
+      let isExplicit = !!diffAgainstMatch.groups?.mod ? hasRefSyntax(raw) : !0;
+      return makeRefInfo(lower === "head" ? "HEAD" : raw, isExplicit, diffAgainstMatch.index, diffAgainstMatch[0].length, !1);
+    }
+  }
+  if (/\b(?:git|repo|repository|working\s+(?:tree|copy)|uncommitted|diff|changes?)\b/i.test(normalized)) {
+    let quotedCompareAgainstMatch = prompt.match(/\bcompare\s+(?:my\s+)?working\s+(?:tree|copy)\s+(?:to|with|against)\s+(?:(?:the\s+)?commit\s+)?([`'"])([^`'"]+)\1/i) || prompt.match(/\bcompare\s+against\s+(?:(?:the\s+)?commit\s+)?([`'"])([^`'"]+)\1/i) || prompt.match(/\bcompare\s+(?:(?:the\s+)?commit\s+)?([`'"])([^`'"]+)\1\s+(?:to|with|against)\s+(?:my\s+)?working\s+(?:tree|copy)\b/i);
+    if (quotedCompareAgainstMatch) {
+      let raw = stripSentencePunctuation(quotedCompareAgainstMatch[2].trim(), { preserveRangeDots: !0 }), lower = raw.toLowerCase();
+      if (!EXPLICIT_STRUCTURAL_EXCLUDED.has(lower) && SAFE_REF_PATTERN.test(raw) && !raw.startsWith("-") && raw !== "--")
+        return makeRefInfo(lower === "head" ? "HEAD" : raw, !0, quotedCompareAgainstMatch.index, quotedCompareAgainstMatch[0].length, !0);
+    }
+    let compareAgainstMatch = normalized.match(/\bcompare\s+(?:my\s+)?working\s+(?:tree|copy)\s+(?:to|with|against)\s+(?:\b(?:the\s+)?(?<mod>commit)\s+(?!(?:and|or|then|vs|but|so|also|with|to|for|from|please|pls|kindly|in)(?![a-zA-Z0-9_/@~^-]|\.+[a-zA-Z0-9_/@~^-])))?(?<ref>[a-zA-Z0-9_./@~^-]+)(?![0-9A-Za-z_/@~^-]|\.+[0-9A-Za-z_/@~^-])/i) || normalized.match(/\bcompare\s+against\s+(?:\b(?:the\s+)?(?<mod>commit)\s+(?!(?:and|or|then|vs|but|so|also|with|to|for|from|please|pls|kindly|in)(?![a-zA-Z0-9_/@~^-]|\.+[a-zA-Z0-9_/@~^-])))?(?<ref>[a-zA-Z0-9_./@~^-]+)(?![0-9A-Za-z_/@~^-]|\.+[0-9A-Za-z_/@~^-])/i) || normalized.match(/\bcompare\s+(?:\b(?:the\s+)?(?<mod>commit)\s+(?!(?:and|or|then|vs|but|so|also|with|to|for|from)(?![a-zA-Z0-9_/@~^-]|\.+[a-zA-Z0-9_/@~^-])))?(?<ref>[a-zA-Z0-9_./@~^-]+)\s+(?:to|with|against)\s+(?:my\s+)?working\s+(?:tree|copy)\b/i);
+    if (compareAgainstMatch) {
+      let raw = stripSentencePunctuation(compareAgainstMatch.groups?.ref || compareAgainstMatch[1]), lower = raw.toLowerCase();
+      if (!EXPLICIT_STRUCTURAL_EXCLUDED.has(lower) && SAFE_REF_PATTERN.test(raw) && !raw.startsWith("-")) {
+        let isExplicit = !!compareAgainstMatch.groups?.mod ? hasRefSyntax(raw) : !0;
+        return makeRefInfo(lower === "head" ? "HEAD" : raw, isExplicit, compareAgainstMatch.index, compareAgainstMatch[0].length, !1);
+      }
+    }
+  }
+  let showDiffAgainstMatch = normalized.match(/\b(?:show|view|see)\s+(?:the\s+)?(?:working\s+(?:tree|copy)\s+)?diff\s+against\s+(?:\b(?:the\s+)?(?<mod>commit)\s+(?!(?:and|or|then|vs|but|so|also|with|to|for|from|please|pls|kindly|in)(?![a-zA-Z0-9_/@~^-]|\.+[a-zA-Z0-9_/@~^-])))?(?<ref>[a-zA-Z0-9_./@~^-]+)(?![0-9A-Za-z_/@~^-]|\.+[0-9A-Za-z_/@~^-])/i);
+  if (showDiffAgainstMatch) {
+    let raw = stripSentencePunctuation(showDiffAgainstMatch.groups?.ref || showDiffAgainstMatch[1]), lower = raw.toLowerCase();
+    if (!EXPLICIT_STRUCTURAL_EXCLUDED.has(lower) && SAFE_REF_PATTERN.test(raw) && !raw.startsWith("-")) {
+      let isExplicit = !!showDiffAgainstMatch.groups?.mod ? hasRefSyntax(raw) : !0;
+      return makeRefInfo(lower === "head" ? "HEAD" : raw, isExplicit, showDiffAgainstMatch.index, showDiffAgainstMatch[0].length, !1);
+    }
+  }
+  let quotedDiffToMatch = prompt.match(/\b(?:show|view|see)?\s*(?:the\s+)?(?:working\s+(?:tree|copy)\s+)?diff\s+to\s+(?:(?:the\s+)?commit\s+)?([`'"])([^`'"]+)\1/i);
+  if (quotedDiffToMatch) {
+    let raw = stripSentencePunctuation(quotedDiffToMatch[2], { preserveRangeDots: !0 }), lower = raw.toLowerCase();
+    if (!EXPLICIT_STRUCTURAL_EXCLUDED.has(lower) && SAFE_REF_PATTERN.test(raw) && !raw.startsWith("-"))
+      return makeRefInfo(lower === "head" ? "HEAD" : raw, !0, quotedDiffToMatch.index, quotedDiffToMatch[0].length, !0);
+  }
+  let diffToMatch = normalized.match(/\bdiff\s+to\s+(?:\b(?:the\s+)?(?<mod>commit)\s+(?!(?:and|or|then|vs|but|so|also|with|to|for|from|please|pls|kindly|in)(?![a-zA-Z0-9_/@~^-]|\.+[a-zA-Z0-9_/@~^-])))?(?<ref>[a-zA-Z0-9_./@~^-]+)(?![0-9A-Za-z_/@~^-]|\.+[0-9A-Za-z_/@~^-])/i) || normalized.match(/\b(?:show|view|see)\s+(?:the\s+)?(?:working\s+(?:tree|copy)\s+)?diff\s+to\s+(?:\b(?:the\s+)?(?<mod>commit)\s+(?!(?:and|or|then|vs|but|so|also|with|to|for|from|please|pls|kindly|in)(?![a-zA-Z0-9_/@~^-]|\.+[a-zA-Z0-9_/@~^-])))?(?<ref>[a-zA-Z0-9_./@~^-]+)(?![0-9A-Za-z_/@~^-]|\.+[0-9A-Za-z_/@~^-])/i);
+  if (diffToMatch) {
+    let raw = stripSentencePunctuation(diffToMatch.groups?.ref || diffToMatch[1]), lower = raw.toLowerCase();
+    if (!PURPOSE_VERBS.has(lower) && !EXPLICIT_STRUCTURAL_EXCLUDED.has(lower) && !TEMPORAL_WORDS.has(lower) && SAFE_REF_PATTERN.test(raw) && !raw.startsWith("-")) {
+      let isExplicit = !!diffToMatch.groups?.mod ? hasRefSyntax(raw) : hasRefSyntax(raw) || isLastTokenInPrompt(normalized, raw);
+      return makeRefInfo(lower === "head" ? "HEAD" : raw, isExplicit, diffToMatch.index, diffToMatch[0].length, !1);
+    }
+  }
+  let quotedDiffWithMatch = prompt.match(/\b(?:show|view|see)?\s*(?:the\s+)?(?:working\s+(?:tree|copy)\s+)?diff\s+with\s+(?:(?:the\s+)?commit\s+)?([`'"])([^`'"]+)\1/i);
+  if (quotedDiffWithMatch) {
+    let raw = stripSentencePunctuation(quotedDiffWithMatch[2], { preserveRangeDots: !0 }), lower = raw.toLowerCase();
+    if (!EXPLICIT_STRUCTURAL_EXCLUDED.has(lower) && SAFE_REF_PATTERN.test(raw) && !raw.startsWith("-"))
+      return makeRefInfo(lower === "head" ? "HEAD" : raw, !0, quotedDiffWithMatch.index, quotedDiffWithMatch[0].length, !0);
+  }
+  let diffWithMatch = normalized.match(/\bdiff\s+with\s+(?:\b(?:the\s+)?(?<mod>commit)\s+(?!(?:and|or|then|vs|but|so|also|with|to|for|from|please|pls|kindly|in)(?![a-zA-Z0-9_/@~^-]|\.+[a-zA-Z0-9_/@~^-])))?(?!line\s+numbers?\b|numbers?\b|(?:more|full|extra)\s+(?:detail|details|context|info|information)\b)(?<ref>[a-zA-Z0-9_./@~^-]+)(?![0-9A-Za-z_/@~^-]|\.+[0-9A-Za-z_/@~^-])/i) || normalized.match(/\b(?:show|view|see)\s+(?:the\s+)?(?:working\s+(?:tree|copy)\s+)?diff\s+with\s+(?:\b(?:the\s+)?(?<mod>commit)\s+(?!(?:and|or|then|vs|but|so|also|with|to|for|from|please|pls|kindly|in)(?![a-zA-Z0-9_/@~^-]|\.+[a-zA-Z0-9_/@~^-])))?(?!line\s+numbers?\b|numbers?\b|(?:more|full|extra)\s+(?:detail|details|context|info|information)\b)(?<ref>[a-zA-Z0-9_./@~^-]+)(?![0-9A-Za-z_/@~^-]|\.+[0-9A-Za-z_/@~^-])/i);
+  if (diffWithMatch) {
+    let raw = stripSentencePunctuation(diffWithMatch.groups?.ref || diffWithMatch[1]), lower = raw.toLowerCase();
+    if (!PRESENTATION_WORDS.has(lower) && !EXPLICIT_STRUCTURAL_EXCLUDED.has(lower) && !TEMPORAL_WORDS.has(lower) && SAFE_REF_PATTERN.test(raw) && !raw.startsWith("-")) {
+      let isExplicit = !!diffWithMatch.groups?.mod ? hasRefSyntax(raw) : hasRefSyntax(raw) || isLastTokenInPrompt(normalized, raw);
+      return makeRefInfo(lower === "head" ? "HEAD" : raw, isExplicit, diffWithMatch.index, diffWithMatch[0].length, !1);
+    }
+  }
+  let quotedSinceMatch = prompt.match(/\b(?:diff|changes)\s+since\s+(?:(?:the\s+)?commit\s+)?([`'"])([^`'"]+)\1/i), diffSinceMatch = quotedSinceMatch || normalized.match(/\b(?:show|view|see|give|get|display|print)?\s*(?:me\s+)?(?:the\s+|my\s+)?(diff|changes)\s+since\s+(?:\b(?:the\s+)?(?<mod>commit)\s+(?!(?:and|or|then|vs|but|so|also|with|to|for|from|please|pls|kindly|in)(?![a-zA-Z0-9_/@~^-]|\.+[a-zA-Z0-9_/@~^-]|\.\.)))?(?<ref>[a-zA-Z0-9_./@~^-]+)(?![0-9A-Za-z_/@~^-]|\.+[0-9A-Za-z_/@~^-]|\.\.)/i);
+  if (diffSinceMatch && !/\bbreaking\s+changes\b/i.test(normalized)) {
+    let isQuoted = !!quotedSinceMatch, raw = isQuoted ? stripSentencePunctuation(quotedSinceMatch[2].trim(), { preserveRangeDots: !0 }) : stripSentencePunctuation(diffSinceMatch.groups?.ref || diffSinceMatch[2]), lower = raw.toLowerCase(), hasGitContext = /\b(?:repo|repository|branch|commit|head|working\s+(?:tree|copy)|git|diff)\b/i.test(normalized), namedLibraryMatch = NON_GIT_SOFTWARE_LIBRARIES.has(lower), escapedRaw = raw.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), versionAfterRawMatch = new RegExp(`\\bsince\\s+${escapedRaw}\\s+(?:v?\\d+(?:\\.\\d+)*)\\b(?!\\s+(?:days?|weeks?|months?|years?|hours?|minutes?))`, "i").test(normalized), dottedVersionMatch = /\bsince\s+v?\d+\.\d+(?:\.\d+)*\b/i.test(normalized), isLibraryInquiry = !isQuoted && !hasRefSyntax(raw) && !hasGitContext && (namedLibraryMatch || versionAfterRawMatch || dottedVersionMatch), isCalendarDate = /^\d{4}[-/]\d{1,2}[-/]\d{1,2}$/.test(raw), isFourDigitYear = /^(?:19|20)\d{2}$/.test(raw), isTemporal = !isQuoted && (isCalendarDate || isFourDigitYear || !hasRefSyntax(raw) && (TEMPORAL_WORDS.has(lower) || /\bsince\s+\d+\s+(?:days?|weeks?|months?|years?|hours?|minutes?)\s+ago\b/i.test(normalized) || /\bsince\s+(?:last|this)\s+(?:week|month|year|monday|tuesday|wednesday|thursday|friday|saturday|sunday)\b/i.test(normalized))), isExcluded = !isQuoted && (COMMAND_FUNCTION_EXCLUDED.has(lower) || TEMPORAL_WORDS.has(lower) || PRESENTATION_WORDS.has(lower));
+    if (!isLibraryInquiry && (!isTemporal || isQuoted) && !isExcluded && SAFE_REF_PATTERN.test(raw) && !raw.startsWith("-")) {
+      let isHexHash = /^[0-9a-fA-F]{4,40}$/.test(raw), isAllDigits = /^\d+$/.test(raw), hasMod = !isQuoted && !!diffSinceMatch.groups?.mod, isExplicit = isQuoted ? !0 : hasMod ? hasRefSyntax(raw) : hasRefSyntax(raw) && !isAllDigits || !isHexHash && !isAllDigits && isLastTokenInPrompt(normalized, raw);
+      return makeRefInfo(lower === "head" ? "HEAD" : raw, isExplicit, diffSinceMatch.index, diffSinceMatch[0].length, isQuoted);
+    }
+  }
+  let quotedWholeGitDiffMatch = prompt.match(/([`'"])\s*git\s+diff\b([\s\S]*?)\1/i);
+  if (quotedWholeGitDiffMatch) {
+    let isLiteralStart = /^\s*[`'"]/.test(prompt), innerStr = quotedWholeGitDiffMatch[0].slice(1, -1), innerTokens = tokenizeShellArgs(innerStr);
+    if (innerTokens.length >= 2 && innerTokens[0].token.toLowerCase() === "git" && innerTokens[1].token.toLowerCase() === "diff") {
+      let operand = parseGitDiffTokens(innerTokens.slice(2));
+      if (operand && !/[\s\x00-\x1f\x7f]/.test(operand.token)) {
+        let raw = stripSentencePunctuation(operand.token, { preserveRangeDots: !0 }), lower = raw.toLowerCase();
+        if (!COMMAND_FUNCTION_EXCLUDED.has(lower) && SAFE_REF_PATTERN.test(raw) && !raw.startsWith("-") && raw !== "--") {
+          let isExplicit = isLiteralStart || operand.isQuoted ? !0 : hasRefSyntax(raw);
+          return makeRefInfo(lower === "head" ? "HEAD" : raw, isExplicit, quotedWholeGitDiffMatch.index, quotedWholeGitDiffMatch[0].length, !0);
+        }
+      }
+    }
+  }
+  let literalGitDiffMatch = prompt.match(/^\s*git\s+diff\b([\s\S]*)/i);
+  if (literalGitDiffMatch) {
+    let cmdTokens = tokenizeShellArgs(literalGitDiffMatch[0]);
+    if (cmdTokens.length >= 2 && cmdTokens[0].token.toLowerCase() === "git" && cmdTokens[1].token.toLowerCase() === "diff") {
+      let operand = parseGitDiffTokens(cmdTokens.slice(2));
+      if (operand && !/[\s\x00-\x1f\x7f]/.test(operand.token)) {
+        let raw = stripSentencePunctuation(operand.token, { preserveRangeDots: !0 }), lower = raw.toLowerCase();
+        if (!COMMAND_FUNCTION_EXCLUDED.has(lower) && SAFE_REF_PATTERN.test(raw) && !raw.startsWith("-") && raw !== "--")
+          return makeRefInfo(lower === "head" ? "HEAD" : raw, !0, literalGitDiffMatch.index, operand.end, !0);
+      }
+    }
+  }
+  let openExcluded = /* @__PURE__ */ new Set([
+    ...EXPLICIT_STRUCTURAL_EXCLUDED,
+    ...PURPOSE_VERBS,
+    ...PRESENTATION_WORDS,
+    ...COMMAND_FUNCTION_EXCLUDED,
+    "vs",
+    "changes",
+    "files",
+    "file",
+    "code",
+    "workspace",
+    "directory",
+    "folder",
+    "project",
+    "stat",
+    "stats",
+    "cached",
+    "staged",
+    "summary",
+    "details",
+    "detail",
+    "show",
+    "shows",
+    "display",
+    "displays",
+    "view",
+    "see",
+    "check",
+    "inspect",
+    "all",
+    "only",
+    "just"
+  ]), conversationalGitDiffMatch = prompt.match(/\bgit\s+diff\b([\s\S]*)/i);
+  if (conversationalGitDiffMatch) {
+    let cmdTokens = tokenizeShellArgs(conversationalGitDiffMatch[0]);
+    if (cmdTokens.length >= 2 && cmdTokens[0].token.toLowerCase() === "git" && cmdTokens[1].token.toLowerCase() === "diff") {
+      let operand = parseGitDiffTokens(cmdTokens.slice(2));
+      if (operand && !/[\s\x00-\x1f\x7f]/.test(operand.token)) {
+        let raw = stripSentencePunctuation(operand.token, { preserveRangeDots: !0 }), lower = raw.toLowerCase();
+        if (operand.isQuoted) {
+          if (SAFE_REF_PATTERN.test(raw) && !raw.startsWith("-") && raw !== "--")
+            return makeRefInfo(lower === "head" ? "HEAD" : raw, !0, conversationalGitDiffMatch.index, operand.end, !0);
+        } else if (!openExcluded.has(lower) && SAFE_REF_PATTERN.test(raw) && !raw.startsWith("-") && raw !== "--")
+          return makeRefInfo(lower === "head" ? "HEAD" : raw, !1, conversationalGitDiffMatch.index, operand.end, !0);
+      }
+    }
+  }
+  let openEndedConversationalMatch = normalized.match(/\b(?:git|repo|working\s+(?:tree|copy)|uncommitted)\s+(?:changes?|diff)\s+(?:since|against)\s+([a-zA-Z0-9_./@~^-]+)(?![0-9A-Za-z_/@~^-]|\.+[0-9A-Za-z_/@~^-]|\.\.)/i) || normalized.match(/\b(?:changes?|diff)\s+in\s+(?:the\s+|my\s+)?(?:working\s+(?:tree|copy)|repo|repository)\s+(?:since|against)\s+([a-zA-Z0-9_./@~^-]+)(?![0-9A-Za-z_/@~^-]|\.+[0-9A-Za-z_/@~^-]|\.\.)/i);
+  if (openEndedConversationalMatch) {
+    let raw = stripSentencePunctuation(openEndedConversationalMatch[1]), lower = raw.toLowerCase();
+    if (!openExcluded.has(lower) && !TEMPORAL_WORDS.has(lower) && SAFE_REF_PATTERN.test(raw) && !raw.startsWith("-") && raw !== "--")
+      return makeRefInfo(lower === "head" ? "HEAD" : raw, !1, openEndedConversationalMatch.index, openEndedConversationalMatch[0].length, !1);
+  }
+}
+function extractComparisonBaseRef(prompt) {
+  return extractComparisonBaseRefInfo(prompt)?.ref;
+}
+function isConceptualGitQuestion(prompt) {
+  let normalized = prompt.replace(/[\u2018\u2019]/g, "'").replace(/[`'"]/g, "").trim();
+  if (/\b[0-9a-f]{6,40}\b/i.test(normalized) || /^(?:git\s+(?:status|diff|show|log|branch)|(?:check|inspect|examine|look\s+at)\s+(?:my|our|the)\s+(?:repo|repository|working\s+(?:tree|copy)|index|staging|workspace)|(?:show|view|see|display|print)\s+(?:(?:me\s+)?(?:my|our)\s+)?(?:staged\s+(?:changes|diff)|working\s+(?:tree|copy)|untracked))\b/i.test(normalized) || /\b(?:what\s+does|how\s+does)\s+git\s+(?:status|diff)\s+(?:look\s+like|show)\s+(?:right\s+now|currently|in\s+(?:my|our|the)\s+working\s+(?:tree|copy)|in\s+(?:my|our|the)\s+(?:repo|repository)|in\s+my\s+workspace)\b/i.test(normalized))
+    return !1;
+  if (/^(?:(?:can|could|would)\s+you\s+(?:please\s+)?(?:tell|show|explain)\s+(?:to\s+)?me\s+)?(?:please\s+)?(?:how\s+(?:do\s+i|can\s+i|to|should\s+i)|(?:explain|describe|tell\s+me)\s+how\s+to)\s+(?:commit|stage|unstage|discard|add|push|pull|revert|reset|restore|checkout|switch|merge|rebase|stash|tag|diff|use)\b/i.test(normalized) || (/^(?:(?:can|could|would)\s+you\s+(?:please\s+)?(?:tell|show|explain)\s+(?:to\s+)?me\s+)?(?:please\s+)?what\s+does\s+git\s+(?:status|diff|checkout|switch|merge|rebase|commit|branch|log|show|reset|restore|stash)\s+(?:do|mean)\b/i.test(normalized) || /^(?:(?:can|could|would)\s+you\s+)?(?:please\s+)?(?:(?:explain|describe|tell\s+me)\s+)?how\s+(?:does\s+)?git\s+(?:status|diff|checkout|switch|merge|rebase|log|commit|branch)\s+(?:works?|compares?|shows?|handles?|displays?)\b/i.test(normalized) || /^(?:(?:can|could|would)\s+you\s+)?(?:please\s+)?(?:explain|describe)\s+how\s+(?:the\s+|git\s+)?working\s+(?:tree|copy)\s+works?\b/i.test(normalized) || /^(?:(?:can|could|would)\s+you\s+)?(?:please\s+)?(?:explain|describe)\s+(?:the\s+)?concept\s+of\s+(?:the\s+)?(?:git\s+)?(?:working\s+(?:tree|copy)|status|diff|index|staging)\b/i.test(normalized)) && !/\b(?:right\s+now|currently|in\s+my\s+working\s+(?:tree|copy))\b/i.test(normalized))
+    return !0;
+  if (/\b(?:my|our)\s+(?:working\s+(?:tree|copy)|index|staging(?:\s+area)?|staged\s+(?:diff|changes)|repo|repository)\b/i.test(normalized) || /\b(?:staged\s+diff|staged\s+changes|changes\s+in\s+(?:the\s+)?(?:index|staging(?:\s+area)?)|what(?:s|\s+is)\s+in\s+(?:my\s+|the\s+)?staging(?:\s+area)?)\b/i.test(normalized) || /\b(?:my\s+working\s+(?:tree|copy)\s+and\s+(?:head|[a-z0-9_./@~^-]+)|(?:head|[a-z0-9_./@~^-]+)\s+and\s+my\s+working\s+(?:tree|copy))\b/i.test(normalized) || /\b(?:how\s+(?:is|does)\s+my\s+working\s+(?:tree|copy)|what\s+does\s+my\s+working\s+(?:tree|copy)\s+look\s+like|is\s+my\s+working\s+(?:tree|copy)\s+clean)\b/i.test(normalized) || /\b(?:working\s+(?:tree|copy)|repo|repository|git\s+status|status)\s+(?:look\s+like\s+)?after\s+(?:the\s+)?(?:rebase|merge|reset|pull|commit|checkout)\b/i.test(normalized) || /\b(?:changes?\s+in\s+(?:the\s+)?working\s+(?:tree|copy)\s+(?:since|against)\s+HEAD|working\s+(?:tree|copy)\s+diff\s+(?:against|since)\s+HEAD)\b/i.test(normalized) || /\blook\s+like\s+right\s+now\b/i.test(normalized) || /\b(?:right\s+now|currently)\b/i.test(normalized))
+    return !1;
+  let compTargets = "(?:the\\s+)?(?:working\\s+(?:tree|copy)|index|staging(?:\\s+area)?|cache|head)";
+  return !!(new RegExp(
+    `^(?:(?:can|could|would)\\s+you\\s+)?(?:please\\s+)?(?:explain|describe|what(?:s|\\s+is))\\s+(?:(?:the\\s+)?(?:difference|distinction)\\s+between\\s+${compTargets}\\s+and\\s+${compTargets}|how\\s+${compTargets}\\s+(?:differs?|is\\s+different)\\s+from\\s+${compTargets}|${compTargets}\\s+(?:versus|vs\\.?)\\s+${compTargets}|(?:how\\s+to\\s+compare|comparing)\\s+${compTargets}\\s+(?:and|with|to|versus|vs\\.?)\\s+${compTargets})\\b`,
+    "i"
+  ).test(normalized) || /^(?:explain|describe|what\s+is\s+(?:the\s+)?difference\s+between|what\s+is)\s+(?:git\s+)?(?:status|diff|log|branch|show|rebase|merge|commit|stash|checkout|switch|reset|restore)\s*[\?.,]?$/i.test(normalized) || /^(?:explain|describe)\s+(?:the\s+)?(?:git\s+)?(?:status|diff|log|branch|show|rebase|merge|commit|stash|checkout|switch|reset|restore)\s+(?:command|concept|operation|workflow)\b/i.test(normalized) || /\b(?:how\s+does\s+git|what\s+does\s+git|what\s+is\s+git|difference\s+between\s+git|explain\s+(?:what\s+|the\s+|how\s+)?git|why\s+does\s+git|how\s+(?:to|do\s+i|can\s+i)\s+use\s+git|tutorial\s+on\s+git|syntax\s+(?:for|of)\s+git)\b/i.test(normalized) || /\b(?:difference\s+between\s+(?:git\s+)?[a-z-]+\s+and\s+(?:git\s+)?[a-z-]+|how\s+does\s+(?:git\s+)?[a-z-]+\s+work)\b/i.test(normalized) || /\b(?:should\s+(?:i|we)\s+use\s+(?:git\s+)?[a-z-]+\s+or\s+(?:git\s+)?[a-z-]+)\b/i.test(normalized) || /\b(?:how\s+(?:do\s+i|to|can\s+i)\s+(?:undo|revert|reset|restore|abort|resolve|cancel)\s+(?:a\s+)?(?:git\s+)?[a-z-]+)\b/i.test(normalized) || /^(?:how|why|should|when|what\s+does)\b.*\b(?:git\s+)?(?:checkout|switch|rebase|merge|commit|stash|reset|restore|cherry-pick)\b/i.test(normalized));
+}
+function isStagedDiffIntent(prompt) {
+  if (/^\s*(?:\/|!)?git\s+diff\b/i.test(prompt)) {
+    let [optionsPart2] = prompt.split(/\s+--\s+/);
+    return /(?:^|\s)(?:--cached|--staged)(?:\s|$)/i.test(optionsPart2);
+  }
+  let [optionsPart] = prompt.split(/\s+--\s+/);
+  return !!(/(?:^|\s)(?:--cached|--staged)(?:\s|$)/i.test(optionsPart) || /\b(?:staged\s+diff|cached\s+diff|staged\s+changes|cached\s+changes|changes\s+in\s+the\s+index|in\s+the\s+index|to\s+be\s+committed)\b/i.test(optionsPart) || /\b(?:diff|show|what\s+is)\s+(?:of\s+)?(?:the\s+)?(?:staged|cached)\b/i.test(optionsPart) && !/\b(?:staged|cached)\.[a-z0-9]+\b/i.test(optionsPart));
+}
+function isQualifiedAdvisoryRunner(runner) {
+  if (!runner) return !1;
+  if (runner?.opts?.localRunner)
+    return isQualifiedAdvisoryRunner(runner.opts.localRunner);
+  if (runner?.localRunner)
+    return isQualifiedAdvisoryRunner(runner.localRunner);
+  if (runner?.opts?.hostedRunner)
+    return isQualifiedAdvisoryRunner(runner.opts.hostedRunner);
+  if (runner?.hostedRunner)
+    return isQualifiedAdvisoryRunner(runner.hostedRunner);
+  let label = runner.runtimeLabel?.toLowerCase() || "";
+  return label.includes("claude") || label.includes("anthropic") || label.includes("composite") || runner.providerKind === "composite" || label.startsWith("local-gemma-process:") ? !1 : typeof runner.generateAdvisory == "function";
+}
+function resolvePreferredAdvisoryRunner(runner) {
+  if (!runner) return null;
+  let isComposite = !!runner?.opts, isFreeTier = runner?.opts?.tier === "FREE";
+  if (isComposite) {
+    let localCandidate = runner?.opts?.localRunner ?? runner?.localRunner ?? null, isLocalHealthy = runner?.localHealthy ?? !0, hostedCandidate = runner?.opts?.hostedRunner ?? runner?.hostedRunner ?? null;
+    return localCandidate && isLocalHealthy && localCandidate.runtimeLabel?.startsWith("local-gemma-process:") ? null : isFreeTier ? localCandidate && isLocalHealthy && isQualifiedAdvisoryRunner(localCandidate) ? localCandidate : null : localCandidate && isLocalHealthy && isQualifiedAdvisoryRunner(localCandidate) ? runner : hostedCandidate && isQualifiedAdvisoryRunner(hostedCandidate) ? hostedCandidate : null;
+  }
+  return (runner.providerKind === "local" || !runner.providerKind && (runner.runtimeLabel?.startsWith("local-gemma-ollama:") || runner.runtimeLabel?.startsWith("local-gemma-process:"))) && isQualifiedAdvisoryRunner(runner) || runner.providerKind === "hosted" && isQualifiedAdvisoryRunner(runner) ? runner : null;
+}
+function renderLocalGemmaGitStatusQueryPrompt(args) {
+  let sanitized = sanitizeForTerminal(redactAbsoluteLocalPaths(args.userPrompt)).trim();
+  return [
+    "You are a semantic Git query analyzer for CodeVibe.",
+    "Classify the user prompt to determine if they are asking about Git repository status, diffs, commits, history, branches, or working tree state.",
+    "Respond with STRICT JSON ONLY. Do not emit markdown formatting or conversational text outside the JSON object.",
+    "",
+    "JSON Schema:",
+    "{",
+    '  "isGitQuery": boolean,    // true if prompt is asking to inspect git status, diffs, log, commit history, branch, or working tree state. false if asking about task progress ("what is the status of the task"), conceptual questions or explanations ("how does git status work", "difference between checkout and switch"), building, coding, or unrelated topics.',
+    '  "asksStatus": boolean,    // true if asking about working tree state, untracked/modified/staged files, or git status',
+    '  "asksDiff": boolean,      // true if asking for working tree diffs or uncommitted changes (NOT a commit diff)',
+    '  "asksLog": boolean,       // true if asking for commit history, recent commits, or git log',
+    '  "asksBranch": boolean,    // true if asking to list branches or current branch',
+    '  "showTarget": string | null, // commit hash, ref, or "HEAD" if asking for diff/details of a specific commit (e.g. "diff of most recent commit" -> "HEAD")',
+    '  "targetRepo": string | null  // repository name if an explicit sub-repository or sibling repo was mentioned, otherwise null',
+    "}",
+    "",
+    "Examples:",
+    'User: "Show me the diff of the most recent commit on this branch"',
+    '{"isGitQuery":true,"asksStatus":false,"asksDiff":false,"asksLog":false,"asksBranch":false,"showTarget":"HEAD","targetRepo":null}',
+    "",
+    'User: "Are there any untracked or modified files in the working tree right now?"',
+    '{"isGitQuery":true,"asksStatus":true,"asksDiff":false,"asksLog":false,"asksBranch":false,"showTarget":null,"targetRepo":null}',
+    "",
+    `User: "What's changed since my last commit?"`,
+    '{"isGitQuery":true,"asksStatus":true,"asksDiff":true,"asksLog":false,"asksBranch":false,"showTarget":null,"targetRepo":null}',
+    "",
+    'User: "What is the status of the running task?"',
+    '{"isGitQuery":false,"asksStatus":false,"asksDiff":false,"asksLog":false,"asksBranch":false,"showTarget":null,"targetRepo":null}',
+    "",
+    'User: "What\'s the difference between `git checkout` and `git switch`?"',
+    '{"isGitQuery":false,"asksStatus":false,"asksDiff":false,"asksLog":false,"asksBranch":false,"showTarget":null,"targetRepo":null}',
+    "",
+    'User: "How does git status work?"',
+    '{"isGitQuery":false,"asksStatus":false,"asksDiff":false,"asksLog":false,"asksBranch":false,"showTarget":null,"targetRepo":null}',
+    "",
+    'User: "What changed in React 19?"',
+    '{"isGitQuery":false,"asksStatus":false,"asksDiff":false,"asksLog":false,"asksBranch":false,"showTarget":null,"targetRepo":null}',
+    "",
+    'User: "How do I get the current working directory in Python?"',
+    '{"isGitQuery":false,"asksStatus":false,"asksDiff":false,"asksLog":false,"asksBranch":false,"showTarget":null,"targetRepo":null}',
+    "",
+    `User prompt: ${JSON.stringify(sanitized)}`
+  ].join(`
+`);
+}
+function parseGemmaGitStatusResponse(raw) {
+  if (!raw || typeof raw != "string") return null;
+  let cleaned = raw.trim();
+  cleaned.startsWith("```") && (cleaned = cleaned.replace(/^```(?:json)?\s*\n?/i, "").replace(/\n?```\s*$/i, "").trim());
+  let parsed;
+  try {
+    parsed = JSON.parse(cleaned);
+  } catch {
+    return null;
+  }
+  if (typeof parsed != "object" || parsed === null || Array.isArray(parsed) || typeof parsed.isGitQuery != "boolean" || typeof parsed.asksStatus != "boolean" || typeof parsed.asksDiff != "boolean" || typeof parsed.asksLog != "boolean" || typeof parsed.asksBranch != "boolean")
+    return null;
+  let isGitQuery = parsed.isGitQuery, asksStatus = parsed.asksStatus, asksDiff = parsed.asksDiff, asksLog = parsed.asksLog, asksBranch = parsed.asksBranch, showTarget = null;
+  if (typeof parsed.showTarget == "string" && parsed.showTarget.trim()) {
+    let candidateTarget = parsed.showTarget.trim();
+    SAFE_REF_PATTERN.test(candidateTarget) && !candidateTarget.startsWith("-") && !candidateTarget.includes("..") && !candidateTarget.endsWith("^!") && !candidateTarget.endsWith("^@") && (showTarget = candidateTarget);
+  }
+  let targetRepo = null;
+  if (typeof parsed.targetRepo == "string" && parsed.targetRepo.trim()) {
+    let candidateRepo = parsed.targetRepo.trim();
+    SAFE_REPO_NAME_PATTERN.test(candidateRepo) && candidateRepo !== "." && candidateRepo !== ".." && !candidateRepo.includes("/") && !candidateRepo.includes("\\") && (targetRepo = candidateRepo);
+  }
+  return {
+    isGitQuery,
+    asksStatus,
+    asksDiff,
+    asksLog,
+    asksBranch,
+    showTarget,
+    targetRepo
+  };
+}
+async function parseGitStatusQueryWithGemma(runner, prompt, timeoutMs = 12e3) {
+  let startTime = Date.now(), boundedPrompt = prompt.slice(0, 2e3).trim(), promptText = renderLocalGemmaGitStatusQueryPrompt({ userPrompt: boundedPrompt }), abortController = new AbortController(), timer = null;
+  try {
+    let timeoutPromise = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        abortController.abort(), reject(new Error(`Gemma status query classification timed out after ${timeoutMs}ms`));
+      }, timeoutMs), timer?.unref?.();
+    }), advisoryPromise = runner.generateAdvisory(promptText, {
+      responseFormat: "json",
+      numPredict: 100,
+      temperature: 0.1,
+      timeoutMs,
+      signal: abortController.signal
+    }), raw = await Promise.race([advisoryPromise, timeoutPromise]);
+    if (!raw || typeof raw != "string")
+      return logger.warn("[git-status-summary] Gemma returned empty or non-string response", {
+        prompt: boundedPrompt,
+        durationMs: Date.now() - startTime
+      }), null;
+    let parsed = parseGemmaGitStatusResponse(raw);
+    return parsed || (logger.warn("[git-status-summary] Gemma response failed schema validation", {
+      prompt: boundedPrompt,
+      raw,
+      durationMs: Date.now() - startTime
+    }), null);
+  } catch (err) {
+    let elapsed = Date.now() - startTime;
+    return logger.warn("[git-status-summary] Gemma status query classification timed out or failed", {
+      prompt: boundedPrompt,
+      durationMs: elapsed,
+      error: err?.message || String(err)
+    }), null;
+  } finally {
+    timer && clearTimeout(timer);
+  }
+}
+function parseGitStatusQuerySemantic(prompt) {
+  let trimmed = prompt.trim();
+  if (!trimmed)
+    return {
+      isGitQuery: !1,
+      asksStatus: !1,
+      asksDiff: !1,
+      asksLog: !1,
+      asksBranch: !1,
+      showTarget: null,
+      targetRepo: null
+    };
+  let isExplicitGit = /\b(?:git\s+(?:status|diff|log|branch|show|checkout|switch|restore)|commit\s+history|recent\s+commits)\b/i.test(trimmed);
+  if (!(isExplicitGit || /\b(?:diff|status|log|branch|show|commits?|untracked|modified|working\s+tree|working\s+copy|working\s+directory)\b/i.test(trimmed)) && (/\b(?:task|agent|orchestrat(?:or|ion)|track|run|job|process|build|test|deploy|session)\s+status\b/i.test(trimmed) || /\bstatus\s+of\s+(?:the\s+)?(?:running\s+|active\s+)?(?:task|agent|orchestrat(?:or|ion)|track|run|job|process|team|build|suite)\b/i.test(trimmed) || /\b(?:how\s+many|what)\s+tasks?\s+(?:are\s+)?(?:running|active|pending)\b/i.test(trimmed) || /\b(?:what\s+did\s+)?(?:the\s+)?(?:last|previous|prior)\s+task\b/i.test(trimmed) || /\b(?:has\s+the|is\s+the)\s+(?:git\s+)?build\s+(?:finished|running|done|complete)\b/i.test(trimmed)))
+    return {
+      isGitQuery: !1,
+      asksStatus: !1,
+      asksDiff: !1,
+      asksLog: !1,
+      asksBranch: !1,
+      showTarget: null,
+      targetRepo: null
+    };
+  let isSinceLastCommit = /\b(?:what(?:'s|\s+is|\s+has)?\s+changed|changes?|diff)\s+(?:since|after)\s+(?:the\s+)?(?:most\s+recent|last|latest|current|head|my\s+last)\s+commit\b/i.test(trimmed.replace(/[\u2018\u2019]/g, "'")) || /\b(?:since|after)\s+(?:the\s+)?(?:most\s+recent|last|latest|current|head|my\s+last)\s+commit\b/i.test(trimmed.replace(/[\u2018\u2019]/g, "'")), asksCommitDiff = !isSinceLastCommit && COMMIT_DIFF_PATTERN.test(trimmed), showTarget = null;
+  if (asksCommitDiff) {
+    let commitHexMatch = /\b([0-9a-f]{7,40}(?:[~^][A-Za-z0-9_/@~^-]*)?)'s\s+diff\b/i.exec(trimmed) || /\bdiff\s+of\s+(?:commit\s+)?(?![^\s;,?]*\.\.[a-zA-Z0-9_/@~^-])([0-9a-f]{7,40}(?:[~^][A-Za-z0-9_/@~^-]*)?)(?![0-9a-zA-Z_/@~^-])/i.exec(trimmed);
+    commitHexMatch && !commitHexMatch[1].includes("..") ? showTarget = stripSentencePunctuation(commitHexMatch[1]) : showTarget = extractBranchOrRefTarget(trimmed) ?? "HEAD";
+  }
+  let hasGitOrRepoContext = /\b(?:git|repo|repository)\b/i.test(trimmed), asksStatus = isSinceLastCommit || /\b(?:git\s+status)\b/i.test(trimmed) || /\b(?:status)\b/i.test(trimmed) && /\b(?:repo|repository|git|workspace|working\s+tree|working\s+copy)\b/i.test(trimmed) || /\b(?:dirty|untracked|modified|uncommitted|staged|unstaged)\s+(?:files|changes)\b/i.test(trimmed) || /\b(?:untracked\s+or\s+modified|modified\s+or\s+untracked)\s+(?:files|changes)?\b/i.test(trimmed) || /\b(?:did\s+i\s+leave\s+anything\s+uncommitted|any\s+uncommitted\s+(?:changes|files|work)|anything\s+uncommitted)\b/i.test(trimmed) || /\b(?:any\s+)?(?:dirty|untracked|modified)\s+files\b/i.test(trimmed) || /\bfiles\s+(?:are\s+)?(?:still\s+|currently\s+)?dirty\b/i.test(trimmed) || /\b(?:what|which)\s+files\s+(?:are\s+)?(?:still\s+|currently\s+)?dirty\b/i.test(trimmed) || /\b(?:repo|repository|workspace|working\s+(?:tree|copy))\s+(?:is\s+)?dirty\b/i.test(trimmed) || /\b(?:is\s+(?:my\s+)?)(?:repo|repository|workspace|working\s+(?:tree|copy))\s+dirty\b/i.test(trimmed) || /\b(?:new\s+files\s+)?not\s+tracked(?:\s+by\s+git)?\b/i.test(trimmed) || /\bworking\s+(?:tree|copy)\b/i.test(trimmed) || /\bworking\s+directory\b/i.test(trimmed) && hasGitOrRepoContext || /\bclean\s+working\s+(?:tree|copy)\b/i.test(trimmed) || /\bclean\s+working\s+directory\b/i.test(trimmed) && hasGitOrRepoContext || /\bis\s+(?:my\s+)?working\s+(?:tree|copy)\s+clean\b/i.test(trimmed) || /\bis\s+(?:my\s+)?working\s+directory\s+clean\b/i.test(trimmed) && hasGitOrRepoContext || /\b(?:which|what)\s+files\s+(?:have\s+i|did\s+i|are|were)?\s*(?:edited|modified|changed)\b/i.test(trimmed) || /\bwhat\s+(?:files\s+)?(?:did\s+i|have\s+been|are)\s+(?:changed|modified|edited)\b/i.test(trimmed) || /(?:git.*(?:狀態|status)|(?:工作區|工作副本|版本庫|暫存區).*(?:狀態|變更|修改)|工作目錄.*(?:狀態|變更|修改)|(?:未追蹤|未跟踪|未暫存|未暂存|已修改|有修改).*(?:檔案|文件)|(?:有沒有|有没有).*(?:未追蹤|未跟踪|未暫存|未暂存|已修改).*(?:檔案|文件)?|(?:程式碼|代碼).*(?:差異|變更))/i.test(trimmed) || /(?:mostra(?:mi)?|elenc(?:a|ami))\s+(?:tutti\s+)?(?:i\s+)?file\s+(?:non\s+tracciati|modificati)|(?:file\s+non\s+tracciati|file\s+modificati|stato\s+del\s+repository)/i.test(trimmed) || /(?:archivos?\s+(?:sin\s+seguimiento|modificados?)|unversionierte\s+dateien|fichiers?\s+(?:non\s+suivis?|modifi[eé]s?)|suivi\s+des\s+fichiers)/i.test(trimmed), comparisonBase = extractComparisonBaseRef(trimmed), asksDiff = !asksCommitDiff && (isSinceLastCommit || !!comparisonBase || /\bgit\s+diff\b/i.test(trimmed) || /\b(?:working\s+tree|working\s+copy|uncommitted|staged|unstaged)\s+diff\b/i.test(trimmed) || /\bdiff\s+against\s+(?:working\s+tree|head)\b/i.test(trimmed) || /\b(?:difference|diff)\s+between\s+my\s+working\s+(?:tree|copy)\s+and\s+([a-z0-9_./@~^-]+)\b/i.test(trimmed) || /^(?:please\s+)?(?:show|view|see)\s+(?:me\s+)?(?:the\s+|my\s+)?(?:diff|changes)(?:\s+since\s+(?:yesterday|today|monday|tuesday|wednesday|thursday|friday|saturday|sunday|(?:last|this)\s+\w+|\d+\s+\w+(?:\s+ago)?))?[\s.!?]*$/i.test(trimmed) || /\b(?:give|show|view|see|get|provide|display|print)\s+(?:me\s+)?(?:a\s+|the\s+|my\s+)?diff\b(?!\s+(?:of|between)\b|\s+(?:for\s+)?these\s+two\b)/i.test(trimmed) || /\b(?:show|view|see)\s+(?:the\s+)?(?:diff|changes)\s+(?:in\s+(?:the\s+|my\s+)?(?:working\s+(?:tree|copy)|repo|repository)|locally|uncommitted)\b/i.test(trimmed) || /\b(?:git|repo|working\s+(?:tree|copy)|uncommitted)\s+(?:changes?|diff)\s+(?:since|against)\b/i.test(trimmed)), asksLog = /\b(?:git\s+log|commit\s+history|recent\s+commits)\b/i.test(trimmed) || /\b(?:log\s+of\s+commits|history\s+of\s+commits|past\s+commits|list\s+commits)\b/i.test(trimmed) || /\b(?:most\s+recent|last|latest)\s+commits\b/i.test(trimmed), asksBranch = /\bgit\s+branch\b/i.test(trimmed) || /\b(?:what|which)\s+branch\s+(?:am\s+i|are\s+we)\s+(?:currently\s+|presently\s+|right\s+now\s+)?(?:on|working\s+on)\b/i.test(trimmed) || /\b(?:what|which)\s+branch\s+(?:is\s+(?:currently\s+|presently\s+)?checked\s+out|is\s+this)\b/i.test(trimmed) || /\bcurrent\s+branch\b/i.test(trimmed) || /\blist\s+(?:all\s+)?branches\b/i.test(trimmed), asksShow = !!showTarget || /\bgit\s+show\b/i.test(trimmed) || /\b(?:show|view|see|display|print|inspect|details\s+of)\s+(?:(?:me|us)\s+)?(?:commit\s+)?(?:HEAD|[0-9a-f]{7,40})(?:[~^][A-Za-z0-9_/@~^-]*)?(?![0-9a-zA-Z_/@~^-]|\.[0-9a-zA-Z_/@~^-])/i.test(trimmed);
+  return {
+    isGitQuery: !!(isExplicitGit || GIT_QUERY_PATTERN.test(trimmed) || asksStatus || asksDiff || asksLog || asksBranch || asksShow || asksCommitDiff),
+    asksStatus,
+    asksDiff,
+    asksLog,
+    asksBranch,
+    showTarget,
+    targetRepo: null
+  };
+}
+async function resolveGitStatusIntent(options) {
+  let { prompt, advisoryRunner } = options, trimmed = prompt.trim();
+  if (!trimmed)
+    return {
+      isGitQuery: !1,
+      asksStatus: !1,
+      asksDiff: !1,
+      asksLog: !1,
+      asksBranch: !1,
+      showTarget: null,
+      targetRepo: null
+    };
+  if (isConceptualGitQuestion(trimmed))
+    return {
+      isGitQuery: !1,
+      asksStatus: !1,
+      asksDiff: !1,
+      asksLog: !1,
+      asksBranch: !1,
+      showTarget: null,
+      targetRepo: null
+    };
+  if (/^(?:[`'"]?(?:\/|!)?git\s+(?:status|diff|log|branch|show|checkout|switch|restore)\b)/i.test(trimmed))
+    return parseGitStatusQuerySemantic(trimmed);
+  let candidateRunner = resolvePreferredAdvisoryRunner(advisoryRunner);
+  if (candidateRunner)
+    try {
+      let gemmaStart = Date.now(), gemmaIntent = await parseGitStatusQueryWithGemma(candidateRunner, trimmed), gemmaDurationMs = Date.now() - gemmaStart;
+      if (gemmaIntent !== null) {
+        if (gemmaIntent.targetRepo) {
+          let repoCandidate = stripSentencePunctuation(gemmaIntent.targetRepo), candLower = repoCandidate.toLowerCase(), genericStopwords = /* @__PURE__ */ new Set([
+            "work",
+            "working",
+            "tree",
+            "directory",
+            "copy",
+            "repo",
+            "repository",
+            "git",
+            "current",
+            "active",
+            "local",
+            "here",
+            "this",
+            "diff",
+            "status",
+            "log",
+            "branch",
+            "show",
+            "commit",
+            "commits"
+          ]), isExplicitRepoSyntax = SAFE_REPO_NAME_PATTERN.test(repoCandidate) && !repoCandidate.includes(".."), designatedTokens = [], afterMatches = trimmed.matchAll(
+            /\b(?:in|for|from|under|at|inside|to)\s+(?:the\s+)?(?:repo|repository|submodule|package|dir|directory|project)\s+["'`]?([A-Za-z0-9_.-]+)["'`]?/gi
+          );
+          for (let m of afterMatches) {
+            let tok = stripSentencePunctuation(m[1]).toLowerCase();
+            tok && designatedTokens.push(tok);
+          }
+          let beforeMatches = trimmed.matchAll(
+            /(?<=^|[\s"'\`(\[{<])([A-Za-z0-9_.-]+)\s+(?:repo|repository|package|project|submodule)\b/gi
+          );
+          for (let m of beforeMatches) {
+            let tok = stripSentencePunctuation(m[1]).toLowerCase();
+            tok && designatedTokens.push(tok);
+          }
+          !designatedTokens.some(
+            (token) => token === candLower && !genericStopwords.has(token)
+          ) || !isExplicitRepoSyntax || genericStopwords.has(candLower) ? gemmaIntent.targetRepo = null : gemmaIntent.targetRepo = repoCandidate;
+        }
+        return logger.info("[git-status-summary] Gemma status intent decision", {
+          prompt: trimmed,
+          runner: candidateRunner.runtimeLabel,
+          providerKind: candidateRunner.providerKind,
+          durationMs: gemmaDurationMs,
+          intent: gemmaIntent
+        }), gemmaIntent;
+      } else
+        logger.info("[git-status-summary] Gemma returned null or timed out, falling back to deterministic semantic parser", {
+          prompt: trimmed
+        });
+    } catch (err) {
+      logger.warn("[git-status-summary] Gemma status intent query failed, falling back to deterministic semantic parser", {
+        prompt: trimmed,
+        error: err?.message
+      });
+    }
+  return parseGitStatusQuerySemantic(trimmed);
+}
+var IGNORED_TARGET_NAMES = /* @__PURE__ */ new Set([
   "git",
   "the",
   "this",
@@ -67703,7 +68720,9 @@ var defaultExecFileAsync = (0, import_util3.promisify)(import_child_process5.exe
   "very"
 ], STOPWORDS = new Set(FUNCTION_WORDS), NON_SHOW_TARGET_WORDS = new Set(FUNCTION_WORDS);
 function extractCandidateRepos(prompt) {
-  let candidates = [], seen = /* @__PURE__ */ new Set(), addCandidate = (name, isExplicit) => {
+  let candidates = [], seen = /* @__PURE__ */ new Set(), addCandidate = (rawName, isExplicit) => {
+    let name = stripSentencePunctuation(rawName);
+    if (!name) return;
     let lower = name.toLowerCase();
     if (IGNORED_TARGET_NAMES.has(lower) || /^[0-9a-f]{7,40}$/i.test(name))
       return;
@@ -67714,13 +68733,20 @@ function extractCandidateRepos(prompt) {
       let existing = candidates.find((c) => c.name.toLowerCase() === lower);
       existing && (existing.isExplicit = !0);
     }
-  }, trailingRepoRegex = /\b([a-zA-Z0-9_.-]+)\s+repo(?:sitory)?\b/gi, match;
-  for (; (match = trailingRepoRegex.exec(prompt)) !== null; )
-    addCandidate(match[1], !0);
-  let leadingRepoRegex = /\brepo(?:sitory)?\s+([a-zA-Z0-9_.-]+)\b/gi;
-  for (; (match = leadingRepoRegex.exec(prompt)) !== null; )
-    addCandidate(match[1], !0);
-  let casualRegex = /\b(?:in|of|for)\s+(?:the\s+)?([a-zA-Z0-9_.-]+)\b/gi;
+  }, trailingRepoRegex = /(?<=^|[\s"'\`(\[{<])([a-zA-Z0-9_.-]+)\s+(?:repo(?:sitory)?|project|package|submodule)\b/gi, match;
+  for (; (match = trailingRepoRegex.exec(prompt)) !== null; ) {
+    let raw = match[1], isStopword = STOPWORDS.has(raw.toLowerCase());
+    addCandidate(raw, !isStopword);
+  }
+  let leadingRepoRegex = /\b(?:repo(?:sitory)?|project|package|submodule)\s+([a-zA-Z0-9_.-]+)/gi;
+  for (; (match = leadingRepoRegex.exec(prompt)) !== null; ) {
+    let raw = match[1];
+    if (match[0].toLowerCase().startsWith("package") && raw.toLowerCase() === "lock")
+      continue;
+    let isStopword = STOPWORDS.has(raw.toLowerCase());
+    addCandidate(raw, !isStopword);
+  }
+  let casualRegex = /\b(?:in|of|for)\s+(?:the\s+)?([a-zA-Z0-9_.-]+)/gi;
   for (; (match = casualRegex.exec(prompt)) !== null; )
     addCandidate(match[1], !1);
   return candidates;
@@ -67736,8 +68762,11 @@ ${content}
 ${fence}`;
 }
 async function executeGitStatusSummary(options) {
-  let { cwd, prompt, hasActiveTask, execFileFn = defaultExecFileAsync } = options;
-  if (!GIT_QUERY_PATTERN.test(prompt) || hasActiveTask)
+  let { cwd, prompt, hasActiveTask, advisoryRunner, execFileFn = defaultExecFileAsync } = options;
+  if (hasActiveTask)
+    return null;
+  let intent = await resolveGitStatusIntent({ prompt, advisoryRunner });
+  if (!intent.isGitQuery)
     return null;
   let gitEnv = scrubSearchApiKeys({ ...process.env, LC_ALL: "C" }), defaultRepoName = sanitizeForTerminal(redactAbsoluteLocalPaths(path64.basename(cwd))), defaultRepoTopLevel = cwd;
   try {
@@ -67749,8 +68778,18 @@ async function executeGitStatusSummary(options) {
     trimmed && (defaultRepoTopLevel = trimmed, defaultRepoName = sanitizeForTerminal(redactAbsoluteLocalPaths(path64.basename(trimmed))));
   } catch {
   }
-  let targetCwd = cwd, targetRepoName = defaultRepoName, notePrefix = "", candidates = extractCandidateRepos(prompt), resolvedRepo = null;
+  let targetCwd = cwd, targetRepoName = defaultRepoName, notePrefix = "", candidates = extractCandidateRepos(prompt);
+  if (intent.targetRepo) {
+    let rawTarget = stripSentencePunctuation(intent.targetRepo);
+    if (SAFE_REPO_NAME_PATTERN.test(rawTarget) && rawTarget !== "." && rawTarget !== ".." && !rawTarget.includes("/") && !rawTarget.includes("\\")) {
+      let existingIndex = candidates.findIndex((c) => c.name.toLowerCase() === rawTarget.toLowerCase());
+      existingIndex >= 0 && candidates.splice(existingIndex, 1), candidates.unshift({ name: rawTarget, isExplicit: !0 });
+    }
+  }
+  let resolvedRepo = null;
   for (let candidate of candidates) {
+    if (!SAFE_REPO_NAME_PATTERN.test(candidate.name) || candidate.name === "." || candidate.name === ".." || candidate.name.includes("/") || candidate.name.includes("\\"))
+      continue;
     if (defaultRepoName.toLowerCase() === candidate.name.toLowerCase()) {
       resolvedRepo = { cwd, name: defaultRepoName };
       break;
@@ -67809,7 +68848,64 @@ async function executeGitStatusSummary(options) {
 
 `), targetCwd = cwd, targetRepoName = defaultRepoName;
   }
-  let sections = [], asksDiff = /\b(?:git\s+diff|diff)\b/i.test(prompt), asksBranch = /\b(?:git\s+branch|branch(?:es)?)\b/i.test(prompt), asksLog = /\b(?:git\s+log|log|commit\s+history|recent\s+commits)\b/i.test(prompt), asksStatus = /\b(?:git\s+status|status)\b/i.test(prompt), asksShow = /\bgit\s+show\b/i.test(prompt), showTarget = null, openerMatch = /\bgit\s+show\b\s*([`'"“‘«‹「『(\[（《【])/iu.exec(prompt);
+  let sections = [], isSinceLastCommit = /\b(?:what(?:'s|\s+is|\s+has)?\s+changed|changes?|diff)\s+(?:since|after)\s+(?:the\s+)?(?:most\s+recent|last|latest|current|head|my\s+last)\s+commit\b/i.test(prompt.replace(/[\u2018\u2019]/g, "'")) || /\b(?:since|after)\s+(?:the\s+)?(?:most\s+recent|last|latest|current|head|my\s+last)\s+commit\b/i.test(prompt.replace(/[\u2018\u2019]/g, "'")), comparisonBaseInfo = isSinceLastCommit ? void 0 : extractComparisonBaseRefInfo(prompt, { includeSpan: !0 });
+  async function isValidGitComparisonRef(ref, targetCwd2, gitEnv2, execFileFn2) {
+    if (ref.includes("..")) {
+      let rangeParts = ref.includes("...") ? ref.split("...") : ref.split("..");
+      if (rangeParts.length !== 2 || !rangeParts[0] && !rangeParts[1])
+        return !1;
+      for (let part of rangeParts) {
+        let endpoint = part || "HEAD";
+        if (!SAFE_REF_PATTERN.test(endpoint) || endpoint.startsWith("-"))
+          return !1;
+        try {
+          await execFileFn2(
+            "git",
+            ["--no-optional-locks", "rev-parse", "--verify", "--quiet", `${endpoint}^{commit}`],
+            { cwd: targetCwd2, env: gitEnv2, timeout: 3e3, encoding: "utf8" }
+          );
+        } catch {
+          return !1;
+        }
+      }
+      return !0;
+    }
+    if (!SAFE_REF_PATTERN.test(ref) || ref.startsWith("-"))
+      return !1;
+    try {
+      return await execFileFn2(
+        "git",
+        ["--no-optional-locks", "rev-parse", "--verify", "--quiet", `${ref}^{commit}`],
+        { cwd: targetCwd2, env: gitEnv2, timeout: 3e3, encoding: "utf8" }
+      ), !0;
+    } catch {
+      return !1;
+    }
+  }
+  function occursOutsideComparisonSpan(prompt2, target, span, comparisonRef) {
+    if (!span) {
+      if (comparisonRef) {
+        let lowerComp = comparisonRef.toLowerCase(), lowerTgt = target.toLowerCase();
+        if (lowerComp === lowerTgt || lowerComp.includes(lowerTgt) || lowerTgt.includes(lowerComp))
+          return !1;
+      }
+      return !0;
+    }
+    let lowerPrompt = prompt2.toLowerCase(), lowerTarget = target.toLowerCase(), idx = lowerPrompt.indexOf(lowerTarget);
+    if (idx === -1)
+      return !0;
+    for (; idx !== -1; ) {
+      if (idx + lowerTarget.length <= span.start || idx >= span.end)
+        return !0;
+      idx = lowerPrompt.indexOf(lowerTarget, idx + 1);
+    }
+    return !1;
+  }
+  if (comparisonBaseInfo && !comparisonBaseInfo.isExplicit) {
+    let candidateRef = comparisonBaseInfo.ref;
+    await isValidGitComparisonRef(candidateRef, targetCwd, gitEnv, execFileFn) || (comparisonBaseInfo = void 0);
+  }
+  let promptForShowDetection = comparisonBaseInfo?.span ? prompt.slice(0, comparisonBaseInfo.span.start) + " ".repeat(comparisonBaseInfo.span.end - comparisonBaseInfo.span.start) + prompt.slice(comparisonBaseInfo.span.end) : prompt, isExplicitCommitShowRequest = /\bgit\s+show\b/i.test(promptForShowDetection) || /\b(?:show|view|display|details\s+of|print|inspect)\s+(?:(?:me|us)\s+)?(?:what\s+changed\s+in\s+)?(?:(?:the|my)\s+)?(?:most\s+recent|last|latest|recent|current)\s+commit(?:'s)?(?:\s+(?:diff|details))?\b/i.test(promptForShowDetection) || /\b(?:(?:show|view|see|display|print|inspect|details\s+of|what\s+changed\s+in)\s+(?:(?:me|us)\s+)?(?:(?:the\s+)?diff\s+of\s+(?:commit\s+)?|(?:details\s+of|commit)\s+)?|(?:the\s+)?diff\s+of\s+(?:commit\s+)?)([`'"])((?:HEAD|[0-9a-f]{7,40})(?:[~^][A-Za-z0-9_/@~^-]*)?)\1/i.test(promptForShowDetection) || /\b(?:(?:show|view|see|display|print|inspect|details\s+of|what\s+changed\s+in)\s+(?:(?:me|us)\s+)?(?:(?:the\s+)?diff\s+of\s+(?:commit\s+)?|(?:details\s+of|commit)\s+)?|(?:the\s+)?diff\s+of\s+(?:commit\s+)?)(?![^\s;,?]*\.{2,3}[a-zA-Z0-9_/@~^-])(?:HEAD|[0-9a-f]{7,40})(?:[~^][A-Za-z0-9_/@~^-]*)?(?![0-9a-zA-Z_/@~^-]|\.[0-9a-zA-Z_/@~^-])/i.test(promptForShowDetection) || /(?:^\s*|\b(?:and|also)\s+)commit\s+((?:HEAD|[0-9a-f]{7,40})(?:[~^][A-Za-z0-9_/@~^-]*)?)(?![0-9a-zA-Z_/@~^-]|\.[0-9a-zA-Z_/@~^-])/i.test(promptForShowDetection) || /\b[0-9a-f]{7,40}(?:[~^][A-Za-z0-9_/@~^-]*)?'s\s+diff\b/i.test(promptForShowDetection), isExplicitGitShow = isExplicitCommitShowRequest, hasStrongComparison = !!(comparisonBaseInfo && (comparisonBaseInfo.isExplicit || hasRefSyntax(comparisonBaseInfo.ref))), hasComparison = !!(isSinceLastCommit || comparisonBaseInfo), isCommitDiff = !isSinceLastCommit && !hasComparison && (COMMIT_DIFF_PATTERN.test(prompt) || !intent.asksDiff && !!intent.showTarget) || !isSinceLastCommit && !hasComparison && !intent.asksDiff && !!intent.showTarget, asksDiff = isSinceLastCommit || hasStrongComparison || !!comparisonBaseInfo && !isCommitDiff || intent.asksDiff && !isCommitDiff, hasExplicitBranchListRequest = /\b(?:list|show|view|see|display|all|other)\s+branches\b/i.test(prompt) || /\b(?:and|also)\s+(?:list\s+)?branches\b/i.test(prompt) || /\bgit\s+branch\b/i.test(prompt) || /\b(?:which|what)\s+branch\s+(?:am\s+i|is\s+this)\b/i.test(prompt), asksBranch = isSinceLastCommit ? !1 : isCommitDiff ? !!(hasExplicitBranchListRequest && intent.asksBranch) : intent.asksBranch, asksLog = isSinceLastCommit ? !1 : intent.asksLog, asksStatus = isSinceLastCommit || intent.asksStatus, asksShow = isExplicitCommitShowRequest || !isSinceLastCommit && !hasComparison && isCommitDiff, showTarget = null, openerMatch = /\bgit\s+show\b\s*([`'"“‘«‹「『(\[（《【])/iu.exec(prompt);
   if (openerMatch) {
     let opener = openerMatch[1], pairRegex = null;
     switch (opener) {
@@ -67881,9 +68977,34 @@ async function executeGitStatusSummary(options) {
       }
     }
   }
-  if (!showTarget) {
-    let commitMatch = /\b([0-9a-f]{7,40})\b/i.exec(prompt);
-    commitMatch ? showTarget = commitMatch[1] : asksShow && (showTarget = "HEAD");
+  if (!isExplicitCommitShowRequest && hasComparison)
+    showTarget = null;
+  else if (!showTarget) {
+    let showCommitMatch = /\b(?:(?:show|view|see|display|print|inspect|details\s+of|what\s+changed\s+in)\s+(?:(?:me|us)\s+)?(?:(?:the\s+)?diff\s+of\s+(?:commit\s+)?|(?:details\s+of|commit)\s+)?|(?:the\s+)?diff\s+of\s+(?:commit\s+)?)([`'"])((?:HEAD|[0-9a-f]{7,40})(?:[~^][A-Za-z0-9_/@~^-]*)?)\1/i.exec(promptForShowDetection) || /\b(?:show|view|display|details\s+of|print)\s+(?:(?:me|us)\s+)?(?:commit\s+)?([`'"])((?:HEAD|[0-9a-f]{7,40})(?:[~^][A-Za-z0-9_/@~^-]*)?)\1/i.exec(promptForShowDetection) || /\b([0-9a-f]{7,40}(?:[~^][A-Za-z0-9_/@~^-]*)?)'s\s+diff\b/i.exec(promptForShowDetection) || /\b(?:(?:show|view|see|display|print|inspect|details\s+of|what\s+changed\s+in)\s+(?:(?:me|us)\s+)?(?:(?:the\s+)?diff\s+of\s+(?:commit\s+)?|(?:details\s+of|commit)\s+)?|(?:the\s+)?diff\s+of\s+(?:commit\s+)?)(?![^\s;,?]*\.{2,3}[a-zA-Z0-9_/@~^-])((?:HEAD|[0-9a-f]{7,40})(?:[~^][A-Za-z0-9_/@~^-]*)?)(?![0-9a-zA-Z_/@~^-]|\.[0-9a-zA-Z_/@~^-])/i.exec(promptForShowDetection) || /(?:^\s*|\b(?:and|also)\s+)commit\s+((?:HEAD|[0-9a-f]{7,40})(?:[~^][A-Za-z0-9_/@~^-]*)?)(?![0-9a-zA-Z_/@~^-]|\.[0-9a-zA-Z_/@~^-])/i.exec(promptForShowDetection) || /\b(?:show|view|display|details\s+of|print)\s+(?:(?:me|us)\s+)?(?:commit\s+)?(?![^\s;,?]*\.\.[a-zA-Z0-9_/@~^-])([0-9a-f]{7,40}(?:[~^][A-Za-z0-9_/@~^-]*)?)(?![0-9a-zA-Z_/@~^-]|\.[0-9a-zA-Z_/@~^-])/i.exec(promptForShowDetection), targetRef = showCommitMatch ? showCommitMatch[2] ?? showCommitMatch[1] : null;
+    if (showCommitMatch && targetRef && occursOutsideComparisonSpan(prompt, targetRef, comparisonBaseInfo?.span, comparisonBaseInfo?.ref))
+      showTarget = stripSentencePunctuation(targetRef);
+    else if (asksShow && intent.showTarget && occursOutsideComparisonSpan(prompt, intent.showTarget, comparisonBaseInfo?.span, comparisonBaseInfo?.ref))
+      showTarget = intent.showTarget;
+    else {
+      let nonComparisonHash = null;
+      for (let m of promptForShowDetection.matchAll(/\b(?![^\s;,?]*\.\.[a-zA-Z0-9_/@~^-])([0-9a-f]{7,40}(?:[~^][A-Za-z0-9_/@~^-]*)?)(?![0-9a-zA-Z_/@~^-]|\.\.[a-zA-Z0-9_/@~^-])/gi)) {
+        let matchIndex = m.index, matchEnd = matchIndex + m[0].length;
+        if (comparisonBaseInfo?.span) {
+          if (!(matchEnd <= comparisonBaseInfo.span.start || matchIndex >= comparisonBaseInfo.span.end))
+            continue;
+        } else if (comparisonBaseInfo?.ref) {
+          let compRef = comparisonBaseInfo.ref.toLowerCase(), cand = m[1].toLowerCase();
+          if (compRef === cand || compRef.includes(cand) || cand.includes(compRef))
+            continue;
+        }
+        let candidate = stripSentencePunctuation(m[1]);
+        if (!candidate.includes("..")) {
+          nonComparisonHash = candidate;
+          break;
+        }
+      }
+      nonComparisonHash ? showTarget = nonComparisonHash : asksShow && (showTarget = "HEAD");
+    }
   }
   let includeStatus = asksStatus || !asksDiff && !asksBranch && !asksShow, includeLog = asksLog || !asksDiff && !asksBranch && !asksShow;
   try {
@@ -67920,24 +69041,27 @@ ${formatFencedCodeBlock(statusContent, "text")}`);
 ${formatFencedCodeBlock(logContent, "text")}`);
     }
     if (asksDiff) {
-      let diffContent = "No working tree changes";
-      try {
-        let { stdout: gitDiff } = await execFileFn(
-          "git",
-          ["--no-optional-locks", "-c", "color.ui=never", "diff", "--stat"],
-          { cwd: targetCwd, env: gitEnv, timeout: 3e3, encoding: "utf8" }
-        ), diffLines = gitDiff.split(/\r?\n/).map((l) => l.trimEnd()).filter((l) => l.length > 0);
-        if (diffLines.length > 0) {
-          let capped = diffLines.slice(0, 20), rem = diffLines.length - 20;
-          diffContent = rem > 0 ? `${capped.join(`
+      let comparisonBase = comparisonBaseInfo?.ref, isExplicitComparison = !!comparisonBaseInfo?.isExplicit, isStaged = !isSinceLastCommit && isStagedDiffIntent(prompt), diffTitle = isStaged ? `### Git Staged Diff (${targetRepoName})` : `### Git Diff (${targetRepoName})`, diffContent = isStaged ? "No staged changes" : isSinceLastCommit || comparisonBase === "HEAD" ? "No changes since last commit" : comparisonBase ? `No differences against ${comparisonBase}` : "No working tree changes";
+      comparisonBase && comparisonBase !== "HEAD" && (await isValidGitComparisonRef(comparisonBase, targetCwd, gitEnv, execFileFn) || (isExplicitComparison ? diffContent = `Commit or reference "${comparisonBase}" was not found` : (comparisonBase = void 0, diffContent = isStaged ? "No staged changes" : "No working tree changes")));
+      let diffArgs = isSinceLastCommit || !isStaged && comparisonBase === "HEAD" ? ["--no-optional-locks", "-c", "color.ui=never", "diff", "--stat", "--end-of-options", "HEAD", "--"] : isStaged && comparisonBase ? ["--no-optional-locks", "-c", "color.ui=never", "diff", "--cached", "--stat", "--end-of-options", comparisonBase, "--"] : isStaged ? ["--no-optional-locks", "-c", "color.ui=never", "diff", "--cached", "--stat"] : comparisonBase ? ["--no-optional-locks", "-c", "color.ui=never", "diff", "--stat", "--end-of-options", comparisonBase, "--"] : ["--no-optional-locks", "-c", "color.ui=never", "diff", "--stat"];
+      if (!diffContent.startsWith("Commit or reference"))
+        try {
+          let { stdout: gitDiff } = await execFileFn(
+            "git",
+            diffArgs,
+            { cwd: targetCwd, env: gitEnv, timeout: 3e3, encoding: "utf8" }
+          ), diffLines = gitDiff.split(/\r?\n/).map((l) => l.trimEnd()).filter((l) => l.length > 0);
+          if (diffLines.length > 0) {
+            let capped = diffLines.slice(0, 20), rem = diffLines.length - 20;
+            diffContent = rem > 0 ? `${capped.join(`
 `)}
 ...and ${rem} more` : capped.join(`
 `);
+          }
+        } catch {
+          diffContent = isStaged ? "Staged diff is unavailable" : "Diff is unavailable";
         }
-      } catch {
-        diffContent = "Diff is unavailable";
-      }
-      diffContent = sanitizeForTerminal(redactAbsoluteLocalPaths(diffContent)), sections.push(`### Git Diff (${targetRepoName})
+      diffContent = sanitizeForTerminal(redactAbsoluteLocalPaths(diffContent)), sections.push(`${diffTitle}
 ${formatFencedCodeBlock(diffContent, "text")}`);
     }
     if (asksBranch) {
@@ -67948,15 +69072,19 @@ ${formatFencedCodeBlock(diffContent, "text")}`);
           ["--no-optional-locks", "-c", "color.ui=never", "branch", "--list"],
           { cwd: targetCwd, env: gitEnv, timeout: 3e3, encoding: "utf8" }
         ), branchLines = gitBranch.split(/\r?\n/).map((l) => l.trimEnd()).filter((l) => l.length > 0);
-        branchLines.length > 0 && (branchContent = branchLines.slice(0, 10).join(`
-`));
+        if (branchLines.length > 0) {
+          let currentBranchLine = branchLines.find((l) => l.startsWith("* ")), cappedOthers = branchLines.filter((l) => !l.startsWith("* ")).slice(0, currentBranchLine ? 9 : 10);
+          branchContent = (currentBranchLine ? [currentBranchLine, ...cappedOthers] : cappedOthers).join(`
+`);
+        }
       } catch {
         branchContent = "Branch listing is unavailable";
       }
       branchContent = sanitizeForTerminal(redactAbsoluteLocalPaths(branchContent)), sections.push(`### Git Branches (${targetRepoName})
 ${formatFencedCodeBlock(branchContent, "text")}`);
     }
-    if (showTarget) {
+    if (!isSinceLastCommit && showTarget) {
+      (showTarget.startsWith("-") || showTarget.includes("\0")) && (showTarget = "HEAD");
       let isHexHash = /^[0-9a-f]{7,40}$/i.test(showTarget), safeTarget = sanitizeForTerminal(redactAbsoluteLocalPaths(showTarget)), title = isHexHash ? `Commit ${safeTarget}` : `Git Show ${safeTarget}`;
       try {
         let gitShowRef = showTarget.endsWith("^!") || showTarget.endsWith("^@") ? showTarget : `${showTarget}^{commit}`, { stdout: showOut } = await execFileFn(
@@ -71053,7 +72181,7 @@ async function runOrchestrationShell(args) {
           let isSlash = isShellSlashCommand(text2), browseController = null;
           isSlash || (browseController = new AbortController(), activeBrowseAbortController = browseController);
           try {
-            await handleShellUserInput({
+            logger.info("[orchestration-shell] Turn started", { prompt: text2 }), await handleShellUserInput({
               text: text2,
               store,
               args,
@@ -71087,7 +72215,7 @@ async function runOrchestrationShell(args) {
           // concurrent slash bypass can't leak its advisory into this mirror
           // and vice-versa.
           ownEntries
-        });
+        }), logger.info("[orchestration-shell] Turn completed", { prompt: text2 });
       });
     }
   ), handleUserInput = (text2, images, options) => {
@@ -75595,6 +76723,10 @@ async function handleShellUserInput(deps) {
     if (decision = await dispatchClassify({
       ...plannerInput,
       prompt: classifyPrompt
+    }), logger.info("[orchestration-shell] Planner classified input", {
+      prompt: plannerInput.prompt,
+      action: decision.action,
+      rationale: decision.rationale
     }), isLocalPlannerRuntime(args) && decision.action === "browse" && hasFileMutationIntent(plannerInput.prompt) && (decision = {
       action: "start_task",
       rationale: decision.rationale ? `${decision.rationale} (promoted to start_task due to file mutation intent)` : "web request with file mutation intent"
@@ -75771,6 +76903,27 @@ async function handleShellUserInput(deps) {
     return;
   }
   if (isTextAdvisory) {
+    let hasRunningSingle = store.getState().runningTasks.size > 0, team = store.getState().team, teamActive = team !== null && !team.groupResolved && team.haltReason === null, hasActiveTask = hasRunningSingle || teamActive;
+    if (!isConceptualGitQuestion(dispatchText)) {
+      let gitResponse = await executeGitStatusSummary({
+        cwd: args.cwd || process.cwd(),
+        prompt: dispatchText,
+        hasActiveTask,
+        advisoryRunner: args.localAdvisoryRunner,
+        execFileFn: execFileAsync
+      });
+      if (gitResponse !== null) {
+        logger.info("[orchestration-shell] Dispatched SHELL_ADVISORY for git status", {
+          prompt: dispatchText,
+          responseLength: gitResponse.length
+        }), store.dispatch({
+          type: "SHELL_ADVISORY",
+          source: "shell",
+          text: gitResponse
+        });
+        return;
+      }
+    }
     await routeAdvisory({
       store,
       args,
@@ -75946,6 +77099,7 @@ async function handleShellUserInput(deps) {
       cwd: args.cwd || process.cwd(),
       prompt: plannerInput.prompt,
       hasActiveTask,
+      advisoryRunner: args.localAdvisoryRunner,
       execFileFn: execFileAsync
     });
     if (gitResponse !== null) {
@@ -76869,7 +78023,7 @@ var import_node_fs28 = require("node:fs"), path69 = __toESM(require("node:path")
     this.signatureCache = /* @__PURE__ */ new Map();
     this.hydrated = /* @__PURE__ */ new Set();
     this.mutex = new AsyncMutex();
-    this.cacheRoot = cacheRoot ?? path69.join(os39.homedir(), ".codevibe", "cache");
+    this.cacheRoot = cacheRoot ?? process.env.CODEVIBE_CACHE_ROOT ?? path69.join(os39.homedir(), ".codevibe", "cache");
   }
   async getWorkflowClassification(userId, prompt) {
     await this.hydrateWorkflowIfNeeded(userId);
@@ -77485,15 +78639,40 @@ var HostedGemmaAdvisoryRunner = class {
       }
       encryptedImages = options.images.map((img) => this.deps.crypto.encryptString(img, sessionKey));
     }
+    if (options?.signal?.aborted) {
+      let err = new Error("Hosted Gemma generation aborted by signal");
+      throw err.name = "AbortError", err;
+    }
     let maxTokens = options?.numPredict, temperature = options?.temperature, start = Date.now();
     try {
-      let response = await this.deps.transport.generatePlannerAdvisory({
+      let promises2 = [this.deps.transport.generatePlannerAdvisory({
         sessionId,
         prompt: encryptedPrompt,
         ...encryptedImages && encryptedImages.length > 0 ? { images: encryptedImages } : {},
         ...maxTokens !== void 0 ? { maxTokens } : {},
         ...temperature !== void 0 ? { temperature } : {}
-      });
+      })], timer, abortHandler;
+      options?.timeoutMs && options.timeoutMs > 0 && promises2.push(
+        new Promise((_, reject) => {
+          timer = setTimeout(() => {
+            let err = new Error(`Hosted Gemma advisory generation timed out after ${options.timeoutMs}ms`);
+            err.name = "TimeoutError", reject(err);
+          }, options.timeoutMs);
+        })
+      ), options?.signal && promises2.push(
+        new Promise((_, reject) => {
+          abortHandler = () => {
+            let err = new Error("Hosted Gemma generation aborted by signal");
+            err.name = "AbortError", reject(err);
+          }, options.signal.addEventListener("abort", abortHandler, { once: !0 });
+        })
+      );
+      let response;
+      try {
+        response = await Promise.race(promises2);
+      } finally {
+        timer && clearTimeout(timer), abortHandler && options?.signal && options.signal.removeEventListener("abort", abortHandler);
+      }
       return this.deps.crypto.decryptString(response.advisoryText, sessionKey);
     } catch (err) {
       let elapsedMs = Date.now() - start;
@@ -81452,6 +82631,7 @@ function enforceStrictJsonStdout(raw) {
 var LocalGemmaProcessRunner = class {
   constructor(config) {
     this.config = config;
+    this.providerKind = "local";
     this.runtimeLabel = `local-gemma-process:${import_path4.default.basename(config.command)}`;
   }
   async classify(promptText) {