@heretek-ai/epistemic-swarm 0.1.0

package/runner/state_machine.py

@@ -0,0 +1,192 @@
+#!/usr/bin/env python3
+"""
+Filesystem IPC Protocol & State Machine for Epistemic Swarm.
+Manages .research/ hierarchy, session state, scope DAG, and dossier serialization.
+"""
+
+import os
+import json
+import threading
+import tempfile
+from enum import Enum
+from pathlib import Path
+from datetime import datetime, timezone
+from typing import Dict, Any, List, Optional
+
+class SessionStatus(str, Enum):
+    INITIALIZING = "INITIALIZING"
+    FRONTIER_SETTLING = "FRONTIER_SETTLING"
+    ORCHESTRATING = "ORCHESTRATING"
+    SWARM_DISPATCHED = "SWARM_DISPATCHED"
+    AUDITING = "AUDITING"
+    COMPLETED = "COMPLETED"
+    FAILED = "FAILED"
+
+class ScopeStatus(str, Enum):
+    PENDING = "PENDING"
+    ALPHA_RUNNING = "ALPHA_RUNNING"
+    BETA_RUNNING = "BETA_RUNNING"
+    RUNNING_PARALLEL = "RUNNING_PARALLEL"
+    ALPHA_COMPLETE = "ALPHA_COMPLETE"
+    BETA_COMPLETE = "BETA_COMPLETE"
+    DOSSIERS_READY = "DOSSIERS_READY"
+    AUDITING = "AUDITING"
+    COMPLETE = "COMPLETE"
+    FAILED = "FAILED"
+
+class ResearchStateMachine:
+    def __init__(self, base_dir: Optional[Path] = None):
+        self.base_dir = base_dir or Path(".research")
+        self.scratchpads_dir = self.base_dir / "scratchpads"
+        self.sources_dir = self.base_dir / "sources"
+        self.manifest_file = self.base_dir / "manifest.json"
+        self._lock = threading.Lock()
+        
+        # Ensure directories exist
+        self.scratchpads_dir.mkdir(parents=True, exist_ok=True)
+        self.sources_dir.mkdir(parents=True, exist_ok=True)
+
+    def init_session(self, objective: str, session_id: Optional[str] = None) -> Dict[str, Any]:
+        """Initialize or reset a research session manifest."""
+        sid = session_id or f"session-{datetime.now(timezone.utc).strftime('%Y%m%d-%H%M%S')}"
+        manifest = {
+            "session_id": sid,
+            "objective": objective,
+            "status": SessionStatus.INITIALIZING.value,
+            "created_at": datetime.now(timezone.utc).isoformat(),
+            "updated_at": datetime.now(timezone.utc).isoformat(),
+            "scopes": [],
+            "telemetry": {
+                "total_scopes": 0,
+                "completed_scopes": 0,
+                "total_claims_audited": 0,
+                "total_verified_claims": 0,
+                "total_rejected_claims": 0,
+                "mean_epistemic_score": 0.0,
+                "mean_divergence_score": 0.0
+            }
+        }
+        self.save_global_manifest(manifest)
+        return manifest
+
+    def load_global_manifest(self) -> Dict[str, Any]:
+        with self._lock:
+            if not self.manifest_file.exists():
+                raise FileNotFoundError(f"Global manifest not found at {self.manifest_file}")
+            with open(self.manifest_file, "r", encoding="utf-8") as f:
+                return json.load(f)
+
+    def save_global_manifest(self, manifest: Dict[str, Any]):
+        with self._lock:
+            manifest["updated_at"] = datetime.now(timezone.utc).isoformat()
+            temp_path = self.manifest_file.with_suffix(".tmp")
+            with open(temp_path, "w", encoding="utf-8") as f:
+                json.dump(manifest, f, indent=2)
+            os.replace(temp_path, self.manifest_file)
+
+    def update_session_status(self, status: SessionStatus):
+        manifest = self.load_global_manifest()
+        manifest["status"] = status.value
+        self.save_global_manifest(manifest)
+
+    def set_scopes(self, scopes: List[Dict[str, Any]]):
+        """Set scopes decomposed by orchestrator and prepare scratchpads."""
+        manifest = self.load_global_manifest()
+        manifest["scopes"] = scopes
+        manifest["telemetry"]["total_scopes"] = len(scopes)
+        self.save_global_manifest(manifest)
+
+        for scope in scopes:
+            scope_id = scope["scope_id"]
+            scope_dir = self.scratchpads_dir / scope_id
+            scope_dir.mkdir(parents=True, exist_ok=True)
+            
+            scope_manifest = {
+                "scope_id": scope_id,
+                "title": scope.get("title", ""),
+                "objective": scope.get("objective", ""),
+                "dependencies": scope.get("dependencies", []),
+                "status": ScopeStatus.PENDING.value,
+                "alpha_completed": False,
+                "beta_completed": False,
+                "audit_completed": False,
+                "created_at": datetime.now(timezone.utc).isoformat()
+            }
+            temp_scope_file = (scope_dir / "manifest.json").with_suffix(".tmp")
+            with open(temp_scope_file, "w", encoding="utf-8") as f:
+                json.dump(scope_manifest, f, indent=2)
+            os.replace(temp_scope_file, scope_dir / "manifest.json")
+
+    def get_scope_dir(self, scope_id: str) -> Path:
+        return self.scratchpads_dir / scope_id
+
+    def load_scope_manifest(self, scope_id: str) -> Dict[str, Any]:
+        with self._lock:
+            scope_manifest_file = self.get_scope_dir(scope_id) / "manifest.json"
+            if not scope_manifest_file.exists():
+                raise FileNotFoundError(f"Scope manifest not found for {scope_id}")
+            with open(scope_manifest_file, "r", encoding="utf-8") as f:
+                return json.load(f)
+
+    def save_scope_manifest(self, scope_id: str, manifest: Dict[str, Any]):
+        with self._lock:
+            scope_manifest_file = self.get_scope_dir(scope_id) / "manifest.json"
+            temp_path = scope_manifest_file.with_suffix(".tmp")
+            with open(temp_path, "w", encoding="utf-8") as f:
+                json.dump(manifest, f, indent=2)
+            os.replace(temp_path, scope_manifest_file)
+
+    def update_scope_status(self, scope_id: str, status: ScopeStatus):
+        sm = self.load_scope_manifest(scope_id)
+        sm["status"] = status.value
+        self.save_scope_manifest(scope_id, sm)
+
+    def record_agent_completion(self, scope_id: str, agent_type: str, dossier_data: Dict[str, Any]):
+        """Records dossier from Alpha or Beta and advances scope state machine."""
+        scope_dir = self.get_scope_dir(scope_id)
+
+        if agent_type.lower() in ["alpha", "thesis", "proponent"]:
+            filename = "alpha_dossier.json"
+            is_alpha = True
+        elif agent_type.lower() in ["beta", "antithesis", "adversary", "red_team"]:
+            filename = "beta_dossier.json"
+            is_alpha = False
+        else:
+            raise ValueError(f"Unknown agent type: {agent_type}")
+
+        temp_dossier = (scope_dir / filename).with_suffix(".tmp")
+        with open(temp_dossier, "w", encoding="utf-8") as f:
+            json.dump(dossier_data, f, indent=2)
+        os.replace(temp_dossier, scope_dir / filename)
+
+        sm = self.load_scope_manifest(scope_id)
+        if is_alpha:
+            sm["alpha_completed"] = True
+        else:
+            sm["beta_completed"] = True
+
+        if sm.get("alpha_completed") and sm.get("beta_completed"):
+            sm["status"] = ScopeStatus.DOSSIERS_READY.value
+        elif sm.get("alpha_completed"):
+            sm["status"] = ScopeStatus.ALPHA_COMPLETE.value
+        elif sm.get("beta_completed"):
+            sm["status"] = ScopeStatus.BETA_COMPLETE.value
+
+        self.save_scope_manifest(scope_id, sm)
+
+    def get_ready_scopes(self) -> List[Dict[str, Any]]:
+        """Return scopes whose dependencies are completed and status is PENDING."""
+        manifest = self.load_global_manifest()
+        ready = []
+        completed_scope_ids = {
+            s["scope_id"] for s in manifest["scopes"] 
+            if self.load_scope_manifest(s["scope_id"]).get("status") == ScopeStatus.COMPLETE.value
+        }
+
+        for scope in manifest["scopes"]:
+            sm = self.load_scope_manifest(scope["scope_id"])
+            if sm["status"] == ScopeStatus.PENDING.value:
+                deps = set(scope.get("dependencies", []))
+                if deps.issubset(completed_scope_ids):
+                    ready.append(scope)
+        return ready

