dsh-continual-evolve 0.10.6 → 0.12.0

package/lib/turn-snapshot.js

@@ -1,238 +0,0 @@
-import { sessionEventsOf } from "./inject.js";
-import { projectKeyOf } from "./project.js";
-/** ZCode's minimum user-prose threshold, counted as lexical words. */
-export const MEMORY_MIN_USER_WORDS = 3;
-const WORD_SEGMENTER = new Intl.Segmenter("und", { granularity: "word" });
-function countUserWords(text) {
-    return [...WORD_SEGMENTER.segment(text)].filter((segment) => segment.isWordLike).length;
-}
-function containsEligibleUserProse(events, minUserWords) {
-    return events.some((event) => {
-        if (!isDirectUserEvent(event))
-            return false;
-        const row = event;
-        return countUserWords(contentText(row.data?.content)) >= minUserWords;
-    });
-}
-/**
- * Capture the current durable surface and select only rows after `cursor`.
- * A seq-bearing session uses `seq:<n>`; older/test surfaces fall back to an
- * event-count cursor so the scheduler still has a deterministic boundary.
- */
-export async function captureTurnSnapshot(ctx, agent, opts) {
-    const allEvents = await readSurface(ctx, agent);
-    const cursor = boundaryCursor(allEvents);
-    const events = eventsAfterCursor(allEvents, opts.cursor);
-    const minUserWords = opts.minUserWords ?? MEMORY_MIN_USER_WORDS;
-    const eligibility = evaluateSnapshotEligibility(events, isInternalAgent(agent), minUserWords);
-    const projectKey = projectKeyOf(agent);
-    return {
-        sessionId: agent.id,
-        ...(projectKey ? { projectKey } : {}),
-        turn: opts.turn,
-        reason: opts.reason,
-        cursor,
-        events,
-        trajectory: eligibility.eligible ? serializeSnapshotEvents(events, opts.maxChars) : "",
-        userText: eligibility.userText,
-        sourceSeqs: directUserSeqs(events),
-        maxChars: opts.maxChars,
-        minUserWords,
-        ...(opts.cursor === undefined ? {} : { capturedAfterCursor: opts.cursor }),
-        eligible: eligibility.eligible,
-        ...(eligibility.reason ? { skipReason: eligibility.reason } : {}),
-    };
-}
-/**
- * Rebase one captured snapshot onto a phase-specific cursor while preserving
- * its outer boundary. The memory phase uses this after a downstream review or
- * fate failure: already-processed evidence is removed, but newly captured rows
- * remain available without moving the shared scheduler cursor backwards.
- */
-export function sliceTurnSnapshot(snapshot, cursor) {
-    const events = sliceSnapshotEvents(snapshot, cursor);
-    const eligibility = evaluateSnapshotEligibility(events, false, snapshot.minUserWords);
-    return {
-        ...snapshot,
-        events,
-        trajectory: eligibility.eligible ? serializeSnapshotEvents(events, snapshot.maxChars) : "",
-        userText: eligibility.userText,
-        sourceSeqs: directUserSeqs(events),
-        eligible: eligibility.eligible,
-        ...(eligibility.reason ? { skipReason: eligibility.reason } : {}),
-    };
-}
-/**
- * Decide whether the incremental rows deserve a model call. This intentionally
- * does not decide whether a fact is valuable; that remains the review model's
- * job. It only removes mechanical noise before the scheduler spends tokens.
- */
-export function evaluateSnapshotEligibility(events, internalAgent = false, minUserWords = MEMORY_MIN_USER_WORDS) {
-    if (internalAgent)
-        return { eligible: false, reason: "internal-agent", userText: "" };
-    if (events.length === 0)
-        return { eligible: false, reason: "no-new-events", userText: "" };
-    if (containsDirectMemoryWrite(events))
-        return { eligible: false, reason: "direct-memory-write", userText: "" };
-    const userText = directUserText(events);
-    if (!containsEligibleUserProse(events, minUserWords))
-        return { eligible: false, reason: "no-user-prose", userText };
-    return { eligible: true, userText };
-}
-/** True when an assistant row records an explicit evolve memory mutation. */
-export function containsDirectMemoryWrite(events) {
-    for (const event of events) {
-        if (!event || typeof event !== "object")
-            continue;
-        const row = event;
-        if (row.type === "tool/call" || row.type === "tool-call") {
-            if (isMemoryMutationName(readNestedString(row.data, ["name", "tool", "toolName"])))
-                return true;
-        }
-        if (row.type === "assistant/message" && containsMemoryMutationName(row.data))
-            return true;
-    }
-    return false;
-}
-/** Serialize only user/assistant text, retaining the bounded tail. */
-export function serializeSnapshotEvents(events, maxChars) {
-    const lines = [];
-    for (const raw of events) {
-        if (!raw || typeof raw !== "object")
-            continue;
-        const event = raw;
-        if (event.type === "user/message" && !isDirectUserEvent(raw))
-            continue;
-        const role = event.type === "user/message" ? "user" : event.type === "assistant/message" ? "assistant" : null;
-        if (role === null)
-            continue;
-        const text = contentText(event.data?.content).trim();
-        if (text.length > 0)
-            lines.push(`${role}: ${text}`);
-    }
-    const joined = lines.join("\n");
-    return joined.length <= maxChars ? joined : joined.slice(-maxChars);
-}
-/** A DSH subagent header is an internal source when its origin says so. */
-export function isInternalAgent(agent) {
-    const header = agent?.session?.header;
-    return header?.origin === "subagent" || header?.origin === "internal" || header?.isSubagent === true;
-}
-async function readSurface(ctx, agent) {
-    const reader = ctx.sessionQuery;
-    if (reader) {
-        const snapshot = await reader.readSurface(agent.id);
-        return Array.isArray(snapshot.events) ? snapshot.events : [];
-    }
-    return sessionEventsOf(agent);
-}
-function boundaryCursor(events) {
-    const seqs = events.map(eventSeq).filter((seq) => seq !== undefined);
-    return seqs.length > 0 ? `seq:${Math.max(...seqs)}` : `index:${events.length}`;
-}
-function sliceSnapshotEvents(snapshot, cursor) {
-    if (snapshot.cursor.startsWith("index:") && cursor.startsWith("index:") && snapshot.capturedAfterCursor?.startsWith("index:")) {
-        const start = Number(snapshot.capturedAfterCursor.slice("index:".length));
-        const phaseBoundary = Number(cursor.slice("index:".length));
-        if (!Number.isInteger(start) || !Number.isInteger(phaseBoundary))
-            return snapshot.events;
-        const relative = phaseBoundary - start;
-        if (relative <= 0)
-            return snapshot.events;
-        return relative >= snapshot.events.length ? [] : snapshot.events.slice(relative);
-    }
-    return eventsAfterCursor(snapshot.events, cursor);
-}
-function eventsAfterCursor(events, cursor) {
-    if (cursor === undefined)
-        return events;
-    if (cursor.startsWith("seq:")) {
-        const boundary = Number(cursor.slice(4));
-        if (!Number.isFinite(boundary))
-            return events;
-        return events.filter((event) => {
-            const seq = eventSeq(event);
-            return seq === undefined || seq > boundary;
-        });
-    }
-    if (cursor.startsWith("index:")) {
-        const boundary = Number(cursor.slice(6));
-        return Number.isInteger(boundary) && boundary >= 0 ? events.slice(boundary) : events;
-    }
-    return events;
-}
-function directUserText(events) {
-    return events
-        .filter(isDirectUserEvent)
-        .map((event) => contentText(event.data?.content).trim())
-        .filter(Boolean)
-        .join("\n");
-}
-function directUserSeqs(events) {
-    return events
-        .filter(isDirectUserEvent)
-        .map(eventSeq)
-        .filter((seq) => seq !== undefined);
-}
-function isDirectUserEvent(event) {
-    if (!event || typeof event !== "object")
-        return false;
-    const row = event;
-    if (row.type !== "user/message")
-        return false;
-    if (row.data?.visibility === "model-only")
-        return false;
-    if (row.data?.source?.synthetic === true)
-        return false;
-    if (row.data?.source?.kind !== undefined && row.data.source.kind !== "user")
-        return false;
-    return contentText(row.data?.content).trim().length > 0;
-}
-function contentText(content) {
-    if (typeof content === "string")
-        return content;
-    if (!Array.isArray(content))
-        return "";
-    return content
-        .map((block) => {
-        if (typeof block === "string")
-            return block;
-        if (!block || typeof block !== "object")
-            return "";
-        const value = block;
-        if (value.synthetic === true || value.ignored === true || (value.type !== undefined && value.type !== "text"))
-            return "";
-        return typeof value.text === "string" ? value.text : "";
-    })
-        .filter(Boolean)
-        .join(" ");
-}
-function eventSeq(event) {
-    if (!event || typeof event !== "object")
-        return undefined;
-    const seq = event.seq;
-    return typeof seq === "number" && Number.isInteger(seq) ? seq : undefined;
-}
-function containsMemoryMutationName(value) {
-    if (typeof value === "string")
-        return isMemoryMutationName(value);
-    if (Array.isArray(value))
-        return value.some(containsMemoryMutationName);
-    if (!value || typeof value !== "object")
-        return false;
-    return Object.values(value).some(containsMemoryMutationName);
-}
-function isMemoryMutationName(value) {
-    return value === "evolve_add" || value === "evolve_update" || value === "evolve_delete";
-}
-function readNestedString(value, keys) {
-    if (!value || typeof value !== "object")
-        return undefined;
-    const row = value;
-    for (const key of keys) {
-        if (typeof row[key] === "string")
-            return row[key];
-    }
-    return undefined;
-}
-//# sourceMappingURL=turn-snapshot.js.map

