@fenixforce/kernel 0.1.0

package/dist/loop/backpressure.d.ts

@@ -0,0 +1,64 @@
+import type { AutonomousLoopController } from "./autonomous-controller.js";
+import type { EventBus } from "../events/bus.js";
+export interface BackpressureConfig {
+    /** Ordered list of quality gate commands */
+    commands: BackpressureCommand[];
+    /** Stop on first failure (default: false — run all, collect results) */
+    failFast: boolean;
+    /** Per-command timeout in ms (default: 60000) */
+    timeout: number;
+}
+export interface BackpressureCommand {
+    /** Human-readable name (e.g. "TypeScript type check") */
+    name: string;
+    /** Shell command to execute (e.g. "bun test", "tsc --noEmit") */
+    command: string;
+    /** Blocking failures prevent loop exit; warnings are logged only */
+    weight: "blocking" | "warning";
+    /** Optional regex to extract failure summary from stdout/stderr */
+    parseFailures?: RegExp;
+}
+export interface BackpressureResult {
+    passed: boolean;
+    commandResults: CommandResult[];
+    failurePrefix: string | null;
+}
+export interface CommandResult {
+    name: string;
+    command: string;
+    weight: "blocking" | "warning";
+    exitCode: number;
+    passed: boolean;
+    stdout: string;
+    stderr: string;
+    failureSummary: string | null;
+    durationMs: number;
+}
+export type ShellExecutor = (command: string, opts: {
+    timeout: number;
+    cwd?: string;
+}) => Promise<{
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}>;
+export declare class BackpressureValidator {
+    private config;
+    private execute;
+    private controller;
+    private eventBus;
+    private lastPassed;
+    constructor(config: BackpressureConfig, execute: ShellExecutor, opts?: {
+        controller?: AutonomousLoopController;
+        eventBus?: EventBus;
+    });
+    /**
+     * Run all backpressure commands after a loop iteration.
+     * Returns a result with pass/fail and an optional failure prefix
+     * to inject into the next iteration's context.
+     */
+    validate(cwd?: string): Promise<BackpressureResult>;
+    private extractFailures;
+    private buildFailurePrefix;
+    private emit;
+}

package/dist/loop/fresh-context.d.ts

@@ -0,0 +1,48 @@
+import type { IterationContext, IterationResult } from "./autonomous-controller.js";
+export interface FreshContextConfig {
+    /** fresh = new context each iteration; persistent = keep conversation */
+    mode: "fresh" | "persistent";
+    /** Files injected into fresh context each iteration (e.g. AGENTS.md, spec) */
+    contextFiles: string[];
+    /** Workspace state file read/written each iteration */
+    stateFile: string;
+    /** System prompt template for fresh iterations */
+    systemPrompt?: string;
+}
+export type FileReader = (path: string) => Promise<string>;
+export type FileWriter = (path: string, content: string) => Promise<void>;
+export type GitCommitter = (message: string) => Promise<string | null>;
+export type AgentRunner = (prompt: string, opts: {
+    sessionId: string | null;
+    systemPrompt: string;
+}) => Promise<AgentIterationOutput>;
+export interface AgentIterationOutput {
+    output: string;
+    sessionId: string;
+    filesChanged: string[];
+    newCommits: number;
+    testResultsChanged: boolean;
+    completionIndicators: string[];
+    stateUpdate?: string;
+}
+export declare class FreshContextManager {
+    private config;
+    private readFile;
+    private writeFile;
+    private commitChanges;
+    private runAgent;
+    constructor(config: FreshContextConfig, deps: {
+        readFile: FileReader;
+        writeFile: FileWriter;
+        commitChanges: GitCommitter;
+        runAgent: AgentRunner;
+    });
+    /**
+     * Build a runIteration callback for the AutonomousLoopController.
+     * In fresh mode, each iteration gets a new context built from files.
+     * In persistent mode, session ID is carried forward.
+     */
+    createIterationRunner(): (ctx: IterationContext) => Promise<IterationResult>;
+    private buildIterationPrompt;
+    private safeRead;
+}

package/dist/loop/prd-importer.d.ts

