@mindexec/cli 0.2.384 → 0.2.386

package/server.js

@@ -1588,15 +1588,8 @@ const CONTENT_TYPE_BY_EXTENSION = new Map([
     ['.mov', 'video/quicktime'],
     ['.m4v', 'video/mp4'],
     ['.pdf', 'application/pdf'],
-    ['.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']
+    ['.txt', 'text/plain; charset=utf-8'],
+    ['.json', 'application/json; charset=utf-8']
 ]);
 
 function detectContentTypeFromHeader(header) {
@@ -2007,47 +2000,6 @@ 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) => {
@@ -2082,15 +2034,11 @@ app.use('/assets', async (req, res, next) => {
             normalizedRequestPath,
             ['.png', '.jpg', '.jpeg', '.webp', '.gif', '.bmp', '.svg', '.mp4', '.webm', '.mov']
         );
-    }
-
-    if (!resolvedPath) {
-        if (await trySendPackagedWebAppAsset(req, res, '/assets')) {
-            return;
-        }
-
-        return res.status(404).json({ error: 'Asset not found' });
-    }
+    }
+
+    if (!resolvedPath) {
+        return res.status(404).json({ error: 'Asset not found' });
+    }
 
     return sendResolvedAssetFile(req, res, resolvedPath, {
         notFoundMessage: 'Asset not found',
@@ -2190,19 +2138,11 @@ 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: 'GET', prefix: '/api/company-core/' },
     { method: 'POST', prefix: '/api/company-core/' },
     { method: 'PUT', prefix: '/api/company-core/' },
     { method: 'DELETE', prefix: '/api/company-core/' },
-    { method: 'GET', prefix: '/api/model-catalog' },
     { method: 'GET', prefix: '/api/codex/' },
     { method: 'POST', prefix: '/api/codex/' },
     { method: 'GET', prefix: '/api/shell/' },
@@ -2721,39 +2661,6 @@ 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',
@@ -2771,16 +2678,7 @@ function buildRemoteFrameBinaryPacket(frameEvent) {
         transport: frame.transport || '',
         contentHash: frame.contentHash || '',
         captureMs: Number(frame.captureMs || 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
+        sameContentStreak: Number(frame.sameContentStreak || 0) || 0
     };
     const metaBuffer = Buffer.from(JSON.stringify(metadata), 'utf8');
     const header = Buffer.allocUnsafe(4);
@@ -3232,78 +3130,14 @@ function extractCodexOutputPath(command) {
     return match[2] || match[3] || match[4] || null;
 }
 
-const CODEX_CONFIG_PATH = path.join(os.homedir(), '.codex', 'config.toml');
-const CODEX_MODEL_CATALOG_TTL_MS = 15 * 60 * 1000;
-const EXTERNAL_MODEL_CATALOG_TTL_MS = 60 * 1000;
-let cachedCodexConfig = null;
-let cachedCodexConfigMtimeMs = -1;
+const CODEX_CONFIG_PATH = path.join(os.homedir(), '.codex', 'config.toml');
+const CODEX_MODEL_CATALOG_TTL_MS = 15 * 60 * 1000;
+let cachedCodexConfig = null;
+let cachedCodexConfigMtimeMs = -1;
 let cachedCodexModelCatalog = null;
 let cachedCodexModelCatalogExpiresAt = 0;
-let cachedBridgeModelCatalog = null;
-let cachedBridgeModelCatalogExpiresAt = 0;
 let lastCodexExecRuntime = null;
 let codexRuntime = null;
-
-const FALLBACK_CODEX_TEXT_MODELS = [
-    { id: 'gpt-5.5', displayName: 'GPT-5.5' },
-    { id: 'gpt-5.4', displayName: 'GPT-5.4' },
-    { id: 'gpt-5.4-mini', displayName: 'GPT-5.4 mini' },
-    { id: 'gpt-5.3-codex-spark', displayName: 'GPT-5.3 Codex Spark' }
-];
-
-const FALLBACK_OPENROUTER_TEXT_MODELS = [
-    { id: 'openrouter/auto', displayName: 'Auto Router', isFallback: true },
-    { id: 'openai/gpt-chat-latest', displayName: 'GPT Chat Latest', isFallback: true },
-    { id: 'anthropic/claude-sonnet-4.5', displayName: 'Claude Sonnet 4.5', supportsReasoning: true, isFallback: true },
-    { id: 'google/gemini-2.5-pro', displayName: 'Gemini 2.5 Pro', supportsReasoning: true, isFallback: true },
-    { id: 'google/gemini-2.5-flash', displayName: 'Gemini 2.5 Flash', isFallback: true }
-];
-
-const FALLBACK_IMAGE_MODELS = [
-    {
-        id: 'gpt-image-2',
-        label: 'GPT Image 2',
-        displayName: 'GPT Image 2',
-        provider: 'openai',
-        mode: 'image',
-        supportedSizes: ['custom'],
-        vendorPricing: { averageUsd: 0.02, source: 'fallback' },
-        isFallback: true
-    },
-    {
-        id: 'Tongyi-MAI/Z-Image-Turbo:free',
-        label: 'Z-Image Turbo',
-        displayName: 'Z-Image Turbo',
-        provider: 'imagerouter',
-        mode: 'image',
-        supportedSizes: ['custom'],
-        vendorPricing: { averageUsd: 0.02, source: 'fallback' },
-        isFallback: true
-    }
-];
-
-const FALLBACK_VIDEO_MODELS = [
-    {
-        id: 'google/veo-2',
-        label: 'Google Veo 2',
-        displayName: 'Google Veo 2',
-        provider: 'imagerouter',
-        mode: 'video',
-        supportedSizes: ['1280x720', '720x1280'],
-        vendorPricing: { averageUsd: 0.25, maxUsd: 0.25, source: 'fallback' },
-        isFallback: true
-    },
-    {
-        id: 'runway/gen-3',
-        label: 'Runway Gen-3',
-        displayName: 'Runway Gen-3',
-        provider: 'imagerouter',
-        mode: 'video',
-        supportedSizes: ['1280x720', '720x1280'],
-        vendorPricing: { averageUsd: 0.20, maxUsd: 0.20, source: 'fallback' },
-        isFallback: true
-    }
-];
 
 function readCodexConfig(options = {}) {
     const forceRefresh = Boolean(options.forceRefresh);
@@ -3474,371 +3308,6 @@ async function getCodexModelCatalog(options = {}) {
     }
 }
 
-function getPlainString(value) {
-    return String(value ?? '').trim();
-}
-
-function getCatalogString(item, propertyName) {
-    if (!item || typeof item !== 'object') {
-        return '';
-    }
-
-    return getPlainString(item[propertyName]);
-}
-
-function getCatalogNumber(item, propertyName) {
-    if (!item || typeof item !== 'object') {
-        return null;
-    }
-
-    const value = Number(item[propertyName]);
-    return Number.isFinite(value) ? value : null;
-}
-
-function getCatalogStringArray(item, propertyName) {
-    if (!item || typeof item !== 'object' || !Array.isArray(item[propertyName])) {
-        return [];
-    }
-
-    return [...new Set(item[propertyName]
-        .map(entry => getPlainString(entry))
-        .filter(Boolean))];
-}
-
-function getNestedCatalogStringArray(item, objectPropertyName, arrayPropertyName) {
-    if (!item || typeof item !== 'object') {
-        return [];
-    }
-
-    return getCatalogStringArray(item[objectPropertyName], arrayPropertyName);
-}
-
-function getNestedCatalogBoolean(item, objectPropertyName, propertyName) {
-    if (!item || typeof item !== 'object') {
-        return false;
-    }
-
-    const parent = item[objectPropertyName];
-    if (!parent || typeof parent !== 'object') {
-        return false;
-    }
-
-    const value = parent[propertyName];
-    return value === true || /^(1|true|yes|on)$/i.test(String(value ?? ''));
-}
-
-function getCatalogDecimal(item, propertyName) {
-    const value = getCatalogNumber(item, propertyName);
-    return value === null ? undefined : value;
-}
-
-function getOpenRouterPricing(item) {
-    const pricing = item?.pricing;
-    if (!pricing || typeof pricing !== 'object') {
-        return null;
-    }
-
-    const promptUsdPerToken = getCatalogDecimal(pricing, 'prompt');
-    const completionUsdPerToken = getCatalogDecimal(pricing, 'completion');
-    const requestUsd = getCatalogDecimal(pricing, 'request');
-    if (promptUsdPerToken === undefined && completionUsdPerToken === undefined && requestUsd === undefined) {
-        return null;
-    }
-
-    return {
-        promptUsdPerToken,
-        completionUsdPerToken,
-        requestUsd,
-        source: 'openrouter',
-        fetchedAt: new Date().toISOString()
-    };
-}
-
-function getImageRouterPricing(item) {
-    const price = item?.price;
-    if (!price || typeof price !== 'object') {
-        return null;
-    }
-
-    const minUsd = getCatalogDecimal(price, 'min');
-    const averageUsd = getCatalogDecimal(price, 'average');
-    const maxUsd = getCatalogDecimal(price, 'max');
-    if (minUsd === undefined && averageUsd === undefined && maxUsd === undefined) {
-        return null;
-    }
-
-    return {
-        minUsd,
-        averageUsd,
-        maxUsd,
-        source: 'imagerouter',
-        fetchedAt: new Date().toISOString()
-    };
-}
-
-function buildCatalogDisplayLabel(name, id) {
-    const label = getPlainString(name);
-    const modelId = getPlainString(id);
-    if (!label || label.toLowerCase() === modelId.toLowerCase()) {
-        return modelId;
-    }
-
-    return `${label} (${modelId})`;
-}
-
-function containsCatalogString(item, propertyName, expected) {
-    return getCatalogStringArray(item, propertyName)
-        .some(value => value.toLowerCase() === String(expected).toLowerCase());
-}
-
-function containsAnyCatalogString(item, propertyName, expectedValues) {
-    const expected = new Set(expectedValues.map(value => String(value).toLowerCase()));
-    return getCatalogStringArray(item, propertyName)
-        .some(value => expected.has(value.toLowerCase()));
-}
-
-function hasCatalogMediaModalityInElement(item) {
-    const modality = getCatalogString(item, 'modality').toLowerCase();
-    return containsAnyCatalogString(item, 'input_modalities', ['image', 'video', 'audio'])
-        || containsAnyCatalogString(item, 'output_modalities', ['image', 'video', 'audio'])
-        || /image|video|audio/i.test(modality);
-}
-
-function supportsOpenRouterTextOnlyOutput(item) {
-    const architecture = item?.architecture && typeof item.architecture === 'object'
-        ? item.architecture
-        : null;
-    const supportsText = containsCatalogString(item, 'output_modalities', 'text')
-        || (architecture && containsCatalogString(architecture, 'output_modalities', 'text'));
-    const hasMedia = hasCatalogMediaModalityInElement(item)
-        || (architecture && hasCatalogMediaModalityInElement(architecture));
-    return supportsText && !hasMedia;
-}
-
-function normalizeOpenRouterModel(item) {
-    const id = getCatalogString(item, 'id');
-    if (!id || !supportsOpenRouterTextOnlyOutput(item)) {
-        return null;
-    }
-
-    const name = getCatalogString(item, 'name');
-    const supportedParameters = getCatalogStringArray(item, 'supported_parameters');
-    return {
-        id,
-        label: buildCatalogDisplayLabel(name, id),
-        displayName: name || id,
-        provider: 'openrouter',
-        mode: 'text',
-        supportsReasoning: supportedParameters.some(value => value.toLowerCase() === 'reasoning'),
-        vendorPricing: getOpenRouterPricing(item),
-        source: 'openrouter'
-    };
-}
-
-async function fetchJsonWithTimeout(url, timeoutMs = 10000) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-        const response = await fetch(url, {
-            headers: {
-                Accept: 'application/json',
-                'Cache-Control': 'no-store',
-                Pragma: 'no-cache'
-            },
-            signal: controller.signal
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}`);
-        }
-        return await response.json();
-    } finally {
-        clearTimeout(timeout);
-    }
-}
-
-async function getOpenRouterTextModelCatalog() {
-    const payload = await fetchJsonWithTimeout('https://openrouter.ai/api/v1/models', 10000);
-    const items = Array.isArray(payload?.data) ? payload.data : [];
-    const options = items
-        .map(normalizeOpenRouterModel)
-        .filter(Boolean)
-        .sort((a, b) => String(a.label).localeCompare(String(b.label)));
-    return options.length > 0
-        ? options
-        : FALLBACK_OPENROUTER_TEXT_MODELS.map(option => ({
-            id: option.id,
-            label: option.displayName,
-            displayName: option.displayName,
-            provider: 'openrouter',
-            mode: 'text',
-            supportsReasoning: option.supportsReasoning === true,
-            isFallback: true,
-            source: 'fallback'
-        }));
-}
-
-function normalizeImageRouterModel(item, outputType) {
-    const id = getCatalogString(item, 'id');
-    if (!id) {
-        return null;
-    }
-
-    const displayName = getCatalogString(item, 'name') || id;
-    const supportedSizes = getNestedCatalogStringArray(item, 'inputs', 'size');
-    const supportedSeconds = getNestedCatalogStringArray(item, 'inputs', 'seconds');
-    return {
-        id,
-        label: displayName,
-        displayName,
-        provider: 'imagerouter',
-        mode: outputType,
-        supportedSizes: supportedSizes.length > 0 ? supportedSizes : (outputType === 'image' ? ['custom'] : []),
-        supportedSeconds,
-        capabilities: {
-            supportsTextToImage: outputType === 'image',
-            supportsImageToImage: getNestedCatalogBoolean(item, 'inputs', 'image'),
-            supportsInpaint: getNestedCatalogBoolean(item, 'inputs', 'mask'),
-            supportsSizeSelection: supportedSizes.length > 0,
-            supportedSizes,
-            supportedSeconds
-        },
-        vendorPricing: getImageRouterPricing(item),
-        source: 'imagerouter'
-    };
-}
-
-async function getImageRouterModelCatalog(outputType) {
-    const endpoint = new URL('https://api.imagerouter.io/v2/models');
-    endpoint.searchParams.set('outputType', outputType);
-    endpoint.searchParams.set('limit', '200');
-    endpoint.searchParams.set('fields', 'name,price,inputs');
-
-    const payload = await fetchJsonWithTimeout(endpoint.toString(), 10000);
-    const items = Array.isArray(payload)
-        ? payload
-        : Array.isArray(payload?.data)
-            ? payload.data
-            : [];
-    const options = items
-        .map(item => normalizeImageRouterModel(item, outputType))
-        .filter(Boolean)
-        .sort((a, b) => String(a.label).localeCompare(String(b.label)));
-
-    if (options.length > 0) {
-        return options;
-    }
-
-    return (outputType === 'image' ? FALLBACK_IMAGE_MODELS : FALLBACK_VIDEO_MODELS)
-        .map(option => ({ ...option, source: 'fallback' }));
-}
-
-function normalizeCodexCatalogOption(model) {
-    if (!model || typeof model !== 'object') {
-        return null;
-    }
-
-    const id = getCatalogString(model, 'id');
-    if (!id) {
-        return null;
-    }
-
-    const displayName = getCatalogString(model, 'displayName') || id;
-    return {
-        id,
-        label: `OpenAI Codex - ${displayName}`,
-        displayName,
-        description: getCatalogString(model, 'description'),
-        provider: 'codex',
-        mode: 'text',
-        supportsReasoning: true,
-        source: 'codex debug models',
-        priority: getCatalogNumber(model, 'priority') ?? 999,
-        defaultReasoningLevel: getCatalogString(model, 'defaultReasoningLevel'),
-        supportedReasoningLevels: getCatalogStringArray(model, 'supportedReasoningLevels'),
-        supportedInApi: model.supportedInApi === true
-    };
-}
-
-async function getBridgeModelCatalog(options = {}) {
-    const now = Date.now();
-    if (!options.forceRefresh && cachedBridgeModelCatalog && cachedBridgeModelCatalogExpiresAt > now) {
-        return cachedBridgeModelCatalog;
-    }
-
-    const errors = [];
-    const codexCatalog = await getCodexModelCatalog({ forceRefresh: options.forceRefresh });
-    if (codexCatalog?.error) {
-        errors.push(`codex: ${codexCatalog.error}`);
-    }
-
-    let codexTextModels = (codexCatalog?.models || [])
-        .map(normalizeCodexCatalogOption)
-        .filter(Boolean)
-        .sort((a, b) => (a.priority ?? 999) - (b.priority ?? 999) || a.id.localeCompare(b.id));
-    if (codexTextModels.length === 0) {
-        codexTextModels = FALLBACK_CODEX_TEXT_MODELS.map((model, index) => ({
-            id: model.id,
-            label: `OpenAI Codex - ${model.displayName}`,
-            displayName: model.displayName,
-            provider: 'codex',
-            mode: 'text',
-            supportsReasoning: true,
-            priority: index,
-            isFallback: true,
-            source: 'fallback'
-        }));
-    }
-
-    const [openRouterResult, imageResult, videoResult] = await Promise.allSettled([
-        getOpenRouterTextModelCatalog(),
-        getImageRouterModelCatalog('image'),
-        getImageRouterModelCatalog('video')
-    ]);
-
-    const openRouterTextModels = openRouterResult.status === 'fulfilled'
-        ? openRouterResult.value
-        : FALLBACK_OPENROUTER_TEXT_MODELS.map(option => ({
-            id: option.id,
-            label: option.displayName,
-            displayName: option.displayName,
-            provider: 'openrouter',
-            mode: 'text',
-            supportsReasoning: option.supportsReasoning === true,
-            isFallback: true,
-            source: 'fallback'
-        }));
-    if (openRouterResult.status === 'rejected') {
-        errors.push(`openrouter: ${openRouterResult.reason?.message || String(openRouterResult.reason)}`);
-    }
-
-    const imageModels = imageResult.status === 'fulfilled'
-        ? imageResult.value
-        : FALLBACK_IMAGE_MODELS.map(option => ({ ...option, source: 'fallback' }));
-    if (imageResult.status === 'rejected') {
-        errors.push(`imagerouter:image: ${imageResult.reason?.message || String(imageResult.reason)}`);
-    }
-
-    const videoModels = videoResult.status === 'fulfilled'
-        ? videoResult.value
-        : FALLBACK_VIDEO_MODELS.map(option => ({ ...option, source: 'fallback' }));
-    if (videoResult.status === 'rejected') {
-        errors.push(`imagerouter:video: ${videoResult.reason?.message || String(videoResult.reason)}`);
-    }
-
-    const updatedAt = new Date().toISOString();
-    cachedBridgeModelCatalog = {
-        success: true,
-        textModels: [...codexTextModels, ...openRouterTextModels],
-        imageModels,
-        videoModels,
-        source: 'localbridge-model-catalog',
-        updatedAt,
-        errors
-    };
-    cachedBridgeModelCatalogExpiresAt = now + EXTERNAL_MODEL_CATALOG_TTL_MS;
-    return cachedBridgeModelCatalog;
-}
-
 function getCodexRuntime() {
     if (!codexRuntime) {
         codexRuntime = createCodexRuntime({
@@ -11489,7 +10958,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)) {
@@ -11500,29 +10969,10 @@ 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);
-}
-
-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) {
+        .map(entry => entry.item)
+        .slice(0, clampedMax);
+}
+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)}`;
@@ -11548,22 +10998,8 @@ 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],
@@ -11598,7 +11034,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);
@@ -11647,1104 +11083,10 @@ async function fetchWebPage(url, maxChars = 12000) {
         contentType,
         truncated,
         retrievedAt: new Date().toISOString()
-    };
-}
-
-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) {
+    };
+}
+
+function parseHtmlAttributes(attrs) {
     const result = {};
     const regex = /([A-Za-z_:][-A-Za-z0-9_:.]*)\s*=\s*["']([^"']*)["']/g;
     let match;
@@ -14031,19 +12373,6 @@ app.get('/api/codex/capabilities', async (req, res) => {
     }
 });
 
-app.get('/api/model-catalog', async (req, res) => {
-    try {
-        const forceRefresh = /^(1|true|yes|on)$/i.test(String(req.query?.refresh || ''));
-        res.json(await getBridgeModelCatalog({ forceRefresh }));
-    } catch (err) {
-        console.error('[ModelCatalog] Error:', err);
-        res.status(500).json({
-            success: false,
-            error: err?.message || String(err)
-        });
-    }
-});
-
 app.post('/api/codex/thread/start', async (req, res) => {
     try {
         res.json(await getCodexRuntime().startThread(req.body || {}));
@@ -14315,9 +12644,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' });
         }
@@ -14333,119 +12662,12 @@ 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/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 || {};
+    }
+});
+
+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' });
         }