@dzhechkov/p-replicator 1.5.17 → 1.6.0

package/templates/.claude/skills/goap-research-ed25519/scripts/fixtures_field_cases.json

@@ -0,0 +1,133 @@
+{
+  "_provenance": {
+    "status": "CLAIMED, not independently re-derived",
+    "evidence_class": "ASSERTED",
+    "note": "The four field cases are taken verbatim from a field report; this pipeline did not open the sources. Their `verbatim` strings are paraphrases of what the field report said the sources said, NOT transcriptions checked against a paper, and no DOI/NCT identifier is invented to make them look more grounded than they are. These fixtures assert the MATCHER's behaviour, which does not depend on the citation being real.",
+    "patient": "male, BMI 25, triglycerides 236 mg/dL, cardiovascular risk moderate (the brief's patient)"
+  },
+  "patient_profile": {
+    "sex": "male",
+    "bmi": 25,
+    "triglycerides_mg_dl": 236,
+    "cv_risk": "moderate"
+  },
+  "cases": [
+    {
+      "id": "testosterone-weight-loss",
+      "kind": "real-field-reversal",
+      "claim": "Weight loss raises testosterone",
+      "expected_verdict": "partial",
+      "expected_discrepancies": [
+        {"field": "bmi", "kind": "baseline-out-of-range", "direction": "below"}
+      ],
+      "why_not_none": "The patient could have enrolled; the effect was simply not measured from where his BMI stands. Saying 'none' here would be the mirror error of saying 'full'.",
+      "study_population": {
+        "description": "men with obesity (BMI >= 30) enrolled in a weight-loss intervention",
+        "locator": "[Methods, Participants]",
+        "criteria": {
+          "sex": {"op": "==", "value": "male", "kind": "eligibility",
+                  "verbatim": "men", "locator": "[Methods, Participants]"},
+          "bmi_min": {"op": ">=", "value": 30, "kind": "baseline",
+                      "verbatim": "men with obesity (BMI >= 30 kg/m2)",
+                      "locator": "[Methods, Participants]"}
+        }
+      }
+    },
+    {
+      "id": "ed-rct-bmi30",
+      "kind": "real-field-reversal",
+      "claim": "Erectile dysfunction is reversible (randomised controlled trial)",
+      "expected_verdict": "none",
+      "expected_discrepancies": [
+        {"field": "bmi", "kind": "eligibility-excluded", "direction": "below"}
+      ],
+      "why_none": "BMI >= 30 was an ENROLMENT criterion — this patient would not have been in the trial at all.",
+      "study_population": {
+        "description": "participants with BMI >= 30 randomised to the intervention",
+        "locator": "[Methods, Eligibility]",
+        "criteria": {
+          "bmi_min": {"op": ">=", "value": 30, "kind": "eligibility",
+                      "verbatim": "inclusion criteria: BMI >= 30 kg/m2",
+                      "locator": "[Methods, Eligibility]"}
+        }
+      }
+    },
+    {
+      "id": "traverse-cv-safety",
+      "kind": "real-field-reversal",
+      "claim": "TRAVERSE found no excess cardiovascular harm from testosterone therapy",
+      "expected_verdict": "none",
+      "expected_discrepancies": [
+        {"field": "cv_risk", "kind": "eligibility-excluded", "direction": "outside-set"}
+      ],
+      "why_none": "A null-harm finding established in high-cardiovascular-risk men does not extend by default to a man who is not high-risk.",
+      "study_population": {
+        "description": "men at high cardiovascular risk with hypogonadism",
+        "locator": "[Methods, Participants]",
+        "criteria": {
+          "cv_risk": {"op": "==", "value": "high", "kind": "eligibility",
+                      "verbatim": "men with high cardiovascular risk",
+                      "locator": "[Methods, Participants]"}
+        }
+      }
+    },
+    {
+      "id": "omega3-ldl",
+      "kind": "real-field-reversal",
+      "claim": "Omega-3 raises LDL by 44.5%",
+      "expected_verdict": "partial",
+      "expected_discrepancies": [
+        {"field": "triglycerides", "kind": "baseline-out-of-range", "direction": "below"}
+      ],
+      "why_not_none": "Severe hypertriglyceridemia is a different metabolic regime; the magnitude is not established at 236 mg/dL, but the patient is not excluded from the population.",
+      "study_population": {
+        "description": "patients with severe hypertriglyceridemia (baseline triglycerides >= 800 mg/dL)",
+        "locator": "[Methods, Baseline characteristics]",
+        "criteria": {
+          "triglycerides_mg_dl_min": {"op": ">=", "value": 800, "kind": "baseline",
+                                      "verbatim": "baseline triglycerides >= 800 mg/dL",
+                                      "locator": "[Methods, Baseline characteristics]"}
+        }
+      }
+    },
+    {
+      "id": "synthetic-missing-patient-value",
+      "kind": "synthetic",
+      "claim": "Synthetic: the patient profile does not carry the axis the study used",
+      "expected_verdict": "unknown",
+      "expected_discrepancies": [
+        {"field": "bmi", "kind": "patient-value-missing", "direction": "absent"}
+      ],
+      "patient_profile_override": {"sex": "male"},
+      "note": "01_requirements.md AC-5 called this `partial` under the three-verdict wording. ADR-001 §2 and AM-6 confirmed a FOURTH verdict: an unestablished criterion is not a milder kind of match, so this is `unknown`. The distinction is the whole of D-17's discipline — unevaluable is never a pass.",
+      "study_population": {
+        "description": "men with obesity (BMI >= 30)",
+        "locator": "[Methods]",
+        "criteria": {
+          "sex": {"op": "==", "value": "male", "kind": "eligibility",
+                  "verbatim": "men", "locator": "[Methods]"},
+          "bmi_min": {"op": ">=", "value": 30, "kind": "eligibility",
+                      "verbatim": "BMI >= 30 kg/m2", "locator": "[Methods]"}
+        }
+      }
+    },
+    {
+      "id": "synthetic-full",
+      "kind": "synthetic",
+      "claim": "Synthetic: every stated criterion is satisfied by a known patient value",
+      "expected_verdict": "full",
+      "expected_discrepancies": [],
+      "patient_profile_override": {"sex": "male", "bmi": 33},
+      "study_population": {
+        "description": "men with obesity (BMI >= 30)",
+        "locator": "[Methods]",
+        "criteria": {
+          "sex": {"op": "==", "value": "male", "kind": "eligibility",
+                  "verbatim": "men", "locator": "[Methods]"},
+          "bmi_min": {"op": ">=", "value": 30, "kind": "eligibility",
+                      "verbatim": "BMI >= 30 kg/m2", "locator": "[Methods]"}
+        }
+      }
+    }
+  ]
+}

