Persist article title, source and analyzed_at in Article node

backend/pipeline/extraction/spacy_extractor.py

@@ -248,11 +248,20 @@ class SpacyExtractor(AbstractExtractor):
 
     # Relation classification
     def _classify_relation(self, verb: Token) -> RelationType:
-        """Determine the relation type based on the verb lemma."""
+        """Determine the relation type based on the verb lemma and compound phrases."""
         lemma = verb.lemma_.lower()
 
+        # Compound verb phrases take priority over single-lemma lookup
+        phrase = " ".join(t.lemma_.lower() for t in verb.subtree if t.dep_ in {"aux", "prt", "compound"} or t == verb)
+        if any(p in phrase for p in ("swear in", "take office", "be elect", "be appoint", "be inaugurate", "step down", "take over")):
+            return RelationType.HOLDS_POSITION
+        if any(p in phrase for p in ("win election", "win race", "defeat opponent")):
+            return RelationType.HOLDS_POSITION
+
         if lemma in POSITION_VERBS:
             return RelationType.HOLDS_POSITION
+        elif lemma in {"win", "defeat", "beat"}:
+            return RelationType.HOLDS_POSITION
         elif lemma in MEMBERSHIP_VERBS:
             return RelationType.MEMBER_OF
         elif lemma in EVENT_VERBS:

backend/pipeline/graph/neo4j_store.py

@@ -52,13 +52,22 @@ class Neo4jTKGStore(AbstractTKGStore):
 
     # Write operations
 
-    def add_fact(self, fact: TemporalFact, article_id: str | None = None) -> None:
+    def add_fact(
+        self,
+        fact: TemporalFact,
+        article_id: str | None = None,
+        title: str | None = None,
+        source: str | None = None,
+    ) -> None:
         """Store a fact as two Entity nodes + a TEMPORAL_RELATION edge."""
         with self._driver.session() as session:
-            session.execute_write(self._create_fact_tx, fact, article_id)
+            session.execute_write(self._create_fact_tx, fact, article_id, title, source)
 
     @staticmethod
-    def _create_fact_tx(tx, fact: TemporalFact, article_id: str | None) -> None:
+    def _create_fact_tx(
+        tx, fact: TemporalFact, article_id: str | None,
+        title: str | None = None, source: str | None = None,
+    ) -> None:
         def to_iso(expr: TemporalExpression | None) -> str | None:
             if expr and expr.normalized_date:
                 return expr.normalized_date.isoformat()
