mindforge-sdk 10.7.0

package/README.md

@@ -0,0 +1,102 @@
+# @mindforge/sdk
+
+TypeScript SDK for embedding MindForge in tools, dashboards, and CI pipelines.
+
+## Installation
+
+```bash
+npm install @mindforge/sdk
+```
+
+## Quick start
+
+```typescript
+import { MindForgeClient } from '@mindforge/sdk';
+
+const client = new MindForgeClient({
+  projectRoot: '/path/to/project',
+  apiKey: process.env.ANTHROPIC_API_KEY,
+});
+
+// Health check
+const health = await client.health();
+console.log(health.overallStatus); // 'healthy' | 'warning' | 'error'
+
+// Read audit log
+const findings = client.readAuditLog({ event: 'security_finding' });
+console.log(findings);
+
+// Read metrics
+const metrics = client.readSessionMetrics(5);
+console.log(metrics);
+```
+
+## Real-time event streaming
+
+```typescript
+import { MindForgeEventStream } from '@mindforge/sdk';
+
+const stream = new MindForgeEventStream();
+await stream.start(7337);
+stream.watchAuditLog('/path/to/project');
+
+// Subscribe from browser or tool:
+const es = new EventSource('http://localhost:7337/events');
+es.addEventListener('audit_entry', (e) => {
+  const entry = JSON.parse(e.data);
+  if (entry.event === 'task_completed') {
+    console.log('Task done:', entry.task_name);
+  }
+});
+```
+
+## Config validation
+
+```typescript
+const { valid, errors } = client.validateConfig();
+if (!valid) console.error(errors);
+```
+
+## Security notes
+
+- `HANDOFF.json` may contain sensitive project state. Do not expose it to untrusted clients
+  or log its contents in external systems.
+- The SDK operates on local files and provides no network authentication. Do not expose SDK
+  endpoints to the public internet.
+
+## New in v9.0.0
+
+### Additional exports
+
+```typescript
+import {
+  MindForgeClient,
+  MindForgeEventStream,
+  VERSION,              // '9.0.0'
+} from '@mindforge/sdk';
+
+import type {
+  WaveExecutionResult,  // Result type returned by wave execution operations
+  MigrationResult,      // Result type returned by schema migration operations
+} from '@mindforge/sdk';
+```
+
+### New `MindForgeClient` methods
+
+```typescript
+const client = new MindForgeClient({ projectRoot: '/path/to/project' });
+
+// Read the current auto-state from auto-state.json
+const state = client.readAutoState();
+console.log(state.status); // 'idle' | 'running' | 'awaiting_regeneration'
+
+// Check whether the local MindForge database has been initialized
+const ready = client.isDatabaseInitialized();
+if (!ready) {
+  console.warn('Run mindforge:init-project first');
+}
+```
+
+## TypeScript support
+
+Full type definitions included. No `@types/` package needed.

package/dist/client.d.ts

@@ -0,0 +1,28 @@
+/**
+ * MindForge SDK — Main Client
+ */
+import { EventEmitter } from 'events';
+import type { MindForgeConfig, HealthReport, AuditLogEntry } from './types';
+export declare class MindForgeClient extends EventEmitter {
+    private config;
+    private projectRoot;
+    constructor(config?: MindForgeConfig);
+    isInitialised(): boolean;
+    readState(): Record<string, unknown> | null;
+    readHandoff(): Record<string, unknown> | null;
+    health(): Promise<HealthReport>;
+    readAuditLog(filter?: {
+        event?: string;
+        phase?: number;
+        since?: Date;
+    }): AuditLogEntry[];
+    readSessionMetrics(limit?: number): unknown[];
+    validateConfig(): {
+        valid: boolean;
+        errors: string[];
+        warnings: string[];
+    };
+    readAutoState(): Record<string, unknown> | null;
+    getDbPath(): string;
+    isDatabaseInitialized(): boolean;
+}

package/dist/client.js