package/runner/tests/test_swarm.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+"""
+Unit and integration test suite for Epistemic Swarm.
+Tests source hashing, state machine IPC transitions, auditor engine, and swarm mock dispatch.
+"""
+
+import sys
+import shutil
+import tempfile
+import unittest
+from pathlib import Path
+
+# Add project root to sys.path
+PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
+sys.path.insert(0, str(PROJECT_ROOT))
+
+from skills.research_cache.hasher import SourceHasher
+from runner.state_machine import ResearchStateMachine, SessionStatus, ScopeStatus
+from runner.auditor_engine import EpistemicAuditorEngine
+from runner.research_swarm import SwarmRunner
+
+class TestEpistemicSwarm(unittest.TestCase):
+    def setUp(self):
+        self.test_dir = Path(tempfile.mkdtemp(prefix="epistemic_test_"))
+        self.hasher = SourceHasher(base_dir=self.test_dir)
+        self.state_machine = ResearchStateMachine(base_dir=self.test_dir)
+        self.auditor = EpistemicAuditorEngine(base_dir=self.test_dir)
+
+    def tearDown(self):
+        shutil.rmtree(self.test_dir, ignore_errors=True)
+
+    def test_source_hasher_and_quote_verification(self):
+        content = """# Deep Learning Scaling Laws
+Empirical measurements show that compute-optimal models scale loss as L(N) = (N_c / N)^alpha_N.
+In our experiments, the 70B parameter model was trained on 15.0 trillion tokens.
+"""
+        shash = self.hasher.store_source(
+            url="https://arxiv.org/abs/2203.15556",
+            content=content,
+            title="Chinchilla Scaling Laws"
+        )
+        self.assertTrue(len(shash) == 64)
+
+        # 1. Exact quote match
+        verified, conf, msg = self.hasher.verify_quote(
+            shash, "the 70B parameter model was trained on 15.0 trillion tokens."
+        )
+        self.assertTrue(verified)
+        self.assertGreaterEqual(conf, 0.95)
+
+        # 2. Normalized whitespace match
+        verified_norm, conf_norm, _ = self.hasher.verify_quote(
+            shash, "the   70B parameter model was\ntrained on 15.0 trillion tokens."
+        )
+        self.assertTrue(verified_norm)
+
+        # 3. Fabricated quote rejection
+        verified_fake, conf_fake, _ = self.hasher.verify_quote(
+            shash, "the 70B parameter model was trained on 500 quadrillion tokens by aliens."
+        )
+        self.assertFalse(verified_fake)
+        self.assertLess(conf_fake, 0.8)
+
+    def test_state_machine_transitions_and_dag(self):
+        self.state_machine.init_session("Evaluate rollup throughput")
+        scopes = [
+            {
+                "scope_id": "scope_01_prover",
+                "title": "Prover Benchmarks",
+                "dependencies": []
+            },
+            {
+                "scope_id": "scope_02_recursion",
+                "title": "Recursive Verification",
+                "dependencies": ["scope_01_prover"]
+            }
+        ]
+        self.state_machine.set_scopes(scopes)
+
+        # Initially, only scope_01 should be ready
+        ready = self.state_machine.get_ready_scopes()
+        self.assertEqual(len(ready), 1)
+        self.assertEqual(ready[0]["scope_id"], "scope_01_prover")
+
+        # Mark scope_01 complete
+        self.state_machine.update_scope_status("scope_01_prover", ScopeStatus.COMPLETE)
+
+        # Now scope_02 should be ready
+        ready_after = self.state_machine.get_ready_scopes()
+        self.assertEqual(len(ready_after), 1)
+        self.assertEqual(ready_after[0]["scope_id"], "scope_02_recursion")
+
+    def test_epistemic_auditor_scoring_and_downgrade(self):
+        # 1. Seed cached source
+        shash = self.hasher.store_source(
+            url="https://benchmark.org/zk",
+            content="FPGA prover executes Poseidon in 184ms.",
+            title="ZK Benchmarks"
+        )
+
+        # 2. Initialize scope
+        self.state_machine.init_session("Test Objective")
+        self.state_machine.set_scopes([{"scope_id": "scope_test", "dependencies": []}])
+
+        # 3. Create Alpha Dossier with 1 verified and 1 fake quote
+        alpha_dossier = {
+            "agent": "Agent Alpha",
+            "scope_id": "scope_test",
+            "affirmative_claims": [
+                {
+                    "claim_id": "A1",
+                    "tag": "VERIFIED",
+                    "statement": "Poseidon prover executes in 184ms",
+                    "source_hash": shash,
+                    "verbatim_quote": "FPGA prover executes Poseidon in 184ms."
+                },
+                {
+                    "claim_id": "A2",
+                    "tag": "VERIFIED",
+                    "statement": "Hallucinated claim that does not exist in source",
+                    "source_hash": shash,
+                    "verbatim_quote": "This string does not exist anywhere in the text."
+                }
+            ],
+            "negative_knowledge": [{"query": "q1", "finding": "None"}]
+        }
+
+        # 4. Create Beta Dossier
+        beta_dossier = {
+            "agent": "Agent Beta",
+            "scope_id": "scope_test",
+            "falsification_claims": [],
+            "methodological_critiques": [
+                {
+                    "target_assertion": "Poseidon prover executes in 184ms",
+                    "critique": "Benchmark excludes PCIe host bus latency"
+                }
+            ],
+            "negative_knowledge": []
+        }
+
+        self.state_machine.record_agent_completion("scope_test", "alpha", alpha_dossier)
+        self.state_machine.record_agent_completion("scope_test", "beta", beta_dossier)
+
+        # 5. Run Auditor
+        report = self.auditor.audit_scope("scope_test")
+        summary = report["summary"]
+
+        self.assertEqual(summary["verified_passed"], 1)
+        self.assertEqual(summary["unverified_rejected"], 1)
+        self.assertEqual(summary["negative_knowledge_count"], 1)
+        self.assertGreater(summary["divergence_score"], 0.0)
+
+        # Check synthesis markdown generated
+        synth_file = self.test_dir / "scratchpads" / "scope_test" / "scope_synthesis.md"
+        self.assertTrue(synth_file.exists())
+        with open(synth_file, "r") as f:
+            synth_content = f.read()
+            self.assertIn("PURGED", synth_content)
+            self.assertIn("Poseidon prover executes in 184ms", synth_content)
+
+    def test_mock_swarm_runner_end_to_end(self):
+        runner = SwarmRunner(base_dir=self.test_dir, mock_mode=True)
+        runner.run_swarm("Evaluate hardware prover latency")
+
+        manifest = runner.state_machine.load_global_manifest()
+        self.assertEqual(manifest["status"], SessionStatus.COMPLETED.value)
+
+        final_report = self.test_dir / "final_synthesis.md"
+        self.assertTrue(final_report.exists())
+        with open(final_report, "r") as f:
+            report_text = f.read()
+            self.assertIn("Master Epistemic Research Report", report_text)
+            self.assertIn("Swarm Epistemic Audit Totals", report_text)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/grilling/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: grilling
+description: Socratic grilling and assumption-inversion skill for deep research. Uses Matt Pocock-style design trees to explore the problem frontier divergently before committing to search queries.
+---
+
+# Socratic Grilling & Divergent Research Framing
+
+Interview the user relentlessly until you reach an airtight, shared understanding of the research scope. Map the problem as a **design tree**: every foundational assumption branches into the technical decisions and empirical hypotheses that hang off it.
+
+## 1. THE FRONTIER METHODOLOGY
+
+1. Work the tree in **rounds**.
+2. The **frontier** is every decision whose prerequisites are already settled: the questions you can ask *now* without guessing at answers you haven't heard yet.
+3. Ask the whole frontier in one round: number each question and provide your recommended answer.
+4. Then wait for the user's answers before moving to the next round.
+
+## 2. FORMATTING A ROUND
+
+```
+❓ **Q1 - <Question Title>**: <Question context, premise inversion, trade-offs, multiple options>
+
+➡️ **Recommended**: <Your recommended answer with rationale>
+
+---
+
+❓ **Q2 - <Question Title>**: <Question context, trade-offs>
+
+➡️ **Recommended**: <Your recommended answer with rationale>
+```
+
+## 3. FACTUAL VS. DECISIONAL SEPARATION
+
+- **Facts are the agent's job**: When a frontier question hinges on an empirical fact (e.g. library benchmarks, API specs, hardware limits), **DO NOT ASK THE USER**. Dispatch a tool call or subagent to look it up in the codebase or online.
+- **Decisions are the user's**: High-level trade-offs, architectural philosophy, threat models, and priority ranking belong to the user. Put each decision to them clearly.
+
+## 4. ASSUMPTION INVERSION TACTICS
+
+Always challenge default premises in Round 1:
+- *Inversion*: What if the primary objective is rendered obsolete by a radical alternative?
+- *Scale Extremes*: What breaks at 100x scale? What breaks at 0 resources?
+- *Adversarial Posture*: How would an intelligent adversary exploit or falsify this design?
+
+## 5. FRONTIER RESOLUTION & FREEZING
+
+When every branch of the design tree has been visited and the frontier is empty:
+1. Summarize the settled constraints.
+2. Save the settled state to `.research/frontier.json` using `python3 skills/grilling/socratic_tree.py --export`.
+3. Hand off the settled frontier to the **Swarm Orchestrator** to begin empirical dialectic execution.

