open-multi-agent-kit 0.78.0

package/dist/memory/memory-config.d.ts

@@ -0,0 +1,51 @@
+import { type EmbeddingConfig } from "./embedding.js";
+export type MemoryBackend = "local_graph" | "kuzu";
+export interface MemorySettings {
+    backend: MemoryBackend;
+    strict: boolean;
+    force: boolean;
+    mirrorFiles: boolean;
+    migrateFiles: boolean;
+    project: {
+        key: string;
+        name: string;
+        root: string;
+    };
+    session: {
+        id: string;
+        key: string;
+    };
+    localGraph: {
+        path: string;
+        ontology: string;
+        query: "graphql-lite";
+        configured: boolean;
+    };
+    embedding: EmbeddingConfig;
+}
+export interface MemoryStatus {
+    backend: MemoryBackend;
+    strict: boolean;
+    force: boolean;
+    mirrorFiles: boolean;
+    migrateFiles: boolean;
+    projectKey: string;
+    projectName: string;
+    sessionId: string;
+    localGraph: {
+        configured: boolean;
+        path: string;
+        ontology: string;
+        query: "graphql-lite";
+    };
+    embedding: Omit<EmbeddingConfig, "apiKey">;
+}
+type Env = NodeJS.ProcessEnv;
+export declare const GLOBAL_MEMORY_CONFIG_TOML = "# open-multi-agent-kit global memory policy\n# Default is project-local graph memory: open-source friendly, no daemon, no secrets.\n# Use backend = \"kuzu\" when you want the embedded Kuzu graph backend.\n[memory]\nbackend = \"local_graph\"    # local_graph | kuzu\nscope = \"project-session\"\nstrict = true               # fail memory writes if the selected graph backend is unavailable\nforce = true                # global policy wins over project-local backend overrides\nmirror_files = true         # keep .omk/memory/*.md as readable mirrors\nmigrate_files = true        # seed the graph from existing .omk/memory files on first read\n\n[local_graph]\npath = \".omk/memory/graph-state.json\"\nontology = \"omk-ontology-mindmap-v1\"\nquery = \"graphql-lite\"\n";
+export declare function getGlobalMemoryConfigPath(): string;
+export declare function isGraphMemoryBackend(backend: MemoryBackend): boolean;
+export declare function usesLocalGraphBackend(backend: MemoryBackend): boolean;
+export declare function usesKuzuBackend(backend: MemoryBackend): boolean;
+export declare function loadMemorySettings(projectRoot?: string, env?: Env): Promise<MemorySettings>;
+export declare function summarizeMemorySettings(settings: MemorySettings): MemoryStatus;
+export {};

package/dist/memory/memory-config.js

