oh-my-knowledge 1.0.0-beta.0 → 1.0.0-beta.2

package/README.md

@@ -228,6 +228,7 @@ The full docs are published at **[oh-my-knowledge.pages.dev](https://oh-my-knowl
 - **[CLI reference](docs/reference/cli.md)** — all top-level commands with bash examples and flag tables
 - **[Migrate to the 1.0 preview](docs/guides/v1-preview-migration.md)** — install channel, storage reset, sample protocol, CLI automation, and embedded API changes since 0.54
 - **[Evaluation Core cutover](docs/guides/eval-core-cutover.md)** — `BREAKING-SCHEMA` storage, resume, Studio, Gold, managed-evidence, and evolve migration
+- **[Embed OMK in a service](docs/guides/eval-runtime.md)** — lightweight `eval-runtime` assembly for Node.js and FaaS hosts
 - **[Storage layout v2](docs/specs/storage-layout-spec.md)** — project/global domains, compatibility boundary, and Git policy
 - **[Executors](docs/reference/executors.md)** & **[artifact layout](docs/reference/artifact-layout.md)** — built-in / custom executors; how `variant` resolves to an artifact + runtime context
 - **[How-to guides](docs/guides/agent-eval.md)** — [evaluate an agent](docs/guides/agent-eval.md) (project runtime context) and [use non-Claude models](docs/guides/non-claude-models.md) (GLM / Qwen / DeepSeek / Moonshot / Ollama)

package/README.zh.md

@@ -228,6 +228,7 @@ omk-mcp
 - **[CLI 参考](docs/zh/reference/cli.md)** —— 顶层命令的 bash 示例和 flag 表
 - **[迁移到 1.0 预览版](docs/zh/guides/v1-preview-migration.md)** —— 从 `0.54` 升级时的安装渠道、存储重建、用例协议、CLI 自动化与嵌入式 API 变化
 - **[Evaluation Core 生产切换](docs/zh/guides/eval-core-cutover.md)** —— `BREAKING-SCHEMA` 存储、resume、Studio、Gold、受管证据与 evolve 迁移
+- **[在服务中嵌入 OMK](docs/zh/guides/eval-runtime.md)** —— 面向 Node.js 与 FaaS 宿主的轻量 `eval-runtime` 装配
 - **[存储布局 v2](docs/zh/specs/storage-layout-spec.md)** —— 项目／全局领域、迁移兼容与 Git 策略
 - **[执行器](docs/zh/reference/executors.md)** & **[知识载体布局](docs/zh/reference/artifact-layout.md)** —— 内置 / 自定义执行器；variant 如何解析为 artifact + runtime context
 - **[操作指南](docs/zh/guides/agent-eval.md)** —— [评测 agent](docs/zh/guides/agent-eval.md)（项目 runtime context）与[使用非 Claude 模型](docs/zh/guides/non-claude-models.md)（GLM / 通义 / DeepSeek / Moonshot / Ollama）

package/dist/dsh-plugin/core-adapter.js

@@ -3,7 +3,7 @@ import { JsonValueSchema, RuntimeIdentitySchema, canonicalizeJson, deepFreezeCan
 import { ExecutionPortFailure, } from '../eval-core/execution/index.js';
 import { createDshHostRuntimeFingerprint } from '../executors/core/runtime-fingerprint.js';
 import { captureClaudeCliRunState, captureClaudeCliTarget, disposeClaudeCliTrial, openClaudeCliTrial, } from '../eval-workflows/runtime-adapter/adapters/claude/resources.js';
-import { createSameProcessExecutorAdapter } from '../eval-workflows/runtime-adapter/adapters/shared/same-process.js';
+import { createSameProcessExecutorAdapter } from '../eval-runtime/adapters/same-process.js';
 import { DSH_HOST_CORE_ADAPTER_IMPLEMENTATION_VERSION, dshHostCoreExecutorCapabilities, parseDshHostCoreResult, } from './core-protocol.js';
 import { supportsDshTraceEventType } from './trace-adapter.js';
 export { DSH_HOST_CORE_ADAPTER_IMPLEMENTATION_VERSION, createDshHostCoreSchemaValidators, } from './core-protocol.js';

package/dist/eval-core/analysis/runtime.js

@@ -260,20 +260,28 @@ function rowsForInputs(inputs) {
     }
     return [...byId.values()].sort((left, right) => compareStrings(left.rowId, right.rowId));
 }
-function observationCoverage(rows, includedRowIds, comparableRowIds) {
+function observationCoverage(rows, includedRowIds, comparableRowIds, notApplicableRowIds = []) {
     const included = new Set(includedRowIds);
     const comparable = new Set(comparableRowIds);
+    const notApplicable = new Set(notApplicableRowIds);
     const known = new Set(rows.map((row) => row.rowId));
     if (included.size !== includedRowIds.length
         || comparable.size !== comparableRowIds.length
+        || notApplicable.size !== notApplicableRowIds.length
         || [...included].some((rowId) => !known.has(rowId))
-        || [...comparable].some((rowId) => !included.has(rowId))) {
+        || [...comparable].some((rowId) => !included.has(rowId))
+        || [...notApplicable].some((rowId) => !known.has(rowId) || included.has(rowId))) {
         throw new TypeError('Analysis implementation returned invalid row membership.');
     }
+    if (rows.some((row) => (notApplicable.has(row.rowId)
+        && (row.rowStatus !== 'missing' || row.censored)))) {
+        throw new TypeError('Analysis implementation marked an ineligible row as not applicable.');
+    }
     const coverage = {
         planned: rows.length,
         observed: 0,
         missing: 0,
+        notApplicable: notApplicable.size,
         invalid: 0,
         evaluationFailed: 0,
         sourceUnavailable: 0,
@@ -284,6 +292,8 @@ function observationCoverage(rows, includedRowIds, comparableRowIds) {
         comparable: comparable.size,
     };
     for (const row of rows) {
+        if (notApplicable.has(row.rowId))
+            continue;
         if (row.rowStatus === 'observed')
             coverage.observed += 1;
         else if (row.rowStatus === 'missing')
@@ -319,6 +329,18 @@ function exclusionFacts(rows, includedRowIds) {
     }))
         .sort((left, right) => compareStrings(left.rowId, right.rowId));
 }
+function notApplicableFacts(rows, notApplicableRowIds) {
+    const notApplicable = new Set(notApplicableRowIds);
+    return rows
+        .filter((row) => notApplicable.has(row.rowId))
+        .map((row) => {
+        if (row.rowStatus === 'observed') {
+            throw new TypeError('Observed Analysis rows cannot be structurally not applicable.');
+        }
+        return { rowId: row.rowId, reasonCode: row.reasonCode };
+    })
+        .sort((left, right) => compareStrings(left.rowId, right.rowId));
+}
 function safeError(error) {
     if (error instanceof AnalysisPortFailure) {
         const parsed = EvaluationErrorSchema.safeParse(error.evaluationError);
@@ -583,6 +605,7 @@ async function runAnalysis(plan, ports, options, prepared, stream) {
                 inputReferences: binding.node.inputs,
                 coverage: emptyCoverage(rows),
                 exclusions: exclusionFacts(rows, []),
+                notApplicableRows: [],
                 assumptionChecks: [],
                 analysisMode: plan.analysis.analysisGraph.analysisMode,
                 derivedAt: ports.clock.timestamp(),
@@ -735,9 +758,10 @@ async function runAnalysis(plan, ports, options, prepared, stream) {
                 .map((row) => row.rowId);
             const includedRowIds = output.includedRowIds ?? observedRowIds;
             const comparableRowIds = output.comparableRowIds ?? includedRowIds;
+            const notApplicableRowIds = output.notApplicableRowIds ?? [];
             let coverage;
             try {
-                coverage = observationCoverage(rows, includedRowIds, comparableRowIds);
+                coverage = observationCoverage(rows, includedRowIds, comparableRowIds, notApplicableRowIds);
             }
             catch (error) {
                 const evaluationError = safeError(error);
@@ -784,6 +808,7 @@ async function runAnalysis(plan, ports, options, prepared, stream) {
                         ...base,
                         coverage,
                         exclusions: exclusionFacts(rows, includedRowIds),
+                        notApplicableRows: notApplicableFacts(rows, notApplicableRowIds),
                         assumptionChecks: checks,
                     }, runtimeDependencies, {
                         analysisStatus: 'inconclusive',
@@ -832,6 +857,7 @@ async function runAnalysis(plan, ports, options, prepared, stream) {
                     ...base,
                     coverage,
                     exclusions: exclusionFacts(rows, includedRowIds),
+                    notApplicableRows: notApplicableFacts(rows, notApplicableRowIds),
                     assumptionChecks: checks,
                 }, runtimeDependencies, {
                     analysisStatus: 'completed',
@@ -852,6 +878,7 @@ async function runAnalysis(plan, ports, options, prepared, stream) {
                     ...base,
                     coverage,
                     exclusions: exclusionFacts(rows, includedRowIds),
+                    notApplicableRows: notApplicableFacts(rows, notApplicableRowIds),
                     assumptionChecks: checks,
                 }, runtimeDependencies, {
                     analysisStatus: 'inconclusive',

package/dist/eval-core/analysis/types.d.ts

@@ -80,12 +80,14 @@ export type AnalysisNodeExecutionResult = {
     value: JsonValue;
     includedRowIds?: readonly Sha256Digest[];
     comparableRowIds?: readonly Sha256Digest[];
+    notApplicableRowIds?: readonly Sha256Digest[];
     assumptionChecks?: readonly Omit<AssumptionCheck, 'nodeId'>[];
 } | {
     analysisStatus: 'inconclusive';
     reasonCodes: readonly string[];
     includedRowIds?: readonly Sha256Digest[];
     comparableRowIds?: readonly Sha256Digest[];
+    notApplicableRowIds?: readonly Sha256Digest[];
     assumptionChecks?: readonly Omit<AssumptionCheck, 'nodeId'>[];
 };
 export declare const AnalysisNodeExecutionResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -101,6 +103,7 @@ export declare const AnalysisNodeExecutionResultSchema: z.ZodDiscriminatedUnion<
     value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
     includedRowIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     comparableRowIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    notApplicableRowIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     assumptionChecks: z.ZodOptional<z.ZodArray<z.ZodObject<{
         details: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
         reasonCode: z.ZodOptional<z.ZodString>;
@@ -116,6 +119,7 @@ export declare const AnalysisNodeExecutionResultSchema: z.ZodDiscriminatedUnion<
     reasonCodes: z.ZodArray<z.ZodString>;
     includedRowIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     comparableRowIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    notApplicableRowIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     assumptionChecks: z.ZodOptional<z.ZodArray<z.ZodObject<{
         details: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
         reasonCode: z.ZodOptional<z.ZodString>;

package/dist/eval-core/analysis/types.js

@@ -26,6 +26,7 @@ export const AnalysisNodeExecutionResultSchema = z.discriminatedUnion('analysisS
         value: JsonValueSchema,
         includedRowIds: z.array(Sha256DigestSchema).optional(),
         comparableRowIds: z.array(Sha256DigestSchema).optional(),
+        notApplicableRowIds: z.array(Sha256DigestSchema).optional(),
         assumptionChecks: z.array(PortAssumptionCheckSchema).optional(),
     }).strict(),
     z.object({
@@ -33,6 +34,7 @@ export const AnalysisNodeExecutionResultSchema = z.discriminatedUnion('analysisS
         reasonCodes: z.array(IdentifierSchema).min(1),
         includedRowIds: z.array(Sha256DigestSchema).optional(),
         comparableRowIds: z.array(Sha256DigestSchema).optional(),
+        notApplicableRowIds: z.array(Sha256DigestSchema).optional(),
         assumptionChecks: z.array(PortAssumptionCheckSchema).optional(),
     }).strict(),
 ]);

package/dist/eval-core/contracts/analysis-bundle.js

@@ -24,6 +24,7 @@ function compareStrings(left, right) {
 function assertObservationCoverage(coverage) {
     if (coverage.planned !== coverage.observed
         + coverage.missing
+        + coverage.notApplicable
         + coverage.invalid
         + coverage.evaluationFailed
         + coverage.sourceUnavailable
@@ -58,6 +59,20 @@ function assertRecords(bundle) {
         if (record.exclusions.length !== record.coverage.excluded) {
             throw new AnalysisBundleValidationError('ANALYSIS_BUNDLE_COVERAGE_INVALID', 'Analysis exclusions must account for every excluded observation row.');
         }
+        if (record.notApplicableRows.length !== record.coverage.notApplicable) {
+            throw new AnalysisBundleValidationError('ANALYSIS_BUNDLE_COVERAGE_INVALID', 'Analysis not-applicable rows must account for structural coverage.');
+        }
+        const exclusionById = new Map(record.exclusions.map((entry) => [entry.rowId, entry]));
+        for (let index = 0; index < record.notApplicableRows.length; index += 1) {
+            const fact = record.notApplicableRows[index];
+            const previousFact = record.notApplicableRows[index - 1];
+            if (previousFact !== undefined && compareStrings(previousFact.rowId, fact.rowId) >= 0) {
+                throw new AnalysisBundleValidationError('ANALYSIS_BUNDLE_COVERAGE_INVALID', 'Analysis not-applicable rows must use unique canonical row order.');
+            }
+            if (exclusionById.get(fact.rowId)?.reasonCode !== fact.reasonCode) {
+                throw new AnalysisBundleValidationError('ANALYSIS_BUNDLE_COVERAGE_INVALID', 'Every not-applicable row must be retained as a matching exclusion fact.');
+            }
+        }
         for (let exclusionIndex = 0; exclusionIndex < record.exclusions.length; exclusionIndex += 1) {
             const exclusion = record.exclusions[exclusionIndex];
             const previousExclusion = record.exclusions[exclusionIndex - 1];
@@ -282,10 +297,12 @@ function expectedRows(plan, execution, evaluation, node) {
     return rows.sort((left, right) => compareStrings(left.rowId, right.rowId));
 }
 function assertSourceCoverage(record, rows) {
+    const notApplicableIds = new Set(record.notApplicableRows.map((entry) => entry.rowId));
     const expected = {
         planned: rows.length,
         observed: rows.filter((row) => row.rowStatus === 'observed').length,
-        missing: rows.filter((row) => row.rowStatus === 'missing').length,
+        missing: rows.filter((row) => (row.rowStatus === 'missing' && !notApplicableIds.has(row.rowId))).length,
+        notApplicable: record.notApplicableRows.length,
         invalid: rows.filter((row) => row.rowStatus === 'invalid').length,
         evaluationFailed: rows.filter((row) => row.rowStatus === 'evaluation-failed').length,
         sourceUnavailable: rows.filter((row) => row.rowStatus === 'source-unavailable').length,
@@ -296,6 +313,7 @@ function assertSourceCoverage(record, rows) {
         planned: record.coverage.planned,
         observed: record.coverage.observed,
         missing: record.coverage.missing,
+        notApplicable: record.coverage.notApplicable,
         invalid: record.coverage.invalid,
         evaluationFailed: record.coverage.evaluationFailed,
         sourceUnavailable: record.coverage.sourceUnavailable,
@@ -308,6 +326,12 @@ function assertSourceCoverage(record, rows) {
     const byId = new Map(rows.map((row) => [row.rowId, row]));
     const exclusionById = new Map(record.exclusions.map((entry) => [entry.rowId, entry]));
     if (record.exclusions.some((entry) => !byId.has(entry.rowId))
+        || record.notApplicableRows.some((entry) => {
+            const row = byId.get(entry.rowId);
+            return row?.rowStatus !== 'missing'
+                || row.censored
+                || row.reasonCode !== entry.reasonCode;
+        })
         || rows.some((row) => row.rowStatus !== 'observed'
             && (exclusionById.get(row.rowId)?.reasonCode !== row.reasonCode))) {
         throw new AnalysisBundleValidationError('ANALYSIS_BUNDLE_SOURCE_MISMATCH', 'Analysis exclusions do not match source observation identities and reasons.');

package/dist/eval-core/contracts/artifacts.d.ts

@@ -2,8 +2,8 @@ import { z } from 'zod';
 export declare const EVALUATION_EVENT_SCHEMA_VERSION: "omk.evaluation-event/v1";
 export declare const EXECUTION_BUNDLE_SCHEMA_VERSION: "omk.execution-bundle/v1";
 export declare const EVALUATION_BUNDLE_SCHEMA_VERSION: "omk.evaluation-bundle/v1";
-export declare const ANALYSIS_BUNDLE_SCHEMA_VERSION: "omk.analysis-bundle/v1";
-export declare const EVALUATION_REPORT_SCHEMA_VERSION: "omk.evaluation-report/v1";
+export declare const ANALYSIS_BUNDLE_SCHEMA_VERSION: "omk.analysis-bundle/v2";
+export declare const EVALUATION_REPORT_SCHEMA_VERSION: "omk.evaluation-report/v2";
 export declare const TimingRecordSchema: z.ZodObject<{
     startedAt: z.ZodString;
     completedAt: z.ZodOptional<z.ZodString>;
@@ -7259,6 +7259,7 @@ export declare const AnalysisObservationCoverageSchema: z.ZodObject<{
     planned: z.ZodNumber;
     observed: z.ZodNumber;
     missing: z.ZodNumber;
+    notApplicable: z.ZodNumber;
     invalid: z.ZodNumber;
     evaluationFailed: z.ZodNumber;
     sourceUnavailable: z.ZodNumber;
@@ -7355,6 +7356,7 @@ export declare const CompletedAnalysisRecordSchema: z.ZodObject<{
         planned: z.ZodNumber;
         observed: z.ZodNumber;
         missing: z.ZodNumber;
+        notApplicable: z.ZodNumber;
         invalid: z.ZodNumber;
         evaluationFailed: z.ZodNumber;
         sourceUnavailable: z.ZodNumber;
@@ -7368,6 +7370,10 @@ export declare const CompletedAnalysisRecordSchema: z.ZodObject<{
         rowId: z.ZodString;
         reasonCode: z.ZodString;
     }, z.core.$strict>>;
+    notApplicableRows: z.ZodArray<z.ZodObject<{
+        rowId: z.ZodString;
+        reasonCode: z.ZodString;
+    }, z.core.$strict>>;
     assumptionChecks: z.ZodArray<z.ZodObject<{
         assumptionId: z.ZodString;
         nodeId: z.ZodString;
@@ -7469,6 +7475,7 @@ export declare const InconclusiveAnalysisRecordSchema: z.ZodObject<{
         planned: z.ZodNumber;
         observed: z.ZodNumber;
         missing: z.ZodNumber;
+        notApplicable: z.ZodNumber;
         invalid: z.ZodNumber;
         evaluationFailed: z.ZodNumber;
         sourceUnavailable: z.ZodNumber;
@@ -7482,6 +7489,10 @@ export declare const InconclusiveAnalysisRecordSchema: z.ZodObject<{
         rowId: z.ZodString;
         reasonCode: z.ZodString;
     }, z.core.$strict>>;
+    notApplicableRows: z.ZodArray<z.ZodObject<{
+        rowId: z.ZodString;
+        reasonCode: z.ZodString;
+    }, z.core.$strict>>;
     assumptionChecks: z.ZodArray<z.ZodObject<{
         assumptionId: z.ZodString;
         nodeId: z.ZodString;
@@ -7575,6 +7586,7 @@ export declare const FailedAnalysisRecordSchema: z.ZodObject<{
         planned: z.ZodNumber;
         observed: z.ZodNumber;
         missing: z.ZodNumber;
+        notApplicable: z.ZodNumber;
         invalid: z.ZodNumber;
         evaluationFailed: z.ZodNumber;
         sourceUnavailable: z.ZodNumber;
@@ -7588,6 +7600,10 @@ export declare const FailedAnalysisRecordSchema: z.ZodObject<{
         rowId: z.ZodString;
         reasonCode: z.ZodString;
     }, z.core.$strict>>;
+    notApplicableRows: z.ZodArray<z.ZodObject<{
+        rowId: z.ZodString;
+        reasonCode: z.ZodString;
+    }, z.core.$strict>>;
     assumptionChecks: z.ZodArray<z.ZodObject<{
         assumptionId: z.ZodString;
         nodeId: z.ZodString;
@@ -7681,6 +7697,7 @@ export declare const NotEvaluatedAnalysisRecordSchema: z.ZodObject<{
         planned: z.ZodNumber;
         observed: z.ZodNumber;
         missing: z.ZodNumber;
+        notApplicable: z.ZodNumber;
         invalid: z.ZodNumber;
         evaluationFailed: z.ZodNumber;
         sourceUnavailable: z.ZodNumber;
@@ -7694,6 +7711,10 @@ export declare const NotEvaluatedAnalysisRecordSchema: z.ZodObject<{
         rowId: z.ZodString;
         reasonCode: z.ZodString;
     }, z.core.$strict>>;
+    notApplicableRows: z.ZodArray<z.ZodObject<{
+        rowId: z.ZodString;
+        reasonCode: z.ZodString;
+    }, z.core.$strict>>;
     assumptionChecks: z.ZodArray<z.ZodObject<{
         assumptionId: z.ZodString;
         nodeId: z.ZodString;
@@ -7787,6 +7808,7 @@ export declare const AnalysisRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         planned: z.ZodNumber;
         observed: z.ZodNumber;
         missing: z.ZodNumber;
+        notApplicable: z.ZodNumber;
         invalid: z.ZodNumber;
         evaluationFailed: z.ZodNumber;
         sourceUnavailable: z.ZodNumber;
@@ -7800,6 +7822,10 @@ export declare const AnalysisRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         rowId: z.ZodString;
         reasonCode: z.ZodString;
     }, z.core.$strict>>;
+    notApplicableRows: z.ZodArray<z.ZodObject<{
+        rowId: z.ZodString;
+        reasonCode: z.ZodString;
+    }, z.core.$strict>>;
     assumptionChecks: z.ZodArray<z.ZodObject<{
         assumptionId: z.ZodString;
         nodeId: z.ZodString;
@@ -7900,6 +7926,7 @@ export declare const AnalysisRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         planned: z.ZodNumber;
         observed: z.ZodNumber;
         missing: z.ZodNumber;
+        notApplicable: z.ZodNumber;
         invalid: z.ZodNumber;
         evaluationFailed: z.ZodNumber;
         sourceUnavailable: z.ZodNumber;
@@ -7913,6 +7940,10 @@ export declare const AnalysisRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         rowId: z.ZodString;
         reasonCode: z.ZodString;
     }, z.core.$strict>>;
+    notApplicableRows: z.ZodArray<z.ZodObject<{
+        rowId: z.ZodString;
+        reasonCode: z.ZodString;
+    }, z.core.$strict>>;
     assumptionChecks: z.ZodArray<z.ZodObject<{
         assumptionId: z.ZodString;
         nodeId: z.ZodString;
@@ -8005,6 +8036,7 @@ export declare const AnalysisRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         planned: z.ZodNumber;
         observed: z.ZodNumber;
         missing: z.ZodNumber;
+        notApplicable: z.ZodNumber;
         invalid: z.ZodNumber;
         evaluationFailed: z.ZodNumber;
         sourceUnavailable: z.ZodNumber;
@@ -8018,6 +8050,10 @@ export declare const AnalysisRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         rowId: z.ZodString;
         reasonCode: z.ZodString;
     }, z.core.$strict>>;
+    notApplicableRows: z.ZodArray<z.ZodObject<{
+        rowId: z.ZodString;
+        reasonCode: z.ZodString;
+    }, z.core.$strict>>;
     assumptionChecks: z.ZodArray<z.ZodObject<{
         assumptionId: z.ZodString;
         nodeId: z.ZodString;
@@ -8110,6 +8146,7 @@ export declare const AnalysisRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         planned: z.ZodNumber;
         observed: z.ZodNumber;
         missing: z.ZodNumber;
+        notApplicable: z.ZodNumber;
         invalid: z.ZodNumber;
         evaluationFailed: z.ZodNumber;
         sourceUnavailable: z.ZodNumber;
@@ -8123,6 +8160,10 @@ export declare const AnalysisRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         rowId: z.ZodString;
         reasonCode: z.ZodString;
     }, z.core.$strict>>;
+    notApplicableRows: z.ZodArray<z.ZodObject<{
+        rowId: z.ZodString;
+        reasonCode: z.ZodString;
+    }, z.core.$strict>>;
     assumptionChecks: z.ZodArray<z.ZodObject<{
         assumptionId: z.ZodString;
         nodeId: z.ZodString;
@@ -8160,7 +8201,7 @@ export declare const AnalysisCoverageSchema: z.ZodObject<{
     notStarted: z.ZodNumber;
 }, z.core.$strict>;
 export declare const AnalysisBundleSchema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<"omk.analysis-bundle/v1">;
+    schemaVersion: z.ZodLiteral<"omk.analysis-bundle/v2">;
     bundleId: z.ZodString;
     runContractDigest: z.ZodString;
     evaluationBundleDigest: z.ZodString;
@@ -8244,6 +8285,7 @@ export declare const AnalysisBundleSchema: z.ZodObject<{
             planned: z.ZodNumber;
             observed: z.ZodNumber;
             missing: z.ZodNumber;
+            notApplicable: z.ZodNumber;
             invalid: z.ZodNumber;
             evaluationFailed: z.ZodNumber;
             sourceUnavailable: z.ZodNumber;
@@ -8257,6 +8299,10 @@ export declare const AnalysisBundleSchema: z.ZodObject<{
             rowId: z.ZodString;
             reasonCode: z.ZodString;
         }, z.core.$strict>>;
+        notApplicableRows: z.ZodArray<z.ZodObject<{
+            rowId: z.ZodString;
+            reasonCode: z.ZodString;
+        }, z.core.$strict>>;
         assumptionChecks: z.ZodArray<z.ZodObject<{
             assumptionId: z.ZodString;
             nodeId: z.ZodString;
@@ -8357,6 +8403,7 @@ export declare const AnalysisBundleSchema: z.ZodObject<{
             planned: z.ZodNumber;
             observed: z.ZodNumber;
             missing: z.ZodNumber;
+            notApplicable: z.ZodNumber;
             invalid: z.ZodNumber;
             evaluationFailed: z.ZodNumber;
             sourceUnavailable: z.ZodNumber;
@@ -8370,6 +8417,10 @@ export declare const AnalysisBundleSchema: z.ZodObject<{
             rowId: z.ZodString;
             reasonCode: z.ZodString;
         }, z.core.$strict>>;
+        notApplicableRows: z.ZodArray<z.ZodObject<{
+            rowId: z.ZodString;
+            reasonCode: z.ZodString;
+        }, z.core.$strict>>;
         assumptionChecks: z.ZodArray<z.ZodObject<{
             assumptionId: z.ZodString;
             nodeId: z.ZodString;
@@ -8462,6 +8513,7 @@ export declare const AnalysisBundleSchema: z.ZodObject<{
             planned: z.ZodNumber;
             observed: z.ZodNumber;
             missing: z.ZodNumber;
+            notApplicable: z.ZodNumber;
             invalid: z.ZodNumber;
             evaluationFailed: z.ZodNumber;
             sourceUnavailable: z.ZodNumber;
@@ -8475,6 +8527,10 @@ export declare const AnalysisBundleSchema: z.ZodObject<{
             rowId: z.ZodString;
             reasonCode: z.ZodString;
         }, z.core.$strict>>;
+        notApplicableRows: z.ZodArray<z.ZodObject<{
+            rowId: z.ZodString;
+            reasonCode: z.ZodString;
+        }, z.core.$strict>>;
         assumptionChecks: z.ZodArray<z.ZodObject<{
             assumptionId: z.ZodString;
             nodeId: z.ZodString;
@@ -8567,6 +8623,7 @@ export declare const AnalysisBundleSchema: z.ZodObject<{
             planned: z.ZodNumber;
             observed: z.ZodNumber;
             missing: z.ZodNumber;
+            notApplicable: z.ZodNumber;
             invalid: z.ZodNumber;
             evaluationFailed: z.ZodNumber;
             sourceUnavailable: z.ZodNumber;
@@ -8580,6 +8637,10 @@ export declare const AnalysisBundleSchema: z.ZodObject<{
             rowId: z.ZodString;
             reasonCode: z.ZodString;
         }, z.core.$strict>>;
+        notApplicableRows: z.ZodArray<z.ZodObject<{
+            rowId: z.ZodString;
+            reasonCode: z.ZodString;
+        }, z.core.$strict>>;
         assumptionChecks: z.ZodArray<z.ZodObject<{
             assumptionId: z.ZodString;
             nodeId: z.ZodString;
@@ -8801,7 +8862,7 @@ export declare const DecisionResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
     decisionDigest: z.ZodString;
 }, z.core.$strict>], "decisionStatus">;
 export declare const EvaluationReportSchema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<"omk.evaluation-report/v1">;
+    schemaVersion: z.ZodLiteral<"omk.evaluation-report/v2">;
     reportId: z.ZodString;
     runContractDigest: z.ZodString;
     status: z.ZodObject<{

package/dist/eval-core/contracts/artifacts.js

@@ -5,8 +5,8 @@ import { BudgetSummarySchema } from './budget.js';
 export const EVALUATION_EVENT_SCHEMA_VERSION = 'omk.evaluation-event/v1';
 export const EXECUTION_BUNDLE_SCHEMA_VERSION = 'omk.execution-bundle/v1';
 export const EVALUATION_BUNDLE_SCHEMA_VERSION = 'omk.evaluation-bundle/v1';
-export const ANALYSIS_BUNDLE_SCHEMA_VERSION = 'omk.analysis-bundle/v1';
-export const EVALUATION_REPORT_SCHEMA_VERSION = 'omk.evaluation-report/v1';
+export const ANALYSIS_BUNDLE_SCHEMA_VERSION = 'omk.analysis-bundle/v2';
+export const EVALUATION_REPORT_SCHEMA_VERSION = 'omk.evaluation-report/v2';
 export const TimingRecordSchema = z.object({
     startedAt: TimestampSchema,
     completedAt: TimestampSchema.optional(),
@@ -280,6 +280,7 @@ export const AnalysisObservationCoverageSchema = z.object({
     planned: z.number().int().nonnegative(),
     observed: z.number().int().nonnegative(),
     missing: z.number().int().nonnegative(),
+    notApplicable: z.number().int().nonnegative(),
     invalid: z.number().int().nonnegative(),
     evaluationFailed: z.number().int().nonnegative(),
     sourceUnavailable: z.number().int().nonnegative(),
@@ -332,6 +333,7 @@ const AnalysisRecordBaseSchema = z.object({
     ])).min(1),
     coverage: AnalysisObservationCoverageSchema,
     exclusions: z.array(AnalysisExclusionSchema),
+    notApplicableRows: z.array(AnalysisExclusionSchema),
     assumptionChecks: z.array(AssumptionCheckSchema),
     runtimeDependencies: z.array(AnalysisRuntimeDependencySchema),
     analysisMode: z.enum(['preregistered', 'exploratory']),
@@ -394,7 +396,7 @@ export const AnalysisBundleSchema = z.object({
     bundleDigest: Sha256DigestSchema,
     extensions: ExtensionsSchema.optional(),
 }).strict().meta({
-    title: 'OMK Analysis Bundle v1',
+    title: 'OMK Analysis Bundle v2',
 });
 export const EvaluationStatusSchema = z.object({
     runStatus: z.enum(['completed', 'cancelled', 'budget-exhausted', 'failed']),
@@ -448,7 +450,7 @@ export const EvaluationReportSchema = z.object({
     reportDigest: Sha256DigestSchema,
     extensions: ExtensionsSchema.optional(),
 }).strict().meta({
-    title: 'OMK Evaluation Report v1',
+    title: 'OMK Evaluation Report v2',
 });
 export const EvaluationEventSchema = z.object({
     schemaVersion: z.literal(EVALUATION_EVENT_SCHEMA_VERSION),

package/dist/eval-core/contracts/json-schema.d.ts

@@ -7,6 +7,8 @@ export interface WireSchemaCatalogEntry {
     schema: z.ZodType;
     includedInRunContract?: false;
 }
+export type WireSchemaCatalogVersion = `v${number}`;
+export declare function wireSchemaCatalogVersion(entry: Pick<WireSchemaCatalogEntry, 'schemaVersion'>): WireSchemaCatalogVersion;
 export declare const WIRE_SCHEMA_CATALOG: readonly WireSchemaCatalogEntry[];
 export declare function generateWireJsonSchemas(): Readonly<Record<string, JsonValue>>;
 export declare function generateWireSchemaIdentities(): SchemaIdentity[];

package/dist/eval-core/contracts/json-schema.js

@@ -8,6 +8,13 @@ import { COMPARABILITY_ASSESSMENT_SCHEMA_VERSION, COMPARABILITY_POLICY_SCHEMA_VE
 import { EVALUATION_SERIES_DEFINITION_SCHEMA_VERSION, EVALUATION_SERIES_PLAN_SCHEMA_VERSION, EVALUATION_SERIES_REPORT_SCHEMA_VERSION, EvaluationSeriesDefinitionSchema, EvaluationSeriesPlanSchema, EvaluationSeriesReportSchema, SERIES_ANALYSIS_BUNDLE_SCHEMA_VERSION, SeriesAnalysisBundleSchema, } from './series.js';
 import { EXECUTOR_CAPABILITIES_SCHEMA_VERSION, ExecutorCapabilitiesSchema, } from './runtime-capabilities.js';
 import { EXECUTION_FACTS_SCHEMA_VERSION, ExecutionFactsSchema, } from './execution-facts.js';
+export function wireSchemaCatalogVersion(entry) {
+    const version = entry.schemaVersion.match(/\/(v[1-9]\d*)$/)?.[1];
+    if (version === undefined) {
+        throw new Error(`Wire schema version is not explicitly versioned: ${entry.schemaVersion}`);
+    }
+    return version;
+}
 export const WIRE_SCHEMA_CATALOG = [
     {
         fileName: 'execution-facts.schema.json',
@@ -121,9 +128,9 @@ export const WIRE_SCHEMA_CATALOG = [
         includedInRunContract: false,
     },
 ];
-// `$id` is the stable document identity established by the published v1 contract. It is
-// intentionally independent from the current catalog retrieval path under `schemas/eval-core`.
-const SCHEMA_BASE_URI = 'https://raw.githubusercontent.com/lizhiyao/oh-my-knowledge/main/schemas/evaluation-core/v1';
+// Keep the public identity aligned with the canonical catalog location so schema tooling can
+// resolve the identifier instead of treating a stale repository path as an opaque URI.
+const SCHEMA_BASE_URI = 'https://raw.githubusercontent.com/lizhiyao/oh-my-knowledge/main/schemas/eval-core';
 function assertNoEmptySchemaNode(value, path = '$') {
     if (Array.isArray(value)) {
         value.forEach((entry, index) => assertNoEmptySchemaNode(entry, `${path}[${index}]`));
@@ -145,7 +152,7 @@ export function generateWireJsonSchemas() {
             cycles: 'ref',
             reused: 'ref',
         });
-        const schemaUri = `${SCHEMA_BASE_URI}/${entry.fileName}`;
+        const schemaUri = `${SCHEMA_BASE_URI}/${wireSchemaCatalogVersion(entry)}/${entry.fileName}`;
         const schema = { ...generated, $id: schemaUri };
         assertNoEmptySchemaNode(schema);
         return [entry.fileName, schema];

package/dist/eval-core/contracts/schemas/v1/analysis-bundle.schema.json

@@ -933,7 +933,7 @@
       "type": "string"
     }
   },
-  "$id": "https://raw.githubusercontent.com/lizhiyao/oh-my-knowledge/main/schemas/evaluation-core/v1/analysis-bundle.schema.json",
+  "$id": "https://raw.githubusercontent.com/lizhiyao/oh-my-knowledge/main/schemas/eval-core/v1/analysis-bundle.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
   "properties": {

package/dist/eval-core/contracts/schemas/v1/analysis-plan.schema.json

@@ -830,7 +830,7 @@
       "type": "array"
     }
   },
-  "$id": "https://raw.githubusercontent.com/lizhiyao/oh-my-knowledge/main/schemas/evaluation-core/v1/analysis-plan.schema.json",
+  "$id": "https://raw.githubusercontent.com/lizhiyao/oh-my-knowledge/main/schemas/eval-core/v1/analysis-plan.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
   "properties": {

package/dist/eval-core/contracts/schemas/v1/budget-summary.schema.json

@@ -400,7 +400,7 @@
       "type": "number"
     }
   },
-  "$id": "https://raw.githubusercontent.com/lizhiyao/oh-my-knowledge/main/schemas/evaluation-core/v1/budget-summary.schema.json",
+  "$id": "https://raw.githubusercontent.com/lizhiyao/oh-my-knowledge/main/schemas/eval-core/v1/budget-summary.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
   "properties": {

package/dist/eval-core/contracts/schemas/v1/comparability-assessment.schema.json

@@ -397,7 +397,7 @@
       "type": "string"
     }
   },
-  "$id": "https://raw.githubusercontent.com/lizhiyao/oh-my-knowledge/main/schemas/evaluation-core/v1/comparability-assessment.schema.json",
+  "$id": "https://raw.githubusercontent.com/lizhiyao/oh-my-knowledge/main/schemas/eval-core/v1/comparability-assessment.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
   "properties": {

package/dist/eval-core/contracts/schemas/v1/comparability-policy.schema.json

@@ -53,7 +53,7 @@
       "type": "string"
     }
   },
-  "$id": "https://raw.githubusercontent.com/lizhiyao/oh-my-knowledge/main/schemas/evaluation-core/v1/comparability-policy.schema.json",
+  "$id": "https://raw.githubusercontent.com/lizhiyao/oh-my-knowledge/main/schemas/eval-core/v1/comparability-policy.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
   "properties": {

package/dist/eval-core/contracts/schemas/v1/decision-plan.schema.json

@@ -351,7 +351,7 @@
       "type": "object"
     }
   },
-  "$id": "https://raw.githubusercontent.com/lizhiyao/oh-my-knowledge/main/schemas/evaluation-core/v1/decision-plan.schema.json",
+  "$id": "https://raw.githubusercontent.com/lizhiyao/oh-my-knowledge/main/schemas/eval-core/v1/decision-plan.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
   "properties": {