core-runtime 0.1.1__py3-none-any.whl

core_runtime-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any

core_runtime-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+core=cli.cli_user:app
+core-admin=cli.admin_cli:app
+

mind/__init__.py

@@ -0,0 +1,4 @@
+# src/mind/__init__.py
+"""Provides functionality for the __init__ module."""
+
+from __future__ import annotations

mind/coherence/__init__.py

@@ -0,0 +1 @@
+# src/mind/coherence/__init__.py

mind/coherence/checker.py

@@ -0,0 +1,314 @@
+# src/mind/coherence/checker.py
+
+"""
+CoherenceChecker — Mind-layer orchestrator for the Constitutional Coherence Checker.
+
+Governing paper: .specs/papers/CORE-Governance-Topology.md (the directional grid)
+Governing ADR:   .specs/decisions/ADR-073-ccc-scanner-redesign.md
+Preserves:       ADR-067 D1 (storage), D2 (CLI), D4 (scheduling), D5 (dashboard).
+
+Per ADR-073 D3, the scanner dispatches to seven check classes covering the
+topology paper §10.2 enabled checks and the §10.3 retained/scoped R1. The
+legacy R1/R2/R3 emission paths are removed.
+
+Constitutional Compliance:
+- Mind layer cognitive instrument; reads constitutional documents and invokes
+  the LLM judge only for SAMECONCERN and R1_SCOPED.
+- LLM has no enforcement power — every output is a candidate for human triage.
+- No direct database access from this module: writes route through
+  CoherenceService (body layer).
+- Per ADR-073 D4: vector-dependent checks (SAMECONCERN, R1_SCOPED) refuse
+  when the governance_claims collection is not seeded by the governor's
+  `core-admin coherence seed bootstrap` operation. Structural checks operate
+  independently and are unaffected.
+"""
+
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from shared.logger import getLogger
+
+
+if TYPE_CHECKING:
+    from body.services.coherence_service import CoherenceService
+    from body.services.governance_claims_service import GovernanceClaimsService
+
+    from .checks.base import CheckClass
+
+
+logger = getLogger(__name__)
+
+__all__ = ["CoherenceChecker"]
+
+
+# ID: 73a23100-c107-4205-9313-0318dca1143b
+class CoherenceChecker:
+    """Orchestrator for the seven ADR-073 D3 check classes.
+
+    Produces candidates only — no verdicts, no enforcement actions, no
+    constitutional amendments. All human triage runs through
+    ``core-admin coherence triage``.
+    """
+
+    # ID: 5ae048c9-f6c7-4200-a4f1-193cbc82f1b9
+    def __init__(
+        self,
+        cognitive_service: Any,
+        coherence_service: CoherenceService,
+        repo_root: Path,
+        claims_service: GovernanceClaimsService | None = None,
+    ):
+        self._cognitive_service = cognitive_service
+        self._coherence_service = coherence_service
+        self._repo_root = Path(repo_root)
+        self._claims_service = claims_service
+
+    # ID: 2e4a95a7-fdac-427a-94eb-ed20ce2930c9
+    async def run(self, full: bool = False, sample_rules: int | None = None) -> str:
+        """Execute one CCC pass over the seven D3 check classes. Returns the new run_id.
+
+        ``sample_rules`` is accepted for back-compat with the ADR-067-era CLI but
+        is no longer meaningful — rule-scoped relations (R2, R3) were retired
+        per topology §10.3. Set values are logged and ignored.
+        """
+        if sample_rules is not None:
+            logger.info(
+                "CCC: sample_rules=%d ignored — R2/R3 retired per ADR-073 D1",
+                sample_rules,
+            )
+
+        trigger = await self._detect_trigger(full=full)
+        manifest = self._build_input_manifest()
+        run_id = await self._coherence_service.create_run(trigger)
+
+        check_status = await self._dispatch_checks(run_id)
+        manifest.append(
+            {
+                "domain": "_meta",
+                "path": None,
+                "type": "check_classes_run",
+                "check_status": check_status,
+            }
+        )
+        await self._coherence_service.update_manifest(run_id, manifest)
+        # Self-guarded close for zero-candidate scans — the triage-driven
+        # auto-close never fires when no candidates exist (issue #458). The
+        # service method's WHERE clause makes this a no-op when candidates
+        # were added, so the call is unconditional here.
+        await self._coherence_service.close_run_if_empty(run_id)
+
+        emitted_total = sum(s.get("emitted", 0) for s in check_status.values())
+        logger.info(
+            "CCC run %s complete (trigger=%s, %d candidates from %d check classes)",
+            run_id,
+            trigger,
+            emitted_total,
+            len(check_status),
+        )
+        return run_id
+
+    # ------------------------------------------------------------------ #
+    # Check-class dispatch
+    # ------------------------------------------------------------------ #
+
+    # ID: 43725b56-2fcb-4746-a414-dc57428ff02f
+    async def _dispatch_checks(self, run_id: str) -> dict[str, dict]:
+        from shared.governance.coherence_harvester import NormativeMarkerRegister
+        from shared.infrastructure.intent.intent_repository import get_intent_repository
+
+        from .checks.r1_scoped import R1ScopedCheck
+        from .checks.row2_grounding import Row2GroundingCheck
+        from .checks.row3_citation import Row3CitationCheck
+        from .checks.row4_naming import Row4NamingCheck
+        from .checks.sameconcern import SameConcernCheck
+        from .checks.specgap import SpecGapCheck
+        from .checks.vocabulary import VocabularyCheck
+
+        register = NormativeMarkerRegister.from_intent(get_intent_repository())
+
+        if self._claims_service is None:
+            logger.info(
+                "CCC: claims_service not injected; SAMECONCERN/R1_SCOPED will skip"
+            )
+
+        checks: list[CheckClass] = [
+            Row2GroundingCheck(self._repo_root),
+            Row3CitationCheck(self._repo_root, register),
+            Row4NamingCheck(self._repo_root),
+            VocabularyCheck(self._repo_root),
+            SpecGapCheck(self._repo_root, register),
+        ]
+        if self._claims_service is not None:
+            checks.append(
+                SameConcernCheck(
+                    self._repo_root,
+                    register,
+                    self._claims_service,
+                    self._cognitive_service,
+                )
+            )
+            checks.append(
+                R1ScopedCheck(
+                    self._repo_root,
+                    register,
+                    self._claims_service,
+                    self._cognitive_service,
+                )
+            )
+
+        status: dict[str, dict] = {}
+        for check in checks:
+            try:
+                candidates = await check.run()
+            except Exception as exc:
+                logger.warning(
+                    "CCC: check %s failed: %s", check.relation, exc, exc_info=True
+                )
+                status[check.relation] = {
+                    "status": "error",
+                    "error": str(exc),
+                    "emitted": 0,
+                }
+                continue
+            for candidate in candidates:
+                await self._coherence_service.add_candidate(
+                    run_id=run_id,
+                    relation=candidate.relation,
+                    documents=candidate.documents,
+                    claim=candidate.claim,
+                    rationale=candidate.rationale,
+                )
+            status[check.relation] = {"status": "ok", "emitted": len(candidates)}
+            logger.info(
+                "CCC: %s emitted %d candidates", check.relation, len(candidates)
+            )
+        return status
+
+    # ------------------------------------------------------------------ #
+    # Trigger detection (preserved from ADR-067 implementation)
+    # ------------------------------------------------------------------ #
+
+    async def _detect_trigger(self, full: bool) -> str:
+        if full:
+            return "manual"
+
+        latest = await self._coherence_service.get_latest_run()
+        if latest is None:
+            return "manual"
+
+        last_manifest = latest.get("input_manifest") or []
+
+        last_adr_count = sum(
+            1 for entry in last_manifest if entry.get("domain") == "adr"
+        )
+        current_adr_count = len(self._adr_paths())
+        if current_adr_count > last_adr_count:
+            return "adr_added"
+
+        last_northstar_hashes = {
+            entry.get("path"): entry.get("sha256")
+            for entry in last_manifest
+            if entry.get("domain") == "northstar"
+        }
+        for path in self._northstar_paths():
+            try:
+                current_hash = _sha256(path)
+            except OSError:
+                return "northstar_changed"
+            rel = self._rel(path)
+            if last_northstar_hashes.get(rel) != current_hash:
+                return "northstar_changed"
+
+        return "manual"
+
+    # ------------------------------------------------------------------ #
+    # Manifest construction
+    # ------------------------------------------------------------------ #
+
+    # ID: c44f8192-948c-4671-82a1-445dc657ee59
+    def _build_input_manifest(self) -> list[dict]:
+        """Document the governance inputs consumed by the redesigned scanner.
+
+        ADR-067-era 'rule' entries are no longer emitted — rule-scoped relations
+        (R2, R3) were retired per topology §10.3. The new scanner consumes
+        ADRs, papers, northstar, phases, and the vocabulary projection.
+        """
+        manifest: list[dict] = []
+        for path in self._adr_paths():
+            manifest.append(self._manifest_entry(path, "adr"))
+        for path in self._paper_paths():
+            manifest.append(self._manifest_entry(path, "paper"))
+        for path in self._northstar_paths():
+            manifest.append(self._manifest_entry(path, "northstar"))
+        for path in self._phase_paths():
+            manifest.append(self._manifest_entry(path, "phase"))
+        vocab = self._repo_root / ".intent" / "META" / "vocabulary.json"
+        if vocab.exists():
+            manifest.append(self._manifest_entry(vocab, "vocabulary"))
+        return manifest
+
+    # ID: f6ffc21f-e4ef-477c-9bb7-2cdd2d4599c5
+    def _manifest_entry(self, path: Path, domain: str) -> dict:
+        rel = self._rel(path)
+        try:
+            sha = _sha256(path)
+        except OSError:
+            return {
+                "path": rel,
+                "domain": domain,
+                "status": "skipped",
+                "skipped_reason": "file_read_failure",
+                "sha256": None,
+            }
+        return {
+            "path": rel,
+            "domain": domain,
+            "status": "checked",
+            "skipped_reason": None,
+            "sha256": sha,
+        }
+
+    # ------------------------------------------------------------------ #
+    # Input enumeration
+    # ------------------------------------------------------------------ #
+
+    def _adr_paths(self) -> list[Path]:
+        decisions = self._repo_root / ".specs" / "decisions"
+        if not decisions.exists():
+            return []
+        return sorted(decisions.glob("ADR-*.md"))
+
+    def _paper_paths(self) -> list[Path]:
+        papers = self._repo_root / ".specs" / "papers"
+        if not papers.exists():
+            return []
+        return sorted(papers.glob("*.md"))
+
+    def _northstar_paths(self) -> list[Path]:
+        northstar = self._repo_root / ".specs" / "northstar"
+        if not northstar.exists():
+            return []
+        return sorted(northstar.glob("*.md"))
+
+    def _phase_paths(self) -> list[Path]:
+        phases = self._repo_root / ".intent" / "phases"
+        if not phases.exists():
+            return []
+        return sorted(phases.glob("*.yaml"))
+
+    # ------------------------------------------------------------------ #
+    # Helpers
+    # ------------------------------------------------------------------ #
+
+    def _rel(self, path: Path) -> str:
+        try:
+            return str(path.relative_to(self._repo_root))
+        except ValueError:
+            return str(path)
+
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()

