1use camino::Utf8Path;
11
12use crate::adapters::fs::{DestinationRefusal, check_destination, sha256_file};
13use crate::domain::gate_id::GateId;
14use crate::domain::manifest::{MANIFEST_PATH, Manifest, ManifestParseError};
15use crate::domain::marker;
16use crate::domain::paths::{AGENTS_DIGEST_PATH, HOOKS_CONFIG_PATH};
17use crate::domain::version::CanonVersion;
18use crate::error::AppError;
19
20#[derive(Debug, Default)]
22pub struct VerifyReport {
23 pub lines: Vec<String>,
25 pub failures: usize,
27 pub managed_drift: usize,
29 pub adopted_drift: usize,
31}
32
33impl VerifyReport {
34 fn fail(&mut self, line: impl Into<String>) {
35 self.lines.push(line.into());
36 self.failures += 1;
37 }
38
39 fn note(&mut self, line: impl Into<String>) {
40 self.lines.push(line.into());
41 }
42}
43
44pub(crate) fn read_manifest(target: &Utf8Path) -> Result<Manifest, AppError> {
45 let path = target.join(MANIFEST_PATH);
46 if reached_through_symlink(target, Utf8Path::new(MANIFEST_PATH)) {
47 return Err(AppError::ManifestInvalid(
48 "manifest reached through a symlink".to_string(),
49 ));
50 }
51 if !path.is_file() {
52 return Err(AppError::ManifestMissing(path));
53 }
54 let text = std::fs::read_to_string(&path)?;
55 Manifest::parse(&text).map_err(|error| match error {
56 ManifestParseError::Invalid(detail) => AppError::ManifestInvalid(detail),
57 other => AppError::ManifestInvalid(other.to_string()),
58 })
59}
60
61fn check_block_entries(block: &str, report: &mut VerifyReport) {
62 let mut sdd_entries = 0usize;
63 for line in block.lines() {
64 let Some(entry) = line.trim_start().strip_prefix("entry: ") else {
65 continue;
66 };
67 let words: Vec<&str> = entry.split_whitespace().collect();
68 let Some(gate_position) = words.iter().position(|word| *word == "gate") else {
69 if words.last() == Some(&"verify") {
70 sdd_entries += 1;
71 }
72 continue;
73 };
74 sdd_entries += 1;
75 match words.get(gate_position + 1) {
76 Some(id) if id.parse::<GateId>().is_ok() => {}
77 Some(id) => report.fail(format!(
78 "FAIL managed block entry names an unknown gate: {id}"
79 )),
80 None => report.fail(format!("FAIL managed block entry names no gate: {entry}")),
81 }
82 }
83 if sdd_entries == 0 {
84 report.fail("FAIL managed block wires no sdd entry");
85 }
86}
87
88fn reached_through_symlink(target: &Utf8Path, destination: &Utf8Path) -> bool {
89 matches!(
90 check_destination(target, destination),
91 Err(DestinationRefusal::SymlinkEscape)
92 )
93}
94
95fn check_declaration(target: &Utf8Path, manifest: &Manifest, report: &mut VerifyReport) {
105 let declaration = match crate::domain::instance_config::InstanceConfig::read(target) {
106 Ok(declaration) => declaration,
107 Err(error) => {
108 report.fail(format!("FAIL {error}"));
109 return;
110 }
111 };
112
113 let agents = target.join(crate::commands::hooks::AGENTS);
117 let agents_recorded = manifest
118 .integration_blocks
119 .iter()
120 .any(|block| block.path.as_str() == crate::commands::hooks::AGENTS);
121 if agents_recorded
122 && let Ok(host) = std::fs::read_to_string(&agents)
123 && let Some(region) = crate::domain::marker::block_region_with(
124 &host,
125 crate::domain::marker::AGENTS_BEGIN,
126 crate::domain::marker::AGENTS_END,
127 )
128 {
129 let expected = crate::services::agents_render::render_block(
130 manifest.docs_root.as_str(),
131 &declaration.writing_style,
132 );
133 if region != expected {
134 report.fail(format!(
135 "FAIL the documentation block in {} does not match the declaration; run 'sdd hooks --apply'",
136 crate::commands::hooks::AGENTS
137 ));
138 }
139 }
140
141 let config = target.join(crate::commands::hooks::CONFIG);
142 let Ok(host) = std::fs::read_to_string(&config) else {
143 return;
144 };
145 let Ok((base, _)) = crate::domain::marker::split_block(&host) else {
149 return;
150 };
151 let Ok(indent) = crate::domain::marker::splice_indent(&base) else {
155 return;
156 };
157 let rendered = crate::services::hooks_render::render_block(
158 &crate::services::hooks_render::RenderOptions {
159 docs_root: manifest.docs_root.to_string(),
160 indent,
161 declaration,
162 ..crate::services::hooks_render::RenderOptions::default()
163 },
164 );
165 let expected = crate::services::hooks_render::selectors(&rendered);
170 let Some(region) = crate::domain::marker::block_region(&host) else {
171 return;
172 };
173 let found = crate::services::hooks_render::selectors(®ion);
174 for (id, wanted) in &expected {
175 let Some(actual) = found.get(id) else {
176 continue;
177 };
178 if actual != wanted {
179 report.fail(format!(
180 "FAIL the wiring for {id} in {} does not match the declaration; run 'sdd hooks --apply'",
181 crate::commands::hooks::CONFIG
182 ));
183 }
184 }
185}
186
187const CANON_ONLY_ROOT: &str = "skill-shared/";
193
194fn check_projection_against(
212 released: &crate::domain::projection::Declaration,
213 manifest: &Manifest,
214 present_at_root: &[String],
215 report: &mut VerifyReport,
216) {
217 if manifest.canon_version != CanonVersion::current() {
218 return;
219 }
220 let Some(declaration) = released.profile(manifest.profile) else {
221 return;
222 };
223 let managed: std::collections::BTreeSet<&str> = manifest
224 .managed_files
225 .iter()
226 .map(|entry| entry.destination.as_str())
227 .collect();
228 let adopted: std::collections::BTreeSet<&str> = manifest
229 .adopted_files
230 .iter()
231 .map(|entry| entry.destination.as_str())
232 .collect();
233
234 let self_layout = managed
235 .iter()
236 .any(|destination| destination.starts_with(CANON_ONLY_ROOT));
237
238 let mut expected: std::collections::BTreeSet<String> = std::collections::BTreeSet::new();
239 let mut missing: Vec<String> = Vec::new();
240 if self_layout {
241 for projection in declaration.managed {
242 expected.insert(projection.source.clone());
243 }
244 for file in crate::embedded::SPECS.files() {
245 if let Some(name) = file.path().as_os_str().to_str() {
246 expected.insert(format!("_docs/specs/{name}"));
247 }
248 }
249 for template in crate::domain::profile::CANON_TEMPLATES.iter() {
250 expected.insert((*template).to_string());
251 }
252 for destination in &expected {
253 if !managed.contains(destination.as_str()) && !adopted.contains(destination.as_str()) {
254 missing.push(destination.clone());
255 }
256 }
257 } else {
258 for projection in declaration.managed {
259 let destination = crate::domain::profile::resolve_destination(
260 &projection.destination,
261 manifest.docs_root,
262 );
263 if !managed.contains(destination.as_str()) {
264 missing.push(destination.to_string());
265 }
266 }
267 for projection in declaration.adopted {
268 let destination = crate::domain::profile::resolve_destination(
269 &projection.destination,
270 manifest.docs_root,
271 );
272 if adopted.contains(destination.as_str()) {
273 continue;
274 }
275 let yielded = projection.yield_set().is_some_and(|set| {
276 set.names()
277 .any(|name| present_at_root.iter().any(|held| held == name))
278 });
279 if !yielded {
280 missing.push(destination.to_string());
281 }
282 }
283 }
284 for destination in missing {
285 report.fail(format!(
286 "FAIL manifest omits a declared projection: {destination}"
287 ));
288 }
289 let required: &[&str] = if self_layout {
293 &[HOOKS_CONFIG_PATH]
294 } else {
295 &[HOOKS_CONFIG_PATH, AGENTS_DIGEST_PATH]
296 };
297 for path in required {
298 if !manifest
299 .integration_blocks
300 .iter()
301 .any(|block| block.path.as_str() == *path)
302 {
303 report.fail(format!(
304 "FAIL manifest records no integration block for {path}"
305 ));
306 }
307 }
308}
309
310pub fn verify(target: &Utf8Path) -> Result<VerifyReport, AppError> {
318 let manifest = read_manifest(target)?;
319 let released = &*crate::domain::profile::DECLARATION;
320 let mut report = VerifyReport::default();
321
322 check_declaration(target, &manifest, &mut report);
323
324 for entry in &manifest.managed_files {
325 let file = target.join(&entry.destination);
326 if reached_through_symlink(target, &entry.destination) {
327 report.managed_drift += 1;
328 report.fail(format!(
329 "FAIL managed file reached through a symlink: {}",
330 entry.destination
331 ));
332 continue;
333 }
334 if !file.is_file() {
335 report.managed_drift += 1;
336 report.fail(format!("FAIL missing managed file: {}", entry.destination));
337 continue;
338 }
339 if sha256_file(&file)? != entry.sha256 {
340 report.managed_drift += 1;
341 report.fail(format!("FAIL managed drift: {}", entry.destination));
342 }
343 }
344
345 for entry in &manifest.adopted_files {
346 let file = target.join(&entry.destination);
347 if reached_through_symlink(target, &entry.destination) {
348 report.fail(format!(
349 "FAIL adopted file reached through a symlink: {}",
350 entry.destination
351 ));
352 continue;
353 }
354 if !file.is_file() {
355 report.fail(format!("FAIL missing adopted file: {}", entry.destination));
356 continue;
357 }
358 if sha256_file(&file)? != entry.sha256 {
359 report.adopted_drift += 1;
360 report.note(format!(
361 "DRIFT adopted file requires reconciliation: {}",
362 entry.destination
363 ));
364 }
365 }
366
367 check_projection_against(
368 released,
369 &manifest,
370 &crate::services::installer::present_at_root(target),
371 &mut report,
372 );
373 check_integration(target, &manifest, &mut report)?;
374 check_specs(target, &manifest, &mut report)?;
375 check_lint_composition(target, &manifest, &mut report);
376 check_debt(target, &mut report);
377 for reconciliation in crate::services::policy::needed(target, manifest.docs_root)? {
378 report.note(reconciliation.note(manifest.docs_root));
379 }
380
381 let current = CanonVersion::current();
382 if manifest.canon_version > current {
383 report.fail(format!(
384 "FAIL sdd {current} is older than the installed canon {}; upgrade sdd",
385 manifest.canon_version
386 ));
387 } else if manifest.canon_version < current {
388 report.note(format!(
389 "note: sdd {current} is newer than the installed canon {}; run 'sdd upgrade'",
390 manifest.canon_version
391 ));
392 }
393
394 if report.failures == 0 {
395 report.note(format!(
396 "OK spec-driven-docs {} at {target}",
397 manifest.canon_version
398 ));
399 }
400 Ok(report)
401}
402
403#[must_use]
421pub fn lint_configurations_that_break_composition(
422 target: &Utf8Path,
423 docs_root: crate::domain::profile::DocsRoot,
424) -> Vec<camino::Utf8PathBuf> {
425 use crate::domain::markdownlint::{LIBRARY_NAMES, discovery_names};
426
427 let root = Utf8Path::new(docs_root.as_str());
428 if reached_through_symlink(target, root) {
429 return Vec::new();
430 }
431 let mut found: Vec<camino::Utf8PathBuf> = LIBRARY_NAMES
432 .iter()
433 .map(|name| root.join(name))
434 .filter(|path| {
435 std::fs::symlink_metadata(target.join(path)).is_ok_and(|held| !held.is_dir())
436 })
437 .collect();
438 for subtree in ["specs", "decisions"] {
439 let subtree = root.join(subtree);
440 if reached_through_symlink(target, &subtree) {
441 continue;
442 }
443 for entry in walkdir::WalkDir::new(target.join(subtree))
444 .follow_links(false)
445 .follow_root_links(false)
446 .into_iter()
447 .filter_map(Result::ok)
448 .filter(|entry| !entry.file_type().is_dir())
449 {
450 let Some(name) = entry.file_name().to_str() else {
451 continue;
452 };
453 if !discovery_names().any(|known| known == name) {
454 continue;
455 }
456 if let Ok(relative) = entry.path().strip_prefix(target.as_std_path())
457 && let Some(relative) = camino::Utf8Path::from_path(relative)
458 {
459 found.push(relative.to_path_buf());
460 }
461 }
462 }
463 found.sort();
464 found
465}
466
467#[must_use]
478pub fn linked_lint_scan_roots(
479 target: &Utf8Path,
480 docs_root: crate::domain::profile::DocsRoot,
481) -> Vec<camino::Utf8PathBuf> {
482 let root = Utf8Path::new(docs_root.as_str());
483 if reached_through_symlink(target, root) {
484 return vec![root.to_path_buf()];
485 }
486 ["specs", "decisions"]
487 .into_iter()
488 .map(|subtree| root.join(subtree))
489 .filter(|subtree| reached_through_symlink(target, subtree))
490 .collect()
491}
492
493fn check_lint_composition(target: &Utf8Path, manifest: &Manifest, report: &mut VerifyReport) {
494 for path in linked_lint_scan_roots(target, manifest.docs_root) {
495 report.fail(format!(
496 "FAIL {path} is reached through a symlink, so no check sees the lint configuration beneath it; replace the link with the directory (instance:the-lint-configuration-composes)"
497 ));
498 }
499 for path in lint_configurations_that_break_composition(target, manifest.docs_root) {
500 report.fail(format!(
501 "FAIL {path} replaces the delivered lint configuration and turns the heading shapes off; fold it into the root .markdownlint-cli2.jsonc (instance:the-lint-configuration-composes)"
502 ));
503 }
504}
505
506fn check_debt(target: &Utf8Path, report: &mut VerifyReport) {
513 use crate::domain::debt::{Debt, LEGACY_DEBT_PATH, Presence};
514 let presence = Presence::at(target);
515 if let Err(error) = Debt::read(target) {
516 report.fail(format!("FAIL {error}"));
517 return;
518 }
519 if presence.legacy {
520 report.note(format!(
521 "note: {LEGACY_DEBT_PATH} is the legacy debt list, which skips a listed chapter instead of holding it to a ceiling; run 'sdd debt migrate --apply'"
522 ));
523 }
524}
525
526fn markers_for(path: &str) -> (&'static str, &'static str) {
528 if path == HOOKS_CONFIG_PATH {
529 (marker::BEGIN, marker::END)
530 } else {
531 (marker::AGENTS_BEGIN, marker::AGENTS_END)
532 }
533}
534
535fn check_integration(
536 target: &Utf8Path,
537 manifest: &Manifest,
538 report: &mut VerifyReport,
539) -> Result<(), AppError> {
540 for block in &manifest.integration_blocks {
541 let path = block.path.as_str();
542 let (begin, end) = markers_for(path);
543 let full = target.join(&block.path);
544 if reached_through_symlink(target, &block.path) {
545 report.fail(format!("FAIL {path} reached through a symlink"));
546 continue;
547 }
548 if !full.is_file() {
549 report.fail(format!("FAIL missing integration host: {path}"));
550 continue;
551 }
552 let host = std::fs::read_to_string(&full)?;
553 let begins = host.lines().filter(|line| *line == begin).count();
554 let ends = host.lines().filter(|line| *line == end).count();
555 if begins != 1 {
556 report.fail(format!("FAIL missing managed block: {path}"));
557 continue;
558 }
559 if ends != 1 {
560 report.fail(format!("FAIL malformed managed block: {path}"));
561 continue;
562 }
563 match marker::block_hash_with(&host, begin, end) {
564 Some(present) if present == block.marker_hash => {
565 if path == HOOKS_CONFIG_PATH
566 && let Some(region) = marker::block_region_with(&host, begin, end)
567 {
568 check_block_entries(®ion, report);
569 }
570 }
571 _ => report.fail(format!("FAIL managed block tampered: {path}")),
572 }
573 }
574 Ok(())
575}
576
577fn check_specs(
578 target: &Utf8Path,
579 manifest: &Manifest,
580 report: &mut VerifyReport,
581) -> Result<(), AppError> {
582 let specs = target.join(manifest.docs_root.as_str()).join("specs");
583 if specs.is_dir() {
584 let mut counts = std::collections::BTreeMap::new();
585 let mut names: Vec<_> = specs
586 .read_dir_utf8()?
587 .filter_map(Result::ok)
588 .map(|entry| entry.file_name().to_string())
589 .filter(|name| {
590 #[allow(
591 clippy::case_sensitive_file_extension_comparisons,
592 reason = "the corpus convention is lowercase"
593 )]
594 name.ends_with(".md")
595 })
596 .collect();
597 names.sort();
598 for name in names {
599 let text = std::fs::read_to_string(specs.join(name))?;
600 for id in crate::embedded::rule_ids_in(&text) {
601 *counts.entry(id).or_insert(0usize) += 1;
602 }
603 }
604 let duplicated: Vec<String> = counts
605 .into_iter()
606 .filter(|(_, n)| *n > 1)
607 .map(|(id, _)| id)
608 .collect();
609 if !duplicated.is_empty() {
610 report.fail("FAIL duplicate rule ID in local specs");
611 for id in duplicated {
612 report.note(format!("### `{id}`"));
613 }
614 }
615 } else {
616 report.fail(format!(
617 "FAIL missing local specs: {}/specs",
618 manifest.docs_root
619 ));
620 }
621 Ok(())
622}
623
624#[cfg(test)]
625mod tests {
626 #![allow(
627 clippy::unwrap_used,
628 reason = "a test panics as its failure signal, not as control flow"
629 )]
630
631 use super::*;
632 use crate::candidate::{Evidence, Input, project};
633 use crate::domain::ownership::{ManagedEntry, Sha256};
634 use crate::domain::profile::{DECLARATION, ProfileId};
635
636 fn consumer(profile: ProfileId) -> Manifest {
637 project(&Input {
638 profile,
639 version: CanonVersion::current(),
640 installed_at: "2026-01-01T00:00:00Z".to_string(),
641 docs_scratch: None,
642 reserve: Vec::new(),
643 writing_style: None,
644 acquisition: None,
645 evidence: Evidence::default(),
646 })
647 .unwrap()
648 .manifest
649 }
650
651 fn failures(manifest: &Manifest) -> Vec<String> {
652 let mut report = VerifyReport::default();
653 check_projection_against(&DECLARATION, manifest, &[], &mut report);
654 report.lines
655 }
656
657 fn managed(path: &str) -> ManagedEntry {
658 ManagedEntry {
659 source: path.into(),
660 destination: path.into(),
661 sha256: Sha256::of(path.as_bytes()),
662 }
663 }
664
665 #[test]
670 fn the_lint_scan_does_not_follow_its_roots_or_their_ancestors() {
671 use crate::domain::profile::DocsRoot;
672
673 for docs_root in [DocsRoot::Docs, DocsRoot::UnderscoreDocs] {
674 for boundary in ["", "specs", "decisions"] {
675 let target = tempfile::tempdir().unwrap();
676 let target = Utf8Path::from_path(target.path()).unwrap();
677 let outside = tempfile::tempdir().unwrap();
678 for relative in [
681 ".markdownlint.json",
682 "specs/.markdownlint-cli2.jsonc",
683 "decisions/.markdownlint.yaml",
684 ] {
685 let path = outside.path().join(relative);
686 std::fs::create_dir_all(path.parent().unwrap()).unwrap();
687 std::fs::write(path, "{}\n").unwrap();
688 }
689 let link = if boundary.is_empty() {
690 target.join(docs_root.as_str())
691 } else {
692 target.join(docs_root.as_str()).join(boundary)
693 };
694 std::fs::create_dir_all(link.parent().unwrap()).unwrap();
695 std::os::unix::fs::symlink(outside.path(), &link).unwrap();
696
697 assert!(
698 lint_configurations_that_break_composition(target, docs_root).is_empty(),
699 "{docs_root}/{boundary}: the scan followed a directory link"
700 );
701 let linked = if boundary.is_empty() {
702 camino::Utf8PathBuf::from(docs_root.as_str())
703 } else {
704 Utf8Path::new(docs_root.as_str()).join(boundary)
705 };
706 assert_eq!(linked_lint_scan_roots(target, docs_root), [linked]);
707 }
708 }
709 }
710
711 #[test]
713 fn the_lint_scan_skips_nested_directory_links_and_cycles() {
714 use crate::domain::profile::DocsRoot;
715
716 for docs_root in [DocsRoot::Docs, DocsRoot::UnderscoreDocs] {
717 let target = tempfile::tempdir().unwrap();
718 let target = Utf8Path::from_path(target.path()).unwrap();
719 let specs = target.join(docs_root.as_str()).join("specs");
720 std::fs::create_dir_all(&specs).unwrap();
721 let outside = tempfile::tempdir().unwrap();
722 std::fs::write(outside.path().join(".markdownlint-cli2.jsonc"), "{}\n").unwrap();
723 std::os::unix::fs::symlink(outside.path(), specs.join("linked")).unwrap();
724 std::os::unix::fs::symlink(&specs, specs.join("cycle")).unwrap();
725 let config = specs.join(".markdownlint.yaml");
728 std::os::unix::fs::symlink(outside.path().join("absent.yaml"), &config).unwrap();
729
730 assert_eq!(
731 lint_configurations_that_break_composition(target, docs_root),
732 [config.strip_prefix(target).unwrap()]
733 );
734 assert!(linked_lint_scan_roots(target, docs_root).is_empty());
736 }
737 }
738
739 #[test]
743 fn a_consumer_whose_managed_destination_equals_its_source_is_still_a_consumer() {
744 let mut manifest = consumer(ProfileId::KnowledgeBase);
745 for projection in &DECLARATION.managed {
746 if !manifest
747 .managed_files
748 .iter()
749 .any(|entry| entry.destination == projection.source.as_str())
750 {
751 manifest.managed_files.push(managed(&projection.source));
752 }
753 }
754 assert!(failures(&manifest).is_empty(), "{:?}", failures(&manifest));
755
756 let mut without_block = manifest.clone();
757 without_block
758 .integration_blocks
759 .retain(|block| block.path != AGENTS_DIGEST_PATH);
760 assert!(
761 failures(&without_block)
762 .iter()
763 .any(|line| line.contains("no integration block for AGENTS.md")),
764 "{:?}",
765 failures(&without_block)
766 );
767
768 let mut without_seed = manifest;
769 let dropped = without_seed.adopted_files.remove(1).destination;
770 assert!(
771 failures(&without_seed)
772 .iter()
773 .any(|line| line.ends_with(dropped.as_str())),
774 "{:?}",
775 failures(&without_seed)
776 );
777 }
778
779 #[test]
780 fn the_canon_record_is_read_as_the_canon() {
781 let text =
782 std::fs::read_to_string(Utf8Path::new(env!("CARGO_MANIFEST_DIR")).join(MANIFEST_PATH))
783 .unwrap();
784 let mut manifest = Manifest::parse(&text).unwrap();
785 manifest.canon_version = CanonVersion::current();
786 assert!(failures(&manifest).is_empty(), "{:?}", failures(&manifest));
787 }
788
789 #[test]
790 fn a_consumer_omitting_a_declared_seed_fails() {
791 let mut manifest = consumer(ProfileId::Codebase);
792 let dropped = manifest.adopted_files.pop().unwrap().destination;
793 let lines = failures(&manifest);
794 assert!(
795 lines.contains(&format!(
796 "FAIL manifest omits a declared projection: {dropped}"
797 )),
798 "{lines:?}"
799 );
800 }
801
802 #[test]
806 fn a_claimed_canon_layout_changes_which_obligations_are_held() {
807 let mut manifest = consumer(ProfileId::KnowledgeBase);
808 manifest
809 .integration_blocks
810 .retain(|block| block.path != AGENTS_DIGEST_PATH);
811 manifest
812 .managed_files
813 .push(managed("skill-shared/plan-gate.md"));
814 let lines = failures(&manifest);
815 assert!(
816 lines
817 .iter()
818 .any(|line| line
819 .contains("omits a declared projection: _docs/specs/SPEC-release.md")),
820 "the canon branch owes the canon-only specs: {lines:?}"
821 );
822
823 for projection in &DECLARATION.managed {
824 manifest.managed_files.push(managed(&projection.source));
825 }
826 for file in crate::embedded::SPECS.files() {
827 let name = file.path().to_str().unwrap();
828 manifest
829 .managed_files
830 .push(managed(&format!("_docs/specs/{name}")));
831 }
832 for template in crate::domain::profile::CANON_TEMPLATES.iter() {
833 manifest.managed_files.push(managed(template));
834 }
835 let lines = failures(&manifest);
836 assert!(lines.is_empty(), "{lines:?}");
837 }
838
839 #[test]
840 fn a_yielded_seed_the_record_does_not_name_is_not_owed() {
841 let Some(yielding) = DECLARATION
842 .adopted
843 .iter()
844 .find(|projection| projection.yield_set().is_some())
845 else {
846 return;
847 };
848 let mut manifest = consumer(ProfileId::Codebase);
849 let destination =
850 crate::domain::profile::resolve_destination(&yielding.destination, manifest.docs_root);
851 manifest
852 .adopted_files
853 .retain(|entry| entry.destination != destination);
854 assert!(!failures(&manifest).is_empty());
855
856 let mut report = VerifyReport::default();
857 let cause = yielding
858 .yield_set()
859 .unwrap()
860 .names()
861 .last()
862 .unwrap()
863 .to_string();
864 check_projection_against(&DECLARATION, &manifest, &[cause], &mut report);
865 assert!(report.lines.is_empty(), "{:?}", report.lines);
866 }
867}