terminal-ai-helper 2.0.1 → 2.2.0

package/VERSION

@@ -1 +1 @@
-2.0.1
+2.2.0

package/install.sh

@@ -23,11 +23,19 @@ else
     exit 1
   }
   if [ -d "$TAI_DIR/.git" ]; then
-    # The one-liner is also the update path: an existing checkout is pulled
-    # forward and reinstalled, never cloned over. A pull that cannot happen
-    # (diverged, offline) fails here, loudly, rather than installing old code.
+    # The one-liner is also the update path: an existing checkout is refetched
+    # and reinstalled, never cloned over. The checkout is this install's own —
+    # nobody develops in it — so the update is one commit deep every time:
+    # fetch --depth 1, reset to what origin named, prune what is left behind.
+    # A pull here would download every commit made since the checkout was cut,
+    # and a checkout that predates --depth 1 would carry its whole history
+    # forever. Offline, the fetch fails and set -e stops the install loudly —
+    # the old rule stands: never install old code on the strength of a guess.
     echo "→ updating the checkout at $TAI_DIR…"
-    git -C "$TAI_DIR" pull --ff-only --quiet
+    _branch="$(git -C "$TAI_DIR" rev-parse --abbrev-ref HEAD)"
+    git -C "$TAI_DIR" fetch --depth 1 --quiet origin "$_branch"
+    git -C "$TAI_DIR" reset --hard --quiet FETCH_HEAD
+    git -C "$TAI_DIR" gc --prune=now --quiet 2>/dev/null || true
   elif [ -e "$TAI_DIR" ]; then
     echo "tai: $TAI_DIR exists and is not a tai checkout — remove it or set TAI_DIR" >&2
     exit 1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "terminal-ai-helper",
