openclaw-observability 2026.4.1 → 2026.4.21

package/dist/web/api.js

@@ -1,9 +1,45 @@
 "use strict";
 /**
- * Audit Web API — query database and return structured data
+ * Observation Web API — query database and return structured data
  * Compatible with both MySQL and DuckDB backends
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTenants = getTenants;
+exports.getSkillsOverview = getSkillsOverview;
+exports.getSkillDetail = getSkillDetail;
 exports.getStats = getStats;
 exports.getSessions = getSessions;
 exports.getSessionActions = getSessionActions;
@@ -16,6 +52,12 @@ exports.getAnalytics = getAnalytics;
 exports.getMetricsOverview = getMetricsOverview;
 exports.getMetricSeries = getMetricSeries;
 exports.getTraceObservationTree = getTraceObservationTree;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const REPLAY_SESSION_PREFIX = 'replay-';
+const SKILL_CATALOG_CACHE_TTL_MS = 60_000;
+const skillCatalogCache = new Map();
 /* ------------------------------------------------------------------ */
 /*  API functions                                                       */
 /* ------------------------------------------------------------------ */
@@ -39,6 +81,564 @@ function parseTimeMs(value) {
     const ms = Date.parse(trimmed);
     return Number.isFinite(ms) ? ms : undefined;
 }