@@ -0,0 +1,232 @@
+"use strict";
+/**
+ * MindForge SDK — Main Client
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MindForgeClient = void 0;
+const events_1 = require("events");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class MindForgeClient extends events_1.EventEmitter {
+    constructor(config = {}) {
+        super();
+        this.projectRoot = config.projectRoot ?? process.cwd();
+        this.config = {
+            projectRoot: this.projectRoot,
+            apiKey: config.apiKey ?? process.env.ANTHROPIC_API_KEY ?? '',
+            ciMode: config.ciMode ?? (process.env.CI === 'true'),
+            outputFormat: config.outputFormat ?? 'json',
+            taskTimeoutMs: config.taskTimeoutMs ?? 600000,
+        };
+    }
+    // ── Project state ──────────────────────────────────────────────────────────
+    isInitialised() {
+        return fs.existsSync(path.join(this.projectRoot, '.planning', 'PROJECT.md'));
+    }
+    readState() {
+        const statePath = path.join(this.projectRoot, '.planning', 'STATE.md');
+        if (!fs.existsSync(statePath))
+            return null;
+        return { raw: fs.readFileSync(statePath, 'utf8') };
+    }
+    readHandoff() {
+        const handoffPath = path.join(this.projectRoot, '.planning', 'HANDOFF.json');
+        if (!fs.existsSync(handoffPath))
+            return null;
+        try {
+            return JSON.parse(fs.readFileSync(handoffPath, 'utf8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    // ── Health check ───────────────────────────────────────────────────────────
+    async health() {
+        const errors = [];
+        const warnings = [];
+        const info = [];
+        const requiredFiles = [
+            '.planning/STATE.md',
+            '.planning/HANDOFF.json',
+            '.planning/AUDIT.jsonl',
+            '.mindforge/org/CONVENTIONS.md',
+        ];
+        for (const file of requiredFiles) {
+            const fullPath = path.join(this.projectRoot, file);
+            if (!fs.existsSync(fullPath)) {
+                warnings.push({ category: 'installation', message: `Missing: ${file}`, autoRepairable: false });
+            }
+        }
+        // Check HANDOFF.json validity
+        const handoff = this.readHandoff();
+        if (handoff && !handoff.schema_version) {
+            errors.push({ category: 'state', message: 'HANDOFF.json missing schema_version field', autoRepairable: false });
+        }
+        // Check AUDIT.jsonl
+        const auditPath = path.join(this.projectRoot, '.planning', 'AUDIT.jsonl');
+        if (fs.existsSync(auditPath)) {
+            const lineCount = fs.readFileSync(auditPath, 'utf8').split('\n').filter(Boolean).length;
+            if (lineCount > 9000) {
+                warnings.push({ category: 'audit', message: `AUDIT.jsonl has ${lineCount} lines — archive soon`, autoRepairable: true });
+            }
+            info.push({ category: 'audit', message: `AUDIT.jsonl: ${lineCount} entries`, autoRepairable: false });
+        }
+        return {
+            overallStatus: errors.length > 0 ? 'error' : warnings.length > 0 ? 'warning' : 'healthy',
+            errors,
+            warnings,
+            informational: info,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    // ── Audit log reading ──────────────────────────────────────────────────────
+    readAuditLog(filter) {
+        const auditPath = path.join(this.projectRoot, '.planning', 'AUDIT.jsonl');
+        if (!fs.existsSync(auditPath))
+            return [];
+        return fs.readFileSync(auditPath, 'utf8')
+            .split('\n')
+            .filter(Boolean)
+            .map((line) => { try {
+            return JSON.parse(line);
+        }
+        catch {
+            return null;
+        } })
+            .filter((entry) => !!entry)
+            .filter(entry => {
+            if (filter?.event && entry.event !== filter.event)
+                return false;
+            if (filter?.phase !== undefined && entry.phase !== filter.phase)
+                return false;
+            if (filter?.since && new Date(entry.timestamp) < filter.since)
+                return false;
+            return true;
+        });
+    }
+    // ── Metrics reading ────────────────────────────────────────────────────────
+    readSessionMetrics(limit = 10) {
+        const metricsPath = path.join(this.projectRoot, '.mindforge', 'metrics', 'session-quality.jsonl');
+        if (!fs.existsSync(metricsPath))
+            return [];
+        return fs.readFileSync(metricsPath, 'utf8')
+            .split('\n')
+            .filter(Boolean)
+            .slice(-limit)
+            .map((line) => { try {
+            return JSON.parse(line);
+        }
+        catch {
+            return null;
+        } })
+            .filter(Boolean);
+    }
+    // ── Config validation ──────────────────────────────────────────────────────
+    validateConfig() {
+        const errors = [];
+        const warnings = [];
+        const configPath = path.join(this.projectRoot, 'MINDFORGE.md');
+        if (!fs.existsSync(configPath)) {
+            return { valid: false, errors: ['MINDFORGE.md not found at project root'], warnings: [] };
+        }
+        const content = fs.readFileSync(configPath, 'utf8');
+        // Required fields that must be present in a valid MINDFORGE.md
+        const requiredFields = [
+            { key: 'VERSION', pattern: /\[VERSION\]\s*=\s*.+/ },
+            { key: 'REACTIVE_MODE', pattern: /\[REACTIVE_MODE\]\s*=\s*.+/ },
+            { key: 'PLANNER', pattern: /\[PLANNER\]\s*=\s*.+/ },
+            { key: 'EXECUTOR', pattern: /\[EXECUTOR\]\s*=\s*.+/ },
+            { key: 'MIN_SOUL_SCORE', pattern: /\[MIN_SOUL_SCORE\]\s*=\s*.+/ },
+        ];
+        for (const field of requiredFields) {
+            if (!field.pattern.test(content)) {
+                errors.push(`Missing required field: [${field.key}]`);
+            }
+        }
+        // Recommended fields — warn if missing
+        const recommendedFields = [
+            { key: 'COST_WARN_USD', pattern: /\[COST_WARN_USD\]\s*=\s*.+/ },
+            { key: 'COST_HARD_LIMIT_USD', pattern: /\[COST_HARD_LIMIT_USD\]\s*=\s*.+/ },
+            { key: 'BLOCK_ON_SECURITY', pattern: /\[BLOCK_ON_SECURITY\]\s*=\s*.+/ },
+        ];
+        for (const field of recommendedFields) {
+            if (!field.pattern.test(content)) {
+                warnings.push(`Recommended field missing: [${field.key}]`);
+            }
+        }
+        // Schema-based validation if schema file exists
+        const schemaPath = path.join(this.projectRoot, '.mindforge', 'MINDFORGE-SCHEMA.json');
+        if (fs.existsSync(schemaPath)) {
+            try {
+                const schema = JSON.parse(fs.readFileSync(schemaPath, 'utf8'));
+                const nonOverridableKeys = Object.entries(schema.properties ?? {})
+                    .filter(([, def]) => def.nonOverridable === true)
+                    .map(([key]) => key);
+                for (const key of nonOverridableKeys) {
+                    // Non-overridable fields must not be set to false
+                    const disabledPattern = new RegExp(`\\[${key}\\]\\s*=\\s*false`, 'i');
+                    if (disabledPattern.test(content)) {
+                        errors.push(`Non-overridable field [${key}] cannot be disabled`);
+                    }
+                }
+            }
+            catch {
+                warnings.push('MINDFORGE-SCHEMA.json exists but could not be parsed');
+            }
+        }
+        return { valid: errors.length === 0, errors, warnings };
+    }
+    // ── v9 Pillar XXIV: Wave execution status ─────────────────────────────────
+    readAutoState() {
+        const statePath = path.join(this.projectRoot, '.planning', 'auto-state.json');
+        if (!fs.existsSync(statePath))
+            return null;
+        try {
+            return JSON.parse(fs.readFileSync(statePath, 'utf8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    // ── v9 Pillar XXVI: Knowledge query ───────────────────────────────────────
+    getDbPath() {
+        return path.join(this.projectRoot, '.mindforge', 'celestial.db');
+    }
+    isDatabaseInitialized() {
+        return fs.existsSync(this.getDbPath());
+    }
+}
+exports.MindForgeClient = MindForgeClient;

package/dist/commands.d.ts

@@ -0,0 +1,39 @@
+/**
+ * MindForge SDK — Command Builders
+ * Builds the command strings that can be sent to Claude Code / Antigravity
+ * via their programmatic APIs.
+ */
+export interface CommandOptions {
+    flags?: string[];
+    args?: string[];
+}
+export declare const commands: {
+    /**
+     * Build a /mindforge:health command string
+     */
+    health(opts?: CommandOptions): string;
+    /**
+     * Build a /mindforge:plan-phase command string
+     */
+    planPhase(phase: number, opts?: CommandOptions): string;
+    /**
+     * Build a /mindforge:execute-phase command string
+     */
+    executePhase(phase: number, opts?: CommandOptions): string;
+    /**
+     * Build a /mindforge:security-scan command string
+     */
+    securityScan(path?: string, opts?: CommandOptions): string;
+    /**
+     * Build a /mindforge:audit command string with filters
+     */
+    audit(filter?: {
+        phase?: number;
+        event?: string;
+        since?: string;
+    }): string;
+    /**
+     * Build a /mindforge:pr-review command string
+     */
+    prReview(opts?: CommandOptions): string;
+};

