Bound auxiliary artifact verification state

Signed-off-by: Nelson Spence <nelson@projectnavi.ai>

Author: Fieldnote-Echo

CHANGELOG.md

@@ -11,7 +11,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Added bounded parser/report defaults to `ordvec-manifest` verification for
   manifest JSON size, row-identity JSONL line length, row count,
-  duplicate-tracking memory, report issue count, and SQLite cached report size.
+  duplicate-tracking memory, auxiliary artifact declaration count, report issue
+  count, and SQLite cached report size.
 
 ### Added
 

ordvec-manifest/README.md

@@ -32,19 +32,21 @@ Verification uses bounded parser/report defaults on both CLI and library paths:
 - row-identity JSONL line: 64 KiB;
 - row-identity JSONL rows: 10,000,000;
 - row-identity duplicate-tracking `db_id` bytes: 64 MiB;
+- auxiliary artifact declarations: 1,024;
 - collected report issues: 1,024, after which a
   `verification_report_issue_limit_exceeded` issue is emitted;
 - SQLite cached report JSON: 4 MiB.
 
 The CLI exposes matching override flags on `inspect`, `verify`, `create`,
 `sqlite verify`, and `sqlite activate`: `--max-manifest-bytes`,
 `--max-row-map-line-bytes`, `--max-row-map-rows`,
-`--max-row-map-tracked-id-bytes`, `--max-report-issues`, and
-`--max-cached-report-bytes`. Library callers can override the same ceilings
-via `VerifyOptions::limits`. Stable limit codes exposed through verification
-reports are `row_identity_line_too_large`,
+`--max-row-map-tracked-id-bytes`, `--max-auxiliary-artifacts`,
+`--max-report-issues`, and `--max-cached-report-bytes`. Library callers can
+override the same ceilings via `VerifyOptions::limits`. Stable limit codes
+exposed through verification reports are `row_identity_line_too_large`,
 `row_identity_row_count_limit_exceeded`,
-`row_identity_duplicate_tracking_limit_exceeded`, and
+`row_identity_duplicate_tracking_limit_exceeded`,
+`auxiliary_artifact_count_limit_exceeded`, and
 `verification_report_issue_limit_exceeded`. `ManifestError::code()` reports
 `manifest_file_too_large`, `row_identity_line_too_large`,
 `row_identity_row_count_limit_exceeded`,

ordvec-manifest/src/lib.rs

@@ -18,6 +18,7 @@ pub const DEFAULT_MAX_MANIFEST_BYTES: u64 = 1024 * 1024;
 pub const DEFAULT_MAX_ROW_IDENTITY_JSONL_LINE_BYTES: usize = 64 * 1024;
 pub const DEFAULT_MAX_ROW_IDENTITY_ROWS: usize = 10_000_000;
 pub const DEFAULT_MAX_ROW_IDENTITY_TRACKED_DB_ID_BYTES: usize = 64 * 1024 * 1024;
+pub const DEFAULT_MAX_AUXILIARY_ARTIFACTS: usize = 1024;
 pub const DEFAULT_MAX_REPORT_ISSUES: usize = 1024;
 pub const DEFAULT_MAX_CACHED_REPORT_BYTES: u64 = 4 * 1024 * 1024;
 
