oh-my-knowledge 0.43.0 → 0.44.0

package/dist/artifact-graph/eval.d.ts

@@ -0,0 +1,16 @@
+import type { ArtifactGraphDocument, EvaluationReport } from '../types/index.js';
+export interface BuildEvalGraphOptions {
+    report: EvaluationReport;
+    sourcePath: string;
+    generatedAt?: string;
+}
+export interface PersistEvalGraphOptions extends BuildEvalGraphOptions {
+    outputDir: string;
+    fileStem?: string;
+}
+export interface PersistEvalGraphResult {
+    graphPath: string;
+}
+export declare function evalGraphDirForReportOutput(reportOutputDir: string): string;
+export declare function buildEvalArtifactGraph(options: BuildEvalGraphOptions): ArtifactGraphDocument;
+export declare function persistEvalGraphSidecar(options: PersistEvalGraphOptions): PersistEvalGraphResult;

package/dist/artifact-graph/eval.js

@@ -0,0 +1,351 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { graphFileName } from '../eval-core/artifact-file-names.js';
+function shortHash(input) {
+    return createHash('sha256').update(input).digest('hex').slice(0, 12);
+}
+function jsonPointerToken(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}
+function sampleSetHash(sampleHashes) {
+    if (!sampleHashes || Object.keys(sampleHashes).length === 0)
+        return undefined;
+    const canonical = Object.entries(sampleHashes)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([id, hash]) => `${id}:${hash}`)
+        .join('|');
+    return shortHash(canonical);
+}
+function statusFromScore(score) {
+    // Display band only. This is not the verdict gate and intentionally does not
+    // reference DEFAULT_GATE_THRESHOLD or statistical significance decisions.
+    if (score === undefined || !Number.isFinite(score))
+        return 'unknown';
+    if (score >= 4)
+        return 'ok';
+    if (score >= 3)
+        return 'warning';
+    return 'failed';
+}
+function assertionStatus(result) {
+    // Assertion topology status only. Pure LLM-scored samples have no assertion
+    // pass/fail edge, so they stay unknown here even when compositeScore is high.
+    if (result.error || !result.ok)
+        return 'failed';
+    const details = result.assertions?.details;
+    if (!details || details.length === 0)
+        return 'unknown';
+    return details.every((detail) => detail.passed) ? 'ok' : 'failed';
+}
+function artifactBinding(variant, hash) {
+    if (hash && hash !== 'no-skill') {
+        return { bindingStrength: 'content-hash', keys: { artifactHash: hash } };
+    }
+    return { bindingStrength: 'name-only', keys: { variantName: variant } };
+}
+function sampleBinding(sampleId, hash) {
+    if (hash) {
+        return { bindingStrength: 'content-hash', keys: { sampleHash: hash } };
+    }
+    return { bindingStrength: 'name-only', keys: { sampleId } };
+}
+function variantConfigByName(report) {
+    return new Map((report.meta.variantConfigs ?? []).map((config) => [config.variant, config]));
+}
+function scopeArtifactKind(report) {
+    const kinds = new Set((report.meta.variantConfigs ?? [])
+        .map((config) => config.artifactKind)
+        .filter((kind) => kind !== 'baseline'));
+    return kinds.size === 1 ? [...kinds][0] : undefined;
+}
+function sampleEvidence(report, sampleId) {
+    return [{
+            sourceKind: 'sample',
+            sourceId: sampleId,
+            selector: { selectorKind: 'sample-id', value: sampleId },
+            contentHash: report.meta.sampleHashes?.[sampleId],
+            label: sampleId,
+        }];
+}
+function evalResultEvidence(report, resultIndex, variant) {
+    return [{
+            sourceKind: 'eval-report',
+            sourceId: report.id,
+            selector: {
+                selectorKind: 'json-pointer',
+                value: `/results/${resultIndex}/variants/${jsonPointerToken(variant)}`,
+            },
+            label: `${variant} result`,
+        }];
+}
+function assertionEvidence(report, sampleId, index, resultIndex, variant) {
+    if (report.sampleSnapshots?.[sampleId]?.assertions?.[index]) {
+        return [{
+                sourceKind: 'sample',
+                sourceId: sampleId,
+                selector: {
+                    selectorKind: 'json-pointer',
+                    value: `/sampleSnapshots/${jsonPointerToken(sampleId)}/assertions/${index}`,
+                },
+                contentHash: report.meta.sampleHashes?.[sampleId],
+                label: `assertion ${index + 1}`,
+            }];
+    }
+    if (resultIndex !== undefined && variant !== undefined) {
+        return [{
+                sourceKind: 'eval-report',
+                sourceId: report.id,
+                selector: {
+                    selectorKind: 'json-pointer',
+                    value: `/results/${resultIndex}/variants/${jsonPointerToken(variant)}/assertions/details/${index}`,
+                },
+                label: `${variant} assertion ${index + 1}`,
+            }];
+    }
+    return [{
+            sourceKind: 'sample',
+            sourceId: sampleId,
+            contentHash: report.meta.sampleHashes?.[sampleId],
+            label: `assertion ${index + 1}`,
+        }];
+}
+function sampleStableKey(report, sampleId) {
+    const hash = report.meta.sampleHashes?.[sampleId];
+    return hash ? `v1:sample:${hash}` : `v1:sample:${report.id}:${sampleId}`;
+}
+function assertionStableKey(report, sampleId, index) {
+    return `${sampleStableKey(report, sampleId)}:assertion:${index}`;
+}
+function sampleAttrs(snapshot) {
+    if (!snapshot)
+        return undefined;
+    const display = {};
+    if (snapshot.capability?.length)
+        display.capability = snapshot.capability;
+    if (snapshot.construct)
+        display.construct = snapshot.construct;
+    if (snapshot.difficulty)
+        display.difficulty = snapshot.difficulty;
+    if (snapshot.provenance)
+        display.provenance = snapshot.provenance;
+    if (snapshot.tripwire)
+        display.tripwire = true;
+    if (snapshot.assertions?.length)
+        display.assertionCount = snapshot.assertions.length;
+    return Object.keys(display).length > 0 ? { display } : undefined;
+}
+export function evalGraphDirForReportOutput(reportOutputDir) {
+    return basename(reportOutputDir) === 'reports'
+        ? join(dirname(reportOutputDir), 'graphs', 'eval')
+        : join(reportOutputDir, 'graphs', 'eval');
+}
+export function buildEvalArtifactGraph(options) {
+    const { report, sourcePath } = options;
+    const generatedAt = options.generatedAt ?? new Date().toISOString();
+    const nodes = [];
+    const edges = [];
+    const nodeIdsByStableKey = new Map();
+    const configs = variantConfigByName(report);
+    const addNode = (stableKey, nodeKind, nodeRole, label, extra = {}) => {
+        const existing = nodeIdsByStableKey.get(stableKey);
+        if (existing)
+            return existing;
+        const id = `node:${shortHash(stableKey)}`;
+        nodeIdsByStableKey.set(stableKey, id);
+        nodes.push({
+            id,
+            stableKey,
+            nodeKind,
+            nodeRole,
+            layer: 'measurement',
+            label,
+            ...extra,
+        });
+        return id;
+    };
+    const addEdge = (fromNodeId, toNodeId, edgeKind, extra = {}) => {
+        const id = `edge:${shortHash(`${fromNodeId}|${edgeKind}|${toNodeId}|${edges.length}`)}`;
+        edges.push({
+            id,
+            fromNodeId,
+            toNodeId,
+            edgeKind,
+            layer: 'measurement',
+            ...extra,
+        });
+    };
+    const variantNodeIds = new Map();
+    for (const variant of report.meta.variants) {
+        const artifactHash = report.meta.artifactHashes?.[variant];
+        const config = configs.get(variant);
+        const variantNodeId = addNode(`v1:variant:${report.id}:${variant}`, 'variant', 'entity', variant, {
+            status: statusFromScore(report.summary?.[variant]?.avgCompositeScore),
+            binding: artifactBinding(variant, artifactHash),
+            metrics: {
+                ...(report.summary?.[variant]?.avgCompositeScore !== undefined
+                    ? { avgCompositeScore: report.summary[variant].avgCompositeScore }
+                    : {}),
+                ...(report.summary?.[variant]?.totalSamples !== undefined
+                    ? { totalSamples: report.summary[variant].totalSamples }
+                    : {}),
+            },
+            attrs: {
+                display: {
+                    ...(config ? {
+                        artifactKind: config.artifactKind,
+                        artifactSource: config.artifactSource,
+                        experimentRole: config.experimentRole,
+                        executionStrategy: config.executionStrategy,
+                    } : {}),
+                },
+            },
+            evidenceRefs: [{
+                    sourceKind: 'eval-report',
+                    sourceId: report.id,
+                    selector: { selectorKind: 'json-pointer', value: `/summary/${jsonPointerToken(variant)}` },
+                    label: `${variant} summary`,
+                }],
+        });
+        variantNodeIds.set(variant, variantNodeId);
+        if (config?.artifactKind === 'skill' && artifactHash && artifactHash !== 'no-skill') {
+            const skillNodeId = addNode(`v1:skill:${artifactHash}`, 'skill', 'entity', variant, {
+                binding: { bindingStrength: 'content-hash', keys: { artifactHash } },
+                attrs: {
+                    display: {
+                        variant,
+                        sourceLocator: config.locator,
+                    },
+                },
+                evidenceRefs: [{
+                        sourceKind: 'eval-report',
+                        sourceId: report.id,
+                        selector: { selectorKind: 'json-pointer', value: `/meta/artifactHashes/${jsonPointerToken(variant)}` },
+                        contentHash: artifactHash,
+                        label: `${variant} artifact hash`,
+                    }],
+            });
+            addEdge(variantNodeId, skillNodeId, 'derived_from');
+        }
+    }
+    for (const [sampleId, snapshot] of Object.entries(report.sampleSnapshots ?? {})) {
+        const sampleNodeId = addNode(sampleStableKey(report, sampleId), 'sample', 'entity', sampleId, {
+            binding: sampleBinding(sampleId, report.meta.sampleHashes?.[sampleId]),
+            attrs: sampleAttrs(snapshot),
+            evidenceRefs: sampleEvidence(report, sampleId),
+        });
+        snapshot.assertions?.forEach((assertion, index) => {
+            const assertionNodeId = addNode(assertionStableKey(report, sampleId, index), 'assertion', 'entity', `assertion: ${assertion.type}`, {
+                attrs: { display: { type: assertion.type, weight: assertion.weight ?? 1 } },
+                evidenceRefs: assertionEvidence(report, sampleId, index),
+            });
+            addEdge(sampleNodeId, assertionNodeId, 'contains');
+        });
+    }
+    for (const [resultIndex, result] of report.results.entries()) {
+        const sampleNodeId = addNode(sampleStableKey(report, result.sample_id), 'sample', 'entity', result.sample_id, {
+            binding: sampleBinding(result.sample_id, report.meta.sampleHashes?.[result.sample_id]),
+            attrs: sampleAttrs(report.sampleSnapshots?.[result.sample_id]),
+            evidenceRefs: sampleEvidence(report, result.sample_id),
+        });
+        for (const [variant, variantResult] of Object.entries(result.variants)) {
+            const variantNodeId = variantNodeIds.get(variant);
+            if (!variantNodeId)
+                continue;
+            addEdge(variantNodeId, sampleNodeId, 'evaluates', {
+                status: assertionStatus(variantResult),
+                evidenceRefs: evalResultEvidence(report, resultIndex, variant),
+            });
+            const evalResultNodeId = addNode(`v1:eval-result:${report.id}:${variant}:${result.sample_id}`, 'eval_result', 'observation', `${variant} / ${result.sample_id}`, {
+                status: assertionStatus(variantResult),
+                metrics: {
+                    durationMs: variantResult.durationMs,
+                    costUSD: variantResult.costUSD,
+                    ...(variantResult.compositeScore !== undefined ? { compositeScore: variantResult.compositeScore } : {}),
+                    ...(variantResult.llmScore !== undefined ? { llmScore: variantResult.llmScore } : {}),
+                    ...(variantResult.assertions ? { assertionScore: variantResult.assertions.score } : {}),
+                },
+                attrs: {
+                    display: {
+                        ok: variantResult.ok,
+                        ...(variantResult.error ? { error: variantResult.error } : {}),
+                    },
+                },
+                evidenceRefs: evalResultEvidence(report, resultIndex, variant),
+            });
+            addEdge(evalResultNodeId, variantNodeId, 'derived_from');
+            addEdge(evalResultNodeId, sampleNodeId, 'evaluates');
+            variantResult.assertions?.details.forEach((detail, index) => {
+                const assertionNodeId = addNode(assertionStableKey(report, result.sample_id, index), 'assertion', 'entity', `assertion: ${detail.type}`, {
+                    attrs: { display: { type: detail.type, weight: detail.weight } },
+                    evidenceRefs: assertionEvidence(report, result.sample_id, index, resultIndex, variant),
+                });
+                addEdge(evalResultNodeId, assertionNodeId, detail.passed ? 'passes' : 'fails', {
+                    status: detail.passed ? 'ok' : 'failed',
+                    evidenceRefs: evalResultEvidence(report, resultIndex, variant),
+                });
+            });
+            for (const [dimension, dimensionResult] of Object.entries(variantResult.dimensions ?? {})) {
+                const dimensionNodeId = addNode(`v1:judge-dimension:${report.id}:${variant}:${result.sample_id}:${dimension}`, 'judge_dimension', 'observation', dimension, {
+                    status: statusFromScore(dimensionResult.score),
+                    metrics: { score: dimensionResult.score },
+                    attrs: { display: { reason: dimensionResult.reason } },
+                    evidenceRefs: evalResultEvidence(report, resultIndex, variant),
+                });
+                addEdge(dimensionNodeId, evalResultNodeId, 'derived_from');
+            }
+            if (variantResult.diagnostic) {
+                const diagnosticNodeId = addNode(`v1:diagnostic:${report.id}:${variant}:${result.sample_id}`, 'diagnostic', 'observation', `diagnostic: ${variant} / ${result.sample_id}`, {
+                    status: variantResult.diagnostic.ok ? 'warning' : 'failed',
+                    attrs: {
+                        display: {
+                            rootCause: variantResult.diagnostic.rootCause,
+                            failureModes: variantResult.diagnostic.failureModes ?? [],
+                        },
+                    },
+                    evidenceRefs: evalResultEvidence(report, resultIndex, variant),
+                });
+                addEdge(diagnosticNodeId, evalResultNodeId, 'diagnoses', {
+                    status: variantResult.diagnostic.ok ? 'warning' : 'failed',
+                });
+            }
+        }
+    }
+    return {
+        documentKind: 'artifact-graph',
+        schemaVersion: 1,
+        graphId: `eval:${report.id}`,
+        generatedAt,
+        source: {
+            sourceKind: 'eval',
+            sourceId: report.id,
+            sourcePath,
+            cliVersion: report.meta.cliVersion,
+        },
+        scope: {
+            cwd: process.cwd(),
+            artifactKind: scopeArtifactKind(report),
+            sourceLocator: report.meta.request?.samplesPath,
+            sampleSetHash: sampleSetHash(report.meta.sampleHashes),
+        },
+        nodes,
+        edges,
+        summaries: [{
+                summaryKind: 'coverage',
+                title: 'Eval measurement graph',
+                severity: report.results.some((result) => Object.values(result.variants).some((variant) => assertionStatus(variant) === 'failed'))
+                    ? 'medium'
+                    : 'info',
+            }],
+    };
+}
+export function persistEvalGraphSidecar(options) {
+    const graphDir = evalGraphDirForReportOutput(options.outputDir);
+    if (!existsSync(graphDir))
+        mkdirSync(graphDir, { recursive: true });
+    const fileStem = options.fileStem ?? options.report.id;
+    const graphPath = join(graphDir, graphFileName(fileStem));
+    const graph = buildEvalArtifactGraph(options);
+    writeFileSync(graphPath, JSON.stringify(graph, null, 2));
+    return { graphPath };
+}