package/lib/types.d.ts

@@ -1,208 +0,0 @@
-/** What a harness entry can be. */
-export type RefinementKind = "prompt" | "memory" | "skill" | "subagent";
-/**
- * Skill-entry form: `executable` skills carry a python reference contract
- * and can be hot-mounted as tools; `guidance` skills are SKILL.md documents
- * (no python reference) that materialize as discoverable skills for the
- * `skill` tool — the form for recurring multi-step workflows. Absent means
- * `executable` (backwards compatible with pre-guidance stores).
- */
-export type SkillKind = "executable" | "guidance";
-/** How an entry changes. */
-export type RefinementAction = "create" | "update" | "delete" | "archive";
-/** Where an entry lives: session staging, one project, or cross-project. */
-export type HarnessScope = "local" | "project" | "global";
-/**
- * Memory-entry shape discipline (one fact per entry, typed like ZCode's
- * memory frontmatter): every `memory` create must stamp one of these in
- * `metadata[MEMORY_TYPE_KEY]` — the recall hook the directory shows.
- */
-export declare const MEMORY_TYPE_KEY = "memoryType";
-/** Closed memory-type set: user | feedback | project | reference. */
-export declare const MEMORY_TYPES: readonly ["user", "feedback", "project", "reference"];
-/** One of {@link MEMORY_TYPES}. */
-export type MemoryRecallType = (typeof MEMORY_TYPES)[number];
-/** True when the value is a closed-set memory type. */
-export declare function isMemoryType(value: unknown): value is MemoryRecallType;
-/**
- * Metadata key recording which session an entry's content was distilled from
- * (trajectory citation; see {@link EntrySource}).
- */
-export declare const SOURCE_SESSION_KEY = "sourceSession";
-/**
- * Metadata key recording the session-log event seqs (of the direct user
- * messages) the entry cites as its source (trajectory citation).
- */
-export declare const SOURCE_SEQS_KEY = "sourceSeqs";
-/**
- * Metadata key recording when an entry was archived. Archived entries are
- * hidden from injection but never deleted — the data stays in the store and
- * the entry can be restored (unarchive) or rolled back like any other edit.
- */
-export declare const ARCHIVED_AT_KEY = "archivedAt";
-/**
- * Metadata key stamped on a LOCAL entry that was promoted to the global
- * store by a session wrap-up: the id of the global entry it became. Present
- * means the entry's lifecycle is finished — it must not be offered for
- * promotion again (the global copy is the live one, the local copy is a
- * restorable trace).
- */
-export declare const PROMOTED_TO_KEY = "promotedTo";
-/**
- * Metadata key recording when a local entry was promoted to the global
- * store (companion of {@link PROMOTED_TO_KEY}).
- */
-export declare const PROMOTED_AT_KEY = "promotedAt";
-/**
- * Metadata key stamped on a GLOBAL entry created by a session wrap-up
- * promotion: `<sessionId>:<localEntryId>` — the反向 provenance link from the
- * cross-session copy back to the session it was distilled from.
- */
-export declare const SOURCED_FROM_KEY = "sourcedFromLocal";
-/**
- * Metadata key stamped on a GLOBAL entry that was created despite a
- * moderate-similarity overlap with an existing entry (write-time conflict
- * guard, warn tier): `<kind>:<id>:<score>` — points at the entry it may
- * duplicate so wrapup/fate can consolidate later. Creates at/above the block
- * threshold never reach this stamp; they are rejected outright.
- */
-export declare const CONFLICT_HINT_KEY = "conflictHint";
-/**
- * Negative-valence counter (P1 效价反馈): how many times an assessment marked
- * this entry contradicted by newer evidence (user correction, overridden
- * fact). Injection ranking demotes entries with a positive counter and the
- * wrapup/fate assessors see the count so they prefer archiving the entry.
- */
-export declare const VALENCE_NEGATIVE_KEY = "valenceNegative";
-/**
- * Provenance of entries merged INTO this one by the consolidation command
- * (P1 反膨胀): array of `<kind>:<id>` — the near-duplicate sources whose
- * content was appended before they archived. The trail keeps an unarchive of
- * the source explainable and lets audits find the merge provenance.
- */
-export declare const MERGED_FROM_KEY = "mergedFrom";
-/**
- * True when the entry is archived (hidden from injection, restorable).
- * Absent or empty archivedAt means the entry is active.
- */
-export declare function isArchived(entry: HarnessEntry): boolean;
-/**
- * Trajectory citation attached to newly created entries: the session the
- * content came from and the seqs of the direct user messages it was
- * distilled from. Both fields are optional — when they cannot be determined
- * the citation is simply omitted (never an error).
- */
-export interface EntrySource {
-    sessionId?: string;
-    /** Event seqs of the source user messages, in log order. */
-    seqs?: number[];
-}
-/** A single persisted harness entry. */
-export interface HarnessEntry {
-    id: string;
-    kind: RefinementKind;
-    title: string;
-    content: string;
-    path: string;
-    scope: HarnessScope;
-    /** Skill entries carry an executable contract; see {@link PythonReference}. */
-    reference: Record<string, unknown>;
-    /** Skill entries declare their accepted inputs here. */
-    arguments: Record<string, unknown>;
-    /** Skill form: "executable" (default) or "guidance" (SKILL.md document). */
-    skill_kind?: SkillKind;
-    metadata: Record<string, unknown>;
-    source: "evolve";
-    created_at: string;
-    updated_at: string;
-    version: number;
-}
-/** One entry of the append-only refinement history (the evidence trail). */
-export interface HarnessRefinementEvent {
-    id: string;
-    trigger: string;
-    changes: string[];
-    /** Where the trajectory evidence for this refinement lives (e.g. seq ranges). */
-    evidence: string;
-    /** The falsifiable expectation recorded with the edit. */
-    outcome: string;
-    created_at: string;
-}
-/** The whole harness state file. */
-export interface HarnessState {
-    schema: number;
-    entries: Record<RefinementKind, Record<string, HarnessEntry>>;
-    refinements: HarnessRefinementEvent[];
-}
-/** A model-proposed edit, before validation and application. */
-export interface RefinementEdit {
-    action: RefinementAction;
-    kind: RefinementKind;
-    id?: string;
-    title?: string;
-    content?: string;
-    path?: string;
-    reference?: Record<string, unknown>;
-    arguments?: Record<string, unknown>;
-    /** Skill form: "guidance" for SKILL.md document skills; absent = executable. */
-    skill_kind?: SkillKind;
-    metadata?: Record<string, unknown>;
-    reason?: string;
-    /**
-     * Gap C2: blast-radius annotation — how broadly this edit applies.
-     * Values: "general" (cross-project tactical), "project" (single project),
-     * "session" (one-off session-specific). The review gate checks that
-     * local-scope edits are "session" or "project" and global-scope edits
-     * are "general" or "project".
-     */
-    blastRadius?: "general" | "project" | "session";
-}
-/** The structured output of a planning pass. */
-export interface RefinementProposal {
-    summary: string;
-    rationale: string;
-    edits: RefinementEdit[];
-    expectedOutcome: string;
-}
-/** An edit after the apply pass: before/after snapshots and outcome per edit. */
-export interface AppliedRefinementEdit extends RefinementEdit {
-    id: string;
-    before?: HarnessEntry;
-    after?: HarnessEntry;
-    applied: boolean;
-    error?: string;
-}
-/** The result of applying one refinement. */
-export interface RefinementResult {
-    id: string;
-    summary: string;
-    rationale: string;
-    expectedOutcome: string;
-    appliedEdits: AppliedRefinementEdit[];
-    harnessStatePath: string;
-    rollbackOf?: string;
-    scope?: HarnessScope;
-}
-/** The executable contract a skill entry must carry (python REPL skills). */
-export interface PythonReference {
-    type: "python";
-    import?: string;
-    python_import?: string;
-    callable?: string;
-    call_pattern?: string;
-}
-/**
- * A stable id derived from a title: ASCII runs become snake_case (unchanged
- * legacy behavior). Titles with no ASCII content at all (e.g. pure Chinese)
- * used to collapse onto the bare fallback, so distinct memories shared one
- * id and every later create failed as "already exists". They now take
- * `<fallback>_<sha256-8>` instead: distinct titles get distinct ids while
- * identical titles still dedupe onto the same id. The fallback itself is
- * assumed id-safe (callers pass entry kinds).
- */
-export declare function slug(raw: string, fallback: string): string;
-/** Fresh empty state with the current schema version. */
-export declare function emptyHarnessState(): HarnessState;
-/** Deep clone helper (state is plain JSON data). */
-export declare function cloneEntry(entry: HarnessEntry | undefined): HarnessEntry | undefined;
-//# sourceMappingURL=types.d.ts.map