@@ -0,0 +1,187 @@
+import { createHash } from "crypto";
+import { readFile } from "fs/promises";
+import { homedir } from "os";
+import { basename, join, resolve } from "path";
+import { loadEmbeddingConfig, redactEmbeddingConfig, } from "./embedding.js";
+const FALLBACK_SESSION_ID = `process-${process.pid}-${new Date().toISOString().replace(/[:.]/g, "-")}`;
+export const GLOBAL_MEMORY_CONFIG_TOML = `# open-multi-agent-kit global memory policy
+# Default is project-local graph memory: open-source friendly, no daemon, no secrets.
+# Use backend = "kuzu" when you want the embedded Kuzu graph backend.
+[memory]
+backend = "local_graph"    # local_graph | kuzu
+scope = "project-session"
+strict = true               # fail memory writes if the selected graph backend is unavailable
+force = true                # global policy wins over project-local backend overrides
+mirror_files = true         # keep .omk/memory/*.md as readable mirrors
+migrate_files = true        # seed the graph from existing .omk/memory files on first read
+
+[local_graph]
+path = ".omk/memory/graph-state.json"
+ontology = "omk-ontology-mindmap-v1"
+query = "graphql-lite"
+`;
+export function getGlobalMemoryConfigPath() {
+    return join(homedir(), ".kimi", "omk.memory.toml");
+}
+export function isGraphMemoryBackend(backend) {
+    return backend === "local_graph" || backend === "kuzu";
+}
+export function usesLocalGraphBackend(backend) {
+    return backend === "local_graph";
+}
+export function usesKuzuBackend(backend) {
+    return backend === "kuzu";
+}
+export async function loadMemorySettings(projectRoot = process.cwd(), env = process.env) {
+    const normalizedRoot = resolve(projectRoot);
+    const [globalConfig, projectConfig] = await Promise.all([
+        readSimpleToml(getGlobalMemoryConfigPath()),
+        readSimpleToml(join(normalizedRoot, ".omk", "config.toml")),
+    ]);
+    const envForce = parseOptionalBoolean(env.OMK_MEMORY_FORCE);
+    const force = envForce ?? readBoolean(globalConfig, "memory.force") ?? false;
+    const readSetting = (key) => {
+        const envKey = toEnvKey(key);
+        const envValue = env[envKey];
+        if (envValue !== undefined && envValue !== "")
+            return envValue;
+        return force ? globalConfig[key] ?? projectConfig[key] : projectConfig[key] ?? globalConfig[key];
+    };
+    const backend = normalizeBackend(env.OMK_MEMORY_BACKEND ?? readSetting("memory.backend"));
+    const strict = parseOptionalBoolean(env.OMK_MEMORY_STRICT) ?? parseOptionalBoolean(readSetting("memory.strict")) ?? true;
+    const mirrorFiles = parseOptionalBoolean(env.OMK_MEMORY_MIRROR_FILES) ?? parseOptionalBoolean(readSetting("memory.mirror_files")) ?? true;
+    const migrateFiles = parseOptionalBoolean(env.OMK_MEMORY_MIGRATE_FILES) ?? parseOptionalBoolean(readSetting("memory.migrate_files")) ?? true;
+    const projectName = env.OMK_PROJECT_NAME ?? readSetting("project.name") ?? (basename(normalizedRoot) || "project");
+    const projectKey = env.OMK_PROJECT_ID ?? readSetting("memory.project_id") ?? `${basename(normalizedRoot) || "project"}:${hashShort(normalizedRoot)}`;
+    const sessionId = env.OMK_SESSION_ID ?? env.OMK_RUN_ID ?? env.KIMI_SESSION_ID ?? FALLBACK_SESSION_ID;
+    const sessionKey = `${projectKey}:${sessionId}`;
+    const localGraphPath = resolve(normalizedRoot, env.OMK_LOCAL_GRAPH_PATH ?? readSetting("local_graph.path") ?? ".omk/memory/graph-state.json");
+    const localGraphOntology = env.OMK_LOCAL_GRAPH_ONTOLOGY ?? readSetting("local_graph.ontology") ?? "omk-ontology-mindmap-v1";
+    const embedding = loadEmbeddingConfig(env);
+    return {
+        backend,
+        strict,
+        force,
+        mirrorFiles,
+        migrateFiles,
+        project: {
+            key: projectKey,
+            name: projectName,
+            root: normalizedRoot,
+        },
+        session: {
+            id: sessionId,
+            key: sessionKey,
+        },
+        localGraph: {
+            path: localGraphPath,
+            ontology: localGraphOntology,
+            query: "graphql-lite",
+            configured: true,
+        },
+        embedding,
+    };
+}
+export function summarizeMemorySettings(settings) {
+    return {
+        backend: settings.backend,
+        strict: settings.strict,
+        force: settings.force,
+        mirrorFiles: settings.mirrorFiles,
+        migrateFiles: settings.migrateFiles,
+        projectKey: settings.project.key,
+        projectName: settings.project.name,
+        sessionId: settings.session.id,
+        localGraph: {
+            configured: settings.localGraph.configured,
+            path: settings.localGraph.path,
+            ontology: settings.localGraph.ontology,
+            query: settings.localGraph.query,
+        },
+        embedding: redactEmbeddingConfig(settings.embedding),
+    };
+}
+async function readSimpleToml(path) {
+    try {
+        const content = await readFile(path, "utf-8");
+        return parseSimpleToml(content);
+    }
+    catch {
+        return {};
+    }
+}
+function parseSimpleToml(content) {
+    const result = {};
+    let section = "";
+    for (const rawLine of content.split(/\r?\n/)) {
+        const line = stripComment(rawLine).trim();
+        if (!line)
+            continue;
+        const sectionMatch = line.match(/^\[([^\]]+)]$/);
+        if (sectionMatch) {
+            section = sectionMatch[1].trim();
+            continue;
+        }
+        const kv = line.match(/^([A-Za-z0-9_.-]+)\s*=\s*(.+)$/);
+        if (!kv)
+            continue;
+        const key = section ? `${section}.${kv[1].trim()}` : kv[1].trim();
+        result[key] = normalizeTomlValue(kv[2].trim());
+    }
+    return result;
+}
+function stripComment(line) {
+    let inString = false;
+    let quote = "";
+    for (let i = 0; i < line.length; i += 1) {
+        const char = line[i];
+        if ((char === '"' || char === "'") && line[i - 1] !== "\\") {
+            if (!inString) {
+                inString = true;
+                quote = char;
+            }
+            else if (quote === char) {
+                inString = false;
+            }
+        }
+        if (char === "#" && !inString) {
+            return line.slice(0, i);
+        }
+    }
+    return line;
+}
+function normalizeTomlValue(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) || (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function normalizeBackend(value) {
+    if (value === "local_graph" || value === "kuzu")
+        return value;
+    if (value === "graph" || value === "local-graph")
+        return "local_graph";
+    // Legacy external graph-database settings are intentionally downgraded to the
+    // local ontology graph. Kuzu remains available through backend = "kuzu".
+    return "local_graph";
+}
+function parseOptionalBoolean(value) {
+    if (value === undefined)
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(normalized))
+        return true;
+    if (["0", "false", "no", "off"].includes(normalized))
+        return false;
+    return undefined;
+}
+function readBoolean(config, key) {
+    return parseOptionalBoolean(config[key]);
+}
+function toEnvKey(key) {
+    return `OMK_${key.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}`;
+}
+function hashShort(value) {
+    return createHash("sha256").update(value).digest("hex").slice(0, 12);
+}