@@ -0,0 +1,134 @@
+import type { LLMProvider } from "../providers/interface.js";
+export type ImportSource = {
+    type: "markdown";
+    content: string;
+    title?: string;
+} | {
+    type: "url";
+    url: string;
+    title?: string;
+} | {
+    type: "github-issue";
+    owner: string;
+    repo: string;
+    issue: number;
+} | {
+    type: "json-prd";
+    data: StructuredPRD;
+};
+export interface StructuredPRD {
+    title?: string;
+    user_stories?: UserStory[];
+    requirements?: Requirement[];
+}
+export interface UserStory {
+    id?: string;
+    title: string;
+    description: string;
+    acceptance_criteria?: string[];
+    priority?: TaskPriority;
+}
+export interface Requirement {
+    id?: string;
+    title: string;
+    description: string;
+    priority?: TaskPriority;
+}
+export type TaskPriority = "critical" | "high" | "medium" | "low";
+export interface ImportedTask {
+    id: string;
+    title: string;
+    description: string;
+    acceptanceCriteria: AcceptanceCriterion[];
+    priority: TaskPriority;
+    dependencies: string[];
+}
+export interface AcceptanceCriterion {
+    given: string;
+    when: string;
+    then: string;
+}
+export interface ImportResult {
+    sourceTitle: string;
+    tasks: ImportedTask[];
+    generatedAt: string;
+    appended: boolean;
+}
+export type FileReader = (path: string) => Promise<string>;
+export type FileWriter = (path: string, content: string) => Promise<void>;
+export type UrlFetcher = (url: string) => Promise<string>;
+export declare const TASK_LIST_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly tasks: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly id: {
+                        readonly type: "string";
+                        readonly description: "Unique task ID (TASK-001 format)";
+                    };
+                    readonly title: {
+                        readonly type: "string";
+                        readonly description: "Short task title";
+                    };
+                    readonly description: {
+                        readonly type: "string";
+                        readonly description: "Detailed description";
+                    };
+                    readonly acceptanceCriteria: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly given: {
+                                    readonly type: "string";
+                                };
+                                readonly when: {
+                                    readonly type: "string";
+                                };
+                                readonly then: {
+                                    readonly type: "string";
+                                };
+                            };
+                            readonly required: readonly ["given", "when", "then"];
+                        };
+                    };
+                    readonly priority: {
+                        readonly type: "string";
+                        readonly enum: readonly ["critical", "high", "medium", "low"];
+                    };
+                    readonly dependencies: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                    };
+                };
+                readonly required: readonly ["id", "title", "description", "acceptanceCriteria", "priority", "dependencies"];
+            };
+        };
+    };
+    readonly required: readonly ["tasks"];
+};
+export declare class PRDImporter {
+    private provider;
+    private readFile;
+    private writeFile;
+    private fetchUrl;
+    constructor(provider: LLMProvider, deps: {
+        readFile: FileReader;
+        writeFile: FileWriter;
+        fetchUrl: UrlFetcher;
+    });
+    /**
+     * Import a source document and generate/append tasks to IMPLEMENTATION_PLAN.md.
+     */
+    import(source: ImportSource, planPath: string): Promise<ImportResult>;
+    private resolveSource;
+    private extractTasks;
+    private parseStructuredPRD;
+    private parseExistingTaskIds;
+    private safeRead;
+}

package/dist/loop/stop-controller.d.ts

@@ -0,0 +1,31 @@
+export declare class StopController {
+    private controller;
+    private reason;
+    private cleanupHandlers;
+    constructor();
+    /** Signal stop from any context. */
+    stop(reason?: string): void;
+    /** Check before starting a new iteration. */
+    get stopRequested(): boolean;
+    /** The reason passed to stop(), if any. */
+    get stopReason(): string | undefined;
+    /** Pass to fetch/async operations for automatic cancellation. */
+    get abortSignal(): AbortSignal;
+    /** Register a cleanup handler that runs when stop is signaled. */
+    onStop(handler: () => void): () => void;
+    /** Reset for a new run (creates fresh AbortController). */
+    reset(): void;
+    /**
+     * Create a child StopController that stops when the parent stops.
+     * Useful for per-worker controllers in FleetCoordinator.
+     */
+    child(): StopController;
+}
+/**
+ * Create a fleet-wide stop controller that propagates to all workers.
+ * Returns the parent controller and a factory for worker controllers.
+ */
+export declare function createFleetStopController(): {
+    controller: StopController;
+    createWorkerController: () => StopController;
+};

