[
  {
    "id": 1,
    "name": "Shadow-Based Chronolocator",
    "category": "chronolocation",
    "difficulty": 3,
    "language": "python",
    "description": "Write a Python tool that estimates the time a photo was taken based on shadow analysis. Given an image with a shadow and the known height of the object casting it, plus the GPS coordinates of the location, calculate the sun elevation angle from the shadow length, then use the ephem library to determine what time of day produces that sun angle at those coordinates for a given date range. Output: estimated time window (UTC), sun azimuth, and a confidence range. Handle edge cases: no shadow visible, circumpolar conditions, multiple possible times per day."
  },
  {
    "id": 2,
    "name": "Evidence Archiver & Hasher",
    "category": "preservation",
    "difficulty": 2,
    "language": "python",
    "description": "Write a Python tool for preserving digital evidence with chain-of-custody integrity. Given a URL, download the full page content (HTML + images + embedded media), compute SHA-256 hashes of every artifact, generate a timestamped manifest file (JSON) listing each file with its hash, size, and download timestamp. Save a WARC-like archive bundle. Include a verify command that re-hashes all files against the manifest and reports any tampering. Use requests for download, hashlib for hashing. Support batch mode from a list of URLs in a text file."
  },
  {
    "id": 3,
    "name": "Geolocation Clue Extractor",
    "category": "geolocation",
    "difficulty": 4,
    "language": "python",
    "description": "Write a Python module that analyzes an image to extract geolocation clues. Use Pillow and basic image processing to: (1) detect and extract any visible text (signs, billboards) using contour detection and OCR-ready cropping, (2) identify dominant vegetation color profiles that suggest climate zones (tropical vs temperate vs arid), (3) detect road marking patterns (solid/dashed, color) and estimate driving side (left/right), (4) extract any visible license plate region for format analysis. Output a structured JSON report with each clue type, the extracted data, and a suggested region. Do NOT use cloud APIs — all processing must be local using Pillow and numpy only."
  },
  {
    "id": 4,
    "name": "Multi-Source Cross-Referencing Engine",
    "category": "verification",
    "difficulty": 5,
    "language": "python",
    "description": "Write a Python tool that cross-references a claim across multiple data sources and produces a verification score. Given a structured claim (JSON with: what, where, when, who), query multiple simulated data feeds (each represented as a JSON file): news_feed.json, social_media.json, satellite_log.json, official_records.json. For each source, search for corroborating or contradicting entries using fuzzy string matching (difflib). Calculate a verification score: each independent corroboration adds weight, contradictions subtract, source reliability weights apply. Output a structured verdict with score, supporting evidence list, contradicting evidence list, and gaps (sources with no relevant data). Include a function to generate a concise verification summary."
  },
  {
    "id": 5,
    "name": "Flight Path Reconstructor",
    "category": "transportation",
    "difficulty": 3,
    "language": "python",
    "description": "Write a Python tool that reconstructs a flight path from ADS-B transponder data. Given a CSV file with columns: timestamp, icao24, callsign, latitude, longitude, altitude, velocity, heading — filter by a specific aircraft (icao24 or callsign), interpolate gaps in position data using linear interpolation, compute total distance traveled (haversine formula), detect takeoff and landing events (altitude thresholds), and identify any holding patterns (repeated circular paths). Output: a GeoJSON LineString of the flight path, a summary JSON with departure/arrival timestamps, total distance, max altitude, and any detected anomalies (sudden altitude changes, course reversals, transponder gaps longer than N minutes)."
  },
  {
    "id": 6,
    "name": "Satellite Change Detector",
    "category": "satellite_imagery",
    "difficulty": 4,
    "language": "python",
    "description": "Write a Python tool that detects changes between two satellite images of the same area taken at different times. Given two images (before.png, after.png) that are already aligned, compute: (1) pixel-level difference map with configurable sensitivity threshold, (2) connected component analysis to identify distinct change regions, (3) bounding boxes and area (in pixels) for each detected change region, (4) classification of change type based on color shift (new construction=gray, vegetation loss=brown, water change=blue). Output a JSON report listing each change region with its bounding box, area, change type, and confidence. Save a visualization image highlighting changes with colored overlays. Use numpy and Pillow only."
  },
  {
    "id": 7,
    "name": "Social Media Timeline Reconstructor",
    "category": "social_media",
    "difficulty": 3,
    "language": "python",
    "description": "Write a Python tool that reconstructs a timeline of events from a collection of social media posts. Given a JSON array of posts (each with: platform, username, timestamp, text, location, media_urls, engagement_count), sort chronologically, detect clusters of posts about the same event (using keyword overlap and time proximity within a configurable window), merge clusters into unified events with earliest/latest timestamps, extract key entities (locations, names, organizations) using regex patterns, and build a timeline JSON with events sorted by time, each containing: time_range, summary of merged posts, locations mentioned, sources (list of original posts), and a thread showing how the narrative evolved. Include duplicate detection by text similarity."
  },
  {
    "id": 8,
    "name": "Network Graph Builder",
    "category": "analysis",
    "difficulty": 3,
    "language": "python",
    "description": "Write a Python tool that builds relationship network graphs from structured investigation data. Given a JSON file of entities (people, organizations, locations, accounts) and a JSON file of connections (entity_a, entity_b, relationship_type, evidence_source, confidence), build an adjacency representation, compute: degree centrality for each node, identify bridge nodes (removal disconnects the graph), find shortest paths between any two entities, detect communities using a simple label propagation algorithm. Output: a full analysis JSON with ranked nodes by centrality, identified communities, bridge nodes, and for a given pair of entities, the shortest connection path with all intermediate relationships. Use only standard library (no networkx)."
  },
  {
    "id": 9,
    "name": "Coordinate Grid Search Generator",
    "category": "geolocation",
    "difficulty": 2,
    "language": "python",
    "description": "Write a Python tool that generates a systematic search grid for satellite imagery analysis. Given a center coordinate (lat, lon), a search radius in kilometers, and a grid cell size in meters, generate a grid of bounding boxes covering the search area. For each cell, output: cell_id, center coordinate, corner coordinates, and a URL template for common tile servers (formatted for OpenStreetMap tile coordinates at a given zoom level). Support both square and hexagonal grid patterns. Output as GeoJSON FeatureCollection where each feature is a grid cell polygon. Include a progress tracker that marks cells as searched/unsearched in a companion JSON state file, so searches can be resumed."
  },
  {
    "id": 10,
    "name": "Metadata Consistency Checker",
    "category": "verification",
    "difficulty": 3,
    "language": "python",
    "description": "Write a Python tool that checks metadata consistency across a set of media files to detect potential manipulation or misattribution. Given a directory of images, extract EXIF data from each using Pillow, then cross-check: (1) do GPS coordinates match the claimed location (within a radius)? (2) do timestamps fall within the claimed time range? (3) are all images from the same camera make/model? (4) are there any timestamp sequence anomalies (out-of-order, impossible gaps, duplicate timestamps)? (5) do any images have stripped or inconsistent EXIF patterns suggesting editing? Output a structured JSON report flagging each inconsistency with severity (info/warning/critical), the affected files, and what specifically doesn't match."
  },
  {
    "id": 11,
    "name": "Open Corporate Registry Parser",
    "category": "corporate_investigation",
    "difficulty": 3,
    "language": "python",
    "description": "Write a Python tool that parses and cross-references company records from structured data sources. Given a JSON file of company records (each with: company_name, registration_number, jurisdiction, directors, registered_address, filing_dates, status), build a search interface that can: (1) find all companies sharing a director name (fuzzy match), (2) find all companies at the same registered address, (3) detect director networks (people who sit on multiple boards together), (4) flag companies with suspicious patterns (registered same day at same address, very recent creation, dormant status). Output: a risk assessment JSON for each company with flags and connections discovered. Include a function that generates a plain-text investigation summary."
  },
  {
    "id": 12,
    "name": "Misinformation Pattern Detector",
    "category": "verification",
    "difficulty": 4,
    "language": "python",
    "description": "Write a Python tool that identifies potential misinformation patterns in a stream of social media posts. Given a JSON array of posts with (id, timestamp, text, source, share_count, reply_to), detect: (1) copy-paste campaigns — near-identical text appearing from different accounts within a short time window, (2) coordinated amplification — unusual spikes in share_count from accounts that regularly amplify each other, (3) narrative injection — new claims that suddenly appear and are rapidly shared with no prior discussion, (4) source concentration — claims that trace back to a single original post but appear to come from many independent sources. Score each detected pattern with confidence and evidence. Output a structured JSON report with each detected pattern, the involved posts, the detection method, and confidence score."
  },
  {
    "id": 13,
    "name": "Haversine Distance Matrix Builder",
    "category": "geolocation",
    "difficulty": 2,
    "language": "python",
    "description": "Write a Python tool that computes a distance matrix between a set of geographic points and identifies spatial patterns. Given a JSON array of named locations (name, lat, lon, timestamp), compute all pairwise haversine distances, identify clusters of points within a configurable radius, determine the geographic centroid of each cluster, calculate the convex hull area of the full point set, and detect travel sequences (ordered by timestamp) that would require impossible speeds (above a configurable threshold). Output: distance matrix as CSV, cluster assignments JSON, travel analysis with flagged impossible movements, and an overall spatial summary."
  },
  {
    "id": 14,
    "name": "Webpage Diff Monitor",
    "category": "monitoring",
    "difficulty": 3,
    "language": "python",
    "description": "Write a Python tool that monitors web pages for changes and preserves snapshots. Given a JSON config with a list of URLs and check_interval_minutes, the tool stores a SQLite database of page snapshots (url, timestamp, content_hash, content). On each check: fetch the page, compute content hash, compare with latest stored version, if changed: store new snapshot, compute a text diff (unified diff format) between old and new content, and log the change. Provide commands: 'check' (run one check cycle), 'history <url>' (show all snapshots with timestamps), 'diff <url> <id1> <id2>' (show diff between two snapshots), 'report' (summary of all monitored URLs and their change frequency). Use requests, hashlib, difflib, sqlite3."
  },
  {
    "id": 15,
    "name": "Investigation Case File Manager",
    "category": "reporting",
    "difficulty": 4,
    "language": "python",
    "description": "Write a Python tool that manages a structured investigation case file. A case contains: entities (people, orgs, locations, accounts), evidence items (files with metadata, hash, source URL, collection timestamp, notes), timeline events (what, when, where, sources, confidence), hypotheses (claim, supporting evidence IDs, contradicting evidence IDs, status). Store everything in SQLite. Support commands: 'add_entity', 'add_evidence', 'add_event', 'add_hypothesis', 'link' (connect evidence to events/entities), 'timeline' (print chronological timeline), 'matrix' (show evidence-hypothesis support matrix), 'export' (generate a structured JSON case file with all data and relationships), 'gaps' (identify timeline gaps, unsupported hypotheses, unlinked evidence). Include chain-of-custody tracking: every modification logged with timestamp and description."
  }
]