package/dist/memory/memory-store.d.ts

@@ -0,0 +1,48 @@
+import { type MemoryStatus } from "./memory-config.js";
+import type { GraphQueryResult, MemoryMindmap, MemoryOntology, MemorySearchResult } from "./local-graph-memory-store.js";
+import type { MemoryBackend } from "./memory-config.js";
+export interface MemoryStoreOptions {
+    projectRoot?: string;
+    sessionId?: string;
+    source?: string;
+    env?: NodeJS.ProcessEnv;
+}
+export interface UnifiedMemoryStore {
+    readonly status: MemoryStatus;
+    readonly strict: boolean;
+    readonly mirrorFiles: boolean;
+    readonly migrateFiles: boolean;
+    read(path: string): Promise<string>;
+    write(path: string, content: string): Promise<void>;
+    append(path: string, content: string): Promise<void>;
+    search(query: string, limit?: number): Promise<MemorySearchResult[]>;
+    ontology?: () => Promise<MemoryOntology | null>;
+    mindmap?: (query?: string, limit?: number) => Promise<MemoryMindmap | null>;
+    graphQuery?: (query: string) => Promise<GraphQueryResult>;
+}
+export declare function createMemoryStore(backend: MemoryBackend, options?: MemoryStoreOptions): Promise<UnifiedMemoryStore | null>;
+export declare class MemoryStore {
+    private readonly options;
+    private readonly basePath;
+    private settingsPromise?;
+    private graphStorePromise?;
+    private graphStatePromise?;
+    constructor(basePath: string, options?: MemoryStoreOptions);
+    ensureGraphState(): Promise<void>;
+    private safePath;
+    read(path: string): Promise<string>;
+    write(path: string, content: string): Promise<void>;
+    append(path: string, content: string): Promise<void>;
+    readRunMemory(runId: string, path: string): Promise<string>;
+    writeRunMemory(runId: string, path: string, content: string): Promise<void>;
+    search(query: string, limit?: number): Promise<MemorySearchResult[]>;
+    ontology(): Promise<MemoryOntology | null>;
+    mindmap(query?: string, limit?: number): Promise<MemoryMindmap | null>;
+    graphQuery(query: string): Promise<GraphQueryResult>;
+    status(): Promise<MemoryStatus>;
+    private readFileContent;
+    private writeFileContent;
+    private safeRunPath;
+    private getSettings;
+    private getGraphStore;
+}

package/dist/memory/memory-store.js