package/lib/types.js

@@ -1,127 +0,0 @@
-/**
- * Type model for the continual-evolution harness state.
- *
- * Design provenance: the state model follows the continual-harness design
- * validated in prime-agent's `/refine` subsystem (MIT): versioned entries
- * keyed by kind, an append-only refinement history carrying an evidence
- * trail, atomic persistence, and deterministic inverse-op rollback. The
- * code here is an original implementation, written for the DeepSeek Harness
- * plugin surface.
- */
-import { createHash } from "node:crypto";
-/**
- * Memory-entry shape discipline (one fact per entry, typed like ZCode's
- * memory frontmatter): every `memory` create must stamp one of these in
- * `metadata[MEMORY_TYPE_KEY]` — the recall hook the directory shows.
- */
-export const MEMORY_TYPE_KEY = "memoryType";
-/** Closed memory-type set: user | feedback | project | reference. */
-export const MEMORY_TYPES = ["user", "feedback", "project", "reference"];
-/** True when the value is a closed-set memory type. */
-export function isMemoryType(value) {
-    return typeof value === "string" && MEMORY_TYPES.includes(value);
-}
-/**
- * Metadata key recording which session an entry's content was distilled from
- * (trajectory citation; see {@link EntrySource}).
- */
-export const SOURCE_SESSION_KEY = "sourceSession";
-/**
- * Metadata key recording the session-log event seqs (of the direct user
- * messages) the entry cites as its source (trajectory citation).
- */
-export const SOURCE_SEQS_KEY = "sourceSeqs";
-/**
- * Metadata key recording when an entry was archived. Archived entries are
- * hidden from injection but never deleted — the data stays in the store and
- * the entry can be restored (unarchive) or rolled back like any other edit.
- */
-export const ARCHIVED_AT_KEY = "archivedAt";
-/**
- * Metadata key stamped on a LOCAL entry that was promoted to the global
- * store by a session wrap-up: the id of the global entry it became. Present
- * means the entry's lifecycle is finished — it must not be offered for
- * promotion again (the global copy is the live one, the local copy is a
- * restorable trace).
- */
-export const PROMOTED_TO_KEY = "promotedTo";
-/**
- * Metadata key recording when a local entry was promoted to the global
- * store (companion of {@link PROMOTED_TO_KEY}).
- */
-export const PROMOTED_AT_KEY = "promotedAt";
-/**
- * Metadata key stamped on a GLOBAL entry created by a session wrap-up
- * promotion: `<sessionId>:<localEntryId>` — the反向 provenance link from the
- * cross-session copy back to the session it was distilled from.
- */
-export const SOURCED_FROM_KEY = "sourcedFromLocal";
-/**
- * Metadata key stamped on a GLOBAL entry that was created despite a
- * moderate-similarity overlap with an existing entry (write-time conflict
- * guard, warn tier): `<kind>:<id>:<score>` — points at the entry it may
- * duplicate so wrapup/fate can consolidate later. Creates at/above the block
- * threshold never reach this stamp; they are rejected outright.
- */
-export const CONFLICT_HINT_KEY = "conflictHint";
-/**
- * Negative-valence counter (P1 效价反馈): how many times an assessment marked
- * this entry contradicted by newer evidence (user correction, overridden
- * fact). Injection ranking demotes entries with a positive counter and the
- * wrapup/fate assessors see the count so they prefer archiving the entry.
- */
-export const VALENCE_NEGATIVE_KEY = "valenceNegative";
-/**
- * Provenance of entries merged INTO this one by the consolidation command
- * (P1 反膨胀): array of `<kind>:<id>` — the near-duplicate sources whose
- * content was appended before they archived. The trail keeps an unarchive of
- * the source explainable and lets audits find the merge provenance.
- */
-export const MERGED_FROM_KEY = "mergedFrom";
-/**
- * True when the entry is archived (hidden from injection, restorable).
- * Absent or empty archivedAt means the entry is active.
- */
-export function isArchived(entry) {
-    const value = entry.metadata[ARCHIVED_AT_KEY];
-    return typeof value === "string" && value.length > 0;
-}
-/**
- * A stable id derived from a title: ASCII runs become snake_case (unchanged
- * legacy behavior). Titles with no ASCII content at all (e.g. pure Chinese)
- * used to collapse onto the bare fallback, so distinct memories shared one
- * id and every later create failed as "already exists". They now take
- * `<fallback>_<sha256-8>` instead: distinct titles get distinct ids while
- * identical titles still dedupe onto the same id. The fallback itself is
- * assumed id-safe (callers pass entry kinds).
- */
-export function slug(raw, fallback) {
-    const normalized = raw
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "_")
-        .replace(/^_+|_+$/g, "")
-        .slice(0, 80);
-    if (normalized)
-        return normalized;
-    const digest = createHash("sha256").update(raw, "utf8").digest("hex").slice(0, 8);
-    return `${fallback}_${digest}`;
-}
-/** Fresh empty state with the current schema version. */
-export function emptyHarnessState() {
-    return {
-        schema: 1,
-        entries: {
-            prompt: {},
-            memory: {},
-            skill: {},
-            subagent: {},
-        },
-        refinements: [],
-    };
-}
-/** Deep clone helper (state is plain JSON data). */
-export function cloneEntry(entry) {
-    return entry ? JSON.parse(JSON.stringify(entry)) : undefined;
-}
-//# sourceMappingURL=types.js.map

