@heretek-ai/epistemic-swarm 0.7.0 → 0.7.2

package/runner/living_dossiers.py

@@ -208,7 +208,9 @@ def append_ledger(base_dir: Path, events: List[StatusEvent]) -> Path:
     return path
 
 
-def queue_requeue(base_dir: Path, scope_id: str, reason: str = "claim degradation") -> Path:
+def queue_requeue(
+    base_dir: Path, scope_id: str, reason: str = "claim degradation"
+) -> Path:
     """Record that a scope needs a re-run on the next swarm pass."""
     path = Path(base_dir) / "requeue.json"
     entries: List[Dict[str, Any]] = []
@@ -248,7 +250,52 @@ def load_requeue(base_dir: Path) -> List[Dict[str, Any]]:
 # ---- one-pass staleness check (the probe's unit of work) ----------------
 
 
-def check_staleness(base_dir: Path, scope_ids: Optional[List[str]] = None) -> Dict[str, Any]:
+def _scope_dirs_for(scratch: Path, scope_ids: Optional[List[str]]):
+    """Scope dirs to fold; None means the workspace has no scratchpad yet."""
+    if scope_ids is not None:
+        return [scratch / s for s in scope_ids]
+    if not scratch.exists():
+        return None
+    return sorted(p for p in scratch.iterdir() if p.is_dir())
+
+
+def _fold_scope(scope_dir: Path, retractions) -> Tuple[List[StatusEvent], int, bool]:
+    """Fold one scope's dossiers: (events, claim_sets, degraded)."""
+    from runner.claim_witness import claims_from_dossier, load_dossier
+
+    events: List[StatusEvent] = []
+    claim_sets = 0
+    for dossier_name in ("alpha_dossier.json", "beta_dossier.json"):
+        dpath = scope_dir / dossier_name
+        if not dpath.exists():
+            continue
+        claim_sets += 1
+        claims = claims_from_dossier(load_dossier(dpath))
+        _, scope_events = apply_degradation(
+            claims, retractions, scope_id=scope_dir.name
+        )
+        events.extend(scope_events)
+    return events, claim_sets, bool(events)
+
+
+def _mirror_events(base_dir: Path, events: List[StatusEvent]) -> None:
+    """Best-effort mirror into the derived claim store (never fatal)."""
+    try:
+        from runner.claim_store import ClaimStore
+
+        store = ClaimStore(base_dir)
+        for e in events:
+            store.record_status_event(
+                e.scope_id, e.claim_id, e.from_status, e.to_status, e.reason, e.at
+            )
+        store.close()
+    except Exception as exc:  # noqa: BLE001
+        print(f"[living-dossiers] claim store mirror skipped: {exc}", file=sys.stderr)
+
+
+def check_staleness(
+    base_dir: Path, scope_ids: Optional[List[str]] = None
+) -> Dict[str, Any]:
     """Run one degradation pass over scope dossiers.
 
     For each scope with alpha/beta dossiers, fold claims, join against
@@ -258,83 +305,54 @@ def check_staleness(base_dir: Path, scope_ids: Optional[List[str]] = None) -> Di
 
     Returns a summary dict suitable for JSON tool output.
     """
-    from runner.claim_witness import claims_from_dossier, load_dossier
-
     base_dir = Path(base_dir)
     retractions = load_retractions(base_dir)
     scratch = base_dir / "scratchpads"
 
-    if scope_ids is None:
-        if not scratch.exists():
-            return {
-                "scopes": [],
-                "retractions": len(retractions),
-                "degraded": 0,
-                # Keep the early return shape identical to the normal one so
-                # callers can key off `degraded_scopes` unconditionally.
-                "degraded_scopes": [],
-            }
-        scope_dirs = sorted(p for p in scratch.iterdir() if p.is_dir())
-    else:
-        scope_dirs = [scratch / s for s in scope_ids]
+    scope_dirs = _scope_dirs_for(scratch, scope_ids)
+    if scope_dirs is None:
+        return {
+            "scopes": [],
+            "retractions": len(retractions),
+            "degraded": 0,
+            # Keep the early return shape identical to the normal one so
+            # callers can key off `degraded_scopes` unconditionally.
+            "degraded_scopes": [],
+        }
 
     all_events: List[StatusEvent] = []
     per_scope: List[Dict[str, Any]] = []
