terminal-ai-helper 2.1.0 → 2.3.0

package/VERSION

@@ -1 +1 @@
-2.1.0
+2.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "terminal-ai-helper",
-  "version": "2.1.0",
+  "version": "2.3.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/plugins/zsh/widgets.zsh

@@ -562,6 +562,23 @@ _tai_line_init() {
   _TAI_ISEARCH=0
   region_highlight=()
   _tai_menu_close
+  # The prophecy. _TAI_SEQ answers "what did I run after this", and the fresh
+  # prompt is where that answer is taken — so the reset above is followed by
+  # the question, through the same _tai_update the redraw hook runs: it looks
+  # the empty buffer up against _TAI_LAST, judges the head's relative paths
+  # where the prompt stands, and paints the gray line the arrow accepts. The
+  # report: the sequence table held `sudo …` after the denied `systemctl …`
+  # and the prompt said nothing, because line-init only ever cleared, and no
+  # widget-triggered redraw fires before the first keystroke — by which time
+  # the buffer is no longer empty and the ordinary prefix lookup has replaced
+  # the question. Nothing here can answer before the first command has run:
+  # _TAI_LAST is set by precmd, so a shell that just opened queries an empty
+  # last command and paints nothing — the prophecy is learned, never a
+  # default. The query is cached, so the first real redraw of this line
+  # restores the answer instead of recomputing it, and every guard the redraw
+  # path applies (isearch stand-down, ours-only clearing, the paste rule) is
+  # this path's guard too, because it is the same call.
+  _tai_update
 }
 
 # The isearch flag the redraw hook stands down under, and the pair that

package/readme.md

@@ -14,6 +14,9 @@ autocomplete that knows *you*:
 systemctl <→>         restart nginx           ← the hint, taken
 git <Tab>             pull      status        ← your habits, ranked
 cd D<Tab>             Desktop/  Documents/  Downloads/
+
+systemctl stop cups.path
+❯ sudo systemctl stop cups.path   ← what you did last time, already waiting
 ```
 
 ![tai in action — the hint, the ranked list, the filesystem, a typo
@@ -77,7 +80,11 @@ tai uninstall   # remove everything tai added
    `Ctrl-F` takes it whole, `Alt-F` one word.
 2. **Press `Tab`.** On a first word your history ranks the lines it knows;
    `Enter` fills one in, a second `Enter` runs it.
-3. **Run `tai web`.** A localhost dashboard of everything it learned, with a
+3. **Run a command and look at the next prompt.** When a command fails the way
+   it failed before, the empty line already shows, in grey, what you did about
+   it last time — `sudo …` after the denied `systemctl …`, `rm -r …` after the
+   refused `rm`. `→` takes it; typing replaces it.
+4. **Run `tai web`.** A localhost dashboard of everything it learned, with a
    try box that answers exactly what the prompt would.
 
 Every command you run teaches it — secrets, multi-line pastes and stray keys
@@ -88,7 +95,7 @@ machine. New commands show up within seconds; no restart, ever.
 
 | key                     | what it does                                                                                                                                           |
 | ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `→`                     | take the hint at the end of the line, else move right                                                                                                  |
+| `→`                     | take the hint at the end of the line, else move right — on a fresh prompt the hint is what followed the command you just ran                           |
 | `Ctrl-F`                | take the hint                                                                                                                                          |
 | `Alt-F` / `Ctrl-Right`  | take **one word** of the hint, leaving the rest to type (bash: `Ctrl-Right`)                                                                           |
 | `Tab`                   | write what every candidate shares, then cycle files, folders and options; on a bare first word the learned lines come first, ranked like the dashboard |
@@ -137,6 +144,11 @@ memory, an array hit in microseconds.
   exists, here, on your PATH.
 - **A tool you have never run still gets an answer:** `tool --help`. Run it
   once and the real `--help` is learned in the background.
+- **A fresh prompt carries what came next.** After a command, the empty line
+  shows in grey what your own history followed it with — ranked by how often
+  it followed, judged where the prompt stands like every suggestion. It is
+  learned or it is nothing: nothing built in, nothing before your first
+  command, and a follower whose path does not resolve here is not offered.
 
 - **If another plugin also draws hints, both work.** `→`, `Ctrl-F` and
   `Alt-F` take whatever is on screen, and tai never overwrites a hint it did

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
@@ -411,15 +413,19 @@ def build(max_commands: int = 20000) -> int:
 
     seq: dict[str, list[str]] = defaultdict(list)
     for prev, counter in eng.seq.items():
-        # Sorted here, best first, because a shell now reads the order as the
-        # ranking and not only as a tiebreak: the zsh menu shows a key's values in
-        # the order they are stored, while _tai_best still re-ranks by
-        # _TAI_SCORE to pick one. It used to add `count * 2.5` to a milli-score,
-        # which is 0.08% of the value it was added to: the list looked
-        # sequence-ranked and was really just base-score ranked with extra steps.
-        values = [cmd for cmd, _ in sorted(
-            ((cmd, scores.get(cmd, 0)) for cmd in counter),
-            key=lambda x: (-x[1], x[0]))[:SEQ_CANDIDATE_CAP]]
+        # Ordered by how often the pair happened, then by how good the line is,
+        # best first — because the head of this list is the line a fresh prompt
+        # offers, and "what did I run after this" is answered by what followed
+        # *most*, not by the best-scoring line that ever did. The engine's own
+        # sequence factor is the pair's normalized count for the same reason;
+        # ordering the list by base score alone (an earlier shape, with the
+        # count discarded here) made the prophecy disagree with the engine on
+        # exactly the key the prophecy exists for: after `git add -A`, the
+        # history's `git commit -m …` lost the head to a bare `ls` that had
+        # merely followed once and scored well on its own.
+        values = [cmd for cmd, _, _ in sorted(
+            ((cmd, counter[cmd], scores.get(cmd, 0)) for cmd in counter),
+            key=lambda x: (-x[1], -x[2], x[0]))[:SEQ_CANDIDATE_CAP]]
         # A key whose every follower was stale has no answer left, and writing
         # it as an empty string puts `_TAI_SEQ[key] = ''` in the file. The zsh
         # plugin splits that into one empty line and the bash one reads it as an
@@ -445,13 +451,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 +487,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 +505,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