@alphazede/bearing-lite 0.2.2 → 1.0.0

package/hooks/verification.cjs

@@ -0,0 +1,358 @@
+"use strict";
+
+/**
+ * Deterministic verification adapter (DES-BDL-008 / AC-BDL-009 / SEIT-BDL-004).
+ * Pure evaluator: no HOOK_CLASS, no host event, no download, no role dispatch.
+ * Reverify is one optional backend; availability never selects it for a task.
+ */
+
+const STATUSES = Object.freeze(["VERIFIED", "REFUTED", "INCONCLUSIVE", "ERROR"]);
+const AUTHORITIES = Object.freeze(["diagnostic", "assurance"]);
+const STAGES = Object.freeze([
+  "implementation",
+  "integration",
+  "assurance",
+  "review",
+  "post_repair_closure",
+]);
+const EXPECTED = Object.freeze(["VERIFIED", "REFUTED"]);
+const SHA256 = /^[0-9a-f]{64}$/;
+const CANDIDATE_FIELDS = Object.freeze([
+  "candidate_ref",
+  "candidate_revision",
+  "candidate_digest",
+]);
+
+const isPlainObject = (value) =>
+  value !== null && typeof value === "object" && !Array.isArray(value);
+
+const nonempty = (value) => typeof value === "string" && value.length > 0;
+
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((item, i) => deepEqual(item, b[i]));
+  }
+  if (isPlainObject(a) && isPlainObject(b)) {
+    const keys = Object.keys(a);
+    return keys.length === Object.keys(b).length && keys.every((key) => deepEqual(a[key], b[key]));
+  }
+  return false;
+}
+
+function result(outcome, reason, extra = {}) {
+  return {
+    outcome,
+    reason,
+    status: extra.status ?? null,
+    authority: extra.authority ?? null,
+    gate_eligible: extra.gate_eligible === true,
+    closure_eligible: extra.closure_eligible === true,
+    rereview: false,
+    download_attempted: false,
+    backend_is_role: false,
+  };
+}
+
+function present(value) {
+  return !(value === undefined || value === null || value === "");
+}
+
+function sameCandidate(left, right) {
+  if (!isPlainObject(left) || !isPlainObject(right)) return false;
+  for (const field of CANDIDATE_FIELDS) {
+    const a = left[field];
+    const b = right[field];
+    if (field === "candidate_digest" && !present(a) && !present(b)) continue;
+    if (!present(a) || !present(b) || a !== b) return false;
+  }
+  return true;
+}
+
+function requestErrors(request) {
+  if (!isPlainObject(request)) return "verification_request_missing";
+  if (request.schema_version !== "1" || request.kind !== "request") return "verification_request_invalid";
+  for (const field of [
+    "candidate_ref",
+    "candidate_revision",
+    "claim_id",
+    "claim_type",
+    "backend",
+    "stage",
+    "authority",
+    "expected_result",
+  ]) {
+    if (!nonempty(request[field])) return "verification_request_unbound";
+  }
+  if (!STAGES.includes(request.stage)) return "verification_request_invalid";
+  if (!AUTHORITIES.includes(request.authority)) return "verification_request_invalid";
+  if (!EXPECTED.includes(request.expected_result)) return "verification_request_invalid";
+  if (!isPlainObject(request.command_configuration) || Object.keys(request.command_configuration).length === 0) {
+    return "verification_request_unbound";
+  }
+  if (typeof request.selected !== "boolean" || typeof request.required !== "boolean") {
+    return "verification_request_unbound";
+  }
+  if (request.candidate_digest !== undefined && !SHA256.test(request.candidate_digest)) {
+    return "verification_request_invalid";
+  }
+  return null;
+}
+
+function receiptErrors(receipt) {
+  if (!isPlainObject(receipt)) return "verification_receipt_missing";
+  if (receipt.schema_version !== "1" || receipt.kind !== "receipt") return "verification_receipt_invalid";
+  for (const field of [
+    "status",
+    "candidate_ref",
+    "candidate_revision",
+    "claim_id",
+    "backend",
+    "backend_version",
+    "evidence_digest",
+    "authority",
+  ]) {
+    if (!nonempty(receipt[field])) return "verification_receipt_unbound";
+  }
+  if (!STATUSES.includes(receipt.status)) return "verification_receipt_invalid";
+  if (!AUTHORITIES.includes(receipt.authority)) return "verification_receipt_invalid";
+  if (!SHA256.test(receipt.evidence_digest)) return "verification_receipt_unbound";
+  if (!isPlainObject(receipt.command_configuration) || Object.keys(receipt.command_configuration).length === 0) {
+    return "verification_receipt_unbound";
+  }
+  const who = receipt.produced_by;
+  if (!isPlainObject(who) || !nonempty(who.role) || !nonempty(who.identity) || !nonempty(who.session)) {
+    return "verification_receipt_unbound";
+  }
+  if (receipt.candidate_digest !== undefined && !SHA256.test(receipt.candidate_digest)) {
+    return "verification_receipt_invalid";
+  }
+  if (receipt.stage !== undefined && !STAGES.includes(receipt.stage)) return "verification_receipt_invalid";
+  return null;
+}
+
+function backendState(input, request) {
+  const backend = isPlainObject(input.backend) ? input.backend : {};
+  const available = backend.available === true;
+  const enabled = backend.enabled;
+  const name = nonempty(backend.name) ? backend.name : request.backend;
+  return {
+    name,
+    selected: request.selected === true,
+    required: request.required === true,
+    available,
+    enabled: enabled === false ? false : enabled === true ? true : available,
+  };
+}
+
+/**
+ * @param {unknown} input verification evaluation request
+ * @returns {{
+ *   outcome: string,
+ *   reason: string,
+ *   status: string|null,
+ *   authority: string|null,
+ *   gate_eligible: boolean,
+ *   closure_eligible: boolean,
+ *   rereview: false,
+ *   download_attempted: false,
+ *   backend_is_role: false
+ * }}
+ */
+function evaluateVerification(input) {
+  try {
+    if (!isPlainObject(input)) {
+      return result("NEEDS_MORE_EVIDENCE", "verification_request_missing");
+    }
+    // Reverify/download is never performed here. A caller hint is ignored.
+    if (input.download === true || input.install === true || typeof input.download_fn === "function") {
+      // Fall through without invoking anything.
+    }
+
+    const requestErr = requestErrors(input.request);
+    if (requestErr) return result("NEEDS_MORE_EVIDENCE", requestErr);
+
+    const request = input.request;
+    const current = isPlainObject(input.candidate) ? input.candidate : request;
+    if (!sameCandidate(request, current)) {
+      return result("REJECT", "candidate_mismatch");
+    }
+
+    const backend = backendState(input, request);
+    const activated = backend.selected || backend.required;
+    if (!activated) {
+      if (!isPlainObject(input.receipt)) {
+        return result("INACTIVE", "backend_unselected_unrequired");
+      }
+    } else if (backend.enabled === false || backend.available !== true) {
+      return result("ERROR", "backend_unavailable", { status: "ERROR" });
+    }
+
+    if (!Object.hasOwn(input, "receipt") || input.receipt === undefined || input.receipt === null) {
+      return result(activated ? "NEEDS_MORE_EVIDENCE" : "INACTIVE", activated ? "verification_receipt_missing" : "backend_unselected_unrequired");
+    }
+
+    const receiptErr = receiptErrors(input.receipt);
+    if (receiptErr) return result("NEEDS_MORE_EVIDENCE", receiptErr);
+    const receipt = input.receipt;
+
+    if (
+      receipt.claim_id !== request.claim_id ||
+      receipt.backend !== request.backend ||
+      !deepEqual(receipt.command_configuration, request.command_configuration)
+    ) {
+      return result("REJECT", "claim_or_backend_mismatch", {
+        status: receipt.status,
+        authority: receipt.authority,
+      });
+    }
+    if (!sameCandidate(receipt, request) || !sameCandidate(receipt, current)) {
+      return result("REJECT", "candidate_mismatch", {
+        status: receipt.status,
+        authority: receipt.authority,
+      });
+    }
+
+    const repair = isPlainObject(input.repair) ? input.repair : {};
+    if (
+      nonempty(repair.prior_evidence_digest) &&
+      repair.prior_evidence_digest === receipt.evidence_digest &&
+      (repair.post_repair === true || nonempty(repair.prior_candidate_revision))
+    ) {
+      return result("REJECT", "stale_evidence", {
+        status: receipt.status,
+        authority: receipt.authority,
+      });
+    }
+    if (
+      nonempty(repair.prior_candidate_revision) &&
+      receipt.candidate_revision === repair.prior_candidate_revision &&
+      current.candidate_revision !== repair.prior_candidate_revision
+    ) {
+      return result("REJECT", "stale_evidence", {
+        status: receipt.status,
+        authority: receipt.authority,
+      });
+    }
+
+    if (receipt.status === "ERROR") {
+      return result("ERROR", "backend_error", {
+        status: "ERROR",
+        authority: receipt.authority,
+      });
+    }
+    if (receipt.status === "INCONCLUSIVE") {
+      return result("INCONCLUSIVE", "inconclusive_cannot_satisfy_gate", {
+        status: "INCONCLUSIVE",
+        authority: receipt.authority,
+      });
+    }
+
+    const author = isPlainObject(input.author) ? input.author : null;
+    const who = receipt.produced_by;
+    const sameIdentity = author && nonempty(author.identity) && who.identity === author.identity;
+    const sameSession = author && nonempty(author.session) && who.session === author.session;
+    const selfCert = sameIdentity || sameSession;
+    const gate = input.gate === "post_repair_closure" ? "post_repair_closure" : input.gate === "assurance" ? "assurance" : "none";
+
+    if (gate === "assurance") {
+      if (!author || !nonempty(author.identity) || !nonempty(author.session)) {
+        return result("NEEDS_MORE_EVIDENCE", "author_identity_missing", {
+          status: receipt.status,
+          authority: receipt.authority,
+        });
+      }
+      if (receipt.authority === "diagnostic") {
+        return result("REJECT", "diagnostic_cannot_satisfy_assurance_gate", {
+          status: receipt.status,
+          authority: "diagnostic",
+        });
+      }
+      if (selfCert) {
+        return result("REJECT", "self_certification", {
+          status: receipt.status,
+          authority: receipt.authority,
+        });
+      }
+      if (receipt.status !== request.expected_result) {
+        return result("REJECT", "expected_result_mismatch", {
+          status: receipt.status,
+          authority: receipt.authority,
+        });
+      }
+      return result("PASS", "independent_assurance_verified", {
+        status: receipt.status,
+        authority: "assurance",
+        gate_eligible: true,
+      });
+    }
+
+    if (gate === "post_repair_closure") {
+      if (input.review_after_repair === true || input.automatic_rereview_requested === true) {
+        return result("REJECT", "automatic_rereview_prohibited", {
+          status: receipt.status,
+          authority: receipt.authority,
+        });
+      }
+      if (!author || !nonempty(author.identity) || !nonempty(author.session)) {
+        return result("NEEDS_MORE_EVIDENCE", "author_identity_missing", {
+          status: receipt.status,
+          authority: receipt.authority,
+        });
+      }
+      if (selfCert) {
+        return result("REJECT", "self_certification", {
+          status: receipt.status,
+          authority: receipt.authority,
+        });
+      }
+      const closureStage =
+        request.stage === "post_repair_closure" || receipt.stage === "post_repair_closure";
+      if (receipt.authority === "diagnostic" && !closureStage) {
+        return result("REJECT", "diagnostic_cannot_satisfy_closure_gate", {
+          status: receipt.status,
+          authority: "diagnostic",
+        });
+      }
+      if (!closureStage) {
+        return result("REJECT", "closure_stage_required", {
+          status: receipt.status,
+          authority: receipt.authority,
+        });
+      }
+      if (receipt.status !== request.expected_result) {
+        return result("REJECT", "expected_result_mismatch", {
+          status: receipt.status,
+          authority: receipt.authority,
+        });
+      }
+      return result("PASS", "post_repair_deterministic_closure", {
+        status: receipt.status,
+        authority: receipt.authority,
+        closure_eligible: true,
+      });
+    }
+
+    if (receipt.authority === "diagnostic") {
+      return result("PASS", "diagnostic_receipt_recorded", {
+        status: receipt.status,
+        authority: "diagnostic",
+      });
+    }
+    return result("PASS", "receipt_recorded", {
+      status: receipt.status,
+      authority: receipt.authority,
+    });
+  } catch {
+    return result("NEEDS_MORE_EVIDENCE", "verification_adapter_unavailable");
+  }
+}
+
+module.exports = {
+  evaluateVerification,
+  STATUSES,
+  AUTHORITIES,
+  STAGES,
+  CANDIDATE_FIELDS,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alphazede/bearing-lite",
-  "version": "0.2.2",
+  "version": "1.0.0",
   "description": "Skills-first Agent Plugin for planning, routing, bounded execution, and independent review of repository work—without CLI, MCP, server, or hidden runtime state.",
   "keywords": [
     "agent-plugins",
@@ -38,8 +38,11 @@
     "CONTRIBUTING.md",
     "SECURITY.md",
     "LICENSE-APACHE",
-    "lineups.json",
-    "schemas/"
+    "profiles.json",
+    "schemas/",
+    "templates/",
+    "tools/",
+    "com.github.copilot/"
   ],
   "packageManager": "pnpm@10.33.0+sha512.10568bb4a6afb58c9eb3630da90cc9516417abebd3fabbe6739f0ae795728da1491e9db5a544c76ad8eb7570f5c4bb3d6c637b2cb41bfdcdb47fa823c8649319"
 }

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "bearing-lite",
-  "version": "0.2.2",
+  "version": "1.0.0",
   "description": "Skills-first portable plugin that routes repository work through the smallest valid planning stages and agent roles, using project Markdown as the only task record.",
   "author": {
     "name": "William Rumph / AlphaZede",
@@ -18,37 +18,5 @@
     "routing",
     "developer-tools",
     "skills-first"
-  ],
-  "hooks": {
-    "com.anthropic.claude-code.activation": {
-      "path": "./hooks/com.anthropic.claude-code/host.cjs"
-    },
-    "com.anthropic.claude-code.closeout": {
-      "path": "./hooks/com.anthropic.claude-code/host.cjs"
-    },
-    "com.openai.codex.activation": {
-      "path": "./hooks/com.anthropic.claude-code/host.cjs"
-    },
-    "com.openai.codex.closeout": {
-      "path": "./hooks/com.anthropic.claude-code/host.cjs"
-    },
-    "com.xai.grok-build.activation": {
-      "path": "./hooks/com.anthropic.claude-code/host.cjs"
-    },
-    "com.xai.grok-build.closeout": {
-      "path": "./hooks/com.anthropic.claude-code/host.cjs"
-    },
-    "com.cursor.ide.activation": {
-      "path": "./hooks/com.anthropic.claude-code/host.cjs"
-    },
-    "com.cursor.ide.closeout": {
-      "path": "./hooks/com.anthropic.claude-code/host.cjs"
-    },
-    "com.moonshotai.kimi-code.activation": {
-      "path": "./hooks/com.anthropic.claude-code/host.cjs"
-    },
-    "com.moonshotai.kimi-code.closeout": {
-      "path": "./hooks/com.anthropic.claude-code/host.cjs"
-    }
-  }
+  ]
 }

