@lamentis/naome 1.3.0 → 1.3.1

package/crates/naome-core/src/workflow/agent.rs

@@ -0,0 +1,34 @@
+mod capability;
+mod context_delta;
+mod decision;
+mod execution;
+mod proof;
+mod support;
+mod watchdog;
+
+use std::path::Path;
+
+use crate::models::NaomeError;
+
+use super::agent_types::AgentRunPlan;
+use super::phases::CommandCheckResult;
+
+pub use capability::repository_capability_graph;
+pub use context_delta::context_delta_report;
+pub use decision::decision_gate;
+pub use execution::execution_plan;
+pub use proof::proof_plan_for_task;
+pub use watchdog::edit_session_watchdog;
+
+pub fn agent_run_plan(root: &Path) -> Result<AgentRunPlan, NaomeError> {
+    let changed_paths = support::changed_paths(root)?;
+    Ok(AgentRunPlan {
+        schema: "naome.agent-run-plan.v1".to_string(),
+        execution_plan: execution_plan(root, &changed_paths)?,
+        context_delta: context_delta_report(root, &[])?,
+        proof_plan: proof_plan_for_task(root, &[] as &[CommandCheckResult])?,
+        capability_graph: repository_capability_graph(root)?,
+        edit_watchdog: edit_session_watchdog(root, &changed_paths)?,
+        decision_gate: decision_gate(root)?,
+    })
+}

package/crates/naome-core/src/workflow/agent_types.rs