mind/coherence/checks/__init__.py

@@ -0,0 +1,4 @@
+# src/mind/coherence/checks/__init__.py
+"""CCC check classes per ADR-073 D3 taxonomy."""
+
+from __future__ import annotations

mind/coherence/checks/base.py

@@ -0,0 +1,34 @@
+# src/mind/coherence/checks/base.py
+"""Shared types for CCC check classes per ADR-073 D3."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Protocol
+
+
+@dataclass(frozen=True)
+# ID: f65b81c3-fff5-41e2-9c9a-58db1d4eeb6b
+class CoherenceCandidate:
+    """One emitted candidate row, persisted via CoherenceService.add_candidate."""
+
+    relation: str
+    documents: list[str]
+    claim: str
+    rationale: str
+
+
+# ID: 5641414f-99ba-42d9-bf53-d0e41d4d4291
+class CheckClass(Protocol):
+    """Common shape for every check class in the ADR-073 D3 taxonomy.
+
+    Implementations are constructed by the CoherenceChecker orchestrator
+    with the resources each class needs (repo_root, harvester, claims
+    service, etc.) and yield CoherenceCandidate instances. Persistence
+    and manifest book-keeping is the orchestrator's responsibility.
+    """
+
+    relation: str
+
+    # ID: a8967c42-38a3-4161-bb66-bf03f1fe5a35
+    async def run(self) -> list[CoherenceCandidate]: ...

mind/coherence/checks/r1_scoped.py

@@ -0,0 +1,228 @@
+# src/mind/coherence/checks/r1_scoped.py
+"""R1_SCOPED — same-concern contradiction over ADR pairs declared via `Relates:`.
+
+Per ADR-073 D2. Subset of SAMECONCERN constrained at the pair-membership step.
+One-directional citation is sufficient: if ADR-X cites ADR-Y, pair (X, Y) is
+checked regardless of whether ADR-Y cites ADR-X.
+
+Mechanism: parse `Relates:` frontmatter, for each declared pair run kNN with
+filter restricting hits to the partner ADR, then LLM-judge with the same
+tiered policy as SAMECONCERN.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from shared.logger import getLogger
+
+from ..llm_judge import judge_contradiction_pair
+from .base import CoherenceCandidate
+
+
+if TYPE_CHECKING:
+    from body.services.governance_claims_service import GovernanceClaimsService
+    from shared.governance.coherence_harvester import NormativeMarkerRegister
+
+
+logger = getLogger(__name__)
+
+
+_RELATES_FRONTMATTER = re.compile(
+    r"^\*\*Relates:\*\*\s*(.+?)\s*$", re.IGNORECASE | re.MULTILINE
+)
+_ADR_TOKEN = re.compile(r"ADR-\d{3}")
+
+# Body-level reconciliation prefix: `**Compatibility with ADR-NNN**`,
+# `**Supersedes:** ADR-NNN`, `**Supersedes (partial):** ADR-NNN`, etc.
+# Used to filter out R1_SCOPED pairs where the author has explicitly
+# reconciled the relationship — the LLM judge cannot see the reconciliation
+# when only chunked claims reach the prompt, and routinely emits
+# false-positive contradiction verdicts on reconciled pairs. See #474.
+_RECONCILIATION_PREFIX = re.compile(
+    r"\*\*\s*(?:Compatibility\s+with|Supersedes)\b",
+    re.IGNORECASE,
+)
+
+
+def _declared_compatibility_partners(text: str) -> set[str]:
+    """Return ADR-NNN tokens this document explicitly reconciles with.
+
+    Scans for body-level patterns: `**Compatibility with ADR-NNN**`,
+    `**Supersedes:** ADR-NNN`, `**Supersedes (partial):** ADR-NNN`.
+    The returned set is treated as authoritative for skipping R1_SCOPED
+    pairs — if the author declares reconciliation, the judge does not get
+    to override it (per #474). Line-level scan; multi-line declarations
+    capture only ADRs cited on the prefix line.
+    """
+    partners: set[str] = set()
+    for line in text.splitlines():
+        if not _RECONCILIATION_PREFIX.search(line):
+            continue
+        partners.update(_ADR_TOKEN.findall(line))
+    return partners
+
+
+_HIGH_CONFIDENCE_COSINE = 0.78
+_AMBIGUOUS_COSINE = 0.74
+_KNN_LIMIT = 10
+
+
+# ID: 411d5a1f-0a88-4a34-b1bc-4a64143daf09
+class R1ScopedCheck:
+    """Emit R1_SCOPED candidates for contradicting claims across declared ADR pairs."""
+
+    relation = "R1_SCOPED"
+
+    # ID: f24bd798-1f30-461e-9038-b791751970bc
+    def __init__(
+        self,
+        repo_root: Path,
+        register: NormativeMarkerRegister,
+        claims_service: GovernanceClaimsService,
+        cognitive_service: Any,
+    ) -> None:
+        self._repo_root = Path(repo_root)
+        self._register = register
+        self._claims_service = claims_service
+        self._cognitive_service = cognitive_service
+
+    # ID: 9208e1dc-5108-45b7-a2e1-514cc9df6af9
+    async def run(self) -> list[CoherenceCandidate]:
+        from shared.governance.coherence_harvester import GovernanceClaimHarvester
+        from shared.infrastructure.vector.cognitive_adapter import (
+            CognitiveEmbedderAdapter,
+        )
+
+        pairs = self._declared_pairs()
+        if not pairs:
+            logger.info(
+                "R1_SCOPED: no ADRs declare `Relates:` frontmatter — emitting zero (expected per D2)"
+            )
+            return []
+
+        if not await self._claims_service.is_seeded():
+            logger.info("R1_SCOPED: governance_claims not seeded; skipping (D4)")
+            return []
+
+        harvester = GovernanceClaimHarvester(self._repo_root, self._register)
+        claims_by_path: dict[str, list] = {}
+        for claim in harvester.harvest():
+            claims_by_path.setdefault(claim.source_path, []).append(claim)
+
+        embedder = CognitiveEmbedderAdapter(self._cognitive_service)
+        seen: set[frozenset[tuple[str, str]]] = set()
+        candidates: list[CoherenceCandidate] = []
+
+        for source_path, partner_path in pairs:
+            source_claims = claims_by_path.get(source_path, [])
+            if not source_claims:
+                continue
+            for claim in source_claims:
+                try:
+                    vector = await embedder.get_embedding(claim.text)
+                except Exception as exc:
+                    logger.warning("R1_SCOPED: embed failed: %s", exc)
+                    continue
+                hits = await self._claims_service.search(
+                    query_vector=vector,
+                    limit=_KNN_LIMIT,
+                    score_threshold=_AMBIGUOUS_COSINE,
+                    source_path_in=[partner_path],
+                )
+                for hit in hits:
+                    if (
+                        hit.source_path == claim.source_path
+                        and hit.content_sha == claim.content_sha
+                    ):
+                        continue
+                    tier = (
+                        "high_confidence"
+                        if hit.cosine >= _HIGH_CONFIDENCE_COSINE
+                        else "ambiguous"
+                    )
+                    pair_key: frozenset[tuple[str, str]] = frozenset(
+                        {
+                            (claim.source_path, claim.content_sha),
+                            (hit.source_path, hit.content_sha),
+                        }
+                    )
+                    if pair_key in seen:
+                        continue
+                    seen.add(pair_key)
+
+                    verdict = await judge_contradiction_pair(
+                        cognitive_service=self._cognitive_service,
+                        text_a=claim.text,
+                        source_a=claim.source_path,
+                        text_b=hit.text,
+                        source_b=hit.source_path,
+                        tier=tier,
+                        relation=self.relation,
+                        category_a=claim.category,
+                        category_b=hit.category,
+                    )
+                    if verdict is not None:
+                        candidates.append(verdict)
+        return candidates
+
+    # ID: 7939908b-6686-4b35-b3e6-a74f6ae1fbaf
+    def _declared_pairs(self) -> list[tuple[str, str]]:
+        """Parse Relates: frontmatter across all accepted ADRs.
+
+        Returns a list of (source_adr_path, partner_adr_path) tuples — one
+        per declared link. One-directional sufficient per D2.
+
+        Per #474: pairs where either ADR reconciles with the other via a
+        body-level `**Compatibility with ADR-NNN**` or `**Supersedes**`
+        declaration are filtered out. The LLM judge cannot see the
+        reconciliation when only chunked claims reach the prompt and
+        routinely emits false-positive contradictions on reconciled pairs.
+        """
+        decisions = self._repo_root / ".specs" / "decisions"
+        if not decisions.is_dir():
+            return []
+        # Map ADR-NNN → relative path, used to resolve cited tokens to files.
+        adr_path_by_id: dict[str, str] = {}
+        for path in sorted(decisions.glob("ADR-*.md")):
+            m = _ADR_TOKEN.match(path.stem)
+            if m:
+                adr_path_by_id[m.group(0)] = str(path.relative_to(self._repo_root))
+
+        # Single read per ADR — extract Relates: partners and reconciliation set.
+        relates_by_id: dict[str, list[str]] = {}
+        reconciled_by_id: dict[str, set[str]] = {}
+        for source_id, source_rel in adr_path_by_id.items():
+            content = (self._repo_root / source_rel).read_text(
+                encoding="utf-8", errors="replace"
+            )
+            match = _RELATES_FRONTMATTER.search(content)
+            if match:
+                relates_by_id[source_id] = _ADR_TOKEN.findall(match.group(1))
+            reconciled_by_id[source_id] = _declared_compatibility_partners(content)
+
+        pairs: list[tuple[str, str]] = []
+        reconciled_skips = 0
+        for source_id, source_rel in adr_path_by_id.items():
+            partners = relates_by_id.get(source_id, [])
+            for partner_id in partners:
+                if partner_id == source_id:
+                    continue
+                partner_rel = adr_path_by_id.get(partner_id)
+                if partner_rel is None:
+                    continue
+                if partner_id in reconciled_by_id.get(
+                    source_id, set()
+                ) or source_id in reconciled_by_id.get(partner_id, set()):
+                    reconciled_skips += 1
+                    continue
+                pairs.append((source_rel, partner_rel))
+
+        if reconciled_skips:
+            logger.info(
+                "R1_SCOPED: skipped %d Relates: pair(s) due to declared compatibility/supersedes (per #474)",
+                reconciled_skips,
+            )
+        return pairs