@@ -0,0 +1,210 @@
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join, dirname, resolve, relative, isAbsolute } from "path";
+import { getProjectRoot } from "../util/fs.js";
+import { loadMemorySettings, summarizeMemorySettings, } from "./memory-config.js";
+export async function createMemoryStore(backend, options = {}) {
+    if (backend === "local_graph") {
+        const { LocalGraphMemoryStore } = await import("./local-graph-memory-store.js");
+        return LocalGraphMemoryStore.create(options);
+    }
+    if (backend === "kuzu") {
+        const { KuzuMemoryStore } = await import("./kuzu-memory-store.js");
+        return KuzuMemoryStore.create(options);
+    }
+    return null;
+}
+export class MemoryStore {
+    options;
+    basePath;
+    settingsPromise;
+    graphStorePromise;
+    graphStatePromise;
+    constructor(basePath, options = {}) {
+        this.options = options;
+        this.basePath = resolve(basePath);
+    }
+    async ensureGraphState() {
+        this.graphStatePromise ??= (async () => {
+            const graph = await this.getGraphStore();
+            if (!graph)
+                return;
+            const settings = await this.getSettings();
+            try {
+                await graph.write("project", JSON.stringify({ key: settings.project.key, name: settings.project.name }));
+            }
+            catch (err) {
+                if (graph.strict)
+                    throw err;
+            }
+        })();
+        return this.graphStatePromise;
+    }
+    safePath(inputPath) {
+        if (isAbsolute(inputPath)) {
+            throw new Error(`MemoryStore: absolute paths are not allowed: ${inputPath}`);
+        }
+        const full = resolve(join(this.basePath, inputPath));
+        const rel = relative(this.basePath, full);
+        if (rel.startsWith("..") || rel === "..") {
+            throw new Error(`MemoryStore: path traversal detected: ${inputPath}`);
+        }
+        return full;
+    }
+    async read(path) {
+        const full = this.safePath(path);
+        const graph = await this.getGraphStore();
+        if (graph) {
+            try {
+                const graphContent = await graph.read(path);
+                if (graphContent)
+                    return graphContent;
+                const fileContent = await this.readFileContent(full);
+                if (fileContent && graph.migrateFiles) {
+                    await graph.write(path, fileContent);
+                    return fileContent;
+                }
+                if (graph.strict)
+                    return graphContent;
+                return fileContent;
+            }
+            catch (err) {
+                if (graph.strict)
+                    throw err;
+            }
+        }
+        return this.readFileContent(full);
+    }
+    async write(path, content) {
+        await this.ensureGraphState();
+        const full = this.safePath(path);
+        const graph = await this.getGraphStore();
+        if (graph) {
+            try {
+                await graph.write(path, content);
+            }
+            catch (err) {
+                if (graph.strict)
+                    throw err;
+            }
+            if (!graph.mirrorFiles)
+                return;
+        }
+        await this.writeFileContent(full, content);
+    }
+    async append(path, content) {
+        const existing = await this.read(path);
+        await this.write(path, existing ? `${existing}\n${content}` : content);
+    }
+    async readRunMemory(runId, path) {
+        const { full, graphPath } = this.safeRunPath(runId, path);
+        const graph = await this.getGraphStore();
+        if (graph) {
+            try {
+                const graphContent = await graph.read(graphPath);
+                if (graphContent)
+                    return graphContent;
+                const fileContent = await this.readFileContent(full);
+                if (fileContent && graph.migrateFiles) {
+                    await graph.write(graphPath, fileContent);
+                    return fileContent;
+                }
+                if (graph.strict)
+                    return graphContent;
+                return fileContent;
+            }
+            catch (err) {
+                if (graph.strict)
+                    throw err;
+            }
+        }
+        return this.readFileContent(full);
+    }
+    async writeRunMemory(runId, path, content) {
+        await this.ensureGraphState();
+        const { full, graphPath } = this.safeRunPath(runId, path);
+        const graph = await this.getGraphStore();
+        if (graph) {
+            try {
+                await graph.write(graphPath, content);
+            }
+            catch (err) {
+                if (graph.strict)
+                    throw err;
+            }
+            if (!graph.mirrorFiles)
+                return;
+        }
+        await this.writeFileContent(full, content);
+    }
+    async search(query, limit) {
+        const graph = await this.getGraphStore();
+        if (!graph)
+            return [];
+        return graph.search(query, limit);
+    }
+    async ontology() {
+        const graph = await this.getGraphStore();
+        return typeof graph?.ontology === "function" ? graph.ontology() : null;
+    }
+    async mindmap(query, limit) {
+        const graph = await this.getGraphStore();
+        return typeof graph?.mindmap === "function" ? graph.mindmap(query, limit) : null;
+    }
+    async graphQuery(query) {
+        const graph = await this.getGraphStore();
+        if (typeof graph?.graphQuery !== "function") {
+            throw new Error("omk_graph_query requires a graph memory backend (local_graph or kuzu)");
+        }
+        return graph.graphQuery(query);
+    }
+    async status() {
+        const graph = await this.getGraphStore();
+        if (graph)
+            return graph.status;
+        return summarizeMemorySettings(await this.getSettings());
+    }
+    async readFileContent(fullPath) {
+        try {
+            return await readFile(fullPath, "utf-8");
+        }
+        catch {
+            return "";
+        }
+    }
+    async writeFileContent(fullPath, content) {
+        await mkdir(dirname(fullPath), { recursive: true });
+        await writeFile(fullPath, content, "utf-8");
+    }
+    safeRunPath(runId, path) {
+        if (runId.includes("..") || runId.startsWith("/") || runId.startsWith("\\")) {
+            throw new Error(`MemoryStore: invalid runId: ${runId}`);
+        }
+        const root = this.options.projectRoot ?? getProjectRoot();
+        const runBase = resolve(join(root, ".omk", "runs", runId, "memory"));
+        const full = resolve(join(runBase, path));
+        const rel = relative(runBase, full);
+        if (rel.startsWith("..") || rel === "..") {
+            throw new Error(`MemoryStore: path traversal detected: ${path}`);
+        }
+        return { full, graphPath: join("runs", runId, path).replace(/\\/g, "/") };
+    }
+    async getSettings() {
+        const env = this.options.sessionId
+            ? { ...(this.options.env ?? process.env), OMK_SESSION_ID: this.options.sessionId }
+            : this.options.env;
+        this.settingsPromise ??= loadMemorySettings(this.options.projectRoot, env);
+        return this.settingsPromise;
+    }
+    async getGraphStore() {
+        this.graphStorePromise ??= (async () => {
+            const settings = await this.getSettings();
+            return createMemoryStore(settings.backend, {
+                projectRoot: this.options.projectRoot,
+                sessionId: this.options.sessionId,
+                source: this.options.source,
+                env: this.options.env,
+            });
+        })();
+        return this.graphStorePromise;
+    }
+}