package/lib/usage.d.ts

@@ -1,36 +0,0 @@
-import type { RefinementKind } from "./types.js";
-export interface UsageStore {
-    /** Injection count per entry key (`kind:id`). */
-    counts: Record<string, number>;
-    /** Session dedup marker: the last session id each key was counted in (v2). */
-    lastSession?: Record<string, string>;
-}
-/**
- * Load the usage store from disk; returns an empty store when absent or
- * corrupt. Accepts BOTH on-disk shapes:
- * - legacy (≤0.3.x): a flat `{ "kind:id": count }` map,
- * - v2: `{ version: 2, counts, lastSession }` with per-session dedup.
- */
-export declare function loadUsage(baseDir: string): UsageStore;
-/** Persist the usage store atomically (always the v2 shape). */
-export declare function saveUsage(baseDir: string, store: UsageStore): void;
-/** Build the usage key for an entry. */
-export declare function usageKey(kind: RefinementKind, id: string): string;
-/**
- * Increment injection counts for the entries that were actually injected.
- * Called after `entriesSectionText` renders the injected block. Keys not
- * present in the store are initialized to 1.
- *
- * Session dedup (2026-08-22): with a sessionId, each key counts AT MOST
- * ONCE per session — the old per-build counting produced meaningless
- * numbers (one entry hit 2311× in a week) and hid the real "how many
- * sessions found this useful" signal that staleness decay needs. Without
- * a sessionId the call degrades to legacy always-increment behavior.
- */
-export declare function recordInjection(baseDir: string, injectedKeys: readonly string[], sessionId?: string): void;
-/**
- * Get the injection count for a specific entry. Returns 0 when the entry
- * has never been injected (absent from the store).
- */
-export declare function getUsageCount(store: UsageStore, kind: RefinementKind, id: string): number;
-//# sourceMappingURL=usage.d.ts.map