package/dist/loop-guard.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Loop guard — SHA256-based tool call tracking that detects stuck patterns.
+ */
+import type { ToolCall } from "./events/types.js";
+export interface LoopGuardResult {
+    blocked: boolean;
+    warning: boolean;
+    reason?: string;
+}
+export declare class LoopGuard {
+    private maxTotal;
+    private history;
+    private callCounts;
+    private pairCounts;
+    constructor(maxTotal?: number);
+    /**
+     * Check a batch of tool calls. Call this before executing each tool batch.
+     * Optionally provide the result content for outcome-aware detection
+     * via recordResult() after the tool executes.
+     */
+    check(toolCalls: ToolCall[]): LoopGuardResult;
+    /**
+     * Record the result of a tool call for outcome-aware detection.
+     * Call after the tool executes with the same ToolCall and the result string.
+     */
+    recordResult(call: ToolCall, resultContent: string): LoopGuardResult;
+    /** Reset all state (e.g. between conversations). */
+    reset(): void;
+    /** Current total call count. */
+    totalCalls(): number;
+    private detectPingPong;
+}

package/dist/mcp/tool-executor.d.ts

@@ -0,0 +1,57 @@
+export interface HeartbeatConfig {
+    enabled: boolean;
+    /** Heartbeat interval in ms. Default: 15000. */
+    intervalMs: number;
+    /** Execution timeout in ms. Default: 1800000 (30 min). */
+    timeoutMs: number;
+}
+export declare const DEFAULT_HEARTBEAT_CONFIG: HeartbeatConfig;
+export interface MCPProgressNotification {
+    method: "notifications/progress";
+    params: {
+        progressToken: string;
+        progress: number;
+        total: number;
+        message: string;
+    };
+}
+export type ProgressCallback = (elapsed: number, count: number) => void;
+/**
+ * Wrap a long-running async function with periodic heartbeat signals.
+ * The heartbeat fires every `intervalMs` until the function completes,
+ * errors, or times out.
+ */
+export declare function withHeartbeat<T>(fn: () => Promise<T>, config: HeartbeatConfig, progressCallback: ProgressCallback): Promise<T>;
+export interface MCPToolCall {
+    name: string;
+    arguments: Record<string, unknown>;
+    progressToken?: string;
+}
+export interface MCPToolResult {
+    content: unknown;
+    isError?: boolean;
+}
+export type MCPToolHandler = (args: Record<string, unknown>) => Promise<unknown>;
+export type MCPNotificationSender = (notification: MCPProgressNotification) => void;
+export interface MCPToolExecutorConfig {
+    heartbeat?: Partial<HeartbeatConfig>;
+    notificationSender?: MCPNotificationSender;
+}
+export declare class MCPToolExecutor {
+    private handlers;
+    private heartbeatConfig;
+    private notificationSender?;
+    constructor(config?: MCPToolExecutorConfig);
+    /** Register a tool handler. */
+    register(name: string, handler: MCPToolHandler): void;
+    /** Unregister a tool handler. */
+    unregister(name: string): void;
+    /** Execute a tool call with heartbeat. */
+    execute(call: MCPToolCall): Promise<MCPToolResult>;
+    /** List registered tool names. */
+    listTools(): string[];
+}
+export declare class MCPTimeoutError extends Error {
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number);
+}

package/dist/memory/brain-artifacts.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Brain artifacts — persistent work-state files loaded during session orient.
+ *
+ * Wraps StorageAdapter's low-level brain-artifact methods with a
+ * filename-oriented API and upsert semantics.
+ */
+import type { StorageAdapter, BrainArtifact } from "../storage/interface.js";
+export declare const STANDARD_ARTIFACTS: Record<string, {
+    filename: string;
+    template: string;
+}>;
+export declare class BrainArtifactManager {
+    private storage;
+    constructor(storage: StorageAdapter);
+    /** Upsert: update existing artifact by filename or insert a new one. */
+    save(conversationId: string, userId: string, filename: string, content: string): Promise<BrainArtifact>;
+    /** Load all artifacts for a conversation. */
+    load(conversationId: string): Promise<BrainArtifact[]>;
+    /** Load a single artifact by filename within a conversation. */
+    loadByFilename(conversationId: string, filename: string): Promise<BrainArtifact | null>;
+    /** Delete an artifact by filename within a conversation. */
+    delete(conversationId: string, filename: string): Promise<void>;
+    /** List all artifacts belonging to a user across conversations. */
+    listForUser(userId: string): Promise<BrainArtifact[]>;
+}