package/templates/.claude/skills/goap-research-ed25519/scripts/goap_planner.py

@@ -16,8 +16,9 @@ Features:
 import heapq
 import json
 import hashlib
+import time
 from dataclasses import dataclass, field, asdict
-from typing import Dict, Set, List, Optional, Tuple, Any
+from typing import Dict, FrozenSet, Set, List, Optional, Tuple, Any, Union
 from datetime import datetime
 from enum import Enum
 
@@ -98,15 +99,70 @@ class ResearchPlan:
         }
 
 
+class PlanVerdict(Enum):
+    """
+    Verdict for a planning attempt that did not produce a plan.
+
+    Two fundamentally different situations that must never share one message
+    (precedented in this repo: INSUFFICIENT_DATA in harness-core/src/compounding.ts
+    and 'inconclusive' in harness-core/src/skills-verify.ts — "don't know" is a
+    first-class verdict, not a failure collapsed into the same bucket as
+    "definitely no"):
+
+    - GOAL_UNREACHABLE: proven — no sequence of available actions can ever
+      satisfy the goal from the initial state, regardless of budget.
+    - SEARCH_EXHAUSTED: not proven unreachable — the search simply did not find
+      a plan within its iteration budget. Retrying with a higher
+      ``max_iterations`` may succeed.
+    """
+    GOAL_UNREACHABLE = "goal_unreachable"
+    SEARCH_EXHAUSTED = "search_exhausted"
+
+
+@dataclass
+class PlanNotFound:
+    """
+    First-class "no plan" result carrying WHY no plan was returned.
+
+    Callers must branch on ``isinstance(result, ResearchPlan)`` /
+    ``isinstance(result, PlanNotFound)`` rather than truthiness. As defense in
+    depth, ``__bool__`` returns False, so legacy TRUTHINESS checks
+    (``if plan:`` / ``if not plan:``) keep behaving exactly as they did when
+    this function returned ``None``.
+
+    IDENTITY checks are NOT covered by that safety net: ``plan is None`` is
+    now ALWAYS False. A caller migrating from the old contract via
+    ``if plan is not None:`` will read a no-plan result as success and then
+    raise ``AttributeError`` on ``.actions`` — or, worse, silently proceed.
+    Migrate every ``is None`` / ``is not None`` check to
+    ``isinstance(result, ResearchPlan)``.
+    """
+    verdict: PlanVerdict
+    iterations: Optional[int] = None   # set for SEARCH_EXHAUSTED; None for GOAL_UNREACHABLE
+    message: str = ""                  # actionable text; carries retry guidance for SEARCH_EXHAUSTED
+
+    def __bool__(self) -> bool:
+        return False
+
+
 # Extended research actions library with Ed25519 verification support
 RESEARCH_ACTIONS = [
     # Setup Actions
+    #
+    # NOTE on the two capability flags below (historical defect: `whitelist_available`):
+    # `issuer_keys_available` (real Ed25519 issuer key material genuinely held) and
+    # `source_class_verified` (this class of source is capable of signed delivery at all)
+    # are INITIAL-STATE-ONLY facts about the deployment. No action in this library may
+    # ever list either of them in `effects` — an action that could manufacture its own
+    # key/source-class credibility for free would repeat the `whitelist_available`
+    # defect, where a dead flag plus a zero-precondition `configure_trusted_issuers`
+    # let the planner fabricate "verified" plans backed by nothing.
     ResearchAction(
         name="configure_trusted_issuers",
-        preconditions=set(),
+        preconditions={"issuer_keys_available"},
         effects={"whitelist_active", "verification_ready"},
         cost=0,
-        description="Initialize trusted issuer whitelist"
+        description="Initialize trusted issuer whitelist (requires real issuer key material)"
     ),
     ResearchAction(
         name="generate_research_keypair",
@@ -126,7 +182,7 @@ RESEARCH_ACTIONS = [
     ),
     ResearchAction(
         name="web_search_verified",
-        preconditions={"topic_defined", "whitelist_active"},
+        preconditions={"topic_defined", "whitelist_active", "source_class_verified"},
         effects={"verified_candidates_found", "trusted_sources_identified"},
         cost=2,
         description="Search with priority to trusted issuer sources",
@@ -158,7 +214,7 @@ RESEARCH_ACTIONS = [
     ),
     ResearchAction(
         name="fetch_signed_source",
-        preconditions={"sources_identified", "whitelist_active"},
+        preconditions={"sources_identified", "whitelist_active", "source_class_verified"},
         effects={"signed_content_retrieved", "signature_verified"},
         cost=3,
         description="Retrieve content with Ed25519 signature verification",
@@ -328,29 +384,122 @@ def heuristic(state: Set[str], goal: Set[str], unsigned_claims: int = 0) -> floa
     return base_cost + verification_penalty
 
 
+# Adaptive default iteration budgets, calibrated by MEASUREMENT (feature
+# ha-slice-e-goap-blockers, 2026-08-04): binary search for the minimal
+# max_iterations that finds a plan for each shipped demo scenario showed the
+# dominant variable is verification_mode, not goal-set size — STRICT scenarios
+# need ~20-100x the iterations of MODERATE ones at comparable goal counts,
+# because the strict-mode unsigned-claims rejection narrows the acceptable goal
+# nodes drastically. Measured minima: competitive/MODERATE 3-goal = 2,249;
+# high_stakes/STRICT 5-goal = 55,128. Floors carry ~2x margin over the worst
+# measured scenario of their mode class. PARANOID inherits the STRICT floor:
+# its search behavior is identical to STRICT in this planner (the only
+# search-relevant switch is require_verification, shared by both modes; the
+# 0.99-vs-0.95 threshold affects reporting, not the search), and the floor is
+# exercised by a shipped scenario (test_default_budget_finds_high_stakes_
+# paranoid_plan runs high_stakes/PARANOID to a plan at the default budget) —
+# so "PARANOID = STRICT floor" is a tested identity, not a bare extrapolation.
+# DEVELOPMENT shares the MODERATE floor via the else-branch (also tested).
+_MODERATE_ITERATIONS_FLOOR = 5_000     # ~2.2x margin over measured competitive/MODERATE minimum (2,249)
+_STRICT_ITERATIONS_FLOOR = 100_000     # ~1.8x margin over measured high_stakes/STRICT minimum (55,128)
+_ITERATIONS_PER_GOAL_MODERATE = 50     # secondary headroom term for large goal sets
+_ITERATIONS_PER_GOAL_STRICT = 500
+
+
+def _default_max_iterations(goal_state: Set[str], verification_mode: VerificationMode) -> int:
+    """Adaptive default search budget (see calibration note above)."""
+    if verification_mode in (VerificationMode.STRICT, VerificationMode.PARANOID):
+        return max(_STRICT_ITERATIONS_FLOOR, _ITERATIONS_PER_GOAL_STRICT * len(goal_state))
+    return max(_MODERATE_ITERATIONS_FLOOR, _ITERATIONS_PER_GOAL_MODERATE * len(goal_state))
+
+
+def _reachability_closure(initial_state: Set[str], actions: List[ResearchAction]) -> FrozenSet[str]:
+    """
+    Delete-free forward-chaining reachability closure (classic STRIPS
+    relaxed-planning-graph technique).
+
+    Because ``ResearchAction.apply()`` is a pure set-union (state only grows,
+    facts are never removed), forward-chaining preconditions -> effects to a
+    fixed point is bounded by ``len(actions)`` passes: each action can flip
+    from inapplicable to applicable at most once. Cost: O(len(actions)^2) set
+    operations — microseconds, and by construction independent of any
+    iteration budget.
+
+    SOUNDNESS NOTE: this closure is a *relaxed* check — it ignores the
+    unsigned-claims / verification-mode gate entirely. ``goal not <= closure``
+    is therefore a SOUND proof of unreachability (the closure is a superset of
+    everything the constrained search could ever reach). ``goal <= closure``
+    is NOT a guarantee the constrained A* search finds a plan within any given
+    budget — which is exactly why SEARCH_EXHAUSTED remains meaningful even
+    when the closure says "reachable in principle".
+    """
+    state = set(initial_state)
+    changed = True
+    while changed:
+        changed = False
+        for action in actions:
+            if action.preconditions.issubset(state):
+                before = len(state)
+                state |= action.effects
+                if len(state) > before:
+                    changed = True
+    return frozenset(state)
+
+
 def find_research_plan(
     initial_state: Set[str],
     goal_state: Set[str],
     actions: List[ResearchAction] = None,
     verification_mode: VerificationMode = VerificationMode.MODERATE,
-    max_iterations: int = 1000
-) -> Optional[ResearchPlan]:
+    max_iterations: Optional[int] = None,
+    max_seconds: Optional[float] = None
+) -> Union[ResearchPlan, "PlanNotFound"]:
     """
     A* search to find optimal research plan with verification support.
-    
+
     Args:
         initial_state: Starting conditions
         goal_state: Target conditions to achieve
         actions: Available actions (defaults to RESEARCH_ACTIONS)
         verification_mode: How strict to be about verification
-        max_iterations: Maximum search iterations
-    
+        max_iterations: Maximum search iterations. ``None`` (the default)
+            selects an adaptive budget calibrated per verification mode and
+            goal-set size (see ``_default_max_iterations``); an explicit value
+            is respected unchanged.
+        max_seconds: Optional wall-clock ceiling for the search, independent
+            of the iteration count. ``None`` (the default) keeps the search
+            deterministic (bounded only by ``max_iterations``) — note that on
+            the FAILURE path this means the full iteration budget is burned
+            (measured: ~7-10s at the default STRICT budget of 100,000 for a
+            goal the verification gate never accepts). Latency-sensitive
+            callers should pass a ceiling (e.g. ``max_seconds=2.0``); hitting
+            it returns SEARCH_EXHAUSTED with the ceiling named in the message.
+
     Returns:
-        ResearchPlan object or None if no plan found
+        ResearchPlan on success, otherwise a PlanNotFound whose ``verdict``
+        distinguishes:
+        - PlanVerdict.GOAL_UNREACHABLE — proven: no action sequence can ever
+          satisfy the goal (decided promptly by a reachability closure, or by
+          exhaustive exploration of the state space).
+        - PlanVerdict.SEARCH_EXHAUSTED — the iteration budget (or the
+          ``max_seconds`` wall-clock ceiling) ran out before a plan was found;
+          ``iterations`` carries the iterations spent. This verdict is an
+          honest "don't know": the relaxed closure passing means the goal is
+          not PROVABLY unreachable, but it is NOT a guarantee that any budget
+          will find a plan — the closure ignores the verification-mode gate,
+          which can permanently reject every path (see the
+          ``_reachability_closure`` soundness note).
+        Branch on ``isinstance(result, ResearchPlan)`` — never on truthiness
+        alone (PlanNotFound is falsy only as a legacy safety net), and NEVER
+        on ``result is None`` (this function no longer returns ``None``; an
+        identity check reads a no-plan result as success).
     """
     if actions is None:
         actions = RESEARCH_ACTIONS
-    
+
+    if max_iterations is None:
+        max_iterations = _default_max_iterations(goal_state, verification_mode)
+
     # Check if goal already satisfied
     if goal_state.issubset(initial_state):
         return ResearchPlan(
@@ -361,7 +510,24 @@ def find_research_plan(
             estimated_confidence=1.0,
             unsigned_claims_count=0
         )
-    
+
+    # Prompt unreachability proof, independent of max_iterations: if the goal
+    # is not inside the delete-free closure, no budget can ever reach it.
+    closure = _reachability_closure(initial_state, actions)
+    if not goal_state.issubset(closure):
+        missing = sorted(goal_state - closure)
+        return PlanNotFound(
+            verdict=PlanVerdict.GOAL_UNREACHABLE,
+            message=(
+                "Goal is provably unreachable from the initial state: no sequence of "
+                f"available actions can ever produce {missing}. "
+                "Raising max_iterations cannot help. If the missing facts are "
+                "deployment capabilities (e.g. issuer_keys_available, "
+                "source_class_verified), they must be supplied in the initial state "
+                "by a real integration — the planner cannot manufacture them."
+            )
+        )
+
     # Priority queue
     start_h = heuristic(initial_state, goal_state)
     open_set = [PlanNode(start_h, 0, frozenset(initial_state), [], 0)]
@@ -372,8 +538,17 @@ def find_research_plan(
     # Verification settings
     require_verification = verification_mode in [VerificationMode.STRICT, VerificationMode.PARANOID]
     
+    # Optional wall-clock ceiling (GAP-6): independent of the iteration count,
+    # so a latency-sensitive caller is not forced to burn the full (large)
+    # adaptive budget on a goal the verification gate never accepts.
+    deadline = None if max_seconds is None else time.perf_counter() + max_seconds
+    time_ceiling_hit = False
+
     iterations = 0
     while open_set and iterations < max_iterations:
+        if deadline is not None and time.perf_counter() >= deadline:
+            time_ceiling_hit = True
+            break
         iterations += 1
         
         current = heapq.heappop(open_set)
@@ -441,8 +616,54 @@ def find_research_plan(
                         unsigned_claims=new_unsigned
                     )
                     heapq.heappush(open_set, new_node)
-    
-    return None  # No plan found
+
+    # No plan found — distinguish WHY (never conflate the two exits):
+    if open_set:
+        # Budget (iterations or wall clock) hit with work remaining: an honest
+        # "don't know yet". The relaxed closure passing means the goal is NOT
+        # PROVABLY unreachable — it does NOT mean a larger budget will find a
+        # plan: the closure ignores the verification-mode unsigned-claims
+        # gate, which (especially in strict/paranoid mode) can permanently
+        # reject every path to the goal (see _reachability_closure's
+        # soundness note; this message must never over-claim past it).
+        if time_ceiling_hit:
+            stopped = (
+                f"Search stopped by the wall-clock ceiling (max_seconds={max_seconds}) "
+                f"after {iterations} iterations without finding a plan."
+            )
+        else:
+            stopped = (
+                f"Search exhausted after {iterations} iterations without finding a plan."
+            )
+        return PlanNotFound(
+            verdict=PlanVerdict.SEARCH_EXHAUSTED,
+            iterations=iterations,
+            message=(
+                stopped + " The relaxed reachability closure passed, so the goal is "
+                "not provably unreachable — but that is NOT a guarantee that a larger "
+                "budget will find a plan: the closure ignores the verification-mode "
+                "unsigned-claims gate, which can permanently reject every path to the "
+                "goal (especially in strict/paranoid mode). A retry with a higher "
+                f"max_iterations (e.g. max_iterations={max(iterations, 1) * 10}) MAY "
+                "succeed; if repeated increases keep exhausting, treat the goal as "
+                "unreachable under the active verification constraints instead of "
+                "raising the budget further."
+            )
+        )
+    # open_set genuinely emptied: the search exhaustively explored every
+    # reachable state without accepting a goal node — a second, stronger,
+    # exhaustive proof of unreachability under the active verification
+    # constraints (the relaxed closure ignores those constraints, so both
+    # outcomes are consistent).
+    return PlanNotFound(
+        verdict=PlanVerdict.GOAL_UNREACHABLE,
+        message=(
+            "Search space exhaustively explored (open set emptied) without a plan "
+            "satisfying the active verification constraints — the goal is "
+            "unreachable under the current verification mode; raising "
+            "max_iterations cannot help."
+        )
+    )
 
 
 def format_plan(plan: ResearchPlan, action_library: List[ResearchAction] = None) -> str:
@@ -607,14 +828,24 @@ class GOAPResearchPlanner:
     def __init__(
         self,
         verification_mode: str = "moderate",
-        trusted_issuers: Optional[List[str]] = None
+        trusted_issuers: Optional[List[str]] = None,
+        issuer_keys_available: bool = False,
+        source_class_verified: bool = False
     ):
         """
         Initialize planner.
-        
+
         Args:
             verification_mode: 'development', 'moderate', 'strict', or 'paranoid'
-            trusted_issuers: List of trusted issuer domains
+            trusted_issuers: List of trusted issuer domains (informational — a
+                list of domain strings is NOT evidence of key possession)
+            issuer_keys_available: True only when real Ed25519 key material for
+                the configured issuers genuinely exists. Default False — the
+                package's honest default, since no real issuer keys exist for
+                PubMed/PMC/DOI/WHO.
+            source_class_verified: True only for source classes actually
+                capable of Ed25519-signed delivery. Default False for the same
+                reason.
         """
         mode_map = {
             "development": VerificationMode.DEVELOPMENT,
@@ -624,38 +855,56 @@ class GOAPResearchPlanner:
         }
         self.verification_mode = mode_map.get(verification_mode.lower(), VerificationMode.MODERATE)
         self.trusted_issuers = trusted_issuers or []
+        self.issuer_keys_available = issuer_keys_available
+        self.source_class_verified = source_class_verified
         self.verification_ledger: List[VerificationResult] = []
     
     def plan(
         self,
         goal_type: str,
         topic: str,
-        custom_goals: Optional[Set[str]] = None
-    ) -> Optional[ResearchPlan]:
+        custom_goals: Optional[Set[str]] = None,
+        max_seconds: Optional[float] = None
+    ) -> Union[ResearchPlan, PlanNotFound]:
         """
         Generate research plan for given goal type.
-        
+
         Args:
             goal_type: Type of research (see create_research_goal)
             topic: Research topic (for logging)
             custom_goals: Override default goals
-        
+            max_seconds: Optional wall-clock ceiling for the search (see
+                find_research_plan) — bounds failure-path latency, which
+                otherwise burns the full adaptive iteration budget.
+
         Returns:
-            ResearchPlan or None
+            ResearchPlan on success, or PlanNotFound with a verdict
+            (PlanVerdict.GOAL_UNREACHABLE — proven impossible; or
+            PlanVerdict.SEARCH_EXHAUSTED — budget ran out; a retry with a
+            higher max_iterations MAY succeed, but is not guaranteed to — the
+            verification gate can permanently reject every path). Branch on
+            ``isinstance(result, ResearchPlan)`` — never on ``result is None``
+            (this method no longer returns ``None``; an identity check reads a
+            no-plan result as success).
         """
         initial, goal = create_research_goal(goal_type, self.verification_mode)
-        
+
         if custom_goals:
             goal = custom_goals
-        
-        # Add verification-related initial state if configured
-        if self.trusted_issuers:
-            initial.add("whitelist_available")
-        
+
+        # Deployment capability facts are initial-state-only: no action can
+        # produce them (see the RESEARCH_ACTIONS setup note). Each is added
+        # only when the deployment genuinely provides it.
+        if self.issuer_keys_available:
+            initial.add("issuer_keys_available")
+        if self.source_class_verified:
+            initial.add("source_class_verified")
+
         return find_research_plan(
             initial_state=initial,
             goal_state=goal,
-            verification_mode=self.verification_mode
+            verification_mode=self.verification_mode,
+            max_seconds=max_seconds
         )
     
     def format_plan(self, plan: ResearchPlan) -> str:
@@ -679,42 +928,63 @@ if __name__ == "__main__":
     initial, goal = create_research_goal("exploratory", VerificationMode.MODERATE)
     print(f"Initial State: {initial}")
     print(f"Goal State: {goal}")
-    
+
     plan = find_research_plan(initial, goal, verification_mode=VerificationMode.MODERATE)
-    if plan:
+    if isinstance(plan, ResearchPlan):
         print(format_plan(plan))
     else:
-        print("No plan found!")
-    
+        print(f"No plan: {plan.verdict.value} — {plan.message}")
+
     # Example 2: High-stakes verified research
     print("\n\n[2] HIGH-STAKES VERIFIED RESEARCH (Strict Mode)")
     print("-" * 50)
-    
+
     initial, goal = create_research_goal("high_stakes", VerificationMode.STRICT)
     print(f"Initial State: {initial}")
     print(f"Goal State: {goal}")
-    
+
+    # Honest default: no real Ed25519 issuer keys exist for the package's
+    # actual health sources (PubMed/PMC/DOI/WHO), so high_stakes is provably
+    # unreachable — reported as a first-class verdict, not a fabricated plan.
+    print("\n[2a] Honest default (no issuer keys):")
     plan = find_research_plan(initial, goal, verification_mode=VerificationMode.STRICT)
-    if plan:
+    if isinstance(plan, ResearchPlan):
         print(format_plan(plan))
     else:
-        print("No plan found!")
-    
+        print(f"No plan: {plan.verdict.value} — {plan.message}")
+
+    # With a real signed-source integration (issuer key material genuinely
+    # held AND a source class capable of signed delivery), the same goal is
+    # reachable at the DEFAULT adaptive budget:
+    print("\n[2b] With real signed-source integration (issuer_keys_available + source_class_verified):")
+    initial_with_keys = initial | {"issuer_keys_available", "source_class_verified"}
+    plan = find_research_plan(initial_with_keys, goal, verification_mode=VerificationMode.STRICT)
+    if isinstance(plan, ResearchPlan):
+        print(format_plan(plan))
+    else:
+        print(f"No plan: {plan.verdict.value} — {plan.message}")
+
     # Example 3: Using the high-level planner interface
     print("\n\n[3] HIGH-LEVEL PLANNER INTERFACE")
     print("-" * 50)
-    
+
     planner = GOAPResearchPlanner(
         verification_mode="strict",
-        trusted_issuers=["reuters.com", "nature.com", "arxiv.org"]
+        trusted_issuers=["reuters.com", "nature.com", "arxiv.org"],
+        # Test-double capability flags simulating a real signed-source
+        # integration; the honest default for both is False.
+        issuer_keys_available=True,
+        source_class_verified=True
     )
-    
+
     plan = planner.plan(
         goal_type="verified_exploratory",
         topic="AI safety regulations 2025"
     )
-    
-    if plan:
+
+    if isinstance(plan, ResearchPlan):
         print(planner.format_plan(plan))
         print("\nJSON Export:")
         print(planner.export_plan(plan))
+    else:
+        print(f"No plan: {plan.verdict.value} — {plan.message}")