package/dist/commands.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * MindForge SDK — Command Builders
+ * Builds the command strings that can be sent to Claude Code / Antigravity
+ * via their programmatic APIs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commands = void 0;
+exports.commands = {
+    /**
+     * Build a /mindforge:health command string
+     */
+    health(opts = {}) {
+        const flags = opts.flags?.join(' ') ?? '';
+        return `/mindforge:health ${flags}`.trim();
+    },
+    /**
+     * Build a /mindforge:plan-phase command string
+     */
+    planPhase(phase, opts = {}) {
+        const flags = opts.flags?.join(' ') ?? '';
+        return `/mindforge:plan-phase ${phase} ${flags}`.trim();
+    },
+    /**
+     * Build a /mindforge:execute-phase command string
+     */
+    executePhase(phase, opts = {}) {
+        const flags = opts.flags?.join(' ') ?? '';
+        return `/mindforge:execute-phase ${phase} ${flags}`.trim();
+    },
+    /**
+     * Build a /mindforge:security-scan command string
+     */
+    securityScan(path, opts = {}) {
+        const flags = opts.flags?.join(' ') ?? '';
+        return `/mindforge:security-scan ${path ?? ''} ${flags}`.trim();
+    },
+    /**
+     * Build a /mindforge:audit command string with filters
+     */
+    audit(filter = {}) {
+        const parts = ['/mindforge:audit'];
+        if (filter.phase)
+            parts.push(`--phase ${filter.phase}`);
+        if (filter.event)
+            parts.push(`--event ${filter.event}`);
+        if (filter.since)
+            parts.push(`--since ${filter.since}`);
+        return parts.join(' ');
+    },
+    /**
+     * Build a /mindforge:pr-review command string
+     */
+    prReview(opts = {}) {
+        const flags = opts.flags?.join(' ') ?? '';
+        return `/mindforge:pr-review ${flags}`.trim();
+    },
+};

