@mindexec/cli 0.2.340 → 0.2.342

package/server.js

@@ -1588,8 +1588,15 @@ const CONTENT_TYPE_BY_EXTENSION = new Map([
     ['.mov', 'video/quicktime'],
     ['.m4v', 'video/mp4'],
     ['.pdf', 'application/pdf'],
-    ['.txt', 'text/plain; charset=utf-8'],
-    ['.json', 'application/json; charset=utf-8']
+    ['.js', 'text/javascript; charset=utf-8'],
+    ['.mjs', 'text/javascript; charset=utf-8'],
+    ['.css', 'text/css; charset=utf-8'],
+    ['.html', 'text/html; charset=utf-8'],
+    ['.txt', 'text/plain; charset=utf-8'],
+    ['.json', 'application/json; charset=utf-8'],
+    ['.map', 'application/json; charset=utf-8'],
+    ['.webmanifest', 'application/manifest+json; charset=utf-8'],
+    ['.wasm', 'application/wasm']
 ]);
 
 function detectContentTypeFromHeader(header) {
@@ -2000,6 +2007,47 @@ app.get('/api/assets/resolve', async (req, res) => {
     });
 });
 
+async function trySendPackagedWebAppAsset(req, res, mountPath) {
+    if (!WEB_APP_ROOT || !['GET', 'HEAD'].includes(String(req.method || '').toUpperCase())) {
+        return false;
+    }
+
+    let requestPath = getMountedAssetRequestPath(req, mountPath);
+    try {
+        requestPath = decodeURIComponent(requestPath);
+    } catch {
+        return false;
+    }
+
+    if (!requestPath || requestPath.includes('\0')) {
+        return false;
+    }
+
+    const packagedAssetsRoot = path.resolve(WEB_APP_ROOT, String(mountPath || '').replace(/^\/+/, ''));
+    const packagedAssetPath = path.resolve(packagedAssetsRoot, requestPath);
+    if (!isPathWithin(packagedAssetsRoot, packagedAssetPath)) {
+        return false;
+    }
+
+    let stats = null;
+    try {
+        stats = await fs.stat(packagedAssetPath);
+    } catch {
+        return false;
+    }
+
+    if (!stats.isFile()) {
+        return false;
+    }
+
+    await sendResolvedAssetFile(req, res, packagedAssetPath, {
+        notFoundMessage: 'Web app asset not found',
+        errorScope: 'web',
+        cacheControl: 'public, max-age=31536000, immutable'
+    });
+    return true;
+}
+
 // Static file serving for assets (direct image loading - bypasses base64 encoding)
 // This allows browsers to directly fetch images via http://127.0.0.1:5147/assets/filename.png
 app.use('/assets', async (req, res, next) => {
@@ -2034,11 +2082,15 @@ app.use('/assets', async (req, res, next) => {
             normalizedRequestPath,
             ['.png', '.jpg', '.jpeg', '.webp', '.gif', '.bmp', '.svg', '.mp4', '.webm', '.mov']
         );
-    }
-
-    if (!resolvedPath) {
-        return res.status(404).json({ error: 'Asset not found' });
-    }
+    }
+
+    if (!resolvedPath) {
+        if (await trySendPackagedWebAppAsset(req, res, '/assets')) {
+            return;
+        }
+
+        return res.status(404).json({ error: 'Asset not found' });
+    }
 
     return sendResolvedAssetFile(req, res, resolvedPath, {
         notFoundMessage: 'Asset not found',
@@ -2138,6 +2190,13 @@ const PROTECTED_BRIDGE_ROUTES = [
     { method: 'POST', exact: '/api/dir/delete' },
     { method: 'POST', prefix: '/api/assets/' },
     { method: 'POST', exact: '/api/local-files/register' },
+    { method: 'POST', exact: '/api/evidence/save' },
+    { method: 'POST', exact: '/api/concept/define-composite' },
+    { method: 'GET', exact: '/api/concept/status' },
+    { method: 'GET', exact: '/api/concept/row' },
+    { method: 'GET', exact: '/api/concept/sqlite/row' },
+    { method: 'GET', exact: '/api/concept/embed/readiness' },
+    { method: 'POST', exact: '/api/concept/embed' },
     { method: 'POST', prefix: '/api/browser/act' },
     { method: 'GET', prefix: '/api/company-core/' },
     { method: 'POST', prefix: '/api/company-core/' },
@@ -2661,6 +2720,39 @@ function buildRemoteFrameBinaryPacket(frameEvent) {
     }
 
     const frame = frameEvent.frame || {};
+    const droppedByAgent = Number(frame.droppedByAgent ?? frameEvent.droppedByAgent ?? 0);
+    const dirtyRectSource = frame.dirtyRectCount
+        ?? frame.dirtyRegionCount
+        ?? frameEvent.dirtyRectCount
+        ?? frameEvent.dirtyRegionCount
+        ?? (Array.isArray(frame.dirtyRects) ? frame.dirtyRects.length : undefined)
+        ?? (Array.isArray(frameEvent.dirtyRects) ? frameEvent.dirtyRects.length : undefined)
+        ?? 0;
+    const dirtyRectCount = Number(dirtyRectSource);
+    const dirtyRatioSource = frame.dirtyPixelRatio
+        ?? frame.dirtyRatio
+        ?? frame.dirtyAreaRatio
+        ?? frame.changedPixelRatio
+        ?? frameEvent.dirtyPixelRatio
+        ?? frameEvent.dirtyRatio
+        ?? frameEvent.dirtyAreaRatio
+        ?? frameEvent.changedPixelRatio
+        ?? 0;
+    const dirtyRatioNumber = Number(dirtyRatioSource);
+    const normalizedDirtyPixelRatio = Number.isFinite(dirtyRatioNumber) && dirtyRatioNumber >= 0
+        ? dirtyRatioNumber <= 1
+            ? dirtyRatioNumber
+            : dirtyRatioNumber <= 100
+                ? dirtyRatioNumber / 100
+                : 1
+        : 0;
+    const deltaValue = frame.deltaEncoded ?? frame.isDeltaEncoded ?? frame.deltaFrame
+        ?? frameEvent.deltaEncoded ?? frameEvent.isDeltaEncoded ?? frameEvent.deltaFrame;
+    const deltaEncoded = typeof deltaValue === 'boolean'
+        ? deltaValue
+        : typeof deltaValue === 'number'
+            ? deltaValue > 0
+            : /^(1|true|yes|on|delta)$/i.test(String(deltaValue || '').trim());
     const metadata = {
         type: 'remote.frame.binary',
         kind: frameEvent.kind || 'live',
@@ -2678,7 +2770,16 @@ function buildRemoteFrameBinaryPacket(frameEvent) {
         transport: frame.transport || '',
         contentHash: frame.contentHash || '',
         captureMs: Number(frame.captureMs || 0) || 0,
-        sameContentStreak: Number(frame.sameContentStreak || 0) || 0
+        sameContentStreak: Number(frame.sameContentStreak || 0) || 0,
+        droppedByAgent: Number.isFinite(droppedByAgent) && droppedByAgent >= 0
+            ? Math.round(droppedByAgent)
+            : 0,
+        dirtyRectCount: Number.isFinite(dirtyRectCount) && dirtyRectCount >= 0
+            ? Math.round(dirtyRectCount)
+            : 0,
+        dirtyPixelRatio: normalizedDirtyPixelRatio,
+        codec: String(frame.codec || frame.encoder || frame.encoding || frameEvent.codec || frameEvent.encoder || frameEvent.encoding || '').slice(0, 80),
+        deltaEncoded
     };
     const metaBuffer = Buffer.from(JSON.stringify(metadata), 'utf8');
     const header = Buffer.allocUnsafe(4);
@@ -10958,7 +11059,7 @@ function scoreSearchResult(query, item) {
     return score;
 }
 
-function filterSearchResults(query, items, maxResults) {
+function filterSearchResults(query, items, maxResults) {
     const clampedMax = Math.max(1, Math.min(Number(maxResults) || 5, 8));
     const list = Array.isArray(items) ? items : [];
     if (!requiresSearchRelevanceFilter(query)) {
@@ -10969,10 +11070,29 @@ function filterSearchResults(query, items, maxResults) {
         .map(item => ({ item, score: scoreSearchResult(query, item) }))
         .filter(entry => entry.score > 0)
         .sort((a, b) => b.score - a.score)
-        .map(entry => entry.item)
-        .slice(0, clampedMax);
-}
-async function searchBing(query, maxResults = 5) {
+        .map(entry => entry.item)
+        .slice(0, clampedMax);
+}
+
+function extractDirectSearchUrl(query) {
+    const match = String(query || '').match(/https?:\/\/[^\s"'<>),]+/i);
+    if (!match) {
+        return '';
+    }
+
+    try {
+        const parsed = new URL(match[0]);
+        if (parsed.protocol === 'http:' || parsed.protocol === 'https:') {
+            return parsed.toString();
+        }
+    } catch {
+        return '';
+    }
+
+    return '';
+}
+
+async function searchBing(query, maxResults = 5) {
     const clampedMax = Math.max(1, Math.min(Number(maxResults) || 5, 8));
     const searchQuery = expandSearchQuery(query);
     const url = `https://www.bing.com/search?q=${encodeURIComponent(searchQuery)}`;
@@ -10998,8 +11118,22 @@ async function searchBing(query, maxResults = 5) {
     };
 }
 
-async function searchWeb(query, maxResults = 5) {
+async function searchWeb(query, maxResults = 5) {
     const searchQuery = expandSearchQuery(query);
+    const directUrl = extractDirectSearchUrl(searchQuery);
+    if (directUrl) {
+        return {
+            query: searchQuery,
+            source: 'direct-url',
+            retrievedAt: new Date().toISOString(),
+            items: [{
+                title: 'Direct URL evidence',
+                url: directUrl,
+                snippet: `Direct URL extracted from the WebResearch query: ${directUrl}`
+            }]
+        };
+    }
+
     const providers = [
         ['duckduckgo', searchDuckDuckGo],
         ['brave', searchBrave],
@@ -11034,7 +11168,7 @@ async function searchWeb(query, maxResults = 5) {
     throw error;
 }
 
-async function fetchWebPage(url, maxChars = 12000) {
+async function fetchWebPage(url, maxChars = 12000) {
     let parsedUrl;
     try {
         parsedUrl = new URL(url);
@@ -11083,10 +11217,1104 @@ async function fetchWebPage(url, maxChars = 12000) {
         contentType,
         truncated,
         retrievedAt: new Date().toISOString()
-    };
-}
-
-function parseHtmlAttributes(attrs) {
+    };
+}
+
+function clampEvidenceText(value, maxLength = 4000) {
+    const text = String(value ?? '').replace(/\r\n/g, '\n').replace(/\r/g, '\n').trim();
+    if (!text) {
+        return '';
+    }
+    return text.length <= maxLength ? text : `${text.slice(0, Math.max(0, maxLength - 3)).trimEnd()}...`;
+}
+
+function evidenceArray(value, maxItems = 12, maxItemLength = 500) {
+    const source = Array.isArray(value) ? value : [];
+    const seen = new Set();
+    const items = [];
+    for (const item of source) {
+        const text = clampEvidenceText(item, maxItemLength);
+        const key = text.toLowerCase();
+        if (!text || seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        items.push(text);
+        if (items.length >= maxItems) {
+            break;
+        }
+    }
+    return items;
+}
+
+function slugifyEvidence(value, maxLength = 56) {
+    const slug = String(value || 'evidence')
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .replace(/[^a-zA-Z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .toLowerCase();
+    return (slug || 'evidence').slice(0, maxLength).replace(/-+$/g, '') || 'evidence';
+}
+
+function safeEvidenceDirectory(baseDir, relativeDirectory) {
+    const base = path.resolve(baseDir);
+    const raw = String(relativeDirectory || '').trim();
+    if (!raw) {
+        return base;
+    }
+
+    const safeSegments = raw
+        .replaceAll('\\', '/')
+        .split('/')
+        .map(segment => slugifyEvidence(segment, 40))
+        .filter(Boolean)
+        .slice(0, 4);
+    const target = path.resolve(base, ...safeSegments);
+    if (!isPathWithin(base, target)) {
+        const err = new Error('Evidence directory must stay under the evidence cache.');
+        err.statusCode = 400;
+        throw err;
+    }
+    return target;
+}
+
+function normalizeEvidenceUrl(value) {
+    const text = clampEvidenceText(value, 1200);
+    if (!text) {
+        return '';
+    }
+
+    try {
+        const parsed = new URL(text);
+        if (parsed.protocol === 'http:' || parsed.protocol === 'https:') {
+            return parsed.toString();
+        }
+    } catch {
+        // SourceUrl is optional. Invalid values are ignored instead of persisted.
+    }
+
+    return '';
+}
+
+function normalizeStructuredEvidence(value) {
+    const source = value && typeof value === 'object' ? value : {};
+    const sourceUrl = normalizeEvidenceUrl(source.sourceUrl || source.SourceUrl);
+    const sourcePath = clampEvidenceText(source.sourcePath || source.SourcePath, 1200);
+    return {
+        Schema: clampEvidenceText(source.schema || source.Schema || 'facts', 80) || 'facts',
+        SourceType: clampEvidenceText(source.sourceType || source.SourceType || 'web', 80) || 'web',
+        SourceUrl: sourceUrl || undefined,
+        SourcePath: sourcePath || undefined,
+        Title: clampEvidenceText(source.title || source.Title, 240),
+        Summary: clampEvidenceText(source.summary || source.Summary, 2000),
+        Facts: evidenceArray(source.facts || source.Facts, 16, 600),
+        Dates: evidenceArray(source.dates || source.Dates, 12, 120),
+        Links: evidenceArray(source.links || source.Links, 16, 1200),
+        Prices: evidenceArray(source.prices || source.Prices, 12, 120),
+        CharCount: Math.max(0, Math.min(Number(source.charCount || source.CharCount || 0) || 0, 1000000)),
+        ExtractedAtUtc: clampEvidenceText(source.structuredAt || source.extractedAt || source.ExtractedAtUtc, 80) || new Date().toISOString()
+    };
+}
+
+function normalizeEvidenceMetadata(value, kind, sourceUrl) {
+    const source = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+    const metadata = {};
+    for (const [key, item] of Object.entries(source)) {
+        const safeKey = String(key || '').replace(/[^a-zA-Z0-9_.:-]/g, '').slice(0, 80);
+        const safeValue = clampEvidenceText(item, 500);
+        if (safeKey && safeValue) {
+            metadata[safeKey] = safeValue;
+        }
+    }
+
+    if (!metadata.kind) {
+        metadata.kind = kind;
+    }
+
+    if (sourceUrl) {
+        try {
+            metadata.sourceHost = new URL(sourceUrl).host;
+        } catch {
+            metadata.sourceHost = sourceUrl;
+        }
+    }
+
+    return metadata;
+}
+
+function buildEvidenceResponse(record) {
+    return {
+        success: true,
+        id: record.Id,
+        kind: record.Kind,
+        title: record.Title,
+        query: record.Query,
+        sourceUrl: record.SourceUrl,
+        sourcePath: record.SourcePath,
+        excerpt: record.Excerpt,
+        notes: record.Notes,
+        path: record.Path,
+        sha256: record.Sha256,
+        capturedAt: record.CapturedAtUtc,
+        metadata: record.Metadata,
+        structured: record.Structured
+    };
+}
+
+async function saveEvidenceRecord(request = {}) {
+    const capturedAt = new Date();
+    const structured = normalizeStructuredEvidence(request.structured || request.Structured);
+    const kind = clampEvidenceText(request.kind || request.Kind || 'evidence', 120) || 'evidence';
+    const sourceUrl = normalizeEvidenceUrl(request.sourceUrl || request.SourceUrl) || structured.SourceUrl || '';
+    const title = clampEvidenceText(request.title || request.Title || structured.Title || request.query || request.Query || sourceUrl || kind, 240);
+    const query = clampEvidenceText(request.query || request.Query, 500);
+    const sourcePath = clampEvidenceText(request.sourcePath || request.SourcePath || structured.SourcePath, 1200);
+    const excerpt = clampEvidenceText(request.excerpt || request.Excerpt || structured.Summary, 2400);
+    const notes = clampEvidenceText(request.notes || request.Notes, 2000);
+    const metadata = normalizeEvidenceMetadata(request.metadata || request.Metadata, kind, sourceUrl);
+    const baseEvidenceDir = path.join(getAiPath(), 'external', 'evidence');
+    const targetDir = safeEvidenceDirectory(baseEvidenceDir, request.relativeDirectory || request.RelativeDirectory);
+    const slugSource = title || query || sourceUrl || sourcePath || kind || 'evidence';
+    const fileName = `${capturedAt.toISOString().replace(/[-:]/g, '').replace(/\.\d{3}Z$/, 'Z')}-${slugifyEvidence(slugSource)}.json`;
+    const fullPath = path.resolve(targetDir, fileName);
+    if (!isPathWithin(baseEvidenceDir, fullPath)) {
+        const err = new Error('Evidence path must stay under the evidence cache.');
+        err.statusCode = 400;
+        throw err;
+    }
+
+    const relativePath = normalizePathForClient(path.relative(workspacePath, fullPath));
+    const id = `evidence-${capturedAt.toISOString().replace(/[-:T.]/g, '').slice(0, 14)}-${crypto.randomUUID().replace(/-/g, '').slice(0, 8)}`;
+    const record = {
+        Id: id,
+        Kind: kind,
+        Title: title,
+        Query: query || undefined,
+        SourceUrl: sourceUrl || undefined,
+        SourcePath: sourcePath || undefined,
+        Excerpt: excerpt,
+        Notes: notes || undefined,
+        CapturedAtUtc: capturedAt.toISOString(),
+        Structured: structured,
+        Metadata: metadata,
+        Path: relativePath
+    };
+
+    const unsignedJson = JSON.stringify(record, null, 2);
+    record.Sha256 = crypto.createHash('sha256').update(unsignedJson, 'utf8').digest('hex');
+    const finalJson = `${JSON.stringify(record, null, 2)}\n`;
+    await writeFileAtomically(fullPath, finalJson, 'utf8');
+    return record;
+}
+
+const CONCEPT_HASH_ALGORITHM = 'xxHash64(seed=0, utf8-trim)';
+const CONCEPT_EMBEDDING_MODEL = 'local-xxhash64-preview-16';
+const CONCEPT_EMBED_LIVE_CONFIRM_VALUE = 'I_UNDERSTAND_THIS_CALLS_EMBEDDING_PROVIDER';
+const CONCEPT_U64_MASK = (1n << 64n) - 1n;
+const CONCEPT_I64_MAX = (1n << 63n) - 1n;
+const CONCEPT_U64_SIZE = 1n << 64n;
+const CONCEPT_PRIME64_1 = 11400714785074694791n;
+const CONCEPT_PRIME64_2 = 14029467366897019727n;
+const CONCEPT_PRIME64_3 = 1609587929392839161n;
+const CONCEPT_PRIME64_4 = 9650029242287828579n;
+const CONCEPT_PRIME64_5 = 2870177450012600261n;
+let nodeSqliteModulePromise = null;
+
+function conceptU64(value) {
+    return BigInt.asUintN(64, value);
+}
+
+function conceptRotateLeft(value, count) {
+    const shift = BigInt(count);
+    return conceptU64((conceptU64(value) << shift) | (conceptU64(value) >> (64n - shift)));
+}
+
+function conceptReadUInt32LE(data, offset) {
+    return Number(data[offset])
+        | (Number(data[offset + 1]) << 8)
+        | (Number(data[offset + 2]) << 16)
+        | (Number(data[offset + 3]) << 24);
+}
+
+function conceptReadUInt64LE(data, offset) {
+    let value = 0n;
+    for (let index = 0; index < 8; index += 1) {
+        value |= BigInt(data[offset + index]) << BigInt(index * 8);
+    }
+    return conceptU64(value);
+}
+
+function conceptXxHash64Round(acc, input) {
+    let value = conceptU64(acc + conceptU64(input * CONCEPT_PRIME64_2));
+    value = conceptRotateLeft(value, 31);
+    return conceptU64(value * CONCEPT_PRIME64_1);
+}
+
+function conceptXxHash64MergeRound(acc, value) {
+    let next = conceptU64(acc ^ conceptXxHash64Round(0n, value));
+    next = conceptU64(next * CONCEPT_PRIME64_1 + CONCEPT_PRIME64_4);
+    return next;
+}
+
+function conceptXxHash64(bytes, seed = 0n) {
+    const data = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes || []);
+    const len = data.length;
+    let index = 0;
+    let h64;
+
+    if (len >= 32) {
+        let v1 = conceptU64(seed + CONCEPT_PRIME64_1 + CONCEPT_PRIME64_2);
+        let v2 = conceptU64(seed + CONCEPT_PRIME64_2);
+        let v3 = conceptU64(seed);
+        let v4 = conceptU64(seed - CONCEPT_PRIME64_1);
+        const limit = len - 32;
+        while (index <= limit) {
+            v1 = conceptXxHash64Round(v1, conceptReadUInt64LE(data, index)); index += 8;
+            v2 = conceptXxHash64Round(v2, conceptReadUInt64LE(data, index)); index += 8;
+            v3 = conceptXxHash64Round(v3, conceptReadUInt64LE(data, index)); index += 8;
+            v4 = conceptXxHash64Round(v4, conceptReadUInt64LE(data, index)); index += 8;
+        }
+        h64 = conceptU64(
+            conceptRotateLeft(v1, 1)
+            + conceptRotateLeft(v2, 7)
+            + conceptRotateLeft(v3, 12)
+            + conceptRotateLeft(v4, 18)
+        );
+        h64 = conceptXxHash64MergeRound(h64, v1);
+        h64 = conceptXxHash64MergeRound(h64, v2);
+        h64 = conceptXxHash64MergeRound(h64, v3);
+        h64 = conceptXxHash64MergeRound(h64, v4);
+    } else {
+        h64 = conceptU64(seed + CONCEPT_PRIME64_5);
+    }
+
+    h64 = conceptU64(h64 + BigInt(len));
+    while (index <= len - 8) {
+        const k1 = conceptXxHash64Round(0n, conceptReadUInt64LE(data, index));
+        h64 = conceptU64(h64 ^ k1);
+        h64 = conceptU64(conceptRotateLeft(h64, 27) * CONCEPT_PRIME64_1 + CONCEPT_PRIME64_4);
+        index += 8;
+    }
+    if (index <= len - 4) {
+        h64 = conceptU64(h64 ^ (BigInt(conceptReadUInt32LE(data, index) >>> 0) * CONCEPT_PRIME64_1));
+        h64 = conceptU64(conceptRotateLeft(h64, 23) * CONCEPT_PRIME64_2 + CONCEPT_PRIME64_3);
+        index += 4;
+    }
+    while (index < len) {
+        h64 = conceptU64(h64 ^ (BigInt(data[index]) * CONCEPT_PRIME64_5));
+        h64 = conceptU64(conceptRotateLeft(h64, 11) * CONCEPT_PRIME64_1);
+        index += 1;
+    }
+
+    h64 = conceptU64(h64 ^ (h64 >> 33n));
+    h64 = conceptU64(h64 * CONCEPT_PRIME64_2);
+    h64 = conceptU64(h64 ^ (h64 >> 29n));
+    h64 = conceptU64(h64 * CONCEPT_PRIME64_3);
+    h64 = conceptU64(h64 ^ (h64 >> 32n));
+    return h64 & CONCEPT_U64_MASK;
+}
+
+function conceptHash64Hex(signature) {
+    const clean = String(signature || '').trim();
+    if (!clean) {
+        const err = new Error('signature is required');
+        err.statusCode = 400;
+        throw err;
+    }
+    return `0x${conceptXxHash64(Buffer.from(clean, 'utf8')).toString(16).padStart(16, '0')}`;
+}
+
+function normalizeConceptHex64(value, field = 'id') {
+    const text = String(value || '').trim().toLowerCase();
+    if (!/^0x[0-9a-f]{16}$/.test(text)) {
+        const err = new Error(`${field} must be 0x[0-9a-f]{16}`);
+        err.statusCode = 400;
+        throw err;
+    }
+    return text;
+}
+
+function conceptSqlKeyString(hex64) {
+    const unsigned = BigInt(hex64);
+    return unsigned > CONCEPT_I64_MAX
+        ? (unsigned - CONCEPT_U64_SIZE).toString()
+        : unsigned.toString();
+}
+
+async function loadNodeSqliteModule() {
+    if (!nodeSqliteModulePromise) {
+        nodeSqliteModulePromise = import('node:sqlite').catch(err => {
+            nodeSqliteModulePromise = null;
+            throw err;
+        });
+    }
+    return nodeSqliteModulePromise;
+}
+
+function normalizeConceptSequence(ir) {
+    const text = String(ir || '').replace(/\r\n/g, '\n').replace(/\r/g, '\n').trim();
+    if (!text) {
+        const err = new Error('ir is required');
+        err.statusCode = 400;
+        throw err;
+    }
+    if (text.length > 240000) {
+        const err = new Error('ir is too large');
+        err.statusCode = 413;
+        throw err;
+    }
+
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    } catch (parseErr) {
+        const err = new Error(`ir must be valid ConceptSequence JSON: ${parseErr?.message || parseErr}`);
+        err.statusCode = 400;
+        throw err;
+    }
+    const literals = Array.isArray(parsed?.literals) ? parsed.literals : [];
+    const instructions = Array.isArray(parsed?.instructions) ? parsed.instructions : [];
+    if (instructions.length === 0) {
+        const err = new Error('ir must include a non-empty instructions array');
+        err.statusCode = 400;
+        throw err;
+    }
+    return { body: text, literals, instructions };
+}
+
+function deterministicConceptVector(signature, description, dimensions = 16) {
+    const size = Math.max(4, Math.min(64, Math.trunc(Number(dimensions) || 16)));
+    const input = `${signature}\n\nDescription: ${description || ''}`;
+    return Array.from({ length: size }, (_, index) => {
+        const hash = BigInt(conceptHash64Hex(`${input}#${index}`));
+        const normalized = Number(hash & 0xffffn) / 32767.5 - 1;
+        return Number(normalized.toFixed(6));
+    });
+}
+
+function serializeConceptFloatVectorBase64(vector) {
+    const values = Array.isArray(vector) ? vector : [];
+    const buffer = Buffer.alloc(values.length * 4);
+    values.forEach((value, index) => {
+        buffer.writeFloatLE(Number(value) || 0, index * 4);
+    });
+    return buffer.toString('base64');
+}
+
+async function readJsonIfExists(filePath, fallback) {
+    try {
+        const content = await fs.readFile(filePath, 'utf8');
+        return JSON.parse(content);
+    } catch (err) {
+        if (err?.code === 'ENOENT') {
+            return fallback;
+        }
+        throw err;
+    }
+}
+
+function normalizeNullableConceptText(value) {
+    const text = String(value ?? '').trim();
+    return text ? text : null;
+}
+
+function conceptEmbeddingBlobFromBase64(base64) {
+    const text = String(base64 || '').trim();
+    if (!text) return null;
+    return Buffer.from(text, 'base64');
+}
+
+function conceptSqliteRowFromRecord(record) {
+    const concept = record?.Concept || {};
+    const sqlKey = String(concept.SqlKey || conceptSqlKeyString(normalizeConceptHex64(concept.Id, 'id'))).trim();
+    return {
+        id: BigInt(sqlKey),
+        idText: sqlKey,
+        signature: String(concept.Signature || ''),
+        body: normalizeNullableConceptText(concept.Body),
+        category: normalizeNullableConceptText(concept.Category),
+        conceptType: normalizeNullableConceptText(concept.ConceptType),
+        createdUtc: normalizeNullableConceptText(concept.CreatedUtc),
+        updatedUtc: normalizeNullableConceptText(concept.UpdatedUtc),
+        description: normalizeNullableConceptText(concept.Description),
+        embedding: conceptEmbeddingBlobFromBase64(concept.EmbeddingBase64),
+        embeddingModel: normalizeNullableConceptText(concept.EmbeddingModel),
+        embeddingUpdatedUtc: normalizeNullableConceptText(concept.EmbeddingUpdatedUtc)
+    };
+}
+
+function initializeConceptSqliteDatabase(db) {
+    db.exec(`
+PRAGMA journal_mode=WAL;
+PRAGMA synchronous=NORMAL;
+PRAGMA temp_store=MEMORY;
+CREATE TABLE IF NOT EXISTS tbl_concepts (
+  id INTEGER PRIMARY KEY,
+  signature TEXT NOT NULL,
+  body TEXT NULL,
+  category TEXT NULL,
+  concept_type TEXT NULL,
+  created_utc TEXT NULL,
+  updated_utc TEXT NULL,
+  description TEXT NULL,
+  embedding BLOB NULL,
+  embedding_model TEXT NULL,
+  embedding_updated_utc TEXT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_tbl_concepts_category ON tbl_concepts(category);
+`);
+}
+
+function bindConceptSqliteReadBigInts(statement) {
+    if (typeof statement?.setReadBigInts === 'function') {
+        statement.setReadBigInts(true);
+    }
+    return statement;
+}
+
+function normalizeConceptSqliteRow(row, sqlitePath) {
+    if (!row) return null;
+    const embedding = row.embedding ? Buffer.from(row.embedding) : null;
+    const idValue = typeof row.id === 'bigint' ? row.id : BigInt(row.id);
+    const hex = `0x${BigInt.asUintN(64, idValue).toString(16).padStart(16, '0')}`;
+    return {
+        success: true,
+        provider: 'LocalBridgeNativeSQLiteConceptStore',
+        adapterState: 'native-sqlite',
+        originalTable: 'tbl_concepts',
+        sqlitePath,
+        id: hex,
+        sqlKey: idValue.toString(),
+        signature: row.signature || '',
+        body: row.body || null,
+        category: row.category || '',
+        conceptType: row.concept_type || null,
+        createdAt: row.created_utc || null,
+        updatedAt: row.updated_utc || null,
+        description: row.description || null,
+        embeddingBase64: embedding ? embedding.toString('base64') : null,
+        embeddingBytes: embedding ? embedding.length : 0,
+        embeddingModel: row.embedding_model || null,
+        embeddingUpdatedAt: row.embedding_updated_utc || null
+    };
+}
+
+function buildConceptCompositeResponse(record) {
+    return {
+        success: true,
+        id: record.Concept.Id,
+        sqlKey: record.Concept.SqlKey,
+        signature: record.Concept.Signature,
+        category: record.Concept.Category,
+        conceptType: record.Concept.ConceptType,
+        path: record.Path,
+        indexPath: record.IndexPath,
+        sha256: record.Sha256,
+        hashAlgorithm: record.HashAlgorithm,
+        embeddingModel: record.Concept.EmbeddingModel,
+        embeddingVector: record.Concept.EmbeddingVector,
+        embeddingBase64: record.Concept.EmbeddingBase64,
+        nativeSqlite: record.NativeSqlite || null,
+        updatedAt: record.Concept.UpdatedUtc
+    };
+}
+
+async function saveConceptCompositeRecord(request = {}) {
+    const nowUtc = new Date().toISOString();
+    const signature = clampEvidenceText(request.signature || request.Signature, 500);
+    const id = normalizeConceptHex64(request.id || request.Id || conceptHash64Hex(signature), 'id');
+    const derivedId = conceptHash64Hex(signature);
+    if (id !== derivedId) {
+        const err = new Error(`signature does not match id. signature->id=${derivedId}, id=${id}`);
+        err.statusCode = 400;
+        throw err;
+    }
+
+    const sequence = normalizeConceptSequence(request.ir || request.IR || request.body || request.Body);
+    const description = clampEvidenceText(request.description || request.Description, 2400);
+    const category = clampEvidenceText(request.category || request.Category || 'Composite.Dynamic', 160) || 'Composite.Dynamic';
+    const conceptType = clampEvidenceText(request.conceptType || request.ConceptType || 'Axiom', 80) || 'Axiom';
+    const vector = deterministicConceptVector(signature, description, request.embeddingDimensions || request.EmbeddingDimensions || 16);
+    const baseConceptDir = path.resolve(getAiPath(), 'concepts');
+    const rowDir = path.resolve(baseConceptDir, 'rows');
+    const fileName = `${id.slice(2)}-${slugifyEvidence(signature, 64)}.json`;
+    const fullPath = path.resolve(rowDir, fileName);
+    const indexPath = path.resolve(baseConceptDir, 'tbl_concepts.rows.json');
+
+    if (!isPathWithin(baseConceptDir, fullPath) || !isPathWithin(baseConceptDir, indexPath)) {
+        const err = new Error('Concept path must stay under the concept cache.');
+        err.statusCode = 400;
+        throw err;
+    }
+
+    const relativePath = normalizePathForClient(path.relative(workspacePath, fullPath));
+    const relativeIndexPath = normalizePathForClient(path.relative(workspacePath, indexPath));
+    const conceptRow = {
+        Id: id,
+        SqlKey: conceptSqlKeyString(id),
+        Signature: signature,
+        Body: sequence.body,
+        Category: category,
+        ConceptType: conceptType,
+        CreatedUtc: nowUtc,
+        UpdatedUtc: nowUtc,
+        Description: description || undefined,
+        EmbeddingVector: vector,
+        EmbeddingBase64: serializeConceptFloatVectorBase64(vector),
+        EmbeddingModel: CONCEPT_EMBEDDING_MODEL,
+        EmbeddingUpdatedUtc: nowUtc,
+        AtomCount: sequence.instructions.length,
+        LiteralCount: sequence.literals.length
+    };
+    const record = {
+        Schema: 'MindExecution.Kernel.Store.ConceptConcept/v1',
+        Store: {
+            Provider: 'LocalBridgeJsonConceptStore',
+            OriginalTable: 'tbl_concepts',
+            Notes: 'JSON row projection for local React parity; LocalBridge also mirrors the row into native SQLite tbl_concepts.'
+        },
+        HashAlgorithm: CONCEPT_HASH_ALGORITHM,
+        Concept: conceptRow,
+        Path: relativePath,
+        IndexPath: relativeIndexPath
+    };
+
+    const unsignedJson = JSON.stringify(record, null, 2);
+    record.Sha256 = crypto.createHash('sha256').update(unsignedJson, 'utf8').digest('hex');
+    await writeFileAtomically(fullPath, `${JSON.stringify(record, null, 2)}\n`, 'utf8');
+
+    const currentIndex = await readJsonIfExists(indexPath, {
+        Schema: 'MindExecution.Kernel.Store.ConceptConceptIndex/v1',
+        Store: 'LocalBridgeJsonConceptStore',
+        HashAlgorithm: CONCEPT_HASH_ALGORITHM,
+        Rows: []
+    });
+    const rows = Array.isArray(currentIndex.Rows) ? currentIndex.Rows : [];
+    const nextRows = [
+        {
+            Id: conceptRow.Id,
+            SqlKey: conceptRow.SqlKey,
+            Signature: conceptRow.Signature,
+            Category: conceptRow.Category,
+            ConceptType: conceptRow.ConceptType,
+            UpdatedUtc: conceptRow.UpdatedUtc,
+            AtomCount: conceptRow.AtomCount,
+            LiteralCount: conceptRow.LiteralCount,
+            Path: relativePath,
+            Sha256: record.Sha256
+        },
+        ...rows.filter(row => String(row?.Id || '').toLowerCase() !== conceptRow.Id)
+    ].slice(0, 512);
+
+    const nextIndex = {
+        Schema: 'MindExecution.Kernel.Store.ConceptConceptIndex/v1',
+        Store: 'LocalBridgeJsonConceptStore',
+        HashAlgorithm: CONCEPT_HASH_ALGORITHM,
+        UpdatedUtc: nowUtc,
+        RowCount: nextRows.length,
+        Rows: nextRows
+    };
+    await writeFileAtomically(indexPath, `${JSON.stringify(nextIndex, null, 2)}\n`, 'utf8');
+    record.NativeSqlite = await upsertConceptNativeSqlite(record);
+    return record;
+}
+
+function getConceptStorePaths() {
+    const baseConceptDir = path.resolve(getAiPath(), 'concepts');
+    const rowDir = path.resolve(baseConceptDir, 'rows');
+    const indexPath = path.resolve(baseConceptDir, 'tbl_concepts.rows.json');
+    const sqlitePath = path.resolve(baseConceptDir, 'mind_concepts.db');
+    return { baseConceptDir, rowDir, indexPath, sqlitePath };
+}
+
+async function upsertConceptNativeSqlite(record) {
+    const { DatabaseSync } = await loadNodeSqliteModule();
+    const { baseConceptDir, sqlitePath } = getConceptStorePaths();
+    if (!isPathWithin(baseConceptDir, sqlitePath)) {
+        const err = new Error('Concept SQLite path must stay under the concept cache.');
+        err.statusCode = 400;
+        throw err;
+    }
+
+    await fs.mkdir(baseConceptDir, { recursive: true });
+    const sqliteRow = conceptSqliteRowFromRecord(record);
+    const db = new DatabaseSync(sqlitePath, { readOnly: false });
+    try {
+        initializeConceptSqliteDatabase(db);
+        db.exec('BEGIN IMMEDIATE;');
+        try {
+            db.prepare(`
+INSERT INTO tbl_concepts (id, signature, body, category, concept_type, created_utc, updated_utc, description, embedding, embedding_model, embedding_updated_utc)
+VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+ON CONFLICT(id) DO UPDATE SET
+  signature=excluded.signature,
+  body=excluded.body,
+  category=excluded.category,
+  concept_type=excluded.concept_type,
+  created_utc=excluded.created_utc,
+  updated_utc=excluded.updated_utc,
+  description=excluded.description,
+  embedding=excluded.embedding,
+  embedding_model=excluded.embedding_model,
+  embedding_updated_utc=excluded.embedding_updated_utc;
+`).run(
+                sqliteRow.id,
+                sqliteRow.signature,
+                sqliteRow.body,
+                sqliteRow.category,
+                sqliteRow.conceptType,
+                sqliteRow.createdUtc,
+                sqliteRow.updatedUtc,
+                sqliteRow.description,
+                sqliteRow.embedding,
+                sqliteRow.embeddingModel,
+                sqliteRow.embeddingUpdatedUtc
+            );
+            db.exec('COMMIT;');
+        } catch (err) {
+            try { db.exec('ROLLBACK;'); } catch {}
+            throw err;
+        }
+
+        const countRow = db.prepare('SELECT COUNT(*) AS row_count FROM tbl_concepts;').get();
+        const relativeSqlitePath = normalizePathForClient(path.relative(workspacePath, sqlitePath));
+        return {
+            success: true,
+            provider: 'LocalBridgeNativeSQLiteConceptStore',
+            adapterState: 'native-sqlite',
+            originalTable: 'tbl_concepts',
+            sqlitePath: relativeSqlitePath,
+            rowCount: Number(countRow?.row_count || 0),
+            lastSqlKey: sqliteRow.idText,
+            lastId: record?.Concept?.Id || null
+        };
+    } finally {
+        db.close();
+    }
+}
+
+async function readConceptNativeSqliteRowById(id) {
+    const normalizedId = normalizeConceptHex64(id, 'id');
+    const { DatabaseSync } = await loadNodeSqliteModule();
+    const { baseConceptDir, sqlitePath } = getConceptStorePaths();
+    if (!isPathWithin(baseConceptDir, sqlitePath)) {
+        const err = new Error('Concept SQLite path must stay under the concept cache.');
+        err.statusCode = 400;
+        throw err;
+    }
+
+    try {
+        await fs.access(sqlitePath);
+    } catch {
+        const err = new Error('Concept native SQLite database has not been created yet.');
+        err.statusCode = 404;
+        throw err;
+    }
+
+    const db = new DatabaseSync(sqlitePath, { readOnly: true });
+    try {
+        const sqlKey = BigInt(conceptSqlKeyString(normalizedId));
+        const statement = bindConceptSqliteReadBigInts(db.prepare(`
+SELECT id, signature, body, category, concept_type, created_utc, updated_utc, description, embedding, embedding_model, embedding_updated_utc
+FROM tbl_concepts
+WHERE id = ?
+LIMIT 1;
+`));
+        const row = statement.get(sqlKey);
+        if (!row) {
+            const err = new Error(`Concept SQLite row not found: ${normalizedId}`);
+            err.statusCode = 404;
+            throw err;
+        }
+        const relativeSqlitePath = normalizePathForClient(path.relative(workspacePath, sqlitePath));
+        return normalizeConceptSqliteRow(row, relativeSqlitePath);
+    } finally {
+        db.close();
+    }
+}
+
+async function readConceptStoreIndex() {
+    const { baseConceptDir, indexPath } = getConceptStorePaths();
+    if (!isPathWithin(baseConceptDir, indexPath)) {
+        const err = new Error('Concept index path must stay under the concept cache.');
+        err.statusCode = 400;
+        throw err;
+    }
+
+    const fallback = {
+        Schema: 'MindExecution.Kernel.Store.ConceptConceptIndex/v1',
+        Store: 'LocalBridgeJsonConceptStore',
+        HashAlgorithm: CONCEPT_HASH_ALGORITHM,
+        UpdatedUtc: null,
+        RowCount: 0,
+        Rows: []
+    };
+    const index = await readJsonIfExists(indexPath, fallback);
+    const rows = Array.isArray(index.Rows) ? index.Rows : [];
+    return {
+        ...fallback,
+        ...index,
+        Rows: rows,
+        RowCount: Number.isFinite(Number(index.RowCount)) ? Number(index.RowCount) : rows.length,
+        Path: normalizePathForClient(path.relative(workspacePath, indexPath))
+    };
+}
+
+async function readConceptNativeSqliteStatus() {
+    const { baseConceptDir, sqlitePath } = getConceptStorePaths();
+    const relativeSqlitePath = normalizePathForClient(path.relative(workspacePath, sqlitePath));
+    try {
+        const { DatabaseSync } = await loadNodeSqliteModule();
+        await fs.access(sqlitePath);
+        const db = new DatabaseSync(sqlitePath, { readOnly: true });
+        try {
+            const tableRows = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='tbl_concepts' LIMIT 1;").all();
+            const hasTable = tableRows.length > 0;
+            const rowCount = hasTable ? Number(db.prepare('SELECT COUNT(*) AS row_count FROM tbl_concepts;').get()?.row_count || 0) : 0;
+            const columnRows = hasTable ? db.prepare('PRAGMA table_info(tbl_concepts);').all() : [];
+            return {
+                success: true,
+                provider: 'LocalBridgeNativeSQLiteConceptStore',
+                adapterState: hasTable ? 'native-sqlite' : 'native-sqlite-pending',
+                originalTable: 'tbl_concepts',
+                sqlitePath: relativeSqlitePath,
+                rowCount,
+                hasTable,
+                columns: columnRows.map(row => String(row.name || '')).filter(Boolean)
+            };
+        } finally {
+            db.close();
+        }
+    } catch (err) {
+        if (err?.code === 'ENOENT') {
+            return {
+                success: true,
+                provider: 'LocalBridgeNativeSQLiteConceptStore',
+                adapterState: 'native-sqlite-pending',
+                originalTable: 'tbl_concepts',
+                sqlitePath: relativeSqlitePath,
+                rowCount: 0,
+                hasTable: false,
+                columns: []
+            };
+        }
+        return {
+            success: false,
+            provider: 'LocalBridgeNativeSQLiteConceptStore',
+            adapterState: 'native-sqlite-error',
+            originalTable: 'tbl_concepts',
+            sqlitePath: relativeSqlitePath,
+            rowCount: 0,
+            hasTable: false,
+            columns: [],
+            error: err?.message || String(err)
+        };
+    }
+}
+
+function buildConceptStoreStatusResponse(index, nativeSqlite = null) {
+    const rows = Array.isArray(index.Rows) ? index.Rows : [];
+    return {
+        success: true,
+        provider: 'LocalBridgeJsonConceptStore',
+        adapterState: 'json-row-projection',
+        originalTable: 'tbl_concepts',
+        schema: index.Schema || 'MindExecution.Kernel.Store.ConceptConceptIndex/v1',
+        hashAlgorithm: index.HashAlgorithm || CONCEPT_HASH_ALGORITHM,
+        embeddingModel: CONCEPT_EMBEDDING_MODEL,
+        rowCount: rows.length,
+        indexPath: index.Path,
+        updatedAt: index.UpdatedUtc || null,
+        latestRows: rows.slice(0, 12).map(row => ({
+            id: row.Id,
+            sqlKey: row.SqlKey,
+            signature: row.Signature,
+            category: row.Category,
+            conceptType: row.ConceptType,
+            atomCount: row.AtomCount,
+            literalCount: row.LiteralCount,
+            path: row.Path,
+            sha256: row.Sha256,
+            updatedAt: row.UpdatedUtc
+        })),
+        sqliteReadyColumns: [
+            'Id',
+            'SqlKey',
+            'Signature',
+            'Body',
+            'Category',
+            'ConceptType',
+            'Description',
+            'EmbeddingVector',
+            'EmbeddingBase64',
+            'EmbeddingModel',
+            'AtomCount',
+            'LiteralCount',
+            'CreatedUtc',
+            'UpdatedUtc'
+        ],
+        paidEmbeddingAdapterState: 'adapter-gated',
+        nativeSqliteAdapterState: nativeSqlite?.adapterState || 'native-sqlite-pending',
+        nativeSqlite
+    };
+}
+
+async function readConceptCompositeRecordById(id) {
+    const normalizedId = normalizeConceptHex64(id, 'id');
+    const index = await readConceptStoreIndex();
+    const row = (Array.isArray(index.Rows) ? index.Rows : []).find(item => String(item?.Id || '').toLowerCase() === normalizedId);
+    if (!row?.Path) {
+        const err = new Error(`Concept row not found: ${normalizedId}`);
+        err.statusCode = 404;
+        throw err;
+    }
+
+    const fullPath = path.resolve(workspacePath, String(row.Path));
+    const { baseConceptDir } = getConceptStorePaths();
+    if (!isPathWithin(baseConceptDir, fullPath)) {
+        const err = new Error('Concept row path must stay under the concept cache.');
+        err.statusCode = 400;
+        throw err;
+    }
+
+    const record = JSON.parse(await fs.readFile(fullPath, 'utf8'));
+    if (String(record?.Concept?.Id || '').toLowerCase() !== normalizedId) {
+        const err = new Error(`Concept row id mismatch: expected ${normalizedId}`);
+        err.statusCode = 409;
+        throw err;
+    }
+    return record;
+}
+
+function getConceptEmbeddingProviderConfig() {
+    const baseUrl = String(
+        process.env.MINDEXEC_CONCEPT_EMBED_BASE_URL
+        || process.env.OPENAI_BASE_URL
+        || process.env.OPENROUTER_BASE_URL
+        || 'https://api.openai.com/v1'
+    ).trim().replace(/\/+$/, '');
+    const model = String(
+        process.env.MINDEXEC_CONCEPT_EMBED_MODEL
+        || process.env.OPENAI_EMBEDDING_MODEL
+        || 'text-embedding-3-small'
+    ).trim();
+    const apiKey = String(
+        process.env.MINDEXEC_CONCEPT_EMBED_API_KEY
+        || process.env.OPENAI_API_KEY
+        || process.env.OPENROUTER_API_KEY
+        || ''
+    ).trim();
+    const confirm = String(process.env.MINDEXEC_CONCEPT_EMBED_LIVE_CONFIRM || '').trim();
+    return {
+        baseUrl,
+        model,
+        apiKey,
+        hasApiKey: Boolean(apiKey) && !apiKey.includes('__PUT_YOUR_KEY_HERE__'),
+        confirm,
+        confirmed: confirm === CONCEPT_EMBED_LIVE_CONFIRM_VALUE
+    };
+}
+
+function buildConceptEmbeddingReadinessResponse() {
+    const config = getConceptEmbeddingProviderConfig();
+    const url = new URL(`${config.baseUrl}/embeddings`);
+    return {
+        success: true,
+        provider: 'OpenAI-compatible embeddings',
+        adapterState: config.confirmed && config.hasApiKey ? 'available-opt-in' : 'adapter-gated',
+        confirmationEnv: 'MINDEXEC_CONCEPT_EMBED_LIVE_CONFIRM',
+        requiredConfirmation: CONCEPT_EMBED_LIVE_CONFIRM_VALUE,
+        confirmationState: config.confirmed ? 'confirmed' : 'missing',
+        apiKeyState: config.hasApiKey ? 'present' : 'missing',
+        baseUrlHost: url.host,
+        endpointPath: url.pathname,
+        model: config.model,
+        inputPolicy: 'signature + "\\n\\nDescription: " + description',
+        storesEmbeddingBase64: true,
+        defaultRunMode: 'blocked-until-confirmed'
+    };
+}
+
+function normalizeConceptEmbeddingRequest(request = {}) {
+    const signature = clampEvidenceText(request.signature || request.Signature, 500);
+    const description = clampEvidenceText(request.description || request.Description, 2400);
+    if (!signature.trim()) {
+        const err = new Error('signature is required');
+        err.statusCode = 400;
+        throw err;
+    }
+    if (!description.trim()) {
+        const err = new Error('description is required');
+        err.statusCode = 400;
+        throw err;
+    }
+    return {
+        signature: signature.trim(),
+        description: description.trim(),
+        category: clampEvidenceText(request.category || request.Category || '', 160),
+        conceptType: clampEvidenceText(request.conceptType || request.ConceptType || 'Axiom', 80) || 'Axiom'
+    };
+}
+
+async function callConceptEmbeddingProvider(input, config) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 45000);
+    try {
+        const response = await fetch(`${config.baseUrl}/embeddings`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${config.apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ model: config.model, input }),
+            signal: controller.signal
+        });
+        const text = await response.text();
+        if (!response.ok) {
+            const err = new Error(`OpenAI-compatible embeddings error ${response.status}: ${text.slice(0, 500)}`);
+            err.statusCode = 502;
+            throw err;
+        }
+        let payload;
+        try {
+            payload = text ? JSON.parse(text) : {};
+        } catch (parseErr) {
+            const err = new Error(`Embedding provider returned invalid JSON: ${parseErr?.message || parseErr}`);
+            err.statusCode = 502;
+            throw err;
+        }
+        const embedding = payload?.data?.[0]?.embedding;
+        if (!Array.isArray(embedding) || embedding.length === 0) {
+            const err = new Error('Embedding provider returned an empty embedding.');
+            err.statusCode = 502;
+            throw err;
+        }
+        if (embedding.length > 16384) {
+            const err = new Error(`Embedding vector too large: ${embedding.length}`);
+            err.statusCode = 413;
+            throw err;
+        }
+        return embedding.map(value => Number(value) || 0);
+    } finally {
+        clearTimeout(timeout);
+    }
+}
+
+async function upsertConceptEmbeddingRecord(request = {}) {
+    const normalized = normalizeConceptEmbeddingRequest(request);
+    const config = getConceptEmbeddingProviderConfig();
+    if (!config.confirmed) {
+        const err = new Error(`Embedding provider calls require MINDEXEC_CONCEPT_EMBED_LIVE_CONFIRM=${CONCEPT_EMBED_LIVE_CONFIRM_VALUE}`);
+        err.statusCode = 403;
+        throw err;
+    }
+    if (!config.hasApiKey) {
+        const err = new Error('Embedding provider API key is missing from server environment.');
+        err.statusCode = 403;
+        throw err;
+    }
+
+    const id = conceptHash64Hex(normalized.signature);
+    let existing = null;
+    try {
+        existing = await readConceptCompositeRecordById(id);
+    } catch (err) {
+        if (Number(err?.statusCode) !== 404) throw err;
+    }
+
+    const input = `${normalized.signature}\n\nDescription: ${normalized.description}`;
+    const vector = await callConceptEmbeddingProvider(input, config);
+    const nowUtc = new Date().toISOString();
+    const { baseConceptDir, rowDir, indexPath } = getConceptStorePaths();
+    const fileName = existing?.Path
+        ? path.basename(existing.Path)
+        : `${id.slice(2)}-${slugifyEvidence(normalized.signature, 64)}.json`;
+    const fullPath = existing?.Path
+        ? path.resolve(workspacePath, existing.Path)
+        : path.resolve(rowDir, fileName);
+
+    if (!isPathWithin(baseConceptDir, fullPath) || !isPathWithin(baseConceptDir, indexPath)) {
+        const err = new Error('Concept embedding path must stay under the concept cache.');
+        err.statusCode = 400;
+        throw err;
+    }
+
+    const relativePath = normalizePathForClient(path.relative(workspacePath, fullPath));
+    const relativeIndexPath = normalizePathForClient(path.relative(workspacePath, indexPath));
+    const previousConcept = existing?.Concept || {};
+    const conceptRow = {
+        Id: id,
+        SqlKey: conceptSqlKeyString(id),
+        Signature: normalized.signature,
+        Body: previousConcept.Body,
+        Category: normalized.category || previousConcept.Category || '',
+        ConceptType: normalized.conceptType || previousConcept.ConceptType || 'Axiom',
+        CreatedUtc: previousConcept.CreatedUtc || nowUtc,
+        UpdatedUtc: nowUtc,
+        Description: normalized.description,
+        EmbeddingVector: vector,
+        EmbeddingBase64: serializeConceptFloatVectorBase64(vector),
+        EmbeddingModel: config.model,
+        EmbeddingUpdatedUtc: nowUtc,
+        AtomCount: Number(previousConcept.AtomCount || 0),
+        LiteralCount: Number(previousConcept.LiteralCount || 0)
+    };
+    const record = {
+        Schema: 'MindExecution.Kernel.Store.ConceptConcept/v1',
+        Store: {
+            Provider: 'LocalBridgeJsonConceptStore',
+            OriginalTable: 'tbl_concepts',
+            Notes: 'OpenAI-compatible embedding provider result stored as JSON row projection and mirrored into native SQLite tbl_concepts.'
+        },
+        HashAlgorithm: CONCEPT_HASH_ALGORITHM,
+        Concept: conceptRow,
+        Path: relativePath,
+        IndexPath: relativeIndexPath
+    };
+
+    const unsignedJson = JSON.stringify(record, null, 2);
+    record.Sha256 = crypto.createHash('sha256').update(unsignedJson, 'utf8').digest('hex');
+    await writeFileAtomically(fullPath, `${JSON.stringify(record, null, 2)}\n`, 'utf8');
+
+    const currentIndex = await readJsonIfExists(indexPath, {
+        Schema: 'MindExecution.Kernel.Store.ConceptConceptIndex/v1',
+        Store: 'LocalBridgeJsonConceptStore',
+        HashAlgorithm: CONCEPT_HASH_ALGORITHM,
+        Rows: []
+    });
+    const rows = Array.isArray(currentIndex.Rows) ? currentIndex.Rows : [];
+    const nextRows = [
+        {
+            Id: conceptRow.Id,
+            SqlKey: conceptRow.SqlKey,
+            Signature: conceptRow.Signature,
+            Category: conceptRow.Category,
+            ConceptType: conceptRow.ConceptType,
+            UpdatedUtc: conceptRow.UpdatedUtc,
+            AtomCount: conceptRow.AtomCount,
+            LiteralCount: conceptRow.LiteralCount,
+            Path: relativePath,
+            Sha256: record.Sha256,
+            EmbeddingModel: conceptRow.EmbeddingModel,
+            EmbeddingUpdatedUtc: conceptRow.EmbeddingUpdatedUtc
+        },
+        ...rows.filter(row => String(row?.Id || '').toLowerCase() !== conceptRow.Id)
+    ].slice(0, 512);
+    const nextIndex = {
+        Schema: 'MindExecution.Kernel.Store.ConceptConceptIndex/v1',
+        Store: 'LocalBridgeJsonConceptStore',
+        HashAlgorithm: CONCEPT_HASH_ALGORITHM,
+        UpdatedUtc: nowUtc,
+        RowCount: nextRows.length,
+        Rows: nextRows
+    };
+    await writeFileAtomically(indexPath, `${JSON.stringify(nextIndex, null, 2)}\n`, 'utf8');
+    record.NativeSqlite = await upsertConceptNativeSqlite(record);
+    return record;
+}
+
+function parseHtmlAttributes(attrs) {
     const result = {};
     const regex = /([A-Za-z_:][-A-Za-z0-9_:.]*)\s*=\s*["']([^"']*)["']/g;
     let match;
@@ -12644,9 +13872,9 @@ app.post('/api/web/search', async (req, res) => {
     }
 });
 
-app.post('/api/web/fetch', async (req, res) => {
-    try {
-        const { url, maxChars = 12000 } = req.body || {};
+app.post('/api/web/fetch', async (req, res) => {
+    try {
+        const { url, maxChars = 12000 } = req.body || {};
         if (!url || !String(url).trim()) {
             return res.status(400).json({ error: 'URL is required' });
         }
@@ -12662,12 +13890,119 @@ app.post('/api/web/fetch', async (req, res) => {
         console.error('[Web/Fetch] Error:', err);
         const statusCode = Number(err?.statusCode) || 500;
         res.status(statusCode).json({ error: err?.message || 'Web fetch failed' });
-    }
-});
-
-app.post('/api/browser/open', async (req, res) => {
-    try {
-        const { url } = req.body || {};
+    }
+});
+
+app.post('/api/evidence/save', async (req, res) => {
+    try {
+        const record = await saveEvidenceRecord(req.body || {});
+        logToolAction(
+            'Evidence.Save',
+            `${formatKeyValue('path', tone(record.Path, 'path'))} ${formatKeyValue('kind', record.Kind)} ${formatKeyValue('source', shortenText(record.SourceUrl || record.SourcePath || '-', 100))}`,
+            'success');
+        res.json(buildEvidenceResponse(record));
+    } catch (err) {
+        console.error('[Evidence/Save] Error:', err);
+        const statusCode = Number(err?.statusCode) || 500;
+        res.status(statusCode).json({ success: false, error: err?.message || 'Evidence save failed' });
+    }
+});
+
+app.post('/api/concept/define-composite', async (req, res) => {
+    try {
+        const record = await saveConceptCompositeRecord(req.body || {});
+        logToolAction(
+            'Concept.DefineComposite',
+            `${formatKeyValue('id', record.Concept.Id)} ${formatKeyValue('path', tone(record.Path, 'path'))} ${formatKeyValue('atoms', record.Concept.AtomCount)}`,
+            'success');
+        res.json(buildConceptCompositeResponse(record));
+    } catch (err) {
+        console.error('[Concept/DefineComposite] Error:', err);
+        const statusCode = Number(err?.statusCode) || 500;
+        res.status(statusCode).json({ success: false, error: err?.message || 'Concept composite save failed' });
+    }
+});
+
+app.get('/api/concept/status', async (req, res) => {
+    try {
+        const index = await readConceptStoreIndex();
+        const nativeSqlite = await readConceptNativeSqliteStatus();
+        const response = buildConceptStoreStatusResponse(index, nativeSqlite);
+        logToolAction(
+            'Concept.Status',
+            `${formatKeyValue('rows', response.rowCount)} ${formatKeyValue('store', response.adapterState)} ${formatKeyValue('sqlite', response.nativeSqliteAdapterState)} ${formatKeyValue('index', tone(response.indexPath || '-', 'path'))}`,
+            response.adapterState === 'json-row-projection' ? 'bridge' : 'warn');
+        res.json(response);
+    } catch (err) {
+        console.error('[Concept/Status] Error:', err);
+        const statusCode = Number(err?.statusCode) || 500;
+        res.status(statusCode).json({ success: false, error: err?.message || 'Concept status failed' });
+    }
+});
+
+app.get('/api/concept/row', async (req, res) => {
+    try {
+        const record = await readConceptCompositeRecordById(req.query?.id || req.query?.Id);
+        logToolAction(
+            'Concept.Row',
+            `${formatKeyValue('id', record.Concept.Id)} ${formatKeyValue('path', tone(record.Path, 'path'))} ${formatKeyValue('atoms', record.Concept.AtomCount)}`,
+            'bridge');
+        res.json(buildConceptCompositeResponse(record));
+    } catch (err) {
+        console.error('[Concept/Row] Error:', err);
+        const statusCode = Number(err?.statusCode) || 500;
+        res.status(statusCode).json({ success: false, error: err?.message || 'Concept row read failed' });
+    }
+});
+
+app.get('/api/concept/sqlite/row', async (req, res) => {
+    try {
+        const response = await readConceptNativeSqliteRowById(req.query?.id || req.query?.Id);
+        logToolAction(
+            'Concept.SQLite.Row',
+            `${formatKeyValue('id', response.id)} ${formatKeyValue('path', tone(response.sqlitePath, 'path'))} ${formatKeyValue('bytes', response.embeddingBytes)}`,
+            'bridge');
+        res.json(response);
+    } catch (err) {
+        console.error('[Concept/SQLite/Row] Error:', err);
+        const statusCode = Number(err?.statusCode) || 500;
+        res.status(statusCode).json({ success: false, error: err?.message || 'Concept SQLite row read failed' });
+    }
+});
+
+app.get('/api/concept/embed/readiness', async (req, res) => {
+    try {
+        const response = buildConceptEmbeddingReadinessResponse();
+        logToolAction(
+            'Concept.Embed.Readiness',
+            `${formatKeyValue('state', response.adapterState)} ${formatKeyValue('model', response.model)} ${formatKeyValue('endpoint', `${response.baseUrlHost}${response.endpointPath}`)}`,
+            response.adapterState === 'available-opt-in' ? 'bridge' : 'warn');
+        res.json(response);
+    } catch (err) {
+        console.error('[Concept/Embed/Readiness] Error:', err);
+        const statusCode = Number(err?.statusCode) || 500;
+        res.status(statusCode).json({ success: false, error: err?.message || 'Concept embed readiness failed' });
+    }
+});
+
+app.post('/api/concept/embed', async (req, res) => {
+    try {
+        const record = await upsertConceptEmbeddingRecord(req.body || {});
+        logToolAction(
+            'Concept.Embed',
+            `${formatKeyValue('id', record.Concept.Id)} ${formatKeyValue('dim', Array.isArray(record.Concept.EmbeddingVector) ? record.Concept.EmbeddingVector.length : 0)} ${formatKeyValue('model', record.Concept.EmbeddingModel)}`,
+            'success');
+        res.json(buildConceptCompositeResponse(record));
+    } catch (err) {
+        console.error('[Concept/Embed] Error:', err);
+        const statusCode = Number(err?.statusCode) || 500;
+        res.status(statusCode).json({ success: false, error: err?.message || 'Concept embed failed' });
+    }
+});
+
+app.post('/api/browser/open', async (req, res) => {
+    try {
+        const { url } = req.body || {};
         if (!url || !String(url).trim()) {
             return res.status(400).json({ error: 'URL is required' });
         }