@dungle-scrubs/tallow 0.9.3 → 0.9.6

package/node_modules/@mariozechner/pi-tui/README.md

@@ -1,51 +1,73 @@
 # @mariozechner/pi-tui (Tallow fork)
 
-Tallow's fork of `@mariozechner/pi-tui` (v0.52.9). Adds customizable
-loader, border styles, and input middleware — changes that require
-modifying pi-tui internals.
+Tallow vendors a local fork of `@mariozechner/pi-tui` to keep a small set
+of UI primitives that upstream still does not expose in the form tallow
+needs.
 
-## What's different from upstream
+This is **not** a tiny historical snapshot anymore. The authoritative
+upstream reference for the current reduction effort is
+`@mariozechner/pi-tui@0.67.68`.
 
-### Configurable Loader
+## Why the fork existed
 
-`Loader` accepts optional `frames` and `intervalMs` via constructor
-options. Static `Loader.defaultFrames` / `Loader.defaultIntervalMs`
-let extensions set global defaults at session start.
+The original fork was created because tallow needed a few TUI primitives
+that extension APIs could not provide directly:
 
-### Border styles
+- configurable loader defaults
+- border styles and bordered boxes
+- earlier input interception hooks
 
-New `BorderStyle` interface with three presets: `SHARP` (┌┐└┘),
-`ROUNDED` (╭╮╰╯), `FLAT` (horizontal rules only).
-`BorderedBox` component wraps content in a full border with optional
-title, padding, and color functions.
+Since then, upstream added several features that used to be local, so the
+current fork is larger than the original rationale justifies.
 
-### Input middleware
+## Long-term keep surface
 
-`TUI.addInputMiddleware(fn)` inserts a hook before `handleInput`
-forwards to the focused component. Middleware returns `true` to
-consume input. Used by the which-key overlay extension.
+The fork reduction effort is shrinking the long-term delta to only the
+smallest set of proven tallow requirements:
 
-## Upstream sync
+- border styles
+- loader global defaults and hide sentinel
+- editor ghost-text and change-listener APIs
+- minimal reset/render primitives still required by tallow
 
-Source extracted from `@mariozechner/pi-tui@0.52.9` source maps.
+Everything else is treated as revert-or-extract unless proven necessary.
 
-### Modified files (conflict surface on sync)
+## Authoritative audit
 
-| File | Change |
-|------|--------|
-| `components/loader.ts` | Constructor options, static defaults |
-| `tui.ts` | Input middleware array + add/remove methods |
+Do not trust this README alone for the current delta. The canonical
+status document is `docs/research/pi-tui-fork-audit.md`, generated and
+validated by the audit script:
 
-### Added files (zero conflict)
+```bash
+node scripts/audit-pi-tui-fork.mjs
+```
 
-| File | Purpose |
-|------|---------|
-| `border-styles.ts` | BorderStyle interface + presets |
-| `components/bordered-box.ts` | Box component with configurable borders |
+To regenerate the human-readable audit note:
 
-### How to sync
+```bash
+node scripts/audit-pi-tui-fork.mjs \
+  --write-markdown docs/research/pi-tui-fork-audit.md
+```
 
-1. Extract new upstream source from source maps (same script)
-2. Diff against `src/` — conflicts only in modified files above
-3. Apply upstream changes, keep our additions
-4. Rebuild: `cd packages/tallow-tui && npm run build`
+The generated report classifies each changed runtime file as one of:
+
+- `keep`
+- `extract`
+- `upstream`
+- `revert`
+
+## Current ownership rules
+
+- `packages/tallow-tui` should own generic TUI primitives only
+- tallow session/reset behavior belongs in `src/interactive-*.ts`, not in
+  the fork
+- application helpers should move to tallow or upstream rather than stay
+  in the fork by accident
+
+## Sync approach
+
+1. audit local-vs-upstream runtime deltas
+2. revert low-risk files first
+3. extract tallow-owned helpers out of the fork
+4. keep only the justified primitive surface
+5. shrink high-risk render/input deltas last with PTY regression tests

