@dungle-scrubs/tallow 0.9.4 → 0.9.6

package/extensions/render-stabilizer/index.ts

@@ -43,15 +43,15 @@ function captureTuiRef(ui: {
 /**
  * Register render stabilization hooks.
  *
+ * The shared reset helper now owns reset-grace handling for the main
+ * interactive reset paths. This extension remains as a compatibility shim
+ * for any remaining session-switch surfaces that still depend on an
+ * extension-side hook.
+ *
  * @param pi - Extension API
  */
 export default function renderStabilizerExtension(pi: ExtensionAPI): void {
-	// Capture the TUI reference on first session_start
-	pi.on("session_start", async (_event, ctx) => {
-		captureTuiRef(ctx.ui);
-	});
-
-	// Reset the render grace period before a session switch so the
+	// Reset the render grace period before a legacy session switch so the
 	// chatContainer.clear() → renderInitialMessages() transition uses
 	// gentle line-by-line redraws instead of screen-clearing redraws.
 	pi.on("session_before_switch", async (_event, ctx) => {

package/extensions/slash-command-bridge/__tests__/slash-command-bridge.test.ts

@@ -13,6 +13,10 @@ import type {
 	ExtensionUIContext,
 	TurnEndEvent,
 } from "@mariozechner/pi-coding-agent";
+import {
+	getResetDiagnosticsForTests,
+	resetResetDiagnosticsForTests,
+} from "../../../src/reset-diagnostics.js";
 import { ExtensionHarness } from "../../../test-utils/extension-harness.js";
 import { ManualTimerScheduler } from "../../../test-utils/manual-timer-scheduler.js";
 import slashCommandBridge, {
@@ -40,6 +44,7 @@ beforeEach(async () => {
 });
 
 afterEach(() => {
+	resetResetDiagnosticsForTests();
 	resetSlashCommandBridgeStateForTests();
 });
 
@@ -314,6 +319,11 @@ describe("compact", () => {
 		const continuation = harness.sentMessages.find(
 			(message) => message.customType === "compact-continue"
 		);
+		expect(
+			getResetDiagnosticsForTests().some(
+				(event) => event.kind === "deferred_registered" && event.source === "slash-command-bridge"
+			)
+		).toBe(true);
 		expect(continuation?.display).toBe(false);
 		expect(continuation?.options?.triggerTurn).toBe(true);
 		expect(continuation?.content).toContain("compaction is complete");
@@ -344,6 +354,14 @@ describe("compact", () => {
 		await harness.fireEvent("turn_start", { type: "turn_start", turnIndex: 0, timestamp: 0 }, ctx);
 		scheduler.advanceBy(200);
 
+		expect(
+			getResetDiagnosticsForTests().some(
+				(event) =>
+					event.kind === "deferred_cancelled" &&
+					event.source === "slash-command-bridge" &&
+					event.reason === "turn_start"
+			)
+		).toBe(true);
 		expect(harness.sentMessages).toHaveLength(0);
 		expect(widgetUpdates.at(-1)).toEqual({ key: "compact-progress", content: undefined });
 	});
@@ -374,6 +392,14 @@ describe("compact", () => {
 		compactOptions?.onComplete?.();
 		scheduler.advanceBy(200);
 
+		expect(
+			getResetDiagnosticsForTests().some(
+				(event) =>
+					event.kind === "deferred_dropped" &&
+					event.source === "slash-command-bridge" &&
+					event.reason === "session_not_idle"
+			)
+		).toBe(true);
 		expect(harness.sentMessages).toHaveLength(0);
 		expect(widgetUpdates.at(-1)).toEqual({ key: "compact-progress", content: undefined });
 		expect(workingMessages.at(-1)).toBeUndefined();

package/extensions/slash-command-bridge/index.ts

@@ -17,6 +17,7 @@ import type {
 } from "@mariozechner/pi-coding-agent";
 import { Text } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
+import { recordResetDiagnostic } from "../../src/reset-diagnostics.js";
 
 /**
  * Deferred compact request — set by the tool handler, consumed on the first
@@ -154,13 +155,18 @@ function stopCompactProgress(ctx?: ExtensionContext): void {
  *
  * @returns Nothing
  */
-function clearContinuationTimer(): void {
+function clearContinuationTimer(reason?: string): void {
 	if (!continuationTimer) {
 		return;
 	}
 
 	timerScheduler.clearTimeout(continuationTimer);
 	continuationTimer = null;
+	recordResetDiagnostic({
+		kind: "deferred_cancelled",
+		reason: reason ?? "clear_continuation_timer",
+		source: "slash-command-bridge",
+	});
 }
 
 /**
@@ -338,6 +344,7 @@ function startDeferredCompact(
 			// 200ms gives session.prompt()'s async setup (API key resolution,
 			// compaction check) time to settle. The turn_start listener cancels
 			// this timer if a turn starts before it fires (defense-in-depth).
+			recordResetDiagnostic({ kind: "deferred_registered", source: "slash-command-bridge" });
 			continuationTimer = timerScheduler.setTimeout(() => {
 				continuationTimer = null;
 				if (ctx.isIdle()) {
@@ -354,6 +361,11 @@ function startDeferredCompact(
 				} else {
 					// User sent a message during compaction — their turn is
 					// handling things, clean up our indicators.
+					recordResetDiagnostic({
+						kind: "deferred_dropped",
+						reason: "session_not_idle",
+						source: "slash-command-bridge",
+					});
 					resumingAfterCompact = false;
 					ctx.ui?.setWidget?.("compact-progress", undefined);
 					ctx.ui?.setWorkingMessage?.();
@@ -601,7 +613,7 @@ WHEN NOT TO USE:
 	 * now active and showing the pending working message ("Resuming task…").
 	 */
 	pi.on("turn_start", (_event, ctx) => {
-		clearContinuationTimer();
+		clearContinuationTimer("turn_start");
 		if (!resumingAfterCompact) return;
 		resumingAfterCompact = false;
 		ctx.ui?.setWidget?.("compact-progress", undefined);

package/extensions/subagent-tool/model-resolver.ts

@@ -1,12 +1,279 @@
 /**
- * Fuzzy model name resolution — re-exports from synapse.
+ * Deterministic fuzzy model resolution for subagents.
+ *
+ * We keep a local implementation instead of delegating straight to synapse
+ * because the direct dependency path was flaky under Linux CI in this repo.
+ * The behavior mirrors synapse's public resolver cascade closely enough for
+ * runtime callers and keeps tests deterministic across platforms.
  *
  * @module
  */
 
-export type { ModelSource, ResolvedModel } from "@dungle-scrubs/synapse";
-export {
-	listAvailableModels,
-	resolveModelCandidates,
-	resolveModelFuzzy,
-} from "@dungle-scrubs/synapse";
+import type { CandidateModel, ModelSource, ResolvedModel } from "@dungle-scrubs/synapse";
+import { getModels, getProviders } from "@mariozechner/pi-ai";
+
+export type { ModelSource, ResolvedModel };
+
+/**
+ * Collect all models from the registered pi-ai providers.
+ *
+ * @returns Flat list of candidate models
+ */
+function getAllModels(): CandidateModel[] {
+	const result: CandidateModel[] = [];
+	for (const provider of getProviders()) {
+		for (const model of getModels(provider)) {
+			result.push({ provider: model.provider, id: model.id, name: model.name });
+		}
+	}
+	return result;
+}
+
+/**
+ * Convert a candidate model into the resolved public shape.
+ *
+ * @param model - Candidate model
+ * @returns Resolved model descriptor
+ */
+function toResolved(model: CandidateModel): ResolvedModel {
+	return {
+		displayName: `${model.provider}/${model.id}`,
+		id: model.id,
+		provider: model.provider,
+	};
+}
+
+/**
+ * Tokenize a query or model identifier for overlap matching.
+ *
+ * @param value - Raw query or identifier
+ * @returns Lowercase tokens split on separators and digit boundaries
+ */
+function tokenize(value: string): string[] {
+	return value
+		.toLowerCase()
+		.replace(/([a-z])(\d)/g, "$1 $2")
+		.replace(/(\d)([a-z])/g, "$1 $2")
+		.split(/[\s\-_.]+/)
+		.filter((token) => token.length > 0);
+}
+
+/**
+ * Normalize a query or identifier by removing separators.
+ *
+ * @param value - Raw query or identifier
+ * @returns Lowercase normalized string
+ */
+function normalize(value: string): string {
+	return value.toLowerCase().replace(/[\s\-_.]+/g, "");
+}
+
+/**
+ * Compare model IDs using numeric-aware sorting.
+ *
+ * @param a - First model ID
+ * @param b - Second model ID
+ * @returns Positive when a is newer/higher than b
+ */
+function compareModelIds(a: string, b: string): number {
+	return a.localeCompare(b, undefined, { numeric: true, sensitivity: "base" });
+}
+
+/**
+ * Build a provider-priority lookup map.
+ *
+ * @param preferredProviders - Ordered provider preference list
+ * @returns Provider -> priority map (lower is better)
+ */
+function buildProviderPreferenceMap(
+	preferredProviders: readonly string[] | undefined
+): ReadonlyMap<string, number> {
+	const priorities = new Map<string, number>();
+	for (const [index, provider] of (preferredProviders ?? []).entries()) {
+		priorities.set(provider.toLowerCase(), index);
+	}
+	return priorities;
+}
+
+/**
+ * Resolve one provider's priority, defaulting unknown providers last.
+ *
+ * @param preferenceMap - Provider priority map
+ * @param provider - Provider to score
+ * @returns Numeric priority (lower is better)
+ */
+function getProviderPriority(preferenceMap: ReadonlyMap<string, number>, provider: string): number {
+	return preferenceMap.get(provider.toLowerCase()) ?? Number.MAX_SAFE_INTEGER;
+}
+
+/**
+ * Pick the best candidate by ID quality only.
+ *
+ * Tiebreak order:
+ * 1. Higher numeric-aware model ID
+ * 2. Shorter ID when numeric ordering ties
+ * 3. Lexicographically last as deterministic fallback
+ *
+ * @param models - Candidate models
+ * @returns Best candidate
+ */
+function pickBestModel(models: readonly CandidateModel[]): CandidateModel {
+	return models.reduce((best, current) => {
+		const versionDiff = compareModelIds(best.id, current.id);
+		if (versionDiff !== 0) {
+			return versionDiff > 0 ? best : current;
+		}
+		if (best.id.length !== current.id.length) {
+			return best.id.length < current.id.length ? best : current;
+		}
+		return best.id >= current.id ? best : current;
+	});
+}
+
+/**
+ * Pick the best final candidate, optionally preferring specific providers.
+ *
+ * @param models - Candidate models
+ * @param preferredProviders - Ordered provider preference list
+ * @returns Best candidate
+ */
+function pickBest(
+	models: readonly CandidateModel[],
+	preferredProviders?: readonly string[]
+): CandidateModel {
+	const bestModel = pickBestModel(models);
+	if (!preferredProviders || preferredProviders.length === 0) {
+		return bestModel;
+	}
+
+	const sameModel = models.filter((model) => model.id === bestModel.id);
+	if (sameModel.length <= 1) {
+		return bestModel;
+	}
+
+	const preferenceMap = buildProviderPreferenceMap(preferredProviders);
+	return sameModel.reduce((best, current) => {
+		return getProviderPriority(preferenceMap, best.provider) <=
+			getProviderPriority(preferenceMap, current.provider)
+			? best
+			: current;
+	});
+}
+
+/**
+ * Find all candidates that tie at the best score for the first matching tier.
+ *
+ * Resolution cascade:
+ * 1. Exact ID match
+ * 2. Case-insensitive ID match
+ * 3. Normalized ID match (strips separators)
+ * 4. Provider/ID exact match
+ * 5. Token overlap scoring
+ * 6. Raw substring match
+ * 7. Normalized substring match
+ *
+ * @param query - Human-friendly query
+ * @param modelSource - Optional injected model source
+ * @returns Tied candidates from the first matching tier
+ */
+function findCandidates(query: string, modelSource?: ModelSource): CandidateModel[] {
+	const models = modelSource ? modelSource() : getAllModels();
+	if (models.length === 0) return [];
+
+	const trimmed = query.trim();
+	if (trimmed.length === 0) return [];
+
+	const lower = trimmed.toLowerCase();
+	const normalized = normalize(trimmed);
+
+	const exact = models.filter((model) => model.id === trimmed);
+	if (exact.length > 0) return exact;
+
+	const caseInsensitive = models.filter((model) => model.id.toLowerCase() === lower);
+	if (caseInsensitive.length > 0) return caseInsensitive;
+
+	const normalizedId = models.filter((model) => normalize(model.id) === normalized);
+	if (normalizedId.length > 0) return normalizedId;
+
+	if (trimmed.includes("/")) {
+		const slashIndex = trimmed.indexOf("/");
+		const provider = trimmed.slice(0, slashIndex).toLowerCase();
+		const id = trimmed.slice(slashIndex + 1).toLowerCase();
+		const providerMatch = models.filter(
+			(model) => model.provider.toLowerCase() === provider && model.id.toLowerCase() === id
+		);
+		if (providerMatch.length > 0) return providerMatch;
+	}
+
+	const queryTokens = tokenize(trimmed);
+	if (queryTokens.length > 0) {
+		let bestScore = 0;
+		let bestMatches: CandidateModel[] = [];
+		for (const model of models) {
+			const idName = `${model.id} ${model.name}`.toLowerCase();
+			const providerText = model.provider.toLowerCase();
+			let score = 0;
+			for (const token of queryTokens) {
+				if (idName.includes(token)) score += 2;
+				else if (providerText.includes(token)) score += 1;
+			}
+			if (score > bestScore) {
+				bestScore = score;
+				bestMatches = [model];
+			} else if (score === bestScore && score > 0) {
+				bestMatches.push(model);
+			}
+		}
+		if (bestMatches.length > 0) return bestMatches;
+	}
+
+	const substring = models.filter(
+		(model) => model.id.toLowerCase().includes(lower) || model.name.toLowerCase().includes(lower)
+	);
+	if (substring.length > 0) return substring;
+
+	return models.filter(
+		(model) =>
+			normalize(model.id).includes(normalized) || normalize(model.name).includes(normalized)
+	);
+}
+
+/**
+ * Resolve a fuzzy model query to one best match.
+ *
+ * @param query - Human-friendly model query
+ * @param modelSource - Optional injected model source for deterministic tests
+ * @param preferredProviders - Optional provider preference ordering
+ * @returns Best matching model or undefined
+ */
+export function resolveModelFuzzy(
+	query: string,
+	modelSource?: ModelSource,
+	preferredProviders?: string[]
+): ResolvedModel | undefined {
+	const candidates = findCandidates(query, modelSource);
+	if (candidates.length === 0) return undefined;
+	return toResolved(pickBest(candidates, preferredProviders));
+}
+
+/**
+ * Resolve a fuzzy model query to all tied candidates.
+ *
+ * @param query - Human-friendly model query
+ * @param modelSource - Optional injected model source for deterministic tests
+ * @returns Candidate matches
+ */
+export function resolveModelCandidates(query: string, modelSource?: ModelSource): ResolvedModel[] {
+	return findCandidates(query, modelSource).map(toResolved);
+}
+
+/**
+ * List available provider/model identifiers.
+ *
+ * @param modelSource - Optional injected model source for deterministic tests
+ * @returns Provider/model identifier strings
+ */
+export function listAvailableModels(modelSource?: ModelSource): string[] {
+	const models = modelSource ? modelSource() : getAllModels();
+	return models.map((model) => `${model.provider}/${model.id}`);
+}

package/extensions/tasks/commands/register-tasks-extension.ts

@@ -2168,15 +2168,15 @@ Before calling manage_tasks complete/update, call manage_tasks list first so ind
 		updateAgentBar(ctx);
 	}
 
-	pi.on("session_start", async (_event, ctx) => {
-		restoreSessionState(ctx);
-	});
-
-	pi.on("session_switch", async (_event, ctx) => {
-		restoreSessionState(ctx);
-	});
-
-	// Cleanup on session end
+	pi.on("session_start", async (_event, ctx) => restoreSessionState(ctx));
+	(
+		pi as unknown as {
+			on: (
+				event: string,
+				handler: (event: unknown, ctx: ExtensionContext) => Promise<void>
+			) => void;
+		}
+	).on("session_switch", async (_event, ctx) => restoreSessionState(ctx));
 	pi.on("session_shutdown", async () => {
 		emitInteropEvent(pi.events, INTEROP_EVENT_NAMES.backgroundTasksPresenterState, {
 			active: false,

package/extensions/teams-tool/tools/register-extension.ts

@@ -20,7 +20,7 @@
  */
 
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
-import { Key, Loader, Text, type TUI } from "@mariozechner/pi-tui";
+import { Key, Text, type TUI } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { INTEROP_EVENT_NAMES, onInteropEvent } from "../../_shared/interop-events.js";
 import {
@@ -248,7 +248,6 @@ export function registerTeamsToolExtension(pi: ExtensionAPI): void {
 		dashboardEnabled = true;
 		setDashboardFlag(true);
 		startDashboardTicker();
-		ctx.ui.setWorkingMessage(Loader.HIDE);
 		ctx.ui.setStatus("team-dashboard", "Team dashboard active");
 		ctx.ui.setEditorComponent((tui, editorTheme, keybindings) => {
 			enterDashboardViewport(tui);
@@ -322,7 +321,6 @@ export function registerTeamsToolExtension(pi: ExtensionAPI): void {
 
 	pi.on("turn_start", async (_event, ctx) => {
 		if (!dashboardEnabled || !ctx.hasUI) return;
-		ctx.ui.setWorkingMessage(Loader.HIDE);
 	});
 
 	// Archive all teams on session shutdown (preserves tasks for future recovery)

package/extensions/web-search-tool/index.ts

@@ -12,9 +12,10 @@
  */
 
 import type { ExtensionAPI, ThemeColor } from "@mariozechner/pi-coding-agent";
-import { hyperlink, Text } from "@mariozechner/pi-tui";
+import { Text } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { getIcon } from "../_icons/index.js";
+import { hyperlink } from "../_shared/terminal-links.js";
 import { formatToolVerb, renderLines } from "../tool-display/index.js";
 import { BraveSearchProvider } from "./providers/brave.js";
 import { SearchError, type SearchProvider, type SearchResult } from "./providers/interface.js";

package/extensions/write-tool-enhanced/index.ts

@@ -2,8 +2,9 @@
  * Enhanced write tool — shows full written content with summary footer.
  */
 import { createWriteTool, type ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { fileLink, Text } from "@mariozechner/pi-tui";
+import { Text } from "@mariozechner/pi-tui";
 import { getIcon } from "../_icons/index.js";
+import { fileLink } from "../_shared/terminal-links.js";
 import {
 	appendSection,
 	dimProcessOutputLine,

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