feed-the-machine 1.0.0 → 1.2.0

package/ftm-researcher/references/output-format.md

@@ -0,0 +1,203 @@
+# Output Format Specification
+
+## Structured JSON Artifact
+
+This is the primary output for skill-to-skill consumption (ftm-brainstorm, ftm-executor, etc.).
+
+### Schema
+
+```json
+{
+  "query": "original research question",
+  "mode": "quick | standard | deep",
+  "timestamp": "ISO-8601",
+  "waves_completed": 1,
+  "agents_dispatched": 7,
+  "council_used": true,
+  "duration_ms": 12345,
+
+  "findings": [
+    {
+      "id": "f-001",
+      "claim": "one-sentence factual claim",
+      "evidence": "2-3 sentence supporting detail",
+      "source_url": "https://...",
+      "source_type": "primary | peer_reviewed | official_docs | code_repo | qa_site | news | blog | forum | codebase",
+      "confidence": 0.85,
+      "credibility_score": 0.78,
+      "trust_level": "high | moderate | low | verify",
+      "agent_role": "web_surveyor | academic_scout | github_miner | competitive_analyst | stack_overflow_digger | codebase_analyst | historical_investigator",
+      "wave": 1,
+      "corroborated": true,
+      "circular_sourcing": false
+    }
+  ],
+
+  "disagreement_map": {
+    "consensus": [
+      {
+        "claim": "...",
+        "supporting_agents": ["web_surveyor", "github_miner", "academic_scout"],
+        "source_count": 5,
+        "source_diversity": 3,
+        "council_verdict": "agreed",
+        "confidence": 0.92
+      }
+    ],
+    "contested": [
+      {
+        "claim_a": "...",
+        "claim_b": "...",
+        "agents_for_a": ["web_surveyor"],
+        "agents_for_b": ["competitive_analyst"],
+        "council_verdict": "contested",
+        "provider_positions": {
+          "claude": "a",
+          "codex": "b",
+          "gemini": "a"
+        },
+        "rank_winner": "a",
+        "judge_rationale": "..."
+      }
+    ],
+    "unique_insights": [
+      {
+        "claim": "...",
+        "agent_role": "historical_investigator",
+        "confidence": 0.6,
+        "note": "Single source — may be high-value insight or hallucination"
+      }
+    ],
+    "refuted": [
+      {
+        "claim": "...",
+        "rejection_reason": "Council unanimously rejected — evidence traces to a single unreliable blog post",
+        "original_agent": "web_surveyor"
+      }
+    ]
+  },
+
+  "metadata": {
+    "sources_total": 34,
+    "sources_high_trust": 12,
+    "sources_moderate_trust": 15,
+    "sources_low_trust": 7,
+    "circular_sourcing_detected": 2,
+    "agent_performance": {
+      "web_surveyor": {"findings": 6, "avg_credibility": 0.65},
+      "academic_scout": {"findings": 4, "avg_credibility": 0.88}
+    }
+  }
+}
+```
+
+### Field Descriptions
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| query | string | yes | The original research question |
+| mode | enum | yes | quick, standard, or deep |
+| timestamp | ISO-8601 | yes | When the research completed |
+| waves_completed | integer | yes | 1 for quick/standard, 1-2 for deep |
+| agents_dispatched | integer | yes | Total agents spawned across all waves |
+| council_used | boolean | yes | Whether ftm-council was invoked |
+| duration_ms | integer | yes | Total execution time |
+| findings | array | yes | All individual findings |
+| disagreement_map | object | standard/deep | The 4-tier reconciled output |
+| metadata | object | yes | Aggregate statistics |
+
+### Finding ID Convention
+
+Finding IDs follow the pattern `f-NNN` where NNN is a zero-padded sequential number. IDs are stable within a session — if the user drills down on finding #3, it remains f-003 even after new findings are added.
+
+---
+
+## Markdown Rendering Template
+
+For user display:
+
+```markdown
+# Research: [query]
+
+**Mode:** [mode] | **Agents:** [count] | **Sources:** [total] | **Duration:** [time]
+
+---
+
+## Consensus Findings
+
+[For each consensus claim:]
+**[N].** [claim] ([confidence]% confidence)
+- *Evidence:* [key evidence summary]
+- *Sources:* [source count] across [diversity] types — [top source URL]
+- *Agreed by:* [agent list]
+
+---
+
+## Contested — Where Agents Disagreed
+
+[For each contested pair:]
+**[N].** [topic of disagreement]
+
+| Position A | Position B |
+|---|---|
+| [claim_a] | [claim_b] |
+| Supported by: [agents_for_a] | Supported by: [agents_for_b] |
+| [evidence summary] | [evidence summary] |
+
+*Ranking:* [winner] — [judge rationale summary]
+*Council:* [provider positions if available]
+
+---
+
+## Unique Insights — Unverified but Interesting
+
+[For each unique insight:]
+- **[claim]** (from [agent_role], [confidence]% confidence)
+  - [note about single-source status]
+
+---
+
+## Refuted — What We Ruled Out
+
+[For each refuted claim:]
+- ~~[claim]~~ — [rejection_reason]
+
+---
+
+## Source Summary
+
+| Source Type | Count | Avg Credibility |
+|---|---|---|
+| [type] | [count] | [avg score] |
+
+---
+
+*What's next? You can:*
+- *"dig deeper on #N"* — spawn targeted agents on a specific finding
+- *"I disagree with #N"* — find counter-evidence
+- *"focus on [angle]"* — reshape and re-run with new weights
+- *"council #N"* — route a specific claim to ftm-council
+- *"compare A vs B"* — spawn comparison agent
+- *"done"* — finalize the research session
+```
+
+---
+
+## Conversational Iteration Protocol
+
+After presenting results, the skill enters iteration mode. Each user command triggers a specific action:
+
+| User Command | Action | Updates |
+|---|---|---|
+| "dig deeper on #N" | Spawn 3 targeted agents on finding N's topic | Add new findings, re-render |
+| "I think X is wrong because Y" | Spawn counter-evidence agents + update findings | May move claims between tiers |
+| "focus on [angle]" | Reshape subtopics, re-dispatch with new weights | Full re-run with angle bias |
+| "council #N" | Route specific finding to ftm-council | Update council_verdict for that claim |
+| "more on [agent]'s findings" | Re-dispatch that agent with broader query | Add new findings from that domain |
+| "compare A vs B" | Spawn comparison agent with both findings as context | Add comparison analysis |
+| "done" | Finalize, write blackboard, emit events | Session ends |
+
+Each iteration:
+1. Updates the JSON artifact (new findings get new IDs, tiers may change)
+2. Re-renders the markdown with changes highlighted
+3. Preserves the full conversation history for ftm-pause/resume