-  "version": "2.0.1",
+  "version": "2.2.0",
   "description": "The terminal that knows your next command Bash/Zsh suggestions that learn from your own history Offline and private with no account required",
   "license": "MIT",
   "repository": {

package/plugins/bash/index.bash

@@ -24,7 +24,7 @@ _TAI_INDEX_STAMP="${_TAI_INDEX_FILE}.stamp"
 # prints "value too great for base" on every keystroke instead of looking
 # anything up. A shell started before the first `tai refresh` still has to
 # be quiet and still gets the installed-command fallback.
-declare -gA _TAI_SCORE _TAI_FIRST _TAI_WORD _TAI_SEQ _TAI_FILE
+declare -gA _TAI_SCORE _TAI_FIRST _TAI_WORD _TAI_SEQ _TAI_FILE _TAI_LIVE
 
 # Is this file the index, or something that only looks like it?
 #
@@ -69,7 +69,7 @@ _tai_load_index() {
   # installed for the life of the shell — the same rule as plugins/tai.zsh, and
   # for the same reason: the file has to be the whole truth rather than a growing
   # superset of every index this shell has ever read.
-  _TAI_SCORE=() _TAI_FIRST=() _TAI_WORD=() _TAI_SEQ=() _TAI_FILE=()
+  _TAI_SCORE=() _TAI_FIRST=() _TAI_WORD=() _TAI_SEQ=() _TAI_FILE=() _TAI_LIVE=()
   # The sorted-keys array is built on first use, not here: its one fork (a
   # `sort` over every first-word key) belonged to the shell's startup, which
   # is exactly the cost a plugin should not add — and most keystrokes never

package/plugins/bash/keys.bash

@@ -201,7 +201,12 @@ _tai_complete() {
       for c in "${_TAI_LEARNED_LINES[@]}"; do
         # Folded, like the lookup that produced them: `ls down` offers
         # `ls Downloads`.
-        [[ "${c,,}" == "${line,,}"* ]] && _tai_reply "$c"
+        [[ "${c,,}" == "${line,,}"* ]] || continue
+        # A whole learned line is committed whole, so every word in it that the
+        # index marked as a relative path has to resolve here — the same
+        # question the ghost asks about the line it hints.
+        _tai_line_here "$c" 0 || continue
+        _tai_reply "$c"
       done
     fi
     local -i names=0
@@ -211,7 +216,15 @@ _tai_complete() {
   fi
   local stem x
   while IFS= read -r c; do
-    [[ -n "$c" && "${c,,}" == "${line,,}"* ]] && _tai_reply "${c##*[[:space:]]}"
+    [[ -n "$c" && "${c,,}" == "${line,,}"* ]] || continue
+    stem="${c##*[[:space:]]}"
+    # The word this completion offers is judged where the shell stands: a
+    # learned word that is unambiguously a relative path (the index marked it
+    # in _TAI_LIVE) was true where it was recorded and may exist nowhere else.
+    # Flags and bare words are never marked; the file and directory sources
+    # above read the disk itself.
+    _tai_here "$stem" || continue
+    _tai_reply "$stem"
   done <<< "$values"
   if (( dir_arg )); then
     local curw=""

package/plugins/bash/lookup.bash

@@ -161,6 +161,11 @@ _TAI_VALUES_ONE=0
 # replaces a walk over 2,600 lines with two or three tests.
 _tai_best() {
   local values="$1" prefix="$2" best="" best_score=-1 c s cl pl="${2,,}"
+  # The words tai adds are the words judged: the ghost writes the whole line it
+  # hints, so every marked word after what the user typed has to resolve here,
+  # or the hint is an error the user is offered.
+  _tai_typed_words "$prefix"
+  local typed=$_TAI_TYPED_WORDS
   # The extends-the-line and echo tests are case-insensitive — the lookup that
   # filled `values` is, and the two have to agree about what extends what.
   if [[ "${_TAI_VALUES_ONE:-0}" == "1" ]]; then
@@ -171,6 +176,7 @@ _tai_best() {
       # what it finds, and a byte that slips through is an escape sequence on
       # someone's terminal.
       [[ "$c" =~ [[:cntrl:]] ]] && continue
+      _tai_line_here "$c" "$typed" || continue
       best="$c"
       break
     done <<< "$values"
@@ -184,6 +190,7 @@ _tai_best() {
     # ghost text: the byte goes to the terminal as an escape sequence. The
     # store refuses at record time now, but this shell sources what it finds.
     [[ "$c" =~ [[:cntrl:]] ]] && continue
+    _tai_line_here "$c" "$typed" || continue
     s="${_TAI_SCORE[$c]:-0}"
     if (( s > best_score )); then best="$c"; best_score="$s"; fi
   done <<< "$values"
@@ -224,6 +231,53 @@ _tai_destination_live() {
   [[ -d "$t" ]]
 }
 
+# The words the index marks in _TAI_LIVE are the learned words that are
+# unambiguously *relative* filesystem paths — the one kind of word whose truth
+# is a fact about the directory it is offered in. A flag is true everywhere and
+# `~/.ollama` is true wherever this machine stands; `Data/INI` was true where it
+# was recorded and may exist nowhere else, and offered from another directory it
+# is the error the user reads the moment they take it. The shape test that
+# decided what gets marked lives in tai/paths.py and is deliberately not
+# re-implemented here — the shell only asks the one question left to it: does
+# the word resolve where the user stands. One builtin stat, paid only on a word
+# the index marked, on the paths that offer it.
+_tai_here() {
+  [[ -n "${_TAI_LIVE[$1]:-}" ]] || return 0
+  [[ -e "$1" ]]
+}
+
+# The marked words *after* the $2 words already typed all resolve here. This is
+# the question about a whole line — the ghost writes the rest of the line it
+# hints and a first-word completion commits it — so the claim under test is not
+# the next word but every word tai would add. The typed words are the user's
+# own and get no opinion; a line that splits to fewer tokens than that adds
+# nothing and passes. An empty _TAI_LIVE — an index that predates the map, or a
+# history with no relative path in it — passes without a split at all.
+_tai_line_here() {
+  local line="$1" n="$2" w
+  ((${#_TAI_LIVE[@]})) || return 0
+  local -a t=()
+  read -ra t <<< "$line"
+  for w in "${t[@]:n}"; do
+    _tai_here "$w" || return 1
+  done
+  return 0
+}
+
+# How many words of `$1` are complete: a trailing space finishes the word before
+# it, so `ls ` has one and `ls Da` still has only the command. Answered in
+# _TAI_TYPED_WORDS and not in the return status, because a pasted line can carry
+# more words than a status can hold and a wrapped count is a wrong count.
+_TAI_TYPED_WORDS=0
+_tai_typed_words() {
+  local -a t=()
+  read -ra t <<< "$1"
+  local n=${#t[@]}
+  [[ "$1" == *' ' ]] || (( n -= 1 ))
+  (( n < 0 )) && n=0
+  _TAI_TYPED_WORDS=$n
+}
+
 # Rank the line behind the wrapper and put the wrapper back. `sudo git ` completes
 # from the `git ...` the user has run.
 _tai_wrapped() {

package/plugins/zsh/index.zsh

@@ -15,7 +15,7 @@ _TAI_INDEX_STAMP="${_TAI_INDEX_FILE}.stamp"
 # Declare the maps even when the index file is missing, so a shell started before
 # the first `tai refresh` is quiet and still gets the installed-command
 # fallback.
-typeset -gA _TAI_SCORE _TAI_FIRST _TAI_WORD _TAI_SEQ _TAI_FILE
+typeset -gA _TAI_SCORE _TAI_FIRST _TAI_WORD _TAI_SEQ _TAI_FILE _TAI_LIVE
 
 # Is this file the index, or something that only looks like it?
 #
@@ -63,7 +63,7 @@ _tai_load_index() {
   # suggestion from the store, the next prompt re-read the index, and the stale
   # key was still there. Clearing first is what makes the file the whole truth
   # rather than a growing superset of every index this shell has ever seen.
-  _TAI_SCORE=() _TAI_FIRST=() _TAI_WORD=() _TAI_SEQ=() _TAI_FILE=()
+  _TAI_SCORE=() _TAI_FIRST=() _TAI_WORD=() _TAI_SEQ=() _TAI_FILE=() _TAI_LIVE=()
   # A lookup may cache an answer about the lines it was asked from, so a reload
   # has to retire those answers: bumping the generation is what makes a cached
   # answer speak about the index that is installed now rather than the one that

package/plugins/zsh/lookup.zsh

@@ -64,6 +64,61 @@ _TAI_CTRL=$'[\x01-\x1f\x7f]'
 # shared by hundreds of commands, where the answer is a guess either way.
 typeset -gi _TAI_PREFIX_KEYS=64
 
+# The words the index marks in _TAI_LIVE are the learned words that are
+# unambiguously *relative* filesystem paths — the one kind of word whose truth
+# is a fact about the directory it is offered in. A flag is true everywhere and
+# `~/.ollama` is true wherever this machine stands; `Data/INI` was true where it
+# was recorded and may exist nowhere else, and offered from another directory it
+# is the error the user reads the moment they take it. The shape test that
+# decided what gets marked lives in tai/paths.py and is deliberately not
+# re-implemented here — the shell only asks the one question left to it: does
+# the word resolve where the user stands. One builtin stat, paid only on a word
+# the index marked, on the paths that offer it.
+_tai_here() {
+  (( ${+_TAI_LIVE[$1]} )) || return 0
+  [[ -e "$1" ]]
+}
+
+# The marked words *after* the $2 words already typed all resolve here. This is
+# the question about a whole line — the ghost writes the rest of the line it
+# hints, a glimpse pick replaces the line, a first-word menu commits it — so the
+# claim under test is not the next word but every word tai would add. The typed
+# words are the user's own and get no opinion; a line that splits to fewer
+# tokens than that adds nothing and passes. An empty _TAI_LIVE — an index that
+# predates the map, or a history with no relative path in it — passes without a
+# split at all.
+_tai_line_here() {
+  local line="$1" w
+  integer n="$2"
+  (( ${#_TAI_LIVE} )) || return 0
+  local -a t
+  t=( ${=line} )
+  # zsh's own slice, not the bash-style `${t[@]:n}`: the colon there is a
+  # subscript flag the parser reads as a modifier and errors on.
+  for w in "${(@)t[n + 1, -1]}"; do
+    _tai_here "$w" || return 1
+  done
+  return 0
+}
+
+# How many words of `$1` are complete: a trailing space finishes the word before
+# it, so `ls ` has one and `ls Da` still has only the command. The count the
+# line question needs, so the words tai adds are exactly the words judged.
+# Answered in _TAI_TYPED_WORDS and not in the return status, because a pasted
+# line can carry more words than a status can hold and a wrapped count is a
+# wrong count. The name is not the widgets' `_TAI_TYPED` — that one is the
+# typing flag the arrow-down gate reads, and a lookup clobbering it on every
+# keystroke was breaking the glimpse it opens.
+_tai_typed_words() {
+  local -a t
+  t=( ${=1} )
+  integer n=${#t}
+  [[ "$1" == *' ' ]] || (( n -= 1 ))
+  (( n < 0 )) && n=0
+  _TAI_TYPED_WORDS=$n
+}
+typeset -gi _TAI_TYPED_WORDS=0
+
 # The candidate lines for a command name — the word before the first space — into
 # _TAI_LINES, newline-joined the way the index stores them.
 #
@@ -288,6 +343,19 @@ _tai_lines() {
 # _TAI_PREFIX_KEYS of them.
 _tai_best() {
   local prefix="$1" c line best="" best_score=-1 s
+  integer typed=0 leadw=0
+  # The words tai adds are the words judged: a candidate is hinted whole, so
+  # every marked word after what the user typed has to resolve here, or the
+  # hint is an error the user is offered. The lead carries the wrapper's words
+  # — typed by the user, absent from the stored line — so they come off the
+  # count before the test.
+  _tai_typed_words "$prefix"
+  typed=$_TAI_TYPED_WORDS
+  local -a lt
+  lt=( ${=_TAI_LINES_LEAD} )
+  leadw=${#lt}
+  (( typed -= leadw ))
+  (( typed < 0 )) && typed=0
   # The extends-the-line and echo tests are case-insensitive — the lookup that
   # filled _TAI_LINES is, and the two have to agree about what extends what.
   # `(#i)` needs extendedglob; localoptions hands this shell its own options
@@ -298,6 +366,7 @@ _tai_best() {
     for c in "${_TAI_LINES[@]}"; do
       line="$_TAI_LINES_LEAD$c"
       [[ -z "$c" || "$line" == (#i)"$prefix" ]] && continue
+      _tai_line_here "$c" "$typed" || continue
       best="$line"
       break
     done
@@ -305,6 +374,7 @@ _tai_best() {
     for c in "${_TAI_LINES[@]}"; do
       line="$_TAI_LINES_LEAD$c"
       [[ -z "$c" || "$line" == (#i)"$prefix" || "$line" != (#i)"$prefix"* ]] && continue
+      _tai_line_here "$c" "$typed" || continue
       s="${_TAI_SCORE[$c]:-0}"
       if (( s > best_score )); then best="$c"; best_score="$s"; fi
     done
@@ -457,6 +527,20 @@ _tai_query_do() {
       done
       _TAI_LOOSE_LINES=( "${live_l[@]}" )
     fi
+    # The same judgement for every other line the glimpse holds, because a pick
+    # here replaces the whole typed line: a relative path in a glimpse line was
+    # true where the line was recorded, and from this directory it can be the
+    # error the user is handed instead of a command. The cd lines above get the
+    # stricter destination test; these get the words test — the same rule, at
+    # the depth each line claims. The list is filtered fresh per query rather
+    # than inside the glimpse, whose cache outlives the directory.
+    local -a here_l
+    local gline
+    here_l=()
+    for gline in "${_TAI_LOOSE_LINES[@]}"; do
+      _tai_line_here "$gline" 0 && here_l+=( "$gline" )
+    done
+    _TAI_LOOSE_LINES=( "${here_l[@]}" )
   fi
 
   # A learned cd destination was judged for liveness where it was recorded,

package/plugins/zsh/menu.zsh

@@ -271,6 +271,10 @@ _tai_menu_first_lines() {
   sorted=( "${(O)merged[@]}" )
   local m
   for m in "${(@)sorted[1,_TAI_MENU_FIRST_CAP]}"; do
+    # A whole line is committed whole, so every marked word in it is judged —
+    # the same question the ghost asks about the line it hints, answered the
+    # same way, so Tab and the grey text cannot disagree about what works here.
+    _tai_line_here "${m[10,-1]}" 0 || continue
     _TAI_MENU_LEARNED+=( "${m[10,-1]}" )
   done
   (( ${#_TAI_MENU_LEARNED[@]} ))
@@ -365,7 +369,15 @@ _tai_menu_open() {
   for c in "${_TAI_LINES[@]}"; do
     (( ${#c} > skip )) || continue
     rest="$_TAI_LINES_LEAD${c}"
-    out+=( "${${rest[skip + 1, -1]}%% *}" ); outq+=( 0 )
+    c="${${rest[skip + 1, -1]}%% *}"
+    # The word the menu completes is judged where the menu stands: a learned
+    # word that is unambiguously a relative path (the index marked it in
+    # _TAI_LIVE) was true where it was recorded and may exist nowhere else,
+    # and Enter on it reads "no such file or directory". Flags and bare words
+    # are never marked; the file and glob sources below are the disk itself.
+    [[ -n "$c" ]] || continue
+    _tai_here "$c" || continue
+    out+=( "$c" ); outq+=( 0 )
   done
 
   # 1b. The first word has no `before` for the lookup above, and without this

package/readme.md

@@ -28,20 +28,6 @@ curl -fsSL https://raw.githubusercontent.com/mlibre/Terminal-AI-Helper/main/inst
 exec zsh
 ```
 
-Or using npm
-
-```sh
-npm i -g terminal-ai-helper@latest --allow-scripts=terminal-ai-helper
-exec zsh
-```
-
-The flag is npm's: newer npm blocks install scripts by default, and without
-it the package unpacks and nothing is wired — no `tai` command, no rc lines.
-
-The line downloads TAI to `~/.tai` and runs the installer from there; run it
-again later and it updates in place. It enables both shells, imports your
-history, and builds the first index:
-
 ```text
 → cloning tai to /home/you/.tai…
 → learning from your history, building the index…
@@ -62,6 +48,13 @@ that switched doors could leave the shell's `source` line naming the
 older tree — code updates never reach it; `tai update` retargets that
 line, and `tai version` says where it points.
 
+Or using npm
+
+```sh
+npm i -g terminal-ai-helper@latest --allow-scripts=terminal-ai-helper
+exec zsh
+```
+
 ## Commands
 
 ```sh

package/tai/cli.py

@@ -266,6 +266,7 @@ def cmd_update(a) -> int:
 
     import shutil
     import subprocess
+    from pathlib import Path
 
     git = shutil.which("git")
     if not git:
@@ -281,15 +282,49 @@ def cmd_update(a) -> int:
         return subprocess.run([git, "-C", str(repo), "rev-parse", "--short", "HEAD"],
                               capture_output=True, text=True).stdout.strip()
 
+    def run_git(*argv: str) -> subprocess.CompletedProcess:
+        return subprocess.run([git, "-C", str(repo), *argv],
+                              capture_output=True, text=True)
+
+    # The checkout the one-liner cloned is this install's own tree, not a
+    # development branch: nobody commits in it, so the update is a fetch one
+    # commit deep and a reset to what origin named — the same three commands
+    # install.sh's piped door runs. A pull here would download every commit
+    # made since the checkout was cut, and one that predates --depth 1 would
+    # carry its whole history forever. A checkout anywhere else is somebody's
+    # tree — maybe a fork they develop in — and it keeps the careful pull:
+    # fast-forward only, a divergence fails loudly rather than resetting
+    # anybody's work away.
+    managed = (repo.resolve()
+               == Path(os.environ.get("TAI_DIR")
+                       or Path.home() / ".tai").resolve())
+
     before = head()
-    pull = subprocess.run([git, "-C", str(repo), "pull", "--ff-only"],
-                          capture_output=True, text=True)
-    if pull.returncode != 0:
-        # A local edit in the checkout is the usual cause, and git's own message
-        # says exactly what to do about it, so pass it through rather than guess.
-        print("tai: git pull failed:")
-        print((pull.stderr or pull.stdout).strip())
-        return 1
+    if managed:
+        branch = run_git("rev-parse", "--abbrev-ref", "HEAD").stdout.strip()
+        failed = None
+        for argv in (("fetch", "--depth", "1", "--quiet", "origin", branch),
+                     ("reset", "--hard", "--quiet", "FETCH_HEAD")):
+            done = run_git(*argv)
+            if done.returncode != 0:
+                failed = argv[0]
+                break
+        if failed:
+            print(f"tai: git {failed} failed:")
+            print((done.stderr or done.stdout).strip())
+            return 1
+        # Hygiene, not a step: what the old history weighed is already
+        # unreachable after the reset, and a failed prune costs nothing.
+        run_git("gc", "--prune=now", "--quiet")
+    else:
+        pull = run_git("pull", "--ff-only")
+        if pull.returncode != 0:
+            # A local edit in the checkout is the usual cause, and git's own
+            # message says exactly what to do about it, so pass it through
+            # rather than guess.
+            print("tai: git pull failed:")
+            print((pull.stderr or pull.stdout).strip())
+            return 1
     after = head()
     # Flushed, because the installer below writes to the same terminal from a
     # child process and would otherwise appear ahead of this line.
@@ -587,21 +622,29 @@ def cmd_uninstall(a) -> int:
             removed.append(str(rc))
     # The piped door clones the code itself to TAI_DIR (default ~/.tai), and
     # leaving it behind would leave the program installed in every way but the
-    # wrapper — the same rule the rc blocks above are held to. What makes the
-    # directory tai's is its layout: cli.py and the installer inside it. A
-    # directory without that shape is not ours to delete, so it is named and
-    # kept. Last on purpose: this command usually runs from inside the checkout
-    # (the wrapper execs this very file), so removing it has to be the last
-    # thing the run does.
+    # wrapper — the same rule the rc blocks above are held to. The name is the
+    # identity: the path is tai's namespace, created by tai's installer and
+    # claimed by nothing else, so whatever the checkout has grown into — a
+    # shape an older door left half-made, files the user dropped beside the
+    # code — goes with the uninstall, and the report says which kind it was.
+    # One floor stands: never a directory the home lives in or under, so a
+    # mistyped TAI_DIR cannot name more than tai owns. Last on purpose: this
+    # command usually runs from inside the checkout (the wrapper execs this
+    # very file), so removing it has to be the last thing the run does.
     checkout = Path(os.environ.get("TAI_DIR") or home / ".tai")
-    left = None
+    held = ""
     if checkout.exists():
-        if ((checkout / "tai" / "cli.py").exists()
-                and (checkout / "install.sh").exists()):
-            shutil.rmtree(checkout)
-            removed.append(str(checkout))
+        if home.is_relative_to(checkout):
+            held = f"left {checkout} — it holds the home directory"
         else:
-            left = checkout
+            ours = ((checkout / "tai" / "cli.py").exists()
+                    and (checkout / "install.sh").exists())
+            if checkout.is_dir():
+                shutil.rmtree(checkout)
+            else:
+                checkout.unlink()
+            removed.append(str(checkout) + ("" if ours
+                           else " (not a tai checkout — removed anyway)"))
     # The npm door's code is npm's to remove, and the running tree says the
     # same thing the wrapper did — this process may itself be executing from
     # the package npm owns. Last, for the same reason the checkout is: the
@@ -622,10 +665,10 @@ def cmd_uninstall(a) -> int:
     print("tai removed" if removed else "tai was not installed")
     for path in removed:
         print(f"  removed {path}")
-    if left:
-        print(f"  left {left} — not a tai checkout")
     if npm_note:
         print(f"  {npm_note}")
+    if held:
+        print(f"  {held}")
     return 0
 
 

package/tai/index.py

@@ -11,6 +11,8 @@ Each snapshot stores:
   _TAI_WORD[word-prefix]    newline-separated candidates
   _TAI_SEQ[previous]        newline-separated candidates
   _TAI_FILE[line-without-its-last-word]  1, when that word is a file
+  _TAI_LIVE[word]           1, when the word is a relative path the shell
+                            must find where it stands before offering it
 
 Commands are escaped as POSIX single-quoted strings, which zsh accepts.
 """
@@ -25,7 +27,7 @@ from pathlib import Path
 from tai.engine import (Engine, LEN_PENALTY_DIV, MAX_LEN_PEN, W_FREQ,
                         W_RECENCY, W_SUCCESS, W_INSTALLED)
 from tai.knowledge import load_all as load_tool_knowledge
-from tai.paths import destinations_first, takes_file
+from tai.paths import destinations_first, relative_word_set, takes_file
 from tai.seed import SEED_COMMANDS
 from tai.store import load_rows
 from tai.typo import shadow_map
@@ -445,13 +447,21 @@ def build(max_commands: int = 20000) -> int:
             if head:
                 file_keys.add(head)
 
+    # The words the shells must ask the filesystem about before offering them:
+    # unambiguously relative paths, by the shape test paths.py already owns.
+    # Everything else is either not a path (flags, subcommands, bare words a
+    # `git` may mean), cwd-independent (`~`-paths and absolutes, judged at build
+    # by the stale set), or unjudgeable — and the module's rule is that an
+    # ambiguous token gets no opinion.
+    live = relative_word_set(cmds)
+
     zsh_file = index_path()
     zsh_file.parent.mkdir(parents=True, exist_ok=True)
     bash_file = bash_index_path()
     tmp = zsh_file.with_suffix(".tmp")
     with tmp.open("w", encoding="utf-8") as f:
         f.write("# tai embedded zsh index; generated, do not edit\n")
-        f.write("typeset -gA _TAI_SCORE _TAI_FIRST _TAI_WORD _TAI_SEQ _TAI_FILE\n")
+        f.write("typeset -gA _TAI_SCORE _TAI_FIRST _TAI_WORD _TAI_SEQ _TAI_FILE _TAI_LIVE\n")
         # `_TAI_X+=(key value)` — a pair appended to an associative array, one
         # builtin call per entry and no function call at all.
         #
@@ -473,12 +483,14 @@ def build(max_commands: int = 20000) -> int:
             f.write(f"_TAI_SEQ+=({_zq(key)} {_zq(chr(10).join(values))})\n")
         for key in sorted(file_keys):
             f.write(f"_TAI_FILE+=({_zq(key)} 1)\n")
+        for word in sorted(live):
+            f.write(f"_TAI_LIVE+=({_zq(word)} 1)\n")
     os.replace(tmp, zsh_file)
 
     bash_tmp = bash_file.with_suffix(".tmp")
     with bash_tmp.open("w", encoding="utf-8") as f:
         f.write("# tai embedded bash index; generated, do not edit\n")
-        f.write("declare -gA _TAI_SCORE _TAI_FIRST _TAI_WORD _TAI_SEQ _TAI_FILE\n")
+        f.write("declare -gA _TAI_SCORE _TAI_FIRST _TAI_WORD _TAI_SEQ _TAI_FILE _TAI_LIVE\n")
         for score, cmd in ranked:
             f.write(f"_TAI_SCORE[{_zq(cmd)}]={score}\n")
         for key, values in sorted(first.items()):
@@ -489,6 +501,8 @@ def build(max_commands: int = 20000) -> int:
             f.write(f"_TAI_SEQ[{_zq(key)}]={_zq(chr(10).join(values))}\n")
         for key in sorted(file_keys):
             f.write(f"_TAI_FILE[{_zq(key)}]=1\n")
+        for word in sorted(live):
+            f.write(f"_TAI_LIVE[{_zq(word)}]=1\n")
     os.replace(bash_tmp, bash_file)
     _compile_zsh_index()
     return len(cmds)

package/tai/paths.py

@@ -459,3 +459,58 @@ def stale_in(engine, cwd: str = "") -> set[str]:
     return stale_commands(
         ((cmd, list(st.cwd)) for cmd, st in engine.cmds.items()),
         cwd)
+
+
+def relative_word_set(cmds) -> frozenset[str]:
+    """The learned words that are unambiguously *relative* filesystem paths.
+
+    The one kind of word whose truth is a fact about the directory it is
+    offered in. A flag is true everywhere; `~/.ollama` and `/usr/bin` are true
+    wherever this machine stands, and were already judged at build; `Data/INI`
+    was true where it was recorded and may exist nowhere else — offered from
+    another directory it is the error the user is shown the moment they take
+    it. The shape test is this module's, unquoted first: reimplementing it in
+    two shells is how `git diff ~main` and `date 1/2/2024` come to be judged
+    as paths. The index writes the set out as _TAI_LIVE, and the shells ask
+    the filesystem the one question a marked word costs.
+    """
+    out: set[str] = set()
+    for cmd in cmds:
+        for token in (cmd or "").split():
+            token = _unquote(token)
+            if token.startswith("~") or token.startswith("/"):
+                continue
+            if is_path_like(token):
+                out.add(token)
+    return frozenset(out)
+
+
+def alive_in(cmd: str, cwd: str = "") -> bool:
+    """True when every relative path in `cmd` resolves in `cwd`.
+
+    `command_verdict` above asks whether a command was ever true: a row
+    recorded in a directory that still holds the path survives. This asks the
+    other question, the one the user answers with Enter: is it true *here*,
+    in the directory the suggestion is being shown in? A `ls Data/INI`
+    recorded in the directory that has Data/INI is alive by the first answer
+    and dead by the second everywhere else, and it was the second answer the
+    report was about.
+
+    Every judgement is a stat against `cwd`, never a removal decision about a
+    stored row — this gates what is shown, and the recorded evidence above
+    stays the only thing that can retire a row. No directory, no opinion.
+    """
+    if not enabled():
+        return True
+    cwd = cwd or os.getcwd()
+    if not cmd or not os.path.isdir(cwd):
+        return True
+    for token in cmd.split():
+        token = _unquote(token)
+        if not is_path_like(token):
+            continue
+        if token.startswith("~") or os.path.isabs(token):
+            continue
+        if not os.path.exists(os.path.join(cwd, token)):
+            return False
+    return True

package/tai/predictor.py

@@ -14,7 +14,7 @@ import time
 
 from tai.engine import WRAPPERS, Engine
 from tai.fresh import files
-from tai.paths import db_path, takes_file
+from tai.paths import alive_in, db_path, takes_file
 
 _E: Engine | None = None
 _STALE: frozenset = frozenset()
@@ -95,6 +95,25 @@ def suggest(prefix: str = "", cwd: str = "", repo: str = "",
     res = _E.suggest(prefix=prefix or "", cwd=cwd, repo=repo, branch=branch,
                      last_commands=last_commands or [], limit=limit, temp=temp,
                      exclude=_STALE, on_path=_on_path)
+    # The stale set above never hides a relative path that was true where it
+    # was recorded — which is most of them, and that is right for a snapshot
+    # shown in every directory. This answer is shown in one directory, so its
+    # lines are judged there too: a line whose relative path does not resolve
+    # where the answer will be taken is not an answer, and Enter on it is the
+    # error the user reads. The same rule the index writes into _TAI_LIVE for
+    # the shells, from the same module, so the rooms cannot disagree about
+    # what works where the user stands.
+    _where = cwd or os.getcwd()
+    _all = res.get("choices", [])
+    _live = [c for c in _all if alive_in(c["cmd"], _where)]
+    if len(_live) != len(_all):
+        res["choices"] = _live
+        res["probabilities"] = {c["cmd"]: c["prob"] for c in _live}
+        _best = _live[0]["cmd"] if _live else ""
+        res["choice"] = _best
+        res["completion"] = (_best[len(prefix or ""):]
+                             if _best.lower().startswith((prefix or "").lower())
+                             else "")
     res = _file_answer(prefix or "", res)
     # The engine measures its own ranking; a caller that only cares about the
     # whole answer wants the process time, and a sub-millisecond rank has no