kibi-opencode 0.8.0 → 0.10.0

package/README.md

@@ -113,13 +113,12 @@ The plugin injects guidance into OpenCode sessions to improve agent grounding. U
 
 OpenCode exposes Kibi MCP prompts as slash commands. The \`/init-kibi\` command triggers the \`kb_autopilot_generate\` workflow to assist in retroactive bootstrap using only public MCP tools.
 
-### Start-Task Briefing
+When the plugin detects an authoritative risky edit (`behavior_candidate` or `traceability_candidate` risk class), it automatically renders a Kibi briefing before the prompt. The plugin uses two complementary paths: the `file.edited` event hook as a fast-path hint, and prompt-cycle reconciliation as an authoritative fallback for programmatic edits that bypass the event bus. Briefings are rendered directly into the prompt to ensure immediate visibility.
 
-Use `/brief-kibi` at the start of authoritative risky edit work when the prompt hints for it.
-
-- The plugin only hints about `/brief-kibi` inside smart-enforcement guidance.
-- The actual briefing content is generated by the registered MCP prompt/tool, not by the prompt hook.
-- Live automatic briefing fetch from `experimental.chat.system.transform` is deferred; the hook remains text-only.
+- **Immediate delivery**: Briefings are rendered-first into the prompt guidance block headed `🧠 **Kibi briefing available**` and TUI toasts titled `Kibi Knowledge Update`.
+- **Narrative structure**: Delivery favors user-facing prose with `What changed` and `Why it matters`, plus conditional `Project knowledge impact` / `Interpretation note` sections when evidence or caveats exist.
+- **TL;DR fallback**: If a full briefing is unavailable, fallback output still preserves `What changed` / `Why it matters` framing while keeping the manual command cue available.
+- **Manual command**: Use `/brief-kibi` at any time to trigger an on-demand briefing if auto-delivery is skipped or fails.
 
 ### Discovery-first MCP guidance
 
@@ -141,7 +140,7 @@ Internal maintenance automatically syncs the knowledge base after relevant file
 ### Non-Blocking UX
 
 - Sync runs in background, never blocks OpenCode
-- Failures reported via console logs only, never as blocking UI elements
+- **Non-blocking toast delivery**: Toast transport is best-effort. The plugin detects available OpenCode TUI capabilities (`client.tui.toast` or `client.tui.showToast`) and uses the official SDK contract. Toast failures resolve to structured `SendToastResult` objects (`delivered`, `unavailable`, `failed`) rather than throwing or falling back to raw HTTP requests.
 
 ## Configuration
 
@@ -165,6 +164,8 @@ Config files (project overrides global):
 | `ux.toastFailures` | boolean | `true` | Show failure toasts for sync/check issues |
 | `ux.toastSuccesses` | boolean | `false` | Show success toasts for sync/check completion |
 | `ux.toastCooldownMs` | number | `10000` | Cooldown between repeated UX toasts |
+| `ux.briefs.autoSubmit` | boolean | `true` | **Deprecated/No-op**: Auto-submission is no longer needed with render-first briefing |
+PP|| `guidance.dynamic` | boolean | `true` | Enable dynamic contextual guidance |
 | `guidance.dynamic` | boolean | `true` | Enable dynamic contextual guidance |
 | `guidance.warnOnKbEdits` | boolean | `true` | Enable loud warnings for .kb/** edits |
 | `guidance.factFirstDomainRouting` | boolean | `true` | Enable FACT-first domain routing suggestions |
@@ -194,21 +195,31 @@ The plugin follows a **silent-except-operational-errors** policy for terminal ou
 
 | Classification | Examples | Surface | Terminal | Structured |
 |---------------|----------|---------|----------|------------|
-| **Advisory (background)** | scheduler check failures, degraded-mode latches | `errorStructuredOnly()` | No | Yes, via `client.app.log()` |
-| **Operational (plugin)** | bootstrap-needed, sync failure, hook/init failure | `error()` | Yes, via `console.error` | Yes, via `client.app.log()` |
+| **Advisory (background)** | routine `info()`, `warn()`, scheduler check failures, degraded-mode latches, `errorStructuredOnly()` | `client.app.log()` | No | Yes, via `client.app.log()` |
+| **Operational (plugin)** | bootstrap-needed, sync failure, hook/init failure | `error()` | Yes, exactly one prefixed `console.error` (`[kibi-opencode]`) | Yes, via `client.app.log()` |
 | **Authoritative external** | git hooks, CLI checks | Outside plugin surface | N/A | N/A |
 
 ### Failure Routing Contract
 
 The logger exposes two error-level surfaces with distinct routing semantics:
 
-- **`error(msg, metadata?)`** — Operational plugin failures. Always emits to `console.error` for terminal visibility, plus `client.app.log()` when a client is bound. Use for bootstrap-needed, hook/init failures, and sync failures that require developer attention.
-- **`errorStructuredOnly(msg, metadata?)`** — Advisory background maintenance failures. Routes through `client.app.log()` only when a client is bound; completely silent when no client is bound (no `console.error` fallback). Use for scheduler check failures and degraded-mode latches.
+- **`error(msg, metadata?)`** — Operational plugin failures. Emits exactly one prefixed `console.error` (`[kibi-opencode]`) for terminal visibility, plus `client.app.log()` when a client is bound. Structured log rejection does not emit secondary console noise. Use for bootstrap-needed, hook/init failures, and sync failures that require developer attention.
+- **`errorStructuredOnly(msg, metadata?)`** — Advisory background maintenance failures. Routes through `client.app.log()` only when a client is bound and remains terminal-silent even when the structured transport rejects. Use for scheduler check failures and degraded-mode latches.
 
-**Contract rule:** Once `client` is bound (after `setClient()`), advisory logging MUST use `errorStructuredOnly()`. When no client is bound, `errorStructuredOnly()` is completely silent — it does not fall back to `console.error`.
+**Contract rule:** Once `client` is bound (after `setClient()`), advisory paths (`info()`, `warn()`, `errorStructuredOnly()`) MUST stay on `client.app.log()` and remain terminal-silent. Operational failures use `error()` for a single prefixed terminal emission without duplicating console output when structured logging rejects.
 
 Routine diagnostics route through [`client.app.log()`](https://opencode.ai/docs/plugins/) and never appear in the terminal. Only operational error-class events break terminal silence. This keeps the developer's workspace clean while preserving full visibility in structured logs for debugging.
 
+### Toast Transport Contract
+
+The plugin uses the official OpenCode toast APIs with automatic capability detection:
+
+1. **Legacy transport**: `client.tui.toast(payload)` — used when available in plugin context
+2. **SDK transport**: `client.tui.showToast({ body: payload })` — used as fallback
+3. **No capability**: Returns `{ status: "unavailable", reason: "missing-capability" }`
+
+All toast delivery is best-effort and non-blocking. The `sendToast` helper returns a discriminated `SendToastResult` union and never throws. There is no raw HTTP fallback.
+
 The `experimental.chat.system.transform` hook handles prompt injection (see [Hook Policy](#hook-policy)). The `chat.params` hook is compatibility-only and never carries prompt text.
 
 ### Hook Modes
@@ -274,6 +285,20 @@ A proposed enhancement would inject Kibi context hints into file-read results (e
 
 Current workaround: static system prompt guidance directs agents to query Kibi explicitly.
 
+### File-Context Guidance
+
+The plugin provides proactive guidance when agents perform file operations:
+
+- **File-create/edit guidance**: When an agent creates or edits a source file, the plugin may inject reminders to check Kibi for that path if e2e evidence exists.
+
+- **File-delete safety guidance**: When an agent attempts to delete a file, the plugin injects a safety check reminding the agent to verify if the file implements any Kibi requirements before removal.
+
+- **E2e reminder evidence**: File-operation reminders use exact Kibi graph evidence first (`covered_by` links to `[e2e]`-tagged entities or `/e2e/`-sourced entities) and narrow path heuristics second. Package-level e2e tests do not trigger "authoritative evidence" flags at the file level.
+
+- **Session suppression**: To minimize prompt noise, this guidance is suppressed after the first occurrence per path per session.
+
+- **Current-host scope**: This feature uses host-side event monitoring to detect intent; it does not intercept or modify actual file content returned by the Read tool.
+
 ## License
 
 AGPL-3.0-or-later

package/dist/brief-intent.d.ts

@@ -0,0 +1,41 @@
+import type { RepoPosture } from "./repo-posture.js";
+import type { RiskClass } from "./risk-classifier.js";
+export interface BriefIntentParams {
+    riskClass: RiskClass;
+    posture: RepoPosture;
+    maintenanceDegraded: boolean;
+    workspaceRoot: string;
+    branch: string;
+    sourceFiles: string[];
+    focusFilePath?: string;
+    seedIds?: string[];
+}
+export interface BriefIntentResult {
+    eligible: boolean;
+    reason: string;
+    fingerprint: string;
+    sourceFiles: string[];
+    seedIds: string[];
+}
+export interface BriefIntentInputs {
+    riskClass: RiskClass;
+    posture: RepoPosture;
+    maintenanceDegraded: boolean;
+    worktreeRoot: string;
+    branch: string;
+    sourceFiles: string[];
+    focusFilePath?: string;
+    seedIds?: string[];
+}
+export declare function deriveBriefIntent(params: BriefIntentParams): BriefIntentResult;
+export declare function computeBriefIntent(inputs: BriefIntentInputs): BriefIntentResult;
+export interface BriefingContextParams {
+    sourceFiles: string[];
+    seedIds?: string[];
+    changedEntityIds?: string[];
+}
+export interface BriefingContextResult {
+    sourceFiles: string[];
+    seedIds: string[];
+}
+export declare function buildBriefingContext(params: BriefingContextParams): BriefingContextResult;

package/dist/brief-intent.js

@@ -0,0 +1,127 @@
+// implements REQ-opencode-kibi-briefing-v2, REQ-opencode-smart-enforcement-v1
+import { getSourceLinkedRequirementIds } from "./source-linked-guidance.js";
+const ELIGIBLE_RISK_CLASSES = new Set([
+    "behavior_candidate",
+    "traceability_candidate",
+]);
+const STRICT_ELIGIBLE_POSTURES = new Set([
+    "root_active",
+    "hybrid_root_plus_vendored",
+]);
+function sortAndDedup(files) {
+    return [...new Set(files)].sort();
+}
+function deriveSeedIds(params) {
+    if (params.seedIds !== undefined && params.seedIds.length > 0) {
+        return buildBriefingContext({
+            sourceFiles: params.sourceFiles,
+            seedIds: params.seedIds,
+        }).seedIds.slice(0, 3);
+    }
+    const focusFile = params.focusFilePath ?? params.sourceFiles[0];
+    if (!focusFile) {
+        return [];
+    }
+    return buildBriefingContext({
+        sourceFiles: params.sourceFiles,
+        seedIds: getSourceLinkedRequirementIds(params.workspaceRoot, focusFile),
+    }).seedIds.slice(0, 3);
+}
+// implements REQ-opencode-kibi-briefing-v2, REQ-opencode-smart-enforcement-v1
+export function deriveBriefIntent(params) {
+    const sortedSourceFiles = sortAndDedup(params.sourceFiles);
+    const fingerprint = `brief:${params.workspaceRoot}\0${params.branch}\0${params.riskClass}\0${sortedSourceFiles.join("\0")}`;
+    const seedIds = deriveSeedIds(params);
+    if (sortedSourceFiles.length === 0) {
+        return {
+            eligible: false,
+            reason: "Ineligible: no source files in session",
+            fingerprint,
+            sourceFiles: sortedSourceFiles,
+            seedIds: [],
+        };
+    }
+    if (!ELIGIBLE_RISK_CLASSES.has(params.riskClass)) {
+        return {
+            eligible: false,
+            reason: `Ineligible: riskClass ${params.riskClass} is not auto-brief eligible`,
+            fingerprint,
+            sourceFiles: sortedSourceFiles,
+            seedIds,
+        };
+    }
+    if (!STRICT_ELIGIBLE_POSTURES.has(params.posture)) {
+        return {
+            eligible: false,
+            reason: `Ineligible: posture ${params.posture} is not authoritative`,
+            fingerprint,
+            sourceFiles: sortedSourceFiles,
+            seedIds,
+        };
+    }
+    if (params.maintenanceDegraded) {
+        return {
+            eligible: false,
+            reason: "Ineligible: maintenance is degraded",
+            fingerprint,
+            sourceFiles: sortedSourceFiles,
+            seedIds,
+        };
+    }
+    return {
+        eligible: true,
+        reason: "Eligible for auto-briefing",
+        fingerprint,
+        sourceFiles: sortedSourceFiles,
+        seedIds,
+    };
+}
+export function computeBriefIntent(
+// implements REQ-opencode-kibi-briefing-v2
+inputs) {
+    return deriveBriefIntent({
+        riskClass: inputs.riskClass,
+        posture: inputs.posture,
+        maintenanceDegraded: inputs.maintenanceDegraded,
+        workspaceRoot: inputs.worktreeRoot,
+        branch: inputs.branch,
+        sourceFiles: inputs.sourceFiles,
+        ...(inputs.focusFilePath !== undefined
+            ? { focusFilePath: inputs.focusFilePath }
+            : {}),
+        ...(inputs.seedIds !== undefined ? { seedIds: inputs.seedIds } : {}),
+    });
+}
+export function buildBriefingContext(
+// implements REQ-opencode-kibi-briefing-v6
+params) {
+    const sourceFiles = [...new Set(params.sourceFiles)].sort();
+    const seen = new Set();
+    const seeds = [];
+    // Take first 3 changed entity IDs in original order, dedupe, sort
+    if (params.changedEntityIds) {
+        for (const id of params.changedEntityIds.slice(0, 3)) {
+            if (!seen.has(id)) {
+                seeds.push(id);
+                seen.add(id);
+            }
+        }
+    }
+    // Fill remaining slots from seedIds in original order
+    if (params.seedIds) {
+        for (const id of params.seedIds) {
+            if (seeds.length >= 5)
+                break;
+            if (!seen.has(id)) {
+                seeds.push(id);
+                seen.add(id);
+            }
+        }
+    }
+    // Sort final seedIds alphabetically
+    seeds.sort((a, b) => a.localeCompare(b));
+    return {
+        sourceFiles,
+        seedIds: seeds,
+    };
+}

package/dist/briefing-runtime.d.ts

@@ -0,0 +1,24 @@
+import type { BriefIntentResult } from "./brief-intent.js";
+export type BriefingWorkspaceCtx = {
+    workspaceRoot: string;
+    branch: string;
+    directory?: string;
+    workspace?: string;
+    ttlMs?: number;
+};
+export type BriefingCitation = {
+    id: string;
+    type?: string;
+    title?: string;
+    source?: string;
+    textRef?: string;
+};
+export type BriefingRuntimeResult = {
+    state: "ready" | "tldr_fallback" | "no_briefing";
+    promptBlock: string;
+    tldr: string;
+    citations: BriefingCitation[];
+    showManualCue: boolean;
+    toastMessage: string;
+};
+export declare function fetchBriefingResult(client: unknown, workspaceCtx: BriefingWorkspaceCtx, intentResult: BriefIntentResult): Promise<BriefingRuntimeResult>;

package/dist/briefing-runtime.js

@@ -0,0 +1,277 @@
+// implements REQ-opencode-kibi-briefing-v2
+const DEFAULT_TTL_MS = 300_000;
+const WORKER_TITLE = "Kibi Auto Brief Worker";
+const READY_TOAST = "Kibi brief ready — summary added to guidance.";
+const TLDR_FALLBACK_TOAST = "Kibi brief summary added — use /brief-kibi for full details.";
+const UNAVAILABLE_TOAST = "Kibi brief unavailable — keeping /brief-kibi manual path.";
+const DEFAULT_WHY_IT_MATTERS = "This update changes how current project knowledge should be interpreted.";
+const PROMPT_INSTRUCTION = "Call only kb_briefing_generate once with the provided sourceFiles and seedIds. If briefingState is ready, copy only cited fields. If briefingState is no_briefing, return empty promptBlock/citations and keep manual cue availability. Never invent claims.";
+const PROMPT_FORMAT = {
+    type: "json_schema",
+    schema: {
+        type: "object",
+        properties: {
+            briefingState: { type: "string" },
+            tldr: { type: "string" },
+            promptBlock: { type: "string" },
+            citations: { type: "array", items: { type: "object" } },
+            activationState: { type: "string" },
+            confidence: { type: "string" },
+            freshness: { type: "string" },
+        },
+        required: ["briefingState"],
+    },
+};
+const workerSessionIds = new Map();
+const workerSessionPromises = new Map();
+const resultCache = new Map();
+const inFlightResults = new Map();
+function noBriefingResult() {
+    return {
+        state: "no_briefing",
+        promptBlock: "",
+        tldr: "",
+        citations: [],
+        showManualCue: true,
+        toastMessage: UNAVAILABLE_TOAST,
+    };
+}
+function workspaceSessionKey(workspaceCtx) {
+    return `${workspaceCtx.workspaceRoot}\0${workspaceCtx.branch}`;
+}
+function asRecord(value) {
+    return typeof value === "object" && value !== null
+        ? value
+        : null;
+}
+function asString(value) {
+    return typeof value === "string" ? value : "";
+}
+function sanitizePromptBlock(value) {
+    return asString(value).trim();
+}
+function sanitizeCitations(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const citations = [];
+    for (const item of value) {
+        const record = asRecord(item);
+        if (!record) {
+            continue;
+        }
+        const id = asString(record.id).trim();
+        if (!id) {
+            continue;
+        }
+        const citation = { id };
+        const type = asString(record.type).trim();
+        const title = asString(record.title).trim();
+        const source = asString(record.source).trim();
+        const textRef = asString(record.textRef).trim();
+        if (type) {
+            citation.type = type;
+        }
+        if (title) {
+            citation.title = title;
+        }
+        if (source) {
+            citation.source = source;
+        }
+        if (textRef) {
+            citation.textRef = textRef;
+        }
+        citations.push(citation);
+    }
+    return citations;
+}
+function hasBriefingState(value) {
+    const record = asRecord(value);
+    return record !== null && "briefingState" in record;
+}
+function extractParts(response) {
+    const root = asRecord(response);
+    if (!root) {
+        return [];
+    }
+    const data = asRecord(root.data);
+    const parts = data?.parts ?? root.parts;
+    return Array.isArray(parts) ? parts : [];
+}
+function parsePromptPayload(response) {
+    const parts = extractParts(response);
+    for (let index = parts.length - 1; index >= 0; index -= 1) {
+        const part = asRecord(parts[index]);
+        if (!part || part.type !== "text") {
+            continue;
+        }
+        const text = asString(part.text);
+        if (!text) {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(text);
+            if (hasBriefingState(parsed)) {
+                return parsed;
+            }
+        }
+        catch {
+            // Ignore malformed text parts and continue searching from the end.
+        }
+    }
+    return null;
+}
+function normalizeResult(payload) {
+    if (!payload) {
+        return noBriefingResult();
+    }
+    const briefingState = asString(payload.briefingState).trim();
+    const tldr = asString(payload.tldr).trim();
+    const promptBlock = sanitizePromptBlock(payload.promptBlock);
+    if (briefingState === "ready" && promptBlock) {
+        return {
+            state: "ready",
+            promptBlock,
+            tldr,
+            citations: sanitizeCitations(payload.citations),
+            showManualCue: false,
+            toastMessage: READY_TOAST,
+        };
+    }
+    if (briefingState === "ready" && tldr) {
+        return {
+            state: "tldr_fallback",
+            promptBlock: `- What changed: ${tldr}\n- Why it matters: ${DEFAULT_WHY_IT_MATTERS}`,
+            tldr,
+            citations: [],
+            showManualCue: true,
+            toastMessage: TLDR_FALLBACK_TOAST,
+        };
+    }
+    return noBriefingResult();
+}
+function getSessionApi(client) {
+    const root = asRecord(client);
+    const session = asRecord(root?.session);
+    if (!session) {
+        return null;
+    }
+    const create = session.create;
+    const prompt = session.prompt;
+    if (typeof create !== "function" || typeof prompt !== "function") {
+        return null;
+    }
+    return {
+        create: create,
+        prompt: prompt,
+    };
+}
+function extractSessionId(response) {
+    const root = asRecord(response);
+    if (!root) {
+        return null;
+    }
+    const directId = asString(root.id).trim();
+    if (directId) {
+        return directId;
+    }
+    const data = asRecord(root.data);
+    const dataId = asString(data?.id).trim();
+    return dataId || null;
+}
+async function getWorkerSessionId(sessionApi, workspaceCtx) {
+    const key = workspaceSessionKey(workspaceCtx);
+    const existing = workerSessionIds.get(key);
+    if (existing) {
+        return existing;
+    }
+    const pending = workerSessionPromises.get(key);
+    if (pending) {
+        return pending;
+    }
+    const promise = (async () => {
+        const response = await sessionApi.create({
+            directory: workspaceCtx.workspaceRoot,
+            title: WORKER_TITLE,
+        });
+        const sessionId = extractSessionId(response);
+        if (!sessionId) {
+            throw new Error("Failed to resolve worker session ID");
+        }
+        workerSessionIds.set(key, sessionId);
+        return sessionId;
+    })().finally(() => {
+        workerSessionPromises.delete(key);
+    });
+    workerSessionPromises.set(key, promise);
+    return promise;
+}
+async function loadBriefingResult(sessionApi, workspaceCtx, intentResult) {
+    const sessionID = await getWorkerSessionId(sessionApi, workspaceCtx);
+    const response = await sessionApi.prompt({
+        sessionID,
+        tools: { kb_briefing_generate: true },
+        format: PROMPT_FORMAT,
+        parts: [
+            {
+                type: "text",
+                text: PROMPT_INSTRUCTION,
+            },
+            {
+                type: "text",
+                text: JSON.stringify({
+                    sourceFiles: intentResult.sourceFiles,
+                    seedIds: intentResult.seedIds,
+                }),
+            },
+        ],
+    });
+    return normalizeResult(parsePromptPayload(response));
+}
+// implements REQ-opencode-kibi-briefing-v2
+export async function fetchBriefingResult(client, workspaceCtx, intentResult) {
+    const ttlMs = workspaceCtx.ttlMs ?? DEFAULT_TTL_MS;
+    const cached = resultCache.get(intentResult.fingerprint);
+    const now = Date.now();
+    if (cached && now - cached.timestamp <= ttlMs) {
+        return cached.result;
+    }
+    if (cached) {
+        resultCache.delete(intentResult.fingerprint);
+    }
+    const pending = inFlightResults.get(intentResult.fingerprint);
+    if (pending) {
+        return pending;
+    }
+    const sessionApi = getSessionApi(client);
+    if (!sessionApi || !intentResult.eligible) {
+        const result = noBriefingResult();
+        resultCache.set(intentResult.fingerprint, {
+            result,
+            timestamp: now,
+        });
+        return result;
+    }
+    const promise = (async () => {
+        try {
+            const result = await loadBriefingResult(sessionApi, workspaceCtx, intentResult);
+            resultCache.set(intentResult.fingerprint, {
+                result,
+                timestamp: Date.now(),
+            });
+            return result;
+        }
+        catch {
+            const result = noBriefingResult();
+            resultCache.set(intentResult.fingerprint, {
+                result,
+                timestamp: Date.now(),
+            });
+            return result;
+        }
+    })().finally(() => {
+        inFlightResults.delete(intentResult.fingerprint);
+    });
+    inFlightResults.set(intentResult.fingerprint, promise);
+    return promise;
+}

package/dist/config.d.ts

@@ -15,6 +15,9 @@ export interface KibiConfig {
         toastFailures: boolean;
         toastSuccesses: boolean;
         toastCooldownMs: number;
+        briefs?: {
+            autoSubmit: boolean;
+        };
     };
     guidance: {
         dynamic: boolean;

package/dist/config.js

@@ -11,6 +11,9 @@ const DEFAULTS = {
         toastFailures: true,
         toastSuccesses: false,
         toastCooldownMs: 10000,
+        briefs: {
+            autoSubmit: true,
+        },
     },
     guidance: {
         dynamic: true,
@@ -100,6 +103,12 @@ export function validateAndMerge(obj) {
             out.ux.toastSuccesses = u.toastSuccesses;
         if (typeof u.toastCooldownMs === "number")
             out.ux.toastCooldownMs = u.toastCooldownMs;
+        if (u.briefs && typeof u.briefs === "object") {
+            const b = u.briefs;
+            out.ux.briefs = { autoSubmit: true };
+            if (typeof b.autoSubmit === "boolean")
+                out.ux.briefs.autoSubmit = b.autoSubmit;
+        }
     }
     if (typeof src.logLevel === "string")
         out.logLevel = src.logLevel;

package/dist/e2e-coverage-signals.d.ts

@@ -0,0 +1,6 @@
+export interface E2eCoverageSignal {
+    level: "exact" | "heuristic" | "none";
+    evidence: string[];
+    reminderText: string | null;
+}
+export declare function getE2eCoverageSignal(worktree: string, filePath: string): E2eCoverageSignal;