package/dist/memory/dual-search.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Dual Search Fusion — combines BM25 lexical search with pgvector
+ * semantic search via Promise.allSettled, then merges results using
+ * Reciprocal Rank Fusion (RRF).
+ *
+ * Configurable text vs semantic weights. Gracefully degrades if
+ * either backend fails (returns results from whichever succeeded).
+ */
+export interface DualSearchResult {
+    /** Document identifier. */
+    id: string;
+    /** Document content/text. */
+    content: string;
+    /** Fused RRF score. */
+    score: number;
+    /** Source(s) that contributed this result. */
+    sources: Array<"bm25" | "semantic">;
+    /** Raw rank from BM25 (undefined if not in BM25 results). */
+    bm25Rank?: number;
+    /** Raw rank from semantic search (undefined if not in semantic results). */
+    semanticRank?: number;
+    /** Optional metadata. */
+    metadata?: Record<string, unknown>;
+}
+export interface SearchBackendResult {
+    id: string;
+    content: string;
+    score: number;
+    metadata?: Record<string, unknown>;
+}
+/** BM25/lexical search function. */
+export type BM25SearchFn = (query: string, limit: number) => Promise<SearchBackendResult[]>;
+/** Semantic/vector search function. */
+export type SemanticSearchFn = (query: string, limit: number) => Promise<SearchBackendResult[]>;
+export interface DualSearchConfig {
+    /** BM25 / full-text search backend. */
+    bm25: BM25SearchFn;
+    /** Semantic / vector search backend. */
+    semantic: SemanticSearchFn;
+    /** Weight for BM25 results in RRF. Default 1.0. */
+    bm25Weight?: number;
+    /** Weight for semantic results in RRF. Default 1.0. */
+    semanticWeight?: number;
+    /** RRF constant k. Default 60. */
+    rrfK?: number;
+    /** Maximum results to return. Default 10. */
+    maxResults?: number;
+    /** Maximum results to fetch from each backend. Default 20. */
+    fetchLimit?: number;
+}
+export type DualSearchEventType = "search_start" | "bm25_done" | "bm25_error" | "semantic_done" | "semantic_error" | "fusion_done";
+export interface DualSearchEvent {
+    type: DualSearchEventType;
+    timestamp: Date;
+    detail: string;
+}
+export type DualSearchEventListener = (event: DualSearchEvent) => void;
+export interface DualSearch {
+    /** Run dual search with RRF fusion. */
+    search(query: string, opts?: {
+        maxResults?: number;
+    }): Promise<DualSearchResult[]>;
+    /** Events. */
+    on(listener: DualSearchEventListener): void;
+    off(listener: DualSearchEventListener): void;
+}
+export declare function createDualSearch(config: DualSearchConfig): DualSearch;

package/dist/memory/episodic.d.ts

@@ -0,0 +1,45 @@
+import type { StorageAdapter } from "../storage/interface.js";
+export interface EpisodicRecord {
+    id: string;
+    userId: string;
+    conversationId: string;
+    /** High-level scope tag: "deploy", "refactor", "debug", etc. */
+    taskScope: string;
+    /** What was decided */
+    decision: string;
+    /** Why this path was chosen */
+    rationale: string;
+    /** What happened as a result */
+    outcome: "success" | "partial" | "failure" | "pending";
+    /** Embedding vector for similarity retrieval */
+    embedding: number[] | null;
+    /** Decays over time — controls retrieval priority */
+    relevanceScore: number;
+    createdAt: Date;
+}
+export interface EpisodicWriteInput {
+    userId: string;
+    conversationId: string;
+    taskScope: string;
+    decision: string;
+    rationale: string;
+    outcome: EpisodicRecord["outcome"];
+    embedding?: number[];
+}
+export interface EpisodicRetrievalOpts {
+    userId: string;
+    queryEmbedding: number[];
+    taskScope?: string;
+    limit?: number;
+    minRelevance?: number;
+}
+export interface EpisodicSearchResult {
+    record: EpisodicRecord;
+    similarity: number;
+}
+export declare const EPISODIC_SCHEMA = "\nCREATE TABLE IF NOT EXISTS episodic_records (\n  id TEXT PRIMARY KEY,\n  user_id TEXT NOT NULL,\n  conversation_id TEXT NOT NULL,\n  task_scope TEXT NOT NULL,\n  decision TEXT NOT NULL,\n  rationale TEXT NOT NULL,\n  outcome TEXT NOT NULL DEFAULT 'pending',\n  embedding vector(1536),\n  relevance_score REAL NOT NULL DEFAULT 1.0,\n  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()\n);\n\nCREATE INDEX IF NOT EXISTS idx_episodic_user\n  ON episodic_records (user_id, task_scope);\nCREATE INDEX IF NOT EXISTS idx_episodic_embedding\n  ON episodic_records USING ivfflat (embedding vector_cosine_ops)\n  WITH (lists = 50);\n";
+export declare function writeEpisodicRecord(storage: StorageAdapter, input: EpisodicWriteInput): Promise<EpisodicRecord>;
+export declare function retrieveEpisodicRecords(storage: StorageAdapter, opts: EpisodicRetrievalOpts): Promise<EpisodicSearchResult[]>;
+/** Apply time-based decay to all records for a user. */
+export declare function applyEpisodicDecay(storage: StorageAdapter, userId: string): Promise<number>;
+export declare function formatEpisodicContext(results: EpisodicSearchResult[]): string;