+function normalizeScopeId(value) {
+    const v = (value || '').trim();
+    return v || 'local';
+}
+function safeParseJsonObject(value) {
+    if (typeof value !== 'string' || !value.trim())
+        return null;
+    try {
+        const parsed = JSON.parse(value);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // ignore invalid json
+    }
+    return null;
+}
+function decodeXmlEntities(input) {
+    return input
+        .replace(/&quot;/g, '"')
+        .replace(/&apos;/g, '\'')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&amp;/g, '&');
+}
+function readSkillCatalogFromSystemPrompt(systemPrompt) {
+    if (!systemPrompt || typeof systemPrompt !== 'string')
+        return [];
+    const out = [];
+    const seen = new Set();
+    const xmlRe = /<skill>\s*<name>([\s\S]*?)<\/name>[\s\S]*?<description>([\s\S]*?)<\/description>[\s\S]*?<location>([\s\S]*?)<\/location>[\s\S]*?<\/skill>/gi;
+    let m;
+    while ((m = xmlRe.exec(systemPrompt)) !== null) {
+        const skill = decodeXmlEntities(String(m[1] || '')).trim();
+        if (!skill || seen.has(skill))
+            continue;
+        seen.add(skill);
+        const description = decodeXmlEntities(String(m[2] || '')).trim();
+        const location = decodeXmlEntities(String(m[3] || '')).trim();
+        out.push({
+            skill,
+            description: description || undefined,
+            location: location || undefined,
+        });
+    }
+    return out;
+}
+function extractSystemPrompt(inputObj) {
+    const sp = typeof inputObj.systemPrompt === 'string'
+        ? inputObj.systemPrompt
+        : (typeof inputObj.extraSystemPrompt === 'string' ? inputObj.extraSystemPrompt : '');
+    return String(sp || '');
+}
+function parseSkillCallInput(input) {
+    const obj = safeParseJsonObject(input);
+    if (!obj)
+        return null;
+    const skill = typeof obj.skill === 'string' ? obj.skill.trim() : '';
+    if (!skill)
+        return null;
+    const toolCallId = typeof obj.toolCallId === 'string' ? obj.toolCallId.trim() : '';
+    const skillPath = typeof obj.skillPath === 'string' ? obj.skillPath.trim() : '';
+    const skillSource = typeof obj.skillSource === 'string' ? obj.skillSource.trim() : '';
+    return {
+        skill,
+        toolCallId: toolCallId || undefined,
+        skillPath: skillPath || undefined,
+        skillSource: skillSource || undefined,
+    };
+}
+function resolveSkillLocation(rawLocation) {
+    const value = String(rawLocation || '').trim();
+    if (!value)
+        return '';
+    if (value === '~')
+        return os.homedir();
+    if (value.startsWith('~/'))
+        return path.join(os.homedir(), value.slice(2));
+    if (value.startsWith('$HOME/'))
+        return path.join(os.homedir(), value.slice(6));
+    return value;
+}
+function inferSkillSourceFromLocation(rawLocation) {
+    const resolved = resolveSkillLocation(rawLocation);
+    const normalized = String(resolved || '').replace(/\\/g, '/');
+    if (!normalized)
+        return '';
+    const home = os.homedir().replace(/\\/g, '/');
+    const stateDir = (String(process.env.OPENCLAW_STATE_DIR || '').trim() || path.join(home, '.openclaw'))
+        .replace(/\\/g, '/');
+    const bundledOverride = String(process.env.OPENCLAW_BUNDLED_SKILLS_DIR || '').trim().replace(/\\/g, '/');
+    const bundledSibling = path.join(path.dirname(process.execPath || ''), 'skills').replace(/\\/g, '/');
+    if (normalized.includes('/node_modules/openclaw/skills/'))
+        return 'openclaw-bundled';
+    if (bundledOverride && normalized.startsWith(`${bundledOverride}/`))
+        return 'openclaw-bundled';
+    if (bundledSibling && normalized.startsWith(`${bundledSibling}/`))
+        return 'openclaw-bundled';
+    if (normalized.startsWith(`${stateDir}/skills/`))
+        return 'openclaw-managed';
+    if (normalized.startsWith(`${stateDir}/workspace/skills/`))
+        return 'openclaw-workspace';
+    if (normalized.startsWith(`${home}/.agents/skills/`))
+        return 'agents-skills-personal';
+    if (normalized.includes('/.agents/skills/'))
+        return 'agents-skills-project';
+    if (normalized.includes('/workspace/skills/'))
+        return 'openclaw-workspace';
+    return 'openclaw-extra';
+}
+function getSkillSearchDirs() {
+    const dirs = [];
+    const home = os.homedir();
+    const stateDir = String(process.env.OPENCLAW_STATE_DIR || '').trim() || path.join(home, '.openclaw');
+    const envHomes = [
+        process.env.OPENCLAW_HOME,
+        process.env.OPENCLAW_STATE_DIR,
+    ].map((v) => String(v || '').trim()).filter(Boolean);
+    const bundledOverride = String(process.env.OPENCLAW_BUNDLED_SKILLS_DIR || '').trim();
+    const bundledSibling = path.join(path.dirname(process.execPath || ''), 'skills');
+    const nodeInstallRoot = path.dirname(path.dirname(process.execPath || ''));
+    const nodeGlobalOpenClawSkills = path.join(nodeInstallRoot, 'lib', 'node_modules', 'openclaw', 'skills');
+    dirs.push(path.join(stateDir, 'skills'));
+    envHomes.forEach((h) => dirs.push(path.join(h, 'workspace', 'skills')));
+    dirs.push(path.join(stateDir, 'workspace', 'skills'));
+    dirs.push(path.join(home, '.agents', 'skills'));
+    dirs.push(path.join(process.cwd(), '.agents', 'skills'));
+    dirs.push(path.join(process.cwd(), 'skills'));
+    dirs.push(path.join(home, '.openclaw', 'workspace', 'skills'));
+    dirs.push(path.join(process.cwd(), 'workspace', 'skills'));
+    dirs.push(nodeGlobalOpenClawSkills);
+    if (bundledOverride)
+        dirs.push(bundledOverride);
+    if (bundledSibling)
+        dirs.push(bundledSibling);
+    // de-dup while preserving order
+    return Array.from(new Set(dirs.map((d) => path.resolve(d))));
+}
+function inferSkillDescriptionFromMarkdown(content) {
+    const text = String(content || '');
+    const lines = text.split(/\r?\n/).map((x) => x.trim());
+    for (const line of lines) {
+        if (!line)
+            continue;
+        if (line.startsWith('#'))
+            continue;
+        if (line.startsWith('```'))
+            continue;
+        return line.length > 220 ? `${line.slice(0, 217)}...` : line;
+    }
+    return '';
+}
+function discoverLocalSkills() {
+    const out = new Map();
+    const roots = getSkillSearchDirs();
+    for (const root of roots) {
+        let entries = [];
+        try {
+            if (!fs.existsSync(root))
+                continue;
+            entries = fs.readdirSync(root, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const ent of entries) {
+            if (!ent.isDirectory())
+                continue;
+            const skill = String(ent.name || '').trim();
+            if (!skill || out.has(skill))
+                continue;
+            const skillFile = path.join(root, skill, 'SKILL.md');
+            if (!fs.existsSync(skillFile))
+                continue;
+            let description = '';
+            try {
+                description = inferSkillDescriptionFromMarkdown(fs.readFileSync(skillFile, 'utf8'));
+            }
+            catch {
+                description = '';
+            }
+            out.set(skill, {
+                description: description || undefined,
+                location: skillFile,
+            });
+        }
+    }
+    return out;
+}
+function normalizeAgentScope(value) {
+    const raw = String(value || 'main').trim().toLowerCase();
+    if (raw === 'subagent' || raw === 'replay' || raw === 'system' || raw === 'all')
+        return raw;
+    return 'main';
+}
+function applyAgentScopeSessionFilter(where, values, scopeId, agentScope) {
+    const subagentPromptClause = `session_id IN (
+    SELECT DISTINCT session_id FROM observation_actions
+    WHERE scope_id = ?
+      AND action_type IN ('prompt_build', 'message')
+      AND (
+        input_params LIKE '%[Subagent Context]%'
+        OR input_params LIKE '%"source":"subagent"%'
+      )
+  )`;
+    const llmSessionClause = `session_id IN (
+    SELECT DISTINCT session_id FROM observation_actions
+    WHERE scope_id = ?
+      AND action_type = 'message'
+      AND action_name LIKE 'llm_call:%'
+  )`;
+    const replaySessionClause = `session_id IN (
+    SELECT DISTINCT session_id FROM observation_actions
+    WHERE scope_id = ?
+      AND action_type = 'replay'
+  )`;
+    const systemSessionClause = `(
+    LOWER(COALESCE(user_id,'')) = 'system'
+    OR LOWER(COALESCE(session_id,'')) = 'system'
+    OR LOWER(COALESCE(channel_id,'')) LIKE '%heartbeat%'
+    OR LOWER(COALESCE(user_id,'')) LIKE '%heartbeat%'
+    OR LOWER(COALESCE(session_id,'')) LIKE '%heartbeat%'
+  )`;
+    if (agentScope === 'replay') {
+        where += ' AND session_id LIKE ?';
+        values.push(`${REPLAY_SESSION_PREFIX}%`);
+        where += ` AND ${replaySessionClause}`;
+        values.push(scopeId);
+        return { where, values };
+    }
+    where += ' AND session_id NOT LIKE ?';
+    values.push(`${REPLAY_SESSION_PREFIX}%`);
+    if (agentScope === 'system') {
+        where += ` AND ${systemSessionClause}`;
+        return { where, values };
+    }
+    where += " AND LOWER(COALESCE(user_id,'')) NOT IN ('unknown','unkown')";
+    where += " AND LOWER(COALESCE(session_id,'')) NOT IN ('unknown','unkown','-')";
+    if (agentScope === 'all') {
+        where += ` AND (${systemSessionClause} OR ${llmSessionClause})`;
+        values.push(scopeId);
+        return { where, values };
+    }
+    where += ` AND ${llmSessionClause}`;
+    values.push(scopeId);
+    if (agentScope === 'subagent') {
+        where += ` AND (COALESCE(TRIM(parent_session_id), '') <> '' OR ${subagentPromptClause})`;
+        values.push(scopeId);
+        return { where, values };
+    }
+    where += ` AND NOT (${systemSessionClause})`;
+    where += ` AND (COALESCE(TRIM(parent_session_id), '') = '' AND NOT (${subagentPromptClause}))`;
+    values.push(scopeId);
+    return { where, values };
+}
+/** List available scope ids */
+async function getTenants(pool) {
+    const [rows] = await pool.query(`SELECT
+       COALESCE(NULLIF(TRIM(scope_id), ''), 'local') AS scope_id
+     FROM observation_sessions
+     WHERE session_id NOT LIKE ?
+     GROUP BY 1
+     ORDER BY CASE WHEN LOWER(COALESCE(NULLIF(TRIM(scope_id), ''), 'local')) = 'local' THEN 0 ELSE 1 END, scope_id ASC`, [`${REPLAY_SESSION_PREFIX}%`]);
+    return { tenants: rows };
+}
+async function getSkillCatalog(pool, scopeId) {
+    const now = Date.now();
+    const hit = skillCatalogCache.get(scopeId);
+    if (hit && (now - hit.cachedAt) < SKILL_CATALOG_CACHE_TTL_MS) {
+        return new Map(hit.catalog);
+    }
+    const baseSql = `SELECT input_params
+       FROM observation_actions
+      WHERE scope_id = ?
+        AND action_type IN ('message', 'replay')
+        AND action_name LIKE 'llm_call:%'
+        AND input_params IS NOT NULL
+      ORDER BY created_at DESC
+      LIMIT ?`;
+    const [hotRows] = await pool.query(baseSql, [scopeId, 8]);
+    let rows = hotRows;
+    if (!rows.length) {
+        const [allRows] = await pool.query(baseSql, [scopeId, 80]);
+        rows = allRows;
+    }
+    const catalog = new Map();
+    const seenPromptHashes = new Set();
+    let staleRounds = 0;
+    for (const row of rows) {
+        const inputObj = safeParseJsonObject(row.input_params);
+        if (!inputObj)
+            continue;
+        const promptHash = typeof inputObj.systemPromptHash === 'string'
+            ? inputObj.systemPromptHash.trim()
+            : '';
+        if (promptHash && seenPromptHashes.has(promptHash))
+            continue;
+        if (promptHash)
+            seenPromptHashes.add(promptHash);
+        const systemPrompt = extractSystemPrompt(inputObj);
+        if (!systemPrompt)
+            continue;
+        const before = catalog.size;
+        const items = readSkillCatalogFromSystemPrompt(systemPrompt);
+        for (const item of items) {
+            if (!catalog.has(item.skill)) {
+                catalog.set(item.skill, {
+                    description: item.description,
+                    location: item.location,
+                });
+            }
+        }
+        if (catalog.size === before) {
+            staleRounds += 1;
+            if (catalog.size > 0 && staleRounds >= 8)
+                break;
+        }
+        else {
+            staleRounds = 0;
+        }
+    }
+    if (!catalog.size && rows.length < 20) {
+        const [fallbackRows] = await pool.query(baseSql, [scopeId, 80]);
+        for (const row of fallbackRows) {
+            const inputObj = safeParseJsonObject(row.input_params);
+            if (!inputObj)
+                continue;
+            const promptHash = typeof inputObj.systemPromptHash === 'string'
+                ? inputObj.systemPromptHash.trim()
+                : '';
+            if (promptHash && seenPromptHashes.has(promptHash))
+                continue;
+            if (promptHash)
+                seenPromptHashes.add(promptHash);
+            const systemPrompt = extractSystemPrompt(inputObj);
+            if (!systemPrompt)
+                continue;
+            const items = readSkillCatalogFromSystemPrompt(systemPrompt);
+            for (const item of items) {
+                if (!catalog.has(item.skill)) {
+                    catalog.set(item.skill, {
+                        description: item.description,
+                        location: item.location,
+                    });
+                }
+            }
+            if (catalog.size > 0)
+                break;
+        }
+    }
+    // Keep local file-system discovery scoped to local tenant only.
+    if (scopeId === 'local') {
+        const localSkills = discoverLocalSkills();
+        for (const [skill, meta] of localSkills.entries()) {
+            if (!catalog.has(skill)) {
+                catalog.set(skill, meta);
+            }
+            else {
+                const existing = catalog.get(skill) || {};
+                catalog.set(skill, {
+                    description: existing.description || meta.description,
+                    location: existing.location || meta.location,
+                });
+            }
+        }
+    }
+    skillCatalogCache.set(scopeId, { cachedAt: now, catalog: new Map(catalog) });
+    return catalog;
+}
+/** Skills overview aggregated from realtime skill_call events */
+async function getSkillsOverview(pool, params) {
+    const scopeId = normalizeScopeId(params?.scopeId);
+    const limit = Math.max(1, Math.min(500, normalizePositiveInt(params?.limit, 200)));
+    const fromMs = parseTimeMs(params?.timeFrom);
+    const toMs = parseTimeMs(params?.timeTo);
+    let where = `scope_id = ? AND action_type = 'skill_call'`;
+    const values = [scopeId];
+    if (fromMs != null) {
+        where += ' AND created_at >= FROM_UNIXTIME(? / 1000)';
+        values.push(fromMs);
+    }
+    if (toMs != null) {
+        where += ' AND created_at <= FROM_UNIXTIME(? / 1000)';
+        values.push(toMs);
+    }
+    const [rows] = await pool.query(`SELECT session_id, run_id, action_name, input_params, created_at
+       FROM observation_actions
+      WHERE ${where}
+      ORDER BY created_at DESC
+      LIMIT 20000`, values);
+    const perSkill = new Map();
+    for (const row of rows) {
+        const parsed = parseSkillCallInput(row.input_params);
+        const fromName = String(row.action_name || '').startsWith('skill_call:')
+            ? String(row.action_name || '').slice('skill_call:'.length).trim()
+            : '';
+        const skillName = parsed?.skill || fromName;
+        if (!skillName)
+            continue;
+        const sessionId = String(row.session_id || '').trim();
+        const runId = String(row.run_id || '').trim();
+        const ts = Date.parse(String(row.created_at || '')) || 0;
+        let rec = perSkill.get(skillName);
+        if (!rec) {
+            rec = { callCount: 0, sessions: new Set(), runs: new Set(), lastSeen: 0, sourceCounts: new Map() };
+            perSkill.set(skillName, rec);
+        }
+        rec.callCount += 1;
+        if (sessionId)
+            rec.sessions.add(sessionId);
+        if (runId)
+            rec.runs.add(runId);
+        if (ts > rec.lastSeen)
+            rec.lastSeen = ts;
+        if (parsed?.skillSource) {
+            rec.sourceCounts.set(parsed.skillSource, Number(rec.sourceCounts.get(parsed.skillSource) || 0) + 1);
+        }
+    }
+    const catalog = await getSkillCatalog(pool, scopeId);
+    for (const skill of catalog.keys()) {
+        if (!perSkill.has(skill)) {
+            perSkill.set(skill, { callCount: 0, sessions: new Set(), runs: new Set(), lastSeen: 0, sourceCounts: new Map() });
+        }
+    }
+    const items = Array.from(perSkill.entries())
+        .map(([skill, rec]) => {
+        const cat = catalog.get(skill);
+        let source = '';
+        let sourceCount = -1;
+        rec.sourceCounts.forEach((cnt, name) => {
+            if (cnt > sourceCount) {
+                source = name;
+                sourceCount = cnt;
+            }
+        });
+        if (!source) {
+            source = inferSkillSourceFromLocation(cat?.location || '');
+        }
+        return {
+            skill,
+            description: cat?.description,
+            location: cat?.location,
+            source: source || undefined,
+            callCount: rec.callCount,
+            sessionCount: rec.sessions.size,
+            runCount: rec.runs.size,
+            lastSeen: rec.lastSeen > 0 ? new Date(rec.lastSeen).toISOString() : '',
+        };
+    })
+        .sort((a, b) => (b.callCount - a.callCount) || a.skill.localeCompare(b.skill))
+        .slice(0, limit);
+    return {
+        totalSkills: perSkill.size,
+        totalCalls: Array.from(perSkill.values()).reduce((sum, it) => sum + it.callCount, 0),
+        items,
+    };
+}
+async function getSkillDetail(pool, params) {
+    const scopeId = normalizeScopeId(params.scopeId);
+    const skill = String(params.skill || '').trim();
+    if (!skill) {
+        throw new Error('skill is required');
+    }
+    const limit = Math.max(1, Math.min(200, normalizePositiveInt(params.limit, 50)));
+    const fromMs = parseTimeMs(params.timeFrom);
+    const toMs = parseTimeMs(params.timeTo);
+    let where = `scope_id = ? AND action_type = 'skill_call' AND action_name = ?`;
+    const values = [scopeId, `skill_call:${skill}`];
+    if (fromMs != null) {
+        where += ' AND created_at >= FROM_UNIXTIME(? / 1000)';
+        values.push(fromMs);
+    }
+    if (toMs != null) {
+        where += ' AND created_at <= FROM_UNIXTIME(? / 1000)';
+        values.push(toMs);
+    }
+    const [rows] = await pool.query(`SELECT session_id, run_id, input_params, output_result, created_at
+       FROM observation_actions
+      WHERE ${where}
+      ORDER BY created_at DESC
+      LIMIT 20000`, values);
+    const sessions = new Set();
+    const runs = new Set();
+    let callCount = 0;
+    let lastSeenMs = 0;
+    const recentCalls = [];
+    const seenToolCallIds = new Set();
+    let latestPath = '';
+    let latestSource = '';
+    for (const row of rows) {
+        callCount += 1;
+        const sessionId = String(row.session_id || '').trim();
+        const runId = String(row.run_id || '').trim();
+        if (sessionId)
+            sessions.add(sessionId);
+        if (runId)
+            runs.add(runId);
+        const ts = Date.parse(String(row.created_at || '')) || 0;
+        if (ts > lastSeenMs)
+            lastSeenMs = ts;
+        const inp = parseSkillCallInput(row.input_params);
+        const out = safeParseJsonObject(row.output_result);
+        const ok = typeof out?.ok === 'boolean' ? out.ok : undefined;
+        const error = typeof out?.error === 'string' ? out.error : undefined;
+        if (inp?.skillPath && !latestPath)
+            latestPath = inp.skillPath;
+        if (inp?.skillSource && !latestSource)
+            latestSource = inp.skillSource;
+        if (recentCalls.length < limit) {
+            const dedupeKey = `${sessionId}|${runId}|${inp?.toolCallId || ''}|${String(row.created_at || '')}`;
+            if (!seenToolCallIds.has(dedupeKey)) {
+                seenToolCallIds.add(dedupeKey);
+                recentCalls.push({
+                    sessionId,
+                    runId,
+                    createdAt: String(row.created_at || ''),
+                    toolCallId: inp?.toolCallId,
+                    skillPath: inp?.skillPath,
+                    skillSource: inp?.skillSource,
+                    ok,
+                    error,
+                });
+            }
+        }
+    }
+    const catalog = await getSkillCatalog(pool, scopeId);
+    const cat = catalog.get(skill);
+    const locationRaw = cat?.location || latestPath || '';
+    const inferredSource = inferSkillSourceFromLocation(locationRaw);
+    const location = resolveSkillLocation(locationRaw);
+    let content = '';
+    let contentLoaded = false;
+    if (location) {
+        try {
+            if (fs.existsSync(location)) {
+                content = fs.readFileSync(location, 'utf8');
+                contentLoaded = true;
+            }
+        }
+        catch {
+            contentLoaded = false;
+        }
+    }
+    return {
+        skill,
+        description: cat?.description,
+        location: locationRaw || undefined,
+        source: latestSource || inferredSource || undefined,
+        content,
+        contentLoaded,
+        callCount,
+        sessionCount: sessions.size,
+        runCount: runs.size,
+        lastSeen: lastSeenMs > 0 ? new Date(lastSeenMs).toISOString() : '',
+        recentCalls,
+    };
+}
 function resolveMetricsWindow(params) {
     const now = Date.now();
     const defaultMinutes = Math.min(Math.max(normalizePositiveInt(params.minutes, 60), 1), 24 * 60);
@@ -60,8 +660,11 @@ function resolveMetricsWindow(params) {
 }
 /** Get summary statistics */
 async function getStats(pool, params) {
-    let sessionWhere = '1=1';
-    const sessionVals = [];
+    const scopeId = normalizeScopeId(params?.scopeId);
+    const agentScope = normalizeAgentScope(params?.agentType);
+    let sessionWhere = 'scope_id = ?';
+    let sessionVals = [scopeId];
+    ({ where: sessionWhere, values: sessionVals } = applyAgentScopeSessionFilter(sessionWhere, sessionVals, scopeId, agentScope));
     if (params?.timeFrom) {
         sessionWhere += ' AND COALESCE(end_time, start_time) >= ?';
         sessionVals.push(params.timeFrom);
@@ -70,8 +673,9 @@ async function getStats(pool, params) {
         sessionWhere += ' AND COALESCE(end_time, start_time) <= ?';
         sessionVals.push(params.timeTo);
     }
-    let actionWhere = '1=1';
-    const actionVals = [];
+    let actionWhere = 'scope_id = ? AND session_id IN (SELECT session_id FROM observation_sessions WHERE ' + sessionWhere + ')';
+    const actionVals = [scopeId];
+    actionVals.push(...sessionVals);
     if (params?.timeFrom) {
         actionWhere += ' AND created_at >= ?';
         actionVals.push(params.timeFrom);
@@ -80,16 +684,16 @@ async function getStats(pool, params) {
         actionWhere += ' AND created_at <= ?';
         actionVals.push(params.timeTo);
     }
-    const [sessionRows] = await pool.query('SELECT COUNT(*) as cnt FROM audit_sessions WHERE ' + sessionWhere, sessionVals);
+    const [sessionRows] = await pool.query('SELECT COUNT(*) as cnt FROM observation_sessions WHERE ' + sessionWhere, sessionVals);
     const [actionRows] = await pool.query(`SELECT COUNT(*) as cnt,
             COALESCE(SUM(COALESCE(prompt_tokens,0) + COALESCE(completion_tokens,0)), 0) as tokens,
             COALESCE(AVG(NULLIF(duration_ms, 0)), 0) as avg_latency,
             COALESCE(SUM(CASE WHEN action_type = 'agent_end' THEN 1 ELSE 0 END), 0) as total_end,
             COALESCE(SUM(CASE WHEN action_type = 'agent_end' AND output_result LIKE '%"success":true%' THEN 1 ELSE 0 END), 0) as success_end
-     FROM audit_actions
+     FROM observation_actions
      WHERE ` + actionWhere, actionVals);
     // Count by action_type
-    const [typeCounts] = await pool.query('SELECT action_type, COUNT(*) as cnt FROM audit_actions WHERE ' + actionWhere + ' GROUP BY action_type ORDER BY cnt DESC', actionVals);
+    const [typeCounts] = await pool.query('SELECT action_type, COUNT(*) as cnt FROM observation_actions WHERE ' + actionWhere + ' GROUP BY action_type ORDER BY cnt DESC', actionVals);
     const actionTypeCounts = {};
     for (const row of typeCounts) {
         actionTypeCounts[row.action_type] = Number(row.cnt);
@@ -109,11 +713,14 @@ async function getStats(pool, params) {
 }
 /** Get session list */
 async function getSessions(pool, params) {
+    const scopeId = normalizeScopeId(params.scopeId);
     const page = normalizePositiveInt(params.page, 1);
     const limit = Math.min(normalizePositiveInt(params.limit, 20), 100);
     const offset = (page - 1) * limit;
-    let where = '1=1';
-    const values = [];
+    const agentScope = normalizeAgentScope(params.agentType);
+    let where = 'scope_id = ?';
+    let values = [scopeId];
+    ({ where, values } = applyAgentScopeSessionFilter(where, values, scopeId, agentScope));
     if (params.sessionId) {
         where += ' AND session_id = ?';
         values.push(params.sessionId);
@@ -132,11 +739,11 @@ async function getSessions(pool, params) {
         where += ` AND (
       session_id LIKE ? OR user_id LIKE ? OR model_name LIKE ?
       OR session_id IN (
-        SELECT DISTINCT session_id FROM audit_actions
-        WHERE input_params LIKE ? OR output_result LIKE ? OR action_name LIKE ?
+        SELECT DISTINCT session_id FROM observation_actions
+        WHERE scope_id = ? AND (input_params LIKE ? OR output_result LIKE ? OR action_name LIKE ?)
       )
     )`;
-        values.push(like, like, like, like, like, like);
+        values.push(like, like, like, scopeId, like, like, like);
     }
     // Time range filter: use "last active time" (end_time fallback start_time)
     // so "recent 24h" reflects recently updated sessions, not only newly started sessions.
@@ -148,23 +755,49 @@ async function getSessions(pool, params) {
         where += ' AND COALESCE(end_time, start_time) <= ?';
         values.push(params.timeTo);
     }
-    // Hide noisy pseudo rows from trace list
-    where += " AND LOWER(COALESCE(user_id,'')) NOT IN ('unknown','unkown')";
-    where += " AND LOWER(COALESCE(session_id,'')) NOT IN ('unknown','unkown','-')";
-    const [countRows] = await pool.query('SELECT COUNT(*) as cnt FROM audit_sessions WHERE ' + where, values);
-    const [rows] = await pool.query(`SELECT * FROM audit_sessions WHERE ${where}
+    const [countRows] = await pool.query('SELECT COUNT(*) as cnt FROM observation_sessions WHERE ' + where, values);
+    const [rows] = await pool.query(`SELECT * FROM observation_sessions WHERE ${where}
      ORDER BY
        CASE WHEN LOWER(COALESCE(user_id,'')) = 'system' THEN 1 ELSE 0 END ASC,
        COALESCE(end_time, start_time) DESC,
        start_time DESC
      LIMIT ? OFFSET ?`, [...values, limit, offset]);
+    const sessions = rows;
+    const sessionIds = sessions.map((s) => String(s.session_id || '')).filter(Boolean);
+    const subagentBySession = new Set();
+    if (sessionIds.length > 0) {
+        const placeholders = sessionIds.map(() => '?').join(',');
+        const [tagRows] = await pool.query(`SELECT DISTINCT session_id
+         FROM observation_actions
+        WHERE scope_id = ?
+          AND session_id IN (${placeholders})
+          AND action_type IN ('prompt_build', 'message')
+          AND (
+            input_params LIKE '%[Subagent Context]%'
+            OR input_params LIKE '%"source":"subagent"%'
+          )`, [scopeId, ...sessionIds]);
+        tagRows.forEach((r) => {
+            if (r && r.session_id)
+                subagentBySession.add(String(r.session_id));
+        });
+    }
+    const normalizedSessions = sessions.map((s) => {
+        const parent = String(s.parent_session_id || '').trim();
+        const sid = String(s.session_id || '');
+        const inferred = parent.length > 0 || subagentBySession.has(sid);
+        return {
+            ...s,
+            is_subagent: inferred ? 1 : 0,
+        };
+    });
     return {
-        sessions: rows,
+        sessions: normalizedSessions,
         total: Number(countRows[0]?.cnt ?? 0),
     };
 }
 /** Get actions for a session (supports field selection and limit) */
 async function getSessionActions(pool, sessionId, options) {
+    const scopeId = normalizeScopeId(options?.scopeId);
     // If fields=action_type, return only minimal fields (for mini trace)
     const selectCols = options?.fields === 'action_type'
         ? 'action_type, created_at'
@@ -173,8 +806,12 @@ async function getSessionActions(pool, sessionId, options) {
         ? Math.min(normalizePositiveInt(options.limit, 1000), 1000)
         : undefined;
     const limitClause = limitedRows ? ` LIMIT ${limitedRows}` : '';
-    let where = 'session_id = ?';
-    const values = [sessionId];
+    let where = 'scope_id = ? AND session_id = ?';
+    const values = [scopeId, sessionId];
+    if (!String(sessionId || '').startsWith(REPLAY_SESSION_PREFIX)) {
+        where += ' AND session_id NOT LIKE ?';
+        values.push(`${REPLAY_SESSION_PREFIX}%`);
+    }
     if (options?.timeFrom) {
         where += ' AND created_at >= ?';
         values.push(options.timeFrom);
@@ -183,16 +820,19 @@ async function getSessionActions(pool, sessionId, options) {
         where += ' AND created_at <= ?';
         values.push(options.timeTo);
     }
-    const [rows] = await pool.query(`SELECT ${selectCols} FROM audit_actions WHERE ${where} ORDER BY created_at ASC, id ASC${limitClause}`, values);
+    const [rows] = await pool.query(`SELECT ${selectCols} FROM observation_actions WHERE ${where} ORDER BY created_at ASC, id ASC${limitClause}`, values);
     return rows;
 }
 /** Get action list */
 async function getActions(pool, params) {
+    const scopeId = normalizeScopeId(params.scopeId);
     const page = normalizePositiveInt(params.page, 1);
     const limit = Math.min(normalizePositiveInt(params.limit, 50), 200);
     const offset = (page - 1) * limit;
-    let where = '1=1';
-    const values = [];
+    let where = 'scope_id = ?';
+    const values = [scopeId];
+    where += ' AND session_id NOT LIKE ?';
+    values.push(`${REPLAY_SESSION_PREFIX}%`);
     if (params.actionType) {
         where += ' AND action_type = ?';
         values.push(params.actionType);
@@ -209,8 +849,8 @@ async function getActions(pool, params) {
         where += ' AND created_at <= ?';
         values.push(params.timeTo);
     }
-    const [countRows] = await pool.query('SELECT COUNT(*) as cnt FROM audit_actions WHERE ' + where, values);
-    const [rows] = await pool.query('SELECT * FROM audit_actions WHERE ' + where + ' ORDER BY created_at DESC, id DESC LIMIT ? OFFSET ?', [...values, limit, offset]);
+    const [countRows] = await pool.query('SELECT COUNT(*) as cnt FROM observation_actions WHERE ' + where, values);
+    const [rows] = await pool.query('SELECT * FROM observation_actions WHERE ' + where + ' ORDER BY created_at DESC, id DESC LIMIT ? OFFSET ?', [...values, limit, offset]);
     return {
         actions: rows,
         total: Number(countRows[0]?.cnt ?? 0),
@@ -221,11 +861,14 @@ function normalizeAlertStatus(status) {
 }
 /** Get security alert list */
 async function getAlerts(pool, params) {
+    const scopeId = normalizeScopeId(params.scopeId);
     const page = normalizePositiveInt(params.page, 1);
     const limit = Math.min(normalizePositiveInt(params.limit, 20), 100);
     const offset = (page - 1) * limit;
-    let where = '1=1';
-    const values = [];
+    let where = 'scope_id = ?';
+    const values = [scopeId];
+    where += ' AND session_id NOT LIKE ?';
+    values.push(`${REPLAY_SESSION_PREFIX}%`);
     if (params.severity) {
         where += ' AND severity = ?';
         values.push(params.severity);
@@ -269,8 +912,8 @@ async function getAlerts(pool, params) {
         where += ' AND created_at <= ?';
         values.push(params.timeTo);
     }
-    const [countRows] = await pool.query('SELECT COUNT(*) as cnt FROM audit_alerts WHERE ' + where, values);
-    const [rows] = await pool.query(`SELECT * FROM audit_alerts WHERE ${where}
+    const [countRows] = await pool.query('SELECT COUNT(*) as cnt FROM observation_alerts WHERE ' + where, values);
+    const [rows] = await pool.query(`SELECT * FROM observation_alerts WHERE ${where}
      ORDER BY
        CASE severity
          WHEN 'critical' THEN 0
@@ -291,8 +934,11 @@ async function getAlerts(pool, params) {
 }
 /** Get security alert statistics */
 async function getAlertStats(pool, params) {
-    let where = '1=1';
-    const values = [];
+    const scopeId = normalizeScopeId(params?.scopeId);
+    let where = 'scope_id = ?';
+    const values = [scopeId];
+    where += ' AND session_id NOT LIKE ?';
+    values.push(`${REPLAY_SESSION_PREFIX}%`);
     if (params?.timeFrom) {
         where += ' AND created_at >= ?';
         values.push(params.timeFrom);
@@ -304,20 +950,20 @@ async function getAlertStats(pool, params) {
     const [summaryRows] = await pool.query(`SELECT
        COUNT(*) as total_cnt,
        COALESCE(SUM(CASE WHEN created_at >= (NOW() - INTERVAL 24 HOUR) THEN 1 ELSE 0 END), 0) as recent_24h
-     FROM audit_alerts
+     FROM observation_alerts
      WHERE ${where}`, values);
     const [groupRows] = await pool.query(`SELECT 'severity' as grp, severity as k, COUNT(*) as cnt
-     FROM audit_alerts
+     FROM observation_alerts
      WHERE ${where}
      GROUP BY severity
      UNION ALL
      SELECT 'category' as grp, category as k, COUNT(*) as cnt
-     FROM audit_alerts
+     FROM observation_alerts
      WHERE ${where}
      GROUP BY category
      UNION ALL
      SELECT 'status' as grp, status as k, COUNT(*) as cnt
-     FROM audit_alerts
+     FROM observation_alerts
      WHERE ${where}
      GROUP BY status`, [...values, ...values, ...values]);
     const bySeverity = {};
@@ -347,22 +993,28 @@ async function getAlertStats(pool, params) {
     };
 }
 /** Update alert status */
-async function updateAlertStatus(pool, alertId, status, resolvedBy) {
+async function updateAlertStatus(pool, alertId, status, resolvedBy, scopeId) {
+    const scopedScopeId = normalizeScopeId(scopeId);
     const validStatuses = ['open', 'acknowledged', 'resolved'];
     if (!validStatuses.includes(status))
         return false;
     const resolvedAt = status === 'resolved'
         ? new Date().toISOString().replace('T', ' ').slice(0, 19) // compatible with MySQL & DuckDB
         : null;
-    await pool.query(`UPDATE audit_alerts SET status = ?, resolved_by = ?, resolved_at = ? WHERE alert_id = ?`, [status, resolvedBy || null, resolvedAt, alertId]);
+    await pool.query(`UPDATE observation_alerts SET status = ?, resolved_by = ?, resolved_at = ? WHERE scope_id = ? AND alert_id = ?`, [status, resolvedBy || null, resolvedAt, scopedScopeId, alertId]);
     // Verify update result (compatible with MySQL and DuckDB, not relying on affectedRows)
-    const [rows] = await pool.query('SELECT 1 FROM audit_alerts WHERE alert_id = ? AND status = ?', [alertId, status]);
+    const [rows] = await pool.query('SELECT 1 FROM observation_alerts WHERE scope_id = ? AND alert_id = ? AND status = ?', [scopedScopeId, alertId, status]);
     return rows.length > 0;
 }
 /** Get alerts for a session */
 async function getSessionAlerts(pool, sessionId, params) {
-    let where = 'session_id = ?';
-    const values = [sessionId];
+    const scopeId = normalizeScopeId(params?.scopeId);
+    let where = 'scope_id = ? AND session_id = ?';
+    const values = [scopeId, sessionId];
+    if (!String(sessionId || '').startsWith(REPLAY_SESSION_PREFIX)) {
+        where += ' AND session_id NOT LIKE ?';
+        values.push(`${REPLAY_SESSION_PREFIX}%`);
+    }
     if (params?.timeFrom) {
         where += ' AND created_at >= ?';
         values.push(params.timeFrom);
@@ -371,7 +1023,7 @@ async function getSessionAlerts(pool, sessionId, params) {
         where += ' AND created_at <= ?';
         values.push(params.timeTo);
     }
-    const [rows] = await pool.query(`SELECT * FROM audit_alerts WHERE ${where} ORDER BY created_at ASC`, values);
+    const [rows] = await pool.query(`SELECT * FROM observation_alerts WHERE ${where} ORDER BY created_at ASC`, values);
     return rows.map((r) => ({
         ...r,
         status: normalizeAlertStatus(String(r.status || '')),
@@ -379,10 +1031,15 @@ async function getSessionAlerts(pool, sessionId, params) {
 }
 /** Get comprehensive analytics data */
 async function getAnalytics(pool, params) {
-    let timeWhere = '1=1';
-    let sessTimeWhere = '1=1';
-    const timeVals = [];
-    const sessTimeVals = [];
+    const scopeId = normalizeScopeId(params.scopeId);
+    let timeWhere = 'scope_id = ?';
+    let sessTimeWhere = 'scope_id = ?';
+    const timeVals = [scopeId];
+    const sessTimeVals = [scopeId];
+    timeWhere += ' AND session_id NOT LIKE ?';
+    sessTimeWhere += ' AND session_id NOT LIKE ?';
+    timeVals.push(`${REPLAY_SESSION_PREFIX}%`);
+    sessTimeVals.push(`${REPLAY_SESSION_PREFIX}%`);
     if (params.timeFrom) {
         timeWhere += ' AND created_at >= ?';
         sessTimeWhere += ' AND start_time >= ?';
@@ -396,17 +1053,17 @@ async function getAnalytics(pool, params) {
         sessTimeVals.push(params.timeTo);
     }
     // 1. Overview KPIs
-    const [sessCount] = await pool.query('SELECT COUNT(*) as cnt FROM audit_sessions WHERE ' + sessTimeWhere, sessTimeVals);
+    const [sessCount] = await pool.query('SELECT COUNT(*) as cnt FROM observation_sessions WHERE ' + sessTimeWhere, sessTimeVals);
     const [actAgg] = await pool.query(`SELECT COUNT(*) as cnt,
             COALESCE(SUM(COALESCE(prompt_tokens,0)), 0) as inp,
             COALESCE(SUM(COALESCE(completion_tokens,0)), 0) as outp,
             COALESCE(AVG(NULLIF(duration_ms, 0)), 0) as avg_lat
-     FROM audit_actions WHERE ` + timeWhere, timeVals);
-    const [modelCount] = await pool.query(`SELECT COUNT(DISTINCT model_name) as cnt FROM audit_actions
+     FROM observation_actions WHERE ` + timeWhere, timeVals);
+    const [modelCount] = await pool.query(`SELECT COUNT(DISTINCT model_name) as cnt FROM observation_actions
      WHERE model_name != '' AND ` + timeWhere, timeVals);
     let secAlerts = 0;
     try {
-        const [alertCount] = await pool.query('SELECT COUNT(*) as cnt FROM audit_alerts WHERE ' + timeWhere, timeVals);
+        const [alertCount] = await pool.query('SELECT COUNT(*) as cnt FROM observation_alerts WHERE ' + timeWhere, timeVals);
         secAlerts = Number(alertCount[0]?.cnt ?? 0);
     }
     catch { /* alerts table may not exist */ }
@@ -430,16 +1087,17 @@ async function getAnalytics(pool, params) {
         if (spanMs <= 48 * 3600 * 1000)
             granularity = 'hour';
     }
-    // Build GROUP BY expressions compatible with both MySQL and DuckDB
+    // Build GROUP BY expressions compatible with both MySQL and DuckDB-like backends.
+    // Avoid CAST(... AS VARCHAR) because some MySQL-compatible engines reject it.
     const sessGroupExpr = granularity === 'hour'
-        ? `CAST(start_time AS VARCHAR)` // full timestamp string, we'll truncate in JS
-        : `CAST(start_time AS DATE)`;
+        ? `start_time` // full timestamp, truncated in JS
+        : `DATE(start_time)`;
     const actGroupExpr = granularity === 'hour'
-        ? `CAST(created_at AS VARCHAR)`
-        : `CAST(created_at AS DATE)`;
+        ? `created_at`
+        : `DATE(created_at)`;
     const [tsRows] = await pool.query(`SELECT ${sessGroupExpr} as bucket,
             COUNT(*) as sessions
-     FROM audit_sessions
+     FROM observation_sessions
      WHERE ` + sessTimeWhere + `
      GROUP BY ${sessGroupExpr}
      ORDER BY bucket ASC`, sessTimeVals);
@@ -447,7 +1105,7 @@ async function getAnalytics(pool, params) {
             COUNT(*) as actions,
             COALESCE(SUM(COALESCE(prompt_tokens,0)),0) as inp,
             COALESCE(SUM(COALESCE(completion_tokens,0)),0) as outp
-     FROM audit_actions
+     FROM observation_actions
      WHERE ` + timeWhere + `
      GROUP BY ${actGroupExpr}
      ORDER BY bucket ASC`, timeVals);
@@ -519,7 +1177,7 @@ async function getAnalytics(pool, params) {
             COALESCE(SUM(COALESCE(prompt_tokens,0)),0) as inp,
             COALESCE(SUM(COALESCE(completion_tokens,0)),0) as outp,
             COALESCE(AVG(NULLIF(duration_ms,0)),0) as avg_lat
-     FROM audit_actions
+     FROM observation_actions
      WHERE action_type = 'message' AND model_name != '' AND ` + timeWhere + `
      GROUP BY model_name
      ORDER BY inp + outp DESC
@@ -537,7 +1195,7 @@ async function getAnalytics(pool, params) {
         output: Number(r.outp),
     }));
     // 4. Action distribution
-    const [actTypeRows] = await pool.query(`SELECT action_type, COUNT(*) as cnt FROM audit_actions
+    const [actTypeRows] = await pool.query(`SELECT action_type, COUNT(*) as cnt FROM observation_actions
      WHERE ` + timeWhere + `
      GROUP BY action_type ORDER BY cnt DESC`, timeVals);
     const actionDistribution = {};
@@ -548,7 +1206,7 @@ async function getAnalytics(pool, params) {
     const [topAgentRows] = await pool.query(`SELECT b.user_id, b.sessions, b.tokens, COALESCE(COUNT(a.id), 0) as actions
      FROM (
        SELECT user_id, COUNT(DISTINCT session_id) as sessions, COALESCE(SUM(total_tokens), 0) as tokens
-       FROM audit_sessions
+       FROM observation_sessions
        WHERE user_id != ''
          AND LOWER(user_id) NOT IN ('unknown','unkown')
          AND ` + sessTimeWhere + `
@@ -558,7 +1216,7 @@ async function getAnalytics(pool, params) {
          sessions DESC
        LIMIT 10
      ) b
-     LEFT JOIN audit_actions a
+     LEFT JOIN observation_actions a
        ON a.user_id = b.user_id
       AND ` + timeWhere + `
      GROUP BY b.user_id, b.sessions, b.tokens
@@ -573,7 +1231,134 @@ async function getAnalytics(pool, params) {
     }));
     return { overview, timeSeries, granularity, modelUsage, actionDistribution, topAgents, tokensByModel };
 }
+function buildBucketTimeline(fromMs, toMs, stepMs) {
+    if (!Number.isFinite(fromMs) || !Number.isFinite(toMs) || !Number.isFinite(stepMs) || stepMs <= 0)
+        return [];
+    const start = Math.floor(fromMs / stepMs) * stepMs;
+    const end = Math.floor(toMs / stepMs) * stepMs;
+    const out = [];
+    for (let ts = start; ts <= end; ts += stepMs)
+        out.push(ts);
+    return out;
+}
+function inferFillMode(temporality) {
+    const t = String(temporality || '').trim().toLowerCase();
+    return t === 'delta' ? 'zero' : 'carry';
+}
+function densifySeriesPoints(points, timeline, fillMode, seedValue) {
+    if (!Array.isArray(points) || !points.length || !Array.isArray(timeline) || !timeline.length)
+        return [];
+    const byTs = new Map();
+    for (const p of points) {
+        const ts = Number(p.timestampMs || 0);
+        const v = Number(p.value || 0);
+        if (!Number.isFinite(ts) || !Number.isFinite(v))
+            continue;
+        byTs.set(ts, v);
+    }
+    let lastKnown = Number.isFinite(seedValue) ? Number(seedValue) : null;
+    if (fillMode === 'carry' && lastKnown == null) {
+        let firstTs = Infinity;
+        let firstVal = null;
+        for (const [ts, v] of byTs.entries()) {
+            if (ts < firstTs) {
+                firstTs = ts;
+                firstVal = v;
+            }
+        }
+        if (Number.isFinite(firstTs) && firstVal != null && Number.isFinite(firstVal)) {
+            lastKnown = Number(firstVal);
+        }
+    }
+    const out = [];
+    for (const ts of timeline) {
+        if (byTs.has(ts)) {
+            const v = Number(byTs.get(ts) || 0);
+            lastKnown = v;
+            out.push({ timestampMs: ts, value: v });
+            continue;
+        }
+        if (fillMode === 'zero') {
+            out.push({ timestampMs: ts, value: 0 });
+            continue;
+        }
+        if (lastKnown != null) {
+            out.push({ timestampMs: ts, value: lastKnown });
+        }
+    }
+    return out;
+}
+function inPlaceholders(n) {
+    return new Array(Math.max(0, n)).fill('?').join(', ');
+}
+async function fetchCarrySeedValuesV2(pool, params) {
+    const ids = (params.seriesIds || []).filter(Boolean);
+    if (!ids.length)
+        return new Map();
+    const placeholders = inPlaceholders(ids.length);
+    const sql = `
+    SELECT t.series_id AS series_id, t.v AS v
+    FROM (
+      SELECT
+        q.series_id AS series_id,
+        q.v AS v,
+        q.ts_ms AS ts_ms,
+        ROW_NUMBER() OVER (PARTITION BY q.series_id ORDER BY q.ts_ms DESC) AS rn
+      FROM (
+        SELECT s.series_id AS series_id, n.ts_ms AS ts_ms, n.value AS v
+        FROM oc_metric_points_number n
+        INNER JOIN oc_metric_series s ON s.series_id = n.series_id
+        WHERE s.scope_id = ? AND n.scope_id = ? AND s.metric_name = ? AND n.ts_ms < ? AND s.series_id IN (${placeholders})
+        UNION ALL
+        SELECT s2.series_id AS series_id, h.ts_ms AS ts_ms, CAST(h.count AS DOUBLE) AS v
+        FROM oc_metric_points_histogram h
+        INNER JOIN oc_metric_series s2 ON s2.series_id = h.series_id
+        WHERE s2.scope_id = ? AND h.scope_id = ? AND s2.metric_name = ? AND h.ts_ms < ? AND s2.series_id IN (${placeholders})
+      ) q
+    ) t
+    WHERE t.rn = 1
+  `;
+    const bind = [
+        params.scopeId, params.scopeId, params.metricName, params.beforeMs, ...ids,
+        params.scopeId, params.scopeId, params.metricName, params.beforeMs, ...ids,
+    ];
+    const [rows] = await pool.query(sql, bind);
+    const out = new Map();
+    for (const r of rows) {
+        const sid = String(r.series_id || '');
+        const v = Number(r.v || 0);
+        if (!sid || !Number.isFinite(v))
+            continue;
+        out.set(sid, v);
+    }
+    return out;
+}
+function aggregateSeriesPoints(series, timeline) {
+    if (!Array.isArray(series) || !series.length || !Array.isArray(timeline) || !timeline.length)
+        return [];
+    const seriesMaps = series.map((s) => {
+        const m = new Map();
+        for (const p of s.points || [])
+            m.set(Number(p.timestampMs || 0), Number(p.value || 0));
+        return m;
+    });
+    const out = [];
+    for (const ts of timeline) {
+        let sum = 0;
+        let hasAny = false;
+        for (const m of seriesMaps) {
+            if (!m.has(ts))
+                continue;
+            sum += Number(m.get(ts) || 0);
+            hasAny = true;
+        }
+        if (hasAny)
+            out.push({ timestampMs: ts, value: sum });
+    }
+    return out;
+}
 async function getMetricsOverview(pool, params) {
+    const scopeId = normalizeScopeId(params?.scopeId);
     const minutes = Math.min(Math.max(normalizePositiveInt(params?.minutes, 60), 1), 24 * 60);
     const limit = Math.min(Math.max(normalizePositiveInt(params?.limit, 100), 1), 500);
     const window = resolveMetricsWindow({
@@ -587,11 +1372,11 @@ async function getMetricsOverview(pool, params) {
         const [summaryRows] = await pool.query(`SELECT
          COUNT(DISTINCT s.metric_name) AS metric_cnt,
          (
-           COALESCE((SELECT COUNT(*) FROM oc_metric_points_number pn WHERE pn.ts_ms >= ? AND pn.ts_ms <= ?), 0) +
-           COALESCE((SELECT COUNT(*) FROM oc_metric_points_histogram ph WHERE ph.ts_ms >= ? AND ph.ts_ms <= ?), 0)
+           COALESCE((SELECT COUNT(*) FROM oc_metric_points_number pn WHERE pn.scope_id = ? AND pn.ts_ms >= ? AND pn.ts_ms <= ?), 0) +
+           COALESCE((SELECT COUNT(*) FROM oc_metric_points_histogram ph WHERE ph.scope_id = ? AND ph.ts_ms >= ? AND ph.ts_ms <= ?), 0)
          ) AS cnt
        FROM oc_metric_series s
-       WHERE s.last_seen_ms >= ? AND s.last_seen_ms <= ?`, [fromMs, toMs, fromMs, toMs, fromMs, toMs]);
+       WHERE s.scope_id = ? AND s.last_seen_ms >= ? AND s.last_seen_ms <= ?`, [scopeId, fromMs, toMs, scopeId, fromMs, toMs, scopeId, fromMs, toMs]);
         const [catalogRows] = await pool.query(`SELECT
          s.metric_name AS metric_name,
          MAX(s.metric_type) AS metric_type,
@@ -602,9 +1387,9 @@ async function getMetricsOverview(pool, params) {
        LEFT JOIN (
          SELECT series_id, COUNT(*) AS samples, MAX(ts_ms) AS latest_ts
          FROM (
-           SELECT series_id, ts_ms FROM oc_metric_points_number WHERE ts_ms >= ? AND ts_ms <= ?
+           SELECT series_id, ts_ms FROM oc_metric_points_number WHERE scope_id = ? AND ts_ms >= ? AND ts_ms <= ?
            UNION ALL
-           SELECT series_id, ts_ms FROM oc_metric_points_histogram WHERE ts_ms >= ? AND ts_ms <= ?
+           SELECT series_id, ts_ms FROM oc_metric_points_histogram WHERE scope_id = ? AND ts_ms >= ? AND ts_ms <= ?
          ) t
          GROUP BY series_id
        ) a ON a.series_id = s.series_id
@@ -612,10 +1397,10 @@ async function getMetricsOverview(pool, params) {
          ON n.series_id = s.series_id AND n.ts_ms = a.latest_ts
        LEFT JOIN oc_metric_points_histogram h
          ON h.series_id = s.series_id AND h.ts_ms = a.latest_ts
-       WHERE s.last_seen_ms >= ? AND s.last_seen_ms <= ?
+       WHERE s.scope_id = ? AND s.last_seen_ms >= ? AND s.last_seen_ms <= ?
        GROUP BY s.metric_name, a.samples, a.latest_ts
        ORDER BY s.metric_name ASC
-       LIMIT ?`, [fromMs, toMs, fromMs, toMs, fromMs, toMs, limit]);
+       LIMIT ?`, [scopeId, fromMs, toMs, scopeId, fromMs, toMs, scopeId, fromMs, toMs, limit]);
         const items = catalogRows.map((r) => ({
             metricName: String(r.metric_name || ''),
             metricType: String(r.metric_type || 'untyped'),
@@ -623,18 +1408,25 @@ async function getMetricsOverview(pool, params) {
             latestTimestampMs: Number(r.latest_ts || 0),
             latestValue: Number(r.latest_value || 0),
         }));
-        return {
+        const result = {
             totalMetrics: Number(summaryRows[0]?.metric_cnt ?? 0),
             totalSamples: Number(summaryRows[0]?.cnt ?? 0),
             rangeMinutes: window.rangeMinutes,
             items,
         };
+        // Some deployments still persist only legacy snapshots.
+        // If new-series tables return empty, fall back to legacy query path.
+        if (result.totalMetrics <= 0 && result.totalSamples <= 0 && items.length === 0) {
+            return getMetricsOverviewLegacy(pool, window.rangeMinutes, limit, fromMs, toMs);
+        }
+        return result;
     }
     catch {
         return getMetricsOverviewLegacy(pool, window.rangeMinutes, limit, fromMs, toMs);
     }
 }
 async function getMetricSeries(pool, params) {
+    const scopeId = normalizeScopeId(params.scopeId);
     const metricName = params.metricName?.trim();
     if (!metricName) {
         return {
@@ -656,27 +1448,28 @@ async function getMetricSeries(pool, params) {
     try {
         const [typeRows] = await pool.query(`SELECT metric_type
        FROM oc_metric_series
-       WHERE metric_name = ?
+       WHERE scope_id = ? AND metric_name = ?
        ORDER BY last_seen_ms DESC
-       LIMIT 1`, [metricName]);
+       LIMIT 1`, [scopeId, metricName]);
         const [rows] = await pool.query(`SELECT
-         CAST(FLOOR(q.ts_ms / ?) * ? AS BIGINT) AS bucket_ms,
+         FLOOR(q.ts_ms / ?) * ? AS bucket_ms,
          q.series_id AS series_id,
          q.labels_json AS labels_json,
+         q.temporality AS temporality,
          MAX(q.v) AS series_bucket_max
        FROM (
-         SELECT n.ts_ms AS ts_ms, n.value AS v, s.series_id AS series_id, s.labels_json AS labels_json
+         SELECT n.ts_ms AS ts_ms, n.value AS v, s.series_id AS series_id, s.labels_json AS labels_json, s.temporality AS temporality
          FROM oc_metric_points_number n
          INNER JOIN oc_metric_series s ON s.series_id = n.series_id
-         WHERE s.metric_name = ? AND n.ts_ms >= ? AND n.ts_ms <= ?
+         WHERE s.scope_id = ? AND n.scope_id = ? AND s.metric_name = ? AND n.ts_ms >= ? AND n.ts_ms <= ?
          UNION ALL
-         SELECT h.ts_ms AS ts_ms, CAST(h.count AS DOUBLE) AS v, s2.series_id AS series_id, s2.labels_json AS labels_json
+         SELECT h.ts_ms AS ts_ms, CAST(h.count AS DOUBLE) AS v, s2.series_id AS series_id, s2.labels_json AS labels_json, s2.temporality AS temporality
          FROM oc_metric_points_histogram h
          INNER JOIN oc_metric_series s2 ON s2.series_id = h.series_id
-         WHERE s2.metric_name = ? AND h.ts_ms >= ? AND h.ts_ms <= ?
+         WHERE s2.scope_id = ? AND h.scope_id = ? AND s2.metric_name = ? AND h.ts_ms >= ? AND h.ts_ms <= ?
        ) q
-       GROUP BY bucket_ms, q.series_id, q.labels_json
-       ORDER BY bucket_ms ASC, q.series_id ASC`, [stepMs, stepMs, metricName, fromMs, toMs, metricName, fromMs, toMs]);
+       GROUP BY bucket_ms, q.series_id, q.labels_json, q.temporality
+       ORDER BY bucket_ms ASC, q.series_id ASC`, [stepMs, stepMs, scopeId, scopeId, metricName, fromMs, toMs, scopeId, scopeId, metricName, fromMs, toMs]);
         const seriesMap = new Map();
         for (const r of rows) {
             const seriesId = String(r.series_id || '');
@@ -689,6 +1482,7 @@ async function getMetricSeries(pool, params) {
                 entry = {
                     seriesId,
                     labels: parseMetricLabelsJson(r.labels_json),
+                    temporality: String(r.temporality || ''),
                     points: [],
                     latestTimestampMs: 0,
                     samples: 0,
@@ -700,23 +1494,31 @@ async function getMetricSeries(pool, params) {
             if (timestampMs > entry.latestTimestampMs)
                 entry.latestTimestampMs = timestampMs;
         }
-        const series = Array.from(seriesMap.values());
+        const timeline = buildBucketTimeline(fromMs, toMs, stepMs);
+        const rawSeries = Array.from(seriesMap.values());
+        const carrySeriesIds = rawSeries
+            .filter((s) => inferFillMode(s.temporality) === 'carry')
+            .map((s) => s.seriesId);
+        const carrySeeds = carrySeriesIds.length
+            ? await fetchCarrySeedValuesV2(pool, { scopeId, metricName, beforeMs: fromMs, seriesIds: carrySeriesIds })
+            : new Map();
+        const series = rawSeries.map((s) => {
+            const mode = inferFillMode(s.temporality);
+            const seed = mode === 'carry' ? carrySeeds.get(s.seriesId) : undefined;
+            const densified = densifySeriesPoints(s.points, timeline, mode, seed);
+            return {
+                ...s,
+                points: densified,
+            };
+        });
         let points = [];
         if (aggregate) {
-            const bucketTotals = new Map();
-            for (const s of series) {
-                for (const p of s.points) {
-                    bucketTotals.set(p.timestampMs, (bucketTotals.get(p.timestampMs) || 0) + p.value);
-                }
-            }
-            points = Array.from(bucketTotals.entries())
-                .sort((a, b) => a[0] - b[0])
-                .map(([timestampMs, value]) => ({ timestampMs, value }));
+            points = aggregateSeriesPoints(series, timeline);
         }
         else if (series.length === 1) {
             points = series[0].points.slice();
         }
-        return {
+        const result = {
             metricName,
             metricType: String(typeRows[0]?.metric_type || 'untyped'),
             rangeMinutes: window.rangeMinutes,
@@ -725,6 +1527,12 @@ async function getMetricSeries(pool, params) {
             series,
             aggregateApplied: aggregate,
         };
+        // Backward compatibility: if v2 metrics tables are present but empty for this metric,
+        // try legacy snapshot table so charts still render.
+        if (result.series.length === 0 && result.points.length === 0) {
+            return getMetricSeriesLegacy(pool, metricName, window.rangeMinutes, stepSec, stepMs, fromMs, toMs, aggregate);
+        }
+        return result;
     }
     catch {
         return getMetricSeriesLegacy(pool, metricName, window.rangeMinutes, stepSec, stepMs, fromMs, toMs, aggregate);
@@ -778,10 +1586,10 @@ async function getMetricSeriesLegacy(pool, metricName, minutes, stepSec, stepMs,
        agg.series_bucket_max AS series_bucket_max
      FROM (
        SELECT
-         CAST(FLOOR(s.sample_timestamp_ms / ?) * ? AS BIGINT) AS bucket_ms,
+         FLOOR(s.sample_timestamp_ms / ?) * ? AS bucket_ms,
          COALESCE(
            NULLIF(TRIM(COALESCE(s.label_fingerprint, '')), ''),
-           CONCAT('id:', CAST(s.id AS CHAR))
+           CONCAT('labels:', COALESCE(s.labels_json, '{}'))
          ) AS series_key,
          COALESCE(s.labels_json, '{}') AS labels_json,
          MAX(s.value) AS series_bucket_max
@@ -789,15 +1597,9 @@ async function getMetricSeriesLegacy(pool, metricName, minutes, stepSec, stepMs,
        WHERE s.metric_name = ?
          AND s.sample_timestamp_ms >= ?
          AND s.sample_timestamp_ms <= ?
-       GROUP BY
-         CAST(FLOOR(s.sample_timestamp_ms / ?) * ? AS BIGINT),
-         COALESCE(
-           NULLIF(TRIM(COALESCE(s.label_fingerprint, '')), ''),
-           CONCAT('id:', CAST(s.id AS CHAR))
-         ),
-         COALESCE(s.labels_json, '{}')
+       GROUP BY 1, 2, 3
      ) agg
-     ORDER BY agg.bucket_ms ASC, agg.series_key ASC`, [stepMs, stepMs, metricName, fromMs, toMs, stepMs, stepMs]);
+     ORDER BY agg.bucket_ms ASC, agg.series_key ASC`, [stepMs, stepMs, metricName, fromMs, toMs]);
     const seriesMap = new Map();
     for (const r of rows) {
         const seriesId = String(r.series_id || '');
@@ -822,20 +1624,17 @@ async function getMetricSeriesLegacy(pool, metricName, minutes, stepSec, stepMs,
             entry.latestTimestampMs = timestampMs;
     }
     const series = Array.from(seriesMap.values());
+    const timeline = buildBucketTimeline(fromMs, toMs, stepMs);
+    const densifiedSeries = series.map((s) => ({
+        ...s,
+        points: densifySeriesPoints(s.points, timeline, 'carry'),
+    }));
     let points = [];
     if (aggregate) {
-        const bucketTotals = new Map();
-        for (const s of series) {
-            for (const p of s.points) {
-                bucketTotals.set(p.timestampMs, (bucketTotals.get(p.timestampMs) || 0) + p.value);
-            }
-        }
-        points = Array.from(bucketTotals.entries())
-            .sort((a, b) => a[0] - b[0])
-            .map(([timestampMs, value]) => ({ timestampMs, value }));
+        points = aggregateSeriesPoints(densifiedSeries, timeline);
     }
-    else if (series.length === 1) {
-        points = series[0].points.slice();
+    else if (densifiedSeries.length === 1) {
+        points = densifiedSeries[0].points.slice();
     }
     return {
         metricName,
@@ -843,7 +1642,7 @@ async function getMetricSeriesLegacy(pool, metricName, minutes, stepSec, stepMs,
         rangeMinutes: minutes,
         stepSec,
         points,
-        series,
+        series: densifiedSeries,
         aggregateApplied: aggregate,
     };
 }
@@ -869,11 +1668,12 @@ function parseMetricLabelsJson(raw) {
     }
 }
 async function getTraceObservationTree(pool, traceId, params) {
+    const scopeId = normalizeScopeId(params?.scopeId);
     const id = String(traceId || '').trim();
     if (!id)
         return { traceId: '', observations: [] };
-    let where = 'c.trace_id = ?';
-    const values = [id];
+    let where = 'c.scope_id = ? AND c.trace_id = ?';
+    const values = [scopeId, id];
     if (params?.timeFrom) {
         where += ' AND c.start_time >= ?';
         values.push(params.timeFrom);
@@ -886,6 +1686,7 @@ async function getTraceObservationTree(pool, traceId, params) {
         const [rows] = await pool.query(`SELECT
          c.observation_id AS observation_id,
          c.parent_observation_id AS parent_observation_id,
+         pcore.run_id AS parent_run_id,
          c.root_observation_id AS root_observation_id,
          c.trace_id AS trace_id,
          c.observation_type AS observation_type,
@@ -912,6 +1713,8 @@ async function getTraceObservationTree(pool, traceId, params) {
          p.model_params_json AS model_params_json,
          p.error_json AS error_json
        FROM oc_observations_core c
+       LEFT JOIN oc_observations_core pcore
+         ON pcore.observation_id = c.parent_observation_id
        LEFT JOIN oc_observations_payload p
          ON p.observation_id = c.observation_id
        WHERE ${where}
@@ -921,6 +1724,7 @@ async function getTraceObservationTree(pool, traceId, params) {
             observations: rows.map((r) => ({
                 observationId: String(r.observation_id || ''),
                 parentObservationId: r.parent_observation_id ? String(r.parent_observation_id) : null,
+                parentRunId: r.parent_run_id ? String(r.parent_run_id) : null,
                 rootObservationId: String(r.root_observation_id || ''),
                 traceId: String(r.trace_id || ''),
                 type: String(r.observation_type || ''),