-    degraded_scopes = set()
 
     for scope_dir in scope_dirs:
         if not scope_dir.is_dir():
             continue
-        scope_id = scope_dir.name
-        scope_event_count = 0
-        claim_sets = 0
-
-        for dossier_name in ("alpha_dossier.json", "beta_dossier.json"):
-            dpath = scope_dir / dossier_name
-            if not dpath.exists():
-                continue
-            claim_sets += 1
-            dossier = load_dossier(dpath)
-            claims = claims_from_dossier(dossier)
-            _, events = apply_degradation(
-                claims, retractions, scope_id=scope_id
-            )
-            all_events.extend(events)
-            scope_event_count += len(events)
-            if events:
-                degraded_scopes.add(scope_id)
-
+        events, claim_sets, degraded = _fold_scope(scope_dir, retractions)
+        all_events.extend(events)
         per_scope.append(
             {
-                "scope_id": scope_id,
+                "scope_id": scope_dir.name,
                 "claim_sets": claim_sets,
-                "status_events": scope_event_count,
-                "degraded": scope_id in degraded_scopes,
+                "status_events": len(events),
+                "degraded": degraded,
             }
         )
 
     if all_events:
         append_ledger(base_dir, all_events)
-        # Mirror into the derived claim store (best-effort; never fatal).
-        try:
-            from runner.claim_store import ClaimStore
-
-            store = ClaimStore(base_dir)
-            for e in all_events:
-                store.record_status_event(
-                    e.scope_id, e.claim_id, e.from_status, e.to_status, e.reason, e.at
-                )
-            store.close()
-        except Exception as exc:  # noqa: BLE001
-            print(f"[living-dossiers] claim store mirror skipped: {exc}", file=sys.stderr)
-
-    for scope_id in sorted(degraded_scopes):
-        queue_requeue(base_dir, scope_id, reason="claim degradation (retraction event)")
+        _mirror_events(base_dir, all_events)
+
+    for scope_dir in per_scope:
+        if scope_dir["degraded"]:
+            queue_requeue(
+                base_dir,
+                scope_dir["scope_id"],
+                reason="claim degradation (retraction event)",
+            )
 
     return {
         "retractions": len(retractions),
         "scopes": per_scope,
-        "degraded_scopes": sorted(degraded_scopes),
+        "degraded_scopes": sorted(s["scope_id"] for s in per_scope if s["degraded"]),
         "status_events": len(all_events),
     }
 

package/runner/mcp_server.py

@@ -68,8 +68,16 @@ DEFAULT_RESEARCH_DIR = ".research"
 
 
 def _resolve_base_dir(args: Dict[str, Any]) -> Path:
-    raw = args.get("base_dir") or args.get("dir") or DEFAULT_RESEARCH_DIR
-    return Path(os.path.realpath(str(raw)))
+    raw = args.get("base_dir") or args.get("dir")
+    if raw:
+        return Path(os.path.realpath(str(raw)))
+    # Project root wins over process cwd: a relative ".research" resolved
+    # against the MCP server's cwd escapes the project (observed live:
+    # evidence landed in ~/.research instead of the project tree).
+    project = os.environ.get("IUMBTEMS_PROJECT_DIR", "").strip()
+    if project and Path(project).is_dir():
+        return Path(os.path.realpath(os.path.join(project, DEFAULT_RESEARCH_DIR)))
+    return Path(os.path.realpath(DEFAULT_RESEARCH_DIR))
 
 
 def _handle_config(args: Dict[str, Any]) -> str:
@@ -123,6 +131,11 @@ def _run_swarm_mode(mode: Optional[str], args: Dict[str, Any]) -> str:
         raise ValueError("objective is required")
 
     frontier = args.get("frontier") or args.get("frontier_file")
