@moritzwilksch/diffle 0.1.0 → 0.1.1

package/dist/server/main.js

@@ -2997,8 +2997,961 @@ function useColor$1() {
 }
 new Command();
 //#endregion
+//#region node_modules/commander-static-completion/dist/model.js
+const definitions = /* @__PURE__ */ new WeakMap();
+function validateDefinition(target, definition) {
+	if (!target._executableHandler) throw new TypeError(`Completion definition target ${target.name()} must be an executable subcommand.`);
+	if (definition === target || definition.parent || definition._executableHandler) throw new TypeError(`Completion definition for ${target.name()} must be an independent, in-process root Command.`);
+	if (target.options.length || target.commands.length) throw new TypeError(`Executable subcommand ${target.name()} has conflicting parser definitions; put options and children on its completion definition.`);
+}
+function checkCompatibility(command) {
+	const internal = command;
+	if (command.commands.some((child) => child.name() === "*" || child.aliases().includes("*"))) throw new Error("Legacy wildcard subcommands are unsupported; use { isDefault: true } with an ordinary command name.");
+	if (internal._executableHandler && !definitions.has(command)) throw new Error(`Supply a definition with completionDefinition() for executable subcommand ${command.name()}.`);
+}
+function description(value) {
+	return stripVTControlCharacters(value).replace(/[\s\x00-\x1f\x7f-\x9f]+/gu, " ").trim();
+}
+const hints = /* @__PURE__ */ new WeakMap();
+function valueSpec(target) {
+	const hint = hints.get(target);
+	if (hint) return hint;
+	return target.argChoices ? {
+		kind: "choices",
+		values: [...target.argChoices]
+	} : { kind: "none" };
+}
+function extract(program) {
+	const nodes = [];
+	const active = /* @__PURE__ */ new Set();
+	function visit(command, inherited = [], ancestorDigit = false) {
+		checkCompatibility(command);
+		const definition = definitions.get(command);
+		if (definition) {
+			validateDefinition(command, definition);
+			if (inherited.some((option) => option.flags.some((flag) => /^-\d$/u.test(flag)))) throw new Error(`Executable subcommand ${command.name()} has active ancestor digit flags; use enablePositionalOptions() on their declaring commands to separate the parsers.`);
+			ancestorDigit = false;
+			command = definition;
+			checkCompatibility(command);
+		}
+		if (active.has(command)) throw new TypeError(`Cyclic completion definition at ${command.name()}.`);
+		active.add(command);
+		const internal = command;
+		const hasDigit = ancestorDigit || command.options.some((option) => /^-\d$/u.test(option.short ?? ""));
+		const help = command.createHelp();
+		const helpCommand = internal._getHelpCommand();
+		const helpOption = internal._getHelpOption();
+		const visibleOptions = help.visibleOptions(command);
+		const optionFlags = (option) => [option.short, option.long].filter((flag) => flag !== void 0);
+		const registeredFlags = new Set(command.options.flatMap(optionFlags));
+		for (const option of visibleOptions) {
+			if (command.options.includes(option) || option === helpOption) continue;
+			const flags = optionFlags(option);
+			if (!helpOption || !flags.length || !flags.every((flag) => optionFlags(helpOption).includes(flag) && !registeredFlags.has(flag))) throw new Error(`configureHelp().visibleOptions() returned an unregistered option ${option.flags} for ${command.name()}. Supply parser definitions with addOption().`);
+		}
+		const localOptions = [.../* @__PURE__ */ new Set([...command.options, ...visibleOptions])].map((option) => ({
+			flags: [option.short, option.long].filter((flag) => flag !== void 0),
+			visible: visibleOptions.includes(option),
+			description: description(option.description),
+			inherited: command.options.includes(option),
+			combineOptional: internal._combineFlagAndOptionalValue !== false,
+			mode: command.options.includes(option) ? option.required ? "required" : option.optional ? "optional" : "boolean" : "boolean",
+			variadic: command.options.includes(option) && option.variadic,
+			value: command.options.includes(option) ? valueSpec(option) : { kind: "none" }
+		}));
+		const seen = /* @__PURE__ */ new Set();
+		const options = [...inherited, ...localOptions].map((option) => ({
+			...option,
+			flags: option.flags.filter((flag) => {
+				if (seen.has(flag)) return false;
+				seen.add(flag);
+				return true;
+			})
+		}));
+		const node = {
+			id: nodes.length,
+			defaultCommand: -1,
+			options,
+			localOptions,
+			positional: internal._enablePositionalOptions ?? false,
+			passThrough: internal._passThroughOptions ?? false,
+			negativeNumbers: !hasDigit,
+			arguments: command.registeredArguments.map((arg) => ({
+				variadic: arg.variadic,
+				value: valueSpec(arg),
+				description: description(arg.description)
+			})),
+			children: []
+		};
+		nodes.push(node);
+		const visibleCommands = help.visibleCommands(command);
+		for (const child of visibleCommands) if (!command.commands.includes(child) && child !== helpCommand) throw new Error(`configureHelp().visibleCommands() returned an unregistered command ${child.name()} for ${command.name()}. Supply parser definitions with addCommand().`);
+		const implicitHelp = helpCommand && !command.commands.some((child) => [child.name(), ...child.aliases()].includes(helpCommand.name())) ? helpCommand : null;
+		for (const child of /* @__PURE__ */ new Set([...command.commands, ...implicitHelp ? [implicitHelp] : []])) {
+			const synthetic = child === implicitHelp;
+			let childNode;
+			if (synthetic) {
+				childNode = {
+					id: nodes.length,
+					defaultCommand: -1,
+					options: [],
+					localOptions: [],
+					passThrough: false,
+					positional: false,
+					negativeNumbers: !hasDigit,
+					arguments: [{
+						variadic: false,
+						description: "",
+						value: {
+							kind: "choices",
+							values: visibleCommands.filter((c) => c !== child).flatMap((c) => [c.name(), ...c.aliases()])
+						}
+					}],
+					children: []
+				};
+				nodes.push(childNode);
+			} else childNode = visit(child, internal._enablePositionalOptions || internal._passThroughOptions ? inherited : [...inherited, ...localOptions.filter((option) => option.inherited)], hasDigit);
+			if (!synthetic && child.name() === internal._defaultCommandName) node.defaultCommand = childNode.id;
+			node.children.push({
+				id: childNode.id,
+				names: synthetic ? [child.name()] : [child.name(), ...child.aliases()],
+				description: description(child.description()),
+				visible: visibleCommands.includes(child)
+			});
+		}
+		if (internal._defaultCommandName && node.defaultCommand < 0) throw new Error(`Default subcommand ${internal._defaultCommandName} is missing from ${command.name()}.`);
+		active.delete(command);
+		return node;
+	}
+	visit(program);
+	return nodes;
+}
+//#endregion
+//#region node_modules/commander-static-completion/dist/bourne-runtime.js
+function bourneRuntime(shell) {
+	return `${filterRuntime}\n${shell === "bash" ? bashDecode + bashWrapper : ""}__PREFIX__${shell === "bash" ? "_complete" : ""}() {
+${shell === "zsh" ? zshInput : bashInput}
+  local state=0 position=0 operands=0 end=0 pending= pending_value=-1 pending_variadic=0
+  local passthrough positional negative default_command consume join_next=0
+  # Isolate regex checks below: Bash/Zsh otherwise overwrite caller match variables.
+  local number_pattern='^-([0-9]+|[0-9]*[.][0-9]+)(e[+-]?[0-9]+)?$'
+  local combine mode value=-1 variadic=0 next kind word current flag rest attached
+  local i j count=0 candidate lead= cluster_prefix= raw_current="\${COMP_WORDS[COMP_CWORD]}"
+  local -a tokens candidates flags alternatives
+  COMPREPLY=()
+  __PREFIX___settings
+
+  # Direct scanner callers may supply split assignments without a source line.
+  for ((i=1; i<=COMP_CWORD; i++)); do
+    word=\${COMP_WORDS[i]}
+    if [[ -z $COMP_LINE ]] && ((count > 0)) && [[ $word == = && \${tokens[count-1]} == --* ]]; then
+      tokens[count-1]+='='
+      join_next=1
+    elif ((join_next)) && [[ $word != = ]]; then
+      tokens[count-1]+=$word
+      join_next=0
+    else
+      tokens[count]=$word
+      ((count+=1))
+    fi
+  done
+  current=\${tokens[count-1]}
+
+  __PREFIX___filter
+  for ((i=0; i<count-1; i++)); do
+    word=\${tokens[i]}
+    if (( ! end )) && [[ $word == -- ]]; then end=1; continue; fi
+    if ((operands == 0)); then
+      __PREFIX___child "$word"
+      consume=1
+      if [[ -z $next ]] && ((default_command >= 0)); then next=$default_command; consume=0; fi
+      if [[ -n $next ]]; then
+        state=$next; position=0
+        tokens=("\${tokens[@]:$((i+consume))}")
+        count=\${#tokens[@]}; i=-1
+        __PREFIX___settings
+        __PREFIX___filter
+        continue
+      fi
+    fi
+    ((operands+=1))
+    if ((passthrough)); then end=1; fi
+    __PREFIX___argument
+    if (( ! variadic )); then ((position+=1)); fi
+  done
+
+  # Until an operand commits a route, offer explicit commands and the default
+  # command's initial completions. A known parent option still owns its value.
+  while ((operands == 0 && default_command >= 0)) && [[ -z $pending ]]; do
+    if (( ! end )) && [[ $current == -?* ]]; then
+      if [[ $current == --* ]]; then
+        __PREFIX___option "\${current%%=*}"
+      else
+        rest=\${current:1}; attached=
+        while [[ -n $rest ]]; do
+          __PREFIX___option "-\${rest:0:1}"
+          if [[ -z $mode ]]; then
+            cluster_prefix+=$attached
+            current=-$rest
+            break
+          fi
+          [[ $mode == required || ( $mode == optional && ( $combine == 1 || \${#rest} == 1 ) ) ]] && break
+          attached+=\${rest:0:1}; rest=\${rest:1}
+        done
+      fi
+      [[ -n $mode ]] && break
+    fi
+    __PREFIX___suggestions
+    alternatives+=("\${candidates[@]}")
+    if (( ! end )); then alternatives+=("\${flags[@]}"); fi
+    state=$default_command
+    __PREFIX___settings
+  done
+
+  value=-1
+  if [[ -n $pending ]] && { [[ $pending == required || $current != -* || $current == - ]] || { ((negative)) && ( [[ $current =~ $number_pattern ]] ); }; }; then
+    value=$pending_value
+  elif (( ! end )) && [[ $current == --*=* ]]; then
+    __PREFIX___option "\${current%%=*}"
+    if [[ -z $mode || $mode == boolean ]]; then return 0; fi
+    lead=\${current%%=*}=
+    current=\${current#*=}
+    # Native Bash trims the actual replacement prefix after generating candidates.
+    if [[ -z $COMP_LINE && $COMP_WORDBREAKS == *=* && $raw_current != --*=* ]]; then lead=; fi
+  elif (( ! end )) && [[ $current == -?* && $current != --* ]]; then
+    rest=\${current:1}; attached=-
+    while [[ -n $rest ]]; do
+      flag=-\${rest:0:1}; attached+=\${rest:0:1}; rest=\${rest:1}
+      __PREFIX___option "$flag"
+      if [[ -z $mode ]]; then value=-1; break; fi
+      if [[ ( $mode == required || ( $mode == optional && $combine == 1 ) ) && -n $rest ]]; then lead=$attached; current=$rest; break; fi
+      value=-1
+    done
+  fi
+
+${shell === "bash" ? bashUnquote : ""}
+  if ((value >= 0)); then
+    __PREFIX___values
+  else
+    __PREFIX___suggestions
+    if ((operands > 0)); then candidates=(); fi
+    if (( ! end )); then candidates+=("\${flags[@]}"); fi
+    local -a base=("\${alternatives[@]}" "\${candidates[@]}")
+    __PREFIX___argument
+    __PREFIX___values
+    candidates=("\${base[@]}" "\${candidates[@]}")
+  fi
+  if [[ -n $cluster_prefix && -n $lead ]]; then lead=-$cluster_prefix\${lead#-}; fi
+${shell === "zsh" ? "  local description has_descriptions=0\n  local -a display\n" : ""}  for candidate in "\${candidates[@]}"; do
+${shell === "zsh" ? `    __PREFIX___description "\${candidate%%:*}"
+    candidate=\${candidate#*:}\n` : ""}    [[ $candidate == "$current"* ]] || continue
+    if [[ -n $cluster_prefix && -z $lead && $candidate == -?* && $candidate != --* ]]; then candidate=-$cluster_prefix\${candidate#-}; fi
+    local duplicate=0 existing
+    for existing in "\${COMPREPLY[@]}"; do [[ $existing == "$lead$candidate" ]] && duplicate=1; done
+    ((duplicate)) || COMPREPLY+=("$lead$candidate")
+${shell === "zsh" ? `    if (( ! duplicate )); then
+      if [[ -n $description ]]; then
+        display+=("$lead$candidate -- $description"); has_descriptions=1
+      else
+        display+=("$lead$candidate")
+      fi
+    fi\n` : ""}  done
+${shell === "bash" ? bashFiles : zshOutput}
+  return 0
+}
+`;
+}
+const bashWrapper = `__PREFIX__() {
+  local _csc_nounset=0 _csc_nocasematch=0 _csc_status=0
+  case $- in *u*) _csc_nounset=1 ;; esac
+  if shopt -q nocasematch; then _csc_nocasematch=1; fi
+  set +u
+  shopt -u nocasematch
+  if __PREFIX___complete "$@"; then :; else _csc_status=$?; fi
+  if ((_csc_nocasematch)); then shopt -s nocasematch; fi
+  if ((_csc_nounset)); then set -u; fi
+  return "$_csc_status"
+}
+`;
+const bashFiles = String.raw`  if [[ $kind == file || $kind == directory ]]; then
+    local action=file search=$current
+    # compgen expands a leading tilde even when the user quoted or escaped it.
+    # Keep './' in the result: Readline can otherwise expand the literal tilde
+    # during insertion, even when completing inside quotes on newer Bash.
+    if ((literal_tilde)); then search=./$current; fi
+    [[ $kind == directory ]] && action=directory
+    while IFS= read -r candidate; do
+      # After trimming a word-break prefix, Readline cannot stat the original
+      # directory. Preserve its slash before returning the replacement suffix.
+      if [[ -n $COMP_LINE && -d $candidate && $candidate != */ ]]; then candidate+=/; fi
+      COMPREPLY+=("$lead$candidate")
+    done < <(compgen -A "$action" -- "$search")
+    # compopt is a Bash 4+ builtin. Never resolve an external command on 3.2.
+    if ((BASH_VERSINFO[0] >= 4)); then compopt -o filenames 2>/dev/null || :; fi
+    if ((BASH_VERSINFO[0] >= 4 && __DOLLAR__{#COMPREPLY[@]} == 1)) && [[ __DOLLAR__{COMPREPLY[0]} == */ ]]; then
+      compopt -o nospace 2>/dev/null || :
+    fi
+  fi
+  # Readline can replace only the suffix after a configured word break. Remove
+  # the already-present prefix from both static candidates and filesystem paths.
+  if [[ -n $readline_prefix ]]; then
+    for ((j=0; j<__DOLLAR__{#COMPREPLY[@]}; j++)); do
+      COMPREPLY[j]=__DOLLAR__{COMPREPLY[j]#"$readline_prefix"}
+    done
+  fi
+  if ((BASH_VERSINFO[0] >= 4)) && [[ $kind != file && $kind != directory && -n $COMP_LINE ]] && compopt -o noquote +o filenames 2>/dev/null; then
+    # Quote static words ourselves: newer Readline can preserve expansion syntax
+    # even with filename quoting enabled. Bash 3.2 uses registration-time quoting.
+    for ((j=0; j<__DOLLAR__{#COMPREPLY[@]}; j++)); do
+      candidate=__DOLLAR__{COMPREPLY[j]}
+      if [[ $quote_char == "'" ]]; then
+        candidate=__DOLLAR__{candidate//\'/\'\\\'\'}
+        COMPREPLY[j]="$candidate'"
+      elif [[ $quote_char == '"' ]]; then
+        local k quoted=
+        for ((k=0; k<__DOLLAR__{#candidate}; k++)); do
+          char=__DOLLAR__{candidate:k:1}
+          if [[ $char == '$' || $char == $'\x60' || $char == '"' || $char == \\ ]]; then quoted+='\'; fi
+          quoted+=$char
+        done
+        COMPREPLY[j]=$quoted'"'
+      else
+        printf -v 'COMPREPLY[j]' '%q' "$candidate"
+      fi
+    done
+  fi
+`.replaceAll("__DOLLAR__", "$");
+const bashDecode = String.raw`__PREFIX___decode() {
+  local part=$1 char escaped=0 offset
+  decoded=; quote_char=
+  for ((offset=0; offset<__DOLLAR__{#part}; offset++)); do
+    char=__DOLLAR__{part:offset:1}
+    if ((escaped)); then
+      if [[ $quote_char == '"' && $char != '$' && $char != $'\x60' && $char != '"' && $char != \\ && $char != $'\n' ]]; then decoded+='\'; fi
+      decoded+=$char; escaped=0
+    elif [[ $char == \\ && $quote_char != "'" ]]; then escaped=1
+    elif [[ -z $quote_char && ( $char == "'" || $char == '"' ) ]]; then quote_char=$char
+    elif [[ -n $quote_char && $char == "$quote_char" ]]; then quote_char=
+    else decoded+=$char
+    fi
+  done
+  ((escaped)) && decoded+='\'
+  return 0
+}
+`.replaceAll("__DOLLAR__", "$");
+const bashUnquote = String.raw`  if [[ -n $COMP_LINE ]]; then
+    local decoded char quote_char path_raw=$current
+    __PREFIX___decode "$readline_prefix"
+    readline_prefix=$decoded
+    __PREFIX___decode "$current"
+    current=$decoded
+    if [[ $current == '~'* && $path_raw != '~'* ]]; then literal_tilde=1; fi
+  fi
+`.replaceAll("__DOLLAR__", "$");
+const zshInput = `  emulate -L ksh
+  local -a COMP_WORDS=("\${(@Q)words[@]}") COMPREPLY
+  local COMP_CWORD=$((CURRENT - 1)) COMP_WORDBREAKS=
+  # Ignore text after the cursor in the current token.
+  COMP_WORDS[COMP_CWORD]=\${(Q)PREFIX}`;
+const bashInput = String.raw`  local -a COMP_WORDS=("__DOLLAR__{COMP_WORDS[@]}")
+  local COMP_CWORD=$COMP_CWORD readline_prefix= literal_tilde=0
+  if [[ -n $COMP_LINE && -n $COMP_POINT ]]; then
+    local before after
+    # Bash 4.3+ counts characters; older versions report a byte offset.
+    if ((BASH_VERSINFO[0] > 4 || (BASH_VERSINFO[0] == 4 && BASH_VERSINFO[1] >= 3))); then
+      before=__DOLLAR__{COMP_LINE:0:COMP_POINT}
+    else
+      printf -v before '%.*s' "$COMP_POINT" "$COMP_LINE"
+    fi
+    after=__DOLLAR__{COMP_LINE#"$before"}
+    local token=__DOLLAR__{COMP_WORDS[COMP_CWORD]} prefix suffix cut
+    for ((cut=__DOLLAR__{#token}; cut>=0; cut--)); do
+      prefix=__DOLLAR__{token:0:cut}; suffix=__DOLLAR__{token:cut}
+      if [[ $before == *"$prefix" && $after == "$suffix"* ]]; then
+        COMP_WORDS[COMP_CWORD]=$prefix
+        break
+      fi
+    done
+    # Bash versions disagree about splitting punctuation in COMP_WORDS. Join
+    # only physically adjacent fragments; whitespace around '=' stays meaningful.
+    local remaining=$before fragment gap index joined_count=0
+    local -a joined
+    for ((index=0; index<=COMP_CWORD; index++)); do
+      fragment=__DOLLAR__{COMP_WORDS[index]}
+      if [[ -n $fragment ]]; then
+        [[ $remaining == *"$fragment"* ]] || { COMPREPLY=(); return 0; }
+        gap=__DOLLAR__{remaining%%"$fragment"*}
+        remaining=__DOLLAR__{remaining#*"$fragment"}
+      else
+        gap=$remaining; remaining=
+      fi
+      if ((joined_count > 0)) && [[ -z $gap ]]; then
+        joined[joined_count-1]+=$fragment
+      else
+        joined[joined_count]=$fragment
+        ((joined_count+=1))
+      fi
+    done
+    COMP_WORDS=("__DOLLAR__{joined[@]}")
+    COMP_CWORD=$((joined_count-1))
+    # Decode committed tokens too, so inserted quoted names route correctly.
+    local decoded quote_char
+    for ((index=1; index<COMP_CWORD; index++)); do
+      __PREFIX___decode "__DOLLAR__{COMP_WORDS[index]}"
+      COMP_WORDS[index]=$decoded
+    done
+    # $2 is Readline's replacement text. It can be shorter than the logical word
+    # even on Bash 3.2, where COMP_WORDS retains punctuation within each word.
+    token=__DOLLAR__{COMP_WORDS[COMP_CWORD]}
+    if (($# >= 2)) && [[ $token == *"$2" ]]; then
+      readline_prefix=__DOLLAR__{token%"$2"}
+    fi
+  fi`.replaceAll("__DOLLAR__", "$");
+const zshOutput = `  emulate -L zsh
+  # Restore compinit options before calling native completion helpers.
+  if ((\${#_comp_options[@]})); then setopt "\${_comp_options[@]}"; fi
+  if ((\${#COMPREPLY[@]})); then
+    if ((has_descriptions)); then compadd -d display -- "\${COMPREPLY[@]}";
+    else compadd -- "\${COMPREPLY[@]}"; fi
+  fi
+  if [[ $kind == file || $kind == directory ]]; then
+    # Native file completion handles quoting and directory suffixes.
+    if [[ -n $lead ]]; then compset -P "\${(b)lead}"; fi
+    # _files can fall back to all files when no directory matches. Use the
+    # lower-level helper to keep directory hints strict, including symlinks.
+    if [[ $kind == directory ]]; then _path_files -/; else _files; fi
+  fi`;
+const filterRuntime = `__PREFIX___filter() {
+  local p seen=0 token rest attached=0
+  local -a filtered
+  pending=; pending_value=-1; pending_variadic=0
+  if ((end)); then return; fi
+  for ((p=0; p<count-1; p++)); do
+    token=\${tokens[p]}
+    if [[ -n $pending ]]; then
+      if [[ $pending == required || $token != -* || $token == - ]] || { ((negative)) && ( [[ $token =~ $number_pattern ]] ); }; then
+        if ((pending_variadic)); then pending=optional; else pending=; fi
+        continue
+      fi
+      pending=
+    fi
+    if [[ $token == -- ]]; then
+      filtered+=("\${tokens[@]:$p:$((count-1-p))}")
+      break
+    fi
+    __PREFIX___local_option "$token"
+    attached=0
+    if [[ -z $mode && $token == --*=* ]]; then
+      __PREFIX___local_option "\${token%%=*}"
+      if [[ $mode == boolean ]]; then mode=; fi
+      attached=1
+    elif [[ -z $mode && $token == -?* && $token != --* ]]; then
+      rest=\${token:1}
+      while [[ -n $rest ]]; do
+        __PREFIX___local_option "-\${rest:0:1}"
+        if [[ -z $mode ]]; then token=-$rest; break; fi
+        rest=\${rest:1}
+        if [[ $mode == required || ( $mode == optional && ( $combine == 1 || -z $rest ) ) ]]; then
+          [[ -n $rest ]] && attached=1
+          break
+        fi
+      done
+    fi
+    if [[ -n $mode ]]; then
+      if [[ $mode != boolean ]] && (( ! attached )); then
+        pending=$mode; pending_value=$value; pending_variadic=$variadic
+      fi
+      continue
+    fi
+    if (((positional || passthrough) && seen == 0)); then
+      __PREFIX___child "$token"
+      if [[ -n $next ]] || ((default_command >= 0)); then
+        filtered+=("$token" "\${tokens[@]:$((p+1)):$((count-2-p))}")
+        break
+      fi
+    fi
+    filtered+=("$token")
+    ((seen+=1))
+    if ((passthrough)); then
+      filtered+=("\${tokens[@]:$((p+1)):$((count-2-p))}")
+      break
+    fi
+  done
+  if [[ -n $pending ]] && { [[ $pending == required || $current != -* || $current == - ]] || { ((negative)) && ( [[ $current =~ $number_pattern ]] ); }; }; then
+    # Ancestor options consume values before a child ever sees the remaining words.
+    tokens=("$current"); count=1
+  else
+    pending=
+    tokens=("\${filtered[@]}" "$current"); count=\${#tokens[@]}
+  fi
+}
+`;
+//#endregion
+//#region node_modules/commander-static-completion/dist/bourne.js
+function quote$1(value) {
+	if (value.includes("\0")) throw new TypeError("Shell completion strings cannot contain NUL.");
+	return "'" + value.replaceAll("'", "'\\''") + "'";
+}
+const array = (values) => `(${values.map(quote$1).join(" ")})`;
+function renderBourne(nodes, executable, prefix, shell) {
+	const descriptions = [];
+	const described = (words, description) => {
+		if (shell === "bash") return [...words];
+		let id = descriptions.indexOf(description);
+		if (id < 0) {
+			id = descriptions.length;
+			descriptions.push(description);
+		}
+		return words.map((word) => `${id}:${word}`);
+	};
+	const specs = [];
+	const spec = (hint, description) => {
+		specs.push({
+			hint,
+			description
+		});
+		return specs.length - 1;
+	};
+	const localCases = [];
+	const optionCases = [], argumentCases = [], childCases = [], suggestionCases = [];
+	for (const node of nodes) {
+		for (const option of node.options) {
+			const id = spec(option.value, option.description);
+			for (const flag of option.flags) optionCases.push(`${quote$1(`${node.id}:${flag}`)}) mode=${option.mode}; combine=${option.combineOptional ? 1 : 0}; value=${id}; variadic=${option.variadic ? 1 : 0} ;;`);
+		}
+		for (const option of node.localOptions) {
+			const id = spec(option.value, option.description);
+			for (const flag of option.flags) localCases.push(`${quote$1(`${node.id}:${flag}`)}) mode=${option.mode}; combine=${option.combineOptional ? 1 : 0}; value=${id}; variadic=${option.variadic ? 1 : 0} ;;`);
+		}
+		node.arguments.forEach((arg, index) => {
+			argumentCases.push(`${quote$1(`${node.id}:${index}`)}) value=${spec(arg.value, arg.description)}; variadic=${arg.variadic ? 1 : 0} ;;`);
+		});
+		for (const child of node.children) for (const name of child.names) childCases.push(`${quote$1(`${node.id}:${name}`)}) next=${child.id} ;;`);
+		suggestionCases.push(`${node.id}) candidates=${array(node.children.filter((c) => c.visible).flatMap((c) => described(c.names, c.description)))}; flags=${array([...new Set(node.options.filter((o) => o.visible).flatMap((o) => described(o.flags, o.description)))])} ;;`);
+	}
+	const functions = [
+		`${prefix}_settings() {\n case "$state" in\n${nodes.map((node) => `${node.id}) passthrough=${node.passThrough ? 1 : 0}; positional=${node.positional ? 1 : 0}; negative=${node.negativeNumbers ? 1 : 0}; default_command=${node.defaultCommand} ;;`).join("\n")}\n esac\n}`,
+		`${prefix}_local_option() {\n mode=; value=-1; variadic=0\n case "$state:$1" in\n${localCases.join("\n")}\n esac\n}`,
+		`${prefix}_option() {\n mode=; value=-1; variadic=0\n case "$state:$1" in\n${optionCases.join("\n")}\n esac\n}`,
+		`${prefix}_argument() {\n value=-1; variadic=0\n case "$state:$position" in\n${argumentCases.join("\n")}\n esac\n}`,
+		`${prefix}_child() {\n next=\n case "$state:$1" in\n${childCases.join("\n")}\n esac\n}`,
+		`${prefix}_suggestions() {\n candidates=(); flags=()\n case "$state" in\n${suggestionCases.join("\n")}\n esac\n}`,
+		`${prefix}_values() {\n candidates=(); kind=none\n case "$value" in\n${specs.map((s, i) => `${i}) kind=${s.hint.kind}; candidates=${array(described(s.hint.kind === "choices" ? s.hint.values : [], s.description))} ;;`).join("\n")}\n esac\n}`
+	];
+	if (shell === "zsh") functions.push(`${prefix}_description() {\n description=\n case "$1" in\n${descriptions.map((text, id) => `${id}) description=${quote$1(text)} ;;`).join("\n")}\n esac\n}`);
+	const runtime = bourneRuntime(shell).replaceAll("__PREFIX__", prefix);
+	const registration = shell === "bash" ? `complete -o filenames -F ${prefix} -- ${quote$1(executable)}` : `# Autoload executes this file as a function; sourcing only registers it.
+if [[ $ZSH_EVAL_CONTEXT == *:shfunc || $ZSH_EVAL_CONTEXT == *:loadautofunc ]]; then
+  ${prefix} "$@"
+else
+  compdef ${prefix} ${quote$1(executable)}
+fi`;
+	return `${shell === "zsh" ? `#compdef ${executable}\n` : ""}# Generated by commander-static-completion. Requires ${shell === "bash" ? "Bash 3.2+" : "Zsh with compinit loaded"}.\n${functions.join("\n\n")}\n\n${runtime}\n${registration}\n`;
+}
+//#endregion
+//#region node_modules/commander-static-completion/dist/fish-runtime.js
+const fishRuntime = String.raw`
+function __PREFIX__
+    set -l tokens (commandline -xpc)
+    set -l current (commandline -ct)
+    set -l raw_current "$current"
+    # Unescape a complete token; leave incomplete quoting to Fish's matcher.
+    set -l unescaped (string unescape -- "$current")
+    if test (count $unescaped) -eq 1
+        set current "$unescaped"
+    end
+    __PREFIX___scan "$current" "$raw_current" $tokens[2..-1]
+end
+
+function __PREFIX___scan
+    set -l current "$argv[1]"
+    set -l raw_current "$argv[2]"
+    set -l state 0
+    set -l position 0
+    set -l operands 0
+    set -l settings (__PREFIX___settings $state)
+    set -l ended 0
+    set -l pending ''
+    set -l pending_value -1
+    set -l pending_variadic 0
+    set -l info
+    set -l lead ''
+    set -l cluster_prefix ''
+    set -l alternatives
+
+    set -l tokens $argv[3..-1]
+    while true
+        set settings (__PREFIX___settings $state)
+        set pending ''
+        if test $ended -eq 0
+            set -l filtered (__PREFIX___filter $state "$current" $tokens | string split0)
+            set pending "$filtered[1]"
+            set pending_value $filtered[2]
+            set pending_variadic $filtered[3]
+            set tokens $filtered[4..-1]
+        end
+        if test -n "$pending"; and begin; test "$pending" = required; or not string match -q -- '-*' "$current"; or test "$current" = -; or begin; test "$settings[2]" = 1; and string match -qr -- '^-([0-9]+|[0-9]*[.][0-9]+)(e[+-]?[0-9]+)?$' "$current"; end; end
+            break
+        end
+        set pending ''
+        set -l dispatched 0
+        set -l index 1
+        while test $index -le (count $tokens)
+            set -l word "$tokens[$index]"
+            set index (math $index + 1)
+            if test $ended -eq 0; and test "$word" = --
+                set ended 1
+                continue
+            end
+            if test $operands -eq 0
+                set -l next (__PREFIX___child $state "$word")
+                set -l consume 1
+                if test "$next" = -1; and test "$settings[4]" != -1
+                    set next $settings[4]
+                    set consume 0
+                end
+                if test "$next" != -1
+                    set state $next
+                    set position 0
+                    if test $consume -eq 0
+                        set index (math $index - 1)
+                    end
+                    set tokens $tokens[$index..-1]
+                    set dispatched 1
+                    break
+                end
+            end
+            set operands (math $operands + 1)
+            if test "$settings[1]" = 1
+                set ended 1
+            end
+            set info (__PREFIX___argument $state $position)
+            if test "$info[2]" = 0
+                set position (math $position + 1)
+            end
+        end
+        if test $dispatched -eq 0
+            if test $operands -ne 0; or test "$settings[4]" = -1
+                break
+            end
+            if test $ended -eq 0; and string match -qr -- '^-.+' "$current"
+                if string match -q -- '--*' "$current"
+                    set -l flag (string split -m 1 = -- "$current")[1]
+                    set info (__PREFIX___option $state "$flag")
+                else
+                    set -l rest (string sub -s 2 -- "$current")
+                    set -l consumed ''
+                    while test -n "$rest"
+                        set -l letter (string sub -l 1 -- "$rest")
+                        set info (__PREFIX___option $state "-$letter")
+                        if test "$info[1]" = unknown
+                            set cluster_prefix "$cluster_prefix$consumed"
+                            set current "-$rest"
+                            break
+                        end
+                        if test "$info[1]" = required; or begin; test "$info[1]" = optional; and begin; test "$info[4]" = 1; or test (string length -- "$rest") -eq 1; end; end
+                            break
+                        end
+                        set consumed "$consumed$letter"
+                        set rest (string sub -s 2 -- "$rest")
+                    end
+                end
+                if test "$info[1]" != unknown
+                    break
+                end
+            end
+            set -a alternatives (__PREFIX___commands $state)
+            if test $ended -eq 0
+                set -a alternatives (__PREFIX___flags $state)
+            end
+            set state $settings[4]
+            set tokens
+        end
+    end
+
+    set -l value -1
+    if test -n "$pending"; and begin; test "$pending" = required; or not string match -q -- '-*' "$current"; or test "$current" = -; or begin; test "$settings[2]" = 1; and string match -qr -- '^-([0-9]+|[0-9]*[.][0-9]+)(e[+-]?[0-9]+)?$' "$current"; end; end
+        set value $pending_value
+    else if test $ended -eq 0; and string match -q -- '--*=*' "$current"
+        set -l parts (string split -m 1 = -- "$current")
+        set info (__PREFIX___option $state "$parts[1]")
+        if not contains -- "$info[1]" required optional
+            return
+        end
+        set value $info[2]
+        set lead "$parts[1]="
+        set current "$parts[2]"
+    else if test $ended -eq 0; and string match -qr -- '^-.+' "$current"; and not string match -q -- '--*' "$current"
+        set -l rest (string sub -s 2 -- "$current")
+        set -l attached -
+        while test -n "$rest"
+            set -l letter (string sub -l 1 -- "$rest")
+            set attached "$attached$letter"
+            set rest (string sub -s 2 -- "$rest")
+            set info (__PREFIX___option $state "-$letter")
+            if test "$info[1]" = unknown
+                break
+            end
+            if begin; test "$info[1]" = required; or begin; test "$info[1]" = optional; and test "$info[4]" = 1; end; end; and test -n "$rest"
+                set value $info[2]
+                set lead "$attached"
+                set current "$rest"
+                break
+            end
+        end
+    end
+
+    if test $value -lt 0
+        set -l suggestions $alternatives
+        if test $operands -eq 0
+            set -a suggestions (__PREFIX___commands $state)
+        end
+        if test $ended -eq 0
+            set -a suggestions (__PREFIX___flags $state)
+        end
+        for candidate in $suggestions
+            if test -n "$cluster_prefix"; and string match -qr -- '^-[^-]' "$candidate"
+                set candidate "-$cluster_prefix"(string sub -s 2 -- "$candidate")
+            end
+            printf '%s\n' "$candidate"
+        end
+        set info (__PREFIX___argument $state $position)
+        set value $info[1]
+    end
+    if test -n "$cluster_prefix"; and test -n "$lead"
+        set lead "-$cluster_prefix"(string sub -s 2 -- "$lead")
+    end
+    for candidate in (__PREFIX___values $value)
+        printf '%s\n' "$lead$candidate"
+    end
+    set -l kind (__PREFIX___kind $value)
+    if test "$kind" = file; or test "$kind" = directory
+        set -l escaped (string escape -- "$current")
+        # Preserve an unquoted home prefix, while escaping the rest of the path
+        # before handing it to native completion. Quoted/escaped '~' stays literal.
+        set -l raw_value (string sub -s (math (string length -- "$lead") + 1) -- "$raw_current")
+        if string match -q -- '~/*' "$raw_value"
+            set escaped '~/'(string escape -- (string sub -s 3 -- "$current"))
+        end
+        set -l paths
+        if test "$kind" = directory
+            set paths (__fish_complete_directories "$escaped")
+        else
+            set paths (__fish_complete_path "$escaped")
+        end
+        for candidate in $paths
+            printf '%s\n' "$lead$candidate"
+        end
+    end
+end
+function __PREFIX___filter
+    set -l state $argv[1]
+    set -l tokens $argv[3..-1]
+    set -l settings (__PREFIX___settings $state)
+    set -l pending ''
+    set -l pending_value -1
+    set -l pending_variadic 0
+    set -l filtered
+    set -l index 1
+    set -l seen 0
+    while test $index -le (count $tokens)
+        set -l token "$tokens[$index]"
+        set -l original_index $index
+        set index (math $index + 1)
+        if test -n "$pending"
+            if test "$pending" = required; or not string match -q -- '-*' "$token"; or test "$token" = -; or begin; test "$settings[2]" = 1; and string match -qr -- '^-([0-9]+|[0-9]*[.][0-9]+)(e[+-]?[0-9]+)?$' "$token"; end
+                if test $pending_variadic -eq 1
+                    set pending optional
+                else
+                    set pending ''
+                end
+                continue
+            end
+            set pending ''
+        end
+        if test "$token" = --
+            set -a filtered $tokens[$original_index..-1]
+            break
+        end
+        set -l info (__PREFIX___local_option $state "$token")
+        set -l attached 0
+        if test "$info[1]" = unknown; and string match -q -- '--*=*' "$token"
+            set -l parts (string split -m 1 = -- "$token")
+            set info (__PREFIX___local_option $state "$parts[1]")
+            if test "$info[1]" = boolean
+                set info unknown -1 0
+            end
+            set attached 1
+        else if test "$info[1]" = unknown; and string match -qr -- '^-.+' "$token"; and not string match -q -- '--*' "$token"
+            set -l rest (string sub -s 2 -- "$token")
+            while test -n "$rest"
+                set -l flag -(string sub -l 1 -- "$rest")
+                set info (__PREFIX___local_option $state "$flag")
+                if test "$info[1]" = unknown
+                    set token "-$rest"
+                    break
+                end
+                set rest (string sub -s 2 -- "$rest")
+                if test "$info[1]" = required; or begin; test "$info[1]" = optional; and begin; test "$info[4]" = 1; or test -z "$rest"; end; end
+                    if test -n "$rest"
+                        set attached 1
+                    end
+                    break
+                end
+            end
+        end
+        if test "$info[1]" != unknown
+            if test "$info[1]" != boolean; and test $attached -eq 0
+                set pending $info[1]
+                set pending_value $info[2]
+                set pending_variadic $info[3]
+            end
+            continue
+        end
+        if begin; test "$settings[3]" = 1; or test "$settings[1]" = 1; end; and test $seen -eq 0
+            set -l next (__PREFIX___child $state "$token")
+            if test "$next" != -1; or test "$settings[4]" != -1
+                set -a filtered "$token" $tokens[$index..-1]
+                break
+            end
+        end
+        set -a filtered "$token"
+        set seen (math $seen + 1)
+        if test "$settings[1]" = 1
+            set -a filtered $tokens[$index..-1]
+            break
+        end
+    end
+    printf '%s\0' "$pending" "$pending_value" "$pending_variadic" $filtered
+end
+`;
+//#endregion
+//#region node_modules/commander-static-completion/dist/fish.js
+function quote(value) {
+	if (/[\0\r\n\t]/u.test(value)) throw new TypeError("Fish completion strings cannot contain NUL, tabs, or newlines.");
+	return "'" + value.replaceAll("\\", "\\\\").replaceAll("'", "\\'") + "'";
+}
+const print = (values) => values.length ? `printf '%s\\n' ${values.map(quote).join(" ")}` : "return 0";
+const literalCase = (key, values) => `if test "$argv[1]:$argv[2]" = ${quote(key)}\n ${print(values)}\n return 0\n end`;
+function renderFish(nodes, executable, prefix) {
+	const specs = [];
+	const spec = (hint, description) => {
+		specs.push({
+			hint,
+			description
+		});
+		return specs.length - 1;
+	};
+	const described = (words, description) => words.map((word) => description ? `printf '%s\\t%s\\n' ${quote(word)} ${quote(description)}` : print([word])).join("\n ") || "return 0";
+	const localCases = [];
+	const optionCases = [], argumentCases = [], childCases = [];
+	const commandCases = [], flagCases = [];
+	for (const node of nodes) {
+		for (const option of node.options) {
+			const value = spec(option.value, option.description);
+			for (const flag of option.flags) optionCases.push(literalCase(`${node.id}:${flag}`, [
+				option.mode,
+				String(value),
+				option.variadic ? "1" : "0",
+				option.combineOptional ? "1" : "0"
+			]));
+		}
+		for (const option of node.localOptions) {
+			const value = spec(option.value, option.description);
+			for (const flag of option.flags) localCases.push(literalCase(`${node.id}:${flag}`, [
+				option.mode,
+				String(value),
+				option.variadic ? "1" : "0",
+				option.combineOptional ? "1" : "0"
+			]));
+		}
+		node.arguments.forEach((arg, index) => {
+			argumentCases.push(`case ${quote(`${node.id}:${index}`)}\n ${print([String(spec(arg.value, arg.description)), arg.variadic ? "1" : "0"])}`);
+		});
+		for (const child of node.children) for (const name of child.names) childCases.push(literalCase(`${node.id}:${name}`, [String(child.id)]));
+		commandCases.push(`case ${node.id}\n ${node.children.filter((c) => c.visible).map((c) => described(c.names, c.description)).join("\n ") || "return 0"}`);
+		flagCases.push(`case ${node.id}\n ${node.options.filter((o) => o.visible && o.flags.length > 0).map((o) => described(o.flags, o.description)).join("\n ") || "return 0"}`);
+	}
+	const helper = (name, key, cases, fallback = []) => `function ${prefix}_${name}\n switch "${key}"\n ${cases.join("\n ")}\n case '*'\n ${print(fallback)}\n end\nend`;
+	const literalHelper = (name, cases, fallback) => `function ${prefix}_${name}\n ${cases.join("\n ")}\n ${print(fallback)}\nend`;
+	return `# Generated by commander-static-completion. Requires Fish 4+.\n${[
+		helper("settings", "$argv[1]", nodes.map((node) => `case ${node.id}\n ${print([
+			node.passThrough ? "1" : "0",
+			node.negativeNumbers ? "1" : "0",
+			node.positional ? "1" : "0",
+			String(node.defaultCommand)
+		])}`)),
+		literalHelper("local_option", localCases, [
+			"unknown",
+			"-1",
+			"0"
+		]),
+		literalHelper("option", optionCases, [
+			"unknown",
+			"-1",
+			"0"
+		]),
+		helper("argument", "$argv[1]:$argv[2]", argumentCases, ["-1", "0"]),
+		literalHelper("child", childCases, ["-1"]),
+		helper("commands", "$argv[1]", commandCases),
+		helper("flags", "$argv[1]", flagCases),
+		helper("values", "$argv[1]", specs.map((s, i) => `case ${i}\n ${described(s.hint.kind === "choices" ? s.hint.values : [], s.description)}`)),
+		helper("kind", "$argv[1]", specs.map((s, i) => `case ${i}\n ${print([s.hint.kind])}`), ["none"])
+	].join("\n\n")}\n${fishRuntime.replaceAll("__PREFIX__", prefix)}\n# Replace this command's registration; leave other commands untouched.\ncomplete -e -- ${quote(executable)}\ncomplete -f -k -a '(${prefix})' -- ${quote(executable)}\n`;
+}
+//#endregion
+//#region node_modules/commander-static-completion/dist/validation.js
+/** Insertable text must survive shell strings and completion record formats. */
+function validateText(value, label, shell) {
+	if (typeof value !== "string" || value.length === 0) throw new TypeError(`${label} must be a nonempty string.`);
+	if (value.includes("\0")) throw new TypeError(`${label} cannot contain NUL.`);
+	if (shell === "fish" && /[\t\r\n]/u.test(value)) throw new TypeError(`${label} cannot contain tabs or newlines: Fish uses them as completion record delimiters.`);
+	if (/[\x01-\x1f\x7f-\x9f]/u.test(value)) throw new TypeError(`${label} cannot contain control characters.`);
+}
+function validateModel(nodes, shell) {
+	for (const node of nodes) {
+		for (const child of node.children) for (const name of child.names) validateText(name, `Command name or alias ${JSON.stringify(name)}`, shell);
+		for (const option of node.localOptions) {
+			for (const flag of option.flags) validateText(flag, `Option flag ${JSON.stringify(flag)}`, shell);
+			if (option.value.kind === "choices") for (const [index, value] of option.value.values.entries()) validateText(value, `Choice ${index + 1} for option ${JSON.stringify(option.flags.join(", "))}`, shell);
+		}
+		for (const [index, argument] of node.arguments.entries()) if (argument.value.kind === "choices") for (const [choice, value] of argument.value.values.entries()) validateText(value, `Choice ${choice + 1} for argument ${index + 1} in command ${node.id}`, shell);
+	}
+}
+//#endregion
+//#region node_modules/commander-static-completion/dist/index.js
+/** Attach static completion metadata without changing Commander parsing. */
+function completionHint(target, hint) {
+	if (!hint || ![
+		"file",
+		"directory",
+		"none",
+		"choices"
+	].includes(hint.kind)) throw new TypeError("Expected a file, directory, none, or choices completion hint.");
+	if (hint.kind === "choices" && (!Array.isArray(hint.values) || [...hint.values].some((value) => typeof value !== "string"))) throw new TypeError("Completion choices must be an array of strings.");
+	hints.set(target, hint.kind === "choices" ? {
+		kind: hint.kind,
+		values: [...hint.values]
+	} : { kind: hint.kind });
+	return target;
+}
+/** Generate a standalone shell script from a fully configured command tree. */
+function generateCompletion(program, { shell, executable = program.name() }) {
+	if (![
+		"bash",
+		"zsh",
+		"fish"
+	].includes(shell)) throw new Error(`Unsupported shell: ${shell}. Expected bash, zsh, or fish.`);
+	validateText(executable, "executable name", shell);
+	if (/\s/u.test(executable)) throw new TypeError("Provide an executable name without whitespace.");
+	const name = "_csc_" + createHash("sha256").update(`${shell}:${executable}`).digest("hex").slice(0, 16);
+	const nodes = extract(program);
+	validateModel(nodes, shell);
+	return shell === "fish" ? renderFish(nodes, executable, name) : renderBourne(nodes, executable, name, shell);
+}
+//#endregion
 //#region package.json
-var version = "0.1.0";
+var version = "0.1.1";
 //#endregion
 //#region src/server/comments/anchor.ts
 function splitLines(contents) {
@@ -3143,11 +4096,9 @@ const CONFIG_ARGS = [
 	"core.quotePath=false"
 ];
 /** Fixed header prefixes and no `diff.external`, so a patch is always a unified diff. */
-const PATCH_ARGS = [
-	"--no-ext-diff",
-	"--src-prefix=a/",
-	"--dst-prefix=b/"
-];
+function patchArgs(oldRev) {
+	return ["--no-ext-diff", ...oldRev === "worktree" ? ["--src-prefix=b/", "--dst-prefix=a/"] : ["--src-prefix=a/", "--dst-prefix=b/"]];
+}
 /** An idle `cat-file --batch` is reaped after this long; the next request respawns one. */
 const CAT_FILE_IDLE_MS = 2e3;
 var GitError = class extends Error {
@@ -3208,7 +4159,7 @@ var GitRepo = class GitRepo {
 		])).toString("utf8").trim().split("\n");
 		if (!root || !gitDir) throw new GitError(`not a git repository: ${dir}`, [], 128, "");
 		const commonDir = common ? resolve(root, common) : gitDir;
-		return new GitRepo(root, gitDir, commonDir);
+		return new GitRepo(resolve(root), resolve(gitDir), commonDir);
 	}
 	exec(args, opts = {}) {
 		return execGit(this.root, args, opts);
@@ -3302,6 +4253,53 @@ var GitRepo = class GitRepo {
 		} catch {}
 		throw new GitError("cannot determine default branch; pass a base explicitly", [], null, "");
 	}
+	/** Full ref for an exact branch; expressions, worktree, and detached HEAD have none. */
+	async branchRef(rev) {
+		if (rev === "worktree") return null;
+		let ref;
+		try {
+			ref = (await this.text(rev === "HEAD" ? [
+				"symbolic-ref",
+				"--quiet",
+				"HEAD"
+			] : [
+				"rev-parse",
+				"--symbolic-full-name",
+				"--verify",
+				"--end-of-options",
+				rev
+			])).trim();
+		} catch (e) {
+			if (e instanceof GitError) return null;
+			throw e;
+		}
+		return ref.startsWith("refs/heads/") || ref.startsWith("refs/remotes/") ? ref : null;
+	}
+	/** Remote branch identity for an exact local/remote branch; expressions and detached HEAD have none. */
+	async upstreamBranch(rev) {
+		const ref = await this.branchRef(rev);
+		if (!ref) return null;
+		if (ref.startsWith("refs/heads/")) {
+			const [remote, upstream] = (await this.text([
+				"for-each-ref",
+				"--format=%(upstream:remotename)%00%(upstream:remoteref)%00",
+				ref
+			])).split("\0");
+			if (!remote || remote === "." || !upstream?.startsWith("refs/heads/")) return null;
+			return {
+				remote,
+				branch: upstream.slice(11)
+			};
+		}
+		if (ref.startsWith("refs/remotes/")) {
+			const remote = (await this.remotes()).sort((a, b) => b.name.length - a.name.length).find((r) => ref.startsWith(`refs/remotes/${r.name}/`));
+			if (remote) return {
+				remote: remote.name,
+				branch: ref.slice(`refs/remotes/${remote.name}/`.length)
+			};
+		}
+		return null;
+	}
 	/** Configured remotes, in git's order, with their fetch URLs. */
 	async remotes() {
 		const out = await this.text([
@@ -3368,7 +4366,9 @@ var GitRepo = class GitRepo {
 	* blob; the worktree's blobs are hashed from disk.
 	*/
 	async numstat(oldRev, newRev) {
-		const range = newRev === "worktree" ? [oldRev] : [oldRev, newRev];
+		if (oldRev === "worktree" && newRev === "worktree") return [];
+		const reverse = oldRev === "worktree";
+		const range = diffRange(oldRev, newRev);
 		const [diff, untracked] = await Promise.all([this.exec([
 			"diff",
 			"-z",
@@ -3377,13 +4377,13 @@ var GitRepo = class GitRepo {
 			"--no-abbrev",
 			"--numstat",
 			...range
-		]), newRev === "worktree" ? this.untracked() : Promise.resolve([])]);
+		]), [oldRev, newRev].includes("worktree") ? this.untracked() : Promise.resolve([])]);
 		const files = parseRawNumstat(diff);
-		const known = new Set(files.map((f) => f.path));
+		const known = new Set(files.flatMap((f) => [f.path, ...f.oldPath ? [f.oldPath] : []]));
 		const extra = await mapLimit(untracked.filter((p) => !known.has(p) && !p.endsWith("/")), READ_CONCURRENCY$1, async (path) => {
 			const file = {
 				path,
-				status: "A",
+				status: reverse ? "D" : "A",
 				additions: 0,
 				deletions: 0,
 				binary: false,
@@ -3397,7 +4397,10 @@ var GitRepo = class GitRepo {
 			};
 			const buf = await this.readWorktree(path).catch(() => null) ?? Buffer.alloc(0);
 			file.binary = isBinary(buf);
-			if (!file.binary) file.additions = countLines(buf);
+			if (!file.binary) {
+				if (reverse) file.deletions = countLines(buf);
+				else file.additions = countLines(buf);
+			}
 			return file;
 		});
 		const all = [...files, ...extra].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
@@ -3566,21 +4569,28 @@ var GitRepo = class GitRepo {
 	* `untracked` when the caller already knows, else an added file is probed.
 	*/
 	async patch(oldRev, newRev, file, context = 3, untracked) {
-		if (newRev === "worktree" && file.status === "A" && (untracked ?? !await this.isTracked(file.path))) return (await this.text([
-			"diff",
-			"--no-index",
-			...PATCH_ARGS,
-			`-U${context}`,
-			"--",
-			"/dev/null",
-			file.path
-		], { okCodes: [0, 1] })).replace(/^diff --git "?a\/dev\/null"? ("?)b\/(.*)$/m, (_m, q, rest) => `diff --git ${q}a/${rest} ${q}b/${rest}`);
-		const range = newRev === "worktree" ? [oldRev] : [oldRev, newRev];
+		if (oldRev === "worktree" && newRev === "worktree") return "";
+		const reverse = oldRev === "worktree";
+		if ((reverse ? file.status === "D" : newRev === "worktree" && file.status === "A") && (untracked ?? !await this.isTracked(file.path))) {
+			const out = await this.text([
+				"diff",
+				"--no-index",
+				...reverse ? ["-R"] : [],
+				...patchArgs(oldRev),
+				`-U${context}`,
+				"--",
+				"/dev/null",
+				file.path
+			], { okCodes: [0, 1] });
+			if (reverse) return out.replace(/^diff --git ("?)a\/(.*) "?b\/dev\/null"?$/m, (_m, q, rest) => `diff --git ${q}a/${rest} ${q}b/${rest}`);
+			return out.replace(/^diff --git "?a\/dev\/null"? ("?)b\/(.*)$/m, (_m, q, rest) => `diff --git ${q}a/${rest} ${q}b/${rest}`);
+		}
+		const range = diffRange(oldRev, newRev);
 		const paths = file.oldPath ? [file.oldPath, file.path] : [file.path];
 		return this.text([
 			"diff",
 			"-M",
-			...PATCH_ARGS,
+			...patchArgs(oldRev),
 			`-U${context}`,
 			...range,
 			"--",
@@ -3589,17 +4599,18 @@ var GitRepo = class GitRepo {
 	}
 	/** Patches for all changed files. Tracked files in one call; untracked appended. */
 	async patchAll(oldRev, newRev, files, context = 3) {
-		const range = newRev === "worktree" ? [oldRev] : [oldRev, newRev];
+		if (oldRev === "worktree" && newRev === "worktree") return "";
+		const range = diffRange(oldRev, newRev);
 		const tracked = this.text([
 			"diff",
 			"-M",
-			...PATCH_ARGS,
+			...patchArgs(oldRev),
 			`-U${context}`,
 			...range
 		]);
 		let untracked = [];
-		if (newRev === "worktree") {
-			const added = files.filter((f) => f.status === "A" && !f.binary);
+		if ([oldRev, newRev].includes("worktree")) {
+			const added = files.filter((f) => f.status === (oldRev === "worktree" ? "D" : "A") && !f.binary);
 			if (added.length) {
 				const known = new Set(await this.lsFiles());
 				untracked = added.filter((f) => !known.has(f.path));
@@ -3613,14 +4624,15 @@ var GitRepo = class GitRepo {
 	* (`patch` probes whether they are untracked). The caller bounds the batch, so the paths ride argv.
 	*/
 	async patchMany(oldRev, newRev, files, context = 3) {
-		const single = newRev === "worktree" ? files.filter((f) => f.status === "A") : [];
+		if (oldRev === "worktree" && newRev === "worktree") return "";
+		const single = [oldRev, newRev].includes("worktree") ? files.filter((f) => f.status === (oldRev === "worktree" ? "D" : "A")) : [];
 		const batched = files.filter((f) => !single.includes(f));
-		const range = newRev === "worktree" ? [oldRev] : [oldRev, newRev];
+		const range = diffRange(oldRev, newRev);
 		const paths = batched.flatMap((f) => f.oldPath ? [f.oldPath, f.path] : [f.path]);
 		const tracked = batched.length ? this.text([
 			"diff",
 			"-M",
-			...PATCH_ARGS,
+			...patchArgs(oldRev),
 			`-U${context}`,
 			...range,
 			"--",
@@ -4050,6 +5062,10 @@ function countLines(buf) {
 	if (buf[buf.length - 1] !== 10) n++;
 	return n;
 }
+/** Git reverses the commit-to-worktree diff when the worktree is the old endpoint. */
+function diffRange(oldRev, newRev) {
+	return oldRev === "worktree" ? ["-R", newRev] : newRev === "worktree" ? [oldRev] : [oldRev, newRev];
+}
 //#endregion
 //#region src/server/github.ts
 /** A precondition the user can fix (no gh, no PR, wrong mode, unpushed head): the route answers 4xx. */
@@ -4134,42 +5150,33 @@ function repoOfPrUrl(url) {
 		repo: m[2]
 	};
 }
-/** Owns one server's export queue so overlapping requests cannot add the same thread twice. */
+/** Serializes validation and writes so overlapping exports cannot add the same thread twice. */
 var GithubExporter = class {
 	queue = Promise.resolve();
-	export(input) {
-		const result = this.queue.then(() => exportToGithub(input));
+	export(prepare) {
+		const result = this.queue.then(async () => exportToGithub(await prepare()));
 		this.queue = result.catch(() => {});
 		return result;
 	}
 };
 /**
-* Adds the threads to a *pending* review on the PR of the checked-out branch, creating
-* the pending review when there is none. The review is never submitted: the human opens
-* the PR and submits it themselves. Refuses when the new side is not the checked-out
-* commit: GitHub anchors comments to a commit, and only HEAD is what the PR shows.
+* Adds the threads to a *pending* review on the active PR, creating the pending review
+* when there is none. The review is never submitted: the human opens the PR and submits
+* it themselves. The caller validates the comparison inside the export queue before posting.
 *
 * Re-exporting matches a hidden thread ID and its anchor in the pending review.
 * A matching comment is left alone when its body matches and rewritten when it does not, so
 * editing a thread and exporting again does not stack a second comment on the line. Comments
 * of an already-submitted review are out of reach — those would have to be replied to.
 */
-async function exportToGithub({ snap, threads, threadIds, run = runGh }) {
-	if (snap.newSha === "worktree") throw new GithubError("GitHub cannot anchor comments to uncommitted lines; commit and review the commit (pr or a revspec ending at HEAD)");
-	if (snap.headSha === "" || snap.newSha !== snap.headSha) throw new GithubError("the new side must be the checked-out commit (HEAD) to post to its pull request");
+async function exportToGithub({ snap, pullRequest: pr, threads, threadIds, run = runGh }) {
+	if (snap.newSha === "worktree") throw new GithubError("GitHub cannot anchor comments to the worktree");
 	const { review, ids, skipped } = buildReview(threads, snap.newSha, threadIds);
 	if (review.comments.length === 0) throw new GithubError(skipped.length ? `nothing to post: ${describe(skipped)}` : "nothing to post", 400);
-	const pr = parsePr(await run([
-		"pr",
-		"view",
-		"--json",
-		"number,url,headRefOid"
-	], { cwd: snap.root }));
-	if (pr.headRefOid !== snap.newSha) throw new GithubError(`the pull request head is ${pr.headRefOid.slice(0, 7)} but HEAD is ${snap.newSha.slice(0, 7)}; push first`);
 	for (const [i, comment] of review.comments.entries()) comment.body += `\n\n${threadMarker(ids[i])}`;
 	const pending = await findPendingReview(run, snap.root, pr);
 	if (!pending) {
-		await createPendingReview(run, snap.root, pr.number, review);
+		await createPendingReview(run, snap.root, pr.repository, pr.number, review);
 		return {
 			url: pr.url,
 			posted: review.comments.length,
@@ -4308,12 +5315,12 @@ async function pendingComments(run, cwd, pr, reviewId) {
 }
 const UPDATE_COMMENT = `mutation($input:UpdatePullRequestReviewCommentInput!){updatePullRequestReviewComment(input:$input){pullRequestReviewComment{id}}}`;
 /** No `event` in the body, so GitHub keeps the new review pending with all of its comments. */
-async function createPendingReview(run, cwd, number, review) {
+async function createPendingReview(run, cwd, repository, number, review) {
 	await run([
 		"api",
 		"--method",
 		"POST",
-		`repos/{owner}/{repo}/pulls/${number}/reviews`,
+		`repos/${repository}/pulls/${number}/reviews`,
 		"--input",
 		"-"
 	], {
@@ -4365,21 +5372,12 @@ function describe(skipped) {
 	for (const s of skipped) counts.set(s.reason, (counts.get(s.reason) ?? 0) + 1);
 	return [...counts].map(([reason, n]) => `${n} ${reason}`).join(", ");
 }
-function parsePr(out) {
-	let pr;
-	try {
-		pr = JSON.parse(out);
-	} catch {
-		throw new GithubError(`unexpected output from gh pr view: ${out.slice(0, 200)}`, 502);
-	}
-	if (typeof pr.number !== "number" || typeof pr.url !== "string" || typeof pr.headRefOid !== "string") throw new GithubError(`unexpected output from gh pr view: ${out.slice(0, 200)}`, 502);
-	return pr;
-}
 /** Spawns the local `gh`. A missing binary or a failing command becomes a GithubError carrying gh's own message. */
-const runGh = (args, { cwd, input }) => new Promise((resolve, reject) => {
+const runGh = (args, { cwd, input, timeoutMs }) => new Promise((resolve, reject) => {
 	const child = execFile("gh", args, {
 		cwd,
-		maxBuffer: 16777216
+		maxBuffer: 16777216,
+		timeout: timeoutMs
 	}, (err, stdout, stderr) => {
 		if (!err) return resolve(stdout);
 		if (err.code === "ENOENT") return reject(new GithubError("gh is not installed; see https://cli.github.com"));
@@ -4389,20 +5387,55 @@ const runGh = (args, { cwd, input }) => new Promise((resolve, reject) => {
 	if (input != null) child.stdin?.end(input);
 	else child.stdin?.end();
 });
-const PR_FIELDS = "number,url,baseRefName,headRefName,headRefOid";
+const PR_FIELDS = "number,url,title,state,isDraft,baseRefOid,baseRefName,headRefName,headRefOid,headRepository,headRepositoryOwner";
 /**
 * `gh pr view` for a PR named by number, `#number`, URL or branch. Without a
 * selector, the PR of the checked-out branch. Option-shaped selectors are
 * refused so a stray flag never reaches gh.
 */
-async function viewPr(selector, cwd, run = runGh) {
-	return parsePrView(await run([
+async function viewPr(selector, cwd, run = runGh, timeoutMs) {
+	return parsePullRequest(parseJson(await run([
 		"pr",
 		"view",
 		...selector == null ? [] : [normalizeSelector(selector)],
 		"--json",
 		PR_FIELDS
-	], { cwd }));
+	], {
+		cwd,
+		timeoutMs
+	}), "view"));
+}
+/** Open pull requests whose head is the named branch in the named remote repository. */
+async function listPrsForHead(baseRepo, base, head, headRepo, cwd, run = runGh, timeoutMs) {
+	const out = await run([
+		"pr",
+		"list",
+		"--repo",
+		baseRepo,
+		"--base",
+		base,
+		"--head",
+		head,
+		"--state",
+		"open",
+		"--limit",
+		"100",
+		"--json",
+		PR_FIELDS
+	], {
+		cwd,
+		timeoutMs
+	});
+	const values = parseJson(out, "list");
+	if (!Array.isArray(values)) throw new GithubError(`unexpected output from gh pr list: ${out.slice(0, 200)}`, 502);
+	return values.flatMap((value) => {
+		const candidate = value;
+		const owner = candidate?.headRepositoryOwner?.login;
+		const name = candidate?.headRepository?.name;
+		if (typeof owner !== "string" || typeof name !== "string") throw new GithubError(`unexpected output from gh pr list: ${out.slice(0, 200)}`, 502);
+		if (`${owner}/${name}`.toLowerCase() !== headRepo.toLowerCase()) return [];
+		return [parsePullRequest(value)];
+	});
 }
 function normalizeSelector(selector) {
 	const s = selector.trim();
@@ -4410,23 +5443,46 @@ function normalizeSelector(selector) {
 	const num = /^#?(\d+)$/.exec(s);
 	return num ? num[1] : s;
 }
-function parsePrView(out) {
-	let pr;
+function parseJson(out, command) {
 	try {
-		pr = JSON.parse(out);
+		return JSON.parse(out);
 	} catch {
-		throw new GithubError(`unexpected output from gh pr view: ${out.slice(0, 200)}`, 502);
+		throw new GithubError(`unexpected output from gh pr ${command}: ${out.slice(0, 200)}`, 502);
 	}
-	if (!(typeof pr.number === "number" && typeof pr.url === "string" && typeof pr.baseRefName === "string" && typeof pr.headRefName === "string" && typeof pr.headRefOid === "string")) throw new GithubError(`unexpected output from gh pr view: ${out.slice(0, 200)}`, 502);
+}
+function parsePullRequest(value) {
+	const pr = value;
+	if (!(pr != null && typeof pr.title === "string" && [
+		"OPEN",
+		"CLOSED",
+		"MERGED"
+	].includes(pr.state ?? "") && typeof pr.isDraft === "boolean" && typeof pr.baseRefOid === "string" && typeof pr.number === "number" && typeof pr.url === "string" && typeof pr.baseRefName === "string" && typeof pr.headRefName === "string" && typeof pr.headRefOid === "string")) throw new GithubError("unexpected pull request data from gh", 502);
 	const slug = /^https?:\/\/[^/]+\/([^/]+\/[^/]+)\/pull\/\d+/.exec(pr.url);
 	if (!slug) throw new GithubError(`cannot read the repository from the pull request url: ${pr.url}`, 502);
+	const source = value;
+	const owner = source.headRepositoryOwner?.login;
+	const name = source.headRepository?.name;
 	return {
-		...pr,
-		baseRepo: slug[1]
+		headRepository: typeof owner === "string" && typeof name === "string" ? `${owner}/${name}` : null,
+		number: pr.number,
+		url: pr.url,
+		title: pr.title,
+		state: pr.state,
+		isDraft: pr.isDraft,
+		repository: slug[1],
+		baseRefOid: pr.baseRefOid,
+		baseRefName: pr.baseRefName,
+		headRefName: pr.headRefName,
+		headRefOid: pr.headRefOid
 	};
 }
 //#endregion
 //#region src/shared/protocol.ts
+/** Display comparison endpoints with branch names instead of internal ref namespaces. */
+function comparisonLabel(mode) {
+	const name = (rev) => rev.replace(/^refs\/diffle\/[^/]+\/\d+\/(?:base|head)\//, "").replace(/^refs\/(?:heads|remotes)\//, "");
+	return `${name(mode.old)}${mode.mergeBase ? "..." : ".."}${name(mode.new)}`;
+}
 const DEFAULT_USER_CONFIG = {
 	autoViewed: [],
 	contextLines: 5,
@@ -4756,13 +5812,6 @@ const DEFAULT_TOKEN_TYPES = [
 	"operator",
 	"decorator"
 ];
-/**
-* pyrefly reports nothing about its workspace index over the protocol (no
-* `$/progress`, even when asked) but logs it on stderr at the default level.
-* Other servers never match and simply never report indexing.
-*/
-const INDEX_START = /Populating up to \d+ files in the workspace/;
-const INDEX_DONE = /Populated all files in the workspace/;
 const INIT_TIMEOUT_MS = 6e4;
 /**
 * Navigation opens whatever file a query lands in. Without a cap every path
@@ -4794,8 +5843,7 @@ var LspBridge = class LspBridge {
 	current;
 	ready;
 	stderr = "";
-	/** Partial last stderr line, so a log phrase split across chunks still matches. */
-	stderrTail = "";
+	progress = /* @__PURE__ */ new Map();
 	/** Open documents, least recently synced first. */
 	open = /* @__PURE__ */ new Map();
 	/** Syncs in flight by path, so a track pass and a query racing on one file send a single didOpen. */
@@ -5088,7 +6136,10 @@ var LspBridge = class LspBridge {
 		child.stderr?.on("data", (d) => {
 			const chunk = d.toString("utf8");
 			this.stderr = (this.stderr + chunk).slice(-2e3);
-			this.noteIndexing(chunk);
+			if (!this.closing && this.current.state !== "unavailable") this.set({
+				...this.current,
+				stderr: this.stderr.trim()
+			});
 		});
 		child.on("error", (e) => this.fail(`cannot start "${this.opts.command}": ${e.message}`));
 		child.on("exit", (code, signal) => {
@@ -5101,6 +6152,7 @@ var LspBridge = class LspBridge {
 		}
 		const rpc = new JsonRpcConnection(child.stdout, child.stdin);
 		this.rpc = rpc;
+		rpc.onNotification((method, params) => this.noteWorkspace(method, params));
 		const rootUri = pathToFileURL(this.opts.root).href;
 		try {
 			const legend = (await rpc.request("initialize", {
@@ -5113,6 +6165,7 @@ var LspBridge = class LspBridge {
 					name: "workspace"
 				}],
 				capabilities: {
+					window: { workDoneProgress: true },
 					textDocument: {
 						synchronization: { didSave: false },
 						definition: { linkSupport: true },
@@ -5144,15 +6197,39 @@ var LspBridge = class LspBridge {
 			state: "ready"
 		});
 	}
-	noteIndexing(chunk) {
-		const text = this.stderrTail + chunk;
-		const nl = text.lastIndexOf("\n");
-		this.stderrTail = nl === -1 ? text.slice(-200) : text.slice(nl + 1);
-		const indexing = INDEX_DONE.test(text) ? false : INDEX_START.test(text) ? true : null;
-		if (indexing == null || this.current.state !== "ready" || this.current.indexing === indexing) return;
+	noteWorkspace(method, params) {
+		if (!params || typeof params !== "object" || this.closing || this.current.state === "unavailable") return;
+		const p = params;
+		if (method === "window/showMessage" || method === "window/logMessage" || method === "window/showMessageRequest") {
+			if (p.type !== 1 && p.type !== 2 || typeof p.message !== "string" || !p.message.trim()) return;
+			const notice = {
+				severity: p.type === 1 ? "error" : "warning",
+				message: p.message
+			};
+			if (notice.severity !== this.current.notice?.severity || notice.message !== this.current.notice?.message) this.set({
+				...this.current,
+				notice
+			});
+			return;
+		}
+		if (method !== "$/progress" || typeof p.token !== "string" && typeof p.token !== "number") return;
+		if (!p.value || typeof p.value !== "object") return;
+		const { kind, title, message, percentage } = p.value;
+		const percent = typeof percentage === "number" && percentage >= 0 && percentage <= 100 ? percentage : void 0;
+		if (kind === "begin" && typeof title === "string") this.progress.set(p.token, {
+			title,
+			message: typeof message === "string" ? message : void 0,
+			percentage: percent
+		});
+		else if (kind === "report" && this.progress.has(p.token)) {
+			if (typeof message === "string") this.progress.get(p.token).message = message;
+			if (percent !== void 0) this.progress.get(p.token).percentage = percent;
+		} else if (kind === "end") {
+			if (!this.progress.delete(p.token)) return;
+		} else return;
 		this.set({
 			...this.current,
-			indexing
+			activity: [...this.progress.values()].map((p) => `${p.title}${p.percentage == null ? "" : ` (${p.percentage}%)`}${p.message ? `: ${p.message}` : ""}`)
 		});
 	}
 	fail(message) {
@@ -5166,6 +6243,7 @@ var LspBridge = class LspBridge {
 		this.rpc?.dispose(new LspUnavailableError(message));
 	}
 	set(status) {
+		if (JSON.stringify(status) === JSON.stringify(this.current)) return;
 		this.current = status;
 		this.opts.onStatus(status);
 	}
@@ -5190,7 +6268,17 @@ var LspBridge = class LspBridge {
 		for (let attempt = 0;; attempt++) {
 			const rpc = path == null ? await this.ensureReady() : await this.sync(path);
 			try {
-				return await rpc.request(method, params);
+				const pending = busyReason(this.current);
+				const result = await rpc.request(method, params);
+				if (result == null || Array.isArray(result) && !result.length) {
+					const busy = busyReason(this.current) ?? pending;
+					if (busy) throw new LspUnavailableError(busy);
+					if (this.current.notice) {
+						const { severity, message } = this.current.notice;
+						throw new LspUnavailableError(`${this.current.name} returned no result; last server ${severity}: ${message}`);
+					}
+				}
+				return result;
 			} catch (e) {
 				if (!(e instanceof JsonRpcError) || e.code !== CONTENT_MODIFIED) throw e;
 				const backoff = CONTENT_MODIFIED_BACKOFF_MS[attempt];
@@ -5374,9 +6462,15 @@ function programName(command) {
 	const prog = argv0(command);
 	return prog.split(/[\\/]/).pop() || prog;
 }
+/**
+* Canonical `p`, or `p` itself when it cannot be resolved. Uses libuv's
+* realpath, the same one the async `realpath` in `pathOf` uses: the JS
+* `realpathSync` keeps a Windows 8.3 short name (`RUNNER~1`) that libuv
+* expands, and the two answers would never compare equal.
+*/
 function safeRealpathSync(p) {
 	try {
-		return realpathSync(p);
+		return realpathSync.native(p);
 	} catch {
 		return p;
 	}
@@ -5417,6 +6511,11 @@ function lastLine(s) {
 	const lines = s.trim().split("\n");
 	return lines[lines.length - 1] ?? "";
 }
+/** Why an empty result may be incomplete while the server reports background work. */
+function busyReason(s) {
+	const work = s.activity?.length ? s.activity.join("; ") : null;
+	return work ? `${s.name} is busy: ${work}; try again when it finishes` : null;
+}
 //#endregion
 //#region src/server/lsp/registry.ts
 /**
@@ -5722,7 +6821,7 @@ var LspPool = class {
 };
 //#endregion
 //#region src/server/revspec.ts
-/** The uncommitted new side, spelled as a revision so every form can name it. */
+/** The uncommitted tree, accepted on either side of a comparison. */
 const WORKTREE = "worktree";
 /**
 * git-diff style revision arguments:
@@ -5739,58 +6838,33 @@ function parseRevspec(args) {
 		const [a, b] = args;
 		if (a.includes("..") || b.includes("..")) throw new RevspecError("cannot combine \"..\" with two revisions");
 		return {
-			old: {
-				kind: "rev",
-				rev: a
-			},
-			newRev: b,
-			label: `${a}..${b}`
+			old: a,
+			new: b,
+			mergeBase: false
 		};
 	}
 	const arg = args[0];
 	const three = arg.indexOf("...");
-	if (three !== -1) {
-		const a = arg.slice(0, three) || "HEAD";
-		const b = arg.slice(three + 3) || "HEAD";
-		return {
-			old: {
-				kind: "merge-base",
-				a,
-				b: b === WORKTREE ? "HEAD" : b
-			},
-			newRev: b,
-			label: `${a}...${b}`
-		};
-	}
+	if (three !== -1) return {
+		old: arg.slice(0, three) || "HEAD",
+		new: arg.slice(three + 3) || "HEAD",
+		mergeBase: true
+	};
 	const two = arg.indexOf("..");
-	if (two !== -1) {
-		const a = arg.slice(0, two) || "HEAD";
-		const b = arg.slice(two + 2) || "HEAD";
-		return {
-			old: {
-				kind: "rev",
-				rev: a
-			},
-			newRev: b,
-			label: `${a}..${b}`
-		};
-	}
+	if (two !== -1) return {
+		old: arg.slice(0, two) || "HEAD",
+		new: arg.slice(two + 2) || "HEAD",
+		mergeBase: false
+	};
 	if (arg === WORKTREE) return {
-		old: {
-			kind: "rev",
-			rev: "HEAD"
-		},
-		newRev: WORKTREE,
-		label: `HEAD..${WORKTREE}`
+		old: "HEAD",
+		new: WORKTREE,
+		mergeBase: false
 	};
 	return {
-		old: {
-			kind: "merge-base",
-			a: arg,
-			b: "HEAD"
-		},
-		newRev: "HEAD",
-		label: `${arg}...HEAD`
+		old: arg,
+		new: "HEAD",
+		mergeBase: true
 	};
 }
 var RevspecError = class extends Error {};
@@ -9086,7 +10160,6 @@ const MAX_PATCH_PATHS = 200;
 function createApi(deps) {
 	const { session, hub } = deps;
 	const app = new Hono();
-	const github = new GithubExporter();
 	app.onError((err, c) => {
 		if (err instanceof NotFoundError) return c.json({ error: "not found" }, 404);
 		if (err instanceof RevspecError || err instanceof GitError) return c.json({ error: err.message }, 400);
@@ -9106,6 +10179,10 @@ function createApi(deps) {
 		if (!isModeRequest(req)) return c.json({ error: "invalid mode request" }, 400);
 		return c.json(await session.switchMode(req));
 	});
+	app.get("/api/github", async (c) => {
+		const snap = await session.snapshotter.current();
+		return c.json(await session.github(snap));
+	});
 	app.get("/api/refs", async (c) => c.json(await session.repo.refs()));
 	app.get("/api/last-commits-preview", async (c) => {
 		const values = [c.req.query("oldOffset") ?? "", c.req.query("newOffset") ?? ""];
@@ -9235,12 +10312,7 @@ function createApi(deps) {
 	app.post("/api/github/export", async (c) => {
 		const ids = (await c.req.json().catch(() => ({}))).threadIds;
 		if (ids != null && !(Array.isArray(ids) && ids.every((id) => typeof id === "string"))) return c.json({ error: "threadIds must be a string list" }, 400);
-		const snap = await session.snapshotter.current();
-		return c.json(await github.export({
-			snap,
-			threads: session.comments.threads({ state: "all" }),
-			threadIds: ids
-		}));
+		return c.json(await session.exportGithub({ threadIds: ids }));
 	});
 	app.get("/api/viewed", (c) => c.json(session.comments.viewed()));
 	app.put("/api/viewed/bulk", async (c) => {
@@ -9508,94 +10580,212 @@ function hasClientBuild() {
 	return existsSync(join(resolveClientDir(), "index.html"));
 }
 //#endregion
-//#region src/server/mode.ts
-async function resolveOrExplain(repo, rev) {
+//#region src/server/GithubMetadata.ts
+const LOOKUP_TIMEOUT_MS = 5e3;
+/** GitHub.com identity from a configured HTTPS, SSH, or scp-style remote URL. */
+function githubRepository(url) {
+	const match = /^(?:https?:\/\/github\.com\/|ssh:\/\/(?:[^/@]+@)?github\.com(?::\d+)?\/|(?:[^/@]+@)?github\.com:)([^/]+)\/([^/]+?)\/?$/i.exec(url);
+	return match ? `${match[1]}/${match[2].replace(/\.git$/i, "")}` : null;
+}
+/** Local-only origin identity; works without gh, authentication, or a network connection. */
+async function originRepository(repo) {
+	const origin = (await repo.remotes()).find((r) => r.name === "origin");
+	return origin ? githubRepository(origin.url) : null;
+}
+/** Enriches a comparison without fetching commits, changing its endpoints, or changing comment storage. */
+async function discoverGithub(repo, snap, { run = runGh, prUrl } = {}) {
+	const repository = await originRepository(repo);
+	const absent = (reason) => ({
+		version: snap.version,
+		repository,
+		pullRequest: null,
+		reason
+	});
 	try {
-		return await repo.resolve(rev);
-	} catch (e) {
-		if (e instanceof GitError) throw new RevspecError(`unknown revision: ${rev}`);
-		throw e;
+		let pr;
+		if (prUrl) pr = await viewPr(prUrl, repo.root, run, LOOKUP_TIMEOUT_MS);
+		else {
+			const [old, next, remotes] = await Promise.all([
+				repo.upstreamBranch(snap.mode.old),
+				repo.upstreamBranch(snap.mode.new),
+				repo.remotes()
+			]);
+			if (!old || !next) return absent("No branch with an upstream available for both endpoints");
+			const repository = (remote) => {
+				const url = remotes.find((r) => r.name === remote)?.url;
+				return url ? githubRepository(url) : null;
+			};
+			const baseRepo = repository(old.remote);
+			const headRepo = repository(next.remote);
+			if (!baseRepo || !headRepo) return absent("Both branches must have GitHub remotes");
+			const prs = await listPrsForHead(baseRepo, old.branch, next.branch, headRepo, repo.root, run, LOOKUP_TIMEOUT_MS);
+			if (!prs.length) return absent("No matching pull request");
+			if (prs.length !== 1) return absent("Multiple matching pull requests; open one explicitly");
+			pr = prs[0];
+		}
+		let reason = null;
+		if (pr.state !== "OPEN") reason = "The pull request is not open";
+		else if (snap.oldSha === "worktree" || snap.newSha === "worktree") reason = "GitHub cannot anchor comments to the worktree";
+		else if (snap.newSha !== pr.headRefOid) reason = "The comparison does not end at the pull request head";
+		else try {
+			if (snap.oldSha !== await repo.mergeBase(pr.baseRefOid, pr.headRefOid)) reason = "The comparison does not match the pull request diff";
+		} catch (e) {
+			if (!(e instanceof GitError)) throw e;
+			reason = "Fetch the pull request base to verify its diff";
+		}
+		return {
+			version: snap.version,
+			repository,
+			pullRequest: {
+				repository: pr.repository,
+				number: pr.number,
+				url: pr.url,
+				title: pr.title,
+				state: pr.state,
+				isDraft: pr.isDraft
+			},
+			reason
+		};
+	} catch (error) {
+		if (!(error instanceof GithubError)) throw error;
+		return absent(`Lookup failed: ${error.message}`);
 	}
 }
-async function mergeBaseOrExplain(repo, a, b) {
-	await Promise.all([resolveOrExplain(repo, a), resolveOrExplain(repo, b)]);
-	try {
-		return await repo.mergeBase(a, b);
-	} catch (e) {
-		if (e instanceof GitError) throw new RevspecError(`no merge base between ${a} and ${b}`);
-		throw e;
+//#endregion
+//#region src/server/mode.ts
+/**
+* Resolves a comparison to Git endpoints for initial mode setup, PR setup after
+* fetching, and snapshot refreshes. Revisions become full hashes; "worktree"
+* is accepted on either side and stays literal unless replaced by a merge base.
+*
+* With main at C and HEAD at E, sharing ancestor B:
+*   A--B--C  main
+*       \--D--E  HEAD
+*
+*   old       new       mergeBase   oldSha      newSha     live
+*   main      HEAD      false       C           E          refs
+*   main      HEAD      true        B           E          refs
+*   HEAD      worktree  false       E           worktree   worktree
+*   worktree  HEAD      false       worktree    E          worktree
+*   main      worktree  true        B           worktree   worktree
+*   <C hash>  <E hash>  false       C           E          none
+*
+* mergeBase replaces only the old endpoint with the common ancestor, using
+* HEAD for any worktree input. live is "worktree" if either input is worktree,
+* "none" if both inputs are pinned hashes, and "refs" otherwise.
+*
+* In an unborn repository, HEAD compared directly with worktree resolves to
+* the empty tree. Invalid revisions or missing merge bases throw RevspecError.
+*/
+async function resolveComparison(repo, comparison) {
+	const endpoints = [comparison.old, comparison.new];
+	const resolve = async (rev) => {
+		if (rev === "worktree") return rev;
+		try {
+			return await repo.resolve(rev);
+		} catch (e) {
+			if (!comparison.mergeBase && rev === "HEAD" && endpoints.includes("worktree") && e instanceof GitError && e.code === 1) return repo.emptyTree();
+			if (e instanceof GitError) throw new RevspecError(`unknown revision: ${rev}`);
+			throw e;
+		}
+	};
+	const [old, next] = await Promise.all([resolve(comparison.old), resolve(comparison.new)]);
+	let oldSha = old;
+	if (comparison.mergeBase) {
+		const [a, b] = await Promise.all([old === "worktree" ? resolve("HEAD") : old, next === "worktree" ? resolve("HEAD") : next]);
+		try {
+			oldSha = await repo.mergeBase(a, b);
+		} catch (e) {
+			if (e instanceof GitError) throw new RevspecError(`no merge base between ${comparison.old} and ${comparison.new}`);
+			throw e;
+		}
 	}
+	const pinned = (rev, sha) => rev.length >= 7 && sha.startsWith(rev.toLowerCase());
+	return {
+		oldSha,
+		newSha: next,
+		live: endpoints.includes("worktree") ? "worktree" : pinned(comparison.old, old) && pinned(comparison.new, next) ? "none" : "refs"
+	};
 }
-function isShaPrefix(rev, sha) {
-	return rev.length >= 7 && sha.startsWith(rev.toLowerCase());
+/** Resolves an input command into a comparison and optional explicit PR identity. */
+async function resolveReview(req, repo, gh = runGh) {
+	if (req.kind === "pr") return resolvePr(req, repo, gh);
+	const parsed = req.kind === "working" ? {
+		old: "HEAD",
+		new: "worktree",
+		mergeBase: false
+	} : parseRevspec(req.args);
+	const { oldSha, newSha, live } = await resolveComparison(repo, parsed);
+	return { mode: {
+		...parsed,
+		live,
+		commentKey: req.kind === "working" ? "working" : await commentKey(repo, parsed, oldSha, newSha)
+	} };
 }
-/** Resolves a ModeRequest into a ModeSpec, including the comment key. */
-async function resolveMode(req, repo, gh = runGh) {
-	switch (req.kind) {
-		case "working": return {
-			kind: "working",
-			request: req,
-			old: {
-				kind: "rev",
-				rev: "HEAD"
-			},
-			newRev: "worktree",
-			label: "HEAD → worktree",
-			live: "worktree",
-			commentKey: "working"
-		};
-		case "pr": return resolvePr(req, repo, gh);
-		case "revspec": {
-			const parsed = parseRevspec(req.args);
-			const oldSha = parsed.old.kind === "rev" ? await resolveOrExplain(repo, parsed.old.rev) : await mergeBaseOrExplain(repo, parsed.old.a, parsed.old.b);
-			let live = "none";
-			let newKey = parsed.newRev;
-			if (parsed.newRev === "worktree") live = "worktree";
-			else {
-				const sha = await resolveOrExplain(repo, parsed.newRev);
-				if (!isShaPrefix(parsed.newRev, sha)) live = "refs";
-				newKey = sha;
-			}
-			return {
-				kind: "revspec",
-				request: req,
-				old: parsed.old,
-				newRev: parsed.newRev,
-				label: parsed.label,
-				live,
-				commentKey: `revspec:${oldSha}..${newKey}`
-			};
-		}
-	}
+/**
+* Branch identities keep review state stable across pushes and local branch aliases.
+* For origin = github.com/o/r and HEAD on feat tracking origin/feat:
+*   origin/main...HEAD → branches:["o/r:main","o/r:feat",true]
+*   origin/main..HEAD  → branches:["o/r:main","o/r:feat",false]
+* The matching explicit PR uses the first key too. If feat tracks a fork,
+* its identity becomes e.g. "contributor/r:feat", keeping forks distinct.
+*
+* Without a GitHub upstream, branches use full refs:
+*   main...feat → branches:["refs/heads/main","refs/heads/feat",true]
+* Non-branch endpoints use their resolved hash or literal "worktree":
+*   main..worktree → branches:["refs/heads/main","worktree",false]
+* If neither endpoint is a branch, the key is revspec:<oldSha>..<newSha>.
+* Hash placeholders denote full resolved hashes, with oldSha already adjusted
+* for mergeBase. The working command bypasses this helper and uses "working".
+*/
+async function commentKey(repo, comparison, oldSha, newSha) {
+	const remotes = await repo.remotes();
+	const identity = async (rev) => {
+		const upstream = await repo.upstreamBranch(rev);
+		if (upstream) {
+			const url = remotes.find((remote) => remote.name === upstream.remote)?.url;
+			const repository = url && githubRepository(url);
+			if (repository) return `${repository.toLowerCase()}:${upstream.branch}`;
+		}
+		return repo.branchRef(rev);
+	};
+	const [old, next] = await Promise.all([identity(comparison.old), identity(comparison.new)]);
+	return old || next ? branchKey(old ?? oldSha, next ?? newSha, comparison.mergeBase) : `revspec:${oldSha}..${newSha}`;
+}
+function branchKey(old, next, mergeBase) {
+	return `branches:${JSON.stringify([
+		old,
+		next,
+		mergeBase
+	])}`;
 }
 /**
 * A GitHub pull request, as GitHub shows it: merge-base(base tip, head) vs head.
 * `gh` names the PR, then one fetch brings the base tip and the PR head into
-* session-owned refs, so a PR nobody has checked out is reviewable. Both
-* sides are pinned to commits, so the mode is static and the comment key follows
-* the PR number: comments survive a force-push.
+* session-owned refs named after the branches, so a PR nobody has checked out
+* is reviewable. These refs stay fixed until another fetch; review state uses
+* the same branch identities as ordinary comparisons, so comments survive
+* pushes and reopening by branch.
 */
 async function resolvePr(req, repo, gh) {
 	const pr = await viewPr(req.pr, repo.root, gh);
-	const head = `${repo.reviewRefs}/${pr.number}/head`;
-	const base = `${repo.reviewRefs}/${pr.number}/base`;
+	const head = `${repo.reviewRefs}/${pr.number}/head/${pr.headRefName}`;
+	const base = `${repo.reviewRefs}/${pr.number}/base/${pr.baseRefName}`;
 	await repo.fetch(await fetchSource(repo, pr), [`+refs/pull/${pr.number}/head:${head}`, `+refs/heads/${pr.baseRefName}:${base}`]);
-	const [headSha, mb] = await Promise.all([resolveOrExplain(repo, head), mergeBaseOrExplain(repo, base, head)]);
+	await resolveComparison(repo, {
+		old: base,
+		new: head,
+		mergeBase: true
+	});
 	return {
-		kind: "pr",
-		request: req,
-		old: {
-			kind: "rev",
-			rev: mb
-		},
-		newRev: headSha,
-		label: `#${pr.number} ${pr.baseRefName}...${pr.headRefName}`,
-		pullRequest: {
-			repository: pr.baseRepo,
-			number: pr.number
-		},
-		live: "none",
-		commentKey: `pr:#${pr.number}`
+		prUrl: pr.url,
+		mode: {
+			old: base,
+			new: head,
+			mergeBase: true,
+			live: "none",
+			commentKey: branchKey(`${pr.repository.toLowerCase()}:${pr.baseRefName}`, `${pr.headRepository?.toLowerCase() ?? `deleted:${pr.url}`}:${pr.headRefName}`, true)
+		}
 	};
 }
 /**
@@ -9603,7 +10793,7 @@ async function resolvePr(req, repo, gh) {
 * that points at it. Foreign repositories must be opened separately by the CLI.
 */
 async function fetchSource(repo, pr) {
-	const slug = pr.baseRepo.toLowerCase();
+	const slug = pr.repository.toLowerCase();
 	const match = (await repo.remotes()).find((r) => remoteSlug(r.url) === slug);
 	if (!match) throw new RevspecError(`foreign repository; open it with diffle pr ${pr.url}`);
 	return match.name;
@@ -9740,12 +10930,8 @@ var Snapshotter = class {
 		return p;
 	}
 	async compute(version) {
-		const [oldSha, newSha, headSha] = await Promise.all([
-			this.resolveOld(),
-			this.resolveNew(),
-			this.repo.resolve("HEAD").catch(() => "")
-		]);
-		const [tracked, changed] = await Promise.all([newSha === "worktree" ? this.repo.lsFiles() : this.repo.lsTree(newSha), this.repo.numstat(oldSha, newSha)]);
+		const [{ oldSha, newSha }, headSha] = await Promise.all([resolveComparison(this.repo, this.mode), this.repo.resolve("HEAD").catch(() => "")]);
+		const [tracked, changed] = await Promise.all([newSha === "worktree" ? Promise.all([this.repo.lsFiles(), this.repo.untracked()]).then((lists) => lists.flat().filter((p) => !p.endsWith("/"))) : this.repo.lsTree(newSha), this.repo.numstat(oldSha, newSha)]);
 		await this.fillGenerated(changed, newSha);
 		const tree = new Set(tracked);
 		for (const f of changed) {
@@ -9795,19 +10981,6 @@ var Snapshotter = class {
 		if (this.sniffed.size >= SNIFF_CACHE_MAX) this.sniffed.clear();
 		this.sniffed.set(f.blob, f.generated);
 	}
-	async resolveOld() {
-		const o = this.mode.old;
-		if (o.kind !== "rev") return this.repo.mergeBase(o.a, o.b);
-		try {
-			return await this.repo.resolve(o.rev);
-		} catch (e) {
-			if (o.rev === "HEAD" && e instanceof GitError && e.code === 1) return this.repo.emptyTree();
-			throw e;
-		}
-	}
-	resolveNew() {
-		return this.mode.newRev === "worktree" ? Promise.resolve("worktree") : this.repo.resolve(this.mode.newRev);
-	}
 };
 //#endregion
 //#region src/server/Session.ts
@@ -9825,6 +10998,7 @@ var Session = class {
 	hub;
 	opts;
 	active = null;
+	exporter = new GithubExporter();
 	readyPromise;
 	resolveReady;
 	rejectReady;
@@ -9853,6 +11027,48 @@ var Session = class {
 	get snapshotter() {
 		return this.require().snapshotter;
 	}
+	/** Cached independently of snapshot construction; callers never hold the transition queue. */
+	github(snap) {
+		const active = this.require();
+		if (snap.mode !== active.mode) return Promise.reject(new GithubError("Comparison changed; try again"));
+		const cached = active.github;
+		if (cached?.snapshot === snap && cached.expires > Date.now()) return cached.promise;
+		const promise = discoverGithub(this.repo, snap, {
+			run: this.opts.gh,
+			prUrl: active.prUrl
+		});
+		const entry = {
+			snapshot: snap,
+			expires: Date.now() + 3e4,
+			promise
+		};
+		active.github = entry;
+		promise.catch(() => {
+			if (active.github === entry) active.github = void 0;
+		});
+		return promise;
+	}
+	/** Validate fresh PR data inside the export queue against the current comparison. */
+	exportGithub({ threadIds }) {
+		return this.exporter.export(async () => {
+			const active = this.require();
+			const snap = await active.snapshotter.current();
+			if (active !== this.active) throw new GithubError("Comparison changed; try again");
+			const metadata = await discoverGithub(this.repo, snap, {
+				run: this.opts.gh,
+				prUrl: active.prUrl
+			});
+			if (!metadata.pullRequest || metadata.reason !== null) throw new GithubError(metadata.reason ?? "No matching pull request");
+			if (active !== this.active || snap !== await active.snapshotter.current()) throw new GithubError("Comparison changed; try again");
+			return {
+				snap,
+				pullRequest: metadata.pullRequest,
+				threads: active.comments.threads({ state: "all" }),
+				threadIds,
+				run: this.opts.gh
+			};
+		});
+	}
 	get comments() {
 		return this.require().comments;
 	}
@@ -9909,11 +11125,12 @@ var Session = class {
 		return this.run(() => this.transition(req));
 	}
 	async transition(req) {
-		const mode = await resolveMode(req, this.repo);
+		const { mode, prUrl } = await resolveReview(req, this.repo, this.opts.gh);
 		const snapshotter = new Snapshotter(this.repo, mode, ++this.version, this.opts.context);
 		const [comments, snap] = await Promise.all([CommentStore.open(this.repo.gitDir, mode.commentKey), snapshotter.current()]);
 		const next = {
 			mode,
+			prUrl,
 			snapshotter,
 			comments,
 			watcher: null
@@ -9996,7 +11213,7 @@ var Session = class {
 		const target = sidePath(this.readablePaths(snap), path, side);
 		if (target == null) return Promise.resolve(null);
 		if (side === "new") return snap.newSha === "worktree" ? this.repo.readWorktree(target) : this.repo.show(snap.newSha, target);
-		return this.repo.show(snap.oldSha, target);
+		return snap.oldSha === "worktree" ? this.repo.readWorktree(target) : this.repo.show(snap.oldSha, target);
 	}
 	/** Whether `readSide` would find `path` on `side`: the allowlist alone, no read. */
 	hasSide(snap, path, side) {
@@ -13855,6 +15072,30 @@ function watchBrowserLifetime(clients, enabled, onClose, graceMs = 1e3) {
 	};
 }
 //#endregion
+//#region src/cli/completion.ts
+const SHELLS = [
+	"bash",
+	"zsh",
+	"fish"
+];
+/**
+* Adds `diffle completion --shell <shell>`, which prints a standalone script derived from
+* this command tree. The script completes in the shell alone: tab completion never starts
+* node, so it stays fast, and it goes stale until the command is run again after an upgrade.
+*/
+function addCompletionCommand(program) {
+	return program.command("completion").description("print a shell completion script for bash, zsh, or fish").addOption(new Option("-s, --shell <shell>", "shell to generate the script for").choices(SHELLS).makeOptionMandatory()).addHelpText("after", `
+Install it for the current user, then start a new shell:
+  bash  diffle completion --shell bash > ~/.local/share/bash-completion/completions/diffle
+  zsh   diffle completion --shell zsh > ~/.local/share/zsh/site-functions/_diffle
+        (any directory that .zshrc puts on fpath before compinit)
+  fish  diffle completion --shell fish > ~/.config/fish/completions/diffle.fish
+
+Run it again after upgrading diffle: the script is static, so new options do not appear on their own.`).action((opts) => {
+		process.stdout.write(generateCompletion(program, { shell: opts.shell }));
+	});
+}
+//#endregion
 //#region src/cli/open.ts
 /** Opens a URL in the default browser. Detached; never awaited. */
 function openBrowser(url) {
@@ -13890,7 +15131,7 @@ async function openReviewRepository(req, cwd, gh = runGh) {
 		close: () => local.cleanReviewRefs()
 	};
 	const pr = await viewPr(req.pr, cwd, gh);
-	if (local && (await local.remotes()).some((r) => remoteSlug(r.url) === pr.baseRepo.toLowerCase())) return {
+	if (local && (await local.remotes()).some((r) => remoteSlug(r.url) === pr.repository.toLowerCase())) return {
 		repo: local,
 		close: () => local.cleanReviewRefs()
 	};
@@ -13947,7 +15188,10 @@ const c = {
 	bold: paint("1"),
 	dim: paint("2")
 };
-const program = new Command().name("diffle").description("Review a git diff in the browser and export line comments as an agent prompt.").version(version, "-v, --version", "print the version and exit").option("-C <path>", "run as if started in <path> (any directory inside a git worktree)").option("-p, --port <port>", `port to listen on (default: ${DEFAULT_PORT}, or the next free one; 0 = random)`, parsePort).option("-H, --host <host>", "address to bind; use 0.0.0.0 to expose on the network", "127.0.0.1").option("--no-open", "do not open a browser").option("--keep-alive", "keep the server running after all browser tabs close").option("--no-watch", "do not watch for changes").addOption(new Option("--auto-viewed <glob>", "mark matching files viewed for this session (repeatable)").argParser(collect).default([], "none")).option("-U, --context <n>", "context lines around changes for this session (default: config, 5)", parseContext).addOption(new Option("--lsp <language=command>", "language server command for one language, started for this run (repeatable); by default the diff's languages are served by whatever is on PATH").argParser(collectLspOverride).default(true, "the diff's languages, resolved on PATH")).option("--no-lsp", "do not start any language server").option("--timing", "print startup phase timings to stderr").option("--dev", "serve the client through Vite (development)", process.env.DIFFLE_DEV === "1" ? true : void 0).argument("[revs...]", "git-diff style revisions: <rev> | <a>..<b> | <a>...<b> | <a> <b>").addHelpText("after", `
+const program = new Command().name("diffle").description("Review a git diff in the browser and export line comments as an agent prompt.").version(version, "-v, --version", "print the version and exit").addOption(completionHint(new Option("-C <path>", "run as if started in <path> (any directory inside a git worktree)"), { kind: "directory" })).option("-p, --port <port>", `port to listen on (default: ${DEFAULT_PORT}, or the next free one; 0 = random)`, parsePort).option("-H, --host <host>", "address to bind; use 0.0.0.0 to expose on the network", "127.0.0.1").option("--no-open", "do not open a browser").option("--keep-alive", "keep the server running after all browser tabs close").option("--no-watch", "do not watch for changes").addOption(new Option("--auto-viewed <glob>", "mark matching files viewed for this session (repeatable)").argParser(collect).default([], "none")).option("-U, --context <n>", "context lines around changes for this session (default: config, 5)", parseContext).addOption(new Option("--lsp <language=command>", "language server command for one language, started for this run (repeatable); by default the diff's languages are served by whatever is on PATH").argParser(collectLspOverride).default(true, "the diff's languages, resolved on PATH")).option("--no-lsp", "do not start any language server").option("--timing", "print startup phase timings to stderr").option("--dev", "serve the client through Vite (development)", process.env.DIFFLE_DEV === "1" ? true : void 0).addArgument(completionHint(new Argument("[revs...]", "git-diff style revisions: <rev> | <a>..<b> | <a>...<b> | <a> <b>"), {
+	kind: "choices",
+	values: ["working", "pr"]
+})).addHelpText("after", `
 Shorthands (in place of <revs>):
   working                  same as HEAD..worktree: uncommitted changes, staged and untracked included
   pr [number|url]          a GitHub pull request: its base...head, fetched if needed
@@ -13990,7 +15234,7 @@ config.command("set-context").description("set context lines around changes").ar
 	await store.set({ contextLines: n });
 	console.log(store.get().contextLines);
 });
-config.command("set-lsp").description("set the language-server command for one language").argument("<language>", `one of: ${LANGUAGE_IDS.join(", ")}`, parseLanguage).argument("<command>", "shell command that starts a stdio language server, e.g. \"pyrefly lsp\"; \"\" to turn it off").action(async (language, command) => {
+config.command("set-lsp").description("set the language-server command for one language").addArgument(languageArgument("<language>", `one of: ${LANGUAGE_IDS.join(", ")}`).argParser(parseLanguage)).argument("<command>", "shell command that starts a stdio language server, e.g. \"pyrefly lsp\"; \"\" to turn it off").action(async (language, command) => {
 	const store = await UserConfigStore.open();
 	await store.set({ lspCommands: {
 		...store.get().lspCommands,
@@ -13998,7 +15242,7 @@ config.command("set-lsp").description("set the language-server command for one l
 	} });
 	printLspCommands(store.get());
 });
-config.command("unset-lsp").description("forget a language-server override, back to PATH").argument("<language...>", `one or more of: ${LANGUAGE_IDS.join(", ")}`, collectLanguage).action(async (languages) => {
+config.command("unset-lsp").description("forget a language-server override, back to PATH").addArgument(languageArgument("<language...>", `one or more of: ${LANGUAGE_IDS.join(", ")}`).argParser(collectLanguage)).action(async (languages) => {
 	const store = await UserConfigStore.open();
 	const drop = new Set(languages);
 	await store.set({ lspCommands: Object.fromEntries(Object.entries(store.get().lspCommands).filter(([l]) => !drop.has(l))) });
@@ -14018,9 +15262,17 @@ program.command("lsp").description("show the language server each language would
 	const width = Math.max(...LANGUAGE_IDS.map((l) => l.length));
 	for (const language of LANGUAGE_IDS) console.log(`${language.padEnd(width)}  ${answer.get(language) ?? ""}`);
 });
+addCompletionCommand(program);
 function collect(value, prev) {
 	return [...prev, value];
 }
+/** A `<language>` argument, completing to the languages diffle knows. */
+function languageArgument(name, description) {
+	return completionHint(new Argument(name, description), {
+		kind: "choices",
+		values: LANGUAGE_IDS
+	});
+}
 function printLspCommands(config) {
 	for (const [language, command] of Object.entries(config.lspCommands)) console.log(`${language}=${command}`);
 }
@@ -14103,7 +15355,7 @@ async function serve(req, opts, repo, closeRepo, config, timing) {
 		const n = snap.changed.length;
 		const adds = snap.changed.reduce((a, f) => a + f.additions, 0);
 		const dels = snap.changed.reduce((a, f) => a + f.deletions, 0);
-		console.error(`🔍 ${c.dim("comparing")} ${c.bold(snap.mode.label)}`);
+		console.error(`🔍 ${c.dim("comparing")} ${c.bold(comparisonLabel(snap.mode))}`);
 		if (n === 0) console.error(`${c.yellow("!")} No differences. Open any file from the tree to comment on it.`);
 		else console.error(`📝 ${n} changed file${n === 1 ? "" : "s"}  ${c.green(`+${adds}`)} ${c.red(`−${dels}`)}`);
 		if (snap.mode.live !== "none") console.error(`👀 ${c.dim(snap.mode.live === "worktree" ? "watching the worktree" : "watching refs")}${opts.watch ? "" : c.dim(" (disabled with --no-watch)")}`);
@@ -14137,7 +15389,7 @@ function startLsp(repo, session, hub, overrides, preload) {
 		const paths = followsCheckout(snap) ? snap.changed.filter((f) => f.status !== "D" && !f.binary).map((f) => f.path) : [];
 		lsp.track(paths);
 	});
-	const reported = /* @__PURE__ */ new Set();
+	const reported = /* @__PURE__ */ new Map();
 	const lsp = new LspPool({
 		root: repo.root,
 		overrides,
@@ -14148,9 +15400,14 @@ function startLsp(repo, session, hub, overrides, preload) {
 		has: async (path) => session.hasSide(await session.snapshotter.current(), path, "new"),
 		onStatus: (status) => {
 			for (const s of status.servers) {
-				if (s.state !== "unavailable" || reported.has(s.command)) continue;
-				reported.add(s.command);
-				console.error(`${c.red("✖")} lsp ${s.name} unavailable: ${s.message}`);
+				const message = s.state === "unavailable" ? s.message ?? "unavailable" : s.notice?.message;
+				if (!message) {
+					reported.delete(s.command);
+					continue;
+				}
+				if (reported.get(s.command) === message) continue;
+				reported.set(s.command, message);
+				console.error(`${c.red("✖")} lsp ${s.name}: ${message}`);
 			}
 			hub.broadcast({
 				type: "lsp",