mind/coherence/checks/row2_grounding.py

@@ -0,0 +1,69 @@
+# src/mind/coherence/checks/row2_grounding.py
+"""ROW2_GROUNDING — every accepted ADR cites at least one grounding paper.
+
+Per ADR-073 D6 / topology §10.2 row 2.
+
+Mechanism: structural grep over ADR References / Relates / Supersedes blocks.
+No LLM, no embeddings.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from .base import CoherenceCandidate
+
+
+_PAPERS_CITE = re.compile(r"\.specs/papers/[\w\-./]+\.md", re.IGNORECASE)
+_SUPERSEDES_FRONTMATTER = re.compile(r"^\*\*Supersedes", re.IGNORECASE | re.MULTILINE)
+_STATUS_ACCEPTED = re.compile(
+    r"^\*\*Status:\*\*\s*Accepted", re.IGNORECASE | re.MULTILINE
+)
+
+
+# ID: d89bcb64-5a44-42a9-af06-ba730a70cf10
+class Row2GroundingCheck:
+    """Emit ROW2_GROUNDING for accepted ADRs missing a grounding paper citation."""
+
+    relation = "ROW2_GROUNDING"
+
+    # ID: 21f65c05-2345-4135-a581-b68b8000de23
+    def __init__(self, repo_root: Path) -> None:
+        self._repo_root = Path(repo_root)
+
+    # ID: 460370e4-9d2d-479e-967c-df37f7e7ab9e
+    async def run(self) -> list[CoherenceCandidate]:
+        decisions = self._repo_root / ".specs" / "decisions"
+        if not decisions.is_dir():
+            return []
+        candidates: list[CoherenceCandidate] = []
+        for adr_path in sorted(decisions.glob("ADR-*.md")):
+            content = adr_path.read_text(encoding="utf-8", errors="replace")
+            if not _STATUS_ACCEPTED.search(content):
+                continue
+            if _SUPERSEDES_FRONTMATTER.search(content):
+                continue
+            if _PAPERS_CITE.search(content):
+                continue
+            rel = str(adr_path.relative_to(self._repo_root))
+            candidates.append(
+                CoherenceCandidate(
+                    relation=self.relation,
+                    documents=[rel],
+                    claim=(
+                        f"ADR {adr_path.stem} cites no grounding paper "
+                        "(.specs/papers/...) and carries no Supersedes: declaration."
+                    ),
+                    rationale=(
+                        "Topology paper §3 row 2 requires every accepted ADR to "
+                        "either cite at least one grounding paper or declare "
+                        "supersession of a predecessor (which inherits its "
+                        "predecessor's grounding). Neither was found in this "
+                        "ADR's text. Either backfill the References block with "
+                        "the operationalized paper, or — if no grounding paper "
+                        "exists — author the missing paper first per §11.3."
+                    ),
+                )
+            )
+        return candidates