package/dist/memory/ontology-model.d.ts

@@ -0,0 +1,175 @@
+/**
+ * Ontology model for OMK project memory.
+ *
+ * Defines core node types, relationship types, project-isolation fields,
+ * and schema helpers used across all graph-backed memory stores.
+ */
+export declare const ONTOLOGY_SCHEMA_VERSION = 1;
+export declare const ONTOLOGY_NODE_TYPES: readonly ["Project", "Session", "Run", "Goal", "Criterion", "Evidence", "Decision", "Task", "Risk", "Constraint", "File", "Symbol", "Test", "Command", "Commit", "MCPServer", "Skill", "Provider", "ProviderRoute", "ProviderFallback", "AuditLink"];
+export type OntologyNodeType = (typeof ONTOLOGY_NODE_TYPES)[number];
+export declare const ONTOLOGY_RELATIONSHIP_TYPES: readonly ["HAS_GOAL", "HAS_RUN", "HAS_CRITERION", "HAS_EVIDENCE", "HAS_DECISION", "HAS_TASK", "DEPENDS_ON", "HAS_RISK", "HAS_FILE", "HAS_SYMBOL", "HAS_TEST", "HAS_COMMAND", "HAS_COMMIT", "USES_MCP", "USES_SKILL", "USES_PROVIDER", "HAS_PROVIDER_ROUTE", "ROUTES_TO", "FALLS_BACK_TO", "HAS_PROVIDER_FALLBACK", "HAS_AUDIT_LINK", "LINKS_TO"];
+export type OntologyRelationshipType = (typeof ONTOLOGY_RELATIONSHIP_TYPES)[number];
+/** Base properties present on every ontology node for project isolation. */
+export interface OntologyNodeBase {
+    /** Unique node identifier (scoped to project). */
+    id: string;
+    /** Project key for multi-tenant isolation. */
+    projectId: string;
+    /** SHA-256 hash of the workspace root path. */
+    workspaceRootHash: string;
+    /** Ontology schema version (default 1). */
+    schemaVersion: number;
+    /** ISO timestamp when the node was created. */
+    createdAt: string;
+    /** ISO timestamp when the node was last updated. */
+    updatedAt: string;
+}
+/** Project node managed by graph memory stores. */
+export interface ProjectNode extends OntologyNodeBase {
+    key: string;
+    name: string;
+    root: string;
+}
+/** Session node managed by graph memory stores. */
+export interface SessionNode extends OntologyNodeBase {
+    key: string;
+    sessionId: string;
+    projectKey: string;
+}
+/** Runtime/run node used to link plans, evidence, reports, and provider attempts. */
+export interface RunNode extends OntologyNodeBase {
+    runId: string;
+    status: string;
+    startedAt: string;
+}
+/** Memory node managed by graph memory stores. */
+export interface MemoryNode extends OntologyNodeBase {
+    key: string;
+    path: string;
+    content: string;
+    source: string;
+}
+/** MemoryVersion node managed by graph memory stores. */
+export interface MemoryVersionNode extends OntologyNodeBase {
+    key: string;
+    path: string;
+    content: string;
+    source: string;
+}
+/** Goal node in the ontology graph. */
+export interface GoalNode extends OntologyNodeBase {
+    goalId: string;
+    title: string;
+    objective: string;
+    status: string;
+    riskLevel: string;
+}
+/** Criterion node linked to a Goal. */
+export interface CriterionNode extends OntologyNodeBase {
+    criterionId: string;
+    description: string;
+    requirement: string;
+    weight: number;
+}
+/** Evidence node for goal verification. */
+export interface EvidenceNode extends OntologyNodeBase {
+    evidenceId: string;
+    passed: boolean;
+    message: string;
+    checkedAt: string;
+}
+/** Decision node capturing project decisions. */
+export interface DecisionNode extends OntologyNodeBase {
+    decisionId: string;
+    description: string;
+    decidedAt: string;
+}
+/** Task node for actionable work items. */
+export interface TaskNode extends OntologyNodeBase {
+    taskId: string;
+    description: string;
+    status: string;
+    priority: string;
+}
+/** Risk node for tracked risks. */
+export interface RiskNode extends OntologyNodeBase {
+    riskId: string;
+    description: string;
+    level: string;
+}
+/** Command node for recorded commands. */
+export interface CommandNode extends OntologyNodeBase {
+    commandId: string;
+    command: string;
+    description: string;
+}
+/** File node for referenced files. */
+export interface FileNode extends OntologyNodeBase {
+    path: string;
+    description: string;
+}
+/** Skill node for available skills. */
+export interface SkillNode extends OntologyNodeBase {
+    name: string;
+    description: string;
+}
+/** MCP Server node for configured MCP servers. */
+export interface MCPServerNode extends OntologyNodeBase {
+    name: string;
+    description: string;
+}
+/** Provider node for provider-neutral multi-provider orchestration. */
+export interface ProviderNode extends OntologyNodeBase {
+    providerId: string;
+    role: "primary" | "opportunistic";
+    description: string;
+}
+/** Provider route decision node for DAG node execution. */
+export interface ProviderRouteNode extends OntologyNodeBase {
+    routeId: string;
+    nodeId: string;
+    requestedProvider: string;
+    actualProvider: string;
+    reason: string;
+    confidence: number;
+}
+/** Provider fallback event node for preserving run evidence. */
+export interface ProviderFallbackNode extends OntologyNodeBase {
+    fallbackId: string;
+    nodeId: string;
+    fromProvider: string;
+    toProvider: string;
+    reason: string;
+}
+/** Audit link node connecting reports/evidence to runs, goals, files, or providers. */
+export interface AuditLinkNode extends OntologyNodeBase {
+    linkId: string;
+    label: string;
+    target: string;
+    targetType: string;
+}
+/** Minimal executor interface accepted by {@link createOntologyConstraints}. */
+export interface OntologyConstraintExecutor {
+    executeQuery(query: string, params?: Record<string, unknown>, options?: {
+        database?: string;
+    }): Promise<unknown>;
+}
+/**
+ * Create unique constraints for every ontology node type.
+ * Each constraint enforces uniqueness on `(projectId, id)` for the label.
+ */
+export declare function createOntologyConstraints(executor: OntologyConstraintExecutor, database?: string): Promise<void>;
+/** Kuzu DDL statements for the full OMK ontology schema. */
+export interface KuzuOntologySchema {
+    nodeTables: string[];
+    relTables: string[];
+}
+/** Build Kuzu CREATE NODE TABLE / CREATE REL TABLE DDLs from the ontology model. */
+export declare function buildKuzuOntologySchema(): KuzuOntologySchema;
+/** Cypher write keywords rejected by the read-only graph query guard. */
+export declare const MUTATION_KEYWORDS: string[];
+/**
+ * Return true if the provided Cypher query contains write mutations.
+ * Strips line comments and block comments before scanning.
+ */
+export declare function containsMutation(query: string): boolean;