package/dist/doctor/index.js

@@ -9,6 +9,7 @@
  */
 import { existsSync, statSync } from 'node:fs';
 import { basename, dirname, join, resolve } from 'node:path';
+import { runFileSuffix } from '../eval-core/artifact-file-names.js';
 import { discoverVariants, resolveArtifacts } from '../inputs/skill-loader.js';
 import { DOCTOR_REPORT_SCHEMA_VERSION, isComposerRule } from '../types/doctor.js';
 import { getRegisteredRules } from './rules.js';
@@ -163,14 +164,8 @@ function inferSkillPath(artifact, baseDir) {
 // ---------------------------------------------------------------------------
 // Public entry
 // ---------------------------------------------------------------------------
-let reportIdCounter = 0;
 function nextReportId() {
-    reportIdCounter += 1;
-    const ts = new Date().toISOString().replace(/[-:.]/g, '').slice(0, 15);
-    // 进程内计数器只防同进程同秒撞;跨进程同秒(两个 omk doctor 并发 / 不同项目)仍会撞同 id,
-    // 经机器级卡片 dedup 当唯一键用时会静默并掉一份。加 4 位随机根治跨进程撞名(id 是标签非测量数)。
-    const rand = Math.random().toString(36).slice(2, 6);
-    return `doctor-${ts}-${reportIdCounter}-${rand}`;
+    return `doctor-${runFileSuffix()}`;
 }
 function readCliVersion() {
     // 不依赖 package.json import(避免 type 解析复杂度);用环境变量或退回 'unknown'

package/dist/eval-core/artifact-file-names.d.ts

@@ -10,6 +10,6 @@ export declare function graphFileName(stem: string): string;
 export declare function cardFileName(stem: string): string;
 export declare function runTimestamp(date?: Date): string;
 export declare function randomRunToken(): string;
-export declare function runFileSuffix(counter?: number): string;
+export declare function runFileSuffix(): string;
 export declare function stripDomainPrefix(id: string, domain: string): string;
 export declare function doctorReportFileStem(skillName: string, reportId: string): string;

package/dist/eval-core/artifact-file-names.js

@@ -32,9 +32,8 @@ export function runTimestamp(date = new Date()) {
 export function randomRunToken() {
     return Math.random().toString(36).slice(2, 6);
 }
-export function runFileSuffix(counter) {
-    const middle = counter === undefined ? '' : `-${counter}`;
-    return `${runTimestamp()}${middle}-${randomRunToken()}`;
+export function runFileSuffix() {
+    return `${runTimestamp()}-${randomRunToken()}`;
 }
 export function stripDomainPrefix(id, domain) {
     const safeId = safeArtifactFileStem(id);

package/dist/eval-core/evaluation-reporting.d.ts

@@ -33,7 +33,7 @@ export interface PersistableReport {
 }
 export declare function persistReport(report: PersistableReport, outputDir: string | null): string | null;
 /**
- * run id 的时间戳后缀 `YYYYMMDD-HHmmss-rand4`。
+ * run id 的时间戳后缀 `YYYYMMDDTHHmmss-rand4`。
  * 含秒 + 4 位随机:id 是 run 标签(非测量数),但被 studio 机器级 dedup 与 managed 证据 (reportId,
  * contentHash) 去重当唯一键用。分钟级会让跨项目 / 同分钟重跑撞同 id → 索引静默顶掉一份、managed 错并一条。
  * 秒+随机根治撞名,保证每次 run 全局唯一。供 generateRunId 与 evolve 合并 id 共用,避免靠 split 反解格式。

package/dist/eval-core/evaluation-reporting.js

@@ -5,7 +5,8 @@ import { createHash } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { DEFAULT_REPORTS_DIR } from './default-dirs.js';
 import { indexReportWrite } from './artifact-index.js';
-import { reportFilePath } from './artifact-file-names.js';
+import { randomRunToken, reportFilePath, runTimestamp } from './artifact-file-names.js';
+import { persistEvalGraphSidecar } from '../artifact-graph/eval.js';
 import { buildVariantSummary } from './schema.js';
 import { buildVariantConfig, resolveExecutionStrategy } from './execution-strategy.js';
 import { getJudgePromptHash } from '../grading/judge.js';
@@ -276,6 +277,20 @@ export function aggregateReport({ runId, variants, model, judgeModel, noJudge, e
             }])),
     };
 }
+function isEvaluationReport(report) {
+    return report['kind'] === 'evaluation';
+}
+function persistEvalGraphSidecarSafely(report, outputDir, sourcePath) {
+    if (!isEvaluationReport(report))
+        return;
+    try {
+        persistEvalGraphSidecar({ report, outputDir, sourcePath, fileStem: report.id });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[omk] 写入 eval 图谱失败：${message}\n`);
+    }
+}
 export function persistReport(report, outputDir) {
     if (!outputDir)
         return null;
@@ -283,28 +298,32 @@ export function persistReport(report, outputDir) {
         mkdirSync(outputDir, { recursive: true });
     const filePath = reportFilePath(outputDir, report.id);
     writeFileSync(filePath, JSON.stringify(report, null, 2));
+    persistEvalGraphSidecarSafely(report, outputDir, filePath);
     // 产物发现索引:报告落项目本地后,best-effort 追加全局轻卡片,让 omk studio 跨项目聚合成机器级总览。
     // 永不抛、永不阻断报告落盘(正文是 source of truth)。
     indexReportWrite(report, filePath, outputDir);
     return filePath;
 }
 /**
- * run id 的时间戳后缀 `YYYYMMDD-HHmmss-rand4`。
+ * run id 的时间戳后缀 `YYYYMMDDTHHmmss-rand4`。
  * 含秒 + 4 位随机:id 是 run 标签(非测量数),但被 studio 机器级 dedup 与 managed 证据 (reportId,
  * contentHash) 去重当唯一键用。分钟级会让跨项目 / 同分钟重跑撞同 id → 索引静默顶掉一份、managed 错并一条。
  * 秒+随机根治撞名,保证每次 run 全局唯一。供 generateRunId 与 evolve 合并 id 共用,避免靠 split 反解格式。
  */
 export function runIdSuffix() {
-    const d = new Date();
-    const pad = (n) => String(n).padStart(2, '0');
-    const date = `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}`;
-    const time = `${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
-    const rand = Math.random().toString(36).slice(2, 6);
-    return `${date}-${time}-${rand}`;
+    return `${runTimestamp()}-${randomRunToken()}`;
+}
+function safeRunSubject(subject) {
+    const sanitized = subject
+        .replaceAll(/[\\/:]/g, '-')
+        .replaceAll(/[^a-zA-Z0-9._@-]/g, '_')
+        .replace(/^-+|-+$/g, '');
+    return sanitized || 'run';
+}
+function primaryRunSubject(variants) {
+    const nonBaseline = variants.filter((variant) => variant !== 'baseline');
+    return nonBaseline.at(-1) ?? variants.at(-1) ?? 'run';
 }
 export function generateRunId(variants) {
-    const variantPart = variants
-        .map((variant) => variant.replaceAll(/[\\/:]/g, '-').replaceAll(/[^a-zA-Z0-9._@-]/g, '_'))
-        .join('-vs-');
-    return `${variantPart}-${runIdSuffix()}`;
+    return `${safeRunSubject(primaryRunSubject(variants))}-${runIdSuffix()}`;
 }

package/dist/renderer/html-renderer.js

@@ -149,9 +149,10 @@ export function renderRunList(runs, lang = DEFAULT_LANG) {
     // 顶部 verdict pill 主导视觉,id+date 是身份,scores 是成绩,底部 meta 是元数据,
     // delete 默认隐藏在 hover 出现避免误点。批量报告共用同一组件,batch pill 替代 verdict。
     const formatDateFromId = (id, fallbackTs) => {
-        // 兼容两代 run id 后缀:旧 `…YYYYMMDD-HHmm`、新 `…YYYYMMDD-HHmmss-rand4`(含秒+随机)。
+        // 兼容三代 run id 后缀:旧 `…YYYYMMDD-HHmm`、过渡期 `…YYYYMMDD-HHmmss-rand4`、
+        // 统一后 `…YYYYMMDDTHHmmss-rand4`(含秒+随机)。
         // 都从 id 直接派生本地展示时间(确定性,不走时区敏感的 toLocaleString);新增的秒段 + 随机后缀可选匹配。
-        const idMatch = id.match(/(\d{4})(\d{2})(\d{2})-(\d{2})(\d{2})(?:\d{2}-[a-z0-9]+)?$/);
+        const idMatch = id.match(/(\d{4})(\d{2})(\d{2})(?:T|-)(\d{2})(\d{2})(?:\d{2})?(?:-[a-z0-9]+)?$/);
         if (idMatch)
             return `${idMatch[2]}/${idMatch[3]} ${idMatch[4]}:${idMatch[5]}`;
         return fallbackTs ? new Date(fallbackTs).toLocaleString('zh-CN', { month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit' }) : '';