package/profiles.json

@@ -0,0 +1 @@
+{"schema_version":1,"profiles":{}}

package/schemas/implementation.schema.json

@@ -2,7 +2,7 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://github.com/alphazede/bearing-lite/schemas/implementation.schema.json",
   "title": "Bearing Lite implementation.json",
-  "description": "Nested execution authority. XLSX is never authority. Owner-configured n, k, and c have no assistant default integers. Every slice requires CONTRACT-EMV-008 fields including reasoning_level (object), not a sibling reasoning string. human_decision may be a string, object, or null. authority_id is a nonempty string on dispatchable slices and may be null only when dispatchable is false or slice_status is publication-blocked. Extra lifecycle metadata is allowed.",
+  "description": "Nested execution authority. XLSX is never authority. Owner-configured n, k, and c have no assistant default integers. Every slice requires CONTRACT-EMV-008 fields including reasoning_level (object), not a sibling reasoning string. human_decision may be a string, object, or null. authority_id is a nonempty string on dispatchable slices and may be null only when dispatchable is false or slice_status is publication-blocked. Extra lifecycle metadata is allowed. lineup_freeze is not a live field; profile_freeze is required.",
   "type": "object",
   "additionalProperties": true,
   "required": [
@@ -10,7 +10,7 @@
     "artifact",
     "source_baseline",
     "journey_settings",
-    "lineup_freeze",
+    "profile_freeze",
     "waves",
     "dependencies",
     "slices",
@@ -108,6 +108,174 @@
           }
         }
       ]
