@evomap/evolver-webui 2.0.0-beta.2 → 2.0.0-beta.4

package/dist/githubPrDiagnostics.js

@@ -0,0 +1,164 @@
+import { execFile } from 'node:child_process';
+import { redactDiagnosticText } from './diagnosticSanitize.js';
+export const GITHUB_PR_TIMEOUT_MS = 15_000;
+export const GITHUB_PR_MAX_BUFFER_BYTES = 512 * 1024;
+export const GITHUB_PR_CACHE_TTL_MS = 45_000;
+export const GITHUB_PR_MAX_ITEMS = 50;
+const GH_FIELDS = 'number,title,url,state,isDraft,headRefName,baseRefName,updatedAt,reviewDecision,statusCheckRollup';
+export const defaultGithubPrRunner = async (command, args, options) => new Promise((resolve) => {
+    execFile(command, [...args], {
+        ...(options.cwd ? { cwd: options.cwd } : {}),
+        encoding: 'utf8',
+        timeout: options.timeoutMs,
+        maxBuffer: options.maxBufferBytes,
+        shell: options.shell,
+        windowsHide: true,
+    }, (error, stdout) => {
+        const code = error && typeof error.code === 'number' ? error.code : error ? 1 : 0;
+        resolve({ code, stdout: typeof stdout === 'string' ? stdout : '' });
+    });
+});
+function boundedInteger(value, fallback, maximum) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return fallback;
+    return Math.max(1, Math.min(maximum, Math.floor(value)));
+}
+function safeText(value, maxChars) {
+    return redactDiagnosticText(value, maxChars);
+}
+function safeGithubUrl(value) {
+    if (typeof value !== 'string' || value.length > 2_000)
+        return null;
+    try {
+        const url = new URL(value);
+        const hostname = url.hostname.toLowerCase();
+        if (url.protocol !== 'https:' || url.port || (hostname !== 'github.com' && !hostname.endsWith('.github.com')))
+            return null;
+        url.username = '';
+        url.password = '';
+        url.hash = '';
+        url.search = '';
+        return url.toString().slice(0, 2_000);
+    }
+    catch {
+        return null;
+    }
+}
+function safeState(value) {
+    const state = String(value ?? '').toUpperCase();
+    return state === 'OPEN' || state === 'CLOSED' || state === 'MERGED' ? state : 'UNKNOWN';
+}
+function safeReviewDecision(value) {
+    if (value === null || value === undefined || value === '')
+        return null;
+    const decision = String(value).toUpperCase();
+    return decision === 'APPROVED' || decision === 'CHANGES_REQUESTED' || decision === 'REVIEW_REQUIRED'
+        ? decision
+        : 'UNKNOWN';
+}
+function safeTimestamp(value) {
+    if (typeof value !== 'string')
+        return null;
+    const text = safeText(value, 64);
+    return Number.isNaN(Date.parse(text)) ? null : text;
+}
+function checkCounts(value) {
+    const counts = { total: 0, passed: 0, failed: 0, pending: 0 };
+    if (!Array.isArray(value))
+        return counts;
+    for (const raw of value.slice(0, 200)) {
+        const record = raw && typeof raw === 'object' ? raw : {};
+        const status = String(record['conclusion'] ?? record['state'] ?? record['status'] ?? '').toUpperCase();
+        counts.total += 1;
+        if (['SUCCESS', 'NEUTRAL', 'SKIPPED'].includes(status))
+            counts.passed += 1;
+        else if (['FAILURE', 'ERROR', 'CANCELLED', 'TIMED_OUT', 'ACTION_REQUIRED', 'STARTUP_FAILURE'].includes(status))
+            counts.failed += 1;
+        else
+            counts.pending += 1;
+    }
+    return counts;
+}
+function parsePr(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const record = raw;
+    const number = typeof record['number'] === 'number' ? Math.floor(record['number']) : Number.NaN;
+    const url = safeGithubUrl(record['url']);
+    if (!Number.isSafeInteger(number) || number <= 0 || !url)
+        return null;
+    return {
+        number,
+        title: safeText(record['title'], 300),
+        url,
+        state: safeState(record['state']),
+        isDraft: record['isDraft'] === true,
+        head: safeText(record['headRefName'], 200),
+        base: safeText(record['baseRefName'], 200),
+        updatedAt: safeTimestamp(record['updatedAt']),
+        reviewDecision: safeReviewDecision(record['reviewDecision']),
+        checks: checkCounts(record['statusCheckRollup']),
+    };
+}
+async function loadGithubPrDiagnostics(runner, options) {
+    try {
+        const result = await runner('gh', [
+            'pr', 'list', '--state', 'all', '--limit', String(options.maxItems), '--json', GH_FIELDS,
+        ], {
+            ...(options.cwd ? { cwd: options.cwd } : {}),
+            timeoutMs: GITHUB_PR_TIMEOUT_MS,
+            maxBufferBytes: GITHUB_PR_MAX_BUFFER_BYTES,
+            shell: false,
+        });
+        if (result.code !== 0)
+            return { available: false, error: 'github_pr_unavailable' };
+        let raw;
+        try {
+            raw = JSON.parse(result.stdout || '[]');
+        }
+        catch {
+            return { available: false, error: 'github_pr_invalid_response' };
+        }
+        if (!Array.isArray(raw))
+            return { available: false, error: 'github_pr_invalid_response' };
+        const selected = raw.slice(0, options.maxItems);
+        const prs = selected.map(parsePr).filter((row) => row !== null);
+        return {
+            available: true,
+            data: {
+                prs,
+                truncated: raw.length > selected.length || prs.length < selected.length,
+                refreshedAt: new Date(options.now()).toISOString(),
+            },
+        };
+    }
+    catch {
+        return { available: false, error: 'github_pr_unavailable' };
+    }
+}
+export function createGithubPrDiagnosticsProvider(options = {}) {
+    const runner = options.runner ?? defaultGithubPrRunner;
+    const now = options.now ?? Date.now;
+    const requestedTtl = boundedInteger(options.ttlMs, GITHUB_PR_CACHE_TTL_MS, 60_000);
+    const ttlMs = Math.max(30_000, requestedTtl);
+    const maxItems = boundedInteger(options.maxItems, GITHUB_PR_MAX_ITEMS, GITHUB_PR_MAX_ITEMS);
+    let cached = null;
+    let inflight = null;
+    return {
+        read() {
+            const current = now();
+            if (cached && current - cached.at < ttlMs)
+                return Promise.resolve(cached.value);
+            if (inflight)
+                return inflight;
+            inflight = loadGithubPrDiagnostics(runner, { cwd: options.cwd, now, maxItems })
+                .then((value) => {
+                if (value.available)
+                    cached = { at: now(), value };
+                return value;
+            })
+                .finally(() => { inflight = null; });
+            return inflight;
+        },
+    };
+}

