@glyphier/cli 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1421 @@
+import Parser from 'web-tree-sitter';
+import { z } from 'zod';
+
+/**
+ * Core type definitions for the Glyphier AI-Native Code Representation Engine.
+ */
+/**
+ * 1-indexed line range [start, end] inclusive.
+ */
+interface LineRange {
+    start: number;
+    end: number;
+}
+/**
+ * Metadata associated with a parsed file.
+ */
+interface FileMetadata {
+    path: string;
+    language: string;
+    lineCount: number;
+    functionCount: number;
+    mtime: number;
+    sizeBytes?: number;
+}
+/**
+ * Represents an imported dependency.
+ */
+interface ImportNode {
+    kind: "use";
+    path: string;
+    symbols: string[];
+}
+/**
+ * Represents a type declaration, interface, struct, or typedef.
+ */
+interface TypeNode {
+    kind: "type";
+    name: string;
+    lines: LineRange;
+    fields: Array<{
+        name: string;
+        type: string;
+    }>;
+    isExported?: boolean;
+    values?: string[];
+}
+/**
+ * Represents a function or method declaration.
+ */
+interface FunctionNode {
+    kind: "fn";
+    name: string;
+    lines: LineRange;
+    params: Array<{
+        name: string;
+        type: string;
+    }>;
+    returnType: string;
+    isAsync?: boolean;
+    isExported?: boolean;
+    /** L2 only: names of guard/validation functions called */
+    validates?: string[];
+    /** L2 only: names or scoped descriptors of functions/methods called */
+    calls?: Array<string | ScopedCall>;
+    /** L2 only: names of error types thrown or raised */
+    throws?: string[];
+    /** Decorators applied to function/method */
+    decorators?: Array<{
+        name: string;
+        args?: string[];
+    }>;
+    /** L2 only: key state transitions, status strings, or enum literals */
+    states?: string[];
+    /** L2 only: concise return object shapes */
+    returns?: string[];
+    /** L2 only: paired test names exercising this function */
+    tests?: string[];
+}
+/**
+ * Scoped call target indicating whether a call is to self, local module, or external.
+ */
+interface ScopedCall {
+    name: string;
+    scope: "self" | "local" | "ext";
+    target?: string;
+    line?: number;
+}
+/**
+ * Represents a class or trait declaration.
+ */
+interface ClassNode {
+    kind: "class";
+    name: string;
+    lines: LineRange;
+    extends?: string;
+    implements?: string[];
+    methods: FunctionNode[];
+    isExported?: boolean;
+    /** Decorators applied to class */
+    decorators?: Array<{
+        name: string;
+        args?: string[];
+    }>;
+}
+/**
+ * Represents a parse or syntax error within a file region.
+ */
+interface ErrorNode {
+    kind: "error";
+    message: string;
+    lines: LineRange;
+}
+/**
+ * Represents the top-level module node for a single file.
+ */
+interface ModuleNode {
+    kind: "mod";
+    name: string;
+    lines: LineRange;
+    imports: ImportNode[];
+    types: TypeNode[];
+    functions: FunctionNode[];
+    classes: ClassNode[];
+    errors?: ErrorNode[];
+}
+/**
+ * The complete parsed IR representation of a file.
+ */
+interface Glyphier {
+    module: ModuleNode;
+    metadata: FileMetadata;
+}
+/**
+ * Node in the project directory tree.
+ */
+interface TreeNode {
+    name: string;
+    type: "file" | "directory";
+    children?: TreeNode[];
+    metadata?: FileMetadata;
+    extension?: string;
+}
+/**
+ * Result of a semantic IR search.
+ */
+interface SearchResult {
+    file: string;
+    symbol: string;
+    kind: "fn" | "class" | "type" | "use" | "calls" | "route" | "var";
+    lines: LineRange;
+    context?: string;
+}
+/**
+ * Configuration options for Glyphier.
+ */
+interface GlyphierConfig {
+    ignore: string[];
+    languages?: Record<string, {
+        extensions: string[];
+        grammar?: string;
+        tags?: string;
+    }>;
+    maxFileSize: number;
+    defaultLevel: 0 | 1 | 2;
+    callFilter?: {
+        exclude?: string[];
+    };
+}
+/**
+ * Information about a caller in the inverted call graph.
+ */
+interface CallerReference {
+    file: string;
+    symbol: string;
+    kind: "function" | "method" | "constructor";
+    lines: LineRange;
+    callsTarget: string;
+}
+/**
+ * Result of impact / blast radius analysis.
+ */
+interface ImpactAnalysisResult {
+    target: string;
+    file?: string;
+    kind?: string;
+    callers: CallerReference[];
+    transitiveCount: number;
+    depth: number;
+    risk: "low" | "med" | "high" | "critical";
+    importers: string[];
+}
+/**
+ * Delta representation for a modified declaration in semantic diff.
+ */
+interface DeclarationDelta {
+    name: string;
+    kind: "function" | "class" | "method" | "type";
+    status: "added" | "removed" | "modified";
+    lines?: LineRange;
+    oldSignature?: string;
+    newSignature?: string;
+    addedCalls?: string[];
+    removedCalls?: string[];
+    paramChanges?: string[];
+}
+/**
+ * Result of semantic AST diffing.
+ */
+interface SemanticDiffResult {
+    file: string;
+    revision: string;
+    deltas: DeclarationDelta[];
+    addedLinesCount: number;
+    deletedLinesCount: number;
+}
+/**
+ * Adaptive token budgeting projection plan.
+ */
+interface BudgetPlan {
+    targetBudget: number;
+    projectedTokens: number;
+    l0Files: string[];
+    l1Files: string[];
+    l2Files: string[];
+    centralityRankings: Array<{
+        file: string;
+        score: number;
+        level: 0 | 1 | 2;
+    }>;
+}
+/**
+ * Pre-flight AST check result.
+ */
+interface PreflightCheckResult {
+    file: string;
+    valid: boolean;
+    syntaxErrors: Array<{
+        line: number;
+        message: string;
+    }>;
+    unresolvedImports: string[];
+    astSummary?: string;
+}
+/**
+ * BullMQ / message queue architectural mapping.
+ */
+interface QueueInfo {
+    name: string;
+    processor?: string;
+    processorFile?: string;
+    jobs?: string[];
+    injectedIn?: string[];
+}
+/**
+ * Cross-module external dependency boundary.
+ */
+interface ExternalDependency {
+    source: string;
+    symbols: string[];
+}
+/**
+ * Subsystem architectural dependency graph.
+ */
+interface SubsystemGraph {
+    name: string;
+    path: string;
+    fileCount: number;
+    moduleName?: string;
+    isGlobal?: boolean;
+    importedModules?: string[];
+    externalDeps: ExternalDependency[];
+    queues: QueueInfo[];
+    services: Array<{
+        name: string;
+        file: string;
+        calls: string[];
+    }>;
+}
+/**
+ * A single node within a multi-file program slice.
+ */
+interface SliceNode {
+    file: string;
+    kind: "fn" | "type";
+    name: string;
+    lines: LineRange;
+    signature?: string;
+    calls?: string[];
+    validates?: string[];
+    tests?: string[];
+}
+/**
+ * The self-contained result of a program slice across multiple files.
+ */
+interface ProgramSliceResult {
+    rootSymbol: string;
+    targetSymbol?: string;
+    depth: number;
+    nodes: SliceNode[];
+    files: string[];
+    tokenEstimate: number;
+}
+/**
+ * Result of a multi-turn session delta comparison.
+ */
+interface SessionDeltaResult {
+    file: string;
+    sessionId: string;
+    status: "unchanged" | "modified" | "new";
+    fingerprint: string;
+    unchangedCount?: number;
+    modifiedFunctions?: FunctionNode[];
+    addedFunctions?: FunctionNode[];
+    removedFunctions?: string[];
+}
+type PatchAction = "add-call" | "add-fn" | "add-field" | "replace-call" | "remove-node";
+interface PatchOperation {
+    action: PatchAction;
+    target: string;
+    code: string;
+}
+interface PatchResult {
+    file: string;
+    success: boolean;
+    appliedOps: number;
+    error?: string;
+    diff?: string;
+    patchedCode?: string;
+}
+
+declare const DEFAULT_CONFIG: GlyphierConfig;
+/**
+ * Loads configuration from a `.glyphierrc.json` in the target directory or its parents,
+ * merging with default values.
+ */
+declare function loadConfig(rootPath?: string): GlyphierConfig;
+/**
+ * Resolves the root directory of the repository/project by walking up to find .git, pnpm-workspace.yaml, or package.json.
+ */
+declare function findProjectRoot(startPath?: string): string;
+
+/**
+ * File-level cache with in-memory fast path and persistent SQLite backing.
+ */
+declare class MtimeCache {
+    private entries;
+    private hits;
+    private misses;
+    /**
+     * Retrieves a cached IR if the file modification time matches.
+     */
+    get(filePath: string, currentMtime?: number): Glyphier | null;
+    /**
+     * Sets or updates the cache entry for a file.
+     */
+    set(filePath: string, mtime: number, ir: Glyphier): void;
+    /**
+     * Checks if an entry is present and fresh.
+     */
+    isValid(filePath: string, currentMtime: number): boolean;
+    /**
+     * Removes a file from the cache.
+     */
+    delete(filePath: string): boolean;
+    /**
+     * Clears the entire cache.
+     */
+    clear(): void;
+    /**
+     * Returns cache metrics.
+     */
+    getStats(): {
+        size: number;
+        hits: number;
+        misses: number;
+    };
+}
+declare const globalCache: MtimeCache;
+
+/**
+ * Maps file extensions to tree-sitter language names.
+ */
+declare const EXTENSION_TO_LANGUAGE: Record<string, string>;
+/**
+ * Initializes the web-tree-sitter WASM engine.
+ */
+declare function initTreeSitter(): Promise<void>;
+/**
+ * Detects the language from a file name or path.
+ */
+declare function detectLanguage(filePath: string): string | null;
+/**
+ * Loads and caches a Tree-sitter Language instance.
+ */
+declare function loadLanguage(langName: string): Promise<Parser.Language | null>;
+/**
+ * Returns a list of all built-in supported languages.
+ */
+declare function getSupportedLanguages(): string[];
+
+interface ParseResult {
+    tree: Parser.Tree;
+    language: string;
+    langInstance: Parser.Language;
+    lineCount: number;
+}
+declare function parseSource(source: string, languageHint?: string): Promise<ParseResult | null>;
+/**
+ * Parses a file on disk into a Tree-sitter CST.
+ */
+declare function parseFileTree(filePath: string): Promise<ParseResult | null>;
+
+/**
+ * Normalizes types to compact abbreviations.
+ */
+declare function abbreviateType(rawType: string): string;
+/**
+ * Options for IR generation.
+ */
+interface GenerateIROptions {
+    level?: 1 | 2;
+    config?: GlyphierConfig;
+    rootPath?: string;
+}
+/**
+ * Generates Glyphier IR from a parsed Tree-sitter CST.
+ */
+declare function generateIR(tree: Parser.Tree, filePath: string, language: string, lineCount: number, options?: GenerateIROptions): Glyphier;
+
+interface BuildTreeOptions {
+    depth?: number;
+    config?: GlyphierConfig;
+    rootPath?: string;
+    ignore?: string[];
+}
+/**
+ * Builds a hierarchical TreeNode representation of a project directory.
+ */
+declare function buildTree(targetDir: string, options?: BuildTreeOptions): Promise<TreeNode>;
+
+interface SearchOptions {
+    kind?: "calls" | "fn" | "type" | "use" | "route" | "var" | "all";
+}
+type SearchTarget = Glyphier[] | {
+    files: Map<string, Glyphier>;
+} | Map<string, Glyphier>;
+/**
+ * Searches across a collection of parsed IR files for symbols or patterns.
+ */
+declare function searchIR(target: SearchTarget, query: string, kindOrOptions?: SearchOptions["kind"] | SearchOptions): SearchResult[];
+/**
+ * Formats search results into a concise string for LLM agents or terminal users.
+ */
+declare function formatSearchResults(query: string, results: SearchResult[]): string;
+
+interface ProjectParseResult {
+    tree: TreeNode;
+    files: Map<string, Glyphier>;
+    rootPath: string;
+}
+interface ParseFileOptions {
+    level?: 1 | 2;
+    config?: GlyphierConfig;
+    rootPath?: string;
+    source?: string;
+    language?: string;
+    noCache?: boolean;
+}
+interface ParseProjectOptions extends ParseFileOptions {
+    ignore?: string[];
+    depth?: number;
+}
+/**
+ * Parses a single file into Glyphier, utilizing cache where possible.
+ */
+declare function parseFile(filePath: string, languageOrOptions?: string | ParseFileOptions, maybeOptions?: ParseFileOptions): Promise<Glyphier | null>;
+/**
+ * Parses an entire project or directory recursively into IR.
+ */
+declare function parseProject(targetDir?: string, options?: ParseProjectOptions): Promise<ProjectParseResult>;
+interface ReadRawOptions {
+    startLine?: number;
+    endLine?: number;
+}
+/**
+ * Reads raw source code lines from a file with line numbers prefixed.
+ */
+declare function readRaw(filePath: string, options?: ReadRawOptions): string | null;
+
+interface ImpactOptions {
+    depth?: number;
+    rootPath?: string;
+    project?: ProjectParseResult;
+}
+/**
+ * Analyzes the blast radius / impact of modifying or renaming a symbol.
+ */
+declare function analyzeImpact(symbolName: string, targetPathOrOptions?: string | ImpactOptions, maybeOptions?: ImpactOptions): Promise<ImpactAnalysisResult>;
+
+interface SemanticDiffOptions {
+    since?: string;
+    rootPath?: string;
+    baseSource?: string;
+    currentSource?: string;
+}
+/**
+ * Computes a semantic AST diff between two versions of a file.
+ */
+declare function semanticDiff(filePath: string, options?: SemanticDiffOptions): Promise<SemanticDiffResult>;
+
+interface BudgetProjectionOptions {
+    budget: number;
+    rootPath?: string;
+    project?: ProjectParseResult;
+    countTokens?: (s: string) => number;
+}
+interface BudgetProjectionResult {
+    plan: BudgetPlan;
+    formattedOutput: string;
+    totalTokens: number;
+}
+/**
+ * Adaptive token budgeting engine: packs maximum semantic information
+ * into a strict token budget using PageRank / centrality ranking.
+ */
+declare function projectBudget(options: BudgetProjectionOptions): Promise<BudgetProjectionResult>;
+
+interface PreflightCheckOptions {
+    rootPath?: string;
+    originalSource?: string;
+}
+/**
+ * Pre-flight validator: checks proposed agent patches/code for AST syntax errors,
+ * missing braces, and structural defects BEFORE writing to disk.
+ */
+declare function preflightCheck(filePath: string, patchOrCode: string, options?: PreflightCheckOptions): Promise<PreflightCheckResult>;
+
+interface GraphOptions {
+    rootPath?: string;
+    project?: ProjectParseResult;
+}
+/**
+ * Analyzes the architectural dependency graph of a module or subsystem directory.
+ */
+declare function analyzeModuleGraph(targetDir: string, options?: GraphOptions): Promise<SubsystemGraph>;
+/**
+ * Formats a SubsystemGraph into an ultra-dense symbolic S-expression.
+ */
+declare function formatGraphSExpr(graph: SubsystemGraph): string;
+
+interface SliceOptions {
+    depth?: number;
+    targetSymbol?: string;
+    rootPath?: string;
+    project?: {
+        files: Map<string, Glyphier>;
+    };
+}
+/**
+ * Computes a targeted, multi-file program slice around a root symbol.
+ * Traces call graphs and type dependencies to isolate only the code execution path.
+ */
+declare function computeProgramSlice(targetPath: string, rootSymbol: string, options?: SliceOptions): Promise<ProgramSliceResult>;
+
+/**
+ * Computes a session delta for a file.
+ * Returns 'unchanged' if file has already been sent to this agent session without modifications,
+ * or an inverted delta of only modified/added functions.
+ */
+declare function computeSessionDelta(sessionId: string, filePath: string, ir: Glyphier): SessionDeltaResult;
+/**
+ * Resets or clears a session state.
+ */
+declare function clearSession(sessionId?: string): void;
+
+/**
+ * Applies surgical AST-native structural patches to a source file.
+ * Pre-validates syntax with Tree-sitter prior to persisting changes to disk.
+ */
+declare function applyAstPatch(filePath: string, operations: PatchOperation[] | string, options?: {
+    dryRun?: boolean;
+}): Promise<PatchResult>;
+
+interface FileStat {
+    path: string;
+    rawTokens: number;
+    l1Tokens: number;
+    l2Tokens: number;
+    ratio: number;
+}
+interface ProjectStats {
+    targetPath: string;
+    filesCount: number;
+    rawTokens: number;
+    l1Tokens: number;
+    l2Tokens: number;
+    compressionRatio: number;
+    languageBreakdown: Record<string, {
+        files: number;
+        rawTokens: number;
+        l2Tokens: number;
+    }>;
+    heaviestFiles: FileStat[];
+    pricing: {
+        sonnetRaw: string;
+        sonnetIr: string;
+        sonnetSaved: string;
+        gpt4oRaw: string;
+        gpt4oIr: string;
+        gpt4oSaved: string;
+    };
+}
+interface StatsOptions {
+    rootPath?: string;
+    topN?: number;
+}
+/**
+ * Computes token density, compression ratios, and pricing analytics across a codebase or file.
+ */
+declare function computeStats(targetPath: string, options?: StatsOptions): Promise<ProjectStats>;
+/**
+ * Formats ProjectStats into a compact S-expression.
+ */
+declare function formatStatsSExpr(stats: ProjectStats): string;
+
+interface FormatSExprOptions {
+    level?: 1 | 2;
+}
+/**
+ * Formats a Glyphier module into compact S-expression notation.
+ */
+declare function formatSExpr(ir: Glyphier, optionsOrLevel?: FormatSExprOptions | 1 | 2): string;
+/**
+ * Formats an Impact Analysis result into compact S-expression notation.
+ */
+declare function formatImpactSExpr(res: ImpactAnalysisResult): string;
+/**
+ * Formats a Semantic Diff result into compact S-expression notation.
+ */
+declare function formatDiffSExpr(res: SemanticDiffResult): string;
+/**
+ * Formats a Pre-flight Check result into compact S-expression notation.
+ */
+declare function formatCheckSExpr(res: PreflightCheckResult): string;
+/**
+ * Formats a ProgramSliceResult into a compact S-expression.
+ */
+declare function formatSliceSExpr(res: ProgramSliceResult): string;
+/**
+ * Formats a SessionDeltaResult into compact S-expression notation.
+ */
+declare function formatDeltaSExpr(res: SessionDeltaResult): string;
+
+/**
+ * Formats a project TreeNode into a compact Prefix-Trie brace-expansion string.
+ */
+declare function formatTrie(rootOrProject: TreeNode | {
+    tree: TreeNode;
+}): string;
+
+declare function formatJSON(data: Glyphier | TreeNode | SearchResult[] | unknown, pretty?: boolean): string;
+
+interface LicenseSession {
+    valid: boolean;
+    plan: "dev" | "enterprise" | "unknown";
+    userId?: string;
+    expiresAt?: string;
+    source: "remote" | "lease" | "missing-key";
+}
+/**
+ * Derives a stable, anonymous hardware machine fingerprint.
+ */
+declare function getMachineFingerprint(): string;
+/**
+ * Retrieves the API key from the process environment only. Never persist a
+ * commercial credential in a workspace or a user-readable configuration file.
+ */
+declare function getApiKey(): string | null;
+/**
+ * Validates the Glyphier license.
+ * Online verification is normal. A device-bound, Ed25519-signed 72-hour lease
+ * is accepted only when the control plane is unreachable, preserving paid local
+ * work during a verified service outage without persisting an API credential.
+ */
+declare function verifyLicense(): Promise<LicenseSession>;
+declare function assertPaidLicense(): Promise<LicenseSession>;
+/**
+ * Asynchronously report token telemetry to Glyphier cloud in the background.
+ * Non-blocking, completely fire-and-forget. Never throws.
+ */
+declare function reportTokenTelemetry(stats: {
+    rawTokens: number;
+    irTokens: number;
+    source?: string;
+}): void;
+
+interface StoredFile {
+    path: string;
+    mtime: number;
+    hash: string;
+    language: string;
+    classification: string;
+    lineCount: number;
+    tokenCount: number;
+}
+interface StoredSymbol {
+    id: string;
+    filePath: string;
+    name: string;
+    qualifiedName: string;
+    kind: string;
+    startLine: number;
+    endLine: number;
+    signature: string;
+    isExported: boolean;
+    hash: string;
+    language: string;
+}
+interface StoredEdge {
+    sourceId: string;
+    targetId: string;
+    kind: string;
+    filePath: string;
+    line: number;
+    confidence: number;
+}
+interface StoredSession {
+    sessionId: string;
+    filePath: string;
+    fingerprint: string;
+    createdAt: number;
+    expiresAt: number;
+}
+interface StoredFact {
+    id: string;
+    statement: string;
+    provenance: Array<{
+        file: string;
+        startLine: number;
+        endLine: number;
+        symbolId?: string;
+    }>;
+    confidence: number;
+    category: string;
+    createdAt: number;
+    verifiedAt: number;
+    dependencies: string[];
+}
+declare class GlyphierStorage {
+    private db;
+    readonly dbPath: string;
+    constructor(dbPath?: string);
+    private initSchema;
+    upsertFile(file: StoredFile): void;
+    getFile(filePath: string): StoredFile | null;
+    getAllFiles(): StoredFile[];
+    deleteFile(filePath: string): void;
+    upsertSymbols(symbols: StoredSymbol[]): void;
+    getSymbolsByFile(filePath: string): StoredSymbol[];
+    getSymbol(id: string): StoredSymbol | null;
+    findSymbols(query: string, kind?: string): StoredSymbol[];
+    deleteSymbolsByFile(filePath: string): void;
+    private mapSymbolRow;
+    upsertEdges(edges: StoredEdge[]): void;
+    getOutgoingEdges(sourceId: string, kind?: string): StoredEdge[];
+    getIncomingEdges(targetId: string, kind?: string): StoredEdge[];
+    deleteEdgesByFile(filePath: string): void;
+    private mapEdgeRow;
+    getIR(filePath: string, level: number, contentHash?: string): string | null;
+    setIR(filePath: string, level: number, contentHash: string, irBlob: string): void;
+    invalidateIR(filePath: string): void;
+    getSession(sessionId: string, filePath: string): StoredSession | null;
+    setSession(sessionId: string, filePath: string, fingerprint: string, ttlHours?: number): void;
+    cleanExpiredSessions(): number;
+    clearSession(sessionId: string): void;
+    upsertFact(fact: StoredFact): void;
+    getFacts(category?: string): StoredFact[];
+    deleteFact(id: string): void;
+    close(): void;
+}
+/**
+ * Returns or initializes the Glyphier persistent storage for a repository root.
+ */
+declare function getStorage(repoRoot?: string): GlyphierStorage;
+
+type FileClassification = "SOURCE" | "GENERATED" | "VENDOR" | "DEPENDENCY" | "CONFIGURATION" | "TEST" | "DOCUMENTATION" | "MIGRATION" | "ASSET" | "BUILD_OUTPUT";
+/**
+ * Classifies a repository file path and optional content into semantic file categories.
+ */
+declare function classifyFile(filePath: string, content?: string): FileClassification;
+
+type SymbolKind = "fn" | "method" | "class" | "interface" | "type" | "enum" | "struct" | "const" | "var" | "mod" | "route" | "handler";
+interface SymbolEntry {
+    id: string;
+    name: string;
+    qualifiedName: string;
+    kind: SymbolKind;
+    filePath: string;
+    startLine: number;
+    endLine: number;
+    signature: string;
+    isExported: boolean;
+    hash: string;
+    language: string;
+}
+/**
+ * Computes a deterministic 16-character hexadecimal ID for a symbol.
+ */
+declare function computeSymbolId(filePath: string, qualifiedName: string, kind: string, startLine: number): string;
+/**
+ * Extracts normalized SymbolEntry records from a parsed Glyphier.
+ */
+declare function extractSymbolsFromIR(ir: Glyphier, filePath: string): SymbolEntry[];
+
+type EdgeKind = "calls" | "called_by" | "imports" | "imported_by" | "extends" | "implements" | "tests" | "tested_by" | "routes_to" | "validates" | "throws" | "references";
+interface SymbolEdge {
+    sourceId: string;
+    targetId: string;
+    kind: EdgeKind;
+    filePath: string;
+    line: number;
+    confidence: number;
+}
+declare function getInverseEdgeKind(kind: EdgeKind): EdgeKind | null;
+
+/**
+ * Resolves cross-file symbol references and extracts directed graph edges.
+ */
+declare function resolveModuleEdges(ir: Glyphier, filePath: string, localSymbols: SymbolEntry[], storage: GlyphierStorage): SymbolEdge[];
+
+interface IndexStats {
+    indexedFiles: number;
+    skippedFiles: number;
+    deletedFiles: number;
+    symbolCount: number;
+    edgeCount: number;
+    durationMs: number;
+}
+/**
+ * Incrementally indexes a repository, synchronizing the ASTs, symbol table,
+ * and dependency edges in SQLite.
+ */
+declare function indexProject(repoRoot: string, options?: {
+    extensions?: string[];
+    force?: boolean;
+    storage?: GlyphierStorage;
+}): Promise<IndexStats>;
+
+interface TraceOptions {
+    direction?: "callers" | "callees" | "both";
+    depth?: number;
+    storage: GlyphierStorage;
+}
+interface TraceNode {
+    symbol: StoredSymbol;
+    depth: number;
+}
+interface TraceResult {
+    rootSymbol: string;
+    direction: "callers" | "callees" | "both";
+    depth: number;
+    nodes: TraceNode[];
+    edges: StoredEdge[];
+}
+/**
+ * Traces the semantic neighborhood of a symbol through the symbol graph.
+ */
+declare function traceSymbol(symbolQuery: string, options: TraceOptions): TraceResult;
+/**
+ * Formats a TraceResult into dense S-expression notation.
+ */
+declare function formatTraceSExpr(result: TraceResult): string;
+
+interface SentSymbolRecord {
+    symbolId: string;
+    name: string;
+    level: number;
+    hash: string;
+    sentAt: number;
+}
+/**
+ * Tracks which symbols and definitions have already been delivered to an agent session.
+ * Replaces repetitive full declarations with dense `@Symbol` references.
+ */
+declare class ContextLedger {
+    readonly sessionId: string;
+    private storage;
+    private sentMap;
+    constructor(sessionId: string, storage: GlyphierStorage);
+    /**
+     * Records that a symbol was delivered to the agent at a given representation level.
+     */
+    recordSent(symbolId: string, name: string, level: number, hash: string): void;
+    /**
+     * Returns true if the symbol was already delivered to this session at the same
+     * or higher level, and its AST hash has not changed.
+     */
+    isAlreadyKnown(symbolId: string, level: number, currentHash: string): boolean;
+    /**
+     * Returns the count of unique symbols known in this session.
+     */
+    get knownCount(): number;
+    /**
+     * Formats a shorthand reference indicating a previously delivered symbol.
+     */
+    formatReference(name: string): string;
+}
+declare function getContextLedger(sessionId: string, storage: GlyphierStorage): ContextLedger;
+
+interface ContextOptimizeOptions {
+    task: string;
+    budget?: number;
+    rootPath?: string;
+    sessionId?: string;
+    storage?: GlyphierStorage;
+}
+interface OptimizedContextResult {
+    task: string;
+    budget: number;
+    usedTokens: number;
+    savedTokens: number;
+    files: string[];
+    symbols: Array<{
+        name: string;
+        isRef: boolean;
+    }>;
+    renderedContext: string;
+}
+/**
+ * Extracts key domain tokens from a natural language task prompt.
+ */
+declare function extractTaskKeywords(task: string): string[];
+/**
+ * Assembles a minimally sufficient, budget-optimized semantic context for an agent task.
+ */
+declare function optimizeContext(options: ContextOptimizeOptions): Promise<OptimizedContextResult>;
+
+interface FrameworkMetadata {
+    framework: string;
+    role: "route" | "page" | "layout" | "middleware" | "service" | "controller" | "queue" | "handler" | "model";
+    endpoint?: string;
+    method?: string;
+    description?: string;
+}
+interface FrameworkAdapter {
+    name: string;
+    detect(files: string[]): boolean;
+    classifyFileRole(filePath: string): string | null;
+    enrichSymbol(symbol: SymbolEntry): FrameworkMetadata | null;
+}
+
+declare class FrameworkRegistry {
+    private adapters;
+    constructor();
+    register(adapter: FrameworkAdapter): void;
+    detectFrameworks(files: string[]): FrameworkAdapter[];
+    getAdapter(name: string): FrameworkAdapter | undefined;
+    getAll(): FrameworkAdapter[];
+}
+declare const globalFrameworkRegistry: FrameworkRegistry;
+
+declare class NextJsAdapter implements FrameworkAdapter {
+    readonly name = "nextjs";
+    detect(files: string[]): boolean;
+    classifyFileRole(filePath: string): string | null;
+    enrichSymbol(symbol: SymbolEntry): FrameworkMetadata | null;
+}
+
+interface KnowledgeEntity {
+    id: string;
+    kind: "capability" | "domain" | "service" | "api" | "queue" | "database";
+    name: string;
+    description?: string;
+    symbols: string[];
+    routes?: string[];
+    dependencies?: string[];
+    tests?: string[];
+}
+interface KnowledgeGraph {
+    entities: KnowledgeEntity[];
+}
+/**
+ * Constructs a domain-aware knowledge graph from indexed repository symbols and files.
+ */
+declare function buildKnowledgeGraph(storage: GlyphierStorage): KnowledgeGraph;
+
+/**
+ * Single source of truth for the public Glyphier release and artifact ABI.
+ *
+ * PRODUCT_VERSION follows the pre-1.0 SemVer policy in VERSIONING.md.
+ * ARTIFACT_SCHEMA_VERSION changes only when durable artifacts cease to
+ * round-trip with the prior release.
+ */
+declare const PRODUCT_VERSION: "0.1.0";
+declare const ARTIFACT_SCHEMA_VERSION: "0.1";
+
+declare const SourceAuthoritySchema: z.ZodEnum<{
+    worktree: "worktree";
+    committed: "committed";
+    generated: "generated";
+}>;
+declare const SnapshotFreshnessSchema: z.ZodEnum<{
+    unknown: "unknown";
+    fresh: "fresh";
+    stale_source: "stale_source";
+    stale_compiler: "stale_compiler";
+    partially_fresh: "partially_fresh";
+}>;
+declare const AnalysisSnapshotSchema: z.ZodObject<{
+    snapshotId: z.ZodString;
+    repositoryId: z.ZodString;
+    headRef: z.ZodNullable<z.ZodString>;
+    worktreeDigest: z.ZodString;
+    sourceAuthority: z.ZodEnum<{
+        worktree: "worktree";
+        committed: "committed";
+        generated: "generated";
+    }>;
+    dirtyPathsDigest: z.ZodNullable<z.ZodString>;
+    generatedPathsDigest: z.ZodNullable<z.ZodString>;
+    compilerFingerprint: z.ZodString;
+    coverageDigest: z.ZodString;
+    freshness: z.ZodEnum<{
+        unknown: "unknown";
+        fresh: "fresh";
+        stale_source: "stale_source";
+        stale_compiler: "stale_compiler";
+        partially_fresh: "partially_fresh";
+    }>;
+    capturedAt: z.ZodString;
+    schemaVersion: z.ZodLiteral<"0.1">;
+}, z.core.$strip>;
+declare const EvidenceAnchorSchema: z.ZodObject<{
+    path: z.ZodString;
+    startLine: z.ZodOptional<z.ZodNumber>;
+    endLine: z.ZodOptional<z.ZodNumber>;
+    symbol: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const EvidenceRefSchema: z.ZodObject<{
+    evidenceId: z.ZodString;
+    snapshotId: z.ZodString;
+    sourceKind: z.ZodEnum<{
+        symbol: "symbol";
+        source: "source";
+        test: "test";
+        edge: "edge";
+        document: "document";
+        configuration: "configuration";
+        inference: "inference";
+    }>;
+    anchor: z.ZodObject<{
+        path: z.ZodString;
+        startLine: z.ZodOptional<z.ZodNumber>;
+        endLine: z.ZodOptional<z.ZodNumber>;
+        symbol: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    excerptDigest: z.ZodString;
+    freshness: z.ZodEnum<{
+        unknown: "unknown";
+        fresh: "fresh";
+        stale_source: "stale_source";
+        stale_compiler: "stale_compiler";
+        partially_fresh: "partially_fresh";
+    }>;
+    authority: z.ZodNumber;
+    schemaVersion: z.ZodLiteral<"0.1">;
+}, z.core.$strip>;
+declare const ContextArtifactSchema: z.ZodObject<{
+    artifactId: z.ZodString;
+    snapshot: z.ZodObject<{
+        snapshotId: z.ZodString;
+        repositoryId: z.ZodString;
+        headRef: z.ZodNullable<z.ZodString>;
+        worktreeDigest: z.ZodString;
+        sourceAuthority: z.ZodEnum<{
+            worktree: "worktree";
+            committed: "committed";
+            generated: "generated";
+        }>;
+        dirtyPathsDigest: z.ZodNullable<z.ZodString>;
+        generatedPathsDigest: z.ZodNullable<z.ZodString>;
+        compilerFingerprint: z.ZodString;
+        coverageDigest: z.ZodString;
+        freshness: z.ZodEnum<{
+            unknown: "unknown";
+            fresh: "fresh";
+            stale_source: "stale_source";
+            stale_compiler: "stale_compiler";
+            partially_fresh: "partially_fresh";
+        }>;
+        capturedAt: z.ZodString;
+        schemaVersion: z.ZodLiteral<"0.1">;
+    }, z.core.$strip>;
+    taskDigest: z.ZodString;
+    riskTier: z.ZodEnum<{
+        low: "low";
+        high: "high";
+        critical: "critical";
+        medium: "medium";
+    }>;
+    evidence: z.ZodArray<z.ZodObject<{
+        evidenceId: z.ZodString;
+        snapshotId: z.ZodString;
+        sourceKind: z.ZodEnum<{
+            symbol: "symbol";
+            source: "source";
+            test: "test";
+            edge: "edge";
+            document: "document";
+            configuration: "configuration";
+            inference: "inference";
+        }>;
+        anchor: z.ZodObject<{
+            path: z.ZodString;
+            startLine: z.ZodOptional<z.ZodNumber>;
+            endLine: z.ZodOptional<z.ZodNumber>;
+            symbol: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        excerptDigest: z.ZodString;
+        freshness: z.ZodEnum<{
+            unknown: "unknown";
+            fresh: "fresh";
+            stale_source: "stale_source";
+            stale_compiler: "stale_compiler";
+            partially_fresh: "partially_fresh";
+        }>;
+        authority: z.ZodNumber;
+        schemaVersion: z.ZodLiteral<"0.1">;
+    }, z.core.$strip>>;
+    selectedEvidenceIds: z.ZodArray<z.ZodString>;
+    excludedEvidence: z.ZodArray<z.ZodObject<{
+        evidenceId: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strip>>;
+    tokenBudget: z.ZodNumber;
+    tokensUsed: z.ZodNumber;
+    claimLedger: z.ZodArray<z.ZodObject<{
+        claimId: z.ZodString;
+        kind: z.ZodEnum<{
+            unknown: "unknown";
+            inference: "inference";
+            fact: "fact";
+        }>;
+        evidenceIds: z.ZodArray<z.ZodString>;
+        supported: z.ZodBoolean;
+    }, z.core.$strip>>;
+    schemaVersion: z.ZodLiteral<"0.1">;
+}, z.core.$strip>;
+declare const ReceiptKindSchema: z.ZodEnum<{
+    verification: "verification";
+    review: "review";
+    knowledge_promotion: "knowledge_promotion";
+    invalidation: "invalidation";
+    provider_decision: "provider_decision";
+    sync_delivery: "sync_delivery";
+}>;
+declare const ReceiptSchema: z.ZodObject<{
+    receiptId: z.ZodString;
+    kind: z.ZodEnum<{
+        verification: "verification";
+        review: "review";
+        knowledge_promotion: "knowledge_promotion";
+        invalidation: "invalidation";
+        provider_decision: "provider_decision";
+        sync_delivery: "sync_delivery";
+    }>;
+    repositoryId: z.ZodString;
+    snapshotId: z.ZodString;
+    principalId: z.ZodString;
+    policyRevision: z.ZodString;
+    subjectDigest: z.ZodString;
+    evidenceDigests: z.ZodArray<z.ZodString>;
+    issuedAt: z.ZodString;
+    schemaVersion: z.ZodLiteral<"0.1">;
+}, z.core.$strip>;
+declare const DecisionClassSchema: z.ZodEnum<{
+    evidence_disposition: "evidence_disposition";
+    sufficiency_routing: "sufficiency_routing";
+    documentation_assertion_support: "documentation_assertion_support";
+    prompt_injection_signal: "prompt_injection_signal";
+}>;
+declare const DecisionPacketSchema: z.ZodObject<{
+    packetId: z.ZodString;
+    repositoryId: z.ZodString;
+    snapshotId: z.ZodString;
+    principalId: z.ZodString;
+    policyRevision: z.ZodString;
+    decisionClass: z.ZodEnum<{
+        evidence_disposition: "evidence_disposition";
+        sufficiency_routing: "sufficiency_routing";
+        documentation_assertion_support: "documentation_assertion_support";
+        prompt_injection_signal: "prompt_injection_signal";
+    }>;
+    riskTier: z.ZodEnum<{
+        low: "low";
+        high: "high";
+        critical: "critical";
+        medium: "medium";
+    }>;
+    contextDigest: z.ZodString;
+    evidenceDigests: z.ZodArray<z.ZodString>;
+    inputBytes: z.ZodNumber;
+    model: z.ZodString;
+    schemaVersion: z.ZodLiteral<"0.1">;
+}, z.core.$strip>;
+type AnalysisSnapshot = z.infer<typeof AnalysisSnapshotSchema>;
+type EvidenceRef = z.infer<typeof EvidenceRefSchema>;
+type ContextArtifact = z.infer<typeof ContextArtifactSchema>;
+type Receipt = z.infer<typeof ReceiptSchema>;
+type DecisionPacket = z.infer<typeof DecisionPacketSchema>;
+type DecisionClass = z.infer<typeof DecisionClassSchema>;
+/** Produce a stable SHA-256 over an object without relying on insertion order. */
+declare function digestCanonical(value: unknown): string;
+/** Only low-risk, explicitly approved judgment classes may leave the device. */
+declare function assertJevEligible(packet: DecisionPacket): void;
+
+declare const SnapshotSymbolIdSchema: z.ZodString;
+declare const LogicalEntityIdSchema: z.ZodString;
+declare const IdentityMappingClaimSchema: z.ZodObject<{
+    claimId: z.ZodString;
+    fromSnapshotId: z.ZodString;
+    toSnapshotId: z.ZodString;
+    fromSymbolId: z.ZodString;
+    toSymbolId: z.ZodString;
+    logicalEntityId: z.ZodString;
+    evidenceDigests: z.ZodArray<z.ZodString>;
+    replayAlgorithm: z.ZodString;
+    replayInputDigest: z.ZodString;
+    confidence: z.ZodNumber;
+    issuedAt: z.ZodString;
+    schemaVersion: z.ZodLiteral<"0.1">;
+}, z.core.$strip>;
+type IdentityMappingClaim = z.infer<typeof IdentityMappingClaimSchema>;
+type IdentityCandidate = {
+    snapshotSymbolId: string;
+    evidenceDigests: string[];
+    score: number;
+};
+type IdentityResolution = {
+    outcome: "mapped";
+    winner: IdentityCandidate;
+} | {
+    outcome: "abstained";
+    reason: "no_candidate" | "ambiguous" | "insufficient_proof";
+};
+/**
+ * Automatic preservation is intentionally conservative.  A mapping needs one
+ * qualifying candidate and a material separation from every alternative.
+ */
+declare function resolveIdentity(candidates: IdentityCandidate[], minimumScore?: number, minimumMargin?: number): IdentityResolution;
+declare function createSnapshotSymbolId(snapshotId: string, qualifiedName: string, kind: string): string;
+declare function createLogicalEntityId(repositoryId: string, seed: string): string;
+
+declare const GlyphierLanguageSchema: z.ZodEnum<{
+    typescript: "typescript";
+    tsx: "tsx";
+    javascript: "javascript";
+    python: "python";
+    rust: "rust";
+    go: "go";
+    java: "java";
+    c: "c";
+    cpp: "cpp";
+    c_sharp: "c_sharp";
+    ruby: "ruby";
+    php: "php";
+    swift: "swift";
+    kotlin: "kotlin";
+    lua: "lua";
+    zig: "zig";
+    elm: "elm";
+    elixir: "elixir";
+    bash: "bash";
+}>;
+declare const CapabilitySchema: z.ZodEnum<{
+    slice: "slice";
+    symbols: "symbols";
+    diff: "diff";
+    freshness: "freshness";
+    snapshot: "snapshot";
+    evidence: "evidence";
+    parse: "parse";
+    imports_exports: "imports_exports";
+    call_edges: "call_edges";
+    semantic_search: "semantic_search";
+    impact: "impact";
+    identity: "identity";
+}>;
+declare const CalibrationStateSchema: z.ZodEnum<{
+    unqualified: "unqualified";
+    provisional: "provisional";
+    calibrated: "calibrated";
+    high_risk_qualified: "high_risk_qualified";
+}>;
+declare const LanguageCapabilityProfileSchema: z.ZodObject<{
+    language: z.ZodEnum<{
+        typescript: "typescript";
+        tsx: "tsx";
+        javascript: "javascript";
+        python: "python";
+        rust: "rust";
+        go: "go";
+        java: "java";
+        c: "c";
+        cpp: "cpp";
+        c_sharp: "c_sharp";
+        ruby: "ruby";
+        php: "php";
+        swift: "swift";
+        kotlin: "kotlin";
+        lua: "lua";
+        zig: "zig";
+        elm: "elm";
+        elixir: "elixir";
+        bash: "bash";
+    }>;
+    framework: z.ZodDefault<z.ZodString>;
+    taskClass: z.ZodEnum<{
+        review: "review";
+        bug_fix: "bug_fix";
+        refactor: "refactor";
+        feature: "feature";
+        investigation: "investigation";
+    }>;
+    riskTier: z.ZodEnum<{
+        low: "low";
+        high: "high";
+        critical: "critical";
+        medium: "medium";
+    }>;
+    compilerFingerprint: z.ZodString;
+    supportedCapabilities: z.ZodArray<z.ZodEnum<{
+        slice: "slice";
+        symbols: "symbols";
+        diff: "diff";
+        freshness: "freshness";
+        snapshot: "snapshot";
+        evidence: "evidence";
+        parse: "parse";
+        imports_exports: "imports_exports";
+        call_edges: "call_edges";
+        semantic_search: "semantic_search";
+        impact: "impact";
+        identity: "identity";
+    }>>;
+    fixtures: z.ZodNumber;
+    falseSufficiencyEvents: z.ZodNumber;
+    calibration: z.ZodEnum<{
+        unqualified: "unqualified";
+        provisional: "provisional";
+        calibrated: "calibrated";
+        high_risk_qualified: "high_risk_qualified";
+    }>;
+}, z.core.$strip>;
+type GlyphierLanguage = z.infer<typeof GlyphierLanguageSchema>;
+type LanguageCapabilityProfile = z.infer<typeof LanguageCapabilityProfileSchema>;
+declare const REGISTERED_LANGUAGE_CATALOG: ("typescript" | "tsx" | "javascript" | "python" | "rust" | "go" | "java" | "c" | "cpp" | "c_sharp" | "ruby" | "php" | "swift" | "kotlin" | "lua" | "zig" | "elm" | "elixir" | "bash")[];
+declare const REQUIRED_CAPABILITIES: ("slice" | "symbols" | "diff" | "freshness" | "snapshot" | "evidence" | "parse" | "imports_exports" | "call_edges" | "semantic_search" | "impact" | "identity")[];
+/** The conservative zero-event upper bound used by the architecture gate. */
+declare function upperFalseSufficiencyBound(fixtures: number, falseSufficiencyEvents: number): number;
+declare function canPromoteCalibration(profile: LanguageCapabilityProfile): boolean;
+
+declare const SyncScopeSchema: z.ZodEnum<{
+    local: "local";
+    enterprise: "enterprise";
+    team: "team";
+}>;
+declare const SyncEnvelopeSchema: z.ZodObject<{
+    eventId: z.ZodString;
+    tenantId: z.ZodString;
+    repositoryId: z.ZodString;
+    principalId: z.ZodString;
+    scope: z.ZodEnum<{
+        local: "local";
+        enterprise: "enterprise";
+        team: "team";
+    }>;
+    sensitivity: z.ZodEnum<{
+        public: "public";
+        internal: "internal";
+        restricted: "restricted";
+    }>;
+    receipt: z.ZodObject<{
+        receiptId: z.ZodString;
+        kind: z.ZodEnum<{
+            verification: "verification";
+            review: "review";
+            knowledge_promotion: "knowledge_promotion";
+            invalidation: "invalidation";
+            provider_decision: "provider_decision";
+            sync_delivery: "sync_delivery";
+        }>;
+        repositoryId: z.ZodString;
+        snapshotId: z.ZodString;
+        principalId: z.ZodString;
+        policyRevision: z.ZodString;
+        subjectDigest: z.ZodString;
+        evidenceDigests: z.ZodArray<z.ZodString>;
+        issuedAt: z.ZodString;
+        schemaVersion: z.ZodLiteral<"0.1">;
+    }, z.core.$strip>;
+    invalidatesReceiptIds: z.ZodArray<z.ZodString>;
+    expiresAt: z.ZodNullable<z.ZodString>;
+    signature: z.ZodString;
+    schemaVersion: z.ZodLiteral<"0.1">;
+}, z.core.$strip>;
+type SyncEnvelope = z.infer<typeof SyncEnvelopeSchema>;
+declare function signSyncEnvelope(envelope: Omit<SyncEnvelope, "signature">, signingSecret: string): SyncEnvelope;
+declare function verifySyncEnvelope(envelope: SyncEnvelope, signingSecret: string, expectedTenantId: string): boolean;
+
+type BuildSnapshotOptions = {
+    rootPath: string;
+    now?: Date;
+};
+/**
+ * Filesystem/Git adapter for snapshot capture. Source bytes are used only to
+ * derive digests and never appear in the returned AnalysisSnapshot.
+ */
+declare function buildAnalysisSnapshot(options: BuildSnapshotOptions): AnalysisSnapshot;
+
+export { ARTIFACT_SCHEMA_VERSION, type AnalysisSnapshot, AnalysisSnapshotSchema, type BudgetPlan, type BudgetProjectionOptions, type BudgetProjectionResult, type BuildSnapshotOptions, type BuildTreeOptions, CalibrationStateSchema, type CallerReference, CapabilitySchema, type ClassNode, type ContextArtifact, ContextArtifactSchema, ContextLedger, type ContextOptimizeOptions, DEFAULT_CONFIG, type DecisionClass, DecisionClassSchema, type DecisionPacket, DecisionPacketSchema, type DeclarationDelta, EXTENSION_TO_LANGUAGE, type EdgeKind, type ErrorNode, EvidenceAnchorSchema, type EvidenceRef, EvidenceRefSchema, type ExternalDependency, type FileClassification, type FileMetadata, type FileStat, type FormatSExprOptions, type FrameworkAdapter, type FrameworkMetadata, FrameworkRegistry, type FunctionNode, type GenerateIROptions, type Glyphier, type GlyphierConfig, type GlyphierLanguage, GlyphierLanguageSchema, GlyphierStorage, type GraphOptions, type IdentityCandidate, type IdentityMappingClaim, IdentityMappingClaimSchema, type IdentityResolution, type ImpactAnalysisResult, type ImpactOptions, type ImportNode, type IndexStats, type KnowledgeEntity, type KnowledgeGraph, type LanguageCapabilityProfile, LanguageCapabilityProfileSchema, type LicenseSession, type LineRange, LogicalEntityIdSchema, type ModuleNode, MtimeCache, NextJsAdapter, type OptimizedContextResult, PRODUCT_VERSION, type ParseFileOptions, type ParseProjectOptions, type ParseResult, type PatchAction, type PatchOperation, type PatchResult, type PreflightCheckOptions, type PreflightCheckResult, type ProgramSliceResult, type ProjectParseResult, type ProjectStats, type QueueInfo, REGISTERED_LANGUAGE_CATALOG, REQUIRED_CAPABILITIES, type ReadRawOptions, type Receipt, ReceiptKindSchema, ReceiptSchema, type ScopedCall, type SearchOptions, type SearchResult, type SearchTarget, type SemanticDiffOptions, type SemanticDiffResult, type SentSymbolRecord, type SessionDeltaResult, type SliceNode, type SliceOptions, SnapshotFreshnessSchema, SnapshotSymbolIdSchema, SourceAuthoritySchema, type StatsOptions, type StoredEdge, type StoredFact, type StoredFile, type StoredSession, type StoredSymbol, type SubsystemGraph, type SymbolEdge, type SymbolEntry, type SymbolKind, type SyncEnvelope, SyncEnvelopeSchema, SyncScopeSchema, type TraceNode, type TraceOptions, type TraceResult, type TreeNode, type TypeNode, abbreviateType, analyzeImpact, analyzeModuleGraph, applyAstPatch, assertJevEligible, assertPaidLicense, buildAnalysisSnapshot, buildKnowledgeGraph, buildTree, canPromoteCalibration, classifyFile, clearSession, computeProgramSlice, computeSessionDelta, computeStats, computeSymbolId, createLogicalEntityId, createSnapshotSymbolId, detectLanguage, digestCanonical, extractSymbolsFromIR, extractTaskKeywords, findProjectRoot, formatCheckSExpr, formatDeltaSExpr, formatDiffSExpr, formatGraphSExpr, formatImpactSExpr, formatJSON, formatSExpr, formatSearchResults, formatSliceSExpr, formatStatsSExpr, formatTraceSExpr, formatTrie, generateIR, getApiKey, getContextLedger, getInverseEdgeKind, getMachineFingerprint, getStorage, getSupportedLanguages, globalCache, globalFrameworkRegistry, indexProject, initTreeSitter, loadConfig, loadLanguage, optimizeContext, parseFile, parseFileTree, parseProject, parseSource, preflightCheck, projectBudget, readRaw, reportTokenTelemetry, resolveIdentity, resolveModuleEdges, searchIR, semanticDiff, signSyncEnvelope, traceSymbol, upperFalseSufficiencyBound, verifyLicense, verifySyncEnvelope };