@@ -113,11 +122,27 @@ class Neo4jTKGStore(AbstractTKGStore):
         """, **params)
 
         if article_id:
-            tx.run("MERGE (a:Article {article_id: $article_id})", article_id=article_id)
+            tx.run("""
+                MERGE (a:Article {article_id: $article_id})
+                ON CREATE SET a.title = $title,
+                              a.source = $source,
+                              a.analyzed_at = $analyzed_at
+            """,
+            article_id=article_id,
+            title=title or "",
+            source=source or "",
+            analyzed_at=datetime.utcnow().isoformat(),
+            )
 
-    def add_facts(self, facts: list[TemporalFact], article_id: str | None = None) -> None:
+    def add_facts(
+        self,
+        facts: list[TemporalFact],
+        article_id: str | None = None,
+        title: str | None = None,
+        source: str | None = None,
+    ) -> None:
         for fact in facts:
-            self.add_fact(fact, article_id)
+            self.add_fact(fact, article_id, title=title, source=source)
         logger.info(
             f"Neo4jTKGStore: {len(facts)} facts written"
             + (f" for article {article_id}" if article_id else "")

backend/pipeline/orchestrator.py

@@ -151,7 +151,12 @@ class PipelineOrchestrator:
         # Persist facts after scoring
         if self._persistent_store and article_id:
             try:
-                self._persistent_store.add_facts(all_facts, article_id=article_id)
+                self._persistent_store.add_facts(
+                    all_facts,
+                    article_id=article_id,
+                    title=article.title or "",
+                    source=article.source or "",
+                )
                 logger.info(f"Neo4j: {len(all_facts)} facts persisted (article_id={article_id})")
             except Exception as e:
                 logger.error(f"Neo4j persistence failed: {e}")

backend/pipeline/scoring/tcs.py

@@ -42,10 +42,10 @@ class TCSCalculator:
 
         # Severity weights
         SEVERITY_WEIGHTS = {
+            Severity.LOW: 0.2,
+            Severity.MEDIUM: 0.5,
             Severity.HIGH: 1.0,
-            Severity.MEDIUM: 0.6,
-            Severity.LOW: 0.3,
-            Severity.CRITICAL: 1.0
+            Severity.CRITICAL: 1.5,
         }
 
         # Weighted penalty
@@ -53,19 +53,21 @@ class TCSCalculator:
         # Worst-case: every claim has a critical inconsistency
         max_possible_penalty = n_claims * max(SEVERITY_WEIGHTS.values())
 
-        # Coverage factor: proportion of facts verified; clamped to min 0.3
+        # Coverage factor: sqrt-softened ratio; higher coverage amplifies the raw signal
         if facts_total > 0:
-            coverage_factor = max(0.3, facts_verified / facts_total)
+            raw_coverage = facts_verified / facts_total
+            coverage_factor = max(0.5, raw_coverage ** 0.5)
         else:
-            # Default when verification coverage is unknown
-            coverage_factor = 0.5
+            coverage_factor = 0.7
 
         # Main formula
         penalty_ratio = min(1.0, weighted_penalty / max_possible_penalty) if max_possible_penalty > 0 else 0.0
         raw_tcs = (1.0 - penalty_ratio) * score_coherence
 
-        # Blend with neutral 0.5 on the unverified portion
-        tcs = raw_tcs * coverage_factor + (1.0 - coverage_factor) * 0.5
+        # Confidence multiplier: amplify deviation from 0.5 proportionally to coverage
+        tcs = raw_tcs + coverage_factor * (raw_tcs - 0.5) * 0.3
+        if facts_verified == 0:
+            tcs = raw_tcs
 
         # Clamp
         tcs = max(0.0, min(1.0, tcs))

backend/pipeline/verification/internal.py

@@ -228,7 +228,8 @@ class InternalVerifier:
                 if SequenceMatcher(None, subj_h, subj_e).ratio() >= 0.85:
                     if _is_inauguration_or_election(e_fact):
                         point_e = _extract_point_time(e_fact)
-                        if point_e and point_e > start_h:
+                        # 180-day buffer: election -> inauguration transition is normal (up to ~6 months)
+                        if point_e and (point_e - start_h).days > 180:
                             inconsistencies.append(Inconsistency(
                                 inconsistency_type=InconsistencyType.IMPLICIT_CONTRADICTION,
                                 severity=Severity.MEDIUM,

frontend/src/components/ArticleHistory.tsx

@@ -147,7 +147,9 @@ function ArticleHistory({ open, onClose }: ArticleHistoryProps): React.ReactElem
                   <ListItemText
                     primary={
                       <Typography variant="body2" noWrap sx={{ fontWeight: "medium" }}>
-                        {article.title ?? <em>Untitled</em>}
+                        {article.title && article.title.trim()
+                          ? article.title.trim().slice(0, 60)
+                          : <em>Untitled</em>}
                       </Typography>
                     }
                     secondary={

start.ps1

@@ -1,149 +0,0 @@
-# Usage: .\start.ps1
-# Starts Ollama, pulls required models, verifies spaCy models,
-# then launches the backend (FastAPI :8000) and frontend (React :3000).
-
-$BACKEND_URL  = "http://localhost:8000"
-$FRONTEND_URL = "http://localhost:3000"
-
-function Write-Step { param($msg) Write-Host "[*] $msg" -ForegroundColor Cyan }
-function Write-Ok   { param($msg) Write-Host "[OK] $msg" -ForegroundColor Green }
-function Write-Warn { param($msg) Write-Host "[!] $msg" -ForegroundColor Yellow }
-function Write-Err  { param($msg) Write-Host "[ERR] $msg" -ForegroundColor Red }
-
-# Load .env into the current process environment
-$envFile = Join-Path $PSScriptRoot ".env"
-if (Test-Path $envFile) {
-    Get-Content $envFile | Where-Object { $_ -notmatch '^\s*#' -and $_ -match '=' } | ForEach-Object {
-        if ($_ -match '^([^=]+)=(.*)$') {
-            [System.Environment]::SetEnvironmentVariable($Matches[1].Trim(), $Matches[2].Trim(), 'Process')
-        }
-    }
-}
-
-# Resolve values from env with fallbacks
-$OLLAMA_URL  = if ($env:OLLAMA_HOST)  { $env:OLLAMA_HOST }  else { "http://localhost:11434" }
-$LLM_MODELS  = if ($env:LLM_MODELS)  { $env:LLM_MODELS  -split ',' | ForEach-Object { $_.Trim() } } else { @("sciphi/triplex") }
-$SPACY_MODELS = if ($env:SPACY_MODELS) { $env:SPACY_MODELS -split ',' | ForEach-Object { $_.Trim() } } else { @("en_core_web_trf") }
-
-# Check if a URL responds with HTTP 200
-function Test-Http {
-    param($url)
-    try {
-        $resp = Invoke-WebRequest -Uri $url -UseBasicParsing -TimeoutSec 5 -ErrorAction Stop
-        return $resp.StatusCode -eq 200
-    } catch {
-        return $false
-    }
-}
-
-# [1/5] Ollama daemon
-Write-Step "[1/5] Checking Ollama..."
-if (-not (Test-Http "$OLLAMA_URL/api/tags")) {
-    Write-Warn "Ollama not running — starting ollama serve"
-    Start-Process -FilePath "ollama" -ArgumentList "serve" -WindowStyle Hidden
-    Start-Sleep -Seconds 3
-    if (-not (Test-Http "$OLLAMA_URL/api/tags")) {
-        Write-Err "Ollama failed to start. Is it installed?"
-        exit 1
-    }
-}
-Write-Ok "Ollama is running"
-
-# [2/5] Ollama LLM models
-Write-Step "[2/5] Checking Ollama LLM models..."
-try {
-    $tagsJson    = Invoke-RestMethod -Uri "$OLLAMA_URL/api/tags" -TimeoutSec 5
-    $pulledNames = $tagsJson.models | ForEach-Object { $_.name -replace ":latest$", "" }
-} catch {
-    $pulledNames = @()
-}
-
-foreach ($model in $LLM_MODELS) {
-    $shortName = $model -replace ":latest$", ""
-    if ($pulledNames -contains $shortName) {
-        Write-Ok "LLM model present: $model"
-    } else {
-        Write-Warn "Pulling LLM model: $model"
-        & ollama pull $model
-        if ($LASTEXITCODE -ne 0) {
-            Write-Err "Failed to pull $model"
-            exit 1
-        }
-        Write-Ok "Pulled: $model"
-    }
-}
-
-# [3/5] spaCy NLP models
-Write-Step "[3/5] Checking spaCy models..."
-foreach ($model in $SPACY_MODELS) {
-    $result = & python -c "import spacy; spacy.load('$model'); print('ok')" 2>&1
-    if ("$result" -match "ok") {
-        Write-Ok "spaCy model present: $model"
-    } else {
-        Write-Warn "spaCy model not found: $model — downloading..."
-        & python -m spacy download $model
-        if ($LASTEXITCODE -ne 0) {
-            Write-Err "Failed to download spaCy model: $model"
-            exit 1
-        }
-        Write-Ok "Downloaded spaCy model: $model"
-    }
-}
-
-# [4/5] Backend
-Write-Step "[4/5] Starting backend (uvicorn on :8000)..."
-$backendJob = Start-Job -ScriptBlock {
-    param($root)
-    Set-Location $root
-    & "$root\venv\Scripts\Activate.ps1"
-    & "$root\venv\Scripts\uvicorn.exe" backend.main:app --host 0.0.0.0 --port 8000
-} -ArgumentList $PWD.Path
-
-Start-Sleep -Seconds 5
-if (Test-Http "$BACKEND_URL/health") {
-    Write-Ok "Backend healthy at $BACKEND_URL"
-} else {
-    Write-Warn "Backend did not respond in time — check logs below"
-}
-
-# [5/5] Frontend
-Write-Step "[5/5] Starting frontend (npm start on :3000)..."
-$frontendJob = Start-Job -ScriptBlock {
-    param($root)
-    Set-Location "$root\frontend"
-    & npm start
-} -ArgumentList $PWD.Path
-
-# Summary
-Write-Host ""
-Write-Host "======================================" -ForegroundColor Cyan
-Write-Host "  Backend   $BACKEND_URL"              -ForegroundColor Green
-Write-Host "  Frontend  $FRONTEND_URL"             -ForegroundColor Green
-Write-Host "  Ollama    $OLLAMA_URL"               -ForegroundColor Green
-Write-Host "  Press Ctrl+C to stop all services"   -ForegroundColor Yellow
-Write-Host "======================================" -ForegroundColor Cyan
-Write-Host ""
-
-# Stream job output until Ctrl+C
-try {
-    while ($true) {
-        Receive-Job -Job $backendJob  | ForEach-Object { Write-Host "[backend]  $_" }
-        Receive-Job -Job $frontendJob | ForEach-Object { Write-Host "[frontend] $_" }
-        Start-Sleep -Milliseconds 500
-
-        if ($backendJob.State -eq "Failed") {
-            Write-Err "Backend job failed"
-            break
-        }
-        if ($frontendJob.State -eq "Failed") {
-            Write-Err "Frontend job failed"
-            break
-        }
-    }
-} finally {
-    Write-Host ""
-    Write-Step "Shutting down..."
-    Stop-Job  -Job $backendJob,  $frontendJob -ErrorAction SilentlyContinue
-    Remove-Job -Job $backendJob, $frontendJob -ErrorAction SilentlyContinue -Force
-    Write-Ok "All services stopped"
-}

start.sh

@@ -41,7 +41,7 @@ fi
 # Resolve values from env with fallbacks
 OLLAMA_URL="${OLLAMA_HOST:-http://localhost:11434}"
 
-IFS=',' read -ra LLM_MODELS   <<< "${LLM_MODELS:-sciphi/triplex}"
+IFS=',' read -ra LLM_MODELS   <<< "${LLM_MODELS:-llama3}"
 IFS=',' read -ra SPACY_MODELS <<< "${SPACY_MODELS:-en_core_web_trf}"
 
 # Trim whitespace from each element