+    },
+    "dodNa": {
+      "type": "object",
+      "additionalProperties": true,
+      "properties": {
+        "not_applicable": { "type": "boolean" },
+        "na": { "type": "boolean" },
+        "reason": { "type": "string", "minLength": 1 },
+        "status": { "type": "string" }
+      }
+    },
+    "dodView": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "format": { "type": "string", "enum": ["svg", "png"] },
+        "path": { "type": "string", "minLength": 1 },
+        "inline": { "type": "string", "minLength": 1 },
+        "alt": { "type": "string" }
+      }
+    },
+    "dodModel": {
+      "type": "object",
+      "additionalProperties": true,
+      "required": ["id"],
+      "properties": {
+        "id": { "type": "string", "minLength": 1 },
+        "mode": { "type": "string" },
+        "source": { "type": "string" },
+        "revision": { "type": "string" },
+        "digest": { "type": "string" },
+        "viewpoint": { "type": "string" },
+        "trace": { "type": "string" },
+        "limitations": { "type": "string" },
+        "render_status": { "type": "string" },
+        "required": { "type": "boolean" },
+        "selected": { "type": "boolean" },
+        "not_applicable": { "type": "boolean" },
+        "reason": { "type": "string" },
+        "view": { "$ref": "#/$defs/dodView" },
+        "views": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/dodView" }
+        }
+      }
+    },
+    "dodManifest": {
+      "type": "object",
+      "additionalProperties": true,
+      "description": "Structured rendering input for the versioned DoD Manifest template. Planning fields are the immutable projection; closeout is append-only. Activated models (selected OR required, including render_status READY/MISSING/STALE) must bind digest plus view.format svg|png and view.path or svg view.inline, either on the planning row or via closeout.model_views. The renderer never invents views or evidence and never rewrites planning model rows.",
+      "required": ["template_version", "output_name", "title"],
+      "properties": {
+        "template_version": { "type": "string", "const": "1.0.1" },
+        "output_name": { "type": "string", "minLength": 1, "pattern": "^[A-Za-z0-9._-]+-dod-manifest\\.html$" },
+        "state": { "type": "string", "minLength": 1 },
+        "title": { "type": "string", "minLength": 1 },
+        "lede": { "type": "string" },
+        "bluf": { "type": "string" },
+        "identity": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "additionalProperties": true,
+            "properties": {
+              "label": { "type": "string" },
+              "value": { "type": ["string", "number"] }
+            }
+          }
+        },
+        "outcome": { "type": "string" },
+        "scope": { "type": "array", "items": { "type": "string" } },
+        "exclusions": { "type": "array", "items": { "type": "string" } },
+        "definition_of_done": {
+          "oneOf": [
+            { "$ref": "#/$defs/dodNa" },
+            { "type": "array", "items": { "type": "object", "additionalProperties": true } }
+          ]
+        },
+        "requirements": {
+          "oneOf": [
+            { "$ref": "#/$defs/dodNa" },
+            { "type": "array", "items": { "type": "object", "additionalProperties": true } }
+          ]
+        },
+        "architecture": {
+          "oneOf": [
+            { "$ref": "#/$defs/dodNa" },
+            { "type": "array", "items": { "type": "object", "additionalProperties": true } }
+          ]
+        },
+        "models": {
+          "oneOf": [
+            { "$ref": "#/$defs/dodNa" },
+            { "type": "array", "items": { "$ref": "#/$defs/dodModel" } }
+          ]
+        },
+        "lineup": {
+          "oneOf": [
+            { "$ref": "#/$defs/dodNa" },
+            { "type": "array", "items": { "type": "object", "additionalProperties": true } }
+          ]
+        },
+        "tasks": {
+          "oneOf": [
+            { "$ref": "#/$defs/dodNa" },
+            { "type": "array", "items": { "type": "object", "additionalProperties": true } }
+          ]
+        },
+        "vv": {
+          "oneOf": [
+            { "$ref": "#/$defs/dodNa" },
+            { "type": "array", "items": { "type": "object", "additionalProperties": true } }
+          ]
+        },
+        "documentation": {
+          "oneOf": [
+            { "$ref": "#/$defs/dodNa" },
+            { "type": "array", "items": { "type": "object", "additionalProperties": true } }
+          ]
+        },
+        "risks": {
+          "oneOf": [
+            { "$ref": "#/$defs/dodNa" },
+            { "type": "array", "items": { "type": "object", "additionalProperties": true } }
+          ]
+        },
+        "authority": {
+          "oneOf": [
+            { "$ref": "#/$defs/dodNa" },
+            { "type": "array", "items": { "type": "object", "additionalProperties": true } }
+          ]
+        },
+        "closeout": {
+          "type": "object",
+          "additionalProperties": true,
+          "description": "Append-only actuals. Must not rewrite planning projection fields.",
+          "properties": {
+            "candidate": { "type": ["string", "null"] },
+            "changed_paths": { "type": "array" },
+            "evidence": { "type": "array" },
+            "open_gaps": { "type": "array" },
+            "owner_acceptance": { "type": ["string", "null"] },
+            "slice_receipts": { "type": "array" },
+            "amendments": { "type": "array" },
+            "owner_amendments": { "type": "array" },
+            "documentation_completion": true,
+            "anomalies": true,
+            "repairs": true,
+            "recovery_used": true,
+            "residual_gaps": { "type": "array" },
+            "completion_status": { "type": "string" },
+            "model_views": {
+              "type": "array",
+              "description": "Append-only supplemental rendering bindings keyed by planning model_id. Each entry may carry digest and view only. Duplicate, unknown, semantically overriding, or already-planned bindings are rejected.",
+              "items": {
+                "type": "object",
+                "additionalProperties": false,
+                "required": ["model_id", "digest", "view"],
+                "properties": {
+                  "model_id": { "type": "string", "minLength": 1 },
+                  "digest": { "type": "string", "minLength": 1 },
+                  "view": { "$ref": "#/$defs/dodView" }
+                }
+              }
+            }
+          }
+        }
+      }
     }
   },
   "properties": {
@@ -129,10 +297,40 @@
             "k": { "type": "integer", "minimum": 0 },
             "c": { "type": "integer", "minimum": 0 }
           }
