pi-ghost-autocomplete 0.3.1 → 0.4.0

package/dist/entropy-stop.d.ts

@@ -0,0 +1,105 @@
+/**
+ * SPDX-License-Identifier: SSPL-1.0
+ * SPDX-FileCopyrightText: 2025 Alessandro Pungitore <alessandro@pungitore.ch>
+ */
+/**
+ * Entropy-based early stop. PRD §M7.
+ *
+ * Streams `(token, -logprob)` pairs; cuts when a token's `-logprob` spikes
+ * above a learned baseline AND the token is whitespace/punctuation
+ * (natural cut points). Returns the text up to (not including) the
+ * cutting token.
+ *
+ * Pure state machine — no I/O, no provider coupling. Caller drives the
+ * stream and acts on the returned `StopDecision`.
+ *
+ * Capability gate (PRD §M7):
+ *   Mercury Edit FIM: no logprobs → caller skips this module
+ *   OpenAI chat:      supported
+ *   Groq/Ollama:      model-dependent
+ *
+ * Disabled when fewer than `warmup` tokens have been seen — no statistical
+ * baseline yet. Hard cap at `maxTokens` regardless.
+ */
+export declare const DEFAULT_WARMUP_TOKENS = 5;
+export declare const DEFAULT_SIGMA_MULT = 1.5;
+export declare const DEFAULT_MAX_TOKENS = 64;
+export interface EntropyStopperOpts {
+    /** Number of leading tokens used to seed the mean+std. */
+    warmupTokens?: number;
+    /** Sigma multiplier for the spike threshold. */
+    sigmaMult?: number;
+    /** Hard cap on total tokens observed before forced stop. */
+    maxTokens?: number;
+}
+export interface StopDecision {
+    /** True iff caller should stop streaming now. */
+    stop: boolean;
+    /**
+     * When `stop`, this is the reason. `entropy-spike` means a natural
+     * cut token tripped the threshold; `max-tokens` means the hard cap
+     * fired regardless of entropy.
+     */
+    reason?: "entropy-spike" | "max-tokens";
+    /**
+     * Running mean of `-logprob` after warmup. Useful for telemetry;
+     * undefined while still in warmup.
+     */
+    mean?: number;
+    /** Running standard deviation; undefined during warmup. */
+    std?: number;
+}
+export declare class EntropyStopper {
+    private readonly warmup;
+    private readonly sigma;
+    private readonly cap;
+    private readonly stats;
+    private tokensSeen;
+    constructor(opts?: EntropyStopperOpts);
+    /**
+     * Feed one streaming token + its `-logprob` (higher = more
+     * surprising / less confident). Returns whether the caller should
+     * stop the stream BEFORE this token. The caller's accumulated text
+     * up to (not including) this token is the "accept" boundary.
+     *
+     * Order of evaluation:
+     *   1. Hard cap: token index >= cap → stop
+     *   2. Warmup: token index < warmup → feed stats, no stop
+     *   3. Spike: -logprob > mean + sigma*std AND token is natural cut
+     *      → stop
+     *   4. Else: feed stats, no stop
+     */
+    observe(token: string, neglogprob: number): StopDecision;
+    /**
+     * Diagnostic snapshot — count + current mean/std. Returns `null`
+     * mean/std until the warmup window has filled enough samples for a
+     * meaningful estimate.
+     */
+    snapshot(): {
+        tokensSeen: number;
+        mean: number | null;
+        std: number | null;
+    };
+}
+/**
+ * True iff `token` is a natural cut point — whitespace, end-of-clause
+ * punctuation, or a closing bracket. PRD §M7 limits entropy-driven
+ * cutoffs to these to avoid mid-identifier truncation.
+ */
+export declare function isNaturalCutToken(token: string): boolean;
+/**
+ * Run a stream through an entropy stopper. Returns the prefix of joined
+ * tokens up to (but not including) the stop point. When the stream ends
+ * naturally without a stop, returns the full concatenation.
+ *
+ * Exposed as a convenience for tests + future provider wiring; editor
+ * integration is deferred until pi-ai exposes per-token logprob events.
+ */
+export declare function runWithStop(tokens: Iterable<{
+    token: string;
+    neglogprob: number;
+}>, opts?: EntropyStopperOpts): {
+    text: string;
+    stopped: boolean;
+    reason?: "entropy-spike" | "max-tokens";
+};