package/ftm-researcher/references/synthesis-pipeline.md

@@ -0,0 +1,165 @@
+# Synthesis Pipeline
+
+5-phase pipeline that takes raw findings from finder agents and produces a structured disagreement map.
+
+---
+
+## Phase 1: Normalize & Deduplicate
+
+Input: Raw findings from all finder agents (7 agents x 3-8 findings each = 21-56 findings)
+
+Steps:
+1. Flatten all findings into a single list
+2. Group by semantic similarity (same claim from different agents)
+3. For each group:
+   - Merge into a single canonical claim
+   - Track which agents found it (agent_count)
+   - Track source type diversity (source_diversity_score = unique source types / total sources)
+   - Flag circular sourcing: if all sources in a group cite the same original source, mark as circular=true
+4. Output: unique_claims[] sorted by agent_count DESC, source_diversity_score DESC
+
+### Semantic Similarity Heuristics
+
+Two claims are considered semantically similar when:
+- They make the same factual assertion about the same subject, even with different wording
+- One is a subset of the other (e.g., "X uses Y" vs "X uses Y for Z")
+- They cite the same source for the same conclusion
+
+Two claims are NOT similar when:
+- They address different aspects of the same topic
+- They reach different conclusions about the same subject
+- One is general and the other is specific with additional qualifying conditions
+
+When merging, keep the most specific version as the canonical claim.
+
+---
+
+## Phase 2: Adversarial Review (ftm-council)
+
+Input: Top claims from Phase 1 (all claims with agent_count >= 2, plus any high-confidence unique claims with confidence > 0.8)
+
+Council invocation:
+- Send claims as a structured prompt to ftm-council
+- Ask: "Evaluate each claim. For each: Is the evidence sufficient? What would make this wrong? Are there alternative explanations? Rate confidence 0-1."
+- Council runs Claude + Codex + Gemini independently, then reconciles
+
+Output: claims[] with council_verdict (agreed | contested | insufficient_evidence), provider_disagreements[]
+
+### FALLBACK (if Codex/Gemini unavailable):
+
+Spawn 2 standalone agents on the review model:
+
+**Devil's Advocate:** "Your job is to find reasons each claim is WRONG. Search for counter-evidence, flag single-source claims, identify logical gaps."
+
+**Edge Case Hunter:** "Your job is to find where each claim BREAKS. Scaling limits, security concerns, accessibility gaps, failure modes under load."
+
+Both receive all claims and return challenge_findings[]
+
+---
+
+## Phase 3: Pairwise Rank (for contested claims)
+
+Input: Claims marked as "contested" by council
+
+For each pair of conflicting claims:
+- LLM-as-judge prompt: "Given research question Q, Claim A says [X] with evidence [E1]. Claim B says [Y] with evidence [E2]. Which claim is better supported? Why? Consider: source authority, evidence specificity, logical coherence, relevance to the question."
+- Tournament bracket: winners advance, losers are demoted to "minority view"
+
+Output: ranked_claims[] with rank_position, judge_rationale
+
+### Ranking Criteria (in priority order)
+
+1. **Source authority**: Primary sources and peer-reviewed research outweigh blog posts and forum answers
+2. **Evidence specificity**: Concrete data points (benchmarks, case studies with numbers) outweigh general assertions
+3. **Logical coherence**: Claims with clear causal reasoning outweigh correlational arguments
+4. **Relevance to question**: Claims that directly address the research question outweigh tangentially related findings
+5. **Recency**: For fast-moving topics, newer evidence outweighs older evidence (all else equal)
+
+---
+
+## Phase 4: Reconcile — Disagreement Map
+
+Input: All processed claims (normalized, council-reviewed, ranked)
+
+The Reconciler agent produces structured output in 4 tiers:
+
+### Tier 1: Consensus Claims
+3+ agents agree, council agreed, multiple source types.
+- Highest confidence. Present as established findings.
+- Include: canonical claim, supporting agents, source count, source diversity, council verdict, confidence score
+
+### Tier 2: Contested Claims
+Council disagreed, or pairwise ranking was close.
+- Present BOTH sides with the specific disagreement.
+- Include: claim_a, claim_b, agents_for_a, agents_for_b, council positions, rank winner, judge rationale
+
+### Tier 3: Unique Insights
+Found by 1 agent only, not contradicted.
+- High value OR hallucination — flag for user judgment.
+- Include: claim, agent_role, confidence, source, note flagging single-source status
+
+### Tier 4: Refuted Claims
+Council rejected, or pairwise loser with low evidence.
+- Still present briefly — knowing what's wrong is valuable.
+- Include: claim, rejection_reason, original_agent
+
+---
+
+## Phase 5: Render
+
+Produce both:
+- **Structured JSON artifact** (see output-format.md for schema)
+- **Rendered markdown** for user display (see output-format.md for template)
+
+The JSON artifact is the primary output for skill-to-skill consumption. The markdown is for human reading.
+
+---
+
+## Reconciler Agent Prompt
+
+```
+You are the Reconciler — the final judge in a multi-agent research pipeline.
+You receive findings from 7 research agents that have been normalized,
+deduplicated, and adversarially reviewed.
+
+Your job is NOT to average or blend. Your job is to JUDGE:
+- Which claims are strong? (multiple independent sources, council agreement)
+- Which claims are contested? (present both sides, don't pick a winner)
+- Which claims are unique insights? (valuable if true, flag for verification)
+- Which claims should be rejected? (weak evidence, circular sourcing, council rejection)
+
+Produce a structured disagreement map, not a smooth summary.
+The user should see WHERE agents agreed, WHERE they disagreed, and WHY.
+
+INPUT:
+- normalized_claims: [list of deduplicated claims with agent_count and source_diversity]
+- council_verdicts: [list of claims with agreed/contested/insufficient verdicts]
+- pairwise_rankings: [list of contested claim pairs with winners and rationale]
+- credibility_scores: [list of claims with scored credibility from score_credibility.py]
+
+OUTPUT FORMAT:
+Return a JSON object with these exact keys:
+{
+  "consensus": [{ claim, supporting_agents, source_count, source_diversity, council_verdict, confidence }],
+  "contested": [{ claim_a, claim_b, agents_for_a, agents_for_b, council_verdict, provider_positions, rank_winner, judge_rationale }],
+  "unique_insights": [{ claim, agent_role, confidence, note }],
+  "refuted": [{ claim, rejection_reason, original_agent }]
+}
+
+RULES:
+- A claim needs 3+ agents AND council agreement to be consensus
+- A claim with 2 agents but council agreement goes to consensus with a "moderate confidence" flag
+- A claim with council disagreement ALWAYS goes to contested, even if 5 agents agree
+- A single-agent claim with confidence > 0.8 goes to unique_insights
+- A single-agent claim with confidence <= 0.5 goes to refuted
+- Everything else goes to unique_insights with appropriate flagging
+- NEVER merge contested claims into a smooth middle ground — preserve the disagreement
+```
+
+---
+
+## Pipeline Skip Rules
+
+- **Quick mode**: Skip Phases 2, 3, 4. Orchestrator does a single-pass synthesis directly from normalized findings.
+- **Standard mode**: Skip Phase 2 (council). Run Phases 1, 3, 4, 5.
+- **Deep mode**: Run all 5 phases.

