docs: rewrite README for launch

Author: Pro0f

CONTRIBUTING.md

@@ -0,0 +1,50 @@
+# Contributing to DevsContext
+
+Thanks for your interest in contributing!
+
+## Development Setup
+
+```bash
+git clone https://github.com/anthropics/devscontext.git
+cd devscontext
+pip install -e ".[dev]"
+```
+
+## Running Tests
+
+```bash
+pytest tests/
+```
+
+## Code Style
+
+We use ruff for linting and formatting:
+
+```bash
+ruff check .
+ruff format .
+mypy src/
+```
+
+## Pull Requests
+
+1. Fork the repo and create a branch from `main`
+2. Add tests for any new functionality
+3. Ensure tests pass and code is formatted
+4. Submit a PR with a clear description
+
+## Adding a New Adapter
+
+Adapters live in `src/devscontext/adapters/`. To add a new source:
+
+1. Create `adapters/your_source.py` extending `Adapter` base class
+2. Implement `fetch_context()`, `health_check()`, and any source-specific methods
+3. Add configuration model to `config.py`
+4. Wire into `DevsContextCore` in `core.py`
+5. Add tests in `tests/test_your_source.py`
+
+See `adapters/jira.py` as a reference implementation.
+
+## Questions?
+
+Open an issue or start a discussion.

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Pro0f
+Copyright (c) 2024 Anthropic
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,100 +1,160 @@
 # DevsContext
 
-**Synthesized engineering context for AI coding agents.**
+MCP server that gives AI coding agents synthesized engineering context — requirements, decisions, architecture, and standards — from your actual tools.
 
-DevsContext is an open-source MCP server that gives AI coding tools (Claude Code,
-Cursor, etc.) the full picture when working on a task — requirements, team decisions,
-architecture patterns, and coding standards — all in one synthesized context block.
+## The Problem
 
-> Large tech companies build this internally. DevsContext brings it to everyone.
+AI coding agents lack context. They don't know your team's decisions, architecture patterns, or coding standards. Connecting raw MCP servers floods them with irrelevant data they can't prioritize. Large companies build internal context infrastructure. DevsContext brings that to everyone.
 
-## The Problem
+## What You Get
+
+When you say "work on PROJ-123" in Claude Code, DevsContext fetches from Jira, meeting transcripts, and your docs, then synthesizes it into this:
+
+```markdown
+## Task: PROJ-123 — Add retry logic to payment webhook handler
+
+### Requirements
+1. Implement exponential backoff for failed webhook deliveries
+2. Max 5 retry attempts over 24 hours
+3. Dead-letter queue for permanently failed webhooks
+4. Metrics for retry success/failure rates
+
+Acceptance criteria: [Jira PROJ-123]
+- [ ] Webhooks retry with exponential backoff (1min, 5min, 30min, 2hr, 12hr)
+- [ ] Failed webhooks move to DLQ after 5 attempts
+- [ ] Dashboard shows retry metrics
+
+### Key Decisions
+- **Use SQS with visibility timeout** for retry scheduling, not cron jobs.
+  Decided by @sarah in March 15 sprint planning. Rationale: SQS handles
+  timing natively, reduces operational overhead. [Meeting: Sprint 23 Planning]
 
-AI coding agents are smart but lack context. They don't know:
-- Why a feature was decided on (from your sprint planning meeting)
-- How your team structures code (from your architecture docs)
-- What coding patterns to follow (from your style guides)
+- **Exponential backoff schedule**: 1min → 5min → 30min → 2hr → 12hr.
+  Based on payment processor rate limits. [Comment by @mike, Mar 16]
 
-Connecting individual MCP servers (Jira, Confluence, etc.) helps, but the AI
-gets flooded with raw data and picks up irrelevant context.
+### Architecture Context
+Webhook flow: `PaymentController` → `WebhookService.dispatch()` → SQS queue
+→ `WebhookWorker.process()` → external endpoint.
 
-## The Solution
+Add retry logic in `WebhookWorker.process()` at:
+`src/workers/webhook_worker.ts:45-80`
 
-DevsContext fetches from your tools, extracts what's relevant, and synthesizes
-it into a clean context block — so your AI agent knows *what* to build, *why*
-it was decided, and *how* it should be written.
+DLQ table schema in `migrations/004_webhook_dlq.sql`. [Architecture: payments-service.md]
+
+### Coding Standards
+- Use `Result<T, WebhookError>` pattern, don't throw exceptions
+- Retry delays: use `calculateBackoff(attempt)` helper from `src/utils/retry.ts`
+- Tests: mock SQS with `@aws-sdk/client-sqs-mock`, see `tests/workers/` for examples
+[Standards: typescript.md, testing.md]
+
+### Related Work
+- PROJ-456: "Payment webhook initial implementation" (Done) — base implementation
+- PROJ-789: "Add webhook monitoring dashboard" (In Progress) — will consume the metrics
+```
+
+One synthesized block. Everything the AI needs to write correct code.
 
 ## Quick Start
 
 ```bash
 pip install devscontext
 devscontext init
+```
+
+Set your credentials:
+```bash
+export JIRA_EMAIL="you@company.com"
+export JIRA_API_TOKEN="your-token"
+export ANTHROPIC_API_KEY="your-key"  # for synthesis
+```
+
+Connect to Claude Code:
+```bash
 claude mcp add devscontext -- devscontext serve
 ```
 
 Then in Claude Code:
-
 ```
-work on PROJ-1234
+> work on PROJ-123
 ```
 
-Claude automatically gets the full context.
+## Supported Sources
+
+| Source | What's Fetched |
+|--------|----------------|
+| **Jira** | Ticket details, comments, linked issues, acceptance criteria |
+| **Fireflies** | Meeting transcripts, decisions, action items |
+| **Local Docs** | Architecture docs, coding standards, ADRs |
+
+Coming soon: Linear, Notion, Confluence, Slack threads
 
 ## Configuration
 
-Create a `.devscontext.yaml` file in your project root:
+DevsContext uses `.devscontext.yaml` in your project root:
 
 ```yaml
 adapters:
   jira:
     enabled: true
     base_url: "https://your-company.atlassian.net"
-    email: "your-email@company.com"
+    email: "${JIRA_EMAIL}"
     api_token: "${JIRA_API_TOKEN}"
 
   fireflies:
-    enabled: false
+    enabled: false  # Optional
     api_key: "${FIREFLIES_API_KEY}"
 
   local_docs:
     enabled: true
     paths:
       - "./docs"
+      - "./CLAUDE.md"
 
-cache:
-  ttl_seconds: 300
-  max_size: 100
+synthesis:
+  provider: "anthropic"
+  model: "claude-3-haiku-20240307"
 ```
 
-## Available Tools
+See [.devscontext.yaml.example](.devscontext.yaml.example) for all options.
 
-| Tool | Description |
-|------|-------------|
-| `get_task_context` | Full synthesized context for a Jira ticket |
-| `search_context` | Search across all sources by keyword |
-| `get_standards` | Coding standards from local documentation |
+## How It Works
+
+1. **Fetch**: When you mention a ticket, DevsContext fetches from all configured sources in parallel
+2. **Extract**: It finds relevant content — ticket matches docs by component/label, searches meeting transcripts for keywords
+3. **Synthesize**: An LLM combines raw data into a structured context block with sources cited
+
+No background processes. No vector database. Just on-demand fetching and synthesis.
+
+## MCP Tools
+
+| Tool | When to Use | Example |
+|------|-------------|---------|
+| `get_task_context` | Starting work on a ticket | "work on PROJ-123" |
+| `search_context` | Questions about architecture or past decisions | "how do we handle payment retries?" |
+| `get_standards` | Checking coding conventions | "what are our testing standards?" |
 
 ## Development
 
 ```bash
-# Install from source
-git clone https://github.com/yourusername/devscontext.git
+git clone https://github.com/anthropics/devscontext.git
 cd devscontext
 pip install -e ".[dev]"
 
-# Run the MCP server
-devscontext serve
-
 # Run tests
 pytest
 
-# Linting
-ruff check src/
+# Lint
+ruff check . && mypy src/
 ```
 
-## Status
+## Contributing
+
+Contributions welcome! See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
 
-Early development — contributions welcome!
+Ideas for contributions:
+- New adapters (Linear, Notion, Confluence)
+- Better keyword extraction
+- Caching improvements
 
 ## License