package/dist/eval-dataset.d.ts

@@ -0,0 +1,55 @@
+/**
+ * SPDX-License-Identifier: SSPL-1.0
+ * SPDX-FileCopyrightText: 2025 Alessandro Pungitore <alessandro@pungitore.ch>
+ */
+export declare const EVAL_REL = ".pi/ghost-autocomplete/eval.jsonl";
+/** Char positions at which to sample prefixes from a committed line. */
+export declare const PREFIX_SAMPLE_POSITIONS: readonly number[];
+/** Beyond `LONG_LINE_START`, sample every `LONG_LINE_STEP` chars. */
+export declare const LONG_LINE_START = 20;
+export declare const LONG_LINE_STEP = 10;
+export interface EvalExample {
+    ts: number;
+    /** Single-line committed text the sample was drawn from. */
+    committed: string;
+    /** Char-position sample point on `committed`. */
+    prefixLen: number;
+    /** Substring `committed[0..prefixLen]` — the LLM input. */
+    prefix: string;
+    /** Substring `committed[prefixLen..end]` — the ground truth continuation. */
+    expected: string;
+    /** Provider context (renderable). May be the empty string. */
+    context: string;
+    /** Provider/version fingerprints active at capture. */
+    providerFingerprint: string;
+    versionFingerprint: string;
+    /** Provider name (e.g. "ghost-mercury-edit"). */
+    providerName: string;
+}
+/**
+ * Generate sample (prefix, expected) splits from a committed line. PRD
+ * §M5c: positions `[3, 5, 8, 12, 20]` plus every 10 chars beyond 20.
+ * Returns empty when the committed text is too short for any sample.
+ */
+export declare function samplePrefixes(committed: string): Array<{
+    prefixLen: number;
+    prefix: string;
+    expected: string;
+}>;
+/**
+ * Build eval examples for a single commit. Drops sensitive messages
+ * entirely. `context` should already be rendered by the caller (the
+ * provider's recent-messages block joined into a single string) — keeps
+ * this module decoupled from provider context shape.
+ */
+export declare function buildExamplesFromCommit(committed: string, meta: {
+    context: string;
+    providerFingerprint: string;
+    versionFingerprint: string;
+    providerName: string;
+}, ts?: number): EvalExample[];
+export declare function appendExamples(cwd: string, examples: EvalExample[]): Promise<void>;
+export declare function loadExamples(cwd: string): Promise<EvalExample[]>;
+export declare function parseExamples(body: string): EvalExample[];
+/** Parse `PI_GHOST_EVAL_CAPTURE`. Returns true only when set to "1". */
+export declare function parseEvalCaptureEnv(raw: string | undefined): boolean;

package/dist/fuzzy-matcher.d.ts

@@ -1,6 +1,18 @@
+/**
+ * SPDX-License-Identifier: SSPL-1.0
+ * SPDX-FileCopyrightText: 2025 Alessandro Pungitore <alessandro@pungitore.ch>
+ */
 import type { PathIndex } from "./path-index.js";
 export interface FindFuzzyOptions {
     recentPaths?: Set<string> | null;
+    /**
+     * PRD §M4 — bounded persistent-path boost. Caller wires
+     * `(path) => profileStore.profilePathBoost(path)` which returns
+     * `[0, 0.2]`. Multiplied by 10 to give it integer-scale weight (max
+     * +2) that nudges fuzzy tie-breakers without overriding subtree (+5)
+     * or short-path (+5) bonuses.
+     */
+    profileBoost?: ((path: string) => number) | null;
 }
 export type FuzzyBand = "basename-prefix" | "fuzzy-basename" | "fuzzy-path";
 export interface FuzzyToken {
@@ -47,4 +59,3 @@ export declare function hasActionTrigger(prefix: string): boolean;
  * 70-84). Scores < 70 should not be shown deterministically.
  */
 export declare function findFuzzyFilename(index: PathIndex, token: string, opts?: FindFuzzyOptions): FuzzyMatch | null;