package/dist/index.d.ts

@@ -1,3 +1,6 @@
 export declare const PACKAGE = "@evomap/evolver-webui";
 export * from './server.js';
-export { CONSOLE_HTML } from './console.js';
+export { CONSOLE_HTML } from './console.js';
+export * from './personalityDiagnostics.js';
+export * from './logDiagnostics.js';
+export * from './githubPrDiagnostics.js';

package/dist/index.js

@@ -1,3 +1,6 @@
 export const PACKAGE = '@evomap/evolver-webui';
 export * from './server.js';
-export { CONSOLE_HTML } from './console.js';
+export { CONSOLE_HTML } from './console.js';
+export * from './personalityDiagnostics.js';
+export * from './logDiagnostics.js';
+export * from './githubPrDiagnostics.js';

package/dist/logDiagnostics.d.ts

@@ -0,0 +1,18 @@
+export declare const LOG_DIAGNOSTICS_MAX_BYTES: number;
+export declare const LOG_DIAGNOSTICS_MAX_LINES = 200;
+export interface LogDiagnosticsData {
+    lines: string[];
+    truncated: boolean;
+}
+export type LogDiagnosticsResult = {
+    available: true;
+    data: LogDiagnosticsData;
+} | {
+    available: false;
+    error: 'log_not_found' | 'log_unavailable';
+};
+export interface LogDiagnosticsOptions {
+    maxBytes?: number;
+    maxLines?: number;
+}
+export declare function readLogDiagnostics(logFile: string, options?: LogDiagnosticsOptions): LogDiagnosticsResult;