package/dist/memory/index.d.ts

@@ -0,0 +1,27 @@
+export { createKnowledgeGraphStore, extractEntitiesAndRelations, createGraphToolRouter, _resetGraphIds, ENTITY_TYPES, RELATION_TYPES, } from "./knowledge-graph.js";
+export type { EntityType, RelationType, Entity, Relation, EntityUpdate, ExtractedEntity, ExtractedRelation, ExtractionResult, LLMCompleteFn, ToolRoute, GraphToolRouter, KnowledgeGraphStore, } from "./knowledge-graph.js";
+export { DualSearch, createDualSearch } from "./dual-search.js";
+export type { DualSearchResult, SearchBackendResult, BM25SearchFn, SemanticSearchFn, DualSearchConfig, DualSearchEventType, DualSearchEvent, DualSearchEventListener, } from "./dual-search.js";
+export { TreeIndexManager, createTreeIndexManager, _resetTreeIds } from "./tree-index.js";
+export type { TreeNode, TreeIndex, NavigationStep, TreeSearchResult, SummarizeFn, NavigateFn, TreeEventType, TreeEvent, TreeEventListener, TreeIndexConfig, } from "./tree-index.js";
+export { evaluateWriteGate, createTemporalValidity, invalidate, isValid, filterValid, } from "./write-gate.js";
+export type { TemporalValidity, WriteGateInput, WriteGateResult, ExistingMemory, FetchExistingFn, WriteGateConfig, } from "./write-gate.js";
+export { ProgressiveSearch } from "./progressive-search.js";
+export type { SearchResult as ProgressiveSearchResult, ProgressiveSearchConfig, KeywordSearchFn, EmbeddingSearchFn, } from "./progressive-search.js";
+export { BrainArtifactManager, STANDARD_ARTIFACTS } from "./brain-artifacts.js";
+export { recordObservation, retrieveObservations, recordObservationWithEvents, retrieveObservationsWithEvents, resetAccessCounts, DEFAULT_OBSERVATION_CONFIG, } from "./observation-store.js";
+export type { ObservationCategory, ObservationInput, ObservationStoreConfig, } from "./observation-store.js";
+export { immediateMemorySave, immediateMemorySaveWithEvents, } from "./mid-conversation-saves.js";
+export type { ImmediateSaveInput, ImmediateSaveContext, } from "./mid-conversation-saves.js";
+export { writeEpisodicRecord, retrieveEpisodicRecords, applyEpisodicDecay, formatEpisodicContext, EPISODIC_SCHEMA, } from "./episodic.js";
+export type { EpisodicRecord, EpisodicWriteInput, EpisodicRetrievalOpts, EpisodicSearchResult, } from "./episodic.js";
+export { writeTaskDiary, synthesizeMemories, TASK_DIARY_SCHEMA, } from "./synthesis.js";
+export type { TaskDiary, DiaryEntry, SynthesisResult, SynthesizedPattern, LLMSynthesizeFn, } from "./synthesis.js";
+export { parseNote, parseFrontmatter, parseObservations, parseRelations, serializeNote, } from "./note-parser.js";
+export type { NoteFrontmatter, Observation as NoteObservation, NoteRelation, Note, } from "./note-parser.js";
+export { MarkdownStore } from "./markdown-store.js";
+export type { FileSystem, NoteIndex, NoteIndexResult, FileWatcher, MarkdownStoreConfig, MarkdownStoreEventType, MarkdownStoreEvent, MarkdownStoreEventHandler, } from "./markdown-store.js";
+export { filtersToSQL, matchesFilters } from "./metadata-filter.js";
+export type { FilterValue, MetadataFilters, } from "./metadata-filter.js";
+export { detectTensions, checkObservationThresholds, DEFAULT_REVIEW_CONFIG, } from "./observation-thresholds.js";
+export type { ObservationReviewConfig, ObservationReviewResult, } from "./observation-thresholds.js";