-//# sourceMappingURL=fuzzy-matcher.d.ts.map

package/dist/ghost-editor.d.ts

@@ -1,46 +1,373 @@
+/**
+ * SPDX-License-Identifier: SSPL-1.0
+ * SPDX-FileCopyrightText: 2025 Alessandro Pungitore <alessandro@pungitore.ch>
+ */
 import { CustomEditor, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { KeybindingsManager } from "@earendil-works/pi-coding-agent";
 import { type EditorTheme, type TUI } from "@earendil-works/pi-tui";
-import type { GhostConfig } from "./config.js";
+import type { GhostConfig, ProviderConfig } from "./config.js";
+import { type RecentMessage } from "./context-aggregator.js";
 import type { MetricsLogger } from "./metrics.js";
 import type { PathIndex } from "./path-index.js";
-import type { GhostProvider } from "./providers/types.js";
+import type { ProfileStore } from "./profile-store.js";
+export { cycleCandidateIdx, nextWordChunk } from "./cycle-manager.js";
+import { type GhostProvider } from "./providers/types.js";
+/**
+ * #5 helper — classify a stale event as divergent or typed-through given
+ * the ghost state at render time and the post-change text. Returns true
+ * when the user typed characters that are NOT a prefix of the suggested
+ * ghost. Pure / exported for testability — the editor wraps this in
+ * `recordDivergentTyped` to track the consecutive run.
+ */
+export declare function isTypedPastDivergent(ghost: string, ghostForText: string, textAfterChange: string): boolean;
+/** Parse `PI_GHOST_SHORT_HOVER_MS`. Falls back to the default on invalid
+ *  or non-positive input. Exposed for tests; called once per dismiss. */
+export declare function parseShortHoverEnv(raw: string | undefined): number;
 export declare class GhostEditor extends CustomEditor {
     private provider;
     private readonly config;
     private readonly extCtx;
     private readonly metrics;
     private readonly onError;
-    private pathIndex;
+    private profile;
     private ghostText;
     private ghostForText;
+    private readonly keystrokeTimer;
+    /**
+     * Tracks consecutive divergent stales on the same line for the #5
+     * typed-past negative signal. Reset by any accept or a non-divergent
+     * (i.e., user-typed-through) stale. Carries the original `(prefix,
+     * ghost)` so a single penalty at threshold can be applied against the
+     * pair that was actually being typed-past.
+     */
+    private divergentRun;
     private ghostReplaceFrom;
     private debounceTimer;
     private inflight;
     private lastTextSeen;
+    /** Last classified intent, set during handleTextChange and consumed
+     *  by buildPredictionContext when the LLM fires after debounce. */
+    private currentIntent;
+    /** Ring buffer of recently-dismissed deterministic completions,
+     *  used to suppress re-showing the same path in the same context. */
+    private readonly dismissCache;
     private disposed;
     private shownMetric;
     private recentPaths;
     private recentPathsAt;
-    constructor(tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager, extCtx: ExtensionContext, config: GhostConfig, provider: GhostProvider | null, metrics?: MetricsLogger | null, pathIndex?: PathIndex | null, onError?: ((err: Error) => void) | null);
+    private readonly fastPath;
+    private readonly providerFingerprint;
+    private readonly versionFingerprint;
+    /** Tracks the prefix shown alongside the current ghost so commit-time
+     *  reconciliation can decide accepted vs divergent. */
+    private lastAcceptedGhost;
+    /** PRD §M3e/f — CycleManager owns the ranked candidate list, cycling (Alt+]/Alt+[),
+     *  word-level partial accepts (Ctrl+Right), and related accounting. */
+    private readonly cycleMgr;
+    /** PRD §M5a — regret detection after accept. Pending while the
+     *  window is open; flushed on regret or deadline. */
+    private pendingRegret;
+    private regretTimer;
+    constructor(tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager, extCtx: ExtensionContext, config: GhostConfig, provider: GhostProvider | null, metrics?: MetricsLogger | null, pathIndex?: PathIndex | null, onError?: ((err: Error) => void) | null, profile?: ProfileStore | null);
     setPathIndex(index: PathIndex | null): void;
+    setProfile(profile: ProfileStore | null): void;
+    /**
+     * PRD §M3g — diagnostic snapshot for the `/ghost` command. Pure read,
+     * no side effects. Numbers are point-in-time; the editor doesn't keep
+     * a running window. `cooldownMs` is reported when the active provider
+     * is a `RaceProvider`; otherwise omitted.
+     */
+    getDiagnostics(): GhostDiagnostics;
+    /**
+     * Build the edit-history section of `/ghost` diag. Snapshot is taken at
+     * call time; `topAdded` / `topRemoved` expose token *lists only* (no
+     * raw text — privacy contract from spec §6.5).
+     */
+    private buildEditHistoryDiag;
     setProvider(provider: GhostProvider | null): void;
     dispose(): void;
     handleInput(data: string): void;
+    /**
+     * Right Arrow → full ghost accept (append-mode appends, replace-mode
+     * replaces the typed token). Seeds the trie + profile with the accepted
+     * (prefix, ghost) pair for append-mode only — replace-mode ghosts are
+     * structurally incompatible with the trie's append model.
+     */
+    private handleFullAccept;
+    /**
+     * PRD §M3f — Ctrl+Right consumes the next word of the ghost.
+     * Append-mode only; replace-mode ghosts (fuzzy/path) accept atomically
+     * via Right. Returns true iff the keystroke was claimed (chunk inserted
+     * or final-chunk path taken). A no-op move (empty chunk) falls through.
+     */
+    private handlePartialWordAccept;
+    /**
+     * PRD §M3e — Alt+]/Alt+[ cycle through ranked candidates. Append-mode
+     * only and only when more than one candidate exists. Clamp at edges
+     * (no wrap). An edge press is a silent no-op: ghost is preserved
+     * (see `maybeDismissGhost`) and cycledCount is NOT incremented since
+     * the user didn't actually cycle.
+     */
+    private handleCycle;
+    /**
+     * Keys we explicitly own preserve the ghost; everything else dismisses.
+     * Alt+]/Alt+[ always preserve (match VS Code: alt+] on a single
+     * candidate is a silent no-op, ghost stays). Ctrl+Right preserves
+     * ONLY in append-mode — for replace-mode (fuzzy/path) ghosts,
+     * Ctrl+Right is normal cursor word-right nav, so the ghost should
+     * dismiss before the parent editor moves the cursor.
+     */
+    private maybeDismissGhost;
+    /**
+     * Observe post-`super.handleInput` text change: feed the keystroke timer
+     * (single-char insertions only), check pending regret, and dispatch
+     * to `handleTextChange` for the next prediction cycle.
+     */
+    private observePostInputTextChange;
+    /**
+     * Enhancement #1 — capture an edit event into the FastPathEngine's
+     * `EditHistoryRing`. Diffs `prev` vs `next` to derive the minimal
+     * `{added, removed}` slice, sanitizes both sides (event dropped on a
+     * sensitive hit), tokenizes, and records.
+     *
+     * No-op when `PI_GHOST_EDIT_HISTORY=0` (master switch read at engine
+     * construction). Single-buffer URI sentinel `"prompt"` — the editor
+     * owns one document.
+     */
+    private recordEditEvent;
+    /**
+     * Build the editProximity scorer bound to the current cursor + a
+     * fresh `EditHistoryIndex` snapshot. Returns `null` when edit-history
+     * is disabled OR the ring is empty (no signal to surface). Captured
+     * per-prediction-cycle so the scorer is consistent across all
+     * candidates in a single rerank.
+     */
+    private buildEditProximityScorer;
     render(width: number): string[];
     private cursorAtEnd;
     private shouldShowGhost;
     private clearGhost;
     private cancelInflight;
+    /**
+     * #5 — track consecutive divergent stales on the same prefix family.
+     * A non-divergent (i.e., typed-through) stale resets the run because
+     * the user was on-track with the suggestion. At threshold we apply a
+     * trie penalty against the original `(prefix, ghost)` and stamp the
+     * current `shownMetric` so the resulting stale record carries the
+     * `typedPastDivergent` flag. Only one penalty per run — the run resets
+     * so a long string of divergent typing doesn't double-charge.
+     */
+    private recordDivergentTyped;
     private handleTextChange;
-    private tryDeterministic;
+    /**
+     * Extension host hook: notify the editor that a user prompt has been
+     * committed (Enter pressed, message submitted). Seeds the session trie
+     * with prefix→remainder shingles from the committed text and reconciles
+     * any in-flight accepted ghost against the actual commit (for divergent
+     * dismiss accounting in a future iteration).
+     *
+     * Sanitization happens inside the trie. The hook is safe to call with raw
+     * user text — secrets are filtered before insertion.
+     */
+    onPromptCommitted(text: string): void;
+    /**
+     * Single-line prefix at the cursor, used as the trie key. Stripping
+     * earlier lines keeps trie entries small and keeps "prefix" semantics
+     * consistent across single-line commits vs multi-line edits.
+     */
+    private lastSingleLinePrefix;
+    /**
+     * Assemble the recent-message context for a prediction. Combines:
+     *  - M6a: opt-in tool entries via `getRecentMessages({ includeTools })`
+     *  - M6c: type-aware summarization + cap on tool count
+     *  - M6b: relevance-pruned selection by BM25 + recency
+     *
+     * Returns oldest-first messages suitable for provider rendering. Sized
+     * by the M6d env knobs; falls back to `config.provider.maxRecentMessages`
+     * when context scanning is effectively disabled.
+     */
+    private buildSelectedContext;
+    private textBeforeCursor;
+    private applyServedGhost;
+    /**
+     * Shared ghost-state mutation used by every "show this ghost now" path
+     * (served, deterministic). Sets the 7 ghost-related fields atomically.
+     * `replaceFrom` is null for append-mode ghosts; non-null for fuzzy/path
+     * replace-mode. Does NOT touch `shownMetric` — callers build that with
+     * source-specific fields.
+     */
+    private setShownGhost;
+    /**
+     * PRD §M4 — slash-command fast-path. Runs before the minChars gate and
+     * before the provider check: profile-local lookup, no LLM, useful even
+     * at 1-char prefixes (`/`). Returns true when a slash-completion was
+     * served. Profile must exist; line must start with `/`.
+     */
+    private trySlashFastPath;
+    private tryDeterministicWithLines;
     private getRecentPaths;
     private applyDeterministic;
     private replaceTokenAtCursor;
+    /**
+     * PRD §M3.5b — arm a provisional ghost. Engine owns the timer + env
+     * gate + picker construction (uses its own trie/lastGhosts plus the
+     * supplied profile). Editor supplies the request-scoped `canRender`
+     * predicate and the `onShow` UI mutator — both close over `ctrl` +
+     * `textAtSchedule` so they stay consistent with the in-flight request.
+     */
+    private armProvisional;
     private requestPrediction;
+    /**
+     * Refresh context + fingerprints + build the provider request bag at
+     * fire-time. Session messages may have arrived during the debounce
+     * window; the cache key we persist must match what the provider actually
+     * sees, otherwise a later identical keystroke would miss its own cached
+     * result. Pure context construction — no LLM call.
+     */
+    private buildPredictionContext;
+    /**
+     * Post-provider-call disposition: stamp TTFT, run the post-flight gate,
+     * sanitize empty results, rerank, apply confidence gate, reconcile with
+     * any displayed provisional, and commit. Each early-return emits the
+     * appropriate metric; the happy path lands in `commitDisplayedGhost`.
+     *
+     * Extracted from `requestPrediction` as part of refactor #57 phase 1 so
+     * the orchestrator stays a thin sequence (build → await → finalize).
+     */
+    private finalizeProviderResult;
+    /**
+     * Centralized post-provider-call disposition. Returns `null` when the
+     * result is good to render; otherwise the abort reason the caller should
+     * report via `emitMetric`. Clears `this.inflight` only on the happy path
+     * (matches the prior in-line behavior at the first non-aborted check) so
+     * an `aborted` return leaves `inflight` for the catch / next request to
+     * deal with.
+     */
+    private postFlightCheck;
+    /**
+     * PRD §M3.5a — invoke the provider in either streaming or multi-candidate
+     * mode and (when streaming) drive incremental UI paint via `onChunk`.
+     * Stamps TTFT on the first stream chunk and returns it for the caller to
+     * attach to the pending metric.
+     *
+     * - Streaming path: provider exposes `predictStream` AND lacks
+     *   `predictMulti`. Used by Mercury FIM streaming + LocalProvider.
+     * - Multi path: everything else (openai-compat FIM, race with sync
+     *   members). `onChunk` is ignored.
+     *
+     * Extracted from `requestPrediction` as part of refactor #57 so the
+     * orchestrator stays focused on rerank / reconcile / commit.
+     */
+    private runPredictionPath;
+    /**
+     * Commit a successfully-reconciled LLM ghost to all on-screen + fast-path
+     * structures: ranked candidate list, ghost text, cache, speculative ring,
+     * and the pending metric record. Extracted from `requestPrediction` as
+     * part of refactor #57 to keep the orchestrator readable.
+     *
+     * Cache + speculative ring store the *reranked* top — a subsequent cache
+     * hit must reproduce what the user actually saw, not the provider's
+     * pre-rerank order.
+     */
+    private commitDisplayedGhost;
     private emitMetric;
     private finalizeShown;
+    /**
+     * Detach + clear the pending-regret watch (handle + timer) atomically
+     * and return the captured handle. Callers decide how to resolve the
+     * outcome (`observeRegret`, `expireRegret`, or a forced no-regret on
+     * Enter-commit) and log the resulting record.
+     *
+     * Returns null when no watch was armed — callers can short-circuit.
+     */
+    private takePendingRegret;
+    private resolvePendingRegret;
+    /**
+     * Flush any pending regret-watched record. Called by the timer, by a
+     * later accept that supersedes the prior window, or by dispose.
+     * Detects regret against the *current* editor text via `expireRegret`
+     * so the final record reflects whatever the user did in the window.
+     */
+    private flushRegret;
 }
+/**
+ * Render a recent-messages array into a single string for eval capture
+ * (PRD §M5c). Format mirrors the provider context shape — `role: text`
+ * joined by newlines — so a CLI replay can feed it back to the same
+ * provider. Tool entries get a `tool ${name}:` label.
+ */
+export declare function renderContextForEval(recent: RecentMessage[]): string;
+export interface GhostDiagnostics {
+    provider: string | null;
+    providerFingerprint: string;
+    versionFingerprint: string;
+    /** PRD §M3g — capability flags detected from the active provider. */
+    capabilities: {
+        streaming: boolean;
+        multiCandidate: boolean;
+        preflight: boolean;
+        /** PRD §M7 — provider populates per-token `-logprob` on stream events. */
+        logprobs: boolean;
+    };
+    cache: {
+        size: number;
+        hits: number;
+        misses: number;
+        hitRate: number;
+    };
+    trie: {
+        prefixes: number;
+        candidates: number;
+        insertsSinceDecay: number;
+    };
+    profile: {
+        enabled: boolean;
+        ngrams: number;
+        paths: number;
+        slash: number;
+        accepts: number;
+        decayDays: number;
+    };
+    race: {
+        cooldown: {
+            active: boolean;
+            remainingMs: number;
+        };
+        members: Array<{
+            name: string;
+            slowCount: number;
+            wins: number;
+            skipRemaining: number;
+        }>;
+    } | null;
+    ghostShown: boolean;
+    /** PRD §M5a — regret window state. `null` when no accept is being
+     *  watched; otherwise the remaining ms until the window closes. */
+    pendingRegret: {
+        remainingMs: number;
+        insertedLen: number;
+    } | null;
+    /**
+     * Enhancement #1 — edit-history snapshot for `/ghost` diag. `enabled`
+     * mirrors `PI_GHOST_EDIT_HISTORY`; the remaining fields are populated
+     * even when disabled (they'll just report zeros).
+     */
+    editHistory: {
+        enabled: boolean;
+        events: number;
+        capacity: number;
+        uris: number;
+        topAdded: string[];
+        topRemoved: string[];
+        oldestAgeMs: number | null;
+        halfLifeMs: number;
+    };
+}
+/**
+ * Build a stable provider fingerprint from the config. For race configs, fold
+ * each member into the `extras` map so member rotation invalidates cache.
+ */
+export declare function providerFingerprintFromConfig(cfg: ProviderConfig): string;
 /**
  * Pure helper: replace the slice `[from.col, end-of-line]` on `from.line` of
  * `text` with `replacement`. Exported for testability.
@@ -62,4 +389,3 @@ export declare function visualWidth(s: string): number;
  * Returns the empty string if `maxCols <= 0` or no characters fit.
  */
 export declare function clipToWidth(s: string, maxCols: number): string;
-//# sourceMappingURL=ghost-editor.d.ts.map

package/dist/index.d.ts

@@ -1,5 +1,18 @@
+/**
+ * SPDX-License-Identifier: SSPL-1.0
+ * SPDX-FileCopyrightText: 2025 Alessandro Pungitore <alessandro@pungitore.ch>
+ */
 import type { ExtensionFactory } from "@earendil-works/pi-coding-agent";
+import { type GhostConfig } from "./config.js";
+import type { GhostDiagnostics } from "./ghost-editor.js";
 declare const ghost: ExtensionFactory;
+/**
+ * PRD §M3g — render the diagnostic snapshot from `GhostEditor.getDiagnostics`
+ * alongside the provider config. The output is a single notify-friendly
+ * string; sections are bullet-indented two spaces deep so they nest under
+ * the leading "Pi Ghost diagnostics" header.
+ */
+export declare function describeDiagnostics(config: GhostConfig, diag: GhostDiagnostics | null): string;
 export default ghost;
 export { CloudProvider } from "./providers/cloud-provider.js";
 export { LocalProvider } from "./providers/local-provider.js";
@@ -8,9 +21,17 @@ export type { PreflightResult } from "./providers/openai-compat-provider.js";
 export { RaceProvider, firstNonNull } from "./providers/race.js";
 export type { RaceConfig, RaceTrace } from "./providers/race.js";
 export { GhostEditor, computeReplacement } from "./ghost-editor.js";
+export type { GhostDiagnostics } from "./ghost-editor.js";
 export type { GhostConfig, ProviderConfig, CloudProviderConfig, LocalProviderConfig, OpenAICompatProviderConfig, RaceProviderConfig } from "./config.js";
 export type { GhostProvider, GhostRequest } from "./providers/types.js";
 export { MetricsLogger, readMetricsConfigFromEnv } from "./metrics.js";
+export { ProfileStore } from "./profile-store.js";
+export { appendExamples, buildExamplesFromCommit, loadExamples, parseEvalCaptureEnv, parseExamples, samplePrefixes, EVAL_REL, } from "./eval-dataset.js";
+export type { EvalExample } from "./eval-dataset.js";
+export { evaluateExample, leadingMatch, levenshtein, savedAtK, summarizeReplay, } from "./replay.js";
+export type { ExampleMetrics, ReplayResult, ReplaySummary } from "./replay.js";
+export { DEFAULT_MAX_TOKENS as ENTROPY_DEFAULT_MAX_TOKENS, DEFAULT_SIGMA_MULT as ENTROPY_DEFAULT_SIGMA_MULT, DEFAULT_WARMUP_TOKENS as ENTROPY_DEFAULT_WARMUP_TOKENS, EntropyStopper, isNaturalCutToken, runWithStop, } from "./entropy-stop.js";
+export type { EntropyStopperOpts, StopDecision } from "./entropy-stop.js";
 export type { MetricsRecord, MetricsConfig, RequestResult, AcceptanceOutcome, ProviderLatency, RejectionReason, CompletionMode } from "./metrics.js";
 export { buildPathIndex } from "./path-index.js";
 export type { PathIndex } from "./path-index.js";
@@ -22,4 +43,3 @@ export type { FindPathPrefixOptions } from "./path-matcher.js";
 export { extractRecentPaths, getRoleWeightedRecent, recentBoost } from "./recent-paths.js";
 export { formatReport, loadMetrics, parseMetricsText, quantile, runBenchmark, summarize, THRESHOLDS, } from "./bench.js";
 export type { BenchmarkReport, ModeStats, ProviderStats } from "./bench.js";
-//# sourceMappingURL=index.d.ts.map