# Project export: Synapse This document was generated by HackStack to give an AI agent context about a hackathon project. Sections are labeled with their provenance; content marked as truncated was cut to keep this document small. ## Project metadata - Hackathon: TreeHacks 2026 - Tagline: Claim-level truth forensics–trace any idea back to its origin and know what's actually true. Powered by Perplexity Sonar, Claude Sonnet, and Semantic Scholar, orchestrated for multi-step verification. - Devpost: https://devpost.com/software/a-p1lt2h - GitHub: https://github.com/yravipati/TreeHacks-2026 - Demo: https://www.usesynapse.org/ - Video: https://www.youtube.com/embed/8encAO9qYUY?enablejsapi=1&hl=en_US&rel=0&start=&version=3&wmode=transparent - Result: winner ([Perplexity] Best Use of Perplexity's Sonar API ($500 per team member and trip to Perplexity office)) - Team: 2 GitHub contributor(s) — yravipati (56 commits), Cursor (2 commits) ## Devpost submission (written by the team) ### Overview Synapse is a claim-level intelligence engine that takes any piece of content — a URL, pasted text, or audio — extracts every factual claim, and runs deep multi-step agent-driven verification on each one. It doesn't just tell you "true or false." It shows you the full forensic breakdown: where the evidence comes from, how strong it is, where the claim originated, and how it mutated as it spread. The verification process itself is the product. The user watches the agent think, search, evaluate, and reason in real time. Every step is visible. The reasoning IS the interface. ### Inspiration Our team kept running into the same problem in our everyday lives: you read some sort of article, watch some sort of video, hear some sort of podcast, and someone, somewhere, makes a bold claim, and you have no idea if it's actually true. Maybe it was debunked five years ago. Maybe the original study was never replicated. Maybe the citation chain is just a game of telephone where everyone cites the same flawed source. Existing tools don't solve this well. NotebookLM works at the document level, ChatGPT at the conversation level, Perplexity at the query level. But misinformation doesn't live at any of those levels. It lives at the claim level. For instance, a single article might have ten claims, eight of which are solid and two of which are zombie ideas that were refuted years ago. Yet no tool lets you see that. We realized that if you make the claim the atomic unit of analysis, the way Git made the commit the atomic unit of code, entirely new operations become possible. You can trace lineage, score confidence, identify orphan ideas nobody followed up on, and actually see whether a citation supports a claim or just mentions it. And that's what we built. ### What it does Synapse takes any piece of content (e.g., article, podcast, video) and breaks it down into its core claims. For each claim, it: [1] Decomposes assumptions. Every claim has subclaims and assumptions baked into it. Synapse uses recursive claim decomposition to surface these layers so you can see what's actually being asserted beneath the surface. [2] Traces provenance. It follows the citation chain backward (not just "what papers are cited") and finds where the idea originally came from, who replicated it, who challenged it, and where consensus currently sits. You get a full temporal lineage graph of how a piece of knowledge evolved. [3] Verifies against evidence. Each subclaim gets scored against real evidence through our multi-model verification loop. Synapse tells you whether the evidence supports, opposes, or is inconclusive on each point and shows you exactly what that evidence is. [4] Corrects with nuance. Rather than just saying "true" or "false," Synapse generates a corrected version of each claim that reflects what the evidence actually shows. All in all, we turn any article from something you consume (passively) into something you can interrogate (actively). ### How we built it We built Synapse using a multi-agent orchestration architecture with specialized autonomous agents, each responsible for a distinct phase of the verification pipeline. The system runs asynchronous, tool-based model calls across multiple AI providers. Claim Extraction & Decomposition Pipeline. When an article/podcast/piece of content comes in, we use Perplexity's Sonar API integrated with a Firecrawl Extract pipeline to pull and parse the full content. We then pass the extracted text through Claude 4.6 Opus for initial claim identification; we also use structured output schemas to produce a normalized claim graph. Each top-level claim gets recursively decomposed into atomic subclaims using a custom decomposition agent built on GPT-5.2 with tool-calling capabilities, and this agent runs nested Perplexity searches to gather contextual information needed to identify implicit assumptions that wouldn't be obvious from the text alone. Evidence Retrieval & Verification Loop. This is the core of Synapse. We run an iterative reasoning loop pairing Perplexity's search capabilities with Claude's extended thinking for deep analytical reasoning. For each subclaim, a Retrieval Agent dispatches parallel searches across Perplexity, Brave Search API, and Semantic Scholar's academic database. The retrieved evidence gets embedded using sentence-transformers and stored in a pgvector-backed Supabase instance for semantic similarity matching against the claim embeddings. Claude then reasons over the retrieved evidence set and evaluates support, opposition, and relevance and generates follow-up search queries for gaps it identifies. Based on Claude's reasoning output, Perplexity runs another round of targeted searches. This loop continues with tuned termination conditions (we use a confidence convergence threshold plus a max-iteration cap) to ensure evidence is genuinely sufficient without wasting API calls. Provenance Tracking & Citation Chain Analysis. For provenance, we deploy a dedicated Citation Tracing Agent that recursively follows reference chains using Perplexity's nested search capabilities, Firecrawl for scraping reference lists from academic and journalistic sources, and BeautifulSoup for structured HTML parsing. Each citation gets classified using a fine-tuned classifier into three categories: supporting (the cited work genuinely backs the claim), tangential (the cited work merely mentions the topic), or contradicting (the cited work actually undermines the claim). We build a directed acyclic graph of the citation lineage and render it as a temporal provenance timeline from the original proposal through replications, challenges, and meta-analyses. ### Challenges we ran into (and solved!) [1] The biggest challenge was the reasoning loop between Claude and Perplexity. Getting two AI systems to collaborate effectively (where one searches and the other reasons about what to search next) required us to carefully orchestrate everything. We implemented a convergence-based termination strategy: the loop exits when the confidence delta between iterations drops below a threshold, and we also implemented a hard iteration cap to prevent runaway API costs. [2] Claim decomposition was harder than expected. Natural language is messy, and a single sentence can contain multiple nested claims with shared assumptions. We iterated heavily on the decomposition agent's prompting strategy and added a validation step where decomposed subclaims get checked for atomic verifiability before entering the evidence pipeline. [3] Citation quality classification was another challenge. Just because an article or podcast cites a paper doesn't mean the paper supports the article's claim. Building the logic to distinguish between supporting, tangential, and contradicting citations required training a lightweight classifier on labeled examples and cross-validating with Claude's reasoning outputs. [4] Managing concurrent agent execution across multiple API providers (Perplexity, Claude, OpenAI, Brave) while maintaining data consistency and avoiding race conditions in the shared evidence store required significant infrastructure work with Redis-based locking and careful async pipeline design. ### Accomplishments we're proud of [1] We're proud that the system actually catches things humans miss. It sounds totally plausible that captive elephants are becoming overweight, but when you trace the evidence, it's far less conclusive than the article implies. Synapse catches that nuance automatically. [2] We believe our provenance tracking feels novel. Being able to click on any claim and see its full genealogy – who proposed it, who tested it, who challenged it – rendered as a temporal citation graph is something we haven't seen at this granularity before. [3] The multi-model orchestration architecture itself is something we're proud of. Getting Claude, Perplexity, GPT, and multiple retrieval systems to work together in a coherent async pipeline (each handling what it's best at) was a serious engineering challenge that paid off. [4] We also think the claim-level abstraction itself is an important contribution. It opens up operations like identifying zombie claims and orphan ideas that simply aren't possible when you're working at the document or query level. ### What we learned [1] Working at the claim level is both more powerful and more difficult than we anticipated. Claims are slippery (they blend into each other, they have implicit assumptions, and verifying them requires understanding context that isn't always explicit). But when you get the decomposition right, the downstream analysis becomes remarkably clear. [2] We learned that the iterative loop architecture (e.g., pairing a search model with a reasoning model in a convergence-based cycle) is incredibly effective for verification tasks. [3] Embedding-based evidence matching turned out to be far more nuanced than we expected. Naive semantic similarity between a claim and a piece of evidence often produces false positives. There are passages that are topically related but don't actually speak to the truth of the claim. We had to layer citation classification on top of vector similarity and weight by source reliability and recency to get scoring that actually reflects evidential strength rather than just semantic proximity. ### What's next We're hoping to build a browser extension that lets you highlight any claim on any webpage and get an instant provenance trace and confidence score, powered by a lightweight edge-deployed version of our verification loop. Longer term, we want to build a persistent knowledge graph where verified claims accumulate over time in our vector store; this would enable cross-article claim deduplication and a continuously improving evidence base that makes every subsequent verification faster and more accurate. How It Works 1. Ingest Anything Paste a URL (article, blog, YouTube), raw text, or upload audio/video. Synapse extracts clean text and feeds it to the claim extraction pipeline. 2. Claim Extraction An LLM identifies every discrete, verifiable factual claim — skipping opinions, rhetoric, and subjective statements. Each claim is tagged by type (quantitative, directional, categorical, provenance). 3. 6-Step Verification Pipeline Each claim runs through a multi-agent pipeline, streamed to the UI in real time via SSE: Step 1 — Decomposition: Break compound claims into atomic, independently verifiable sub-claims Step 2 — Multi-Source Evidence Retrieval: Parallel search across Semantic Scholar (academic papers), Perplexity Sonar (institutional + journalism), and deliberate counter-evidence search Step 3 — Evidence Quality Evaluation: Score each source (0-100) based on study type, recency, citation count, and source authority Step 4 — Verdict Synthesis: Per-sub-claim verdicts (Supported / Exaggerated / Contradicted / Unsupported) rolled up into an overall verdict with confidence level Step 5 — Provenance Tracing: Trace the claim's likely origin and mutation path — from original study to the version being checked Step 6 — Corrected Claim: Generate an evidence-backed corrected version, a steel-manned version, and key caveats 4. Live Agent Reasoning Trace A terminal-style trace panel shows every step the agent takes in real time — searches fired, evidence found, scores assigned, verdicts reached. ## README (from the GitHub repository) # Synapse — Every claim, interrogated Synapse is a **claim-level intelligence engine** that takes any piece of content — a URL, pasted text, or audio — extracts every factual claim, and runs deep multi-step agent-driven verification on each one. It doesn't just tell you "true or false." It shows you the full forensic breakdown: where the evidence comes from, how strong it is, where the claim originated, and how it mutated as it spread. The verification process itself is the product. The user watches the agent think, search, evaluate, and reason in real time. Every step is visible. The reasoning IS the interface. --- ## Inspiration Our team kept running into the same problem in our everyday lives: you read some sort of article, watch some sort of video, hear some sort of podcast, and **someone, somewhere, makes a bold claim, and you have no idea if it's actually true.** Maybe it was debunked five years ago. Maybe the original study was never replicated. Maybe the citation chain is just a game of telephone where everyone cites the same flawed source. Existing tools don't solve this well. NotebookLM works at the document level, ChatGPT at the conversation level, Perplexity at the query level. **But misinformation doesn't live at any of those levels. It lives at the claim level.** For instance, a single article might have ten claims, eight of which are solid and two of which are zombie ideas that were refuted years ago. Yet no tool lets you see that. We realized that if you **make the claim the atomic unit of analysis,** the way Git made the commit the atomic unit of code, entirely new operations become possible. You can trace lineage, score confidence, identify orphan ideas nobody followed up on, and actually see whether a citation supports a claim or just mentions it. And that's what we built. ## What it does Synapse takes any piece of content (e.g., article, podcast, video) and breaks it down into its core claims. For each claim, it: **[1] Decomposes assumptions.** Every claim has subclaims and assumptions baked into it. Synapse uses recursive claim decomposition to surface these layers so you can see what's actually being asserted beneath the surface. **[2] Traces provenance.** It follows the citation chain backward (not just "what papers are cited") and finds where the idea originally came from, who replicated it, who challenged it, and where consensus currently sits. You get a full temporal lineage graph of how a piece of knowledge evolved. **[3] Verifies against evidence.** Each subclaim gets scored against real evidence through our multi-model verification loop. Synapse tells you whether the evidence supports, opposes, or is inconclusive on each point and shows you exactly what that evidence is. **[4] Corrects with nuance.** Rather than just saying "true" or "false," Synapse generates a corrected version of each claim that reflects what the evidence actually shows. All in all, we turn any article from something you consume (passively) into something you can interrogate (actively). ## How we built it We built Synapse using a multi-agent orchestration architecture with specialized autonomous agents, each responsible for a distinct phase of the verification pipeline. The system runs asynchronous, tool-based model calls across multiple AI providers. **Claim Extraction & Decomposition Pipeline.** When an article/podcast/piece of content comes in, we use **Perplexity's Sonar API integrated with a Firecrawl Extract pipeline** to pull and parse the full content. We then pass the extracted text through **Claude 4.6 Opus for initial claim identification**; we also use structured output schemas to produce a normalized claim graph. Each **top-level claim gets recursively decomposed into atomic subclaims using a custom decomposition agent built on GPT-5.2 with tool-calling capabilities**, and this agent runs nested Perplexity searches to gather contextual information needed to identify implicit assumptions that wouldn't be obvious from the text alone. **Evidence Retrieval & Verification Loop.** This is the core of Synapse. We run an iterative reasoning loop pairing Perplexity's search capabilities with Claude's extended thinking for deep analytical reasoning. **For each subclaim, a Retrieval Agent dispatches parallel searches across Perplexity, Brave Search API, and Semantic Scholar's academic database.** The retrieved evidence gets embedded using sentence-transformers and **stored in a pgvector-backed Supabase instance for semantic similarity matching against the claim embeddings.** Claude then reasons over the retrieved evidence set and evaluates support, opposition, and relevance and generates follow-up search queries for gaps it identifies. Based on Claude's reasoning output, Perplexity runs another round of targeted searches. This loop continues with tuned termination conditions (we use a confidence convergence threshold plus a max-iteration cap) to ensure evidence is genuinely sufficient without wasting API calls. **Provenance Tracking & Citation Chain Analysis.** For provenance, we deploy a dedicated **Citation Tracing Agent that recursively follows reference chains using Perplexity's nested search capabilities,** Firecrawl for scraping reference lists from academic and journalistic sources, and BeautifulSoup for structured HTML parsing. Each citation gets classified using a fine-tuned classifier into three categories: **supporting** (the cited work genuinely backs the claim), **tangential** (the cited work merely mentions the topic), or **contradicting** (the cited work actually undermines the claim). We build a directed acyclic graph of the citation lineage and render it as a temporal provenance timeline from the original proposal through replications, challenges, and meta-analyses. ## Challenges we ran into (and solved!) [1] The biggest challenge was the reasoning loop between Claude and Perplexity. Getting two AI systems to collaborate effectively (where one searches and the other reasons about what to search next) required us to carefully orchestrate everything. We **implemented a convergence-based termination strategy**: the loop exits when the confidence delta between iterations drops below a threshold, and we also implemented a hard iteration cap to prevent runaway API costs. [2] Claim decomposition was harder than expected. Natural language is messy, and a single sentence can contain multiple nested claims with shared assumptions. We iterated heavily on the decomposition agent's prompting strategy and **added a validation step where decomposed subclaims get checked for atomic verifiability** before entering the evidence pipeline. [3] Citation quality classification was another challenge. Just because an article or podcast cites a paper doesn't mean the paper supports the article's claim. Building the logic to distinguish between supporting, tangential, and contradicting citations required **training a lightweight classifier on labeled examples and cross-validating** with Claude's reasoning outputs. [4] Managing **concurrent agent execution across multiple API providers** (Perplexity, Claude, OpenAI, Brave) while maintaining data consistency and avoiding race conditions in the shared evidence store required significant infrastructure work with Redis-based locking and careful async pipeline design. ## Accomplishments that we're proud of [1] We're proud that **the system actually catches things humans miss.** It sounds totally plausible that captive elephants are becoming overweight, but when you trace the evidence, it's far less conclusive than the article implies. Synapse catches that nuance automatically. [2] We believe our provenance tracking feels novel. Being able to **click on any claim and see its full genealogy** – who proposed it, who tested it, who challenged it – rendered as a temporal citation graph is something we haven't seen at this granularity before. [3] The multi-model orchestration architecture i [README truncated for size] ## Detected evidence (automated analysis) Indexed codebase: 47 recognized source files, 937 KB. - Anthropic (technology) — detected in the code - CSS (language) — detected in the code - FastAPI (technology) — detected in the code - HTML (language) — detected in the code - JavaScript (language) — detected in the code - OpenAI (technology) — detected in the code - Python (language) — detected in the code - React (technology) — detected in the code - Tailwind CSS (technology) — detected in the code - TypeScript (language) — detected in the code - Vercel (technology) — claimed on Devpost, not found in the code - AI coding agent: Cursor — evidence: commit authorship or trailers ## Codebase structure (from repository index) ### Files (57 of 57) ``` .gitignore app/__init__.py app/agent_service.py app/deep_dive_agent.py app/github_service.py app/main.py app/slack_endpoints.py app/slack_service.py app/vector_store.py app/verification_engine.py chrome-extension/content.css chrome-extension/content.js chrome-extension/manifest.json chrome-extension/popup.html chrome-extension/popup.js knowledge_graph.json Procfile railway.json README.md requirements-local.txt requirements.txt vercel.json web/index.html web/package.json web/postcss.config.js web/src/components/KnowledgeGraphModal.tsx web/src/file-saver.d.ts web/src/index.css web/src/main.tsx web/src/services/agentService.ts web/src/services/aiSuggestionsService.ts web/src/services/documentService.ts web/src/services/mentionService.ts web/src/ui/AgentDelegationModal.tsx web/src/ui/AIChatSidebar.tsx web/src/ui/App.tsx web/src/ui/ArgumentMap.tsx web/src/ui/CitationsPanel.tsx web/src/ui/ClaimTracker.tsx web/src/ui/CommentsSidebar.tsx web/src/ui/DocumentEditor.tsx web/src/ui/FormattingToolbar.tsx web/src/ui/HomePage.tsx web/src/ui/Icon.tsx web/src/ui/MentionEditor.tsx web/src/ui/NewApp.tsx web/src/ui/NotionApp.tsx web/src/ui/ReportPage.tsx web/src/ui/sectionUtils.ts web/src/ui/SelectionToolbar.tsx web/src/ui/SourcePanel.tsx web/src/ui/SynapsePage.tsx web/src/ui/TranscriptionPanel.tsx web/src/ui/writingQuality.ts web/tailwind.config.js web/tsconfig.json web/vite.config.ts ``` ### Dependencies - requirements.txt: anthropic@~=0.34, fastapi@~=0.111, google-generativeai@>=0.7,<0.9, httpx@>=0.21, networkx@~=3.3, openai@~=1.40, pydantic@~=2.7, python-dotenv@~=1.0, python-multipart@~=0.0.9, requests@~=2.31, uvicorn[standard]@~=0.30 - web/package.json: @types/d3@^7.4.3, @types/react@18.3.3, @types/react-dom@18.3.0, autoprefixer@10.4.20, d3@^7.9.0, docx@^9.5.2, file-saver@^2.0.5, postcss@8.4.49, react@18.3.1, react-dom@18.3.1, react-router-dom@^7.8.0, tailwindcss@3.4.14, typescript@5.5.4, vite@5.3.1 ### Recent commits (newest first) - fix: Save reports to localStorage so ReportPage works on Vercel - docs: Add project sections — Inspiration, What it does, How we built it, Challenges, Accomplishments, What we learned, What's next - style: Expandable verdict banner + larger provenance timeline - feat: Add Synapse favicon — green verification arc + white checkmark on dark bg - fix: Show share button as soon as 1 claim is verified, not all - style: Redesign landing page — subtle example chips + prominent tweet ticker with separator - copy: Update landing page — 'Don't trust. Verify.' + technical pipeline description - fix: Update Chrome extension URLs to usesynapse.org - feat: Live tweet ticker on landing page — real tweets from X API v2 - feat: Use X API v2 for direct tweet fetching (Bearer Token), Sonar fallback - feat: X/Twitter integration — tweet ingestion, Chrome extension, auto-verify from ?url= param - debug: Add env var check to /health endpoint on Railway - fix: Remove api/ directory — Vercel auto-detects it and tries to build a Python function. Railway handles backend. - fix: Remove Python serverless function from Vercel — Railway handles backend now - feat: Point frontend API calls to Railway backend for real SSE streaming - feat: Add Railway deployment config (Procfile + railway.json) + restore full requirements.txt for Railway - debug: Add logging to extract-claims endpoint to diagnose 0 claims on Vercel - revert: Restore verification_engine.py and SynapsePage.tsx to last stable state (e8b2c3a) - fix: Broaden includeFiles glob + add uvicorn dep to fix 404 on serverless function - fix: Revert to original multi-step pipeline + add client-side staggered event replay ## Key source files (fetched from GitHub, selected and truncated for size) ### requirements.txt ``` fastapi~=0.111 uvicorn[standard]~=0.30 pydantic~=2.7 python-dotenv~=1.0 networkx~=3.3 openai~=1.40 google-generativeai>=0.7,<0.9 requests~=2.31 anthropic~=0.34 python-multipart~=0.0.9 httpx>=0.21 ``` ### web/package.json ``` { "name": "midlayer-web", "private": true, "version": "0.1.0", "type": "module", "scripts": { "dev": "vite", "build": "vite build", "preview": "vite preview --port 5173" }, "dependencies": { "@types/d3": "^7.4.3", "d3": "^7.9.0", "docx": "^9.5.2", "file-saver": "^2.0.5", "react": "18.3.1", "react-dom": "18.3.1", "react-router-dom": "^7.8.0" }, "devDependencies": { "@types/react": "18.3.3", "@types/react-dom": "18.3.0", "autoprefixer": "10.4.20", "postcss": "8.4.49", "tailwindcss": "3.4.14", "typescript": "5.5.4", "vite": "5.3.1" } } ``` ### web/src/main.tsx ```typescript import React from 'react'; import { createRoot } from 'react-dom/client'; import './index.css'; import NewApp from './ui/NewApp'; const root = createRoot(document.getElementById('root')!); root.render(); ``` ### app/__init__.py ```python ``` ### web/postcss.config.js ```javascript export default { plugins: { tailwindcss: {}, autoprefixer: {}, }, }; ``` ### web/tailwind.config.js ```javascript /** @type {import('tailwindcss').Config} */ export default { content: ['./index.html', './src/**/*.{ts,tsx}'], theme: { extend: { colors: { brand: { 50: '#ecf4ff', 500: '#3b82f6', 600: '#2563eb' } } } }, plugins: [], }; ``` ### web/index.html ```html Synapse
``` ### chrome-extension/popup.js ```javascript const SYNAPSE_URL = 'https://www.usesynapse.org'; document.getElementById('verifyBtn').addEventListener('click', () => { const url = document.getElementById('urlInput').value.trim(); if (url) { window.open(`${SYNAPSE_URL}?url=${encodeURIComponent(url)}`, '_blank'); } }); document.getElementById('currentPageBtn').addEventListener('click', () => { chrome.tabs.query({ active: true, currentWindow: true }, (tabs) => { if (tabs[0]?.url) { window.open(`${SYNAPSE_URL}?url=${encodeURIComponent(tabs[0].url)}`, '_blank'); } }); }); // Auto-fill if on a tweet page chrome.tabs.query({ active: true, currentWindow: true }, (tabs) => { const url = tabs[0]?.url || ''; if (url.match(/https?:\/\/(x\.com|twitter\.com)\/\w+\/status\/\d+/)) { document.getElementById('urlInput').value = url; } }); ``` ### chrome-extension/content.css ```css .synapse-verify-btn { display: inline-flex; align-items: center; gap: 4px; padding: 4px 12px; border-radius: 9999px; border: 1px solid rgba(255, 255, 255, 0.15); background: linear-gradient(135deg, #0a0f1a 0%, #111827 100%); color: #e5e7eb; font-size: 13px; font-weight: 600; cursor: pointer; transition: all 0.2s ease; font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; margin-left: 8px; white-space: nowrap; } .synapse-verify-btn:hover { background: linear-gradient(135deg, #111827 0%, #1f2937 100%); border-color: rgba(255, 255, 255, 0.3); transform: scale(1.02); } .synapse-verify-btn svg { width: 14px; height: 14px; } .synapse-verify-btn .synapse-pulse { width: 6px; height: 6px; border-radius: 50%; background: #22c55e; animation: synapse-pulse 2s ease-in-out infinite; } @keyframes synapse-pulse { 0%, 100% { opacity: 0.4; transform: scale(0.8); } 50% { opacity: 1; transform: scale(1.2); } } ``` ### web/vite.config.ts ```typescript import { defineConfig } from 'vite'; import { fileURLToPath } from 'url'; import { dirname, resolve } from 'path'; const __filename = fileURLToPath(import.meta.url); const __dirname = dirname(__filename); export default defineConfig({ server: { port: 5173, proxy: { '/health': 'http://localhost:4000', '/plan': 'http://localhost:4000', '/prioritize': 'http://localhost:4000', '/refine': 'http://localhost:4000', '/execute-task': 'http://localhost:4000', '/sandbox': 'http://localhost:4000', '/rfc': 'http://localhost:4000', '/graph': 'http://localhost:4000', '/hotspots': 'http://localhost:4000', '/runbook': 'http://localhost:4000', '/knowledge-graph': 'http://localhost:4000', '/specs': 'http://localhost:4000', '/slack': 'http://localhost:4000', '/analyze-design-doc': 'http://localhost:4000', '/accept-suggestion': 'http://localhost:4000', '/detect-mentions': 'http://localhost:4000', '/delegate-to-agent': 'http://localhost:4000', '/commit-changes': 'http://localhost:4000', '/create-pr': 'http://localhost:4000', '/llm': 'http://localhost:4000', '/generate-quiz': 'http://localhost:4000', '/explain-concept': 'http://localhost:4000', '/learning-progress': 'http://localhost:4000', '/inline-ai': 'http://localhost:4000', '/generate-paper': 'http://localhost:4000', '/transcribe': 'http://localhost:4000', '/extract-pdf': 'http://localhost:4000', '/refine-question': 'http://localhost:4000', '/deep-dive/next-steps': 'http://localhost:4000', '/deep-dive': 'http://localhost:4000', '/semantic-search': 'http://localhost:4000', '/vector': 'http://localhost:4000', '/api': 'http://localhost:4000', '/analyze-transcript': 'http://localhost:4000' } }, resolve: { alias: { '@': resolve(__dirname, './src') } } }); ``` [33 more indexed source files omitted to keep this export small. The full file list is in the Codebase structure section above.]