+    overrides = None
+    backend = (args.get("backend") or "").strip().lower()
+    if backend in ("claude", "opencode"):
+        argv = ["claude", "-p"] if backend == "claude" else ["opencode", "run"]
+        overrides = {"alpha": {"backend": argv}, "beta": {"backend": argv}}
     runner = SwarmRunner(
         base_dir=_resolve_base_dir(args),
         mock_mode=bool(args.get("mock_claude") or args.get("mock_mode")),
@@ -130,6 +143,7 @@ def _run_swarm_mode(mode: Optional[str], args: Dict[str, Any]) -> str:
         engine=args.get("engine"),
         depth=args.get("depth"),
         domain_pack=args.get("domain_pack"),
+        agent_overrides=overrides,
     )
     buf = io.StringIO()
     with redirect_stdout(buf):
@@ -423,6 +437,11 @@ def build_tools() -> List[ToolSpec]:
                         "type": "boolean",
                         "description": "Synthetic run, zero API cost",
                     },
+                    "backend": {
+                        "type": "string",
+                        "enum": ["auto", "claude", "opencode"],
+                        "description": "Agent runtime backend (default auto = host-native)",
+                    },
                 },
                 "required": ["objective"],
             },
@@ -440,6 +459,10 @@ def build_tools() -> List[ToolSpec]:
                     },
                     "base_dir": {"type": "string"},
                     "mock_claude": {"type": "boolean"},
+                    "backend": {
+                        "type": "string",
+                        "enum": ["auto", "claude", "opencode"],
+                    },
                 },
                 "required": ["target"],
             },
@@ -457,6 +480,10 @@ def build_tools() -> List[ToolSpec]:
                     },
                     "base_dir": {"type": "string"},
                     "mock_claude": {"type": "boolean"},
+                    "backend": {
+                        "type": "string",
+                        "enum": ["auto", "claude", "opencode"],
+                    },
                 },
                 "required": ["feature"],
             },
@@ -474,6 +501,10 @@ def build_tools() -> List[ToolSpec]:
                     },
                     "base_dir": {"type": "string"},
                     "mock_claude": {"type": "boolean"},
+                    "backend": {
+                        "type": "string",
+                        "enum": ["auto", "claude", "opencode"],
+                    },
                 },
                 "required": ["objective"],
             },
@@ -501,6 +532,10 @@ def build_tools() -> List[ToolSpec]:
                     "depth": {"type": "integer", "description": "Dialectic depth 1-4"},
                     "base_dir": {"type": "string"},
                     "mock_claude": {"type": "boolean"},
+                    "backend": {
+                        "type": "string",
+                        "enum": ["auto", "claude", "opencode"],
+                    },
                 },
                 "required": ["objective"],
             },

package/runner/pcrb.py