package/ftm-researcher/scripts/score_credibility.py

@@ -0,0 +1,234 @@
+#!/usr/bin/env python3
+"""
+Source credibility scoring for ftm-researcher findings.
+
+Scoring dimensions:
+- Source type weight (35%): primary > peer_reviewed > official_docs > news > blog > forum
+- Recency (20%): decay based on age for fast-moving topics
+- Expertise signals (25%): domain authority, author credentials
+- Bias detection (20%): sensationalism penalties, balanced language bonuses
+
+Additional flags:
+- Corroboration bonus: +0.15 if independently found by 2+ agents from different source types
+- Circular sourcing: flag if multiple sources cite the same original
+"""
+import json
+import sys
+import re
+from datetime import datetime
+from urllib.parse import urlparse
+
+# Source type base weights
+SOURCE_WEIGHTS = {
+    "primary": 1.0,
+    "peer_reviewed": 0.9,
+    "official_docs": 0.85,
+    "code_repo": 0.8,
+    "qa_site": 0.65,
+    "news": 0.6,
+    "blog": 0.4,
+    "forum": 0.25,
+    "codebase": 0.95,  # local codebase findings are high-trust
+}
+
+# High-authority domains
+HIGH_AUTHORITY = {
+    "arxiv.org", "nature.com", "science.org", "acm.org", "ieee.org",
+    "github.com", "docs.python.org", "developer.mozilla.org",
+    "platform.openai.com", "docs.anthropic.com", "cloud.google.com",
+    "aws.amazon.com", "learn.microsoft.com",
+}
+
+MODERATE_AUTHORITY = {
+    "stackoverflow.com", "stackexchange.com", "reddit.com",
+    "news.ycombinator.com", "techcrunch.com", "arstechnica.com",
+    "thenewstack.io", "infoq.com", "dev.to",
+}
+
+# Sensationalism indicators
+SENSATIONAL_PATTERNS = [
+    r"you won't believe", r"shocking", r"mind-blowing", r"game.?changer",
+    r"revolutionary", r"incredible", r"amazing breakthrough",
+]
+
+# Balanced language indicators
+BALANCED_PATTERNS = [
+    r"however", r"on the other hand", r"trade-?off", r"limitation",
+    r"caveat", r"although", r"despite", r"conversely",
+]
+
+
+def score_source_type(finding: dict) -> float:
+    return SOURCE_WEIGHTS.get(finding.get("source_type", "blog"), 0.4)
+
+
+def score_recency(finding: dict, fast_moving: bool = True) -> float:
+    """Score based on source recency. Extracts year from URL or metadata."""
+    url = finding.get("source_url", "")
+    evidence = finding.get("evidence", "")
+    current_year = datetime.now().year
+
+    # Try to extract year from URL (common in blog/paper URLs)
+    year_match = re.search(r'/(20[12]\d)/', url)
+    if not year_match:
+        # Try evidence text for year mentions
+        year_match = re.search(r'\b(20[12]\d)\b', evidence)
+
+    if year_match:
+        source_year = int(year_match.group(1))
+        age = current_year - source_year
+        if fast_moving:
+            # Aggressive decay for fast-moving topics (tech, AI, etc.)
+            decay_map = {0: 1.0, 1: 0.85, 2: 0.65, 3: 0.45, 4: 0.30}
+            return decay_map.get(age, 0.2)
+        else:
+            # Gentle decay for stable topics
+            decay_map = {0: 1.0, 1: 0.95, 2: 0.85, 3: 0.75, 4: 0.65, 5: 0.55}
+            return decay_map.get(age, 0.4)
+
+    # No date info — return neutral
+    return 0.7
+
+
+def score_domain_authority(finding: dict) -> float:
+    url = finding.get("source_url", "")
+    if not url:
+        if finding.get("source_type") == "codebase":
+            return 0.95
+        return 0.5
+
+    try:
+        domain = urlparse(url).netloc.lower()
+        # Strip www.
+        domain = domain.removeprefix("www.")
+    except Exception:
+        return 0.5
+
+    if domain in HIGH_AUTHORITY:
+        return 0.9
+    if domain in MODERATE_AUTHORITY:
+        return 0.7
+    # Check for .edu, .gov
+    if domain.endswith(".edu") or domain.endswith(".gov"):
+        return 0.85
+    return 0.55
+
+
+def score_bias(finding: dict) -> float:
+    text = finding.get("evidence", "") + " " + finding.get("claim", "")
+    text_lower = text.lower()
+
+    score = 0.7  # baseline
+
+    # Penalize sensationalism
+    for pattern in SENSATIONAL_PATTERNS:
+        if re.search(pattern, text_lower):
+            score -= 0.1
+
+    # Bonus for balanced language
+    for pattern in BALANCED_PATTERNS:
+        if re.search(pattern, text_lower):
+            score += 0.05
+
+    return max(0.1, min(1.0, score))
+
+
+def detect_circular_sourcing(findings: list) -> list:
+    """Flag findings where multiple sources trace to the same original."""
+    url_groups = {}
+    for i, f in enumerate(findings):
+        url = f.get("source_url", "")
+        if url:
+            domain = urlparse(url).netloc.lower().removeprefix("www.")
+            claim_key = f.get("claim", "")[:50]
+            key = f"{domain}:{claim_key}"
+            url_groups.setdefault(key, []).append(i)
+
+    circular_indices = set()
+    for key, indices in url_groups.items():
+        if len(indices) > 1:
+            for idx in indices:
+                circular_indices.add(idx)
+
+    return list(circular_indices)
+
+
+def score_findings(findings: list) -> list:
+    circular = detect_circular_sourcing(findings)
+
+    # Count agent agreement per claim (simplified: exact claim match)
+    claim_agents = {}
+    for f in findings:
+        claim = f.get("claim", "")
+        agent = f.get("agent_role", "unknown")
+        source_type = f.get("source_type", "")
+        claim_agents.setdefault(claim, {"agents": set(), "source_types": set()})
+        claim_agents[claim]["agents"].add(agent)
+        claim_agents[claim]["source_types"].add(source_type)
+
+    scored = []
+    for i, f in enumerate(findings):
+        type_score = score_source_type(f)
+        recency_score = score_recency(f)
+        authority_score = score_domain_authority(f)
+        bias_score = score_bias(f)
+
+        # Weighted composite
+        composite = (
+            type_score * 0.35 +
+            recency_score * 0.20 +
+            authority_score * 0.25 +
+            bias_score * 0.20
+        )
+
+        # Corroboration bonus
+        claim = f.get("claim", "")
+        if claim in claim_agents:
+            info = claim_agents[claim]
+            if len(info["agents"]) >= 2 and len(info["source_types"]) >= 2:
+                composite += 0.15
+
+        # Circular sourcing penalty
+        is_circular = i in circular
+        if is_circular:
+            composite -= 0.2
+
+        composite = max(0.0, min(1.0, composite))
+
+        scored_finding = {
+            **f,
+            "credibility_score": round(composite, 3),
+            "score_breakdown": {
+                "source_type": round(type_score, 3),
+                "recency": round(recency_score, 3),
+                "domain_authority": round(authority_score, 3),
+                "bias": round(bias_score, 3),
+            },
+            "circular_sourcing": is_circular,
+            "corroborated": claim in claim_agents and len(claim_agents[claim]["agents"]) >= 2,
+            "trust_level": (
+                "high" if composite >= 0.75 else
+                "moderate" if composite >= 0.55 else
+                "low" if composite >= 0.35 else
+                "verify"
+            ),
+        }
+        scored.append(scored_finding)
+
+    return sorted(scored, key=lambda x: x["credibility_score"], reverse=True)
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: score_credibility.py <findings.json>", file=sys.stderr)
+        sys.exit(1)
+
+    with open(sys.argv[1]) as f:
+        findings = json.load(f)
+
+    scored = score_findings(findings)
+    print(json.dumps(scored, indent=2))
+
+
+if __name__ == "__main__":
+    main()