package/dist/memory/knowledge-graph.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Knowledge Graph — in-memory Entity/Relation store with
+ * LLM-driven entity extraction, LightRAG-style two-phase merge,
+ * confidence-scored relations, and a "memory.graph" tool router.
+ */
+export declare const ENTITY_TYPES: readonly ["person", "organization", "project", "concept", "location", "tool", "event", "technology"];
+export type EntityType = (typeof ENTITY_TYPES)[number] | (string & {});
+export declare const RELATION_TYPES: readonly ["works_at", "uses", "knows", "created", "relates_to", "part_of", "founded", "located_in"];
+export type RelationType = (typeof RELATION_TYPES)[number] | (string & {});
+export interface Entity {
+    id: string;
+    name: string;
+    type: EntityType;
+    properties: Record<string, unknown>;
+    observations: string[];
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface Relation {
+    id: string;
+    from: string;
+    to: string;
+    type: RelationType;
+    confidence: number;
+    properties: Record<string, unknown>;
+    createdAt: Date;
+}
+export interface EntityUpdate {
+    name?: string;
+    type?: EntityType;
+    properties?: Record<string, unknown>;
+    observations?: string[];
+}
+export interface ExtractedEntity {
+    name: string;
+    type: EntityType;
+    observations: string[];
+}
+export interface ExtractedRelation {
+    fromName: string;
+    toName: string;
+    type: RelationType;
+    confidence?: number;
+}
+export interface ExtractionResult {
+    entities: ExtractedEntity[];
+    relations: ExtractedRelation[];
+}
+/** Minimal LLM interface: send a prompt, get a text response. */
+export type LLMCompleteFn = (prompt: string) => Promise<string>;
+export interface ToolRoute {
+    name: string;
+    description: string;
+    handler: (args: Record<string, unknown>) => Promise<string>;
+}
+export interface GraphToolRouter {
+    readonly routes: ReadonlyArray<ToolRoute>;
+    get(name: string): ToolRoute | undefined;
+}
+export interface KnowledgeGraphStore {
+    addEntity(name: string, type: string, properties?: Record<string, unknown>, observations?: string[]): Entity;
+    getEntity(id: string): Entity | undefined;
+    getEntityByName(name: string): Entity | undefined;
+    findEntities(query: string): Entity[];
+    updateEntity(id: string, updates: EntityUpdate): Entity | undefined;
+    deleteEntity(id: string): boolean;
+    addRelation(fromId: string, toId: string, type: RelationType, properties?: Record<string, unknown>, confidence?: number): Relation;
+    getRelation(id: string): Relation | undefined;
+    getRelationsFor(entityId: string): Relation[];
+    deleteRelation(id: string): boolean;
+    getNeighbors(entityId: string): Entity[];
+    findPath(fromId: string, toId: string, maxDepth?: number): Entity[] | null;
+    mergeExtracted(result: ExtractionResult): {
+        entities: Entity[];
+        relations: Relation[];
+    };
+    mergeExtractedAsync(result: ExtractionResult): Promise<{
+        entities: Entity[];
+        relations: Relation[];
+    }>;
+    readonly entityCount: number;
+    readonly relationCount: number;
+    allEntities(): Entity[];
+    allRelations(): Relation[];
+}
+export declare function _resetGraphIds(): void;
+export declare function createKnowledgeGraphStore(): KnowledgeGraphStore;
+export declare function extractEntitiesAndRelations(text: string, llmComplete: LLMCompleteFn, existingEntities?: Entity[]): Promise<ExtractionResult>;
+export declare function createGraphToolRouter(store: KnowledgeGraphStore, llmComplete?: LLMCompleteFn): GraphToolRouter;