pi-ghost-autocomplete 0.9.0 → 0.10.0

package/dist/providers/openai-compat-provider.d.ts

@@ -25,6 +25,10 @@ export declare class OpenAICompatProvider implements GhostProvider {
     readonly name: string;
     /** Why the most recent `fireOne` resolved empty; consumed by the editor. */
     private lastEmptyReason;
+    /** Snapshot of `PI_GHOST_FIM_CONTEXT_ALL_INTENTS`, read once at construction
+     *  instead of per `predict` (#3 — `buildFIMPrompt` previously read
+     *  `process.env` on every prediction). */
+    private readonly fimContextAllIntentsRaw;
     constructor(config: OpenAICompatProviderConfig);
     get debounceMs(): number;
     /**
@@ -66,7 +70,7 @@ export declare function fimContextIncluded(intent: PromptIntent | undefined, all
  * `question` intents, where the context is dropped to avoid the empty-rate
  * spike described on {@link FIM_CONTEXT_SUPPRESSED_INTENTS}.
  */
-export declare function buildFIMPrompt(req: GhostRequest, maxRecent: number): {
+export declare function buildFIMPrompt(req: GhostRequest, maxRecent: number, fimContextAllIntentsRaw?: string): {
     prompt: string;
     suffix: string;
 };

package/dist/providers/race.d.ts

@@ -41,6 +41,17 @@ export declare class RaceProvider implements GhostProvider {
         wins: number;
         skipRemaining: number;
     }>;
+    /**
+     * Skip-penalty filter (PRD §M8). Drop members still under a skip penalty,
+     * decrementing their counter and recording them in `skipped` so metrics can
+     * attribute the skip. If ALL members are skipped, fall back to running them
+     * anyway so the weighting policy can't permanently starve the user.
+     *
+     * In the all-skipped fallback the returned array is `this.members`, but
+     * `skipRemaining` has already been decremented for everyone — they execute
+     * regardless, which prevents starvation when every member is flagged slow.
+     */
+    private filterSkippedMembers;
     get debounceMs(): number;
     consumeLastTrace(): RaceTrace | null;
     /**

package/dist/providers/router.d.ts

@@ -42,6 +42,11 @@ export declare class RouterProvider implements GhostProvider {
     /** Leg that served the most recent request — the one to query for the
      *  empty-cause diagnostic so it reflects the register that actually ran. */
     private lastLeg;
+    /** Register-debounce multipliers snapshotted once at construction instead
+     *  of re-read per `debounceMsFor` (#3 — `debounceProseMult`/
+     *  `debounceAgentMult` previously read `process.env` on every dispatch). */
+    private readonly proseMult;
+    private readonly agentMult;
     constructor(fim: GhostProvider, chat: GhostProvider | null);
     get debounceMs(): number;
     /**

package/dist/recent-paths.d.ts

@@ -26,3 +26,34 @@ export declare function recentBoost(matchPath: string, recent: Set<string> | nul
  * assistant messages. Oldest-first.
  */
 export declare function getRoleWeightedRecent(ctx: ExtensionContext, userMax: number, assistantMax: number): RecentMessage[];
+/** How long a tool-touched path keeps its ranking boost. */
+export declare const TOOL_PATH_TTL_MS: number;
+/** Bound on live tool paths kept for boosting. */
+export declare const MAX_TOOL_PATHS = 32;
+/**
+ * Normalize a `read`/`edit`/`write` tool-input path so it string-matches
+ * PathIndex entries (git ls-files output: POSIX separators, root-relative).
+ *
+ * - Backslashes → forward slashes (Windows tool inputs).
+ * - Absolute paths inside `root` → root-relative.
+ * - Leading `./` stripped.
+ *
+ * Paths outside `root` (or when `root` is null) pass through normalized —
+ * they simply won't exact-hit an index entry and only degrade the boost.
+ */
+export declare function normalizeToolPath(raw: string, root: string | null): string;
+/**
+ * Merge regex-scraped mention paths with live tool-recorded paths.
+ * Tool entries survive the scrape TTL (5 s) — they are exact inputs, not
+ * text guesses — and are pruned only by their own {@link TOOL_PATH_TTL_MS}.
+ */
+export declare function mergeRecentPathSets(scraped: Set<string>, toolPaths: Map<string, number>, now: number, ttlMs?: number): Set<string>;
+/**
+ * Re-key recorded tool paths against a (possibly late-arriving) index
+ * root. The PathIndex is built asynchronously after the editor installs;
+ * tool results that land before it settles were normalized with
+ * `root === null` and may be absolute. Renormalizing against the real
+ * root makes them string-match the git ls-files keys. Collisions keep
+ * the newest timestamp.
+ */
+export declare function renormalizeToolPaths(toolPaths: Map<string, number>, root: string): Map<string, number>;