package/ftm-researcher/scripts/validate_research.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""
+Validates ftm-researcher output for completeness and quality.
+
+Checks:
+1. All required fields present in each finding
+2. Source URLs are non-empty for non-codebase findings
+3. Confidence scores in valid range
+4. Disagreement map has all 4 tiers
+5. No placeholder text (TBD, TODO, FIXME)
+6. Minimum finding count per mode (quick: 3, standard: 10, deep: 15)
+7. Source diversity: at least 3 different source types represented
+8. No duplicate claims (exact match)
+"""
+import json
+import sys
+
+REQUIRED_FINDING_FIELDS = ["claim", "source_type", "confidence", "agent_role"]
+REQUIRED_MAP_TIERS = ["consensus", "contested", "unique_insights", "refuted"]
+PLACEHOLDER_PATTERNS = ["TBD", "TODO", "FIXME", "placeholder", "lorem ipsum"]
+MIN_FINDINGS = {"quick": 3, "standard": 10, "deep": 15}
+
+
+def validate(output: dict) -> dict:
+    errors = []
+    warnings = []
+
+    mode = output.get("mode", "standard")
+    findings = output.get("findings", [])
+    disagreement_map = output.get("disagreement_map", {})
+
+    # Check minimum findings
+    min_count = MIN_FINDINGS.get(mode, 10)
+    if len(findings) < min_count:
+        warnings.append(f"Only {len(findings)} findings for {mode} mode (expected >= {min_count})")
+
+    # Check required fields
+    for i, f in enumerate(findings):
+        for field in REQUIRED_FINDING_FIELDS:
+            if field not in f or not f[field]:
+                errors.append(f"Finding {i}: missing required field '{field}'")
+
+        # Source URL required for non-codebase
+        if f.get("source_type") != "codebase" and not f.get("source_url"):
+            warnings.append(f"Finding {i}: no source_url for {f.get('source_type')} source")
+
+        # Confidence range
+        conf = f.get("confidence", 0)
+        if not (0.0 <= conf <= 1.0):
+            errors.append(f"Finding {i}: confidence {conf} out of range [0, 1]")
+
+        # Placeholder detection
+        text = json.dumps(f).lower()
+        for p in PLACEHOLDER_PATTERNS:
+            if p.lower() in text:
+                errors.append(f"Finding {i}: contains placeholder text '{p}'")
+
+    # Source diversity
+    source_types = set(f.get("source_type", "") for f in findings)
+    if len(source_types) < 3:
+        warnings.append(f"Only {len(source_types)} source types (expected >= 3)")
+
+    # Duplicate detection
+    claims = [f.get("claim", "") for f in findings]
+    dupes = [c for c in claims if claims.count(c) > 1]
+    if dupes:
+        errors.append(f"Duplicate claims found: {set(dupes)}")
+
+    # Disagreement map tiers
+    if mode in ("standard", "deep"):
+        for tier in REQUIRED_MAP_TIERS:
+            if tier not in disagreement_map:
+                errors.append(f"Disagreement map missing tier: {tier}")
+
+    return {"errors": errors, "warnings": warnings, "valid": len(errors) == 0}
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: validate_research.py <output.json>", file=sys.stderr)
+        sys.exit(1)
+
+    with open(sys.argv[1]) as f:
+        output = json.load(f)
+
+    result = validate(output)
+    print(json.dumps(result, indent=2))
+    sys.exit(0 if result["valid"] else 1)
+
+
+if __name__ == "__main__":
+    main()