@@ -83,10 +83,14 @@ def _resolve_key(key: Optional[str], key_path: Optional[Path]) -> Optional[bytes
     return None
 
 
-def sign_manifest(manifest: Dict[str, Any], key: Optional[bytes], key_id: str = "local") -> Dict[str, Any]:
+def sign_manifest(
+    manifest: Dict[str, Any], key: Optional[bytes], key_id: str = "local"
+) -> Dict[str, Any]:
     if not key:
         return {"alg": "none", "key_id": None, "sig": None}
-    sig = hmac.new(key, canonical_json(manifest).encode("utf-8"), hashlib.sha256).hexdigest()
+    sig = hmac.new(
+        key, canonical_json(manifest).encode("utf-8"), hashlib.sha256
+    ).hexdigest()
     return {"alg": "hmac-sha256", "key_id": key_id, "sig": sig}
 
 
@@ -98,35 +102,47 @@ def _resolve_synthesis(base_dir: Path) -> str:
     return "\n\n---\n\n".join(p.read_text(encoding="utf-8") for p in parts)
 
 
-def _collect_claims(
-    scope_dirs: List[Path], hasher: Any
-) -> Tuple[List[Dict[str, Any]], set]:
-    claim_records: List[Dict[str, Any]] = []
-    needed_hashes = set()
+def _witness_for(c, hasher: Any, needed_hashes: set) -> Dict[str, Any]:
+    """Build one claim's witness record and track hashes worth bundling."""
+    witness: Dict[str, Any] = {
+        "quote": c.verbatim_quote,
+        "source_hash": c.source_hash,
+        "confidence": None,
+        "verified_at": None,
+    }
+    if not c.source_hash:
+        return witness
+    if c.verbatim_quote:
+        passed, conf, _msg = hasher.verify_quote(c.source_hash, c.verbatim_quote)
+        witness["confidence"] = float(conf)
+        witness["verified_at"] = datetime.now(timezone.utc).isoformat()
+        if passed:
+            needed_hashes.add(c.source_hash)
+    else:
+        needed_hashes.add(c.source_hash)
+    return witness
+
+
+def _iter_dossier_claims(scope_dirs: List[Path]):
+    """Yield claim witnesses from every alpha/beta dossier under scopes."""
     for scope_dir in scope_dirs:
         for dossier_name in ("alpha_dossier.json", "beta_dossier.json"):
             dpath = scope_dir / dossier_name
             if not dpath.exists():
                 continue
-            dossier = load_dossier(dpath)
-            for c in claims_from_dossier(dossier):
-                rec = c.to_dict()
-                witness: Dict[str, Any] = {
-                    "quote": c.verbatim_quote,
-                    "source_hash": c.source_hash,
-                    "confidence": None,
-                    "verified_at": None,
-                }
-                if c.source_hash and c.verbatim_quote:
-                    passed, conf, _msg = hasher.verify_quote(c.source_hash, c.verbatim_quote)
-                    witness["confidence"] = float(conf)
-                    witness["verified_at"] = datetime.now(timezone.utc).isoformat()
-                    if passed and c.source_hash:
-                        needed_hashes.add(c.source_hash)
-                elif c.source_hash:
-                    needed_hashes.add(c.source_hash)
-                rec["witness"] = witness
-                claim_records.append(rec)
+            for c in claims_from_dossier(load_dossier(dpath)):
+                yield c
+
+
+def _collect_claims(
+    scope_dirs: List[Path], hasher: Any
+) -> Tuple[List[Dict[str, Any]], set]:
+    claim_records: List[Dict[str, Any]] = []
+    needed_hashes: set = set()
+    for c in _iter_dossier_claims(scope_dirs):
+        rec = c.to_dict()
+        rec["witness"] = _witness_for(c, hasher, needed_hashes)
+        claim_records.append(rec)
     return claim_records, needed_hashes
 
 
@@ -203,7 +219,11 @@ def export_brief(
         "signature": signature,
     }
 
-    out = Path(os.path.realpath(str(out_path))) if out_path else (base_dir / "brief.pcrb.json")
+    out = (
+        Path(os.path.realpath(str(out_path)))
+        if out_path
+        else (base_dir / "brief.pcrb.json")
+    )
     out.parent.mkdir(parents=True, exist_ok=True)
     with open(out, "w", encoding="utf-8") as f:
         json.dump(bundle, f, indent=2)
@@ -213,7 +233,9 @@ def export_brief(
 def main(argv: Optional[List[str]] = None) -> int:
     import argparse
 
-    parser = argparse.ArgumentParser(description="Export a proof-carrying research brief")
+    parser = argparse.ArgumentParser(
+        description="Export a proof-carrying research brief"
+    )
     parser.add_argument("--dir", default=".research")
     parser.add_argument("--out", default=None)
     parser.add_argument("--scope", action="append", dest="scope_ids")
@@ -224,7 +246,9 @@ def main(argv: Optional[List[str]] = None) -> int:
 
     canonical_dir = Path(os.path.realpath(str(args.dir)))
     canonical_out = Path(os.path.realpath(str(args.out))) if args.out else None
-    canonical_key = Path(os.path.realpath(str(args.key_file))) if args.key_file else None
+    canonical_key = (
+        Path(os.path.realpath(str(args.key_file))) if args.key_file else None
+    )
     path = export_brief(
         canonical_dir,
         out_path=canonical_out,

package/runner/refinement.py

@@ -52,9 +52,7 @@ class Constitution:
     """Scoring + enforcement policy. Defaults == legacy auditor behavior."""
 
     # Per-verified-claim weight. Flat 1.0 reproduces legacy E(D).
-    tier_weights: Dict[str, float] = field(
-        default_factory=lambda: {"__default__": 1.0}
-    )
+    tier_weights: Dict[str, float] = field(default_factory=lambda: {"__default__": 1.0})
     neg_bonus: float = 0.5
     reject_penalty: float = 2.5
     accept_threshold: float = 0.65
@@ -144,9 +142,12 @@ def claim_verdict(
         reasons.append(
             f"ZERO_TOLERANCE_RETRACTION: source {claim.source_hash} was retracted"
         )
-    if claim.status in (STATUS_STALE, STATUS_SUSPECT) and constitution.retraction_policy == "zero_tolerance":
-        if not any(r.startswith("ZERO_TOLERANCE_RETRACTION") for r in reasons):
-            reasons.append(f"ZERO_TOLERANCE_RETRACTION: claim status {claim.status}")
+    if (
+        claim.status in (STATUS_STALE, STATUS_SUSPECT)
+        and constitution.retraction_policy == "zero_tolerance"
+        and not any(r.startswith("ZERO_TOLERANCE_RETRACTION") for r in reasons)
+    ):
+        reasons.append(f"ZERO_TOLERANCE_RETRACTION: claim status {claim.status}")
 
     return {
         "claim_id": claim.claim_id,
@@ -155,33 +156,65 @@ def claim_verdict(
     }
 
 
-def _check_verified_and_inferred(c: ClaimWitness, hasher: Any, out: List[Violation]) -> None:
+def _check_verified_claim(c: ClaimWitness, hasher: Any, out: List[Violation]) -> None:
+    """Verified/claim-kind gates: hash, quote, then live witness check."""
+    if not c.source_hash:
+        out.append(
+            Violation(c.claim_id, "VERIFIED_REQUIRES_HASH", "source_hash missing")
+        )
+    if not c.verbatim_quote:
+        out.append(
+            Violation(c.claim_id, "VERIFIED_REQUIRES_QUOTE", "verbatim_quote missing")
+        )
+    if hasher is None or not (c.source_hash and c.verbatim_quote):
+        return
+    passed, _conf, msg = witness_check(c, hasher)
+    if not passed:
+        out.append(
+            Violation(c.claim_id, "WITNESS_CHECK_FAILED", msg or "quote not in source")
+        )
+
+
+def _check_verified_and_inferred(
+    c: ClaimWitness, hasher: Any, out: List[Violation]
+) -> None:
     if c.tag == TAG_VERIFIED or c.kind == KIND_CLAIM:
-        if not c.source_hash:
-            out.append(Violation(c.claim_id, "VERIFIED_REQUIRES_HASH", "source_hash missing"))
-        if not c.verbatim_quote:
-            out.append(Violation(c.claim_id, "VERIFIED_REQUIRES_QUOTE", "verbatim_quote missing"))
-        if hasher is not None and c.source_hash and c.verbatim_quote:
-            passed, _conf, msg = witness_check(c, hasher)
-            if not passed:
-                out.append(Violation(c.claim_id, "WITNESS_CHECK_FAILED", msg or "quote not in source"))
+        _check_verified_claim(c, hasher, out)
 
     if c.tag == TAG_INFERRED or c.kind == KIND_INFERENCE:
         if not c.parent_claims:
-            out.append(Violation(c.claim_id, "INFERRED_REQUIRES_PARENTS", "parent_claims empty"))
+            out.append(
+                Violation(
+                    c.claim_id, "INFERRED_REQUIRES_PARENTS", "parent_claims empty"
+                )
+            )
         if not c.deductive_logic:
-            out.append(Violation(c.claim_id, "INFERRED_REQUIRES_LOGIC", "deductive_logic missing"))
+            out.append(
+                Violation(
+                    c.claim_id, "INFERRED_REQUIRES_LOGIC", "deductive_logic missing"
+                )
+            )
 
 
 def _check_hypotheses_and_neg_knowledge(c: ClaimWitness, out: List[Violation]) -> None:
     if (c.tag == TAG_HYPOTHESIS or c.kind == KIND_HYPOTHESIS) and not c.falsification:
-        out.append(Violation(c.claim_id, "HYPOTHESIS_REQUIRES_FALSIFICATION", "falsification missing"))
+        out.append(
+            Violation(
+                c.claim_id, "HYPOTHESIS_REQUIRES_FALSIFICATION", "falsification missing"
+            )
+        )
 
     if c.tag == TAG_NEGATIVE_KNOWLEDGE or c.kind == KIND_NEGATIVE_KNOWLEDGE:
         if not c.query:
-            out.append(Violation(c.claim_id, "NEG_KNOWLEDGE_REQUIRES_QUERY", "query missing"))
+            out.append(
+                Violation(c.claim_id, "NEG_KNOWLEDGE_REQUIRES_QUERY", "query missing")
+            )
         if not c.finding:
-            out.append(Violation(c.claim_id, "NEG_KNOWLEDGE_REQUIRES_FINDING", "finding missing"))
+            out.append(
+                Violation(
+                    c.claim_id, "NEG_KNOWLEDGE_REQUIRES_FINDING", "finding missing"
+                )
+            )
 
 
 def _check_constitution_and_parents(
@@ -193,7 +226,11 @@ def _check_constitution_and_parents(
     for parent in c.parent_claims:
         if parent not in known_ids:
             out.append(
-                Violation(c.claim_id, "PARENT_UNRESOLVED", f"parent_claims '{parent}' not in dossier set")
+                Violation(
+                    c.claim_id,
+                    "PARENT_UNRESOLVED",
+                    f"parent_claims '{parent}' not in dossier set",
+                )
             )
 
     if constitution.mandatory_tags and not c.tag:
@@ -204,7 +241,11 @@ def _check_constitution_and_parents(
         for dom in constitution.banned_domains:
             if dom.lower() in src_lower:
                 out.append(
-                    Violation(c.claim_id, "BANNED_DOMAIN", f"source_url on banned domain '{dom}'")
+                    Violation(
+                        c.claim_id,
+                        "BANNED_DOMAIN",
+                        f"source_url on banned domain '{dom}'",
+                    )
                 )
 
 
@@ -261,9 +302,7 @@ def compute_epistemic_score(
     # tier. A Domain Pack may override tier_weights; then each verified claim
     # would need its tier looked up — that path is exercised by Stream G's
     # `compute_epistemic_score_from_claims`, not here.
-    verified_weight = (
-        constitution.weight_for(None) * total_verified
-    )
+    verified_weight = constitution.weight_for(None) * total_verified
 
     total_assertions = max(
         1, total_verified + total_inferred + total_hypotheses + total_rejected
@@ -308,7 +347,8 @@ def compute_epistemic_score_from_claims(
     }
     weight_sum = 0.0
     tier_weighted = any(
-        not math.isclose(w, 1.0, rel_tol=1e-7) for w in constitution.tier_weights.values()
+        not math.isclose(w, 1.0, rel_tol=1e-7)
+        for w in constitution.tier_weights.values()
     )
 
     for c in claims:
@@ -326,7 +366,10 @@ def compute_epistemic_score_from_claims(
 
     total_assertions = max(
         1,
-        counts["verified"] + counts["inferred"] + counts["hypotheses"] + counts["rejected"],
+        counts["verified"]
+        + counts["inferred"]
+        + counts["hypotheses"]
+        + counts["rejected"],
     )
     raw_score = (
         weight_sum