package/node_modules/@mariozechner/pi-tui/dist/autocomplete.d.ts

@@ -3,16 +3,22 @@ export interface AutocompleteItem {
     label: string;
     description?: string;
 }
+type Awaitable<T> = T | Promise<T>;
 export interface SlashCommand {
     name: string;
     description?: string;
-    getArgumentCompletions?(argumentPrefix: string): AutocompleteItem[] | null;
+    argumentHint?: string;
+    getArgumentCompletions?(argumentPrefix: string): Awaitable<AutocompleteItem[] | null>;
+}
+export interface AutocompleteSuggestions {
+    items: AutocompleteItem[];
+    prefix: string;
 }
 export interface AutocompleteProvider {
-    getSuggestions(lines: string[], cursorLine: number, cursorCol: number): {
-        items: AutocompleteItem[];
-        prefix: string;
-    } | null;
+    getSuggestions(lines: string[], cursorLine: number, cursorCol: number, options: {
+        signal: AbortSignal;
+        force?: boolean;
+    }): Promise<AutocompleteSuggestions | null>;
     applyCompletion(lines: string[], cursorLine: number, cursorCol: number, item: AutocompleteItem, prefix: string): {
         lines: string[];
         cursorLine: number;
@@ -24,10 +30,10 @@ export declare class CombinedAutocompleteProvider implements AutocompleteProvide
     private basePath;
     private fdPath;
     constructor(commands?: (SlashCommand | AutocompleteItem)[], basePath?: string, fdPath?: string | null);
-    getSuggestions(lines: string[], cursorLine: number, cursorCol: number): {
-        items: AutocompleteItem[];
-        prefix: string;
-    } | null;
+    getSuggestions(lines: string[], cursorLine: number, cursorCol: number, options: {
+        signal: AbortSignal;
+        force?: boolean;
+    }): Promise<AutocompleteSuggestions | null>;
     applyCompletion(lines: string[], cursorLine: number, cursorCol: number, item: AutocompleteItem, prefix: string): {
         lines: string[];
         cursorLine: number;
@@ -36,13 +42,12 @@ export declare class CombinedAutocompleteProvider implements AutocompleteProvide
     private extractAtPrefix;
     private extractPathPrefix;
     private expandHomePath;
+    private resolveScopedFuzzyQuery;
+    private scopedPathForDisplay;
     private getFileSuggestions;
     private scoreEntry;
     private getFuzzyFileSuggestions;
-    getForceFileSuggestions(lines: string[], cursorLine: number, cursorCol: number): {
-        items: AutocompleteItem[];
-        prefix: string;
-    } | null;
     shouldTriggerFileCompletion(lines: string[], cursorLine: number, cursorCol: number): boolean;
 }
+export {};
 //# sourceMappingURL=autocomplete.d.ts.map

package/node_modules/@mariozechner/pi-tui/dist/autocomplete.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"autocomplete.d.ts","sourceRoot":"","sources":["../src/autocomplete.ts"],"names":[],"mappings":"AA2JA,MAAM,WAAW,gBAAgB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,YAAY;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IAGrB,sBAAsB,CAAC,CAAC,cAAc,EAAE,MAAM,GAAG,gBAAgB,EAAE,GAAG,IAAI,CAAC;CAC3E;AAED,MAAM,WAAW,oBAAoB;IAGpC,cAAc,CACb,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,GACf;QACF,KAAK,EAAE,gBAAgB,EAAE,CAAC;QAC1B,MAAM,EAAE,MAAM,CAAC;KACf,GAAG,IAAI,CAAC;IAIT,eAAe,CACd,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,gBAAgB,EACtB,MAAM,EAAE,MAAM,GACZ;QACF,KAAK,EAAE,MAAM,EAAE,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;KAClB,CAAC;CACF;AAGD,qBAAa,4BAA6B,YAAW,oBAAoB;IACxE,OAAO,CAAC,QAAQ,CAAsC;IACtD,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,MAAM,CAAgB;gBAG7B,QAAQ,GAAE,CAAC,YAAY,GAAG,gBAAgB,CAAC,EAAO,EAClD,QAAQ,GAAE,MAAsB,EAChC,MAAM,GAAE,MAAM,GAAG,IAAW;IAO7B,cAAc,CACb,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,GACf;QAAE,KAAK,EAAE,gBAAgB,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAqGvD,eAAe,CACd,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,gBAAgB,EACtB,MAAM,EAAE,MAAM,GACZ;QAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE;IAwF7D,OAAO,CAAC,eAAe;IAiBvB,OAAO,CAAC,iBAAiB;IA8BzB,OAAO,CAAC,cAAc;IAYtB,OAAO,CAAC,kBAAkB;IAoI1B,OAAO,CAAC,UAAU;IAuBlB,OAAO,CAAC,uBAAuB;IAkD/B,uBAAuB,CACtB,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,GACf;QAAE,KAAK,EAAE,gBAAgB,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAyBvD,2BAA2B,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO;CAW5F"}
+{"version":3,"file":"autocomplete.d.ts","sourceRoot":"","sources":["../src/autocomplete.ts"],"names":[],"mappings":"AA8NA,MAAM,WAAW,gBAAgB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,KAAK,SAAS,CAAC,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAEnC,MAAM,WAAW,YAAY;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IAGtB,sBAAsB,CAAC,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC,gBAAgB,EAAE,GAAG,IAAI,CAAC,CAAC;CACtF;AAED,MAAM,WAAW,uBAAuB;IACvC,KAAK,EAAE,gBAAgB,EAAE,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,oBAAoB;IAGpC,cAAc,CACb,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE;QAAE,MAAM,EAAE,WAAW,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,GAC/C,OAAO,CAAC,uBAAuB,GAAG,IAAI,CAAC,CAAC;IAI3C,eAAe,CACd,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,gBAAgB,EACtB,MAAM,EAAE,MAAM,GACZ;QACF,KAAK,EAAE,MAAM,EAAE,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;KAClB,CAAC;CACF;AAGD,qBAAa,4BAA6B,YAAW,oBAAoB;IACxE,OAAO,CAAC,QAAQ,CAAsC;IACtD,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,MAAM,CAAgB;gBAG7B,QAAQ,GAAE,CAAC,YAAY,GAAG,gBAAgB,CAAC,EAAO,EAClD,QAAQ,GAAE,MAAsB,EAChC,MAAM,GAAE,MAAM,GAAG,IAAW;IAOvB,cAAc,CACnB,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE;QAAE,MAAM,EAAE,WAAW,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,GAC/C,OAAO,CAAC,uBAAuB,GAAG,IAAI,CAAC;IAsF1C,eAAe,CACd,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,gBAAgB,EACtB,MAAM,EAAE,MAAM,GACZ;QAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE;IAwF7D,OAAO,CAAC,eAAe;IAiBvB,OAAO,CAAC,iBAAiB;IA8BzB,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,uBAAuB;IAgC/B,OAAO,CAAC,oBAAoB;IAS5B,OAAO,CAAC,kBAAkB;IAyI1B,OAAO,CAAC,UAAU;YAuBJ,uBAAuB;IA6DrC,2BAA2B,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO;CAW5F"}

package/node_modules/@mariozechner/pi-tui/dist/autocomplete.js

@@ -1,9 +1,39 @@
-import { spawnSync } from "node:child_process";
+import { spawn } from "node:child_process";
 import { readdirSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, dirname, join } from "node:path";
 import { fuzzyFilter } from "./fuzzy.js";
 const PATH_DELIMITERS = new Set([" ", "\t", '"', "'", "="]);
+function toDisplayPath(value) {
+    return value.replace(/\\/g, "/");
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildFdPathQuery(query) {
+    const normalized = toDisplayPath(query);
+    if (!normalized.includes("/")) {
+        return normalized;
+    }
+    const hasTrailingSeparator = normalized.endsWith("/");
+    const trimmed = normalized.replace(/^\/+|\/+$/g, "");
+    if (!trimmed) {
+        return normalized;
+    }
+    const separatorPattern = "[\\\\/]";
+    const segments = trimmed
+        .split("/")
+        .filter(Boolean)
+        .map((segment) => escapeRegex(segment));
+    if (segments.length === 0) {
+        return normalized;
+    }
+    let pattern = segments.join(separatorPattern);
+    if (hasTrailingSeparator) {
+        pattern += separatorPattern;
+    }
+    return pattern;
+}
 function findLastDelimiter(text) {
     for (let i = text.length - 1; i >= 0; i -= 1) {
         if (PATH_DELIMITERS.has(text[i] ?? "")) {
@@ -67,7 +97,7 @@ function buildCompletionValue(path, options) {
     return `${openQuote}${path}${closeQuote}`;
 }
 // Use fd to walk directory tree (fast, respects .gitignore)
-function walkDirectoryWithFd(baseDir, fdPath, query, maxResults) {
+async function walkDirectoryWithFd(baseDir, fdPath, query, maxResults, signal) {
     const args = [
         "--base-directory",
         baseDir,
@@ -86,35 +116,63 @@ function walkDirectoryWithFd(baseDir, fdPath, query, maxResults) {
         "--exclude",
         ".git/**",
     ];
-    // Add query as pattern if provided
     if (query) {
-        args.push(query);
+        args.push(buildFdPathQuery(query));
     }
-    const result = spawnSync(fdPath, args, {
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"],
-        maxBuffer: 10 * 1024 * 1024,
-    });
-    if (result.status !== 0 || !result.stdout) {
-        return [];
-    }
-    const lines = result.stdout.trim().split("\n").filter(Boolean);
-    const results = [];
-    for (const line of lines) {
-        const normalizedPath = line.endsWith("/") ? line.slice(0, -1) : line;
-        if (normalizedPath === ".git" ||
-            normalizedPath.startsWith(".git/") ||
-            normalizedPath.includes("/.git/")) {
-            continue;
+    return await new Promise((resolve) => {
+        if (signal.aborted) {
+            resolve([]);
+            return;
         }
-        // fd outputs directories with trailing /
-        const isDirectory = line.endsWith("/");
-        results.push({
-            path: line,
-            isDirectory,
+        const child = spawn(fdPath, args, {
+            stdio: ["ignore", "pipe", "pipe"],
         });
-    }
-    return results;
+        let stdout = "";
+        let resolved = false;
+        const finish = (results) => {
+            if (resolved)
+                return;
+            resolved = true;
+            signal.removeEventListener("abort", onAbort);
+            resolve(results);
+        };
+        const onAbort = () => {
+            if (child.exitCode === null) {
+                child.kill("SIGKILL");
+            }
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        child.stdout.setEncoding("utf-8");
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.on("error", () => {
+            finish([]);
+        });
+        child.on("close", (code) => {
+            if (signal.aborted || code !== 0 || !stdout) {
+                finish([]);
+                return;
+            }
+            const lines = stdout.trim().split("\n").filter(Boolean);
+            const results = [];
+            for (const line of lines) {
+                const displayLine = toDisplayPath(line);
+                const hasTrailingSeparator = displayLine.endsWith("/");
+                const normalizedPath = hasTrailingSeparator ? displayLine.slice(0, -1) : displayLine;
+                if (normalizedPath === ".git" ||
+                    normalizedPath.startsWith(".git/") ||
+                    normalizedPath.includes("/.git/")) {
+                    continue;
+                }
+                results.push({
+                    path: displayLine,
+                    isDirectory: hasTrailingSeparator,
+                });
+            }
+            finish(results);
+        });
+    });
 }
 // Combined provider that handles both slash commands and file paths
 export class CombinedAutocompleteProvider {
@@ -126,15 +184,15 @@ export class CombinedAutocompleteProvider {
         this.basePath = basePath;
         this.fdPath = fdPath;
     }
-    getSuggestions(lines, cursorLine, cursorCol) {
+    async getSuggestions(lines, cursorLine, cursorCol, options) {
         const currentLine = lines[cursorLine] || "";
         const textBeforeCursor = currentLine.slice(0, cursorCol);
-        // Check for @ file reference (fuzzy search) - must be after a delimiter or at start
         const atPrefix = this.extractAtPrefix(textBeforeCursor);
         if (atPrefix) {
             const { rawPrefix, isQuotedPrefix } = parsePathPrefix(atPrefix);
-            const suggestions = this.getFuzzyFileSuggestions(rawPrefix, {
-                isQuotedPrefix: isQuotedPrefix,
+            const suggestions = await this.getFuzzyFileSuggestions(rawPrefix, {
+                isQuotedPrefix,
+                signal: options.signal,
             });
             if (suggestions.length === 0)
                 return null;
@@ -143,17 +201,21 @@ export class CombinedAutocompleteProvider {
                 prefix: atPrefix,
             };
         }
-        // Check for slash commands
-        if (textBeforeCursor.startsWith("/")) {
+        if (!options.force && textBeforeCursor.startsWith("/")) {
             const spaceIndex = textBeforeCursor.indexOf(" ");
             if (spaceIndex === -1) {
-                // No space yet - complete command names with fuzzy matching
-                const prefix = textBeforeCursor.slice(1); // Remove the "/"
-                const commandItems = this.commands.map((cmd) => ({
-                    name: "name" in cmd ? cmd.name : cmd.value,
-                    label: "name" in cmd ? cmd.name : cmd.label,
-                    description: cmd.description,
-                }));
+                const prefix = textBeforeCursor.slice(1);
+                const commandItems = this.commands.map((cmd) => {
+                    const name = "name" in cmd ? cmd.name : cmd.value;
+                    const hint = "argumentHint" in cmd && cmd.argumentHint ? cmd.argumentHint : undefined;
+                    const desc = cmd.description ?? "";
+                    const fullDesc = hint ? (desc ? `${hint} — ${desc}` : hint) : desc;
+                    return {
+                        name,
+                        label: name,
+                        description: fullDesc || undefined,
+                    };
+                });
                 const filtered = fuzzyFilter(commandItems, prefix, (item) => item.name).map((item) => ({
                     value: item.name,
                     label: item.label,
@@ -166,52 +228,35 @@ export class CombinedAutocompleteProvider {
                     prefix: textBeforeCursor,
                 };
             }
-            else {
-                // Space found - complete command arguments
-                const commandName = textBeforeCursor.slice(1, spaceIndex); // Command without "/"
-                const argumentText = textBeforeCursor.slice(spaceIndex + 1); // Text after space
-                const command = this.commands.find((cmd) => {
-                    const name = "name" in cmd ? cmd.name : cmd.value;
-                    return name === commandName;
-                });
-                if (!command || !("getArgumentCompletions" in command) || !command.getArgumentCompletions) {
-                    return null; // No argument completion for this command
-                }
-                const argumentSuggestions = command.getArgumentCompletions(argumentText);
-                if (!argumentSuggestions || argumentSuggestions.length === 0) {
-                    return null;
-                }
-                return {
-                    items: argumentSuggestions,
-                    prefix: argumentText,
-                };
+            const commandName = textBeforeCursor.slice(1, spaceIndex);
+            const argumentText = textBeforeCursor.slice(spaceIndex + 1);
+            const command = this.commands.find((cmd) => {
+                const name = "name" in cmd ? cmd.name : cmd.value;
+                return name === commandName;
+            });
+            if (!command || !("getArgumentCompletions" in command) || !command.getArgumentCompletions) {
+                return null;
             }
-        }
-        // Check for file paths - triggered by Tab or if we detect a path pattern
-        const pathMatch = this.extractPathPrefix(textBeforeCursor, false);
-        if (pathMatch !== null) {
-            const suggestions = this.getFileSuggestions(pathMatch);
-            if (suggestions.length === 0)
+            const argumentSuggestions = await command.getArgumentCompletions(argumentText);
+            if (!Array.isArray(argumentSuggestions) || argumentSuggestions.length === 0) {
                 return null;
-            // Check if we have an exact match that is a directory
-            // In that case, we might want to return suggestions for the directory content instead
-            // But only if the prefix ends with /
-            if (suggestions.length === 1 &&
-                suggestions[0]?.value === pathMatch &&
-                !pathMatch.endsWith("/")) {
-                // Exact match found (e.g. user typed "src" and "src/" is the only match)
-                // We still return it so user can select it and add /
-                return {
-                    items: suggestions,
-                    prefix: pathMatch,
-                };
             }
             return {
-                items: suggestions,
-                prefix: pathMatch,
+                items: argumentSuggestions,
+                prefix: argumentText,
             };
         }
-        return null;
+        const pathMatch = this.extractPathPrefix(textBeforeCursor, options.force ?? false);
+        if (pathMatch === null) {
+            return null;
+        }
+        const suggestions = this.getFileSuggestions(pathMatch);
+        if (suggestions.length === 0)
+            return null;
+        return {
+            items: suggestions,
+            prefix: pathMatch,
+        };
     }
     applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
         const currentLine = lines[cursorLine] || "";
@@ -332,6 +377,41 @@ export class CombinedAutocompleteProvider {
         }
         return path;
     }
+    resolveScopedFuzzyQuery(rawQuery) {
+        const normalizedQuery = toDisplayPath(rawQuery);
+        const slashIndex = normalizedQuery.lastIndexOf("/");
+        if (slashIndex === -1) {
+            return null;
+        }
+        const displayBase = normalizedQuery.slice(0, slashIndex + 1);
+        const query = normalizedQuery.slice(slashIndex + 1);
+        let baseDir;
+        if (displayBase.startsWith("~/")) {
+            baseDir = this.expandHomePath(displayBase);
+        }
+        else if (displayBase.startsWith("/")) {
+            baseDir = displayBase;
+        }
+        else {
+            baseDir = join(this.basePath, displayBase);
+        }
+        try {
+            if (!statSync(baseDir).isDirectory()) {
+                return null;
+            }
+        }
+        catch {
+            return null;
+        }
+        return { baseDir, query, displayBase };
+    }
+    scopedPathForDisplay(displayBase, relativePath) {
+        const normalizedRelativePath = toDisplayPath(relativePath);
+        if (displayBase === "/") {
+            return `/${normalizedRelativePath}`;
+        }
+        return `${toDisplayPath(displayBase)}${normalizedRelativePath}`;
+    }
     // Get file/directory suggestions for a given path prefix
     getFileSuggestions(prefix) {
         try {
@@ -406,7 +486,7 @@ export class CombinedAutocompleteProvider {
                     // If prefix ends with /, append entry to the prefix
                     relativePath = displayPrefix + name;
                 }
-                else if (displayPrefix.includes("/")) {
+                else if (displayPrefix.includes("/") || displayPrefix.includes("\\")) {
                     // Preserve ~/ format for home directory paths
                     if (displayPrefix.startsWith("~/")) {
                         const homeRelativeDir = displayPrefix.slice(2); // Remove ~/
@@ -425,6 +505,10 @@ export class CombinedAutocompleteProvider {
                     }
                     else {
                         relativePath = join(dirname(displayPrefix), name);
+                        // path.join normalizes away ./ prefix, preserve it
+                        if (displayPrefix.startsWith("./") && !relativePath.startsWith("./")) {
+                            relativePath = `./${relativePath}`;
+                        }
                     }
                 }
                 else {
@@ -436,6 +520,7 @@ export class CombinedAutocompleteProvider {
                         relativePath = name;
                     }
                 }
+                relativePath = toDisplayPath(relativePath);
                 const pathValue = isDirectory ? `${relativePath}/` : relativePath;
                 const value = buildCompletionValue(pathValue, {
                     isDirectory,
@@ -489,30 +574,35 @@ export class CombinedAutocompleteProvider {
         return score;
     }
     // Fuzzy file search using fd (fast, respects .gitignore)
-    getFuzzyFileSuggestions(query, options) {
-        if (!this.fdPath) {
-            // fd not available, return empty results
+    async getFuzzyFileSuggestions(query, options) {
+        if (!this.fdPath || options.signal.aborted) {
             return [];
         }
         try {
-            const entries = walkDirectoryWithFd(this.basePath, this.fdPath, query, 100);
-            // Score entries
+            const scopedQuery = this.resolveScopedFuzzyQuery(query);
+            const fdBaseDir = scopedQuery?.baseDir ?? this.basePath;
+            const fdQuery = scopedQuery?.query ?? query;
+            const entries = await walkDirectoryWithFd(fdBaseDir, this.fdPath, fdQuery, 100, options.signal);
+            if (options.signal.aborted) {
+                return [];
+            }
             const scoredEntries = entries
                 .map((entry) => ({
                 ...entry,
-                score: query ? this.scoreEntry(entry.path, query, entry.isDirectory) : 1,
+                score: fdQuery ? this.scoreEntry(entry.path, fdQuery, entry.isDirectory) : 1,
             }))
                 .filter((entry) => entry.score > 0);
-            // Sort by score (descending) and take top 20
             scoredEntries.sort((a, b) => b.score - a.score);
             const topEntries = scoredEntries.slice(0, 20);
-            // Build suggestions
             const suggestions = [];
             for (const { path: entryPath, isDirectory } of topEntries) {
-                // fd already includes trailing / for directories
                 const pathWithoutSlash = isDirectory ? entryPath.slice(0, -1) : entryPath;
+                const displayPath = scopedQuery
+                    ? this.scopedPathForDisplay(scopedQuery.displayBase, pathWithoutSlash)
+                    : pathWithoutSlash;
                 const entryName = basename(pathWithoutSlash);
-                const value = buildCompletionValue(entryPath, {
+                const completionPath = isDirectory ? `${displayPath}/` : displayPath;
+                const value = buildCompletionValue(completionPath, {
                     isDirectory,
                     isAtPrefix: true,
                     isQuotedPrefix: options.isQuotedPrefix,
@@ -520,7 +610,7 @@ export class CombinedAutocompleteProvider {
                 suggestions.push({
                     value,
                     label: entryName + (isDirectory ? "/" : ""),
-                    description: pathWithoutSlash,
+                    description: displayPath,
                 });
             }
             return suggestions;
@@ -529,27 +619,6 @@ export class CombinedAutocompleteProvider {
             return [];
         }
     }
-    // Force file completion (called on Tab key) - always returns suggestions
-    getForceFileSuggestions(lines, cursorLine, cursorCol) {
-        const currentLine = lines[cursorLine] || "";
-        const textBeforeCursor = currentLine.slice(0, cursorCol);
-        // Don't trigger if we're typing a slash command at the start of the line
-        if (textBeforeCursor.trim().startsWith("/") && !textBeforeCursor.trim().includes(" ")) {
-            return null;
-        }
-        // Force extract path prefix - this will always return something
-        const pathMatch = this.extractPathPrefix(textBeforeCursor, true);
-        if (pathMatch !== null) {
-            const suggestions = this.getFileSuggestions(pathMatch);
-            if (suggestions.length === 0)
-                return null;
-            return {
-                items: suggestions,
-                prefix: pathMatch,
-            };
-        }
-        return null;
-    }
     // Check if we should trigger file completion (called on Tab key)
     shouldTriggerFileCompletion(lines, cursorLine, cursorCol) {
         const currentLine = lines[cursorLine] || "";