-        }
+        },
+        "development_strategy": {
+          "type": "object",
+          "additionalProperties": true,
+          "required": ["mode"],
+          "properties": {
+            "mode": { "type": "string", "enum": ["single_implementer", "tdd"] }
+          }
+        },
+        "assurance_cadence": {
+          "type": "object",
+          "additionalProperties": true,
+          "properties": {
+            "test_engineer": {
+              "type": "object",
+              "additionalProperties": true,
+              "properties": {
+                "assurance": { "type": "string", "enum": ["slice", "phase", "lifecycle"] }
+              }
+            },
+            "reviewer": { "type": "string", "enum": ["slice", "phase", "lifecycle"] },
+            "integration_engineer": {
+              "type": "object",
+              "additionalProperties": true,
+              "properties": {
+                "execution": { "type": "string", "enum": ["slice", "phase", "lifecycle"] }
+              }
+            }
+          }
+        },
+        "planning_to_implementation_clean_session": { "type": "boolean" }
       }
     },
-    "lineup_freeze": { "$ref": "#/$defs/contentfulObject" },
+    "profile_freeze": { "$ref": "#/$defs/contentfulObject" },
     "waves": {
       "type": "array",
       "items": { "type": "object", "additionalProperties": true }
@@ -145,6 +343,7 @@
       "type": "array",
       "items": { "$ref": "#/$defs/slice" }
     },
-    "traceability": { "$ref": "#/$defs/contentfulObject" }
+    "traceability": { "$ref": "#/$defs/contentfulObject" },
+    "dod_manifest": { "$ref": "#/$defs/dodManifest" }
   }
 }