package/dist/events.d.ts

@@ -0,0 +1,27 @@
+/**
+ * MindForge SDK — Server-Sent Events (SSE) stream for real-time progress
+ * Enables external tools to subscribe to MindForge execution progress.
+ */
+export declare class MindForgeEventStream {
+    private clients;
+    private server;
+    private auditWatcher;
+    private lastAuditLine;
+    /**
+     * Start the SSE server on the given port
+     */
+    start(port?: number): Promise<void>;
+    /**
+     * Watch AUDIT.jsonl for new entries and broadcast as SSE events
+     */
+    watchAuditLog(projectRoot: string): void;
+    /**
+     * Broadcast an event to all connected clients
+     */
+    broadcast(eventType: string, data: unknown): void;
+    private sendEvent;
+    /**
+     * Stop the event stream server
+     */
+    stop(): void;
+}

package/dist/events.js

@@ -0,0 +1,186 @@
+"use strict";
+/**
+ * MindForge SDK — Server-Sent Events (SSE) stream for real-time progress
+ * Enables external tools to subscribe to MindForge execution progress.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MindForgeEventStream = void 0;
+const http = __importStar(require("http"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class MindForgeEventStream {
+    constructor() {
+        this.clients = [];
+        this.server = null;
+        this.auditWatcher = null;
+        this.lastAuditLine = 0;
+    }
+    /**
+     * Start the SSE server on the given port
+     */
+    start(port = 7337) {
+        return new Promise((resolve, reject) => {
+            this.server = http.createServer((req, res) => {
+                if (req.url !== '/events') {
+                    res.writeHead(404);
+                    res.end();
+                    return;
+                }
+                // SECURITY: Only allow connections from localhost
+                const clientIp = req.socket.remoteAddress;
+                const isLocalhost = clientIp === '127.0.0.1' ||
+                    clientIp === '::1' ||
+                    clientIp === '::ffff:127.0.0.1';
+                if (!isLocalhost) {
+                    res.writeHead(403);
+                    res.end('Forbidden: MindForge event stream is localhost-only');
+                    return;
+                }
+                // CORS: Only allow localhost origins (exact match, not wildcard)
+                const origin = req.headers.origin;
+                const allowedOriginPattern = /^https?:\/\/localhost(:\d+)?$/;
+                const corsOrigin = origin && allowedOriginPattern.test(origin)
+                    ? origin
+                    : 'http://localhost';
+                res.writeHead(200, {
+                    'Content-Type': 'text/event-stream',
+                    'Cache-Control': 'no-cache',
+                    'Connection': 'keep-alive',
+                    'Access-Control-Allow-Origin': corsOrigin,
+                    'X-Content-Type-Options': 'nosniff',
+                });
+                const clientId = Date.now().toString();
+                this.clients.push({ id: clientId, response: res });
+                // Send initial connection event
+                this.sendEvent(res, 'connected', { clientId, timestamp: new Date().toISOString() });
+                // Clean up on disconnect
+                req.on('close', () => {
+                    this.clients = this.clients.filter(c => c.id !== clientId);
+                });
+            });
+            // SECURITY: Bind to localhost ONLY — not all interfaces
+            this.server.listen(port, '127.0.0.1', () => {
+                console.log(`MindForge event stream: http://localhost:${port}/events (localhost only)`);
+                resolve();
+            });
+            this.server.on('error', (err) => {
+                if (err.code === 'EADDRINUSE') {
+                    reject(new Error(`Port ${port} is already in use. Use: new MindForgeEventStream().start(${port + 1})`));
+                }
+                else {
+                    reject(err);
+                }
+            });
+        });
+    }
+    /**
+     * Watch AUDIT.jsonl for new entries and broadcast as SSE events
+     */
+    watchAuditLog(projectRoot) {
+        const auditPath = path.join(projectRoot, '.planning', 'AUDIT.jsonl');
+        if (!fs.existsSync(auditPath)) {
+            // Create the file if it doesn't exist yet
+            fs.writeFileSync(auditPath, '');
+        }
+        // Set initial line count
+        const content = fs.readFileSync(auditPath, 'utf8');
+        this.lastAuditLine = content.split('\n').filter(Boolean).length;
+        try {
+            this.auditWatcher = fs.watch(auditPath, () => {
+                const lines = fs.readFileSync(auditPath, 'utf8')
+                    .split('\n')
+                    .filter(Boolean);
+                // Broadcast new lines
+                for (let i = this.lastAuditLine; i < lines.length; i++) {
+                    try {
+                        const entry = JSON.parse(lines[i]);
+                        this.broadcast('audit_entry', entry);
+                    }
+                    catch {
+                        // Ignore parse errors for incomplete lines
+                    }
+                }
+                this.lastAuditLine = lines.length;
+            });
+        }
+        catch (err) {
+            if (err.code === 'ENOSPC') {
+                // Linux inotify limit reached — fall back to polling
+                console.warn('MindForge: inotify limit reached, falling back to 2s polling');
+                setInterval(() => {
+                    const lines = fs.readFileSync(auditPath, 'utf8').split('\n').filter(Boolean);
+                    for (let i = this.lastAuditLine; i < lines.length; i++) {
+                        try {
+                            this.broadcast('audit_entry', JSON.parse(lines[i]));
+                        }
+                        catch { /* ignore */ }
+                    }
+                    this.lastAuditLine = lines.length;
+                }, 2000);
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    /**
+     * Broadcast an event to all connected clients
+     */
+    broadcast(eventType, data) {
+        this.clients.forEach(client => {
+            this.sendEvent(client.response, eventType, data);
+        });
+    }
+    sendEvent(res, type, data) {
+        try {
+            res.write(`event: ${type}\n`);
+            res.write(`data: ${JSON.stringify(data)}\n\n`);
+        }
+        catch {
+            // Client disconnected
+        }
+    }
+    /**
+     * Stop the event stream server
+     */
+    stop() {
+        this.auditWatcher?.close();
+        this.server?.close();
+        this.clients.forEach(c => c.response.end());
+        this.clients = [];
+    }
+}
+exports.MindForgeEventStream = MindForgeEventStream;

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * MindForge SDK — Public API
+ * @module @mindforge/sdk
+ */
+export { MindForgeClient } from './client';
+export { MindForgeEventStream } from './events';
+export { commands } from './commands';
+export { MindForgeMemory } from './memory';
+export type { CommandOptions } from './commands';
+export type { MindForgeConfig, PhaseResult, TaskResult, SecurityFinding, GateResult, HealthReport, HealthIssue, MindForgeEvent, AuditLogEntry, WaveExecutionResult, MigrationResult, } from './types';
+export declare const VERSION = "10.7.0";