@@ -0,0 +1,105 @@
+use serde::{Deserialize, Serialize};
+
+use super::types::WorkflowFinding;
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AgentRunPlan {
+    pub schema: String,
+    pub execution_plan: ExecutionPlanLedger,
+    pub context_delta: ContextDeltaReport,
+    pub proof_plan: ProofPlan,
+    pub capability_graph: CapabilityGraph,
+    pub edit_watchdog: EditSessionWatchdog,
+    pub decision_gate: DecisionGate,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ExecutionPlanLedger {
+    pub task_state: String,
+    pub changed_paths: Vec<String>,
+    pub steps: Vec<ExecutionPlanStep>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ExecutionPlanStep {
+    pub id: String,
+    pub phase: String,
+    pub paths: Vec<String>,
+    pub commands: Vec<String>,
+    pub reason_codes: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ContextDeltaReport {
+    pub schema: String,
+    pub reusable_context: Vec<String>,
+    pub stale_context: Vec<String>,
+    pub unread_required_context: Vec<String>,
+    pub reason_codes: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ProofPlan {
+    pub schema: String,
+    pub recommended_check_ids: Vec<String>,
+    pub withheld_check_ids: Vec<String>,
+    pub evidence_paths: Vec<String>,
+    pub reason_codes: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CapabilityGraph {
+    pub schema: String,
+    pub capabilities: Vec<RepositoryCapability>,
+    pub roots: Vec<CapabilityRoot>,
+    pub verification_edges: Vec<VerificationEdge>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RepositoryCapability {
+    pub id: String,
+    pub kind: String,
+    pub value: String,
+    pub evidence: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CapabilityRoot {
+    pub role: String,
+    pub path: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct VerificationEdge {
+    pub check_id: String,
+    pub command: String,
+    pub evidence: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EditSessionWatchdog {
+    pub schema: String,
+    pub touched_paths: Vec<String>,
+    pub next_commands: Vec<String>,
+    pub findings: Vec<WorkflowFinding>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DecisionGate {
+    pub schema: String,
+    pub action: String,
+    pub reason_codes: Vec<String>,
+    pub human_options: Vec<String>,
+    pub next_action: String,
+}

package/crates/naome-core/src/workflow/doctor.rs

@@ -5,6 +5,7 @@ use serde::Serialize;
 
 use crate::harness_health::{validate_harness_health, HarnessHealthOptions};
 use crate::models::NaomeError;
+use crate::repository_model_drift;
 use crate::task_state::{validate_task_state, TaskStateMode, TaskStateOptions};
 use crate::verification_contract::validate_verification_contract;
 
@@ -18,6 +19,7 @@ pub struct DoctorReport {
     pub harness_health: DoctorSection,
     pub task_state: DoctorSection,
     pub verification: DoctorSection,
+    pub repository_model: RepositoryPolicySection,
     pub repository_quality: RepositoryPolicySection,
     pub repository_structure: RepositoryPolicySection,
     pub recommended_check_ids: Vec<String>,
@@ -38,6 +40,7 @@ pub struct RepositoryPolicySection {
     pub config_present: bool,
     pub baseline_present: bool,
     pub status: String,
+    pub messages: Vec<String>,
 }
 
 pub fn doctor_report(root: &Path) -> Result<DoctorReport, NaomeError> {
@@ -59,6 +62,7 @@ pub fn doctor_report(root: &Path) -> Result<DoctorReport, NaomeError> {
     let verification_errors = validate_verification_contract(root)?;
     let phase_plan = verification_phase_plan(root, &[])?;
 
+    let repository_model = repository_model_section(root)?;
     let repository_quality = policy_section(
         root,
         ".naome/repository-quality.json",
@@ -72,12 +76,14 @@ pub fn doctor_report(root: &Path) -> Result<DoctorReport, NaomeError> {
     let ok = harness_health.status == "ok"
         && task_state.status == "ok"
         && verification.status == "ok"
+        && repository_model.status == "ok"
         && repository_quality.status == "ok"
         && repository_structure.status == "ok";
     let next_action = next_action(
         &harness_health,
         &task_state,
         &verification,
+        &repository_model,
         &repository_quality,
         &repository_structure,
     );
@@ -88,6 +94,7 @@ pub fn doctor_report(root: &Path) -> Result<DoctorReport, NaomeError> {
         harness_health,
         task_state,
         verification,
+        repository_model,
         repository_quality,
         repository_structure,
         recommended_check_ids: phase_plan.recommended_check_ids,
@@ -117,13 +124,38 @@ fn policy_section(root: &Path, config_path: &str, baseline_path: &str) -> Reposi
             "missing"
         }
         .to_string(),
+        messages: Vec::new(),
     }
 }
 
+fn repository_model_section(root: &Path) -> Result<RepositoryPolicySection, NaomeError> {
+    let drift = repository_model_drift(root)?;
+    let config_present = drift.model_present;
+    let status = if !config_present {
+        "missing"
+    } else if drift.stale {
+        "stale"
+    } else {
+        "ok"
+    };
+    let messages = if !config_present {
+        vec!["NAOME repository model is missing; run naome repo model --write.".to_string()]
+    } else {
+        drift.messages
+    };
+    Ok(RepositoryPolicySection {
+        config_present,
+        baseline_present: true,
+        status: status.to_string(),
+        messages,
+    })
+}
+
 fn next_action(
     harness_health: &DoctorSection,
     task_state: &DoctorSection,
     verification: &DoctorSection,
+    repository_model: &RepositoryPolicySection,
     repository_quality: &RepositoryPolicySection,
     repository_structure: &RepositoryPolicySection,
 ) -> String {
@@ -136,6 +168,13 @@ fn next_action(
     if verification.status != "ok" {
         return "Fix .naome/verification.json before relying on gates.".to_string();
     }
+    if repository_model.status == "stale" {
+        return "Run naome repo model --write to refresh deterministic repository facts."
+            .to_string();
+    }
+    if repository_model.status != "ok" {
+        return "Run naome repo model --write to seed deterministic repository facts.".to_string();
+    }
     if repository_quality.status != "ok" || repository_structure.status != "ok" {
         return "Run naome quality init or naome sync to seed repository quality policy."
             .to_string();

package/crates/naome-core/src/workflow/mod.rs

@@ -1,3 +1,5 @@
+mod agent;
+mod agent_types;
 mod doctor;
 mod integrity;
 mod integrity_normalize;
@@ -10,6 +12,15 @@ mod policy;
 mod processes;
 mod types;
 
+pub use agent::{
+    agent_run_plan, context_delta_report, decision_gate, edit_session_watchdog,
+    proof_plan_for_task, repository_capability_graph,
+};
+pub use agent_types::{
+    AgentRunPlan, CapabilityGraph, CapabilityRoot, ContextDeltaReport, DecisionGate,
+    EditSessionWatchdog, ExecutionPlanLedger, ExecutionPlanStep, ProofPlan, RepositoryCapability,
+    VerificationEdge,
+};
 pub use doctor::{doctor_report, DoctorReport, DoctorSection, RepositoryPolicySection};
 pub use integrity::{refresh_integrity, IntegrityRefreshReport};
 pub use mutation::classify_mutations;

package/crates/naome-core/src/workflow/output.rs

@@ -71,6 +71,8 @@ fn is_relevant_line(line: &str) -> bool {
         "outside allowedpaths",
         "denied",
         "missing",
+        ".log",
+        "artifact",
     ]
     .iter()
     .any(|needle| lower.contains(needle))
@@ -86,8 +88,12 @@ fn collect_paths(lines: &[String]) -> Vec<String> {
                     '"' | '\'' | '`' | ':' | ',' | ';' | '(' | ')' | '[' | ']'
                 )
             });
-            if looks_like_path(cleaned) {
-                paths.insert(cleaned.replace('\\', "/"));
+            let path_token = cleaned
+                .split_once(':')
+                .map(|(path, _)| path)
+                .unwrap_or(cleaned);
+            if looks_like_path(path_token) {
+                paths.insert(path_token.replace('\\', "/"));
             }
         }
     }

package/crates/naome-core/src/workflow/phase_inference.rs

@@ -54,7 +54,7 @@ fn inferred_phase<'a>(check: &'a CheckDefinition, release_gate_ids: &HashSet<&st
     if id == "diff-check" || command.contains("diff --check") {
         return "diff-check";
     }
-    if id.contains("quality") {
+    if id.contains("quality") || id.contains("semantic") {
         return "quality";
     }
     if id.contains("health") || id.contains("task-state") || command.contains("check-task-state") {

package/crates/naome-core/tests/context.rs

@@ -0,0 +1,99 @@
+mod repo_support;
+
+use naome_core::{select_context_for_changed_paths, select_context_for_prompt};
+
+use repo_support::{verification_value, TestRepo};
+
+#[test]
+fn changed_context_selects_touched_files_and_compact_quality_capsule() {
+    let repo = context_repo("context-changed-quality");
+    repo.write_file("packages/tool/src/quality/scanner.rs", "pub fn scan() {}\n");
+    repo.write_file("docs/naome/testing.md", "# Testing\n");
+    repo.commit_all("baseline");
+    repo.write_file(
+        "packages/tool/src/quality/scanner.rs",
+        "pub fn scan() {}\npub fn changed() {}\n",
+    );
+    repo.write_file("docs/naome/testing.md", "# Testing\n\nchanged\n");
+
+    let selection = select_context_for_changed_paths(repo.path()).unwrap();
+
+    assert_eq!(selection.schema, "naome.context-selection.v1");
+    assert_eq!(selection.mode, "changed");
+    assert_eq!(selection.capsule.id, "quality-work");
+    assert!(selection.required_context.iter().any(|item| {
+        item.path == "packages/tool/src/quality/scanner.rs" && item.reason == "changed_path"
+    }));
+    assert!(selection.commands.iter().any(|command| {
+        command == "node .naome/bin/naome.js quality check --path packages/tool/src/quality/scanner.rs"
+    }));
+    assert!(selection
+        .commands
+        .contains(&"node .naome/bin/naome.js quality check --changed".to_string()));
+    assert!(selection
+        .forbidden_context
+        .contains(&".naome/archive/**".to_string()));
+    assert!(selection.budget_ledger.selected_files < 6);
+    assert!(selection.budget_ledger.estimated_tokens > 0);
+}
+
+#[test]
+fn prompt_context_uses_file_mentions_without_broad_markdown_context() {
+    let repo = context_repo("context-prompt-paths");
+    repo.write_file("packages/app/src/lib.rs", "pub fn app() {}\n");
+    repo.write_file("docs/naome/repository-quality.md", "# Quality\n");
+    repo.commit_all("baseline");
+
+    let selection = select_context_for_prompt(
+        repo.path(),
+        "Please update packages/app/src/lib.rs and run a path-scoped quality check.",
+    )
+    .unwrap();
+
+    assert_eq!(selection.mode, "prompt");
+    assert_eq!(selection.capsule.id, "source-work");
+    assert_eq!(
+        selection.required_context[0].path,
+        "packages/app/src/lib.rs"
+    );
+    assert!(!selection
+        .required_context
+        .iter()
+        .any(|item| item.path == "docs/naome/repository-quality.md"));
+    assert!(selection
+        .optional_context
+        .iter()
+        .any(|item| item.path == "docs/naome/repository-quality.md"));
+}
+
+#[test]
+fn context_selection_reports_over_budget_when_many_paths_change() {
+    let repo = context_repo("context-budget");
+    for index in 0..20 {
+        repo.write_file(&format!("src/file_{index}.rs"), "pub fn before() {}\n");
+    }
+    repo.commit_all("baseline");
+    for index in 0..20 {
+        repo.write_file(&format!("src/file_{index}.rs"), "pub fn after() {}\n");
+    }
+
+    let selection = select_context_for_changed_paths(repo.path()).unwrap();
+
+    assert_eq!(selection.budget_ledger.selected_files, 12);
+    assert!(selection.budget_ledger.avoided_files >= 8);
+    assert!(selection
+        .budget_ledger
+        .reason_codes
+        .contains(&"context_file_budget_reached".to_string()));
+}
+
+fn context_repo(name: &str) -> TestRepo {
+    let repo = TestRepo::new(name);
+    repo.init_git();
+    repo.write_file(".naomeignore", ".naome/archive/\n.naome/cache/\n");
+    repo.write_naome_json(
+        "verification.json",
+        verification_value("ready", vec![], vec![]),
+    );
+    repo
+}

package/crates/naome-core/tests/harness_health.rs

@@ -18,7 +18,9 @@ const MACHINE_OWNED_PATHS: &[&str] = &[
     "docs/naome/index.md",
     "docs/naome/first-run.md",
     "docs/naome/agent-workflow.md",
+    "docs/naome/context-economy.md",
     "docs/naome/execution.md",
+    "docs/naome/task-ledger.md",
     "docs/naome/upgrade.md",
 ];
 
@@ -29,12 +31,14 @@ const PROJECT_OWNED_PATHS: &[&str] = &[
     ".naome/task-state.json",
     ".naome/upgrade-state.json",
     ".naome/verification.json",
+    ".naome/repository-model.json",
     ".naome/repository-quality.json",
     ".naome/repository-structure.json",
     ".naome/repository-quality-baseline.json",
     "docs/naome/architecture.md",
     "docs/naome/decisions.md",
     "docs/naome/repo-profile.md",
+    "docs/naome/repository-model.md",
     "docs/naome/repository-quality.md",
     "docs/naome/repository-structure.md",
     "docs/naome/security.md",

package/crates/naome-core/tests/install_plan.rs

@@ -8,6 +8,7 @@ fn install_plan_marks_machine_docs_and_bins_local_only() {
     assert_eq!(plan.harness_version, "1.0.0");
     assert!(plan.machine_owned.contains(&"docs/naome/execution.md"));
     assert!(plan.project_owned.contains(&"docs/naome/architecture.md"));
+    assert!(!plan.project_owned.contains(&".naome/tasks/**"));
     assert!(plan
         .local_only_machine_owned
         .contains(&".naome/bin/check-task-state.js"));
@@ -18,6 +19,17 @@ fn install_plan_marks_machine_docs_and_bins_local_only() {
     assert!(!plan
         .local_only_machine_owned
         .contains(&"docs/naome/architecture.md"));
+    assert!(plan
+        .optional_codex_hook_paths
+        .contains(&".codex/hooks.json"));
+    assert!(plan
+        .optional_codex_hook_paths
+        .contains(&".codex/config.toml"));
+    assert!(plan
+        .optional_codex_hook_paths
+        .contains(&".naome/bin/codex-hook.js"));
+    assert!(!plan.machine_owned.contains(&".naome/bin/codex-hook.js"));
+    assert!(!plan.project_owned.contains(&".codex/hooks.json"));
 }
 
 #[test]

package/crates/naome-core/tests/quality.rs

@@ -2,8 +2,8 @@ use std::fs;
 
 use naome_core::{
     check_repository_quality, init_repository_quality, init_repository_quality_with_mode,
-    plan_quality_cleanup, route_quality_cleanup, seed_builtin_verification_checks, QualityInitMode,
-    QualityMode,
+    plan_quality_cleanup, reconcile_repository_quality, route_quality_cleanup,
+    seed_builtin_verification_checks, QualityInitMode, QualityMode,
 };
 use serde_json::Value;
 
@@ -248,6 +248,174 @@ fn init_generates_adapter_selection_without_product_specific_path_rules() {
     assert!(!serialized_config.contains("naome-template-harness"));
 }
 
+#[test]
+fn init_auto_detects_ios_swift_adapter_set() {
+    let repo = QualityFixture::new("quality-ios-swift-adapters");
+    repo.write(
+        "Package.swift",
+        "// swift-tools-version: 5.9\nimport PackageDescription\n",
+    );
+    repo.write(
+        "Demo.xcodeproj/project.pbxproj",
+        "// !$*UTF8*$!\n{ archiveVersion = 1; }\n",
+    );
+    repo.write(
+        "Sources/App/App.swift",
+        "import SwiftUI\n@main struct DemoApp: App { var body: some Scene { WindowGroup { ContentView() } } }\n",
+    );
+    repo.write(
+        "Tests/AppTests/AppTests.swift",
+        "import XCTest\nfinal class AppTests: XCTestCase {}\n",
+    );
+    repo.write(
+        "Resources/Assets.xcassets/AppIcon.appiconset/Contents.json",
+        "{}\n",
+    );
+    repo.write("Generated/R.generated.swift", "enum R {}\n");
+    repo.commit_all("ios swift project");
+
+    init_repository_quality(repo.path()).unwrap();
+    let quality: Value = serde_json::from_str(
+        &fs::read_to_string(repo.path().join(".naome/repository-quality.json")).unwrap(),
+    )
+    .unwrap();
+    let structure: Value = serde_json::from_str(
+        &fs::read_to_string(repo.path().join(".naome/repository-structure.json")).unwrap(),
+    )
+    .unwrap();
+
+    for adapter in [
+        "swift",
+        "xcode",
+        "xctest",
+        "swiftui",
+        "ios-app-structure",
+        "swift-package",
+        "ios-resources",
+        "generated-ios",
+    ] {
+        assert!(
+            has_adapter(&quality, adapter),
+            "missing quality adapter {adapter}: {quality:#?}"
+        );
+        assert!(
+            has_adapter(&structure, adapter),
+            "missing structure adapter {adapter}: {structure:#?}"
+        );
+    }
+}
+
+#[test]
+fn changed_check_reports_stale_adapter_policy_after_stack_changes() {
+    let repo = QualityFixture::new("quality-stale-adapter-policy");
+    repo.write_quality_config_with_adapters(450, 100, 10, &[]);
+    repo.write_structure_config(serde_json::json!({
+        "enabledAdapters": []
+    }));
+    repo.commit_all("initial quality policy");
+    repo.write(
+        "Package.swift",
+        "// swift-tools-version: 5.9\nimport PackageDescription\n",
+    );
+    repo.write(
+        "Sources/App/App.swift",
+        "public struct DemoApp { public init() {} }\n",
+    );
+
+    let report = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+
+    assert!(!report.ok);
+    assert!(report.violations.iter().any(|violation| {
+        violation.check_id == "adapter-policy-stale"
+            && violation.path == ".naome/repository-quality.json"
+            && violation.message.contains("swift")
+            && violation
+                .related_paths
+                .contains(&".naome/repository-structure.json".to_string())
+    }));
+}
+
+#[test]
+fn changed_check_reports_stale_repository_model_after_stack_changes() {
+    let repo = QualityFixture::new("quality-repository-model-stale");
+    repo.write_quality_config();
+    repo.write_structure_config(serde_json::json!({}));
+    repo.write(
+        ".naome/repository-model.json",
+        "{\"schema\":\"naome.repository-model.v1\",\"version\":1,\"status\":\"ready\",\"facts\":[]}\n",
+    );
+    repo.write("README.md", "# Baseline\n");
+    repo.commit_all("baseline");
+
+    repo.write("Package.swift", "// swift-tools-version: 5.9\n");
+
+    let report = check_repository_quality(repo.path(), QualityMode::Changed).unwrap();
+
+    assert!(!report.ok);
+    assert!(report
+        .summary
+        .reason_codes
+        .contains(&"repository_model_stale".to_string()));
+    assert!(report.violations.iter().any(|violation| {
+        violation.check_id == "repository-model-stale"
+            && violation.path == ".naome/repository-model.json"
+            && violation
+                .related_paths
+                .contains(&"Package.swift".to_string())
+    }));
+}
+
+#[test]
+fn reconcile_write_updates_stale_quality_and_structure_adapter_policy() {
+    let repo = QualityFixture::new("quality-reconcile-adapters");
+    repo.write_quality_config_with_adapters(450, 100, 10, &[]);
+    repo.write_structure_config(serde_json::json!({
+        "enabledAdapters": []
+    }));
+    repo.write(
+        "Package.swift",
+        "// swift-tools-version: 5.9\nimport PackageDescription\n",
+    );
+    repo.write(
+        "Sources/App/App.swift",
+        "public struct DemoApp { public init() {} }\n",
+    );
+
+    let planned = reconcile_repository_quality(repo.path(), false).unwrap();
+    assert!(!planned.ok);
+    assert!(planned.stale);
+    assert!(planned
+        .missing_quality_adapters
+        .contains(&"swift".to_string()));
+    assert!(planned.updated_paths.is_empty());
+
+    let written = reconcile_repository_quality(repo.path(), true).unwrap();
+    assert!(written.ok);
+    assert!(!written.stale);
+    assert_eq!(
+        written.updated_paths,
+        vec![
+            ".naome/repository-quality.json".to_string(),
+            ".naome/repository-structure.json".to_string()
+        ]
+    );
+
+    let quality: Value = serde_json::from_str(
+        &fs::read_to_string(repo.path().join(".naome/repository-quality.json")).unwrap(),
+    )
+    .unwrap();
+    let structure: Value = serde_json::from_str(
+        &fs::read_to_string(repo.path().join(".naome/repository-structure.json")).unwrap(),
+    )
+    .unwrap();
+    assert!(has_adapter(&quality, "swift"));
+    assert!(has_adapter(&structure, "swift"));
+
+    let repeated = reconcile_repository_quality(repo.path(), true).unwrap();
+    assert!(repeated.ok);
+    assert!(repeated.updated_paths.is_empty());
+}
+
 #[test]
 fn enabled_adapters_apply_their_rules_without_materialized_path_rules() {
     let repo = QualityFixture::new("quality-adapter-runtime-config");
@@ -266,6 +434,14 @@ fn enabled_adapters_apply_their_rules_without_materialized_path_rules() {
     }));
 }
 
+fn has_adapter(config: &Value, adapter: &str) -> bool {
+    config["enabledAdapters"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .any(|value| value.as_str() == Some(adapter))
+}
+
 #[test]
 fn seeding_builtin_verification_wires_repository_quality_into_change_types() {
     let repo = QualityFixture::new("quality-verification-wiring");