oh-my-knowledge 0.34.0 → 0.36.0

package/dist/inputs/source-resolver.js

@@ -1,40 +1,56 @@
-import { existsSync, lstatSync, mkdirSync, mkdtempSync, realpathSync, rmSync, statSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join, resolve, sep } from 'node:path';
-import { isDistributablePath } from '../managed/index.js';
-import { classifyGitSkillRef, parseGitInput, resolveGitRepoContext, gitJoin, gitLsTreeBlobs, gitShowBytes, skillNameFromPath } from './skill-loader.js';
-export class SourceResolveError extends Error {
-    messageKey;
-    params;
-    constructor(messageKey, params = {}) {
-        super(messageKey);
-        this.name = 'SourceResolveError';
-        this.messageKey = messageKey;
-        this.params = params;
-    }
-}
-const noop = () => { };
+import { existsSync, lstatSync, realpathSync, statSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { classifyGitSkillRef, parseGitInput, resolveGitRepoContext, materializeGitSkillTree, skillNameFromPath, SourceResolveError, fetchRemoteGitRef } from './skill-loader.js';
 /**
- * 校验 git tree 条目路径在物化目标内,越界即 fail closed(抛 SourceResolveError)。
- * 双保险:既显式拒 `..` / 空段(git tree 可被手工构造出名为 `..` 的子树),也用 resolve 兜底
- * 确认落点仍在 temp 之下(绝对路径 / 符号化逃逸)。绝不静默跳过——跳过会让物化树与真实树发散。
+ * 安装源解析器 —— 把"各种源"物化成统一的本地形态,让 install / managed 主干**源无关**。
+ * 新增一种源 = 加一个分支,install.ts 不动。本模块不依赖 CLI(不打印、不 tCli):错误以
+ * `SourceResolveError(messageKey)` 抛出,由调用方(install)映射成本地化文案。
+ *
+ * 当前支持:`file`(本地路径)、`git`(当前仓库的某个 ref)、远端 git(URL + ref,fetch 到临时 bare)。
+ * 三者沿同一 `ResolvedSource` 契约,install / managed 主干源无关。
  */
-function assertContainedRelPath(temp, relPath) {
-    const segments = relPath.split('/');
-    if (segments.some((s) => s === '' || s === '.' || s === '..')) {
-        throw new SourceResolveError('cli.install.git_unsafe_path', { path: relPath });
-    }
-    const root = resolve(temp);
-    const dest = resolve(temp, relPath);
-    if (dest !== root && !dest.startsWith(root + sep)) {
-        throw new SourceResolveError('cli.install.git_unsafe_path', { path: relPath });
-    }
-}
+// SourceResolveError 住在 skill-loader(让共享 materializeGitSkillTree 能抛它而不成环);此处 re-export
+// 保持 install 既有 import 不破。
+export { SourceResolveError } from './skill-loader.js';
+const noop = () => { };
 export function resolveInstallSource(input) {
     if (input.startsWith('git:'))
         return resolveGitSource(input);
     return resolveFileSource(input);
 }
+/**
+ * 远端 git 源:`<url>` + `<ref>` + repo 相对 `<spec>`(三者结构化传入,URL 不经任何字符串切分,
+ * 避开 `parseGitInput` 的 `:` 与 `parseVariantCwd` 的 `@`)。fetch 到临时 bare → 复用既有
+ * classifyGitSkillRef / materializeGitSkillTree(repoRoot 换成 bare)。locator 落 `git+<url>@<sha>:<spec>`
+ * 仅作记录身份;url 另以结构化字段携带,供 drift 重取。失败 fail-closed 并清临时资源。
+ */
+export function resolveRemoteGitSource(url, ref, spec) {
+    const checkout = fetchRemoteGitRef(url, ref);
+    try {
+        // 远端 URL 指向仓库根,spec 是仓库相对路径 → gitRelDir 为空。
+        const resolved = classifyGitSkillRef(checkout.ref, '', spec, checkout.repoRoot);
+        if (!resolved)
+            throw new SourceResolveError('cli.install.remote_skill_not_found', { url, ref: checkout.ref, name: spec });
+        const mat = materializeGitSkillTree(checkout.ref, resolved, checkout.repoRoot);
+        return {
+            sourceKind: 'git',
+            localRoot: mat.localRoot,
+            name: mat.name,
+            isDirectorySkill: mat.isDirectorySkill,
+            locator: `git+${url}@${checkout.ref}:${spec}`,
+            ref: checkout.ref,
+            url,
+            cleanup: () => {
+                mat.cleanup();
+                checkout.cleanup();
+            },
+        };
+    }
+    catch (err) {
+        checkout.cleanup();
+        throw err;
+    }
+}
 function resolveFileSource(input) {
     const abs = resolve(input);
     if (!existsSync(abs))
@@ -74,52 +90,16 @@ function resolveGitSource(input) {
     if (!resolved) {
         throw new SourceResolveError('cli.install.git_skill_not_found', { ref, name: spec });
     }
-    const temp = mkdtempSync(join(tmpdir(), 'omk-install-git-'));
-    const cleanup = () => {
-        try {
-            rmSync(temp, { recursive: true, force: true });
-        }
-        catch {
-            // 临时目录清理失败不致命
-        }
+    // 物化复用共享 materializeGitSkillTree(install 与 eval 同一条物化路径);install 只需在其上补
+    // locator / sourceKind 包成 ResolvedSource。
+    const mat = materializeGitSkillTree(ref, resolved, ctx.repoRoot);
+    return {
+        sourceKind: 'git',
+        localRoot: mat.localRoot,
+        name: mat.name,
+        isDirectorySkill: mat.isDirectorySkill,
+        locator: `git:${ref}:${spec}`,
+        ref,
+        cleanup: mat.cleanup,
     };
-    try {
-        const locator = `git:${ref}:${spec}`;
-        if (resolved.isDir) {
-            for (const entry of gitLsTreeBlobs(ref, resolved.treePath, ctx.repoRoot)) {
-                // 安全边界 fail closed:git tree 可被 git mktree 手工构造出名为 `..` 的子树,`ls-tree -r` 会
-                // 吐 `../evil.txt`,`join(temp, ...)` 会逃出临时目录写盘、cleanup 也删不掉。任一越界路径(.. /
-                // 绝对路径 / 空段 / 解析后不在 temp 内)直接抛错,而非静默跳过——静默跳过会让物化树与真实
-                // git tree / hash / 分发树发散。正常 checkout 永不触发。
-                assertContainedRelPath(temp, entry.path);
-                if (entry.mode === '120000' || entry.mode === '160000')
-                    continue; // 跳过软链 / submodule(与本地分发一致)
-                if (!isDistributablePath(entry.path.split('/')))
-                    continue; // 排除 .omk/.git/evolve 等
-                const bytes = gitShowBytes(ref, gitJoin(resolved.treePath, entry.path), ctx.repoRoot);
-                if (!bytes)
-                    continue;
-                const dest = join(temp, entry.path);
-                mkdirSync(dirname(dest), { recursive: true });
-                // 保留可执行位(与本地 cpSync 一致);其余 0644。
-                writeFileSync(dest, bytes, { mode: entry.mode === '100755' ? 0o755 : 0o644 });
-            }
-            // 纵深防御:classify 与物化用的是两条 git 路径(gitShowFile vs ls-tree),万一发散(如 treePath 退化)
-            // 导致空树,这里失败而非静默分发一个空 skill。
-            if (!existsSync(join(temp, 'SKILL.md'))) {
-                throw new SourceResolveError('cli.install.git_skill_not_found', { ref, name: spec });
-            }
-            return { sourceKind: 'git', localRoot: temp, name: resolved.name, isDirectorySkill: true, locator, ref, cleanup };
-        }
-        const bytes = gitShowBytes(ref, resolved.fileSkillPath, ctx.repoRoot);
-        if (!bytes)
-            throw new SourceResolveError('cli.install.git_skill_not_found', { ref, name: spec });
-        const dest = join(temp, `${resolved.name}.md`);
-        writeFileSync(dest, bytes);
-        return { sourceKind: 'git', localRoot: dest, name: resolved.name, isDirectorySkill: false, locator, ref, cleanup };
-    }
-    catch (err) {
-        cleanup();
-        throw err;
-    }
 }

package/dist/managed/evidence.d.ts

@@ -0,0 +1,22 @@
+import type { EvaluationReport, ManagedEvidenceRef } from '../types/index.js';
+/**
+ * 为某个变体组装一条 evidence ref;变体无真实内容(baseline / no-skill / 缺 hash)→ null。
+ * `verdict` 由调用方传入(CLI 已 computeVerdict,避免在此重算)。
+ */
+export declare function buildEvidenceRef(report: EvaluationReport, variant: string, verdict: string, recordedAt: string): ManagedEvidenceRef | null;
+export interface RecordedEvidence {
+    recordId: string;
+    name: string;
+    contentHash: string;
+    /** true ⇒ evidence.contentHash 等于记录当前 contentHash → deriveManagedState 计为当前证据 →
+     *  measurable。false ⇒ 测的是旧内容(已 drift),证据留存但不绑当前版本。 */
+    bound: boolean;
+}
+/**
+ * 驱动:对每个能在报告里(按 contentHash 主键 / 同名回退)匹配到被测 variant 的**已纳管**记录,
+ * 追加一条 evidence。返回实际写入的清单(供 CLI 提示,`name` 取受管记录名而非 variant 键)。
+ * 无任何记录匹配 → 返回空(常见的非管理用户场景,静默无副作用)。
+ */
+export declare function recordEvalEvidence(report: EvaluationReport, verdict: string, recordedAt: string, opts?: {
+    dir?: string;
+}): RecordedEvidence[];

package/dist/managed/evidence.js

@@ -0,0 +1,143 @@
+/**
+ * eval → managed evidence 写入(承接 #203 管理支柱 / #214 验收第 3 条)。
+ *
+ * 一次 `omk eval` 跑完,把结果落成一条 `ManagedEvidenceRef` 追加进**已纳管**记录的 evidence[],
+ * 让 skill 从 `installed` 走到 `measurable`(由 `deriveManagedState` 读时推导)。承重前提是 #214/#218
+ * 已把 install 与 eval 的内容指纹统一到同一空间(整树哈),所以 `report.artifactHashes[variant]` 与
+ * `record.contentHash` 可直接相等比对、evidence 绑得上。
+ *
+ * 三条设计取舍(对应 issue #221 的"待定决策"):
+ *   - **触发**:eval 完成**自动**写,但只写**已存在**的受管记录 —— install 是显式 opt-in,未纳管的
+ *     skill 永不被凭空建记录(零副作用惊吓)。CLI 另给 `--no-evidence` 关闭。
+ *   - **多对一**:append-only + 按 (reportId, contentHash) 去重;保留全部历史条目,当前有效性仍由
+ *     `deriveManagedState` 按 contentHash 匹配裁定(重装新内容后旧证据留存供回滚,却不让新内容显得已测)。
+ *   - **跨源**:用三级身份消歧把被测 variant 对到受管记录(install 与 eval 命名不一致:记录名是
+ *     skill 短名 `review`,而 eval 报告 variant key 可能是整串表达式 `git:HEAD:skills/review`、
+ *     eval.yaml 别名 `candidate`、blind 模式的 `A`/`B`)。`applyBlindMode` 盲化 `variants` 但**不**动
+ *     `artifactHashes` / `variantConfigs` 的键面,故三级都按真实键工作:
+ *       (a) 显式**同名** variant —— 最强身份(本地 `--treatment <name>` 与 drift);
+ *       (b) **结构化源匹配** —— `variantConfigs[].locator(+ref)` 与 `record.source` 对齐(git / 远端 /
+ *           别名),即便内容撞哈也能精确消歧;
+ *       (c) **纯 contentHash 回退** —— 仅当该内容哈在受管记录中**唯一**才用。否则两条不同记录恰好当前
+ *           内容相同(同模板复制 / 刚装)时,只测了一条的 report 会把同哈的另一条也推成 measurable ——
+ *           唯一性闸门挡掉这种越权写入(撞哈又非同名 / 无结构化身份 → 跳过,不乱绑)。
+ *
+ * bundle 按 evidence-gated-management.md §5 denormalize 进记录(reportId / contentHash /
+ * verdict / sampleCoverage / comparability),不依赖 report 文件仍在盘。
+ */
+import { basename, dirname } from 'node:path';
+import { hashString } from '../eval-core/evaluation-reporting.js';
+import { loadAllManagedRecords, appendManagedEvidence, managedDir, resolveManagedDir } from './store.js';
+/** baseline / 无 skill 变体的 artifactHash 哨兵(见 report.ts artifactHashes 注释)——不产证据。 */
+const NO_SKILL = 'no-skill';
+/** 样本集覆盖摘要:report 的 sampleHashes 排序后取一个稳定 digest(同一样本集 ⇒ 同 hash)。
+ *  缺 sampleHashes(旧报告 / --dry-run)→ undefined,bundle 仍含其余三项 mandatory。 */
+function sampleCoverage(report) {
+    const sh = report.meta?.sampleHashes;
+    if (!sh)
+        return undefined;
+    const entries = Object.entries(sh).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+    return { count: entries.length, hash: hashString(JSON.stringify(entries)) };
+}
+/**
+ * 为某个变体组装一条 evidence ref;变体无真实内容(baseline / no-skill / 缺 hash)→ null。
+ * `verdict` 由调用方传入(CLI 已 computeVerdict,避免在此重算)。
+ */
+export function buildEvidenceRef(report, variant, verdict, recordedAt) {
+    const contentHash = report.meta?.artifactHashes?.[variant];
+    if (!contentHash || contentHash === NO_SKILL)
+        return null;
+    const meta = report.meta;
+    const cov = sampleCoverage(report);
+    return {
+        reportId: report.id,
+        contentHash,
+        recordedAt,
+        verdict,
+        ...(cov ? { sampleCoverage: cov } : {}),
+        comparability: {
+            cliVersion: meta.cliVersion,
+            ...(meta.judgePromptHash ? { judgePromptHash: meta.judgePromptHash } : {}),
+            ...(meta.debiasMode ? { debiasMode: meta.debiasMode } : {}),
+        },
+    };
+}
+/**
+ * variantConfig 的源身份是否与受管记录 source 对得上 —— install 与 eval 两侧 locator **口径不同**,
+ * 必须先归一化再比,不能裸字符串相等(否则同 hash 多记录场景下正确的本地 git / 目录-skill 也会因
+ * locator 不等而漏写):
+ *   - 直接相等:远端 git(两侧都 `git+<url>@<sha>:<spec>`)、本地 file-skill(两侧都是 .md 路径);
+ *   - 本地 git:install 记完整身份串 `git:<ref>:<spec>`,eval 把 spec 落 `cfg.locator`、ref 另存 `cfg.ref`
+ *     → 归一化成 `git:<cfg.ref>:<cfg.locator>` 再比;
+ *   - 本地目录-skill:install 记目录根,eval 记 `<dir>/SKILL.md` → 比 `dirname(cfg.locator)`。
+ */
+function sourceMatches(cfg, source) {
+    if (!cfg.locator)
+        return false;
+    if (cfg.locator === source.locator)
+        return true;
+    if (source.sourceKind === 'git' && cfg.ref && `git:${cfg.ref}:${cfg.locator}` === source.locator)
+        return true;
+    if (source.isDirectorySkill && basename(cfg.locator) === 'SKILL.md' && dirname(cfg.locator) === source.locator)
+        return true;
+    return false;
+}
+/**
+ * 给某条受管记录在报告里找该绑定的 variant key,三级身份消歧(见文件头「跨源」)。
+ * `hashIsUnique` 由调用方按全体受管记录的 contentHash 计数提供 —— 纯 hash 回退的越权闸门。
+ */
+function matchVariantKey(report, record, hashIsUnique) {
+    const hashes = report.meta?.artifactHashes ?? {};
+    // (a) 显式同名 variant(本地 --treatment <name> / drift)。
+    if (hashes[record.name] && hashes[record.name] !== NO_SKILL)
+        return record.name;
+    // (b) 结构化源匹配:variantConfig.locator(+ref) 对齐记录 source(git / 远端 / 别名)。
+    for (const cfg of report.meta?.variantConfigs ?? []) {
+        const h = hashes[cfg.variant];
+        if (!h || h === NO_SKILL)
+            continue;
+        if (sourceMatches(cfg, record.source))
+            return cfg.variant;
+    }
+    // (c) 纯 contentHash 回退 —— 仅当该哈在受管记录中唯一(否则撞哈会越权写到没测的记录)。
+    if (hashIsUnique(record.contentHash)) {
+        for (const [key, hash] of Object.entries(hashes)) {
+            if (hash !== NO_SKILL && hash === record.contentHash)
+                return key;
+        }
+    }
+    return undefined;
+}
+/**
+ * 驱动:对每个能在报告里(按 contentHash 主键 / 同名回退)匹配到被测 variant 的**已纳管**记录,
+ * 追加一条 evidence。返回实际写入的清单(供 CLI 提示,`name` 取受管记录名而非 variant 键)。
+ * 无任何记录匹配 → 返回空(常见的非管理用户场景,静默无副作用)。
+ */
+export function recordEvalEvidence(report, verdict, recordedAt, opts = {}) {
+    const out = [];
+    if (Object.keys(report.meta?.artifactHashes ?? {}).length === 0)
+        return out;
+    // 写回读方实际取记录的同一目录(project→global 同口径)。
+    const dir = resolveManagedDir(opts.dir ?? managedDir());
+    const records = loadAllManagedRecords(dir);
+    if (records.length === 0)
+        return out;
+    // 全体记录的 contentHash 计数 —— 纯 hash 回退只在唯一时放行(挡同内容多记录的越权写)。
+    const hashCount = new Map();
+    for (const r of records)
+        hashCount.set(r.contentHash, (hashCount.get(r.contentHash) ?? 0) + 1);
+    const hashIsUnique = (hash) => (hashCount.get(hash) ?? 0) === 1;
+    for (const rec of records) {
+        const variantKey = matchVariantKey(report, rec, hashIsUnique);
+        if (!variantKey)
+            continue;
+        const ref = buildEvidenceRef(report, variantKey, verdict, recordedAt);
+        if (!ref)
+            continue;
+        const merged = appendManagedEvidence(dir, rec.id, ref);
+        if (!merged)
+            continue;
+        out.push({ recordId: rec.id, name: rec.name, contentHash: ref.contentHash, bound: ref.contentHash === merged.contentHash });
+    }
+    return out;
+}

package/dist/managed/index.d.ts

@@ -3,3 +3,5 @@
  * 不直接依赖内部文件布局。
  */
 export * from './store.js';
+export * from './evidence.js';
+export * from './list-view.js';

package/dist/managed/index.js

@@ -3,3 +3,5 @@
  * 不直接依赖内部文件布局。
  */
 export * from './store.js';
+export * from './evidence.js';
+export * from './list-view.js';

package/dist/managed/list-view.d.ts

@@ -0,0 +1,55 @@
+/**
+ * `omk list` 的纯视图构造(#203 管理支柱)—— 把受管记录摊成可渲染的行,不做任何 IO。
+ *
+ * 「当前源探测」由调用方注入(`probeOf`):CLI 侧重物化真源算哈,单测侧给 mock —— 保持本模块纯函数、
+ * 可测。探测是**三态**:`reachable:true + hash`(算出了当前哈,可判 drift)/ `reachable:false`(源不可达 /
+ * 解析失败 / 拒绝读取)。**不可达 ≠ 已 drift** —— 把「这里查不了」当「内容变了」会对从别处看的本地 git 记录
+ * 误报 stale(locator 随 cwd 漂),所以不可达时只按证据给 installed/measurable、不打 drift、单独标「未核」。
+ * reachable 时才走 `deriveManagedState`(哈不等 → stale)。verdict / 可比性取**当前有效证据**
+ * (contentHash == record.contentHash)里 recordedAt 最新那条 —— 旧内容的证据不冒充当前。
+ */
+import type { ArtifactKind, ManagedArtifactRecord, ManagedLifecycleLabel } from '../types/index.js';
+/** 当前源探测结果(三态)。`reachable:false` = 不可达 / 解析失败 / 拒读,**不等于**已 drift。 */
+export interface SourceProbe {
+    reachable: boolean;
+    /** 当前源整树 / 单文件哈;仅 reachable 时有。 */
+    hash?: string;
+}
+export interface ManagedListRow {
+    id: string;
+    name: string;
+    /** artifact 类型,直取自记录(裸 kind 留给 ArtifactKind,见 terminology-spec §5.4)。 */
+    kind: ArtifactKind;
+    sourceKind: 'file' | 'git';
+    /** 展示用源标识:仅远端 git(sourceKind==='git' 且带 url)显 url,其余一律显 locator —— 保证「显示的」
+     *  就是「被 probe / 读取的」路径,file 源即便混入 url(validator 已拒)也不显示它。 */
+    sourceLabel: string;
+    state: ManagedLifecycleLabel;
+    drifted: boolean;
+    /** 当前源是否被成功核对过 hash。false = 不可达/拒读 → drift 未核(不据此判 stale)。 */
+    reachable: boolean;
+    /** 当前有效证据(若有)里 recordedAt 最新那条的 verdict。 */
+    latestVerdict?: string;
+    /** 该证据的可比性 marker —— 跨报告比 verdict 前需一致。 */
+    comparability?: {
+        cliVersion: string;
+        judgePromptHash?: string;
+        debiasMode?: Array<'length' | 'position'>;
+    };
+    /** 最新当前证据的记录时间。 */
+    recordedAt?: string;
+    /** 当前有效证据数 / 全部证据数(含旧内容的历史证据)。 */
+    currentEvidenceCount: number;
+    totalEvidenceCount: number;
+    distributionCount: number;
+}
+export declare function buildManagedListRow(record: ManagedArtifactRecord, probe: SourceProbe): ManagedListRow;
+/**
+ * 组装全部行。`probeOf` 给每条记录探测当前源(三态,见文件头)。
+ * 按 name 排序(稳定、可读);name collation 相等再按 kind。排序对机读出口(--json)也生效,故:
+ *   - **钉死 locale**(`'en'`):缺省 locale 随宿主 LANG / LC_COLLATE 漂,会让两台机器对同一批记录排出不同
+ *     JSON 顺序,破坏 omk「确定、可比」的底色。
+ *   - 平级判定用**同一 collation 度量**(localeCompare 结果是否为 0)而非 `===`:NFC / NFD 等价的同显示名
+ *     在 `===` 下不等、却 collation 相等,用 `===` 会漏掉 kind 平级 tiebreak、令顺序退回 readdir 序(不定)。
+ */
+export declare function buildManagedListRows(records: ManagedArtifactRecord[], probeOf: (record: ManagedArtifactRecord) => SourceProbe): ManagedListRow[];

package/dist/managed/list-view.js

@@ -0,0 +1,66 @@
+import { deriveManagedState } from './store.js';
+function latestCurrentEvidence(record) {
+    const current = record.evidence.filter((e) => e.contentHash === record.contentHash);
+    if (current.length === 0)
+        return undefined;
+    // 取 recordedAt 最新的一条。omk 自写恒 UTC `Z`、字典序即时间序;但记录可手改 / 随仓库分发,异偏移
+    // 或异精度的 ISO 串字典序会乱 → 优先按解析后的真实时刻比,两端都可解析才用;否则退回字典序(不劣化
+    // omk 自写场景)。并列取后出现的。
+    const ms = (s) => { const n = Date.parse(s); return Number.isNaN(n) ? null : n; };
+    return current.reduce((a, b) => {
+        const ta = ms(a.recordedAt);
+        const tb = ms(b.recordedAt);
+        if (ta !== null && tb !== null)
+            return tb >= ta ? b : a;
+        return b.recordedAt >= a.recordedAt ? b : a;
+    });
+}
+export function buildManagedListRow(record, probe) {
+    const currentEvidenceCount = record.evidence.filter((e) => e.contentHash === record.contentHash).length;
+    let state;
+    let drifted;
+    if (probe.reachable) {
+        // 算出了当前哈:正常推导(哈不等 → stale/drift)。
+        const d = deriveManagedState({ record, currentContentHash: probe.hash });
+        state = d.label;
+        drifted = d.drifted;
+    }
+    else {
+        // 不可达:不据此判 stale —— 只按证据给 installed/measurable,drift 标未核。
+        state = currentEvidenceCount > 0 ? 'measurable' : 'installed';
+        drifted = false;
+    }
+    const latest = latestCurrentEvidence(record);
+    return {
+        id: record.id,
+        name: record.name,
+        kind: record.kind,
+        sourceKind: record.source.sourceKind,
+        sourceLabel: record.source.sourceKind === 'git' && record.source.url ? record.source.url : record.source.locator,
+        state,
+        drifted,
+        reachable: probe.reachable,
+        ...(latest?.verdict ? { latestVerdict: latest.verdict } : {}),
+        ...(latest?.comparability ? { comparability: latest.comparability } : {}),
+        ...(latest?.recordedAt ? { recordedAt: latest.recordedAt } : {}),
+        currentEvidenceCount,
+        totalEvidenceCount: record.evidence.length,
+        distributionCount: record.distribution.length,
+    };
+}
+/**
+ * 组装全部行。`probeOf` 给每条记录探测当前源(三态,见文件头)。
+ * 按 name 排序(稳定、可读);name collation 相等再按 kind。排序对机读出口(--json)也生效,故:
+ *   - **钉死 locale**(`'en'`):缺省 locale 随宿主 LANG / LC_COLLATE 漂,会让两台机器对同一批记录排出不同
+ *     JSON 顺序,破坏 omk「确定、可比」的底色。
+ *   - 平级判定用**同一 collation 度量**(localeCompare 结果是否为 0)而非 `===`:NFC / NFD 等价的同显示名
+ *     在 `===` 下不等、却 collation 相等,用 `===` 会漏掉 kind 平级 tiebreak、令顺序退回 readdir 序(不定)。
+ */
+export function buildManagedListRows(records, probeOf) {
+    return records
+        .map((r) => buildManagedListRow(r, probeOf(r)))
+        .sort((a, b) => {
+        const byName = a.name.localeCompare(b.name, 'en');
+        return byName !== 0 ? byName : a.kind.localeCompare(b.kind, 'en');
+    });
+}

package/dist/managed/store.d.ts

@@ -1,4 +1,4 @@
-import type { ArtifactKind, DeriveManagedStateInput, DerivedManagedState, ManagedArtifactRecord, ManagedArtifactSource, ManagedDistributionTarget } from '../types/index.js';
+import type { ArtifactKind, DeriveManagedStateInput, DerivedManagedState, ManagedArtifactRecord, ManagedArtifactSource, ManagedDistributionTarget, ManagedEvidenceRef } from '../types/index.js';
 /**
  * 受管记录的 per-record 文件存储。一条记录一个 `.omk/managed/<id>.json`,镜像 report-store 的
  * 成熟模式(原子 tmp+rename):每次 install 只碰自己那个文件,independent write、不丢别人、
@@ -14,28 +14,16 @@ export declare function globalManagedDir(): string;
 export declare function recordPath(dir: string, id: string): string;
 /** 稳定身份 = hash(kind, name)。源路径是可变属性、不进 id。kind 取自固定枚举(无 `|`),分隔可注入。 */
 export declare function managedRecordId(kind: ArtifactKind, name: string): string;
-/**
- * 给定相对源根的路径分段(空数组 = 源根本身),判断是否进可分发树。hash 的 walk、copy 的 filter、
- * git 物化共用此一处,保证三者完全一致。
- *
- * 关键:检查**每一段**而非只看叶子。本地 walk / cpSync 是逐层下降、命中目录即剪枝,只看叶子也够;
- * 但 git ls-tree 给的是**扁平路径**(如 `.omk/samples.json`),只看叶子 `samples.json` 会让 `.omk`
- * 内容漏过。故:任一段命中全局排除即排除;首段命中 root-only(evolve)即排除(嵌套同名是合法资产)。
- */
-export declare function isDistributablePath(segments: string[]): boolean;
-/**
- * artifact 内容 hash —— drift baseline 与 evidence 绑定的依据。
- *   - 文件-skill:单个 .md 的字节;
- *   - 目录-skill:覆盖**整棵可分发目录树**(SKILL.md + references/ 等资产,但排除 .omk / .git /
- *     evolve 等评测迭代产物),按相对路径排序后把每个文件的`路径 + 字节长度 + 内容`喂进同一个
- *     sha256 —— 改任意资产都会令 hash 变化、drift 不漏;只补样本则 hash 不动。
- * 用 createHash 直接喂 Buffer(字节级,二进制资产也稳;分隔符是运行时字节,源码里不引入任何不可见字符)。
- * 读时(未来 list / drift 检查)用同一函数重算比对。
- */
-export declare function hashArtifactSource(source: string, isDirectorySkill: boolean): string;
+export { hashArtifactSource, isDistributablePath, distributableCopyFilter } from '../inputs/content-hash.js';
 export declare function loadManagedRecord(dir: string, id: string): ManagedArtifactRecord | null;
 /** 读全部记录。项目目录空 → 兜底全局(镜像 observe inbox 的 project→global)。 */
 export declare function loadAllManagedRecords(dir?: string): ManagedArtifactRecord[];
+/**
+ * 哪个 managed 目录是权威(有记录的那个):项目目录非空取项目,否则全局非空取全局,都空回项目。
+ * 与 `loadAllManagedRecords` 的 project→global 回退**同口径** —— 写方(append evidence)据此写回
+ * 读方实际取记录的同一目录,避免"读全局、写项目"把证据落到空目录。
+ */
+export declare function resolveManagedDir(dir?: string): string;
 /**
  * 纯合并逻辑(无 IO):install 写的是事实,绝不动 evidence/decisions(那是 eval/promote 的地盘)。
  *   - distribution 按 path 去重(同路径以新值替换);
@@ -48,6 +36,14 @@ export declare function loadAllManagedRecords(dir?: string): ManagedArtifactReco
 export declare function mergeManagedRecord(prev: ManagedArtifactRecord | null, next: ManagedArtifactRecord): ManagedArtifactRecord;
 /** 读旧记录 → 合并 → 原子 tmp+rename 只写该 id 的文件。返回合并后记录。 */
 export declare function upsertManagedRecord(dir: string, record: ManagedArtifactRecord): ManagedArtifactRecord;
+/**
+ * 追加一条评测证据(append-only)。与 install 的 upsert 路径相反——`mergeManagedRecord` 刻意**保留旧
+ * evidence、丢弃 next.evidence**(install 只写事实),所以证据写入不能走 upsert,必须独立 load→push→
+ * 原子重写。按 `(reportId, contentHash)` 去重:重跑同一份 eval 不堆重复条目(reportId 含运行身份,
+ * 同内容重测会是新 reportId → 新条目,正是要的版本史)。记录不存在(未 install / 名字不匹配)返回
+ * null —— 这是"管理是 install 显式 opt-in"的体现:eval 绝不为未纳管的 skill 凭空建记录。
+ */
+export declare function appendManagedEvidence(dir: string, recordId: string, evidence: ManagedEvidenceRef): ManagedArtifactRecord | null;
 /**
  * 统一的记录构造点——所有消费方(CLI / 未来 server / SDK)经此组装,保证 schema 一致。
  * 只接收事实(身份、源、hash、分发落点);evidence/decisions 恒为空(eval/promote 的地盘)。