package/dist/logDiagnostics.js

@@ -0,0 +1,81 @@
+import { closeSync, constants, fstatSync, lstatSync, openSync, readSync } from 'node:fs';
+export const LOG_DIAGNOSTICS_MAX_BYTES = 128 * 1024;
+export const LOG_DIAGNOSTICS_MAX_LINES = 200;
+const LOG_DIAGNOSTICS_HARD_MAX_BYTES = 1024 * 1024;
+const LOG_DIAGNOSTICS_HARD_MAX_LINES = 1_000;
+const MAX_LINE_CHARS = 4_000;
+function boundedInteger(value, fallback, maximum) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return fallback;
+    return Math.max(1, Math.min(maximum, Math.floor(value)));
+}
+function redactSecrets(input) {
+    let text = input;
+    text = text.replace(/-----BEGIN(?: [A-Z0-9]+)* PRIVATE KEY-----[\s\S]*?-----END(?: [A-Z0-9]+)* PRIVATE KEY-----/gi, '[redacted private key]');
+    text = text.replace(/-----BEGIN(?: [A-Z0-9]+)* PRIVATE KEY-----[\s\S]*$/gi, '[redacted private key]');
+    text = text.replace(/\bBearer\s+[^\s,;"']+/gi, 'Bearer [redacted]');
+    text = text.replace(/\b(authorization|proxy-authorization|api[_ -]?key|token|access[_ -]?token|refresh[_ -]?token|password|passwd|cookie|set-cookie)\b(\s*[=:]\s*)(?:"[^"]*"|'[^']*'|[^\s,;]+)/gi, '$1$2[redacted]');
+    text = text.replace(/([?&](?:api[_-]?key|token|access_token|password)=)[^&\s]+/gi, '$1[redacted]');
+    return text;
+}
+function replaceUnsafeControls(value) {
+    let out = '';
+    for (const char of value) {
+        const code = char.codePointAt(0) ?? 0;
+        out += code >= 0x20 || code === 0x09 || code === 0x0a || code === 0x0d ? char : ' ';
+    }
+    return out;
+}
+function safeLine(line) {
+    const normalized = replaceUnsafeControls(line);
+    if (/^[A-Za-z0-9+/]{40,}={0,2}$/.test(normalized.trim()))
+        return '[redacted private key material]';
+    return normalized.slice(0, MAX_LINE_CHARS);
+}
+export function readLogDiagnostics(logFile, options = {}) {
+    const maxBytes = boundedInteger(options.maxBytes, LOG_DIAGNOSTICS_MAX_BYTES, LOG_DIAGNOSTICS_HARD_MAX_BYTES);
+    const maxLines = boundedInteger(options.maxLines, LOG_DIAGNOSTICS_MAX_LINES, LOG_DIAGNOSTICS_HARD_MAX_LINES);
+    let fd;
+    try {
+        const before = lstatSync(logFile);
+        if (before.isSymbolicLink() || !before.isFile())
+            return { available: false, error: 'log_unavailable' };
+        const noFollow = constants.O_NOFOLLOW ?? 0;
+        fd = openSync(logFile, constants.O_RDONLY | noFollow);
+        const stats = fstatSync(fd);
+        const current = lstatSync(logFile);
+        if (current.isSymbolicLink() || !current.isFile() || !stats.isFile()
+            || current.dev !== stats.dev || current.ino !== stats.ino) {
+            return { available: false, error: 'log_unavailable' };
+        }
+        const size = stats.size;
+        const bytes = Math.min(size, maxBytes);
+        const start = Math.max(0, size - bytes);
+        const buffer = Buffer.alloc(bytes);
+        if (bytes > 0)
+            readSync(fd, buffer, 0, bytes, start);
+        let text = buffer.toString('utf8');
+        if (start > 0) {
+            const firstNewline = text.indexOf('\n');
+            text = firstNewline >= 0 ? text.slice(firstNewline + 1) : '';
+        }
+        const redacted = redactSecrets(text);
+        const allLines = redacted.split(/\r?\n/).filter((line) => line.length > 0);
+        const lineTruncated = allLines.length > maxLines;
+        return {
+            available: true,
+            data: {
+                lines: allLines.slice(-maxLines).map(safeLine),
+                truncated: start > 0 || lineTruncated,
+            },
+        };
+    }
+    catch (error) {
+        const code = error && typeof error === 'object' ? error.code : undefined;
+        return { available: false, error: code === 'ENOENT' ? 'log_not_found' : 'log_unavailable' };
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
+}

package/dist/observabilityRelations.d.ts

@@ -0,0 +1,22 @@
+import type { events as ev } from '@evomap/evolver-core';
+export interface AssetRelation {
+    id: string;
+    assetId: string;
+    type: string;
+}
+export interface TrajectoryRelation {
+    traceId: string;
+    sessionId: string;
+}
+export interface PullRequestRelation {
+    number: number | null;
+    url: string;
+    repo: string;
+}
+export interface ObservabilityRelations {
+    assets: AssetRelation[];
+    trajectories: TrajectoryRelation[];
+    pullRequests: PullRequestRelation[];
+}
+export declare function eventRelations(event: ev.ReportEvent): ObservabilityRelations;
+export declare function eventListRelations(events: readonly ev.ReportEvent[]): ObservabilityRelations;

package/dist/observabilityRelations.js

@@ -0,0 +1,93 @@
+import { redactDiagnosticText } from './diagnosticSanitize.js';
+const MAX_ID = 160;
+const MAX_RELATIONS = 50;
+const OPAQUE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9:._-]{0,159}$/;
+function safeOpaqueId(value) {
+    if (typeof value !== 'string')
+        return '';
+    const id = value.trim();
+    return OPAQUE_ID_RE.test(id) ? id : '';
+}
+function safeDisplayText(value) {
+    if (typeof value !== 'string')
+        return '';
+    return redactDiagnosticText(value, MAX_ID);
+}
+function safePrUrl(value) {
+    if (typeof value !== 'string')
+        return '';
+    const raw = value.replace(/[\r\n\t]/g, '').trim();
+    if (!raw)
+        return '';
+    try {
+        const url = new URL(raw);
+        if (url.protocol !== 'https:')
+            return '';
+        const host = url.hostname.toLowerCase();
+        if ((host !== 'github.com' && !host.endsWith('.github.com')) || url.port)
+            return '';
+        url.username = '';
+        url.password = '';
+        url.search = '';
+        url.hash = '';
+        return url.toString().slice(0, MAX_ID);
+    }
+    catch {
+        return '';
+    }
+}
+function positivePrNumber(value) {
+    const number = typeof value === 'number' ? value : Number(value);
+    return Number.isSafeInteger(number) && number > 0 ? number : null;
+}
+function addAsset(out, value, type) {
+    const id = safeOpaqueId(value);
+    if (!id || out.size >= MAX_RELATIONS)
+        return;
+    const key = `${type}:${id}`;
+    if (!out.has(key))
+        out.set(key, { id, assetId: id, type });
+}
+function addAssetArray(out, value, type) {
+    if (!Array.isArray(value))
+        return;
+    for (const item of value)
+        addAsset(out, item, type);
+}
+function relationsFromPayload(payload) {
+    const assets = new Map();
+    addAsset(assets, payload['assetId'] ?? payload['asset_id'], 'asset');
+    addAsset(assets, payload['geneId'] ?? payload['gene'], 'gene');
+    addAsset(assets, payload['capsuleId'] ?? payload['capsule_id'], 'capsule');
+    addAssetArray(assets, payload['assetIds'] ?? payload['asset_ids'], 'asset');
+    addAssetArray(assets, payload['genesUsed'] ?? payload['genes_used'] ?? payload['genes'], 'gene');
+    const traceId = safeOpaqueId(payload['traceId'] ?? payload['trace_id'] ?? payload['trajectoryId'] ?? payload['trajectory_id']);
+    const sessionId = safeOpaqueId(payload['sessionId'] ?? payload['session_id']);
+    const trajectories = traceId || sessionId ? [{ traceId, sessionId }] : [];
+    const url = safePrUrl(payload['pullRequestUrl'] ?? payload['pull_request_url'] ?? payload['prUrl'] ?? payload['pr_url'] ?? payload['githubPrUrl']);
+    const number = positivePrNumber(payload['pullRequestNumber'] ?? payload['pull_request_number'] ?? payload['prNumber'] ?? payload['pr_number'] ?? payload['githubPrNumber']);
+    const repo = safeDisplayText(payload['repo'] ?? payload['repository'] ?? payload['githubRepo']);
+    const pullRequests = url || number !== null ? [{ number, url, repo }] : [];
+    return { assets: [...assets.values()], trajectories, pullRequests };
+}
+function dedupe(items, key) {
+    const out = new Map();
+    for (const item of items) {
+        const itemKey = key(item);
+        if (!itemKey || out.has(itemKey) || out.size >= MAX_RELATIONS)
+            continue;
+        out.set(itemKey, item);
+    }
+    return [...out.values()];
+}
+export function eventRelations(event) {
+    return relationsFromPayload((event.payload ?? {}));
+}
+export function eventListRelations(events) {
+    const relations = events.map(eventRelations);
+    return {
+        assets: dedupe(relations.flatMap((entry) => entry.assets), (item) => `${item.type}:${item.assetId}`),
+        trajectories: dedupe(relations.flatMap((entry) => entry.trajectories), (item) => `${item.traceId}:${item.sessionId}`),
+        pullRequests: dedupe(relations.flatMap((entry) => entry.pullRequests), (item) => `${item.url}:${item.repo}:${item.number ?? ''}`),
+    };
+}

package/dist/personalityDiagnostics.d.ts

@@ -0,0 +1,41 @@
+import { type personality as PersonalityNamespace } from '@evomap/evolver-core';
+export declare const PERSONALITY_DIAGNOSTICS_MAX_STATS = 40;
+export declare const PERSONALITY_DIAGNOSTICS_MAX_HISTORY = 60;
+export type PersonalityAxisValues = Pick<PersonalityNamespace.PersonalityState, 'rigor' | 'creativity' | 'verbosity' | 'risk_tolerance' | 'obedience'>;
+export interface PersonalityDiagnosticStat {
+    key: string;
+    success: number;
+    fail: number;
+    avgScore: number;
+    n: number;
+    updatedAt: string | null;
+}
+export interface PersonalityDiagnosticHistoryEntry {
+    at: string;
+    key: string;
+    outcome: string;
+    score: number | null;
+}
+export interface PersonalityDiagnosticData {
+    current: PersonalityAxisValues;
+    updatedAt: string | null;
+    stats: PersonalityDiagnosticStat[];
+    history: PersonalityDiagnosticHistoryEntry[];
+    truncated: {
+        stats: boolean;
+        history: boolean;
+    };
+}
+export type PersonalityDiagnosticsResult = {
+    available: true;
+    data: PersonalityDiagnosticData;
+} | {
+    available: false;
+    error: 'personality_unavailable';
+};
+export type PersonalityDiagnosticsReader = () => unknown | Promise<unknown>;
+export interface PersonalityDiagnosticsOptions {
+    maxStats?: number;
+    maxHistory?: number;
+}
+export declare function readPersonalityDiagnostics(reader: PersonalityDiagnosticsReader | undefined, options?: PersonalityDiagnosticsOptions): Promise<PersonalityDiagnosticsResult>;

package/dist/personalityDiagnostics.js

@@ -0,0 +1,101 @@
+import { personality } from '@evomap/evolver-core';
+import { redactDiagnosticText } from './diagnosticSanitize.js';
+export const PERSONALITY_DIAGNOSTICS_MAX_STATS = 40;
+export const PERSONALITY_DIAGNOSTICS_MAX_HISTORY = 60;
+const MAX_TEXT_CHARS = 240;
+function boundedInteger(value, fallback, maximum) {
+    if (!Number.isFinite(value))
+        return fallback;
+    return Math.max(1, Math.min(maximum, Math.floor(value)));
+}
+function finiteNumber(value, fallback = 0) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+function nonnegativeInteger(value) {
+    return Math.max(0, Math.floor(finiteNumber(value)));
+}
+function replaceControlCharacters(value) {
+    let out = '';
+    for (const char of value) {
+        const code = char.codePointAt(0) ?? 0;
+        out += code < 0x20 || code === 0x7f ? ' ' : char;
+    }
+    return out;
+}
+function boundedText(value, maxChars = MAX_TEXT_CHARS) {
+    return replaceControlCharacters(String(value ?? '')).slice(0, maxChars);
+}
+function nullableTimestamp(value) {
+    if (typeof value !== 'string')
+        return null;
+    const text = boundedText(value, 64);
+    return Number.isNaN(Date.parse(text)) ? null : text;
+}
+function axisValue(value) {
+    return Math.max(0, Math.min(1, finiteNumber(value)));
+}
+function currentAxes(value) {
+    const record = value && typeof value === 'object' ? value : {};
+    return {
+        rigor: axisValue(record['rigor']),
+        creativity: axisValue(record['creativity']),
+        verbosity: axisValue(record['verbosity']),
+        risk_tolerance: axisValue(record['risk_tolerance']),
+        obedience: axisValue(record['obedience']),
+    };
+}
+function statRows(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return [];
+    return Object.entries(value).map(([key, raw]) => {
+        const record = raw && typeof raw === 'object' ? raw : {};
+        return {
+            key: redactDiagnosticText(key, MAX_TEXT_CHARS),
+            success: nonnegativeInteger(record['success']),
+            fail: nonnegativeInteger(record['fail']),
+            avgScore: axisValue(record['avgScore']),
+            n: nonnegativeInteger(record['n']),
+            updatedAt: nullableTimestamp(record['updatedAt']),
+        };
+    }).sort((left, right) => (right.updatedAt ?? '').localeCompare(left.updatedAt ?? ''));
+}
+function historyRows(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.map((raw) => {
+        const record = raw && typeof raw === 'object' ? raw : {};
+        return {
+            at: nullableTimestamp(record['at']) ?? '',
+            key: redactDiagnosticText(record['key'], MAX_TEXT_CHARS),
+            outcome: redactDiagnosticText(record['outcome'], MAX_TEXT_CHARS),
+            score: record['score'] === null ? null : axisValue(record['score']),
+        };
+    });
+}
+export async function readPersonalityDiagnostics(reader, options = {}) {
+    if (!reader)
+        return { available: false, error: 'personality_unavailable' };
+    try {
+        const raw = await reader();
+        const parsed = personality.personalityModel.safeParse(raw);
+        if (!parsed.success)
+            return { available: false, error: 'personality_unavailable' };
+        const maxStats = boundedInteger(options.maxStats, PERSONALITY_DIAGNOSTICS_MAX_STATS, PERSONALITY_DIAGNOSTICS_MAX_STATS);
+        const maxHistory = boundedInteger(options.maxHistory, PERSONALITY_DIAGNOSTICS_MAX_HISTORY, PERSONALITY_DIAGNOSTICS_MAX_HISTORY);
+        const stats = statRows(parsed.data.stats);
+        const history = historyRows(parsed.data.history);
+        return {
+            available: true,
+            data: {
+                current: currentAxes(parsed.data.current),
+                updatedAt: nullableTimestamp(parsed.data.updatedAt),
+                stats: stats.slice(0, maxStats),
+                history: history.slice(-maxHistory).reverse(),
+                truncated: { stats: stats.length > maxStats, history: history.length > maxHistory },
+            },
+        };
+    }
+    catch {
+        return { available: false, error: 'personality_unavailable' };
+    }
+}

package/dist/server.d.ts

@@ -1,11 +1,29 @@
 import { events as ev, assetstore, mailbox as mb, ops } from '@evomap/evolver-core';
 import { type EventSnapshotSource } from './eventSnapshot.js';
+export interface MemoryGraphStatus {
+    recovery: 'healthy' | 'degraded' | 'recovered' | 'empty';
+    compactedRecords: number;
+    activeRecords: number;
+    corruptLines: number;
+    oversizedLines: number;
+    oversizedFiles: number;
+    archives: number;
+    selectionReason?: string;
+}
+export type MemoryGraphStatusResponse = ({
+    available: true;
+} & MemoryGraphStatus) | {
+    available: false;
+    error?: 'memory_graph_unavailable';
+};
 export interface WebUIServerDeps {
     eventsPath: string;
     ingestor?: ev.Ingestor;
     store?: assetstore.AssetStoreProvider;
     /** 人审队列用的 review ledger(#117 人审门）。缺省由 LocalJsonlProvider store 的 baseDir 推导。 */
     review?: assetstore.ReviewLedger;
+    /** Optional provenance sidecar; inferred for a LocalJsonlProvider when absent. */
+    provenance?: assetstore.ProvenanceStore;
     mailbox?: mb.MailboxStore;
     now?: () => number;
     host?: string;
@@ -22,8 +40,14 @@ export interface WebUIServerDeps {
     valueSummary?: (window: ops.SummaryWindow, events: readonly ev.ReportEvent[]) => ops.ValueSummary;
     /** Shared core retention report provider. Kept injectable so WebUI never owns filesystem policy or paths. */
     retentionReport?: () => ev.RetentionReport;
+    /** Read-only, already scoped MemoryGraph operator status. Re-read for every request; WebUI only exposes a sanitized allowlist. */
+    memoryGraphStatus?: () => MemoryGraphStatus;
     /** Injectable file/source seam for versioned root-event snapshots. */
     eventSource?: EventSnapshotSource;
+    /** Optional bounded diagnostics providers. Each source degrades independently. */
+    personalityDiagnostics?: () => unknown | Promise<unknown>;
+    logDiagnostics?: () => unknown | Promise<unknown>;
+    githubPrDiagnostics?: () => unknown | Promise<unknown>;
 }
 /**
  * WebUI 控台(M7): 可观测 + 保活. node:http + 自包含 HTML, 仅绑 loopback.
@@ -38,6 +62,7 @@ export declare class WebUIServer {
     private readonly actorId;
     /** Review ledger backing the human-review queue. Undefined when no LocalJsonlProvider store is available. */
     private readonly review;
+    private readonly provenance;
     /** Token guarding /api/*; supplied by the browser via Bearer, with ?token= retained for compatibility. */
     readonly token: string;
     readonly launchTicket: string;