package/skills/grilling/socratic_tree.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""
+Socratic Tree & Decision Frontier Engine for Epistemic Swarm.
+Implements Matt Pocock-style design tree traversal to isolate the active decision frontier.
+"""
+
+import sys
+import json
+import argparse
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+
+class DecisionNode:
+    def __init__(self, node_id: str, title: str, question: str, 
+                 recommended: str, options: Optional[List[str]] = None,
+                 prerequisites: Optional[List[str]] = None):
+        self.node_id = node_id
+        self.title = title
+        self.question = question
+        self.recommended = recommended
+        self.options = options or []
+        self.prerequisites = prerequisites or []
+        self.settled_answer: Optional[str] = None
+
+    def is_settled(self) -> bool:
+        return self.settled_answer is not None
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "node_id": self.node_id,
+            "title": self.title,
+            "question": self.question,
+            "recommended": self.recommended,
+            "options": self.options,
+            "prerequisites": self.prerequisites,
+            "settled_answer": self.settled_answer
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'DecisionNode':
+        node = cls(
+            node_id=data["node_id"],
+            title=data["title"],
+            question=data["question"],
+            recommended=data["recommended"],
+            options=data.get("options", []),
+            prerequisites=data.get("prerequisites", [])
+        )
+        node.settled_answer = data.get("settled_answer")
+        return node
+
+
+class DesignTree:
+    def __init__(self, objective: str):
+        self.objective = objective
+        self.nodes: Dict[str, DecisionNode] = {}
+
+    def add_node(self, node: DecisionNode):
+        self.nodes[node.node_id] = node
+
+    def compute_frontier(self) -> List[DecisionNode]:
+        """
+        The frontier is all unsettled nodes whose prerequisites are ALL settled.
+        """
+        frontier = []
+        for node in self.nodes.values():
+            if node.is_settled():
+                continue
+            prereqs_met = True
+            for prereq_id in node.prerequisites:
+                prereq_node = self.nodes.get(prereq_id)
+                if not prereq_node or not prereq_node.is_settled():
+                    prereqs_met = False
+                    break
+            if prereqs_met:
+                frontier.append(node)
+        return frontier
+
+    def settle_node(self, node_id: str, answer: str):
+        if node_id in self.nodes:
+            self.nodes[node_id].settled_answer = answer
+
+    def is_complete(self) -> bool:
+        return len(self.compute_frontier()) == 0 and all(n.is_settled() for n in self.nodes.values())
+
+    def export_frontier_json(self, output_path: Path):
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        data = {
+            "objective": self.objective,
+            "is_complete": self.is_complete(),
+            "nodes": {k: v.to_dict() for k, v in self.nodes.items()},
+            "settled_constraints": {
+                k: v.settled_answer for k, v in self.nodes.items() if v.is_settled()
+            }
+        }
+        with open(output_path, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2)
+
+    @classmethod
+    def load_from_json(cls, file_path: Path) -> 'DesignTree':
+        with open(file_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        tree = cls(objective=data["objective"])
+        for k, v in data.get("nodes", {}).items():
+            tree.add_node(DecisionNode.from_dict(v))
+        return tree
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Epistemic Swarm Socratic Decision Tree")
+    parser.add_argument("--objective", type=str, help="Research objective")
+    parser.add_argument("--file", type=str, default=".research/frontier.json", help="Path to frontier.json")
+    parser.add_argument("--show-frontier", action="store_true", help="Print the current decision frontier")
+    parser.add_argument("--settle", nargs=2, metavar=("NODE_ID", "ANSWER"), help="Settle a decision node")
+    
+    args = parser.parse_args()
+    frontier_path = Path(args.file)
+
+    if frontier_path.exists():
+        tree = DesignTree.load_from_json(frontier_path)
+    else:
+        objective = args.objective or "Epistemic Swarm Research Objective"
+        tree = DesignTree(objective=objective)
+
+    if args.settle:
+        node_id, answer = args.settle
+        tree.settle_node(node_id, answer)
+        tree.export_frontier_json(frontier_path)
+        print(f"Settled {node_id} -> {answer}")
+
+    frontier = tree.compute_frontier()
+    if args.show_frontier or not args.settle:
+        print(f"\n🎯 Objective: {tree.objective}")
+        print(f"📊 Total Nodes: {len(tree.nodes)} | Settled: {sum(1 for n in tree.nodes.values() if n.is_settled())}")
+        if not frontier:
+            if tree.nodes and tree.is_complete():
+                print("✅ Frontier is EMPTY. All prerequisite branches are fully settled!")
+            else:
+                print("ℹ️ No active frontier nodes. Define new decision nodes to begin grilling.")
+        else:
+            print(f"\n⚡ Current Active Frontier ({len(frontier)} questions ready):")
+            for idx, node in enumerate(frontier, 1):
+                print(f"\n❓ Q{idx} [{node.node_id}] - {node.title}")
+                print(f"   {node.question}")
+                print(f"   ➡️ Recommended: {node.recommended}")
+
+if __name__ == "__main__":
+    main()

package/skills/research-cache/SKILL.md

@@ -0,0 +1,36 @@
+---
+name: research-cache
+description: Content-addressed document caching and quote verification skill. Hashes retrieved web pages and academic papers to SHA-256 for mathematical auditability.
+---
+
+# Content-Addressed Research Cache & Verification
+
+To maintain epistemic integrity, every document fetched from the web, arXiv, or technical docs must be cached locally with a content-addressed SHA-256 fingerprint before its claims can be cited.
+
+## 1. CACHING A SOURCE
+When you fetch or scrape a URL:
+```bash
+python3 skills/research-cache/hasher.py cache \
+  --url "https://arxiv.org/abs/2407.21783" \
+  --title "Llama 3 Herd of Models" \
+  --content "$(cat fetched_paper.md)"
+```
+This prints the content hash:
+```
+[CACHED] 3f8a9e21... -> .research/sources/3f8a9e21....md
+```
+
+## 2. CITING WITH HASHES
+In your dossiers and markdown reports, cite the claim using the hash:
+`[VERIFIED: 3f8a9e21]`
+
+Ensure that any `verbatim_quote` you provide is an exact substring from the cached markdown document.
+
+## 3. AUDITING A QUOTE
+The Epistemic Auditor verifies claims using:
+```bash
+python3 skills/research-cache/hasher.py verify \
+  --hash "3f8a9e21..." \
+  --quote "Our FPGA pipeline executes the Poseidon round constraints in 184ms"
+```
+If the quote does not match, the claim is rejected and flagged as unverified.