@@ -157,7 +158,7 @@ pub fn verify_index_manifest(
 
 pub fn verify_manifest(document: &ManifestDocument, options: VerifyOptions) -> VerificationReport {
     let mut report = VerificationReport::new(Some(document.manifest.manifest_id.clone()));
-    validate_manifest_shape(&document.manifest, &mut report);
+    validate_manifest_shape(&document.manifest, &options.limits, &mut report);
 
     let artifact_display_path = document.manifest.artifact.path.clone();
     report.artifact.manifest_path = Some(artifact_display_path.clone());
@@ -228,7 +229,11 @@ pub fn verify_manifest(document: &ManifestDocument, options: VerifyOptions) -> V
     report
 }
 
-fn validate_manifest_shape(manifest: &IndexManifest, report: &mut VerificationReport) {
+fn validate_manifest_shape(
+    manifest: &IndexManifest,
+    limits: &ResourceLimits,
+    report: &mut VerificationReport,
+) {
     if manifest.schema_version != SCHEMA_VERSION {
         report.error(
             "schema_version_unsupported",
@@ -321,7 +326,7 @@ fn validate_manifest_shape(manifest: &IndexManifest, report: &mut VerificationRe
         }
     }
 
-    validate_auxiliary_artifact_shape(manifest, report);
+    validate_auxiliary_artifact_shape(manifest, limits, report);
 
     validate_optional_non_empty(
         "embedding_model_revision_empty",
@@ -401,7 +406,14 @@ fn validate_manifest_shape(manifest: &IndexManifest, report: &mut VerificationRe
     }
 }
 
-fn validate_auxiliary_artifact_shape(manifest: &IndexManifest, report: &mut VerificationReport) {
+fn validate_auxiliary_artifact_shape(
+    manifest: &IndexManifest,
+    limits: &ResourceLimits,
+    report: &mut VerificationReport,
+) {
+    if !check_auxiliary_artifact_count(manifest, limits, report) {
+        return;
+    }
     let mut names = HashSet::new();
     for artifact in &manifest.auxiliary_artifacts {
         let name = artifact.name.trim();
@@ -1176,6 +1188,9 @@ fn verify_auxiliary_artifacts(
     options: &VerifyOptions,
     report: &mut VerificationReport,
 ) {
+    if !check_auxiliary_artifact_count(&document.manifest, &options.limits, report) {
+        return;
+    }
     for artifact in auxiliary_artifacts_in_report_order(&document.manifest) {
         let mut entry = AuxiliaryArtifactReport {
             name: artifact.name.clone(),
@@ -1264,6 +1279,33 @@ fn verify_auxiliary_artifacts(
     }
 }
 
+fn check_auxiliary_artifact_count(
+    manifest: &IndexManifest,
+    limits: &ResourceLimits,
+    report: &mut VerificationReport,
+) -> bool {
+    let count = manifest.auxiliary_artifacts.len();
+    if count <= limits.max_auxiliary_artifacts {
+        return true;
+    }
+    if !report
+        .errors
+        .iter()
+        .any(|issue| issue.code == "auxiliary_artifact_count_limit_exceeded")
+    {
+        push_report_issue_bounded(
+            &mut report.errors,
+            limits,
+            "auxiliary_artifact_count_limit_exceeded",
+            format!(
+                "auxiliary_artifacts has {count} entries, exceeding max_auxiliary_artifacts={}",
+                limits.max_auxiliary_artifacts
+            ),
+        );
+    }
+    false
+}
+
 fn auxiliary_artifacts_in_report_order(manifest: &IndexManifest) -> Vec<&AuxiliaryArtifact> {
     let mut artifacts: Vec<_> = manifest.auxiliary_artifacts.iter().collect();
     artifacts.sort_by(|left, right| {
@@ -1473,6 +1515,7 @@ pub struct ResourceLimits {
     pub max_row_identity_jsonl_line_bytes: usize,
     pub max_row_identity_rows: usize,
     pub max_row_identity_tracked_db_id_bytes: usize,
+    pub max_auxiliary_artifacts: usize,
     pub max_report_issues: usize,
     pub max_cached_report_bytes: u64,
 }
@@ -1484,6 +1527,7 @@ impl Default for ResourceLimits {
             max_row_identity_jsonl_line_bytes: DEFAULT_MAX_ROW_IDENTITY_JSONL_LINE_BYTES,
             max_row_identity_rows: DEFAULT_MAX_ROW_IDENTITY_ROWS,
             max_row_identity_tracked_db_id_bytes: DEFAULT_MAX_ROW_IDENTITY_TRACKED_DB_ID_BYTES,
+            max_auxiliary_artifacts: DEFAULT_MAX_AUXILIARY_ARTIFACTS,
             max_report_issues: DEFAULT_MAX_REPORT_ISSUES,
             max_cached_report_bytes: DEFAULT_MAX_CACHED_REPORT_BYTES,
         }
@@ -1863,6 +1907,7 @@ pub struct VerificationReport {
     pub checked_at: String,
     pub manifest_id: Option<String>,
     pub artifact: ArtifactReport,
+    #[serde(default)]
     pub auxiliary_artifacts: Vec<AuxiliaryArtifactReport>,
     pub row_identity: RowIdentityReport,
     pub calibration: CalibrationReport,

ordvec-manifest/src/main.rs

@@ -131,6 +131,8 @@ struct LimitArgs {
     #[arg(long)]
     max_row_map_tracked_id_bytes: Option<usize>,
     #[arg(long)]
+    max_auxiliary_artifacts: Option<usize>,
+    #[arg(long)]
     max_report_issues: Option<usize>,
     #[arg(long)]
     max_cached_report_bytes: Option<u64>,
@@ -151,6 +153,9 @@ impl LimitArgs {
         if let Some(value) = self.max_row_map_tracked_id_bytes {
             limits.max_row_identity_tracked_db_id_bytes = value;
         }
+        if let Some(value) = self.max_auxiliary_artifacts {
+            limits.max_auxiliary_artifacts = value;
+        }
         if let Some(value) = self.max_report_issues {
             limits.max_report_issues = value;
         }

ordvec-manifest/src/sqlite.rs

@@ -465,9 +465,6 @@ fn current_auxiliary_artifacts_sha256(
     }
     let mut report = VerificationReport::new(None);
     verify_auxiliary_artifacts(document, options, &mut report);
-    if !report.errors.is_empty() {
-        return Ok(None);
-    }
     auxiliary_artifacts_sha256_from_report(document, &report)
 }
 
@@ -484,35 +481,27 @@ fn auxiliary_artifacts_sha256_from_report(
 
     let mut entries = Vec::with_capacity(report.auxiliary_artifacts.len());
     for entry in &report.auxiliary_artifacts {
-        match entry.state {
+        let state = match entry.state {
             AuxiliaryArtifactState::Verified => {
                 let (Some(sha256), Some(size_bytes)) = (entry.sha256.as_ref(), entry.size_bytes)
                 else {
                     return Ok(None);
                 };
-                entries.push(AuxiliaryArtifactCacheEntry {
-                    name: entry.name.clone(),
-                    path: entry.manifest_path.clone(),
-                    required: entry.required,
-                    state: "verified",
-                    sha256: Some(sha256.clone()),
-                    size_bytes: Some(size_bytes),
-                });
+                ("verified", Some(sha256.clone()), Some(size_bytes))
             }
-            AuxiliaryArtifactState::OptionalAbsent => {
-                entries.push(AuxiliaryArtifactCacheEntry {
-                    name: entry.name.clone(),
-                    path: entry.manifest_path.clone(),
-                    required: entry.required,
-                    state: "optional_absent",
-                    sha256: None,
-                    size_bytes: None,
-                });
-            }
-            AuxiliaryArtifactState::MissingRequired | AuxiliaryArtifactState::Failed => {
-                return Ok(None);
-            }
-        }
+            AuxiliaryArtifactState::OptionalAbsent => ("optional_absent", None, None),
+            AuxiliaryArtifactState::MissingRequired => ("missing_required", None, None),
+            AuxiliaryArtifactState::Failed => ("failed", entry.sha256.clone(), entry.size_bytes),
+        };
+        entries.push(AuxiliaryArtifactCacheEntry {
+            name: entry.name.clone(),
+            path: entry.manifest_path.clone(),
+            required: entry.required,
+            state: state.0,
+            reason_code: entry.reason_code.clone(),
+            sha256: state.1,
+            size_bytes: state.2,
+        });
     }
 
     let json = serde_json::to_vec(&entries)?;
@@ -525,6 +514,7 @@ struct AuxiliaryArtifactCacheEntry {
     path: String,
     required: bool,
     state: &'static str,
+    reason_code: Option<String>,
     sha256: Option<String>,
     size_bytes: Option<u64>,
 }

ordvec-manifest/tests/manifest.rs

@@ -1413,6 +1413,46 @@ fn auxiliary_artifact_schema_rejects_unknown_fields_and_duplicate_names() {
     assert!(parsed.is_err());
 }
 
+#[test]
+fn auxiliary_artifact_count_limit_is_enforced_before_verification() {
+    let root = tempfile::tempdir().unwrap();
+    let (temp, mut manifest, _manifest_path) = identity_manifest(root.path());
+    fs::write(temp.path().join("a.bin"), b"a").unwrap();
+    fs::write(temp.path().join("b.bin"), b"b").unwrap();
+    let a_hash = sha256_file(temp.path().join("a.bin")).unwrap();
+    let b_hash = sha256_file(temp.path().join("b.bin")).unwrap();
+    manifest.auxiliary_artifacts = vec![
+        auxiliary_artifact("a", "a.bin", a_hash, true),
+        auxiliary_artifact("b", "b.bin", b_hash, true),
+    ];
+
+    let report = verify_manifest_with_base(
+        manifest,
+        temp.path(),
+        VerifyOptions {
+            limits: ResourceLimits {
+                max_auxiliary_artifacts: 1,
+                ..ResourceLimits::default()
+            },
+            ..VerifyOptions::default()
+        },
+    );
+    assert!(error_codes(&report).contains(&"auxiliary_artifact_count_limit_exceeded"));
+    assert!(report.auxiliary_artifacts.is_empty());
+}
+
+#[test]
+fn verification_report_deserializes_missing_auxiliary_artifacts_field() {
+    let root = tempfile::tempdir().unwrap();
+    let (temp, manifest, _manifest_path) = identity_manifest(root.path());
+    let report = verify_manifest_with_base(manifest, temp.path(), VerifyOptions::default());
+    let mut value = serde_json::to_value(&report).unwrap();
+    value.as_object_mut().unwrap().remove("auxiliary_artifacts");
+
+    let parsed: ordvec_manifest::VerificationReport = serde_json::from_value(value).unwrap();
+    assert!(parsed.auxiliary_artifacts.is_empty());
+}
+
 #[test]
 fn attestation_shape_requires_matching_subject_sha256() {
     let root = tempfile::tempdir().unwrap();
@@ -1929,6 +1969,70 @@ fn sqlite_cache_key_includes_auxiliary_artifact_bytes() {
     assert!(error_codes(&cached).contains(&"auxiliary_artifact_sha256_mismatch"));
 }
 
+#[cfg(feature = "sqlite")]
+#[test]
+fn sqlite_cache_key_includes_failed_auxiliary_artifact_observed_bytes() {
+    let temp = tempfile::tempdir().unwrap();
+    let index = write_index(temp.path());
+    let manifest_path = temp.path().join("manifest.json");
+    let mut manifest = create_manifest_for_index(
+        &index,
+        CreateRowIdentity::RowIdIdentity,
+        "test-embedding",
+        &manifest_path,
+    )
+    .unwrap();
+    let sidecar_path = temp.path().join("sidecar.json");
+    fs::write(&sidecar_path, b"{\"version\":1}\n").unwrap();
+    let expected_hash = sha256_file(&sidecar_path).unwrap();
+    manifest.auxiliary_artifacts = vec![auxiliary_artifact(
+        "sidecar",
+        "sidecar.json",
+        expected_hash,
+        true,
+    )];
+    fs::write(
+        &manifest_path,
+        serde_json::to_string_pretty(&manifest).unwrap(),
+    )
+    .unwrap();
+    let document = load_manifest_file(&manifest_path).unwrap();
+    let db = temp.path().join("registry.sqlite");
+
+    fs::write(&sidecar_path, b"{\"version\":2}\n").unwrap();
+    let first_observed = sha256_file(&sidecar_path).unwrap();
+    let report = ordvec_manifest::sqlite::verify_with_registry(
+        &db,
+        &document,
+        &manifest_path,
+        VerifyOptions::default(),
+        true,
+    )
+    .unwrap();
+    assert!(!report.ok);
+    assert_eq!(
+        report.auxiliary_artifacts[0].sha256.as_deref(),
+        Some(first_observed.sha256.as_str())
+    );
+
+    fs::write(&sidecar_path, b"{\"version\":3}\n").unwrap();
+    let second_observed = sha256_file(&sidecar_path).unwrap();
+    let cached = ordvec_manifest::sqlite::verify_with_registry(
+        &db,
+        &document,
+        &manifest_path,
+        VerifyOptions::default(),
+        true,
+    )
+    .unwrap();
+    assert!(!cached.ok);
+    assert_eq!(
+        cached.auxiliary_artifacts[0].sha256.as_deref(),
+        Some(second_observed.sha256.as_str())
+    );
+    assert_ne!(first_observed.sha256, second_observed.sha256);
+}
+
 #[cfg(feature = "sqlite")]
 #[test]
 fn sqlite_cache_key_distinguishes_optional_auxiliary_absent_and_present() {
@@ -2041,6 +2145,29 @@ fn sqlite_cache_key_includes_limits_and_bounds_cached_report_size() {
     assert!(cached.ok, "{:?}", cached.errors);
 
     let conn = Connection::open(&db).unwrap();
+    let count: i64 = conn
+        .query_row("SELECT COUNT(*) FROM verification_reports", [], |row| {
+            row.get(0)
+        })
+        .unwrap();
+    assert_eq!(count, 1, "same limits should reuse the cached report");
+
+    let options_b = VerifyOptions {
+        limits: ResourceLimits {
+            max_report_issues: 18,
+            ..ResourceLimits::default()
+        },
+        ..VerifyOptions::default()
+    };
+    let report = ordvec_manifest::sqlite::verify_with_registry(
+        &db,
+        &document,
+        &manifest_path,
+        options_b,
+        true,
+    )
+    .unwrap();
+    assert!(report.ok, "{:?}", report.errors);
     let count: i64 = conn
         .query_row("SELECT COUNT(*) FROM verification_reports", [], |row| {
             row.get(0)