agent-os-kernel 1.1.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

modules/caas/paper/method.md

@@ -0,0 +1,350 @@
+# Method
+
+## System Overview
+
+Context-as-a-Service (CaaS) is a modular pipeline for intelligent context extraction and serving. Figure 1 illustrates the overall architecture.
+
+```
+┌─────────────┐     ┌──────────────┐     ┌─────────────┐     ┌──────────────┐
+│  Ingestion  │ ──▶ │  Structure   │ ──▶ │  Metadata   │ ──▶ │    Time      │
+│  (PDF/HTML/ │     │   Parser     │     │  Injector   │     │    Decay     │
+│   Code)     │     └──────────────┘     └─────────────┘     └──────────────┘
+└─────────────┘            │                    │                    │
+                           ▼                    ▼                    ▼
+                    ┌────────────────────────────────────────────────────┐
+                    │              Indexed Document Store                │
+                    │         (Three-Tier Value Hierarchy)              │
+                    └────────────────────────────────────────────────────┘
+                                          │
+                                          ▼
+                    ┌────────────────────────────────────────────────────┐
+                    │              Context Triad Assembly                │
+                    │         (Hot / Warm / Cold Prioritization)         │
+                    └────────────────────────────────────────────────────┘
+                                          │
+                    ┌─────────────────────┼─────────────────────┐
+                    ▼                     ▼                     ▼
+            ┌─────────────┐       ┌─────────────┐       ┌─────────────┐
+            │ Heuristic   │       │  Pragmatic  │       │    Trust    │
+            │   Router    │       │    Truth    │       │   Gateway   │
+            └─────────────┘       └─────────────┘       └─────────────┘
+                    │                     │                     │
+                    └─────────────────────┼─────────────────────┘
+                                          ▼
+                                    ┌───────────┐
+                                    │    LLM    │
+                                    └───────────┘
+```
+
+## Structure-Aware Indexing
+
+### Problem
+
+Traditional RAG systems use **flat chunking**: split documents into fixed-size segments (e.g., 500 tokens) and embed each equally. This approach treats a class definition the same as a TODO comment, losing the structural signals that encode importance.
+
+### Solution: Three-Tier Value Hierarchy
+
+We classify document content into three value tiers based on document type and structural patterns:
+
+**Algorithm 1: Structure-Aware Classification**
+
+```python
+def classify_content(chunk, doc_type):
+    if doc_type == "code":
+        if is_class_or_function_definition(chunk):
+            return HIGH_VALUE
+        elif is_docstring_or_comment(chunk):
+            return MEDIUM_VALUE
+        else:  # imports, config, TODOs
+            return LOW_VALUE
+    
+    elif doc_type == "legal":
+        if is_definitions_or_liability(chunk):
+            return HIGH_VALUE
+        elif is_terms_or_conditions(chunk):
+            return MEDIUM_VALUE
+        else:  # boilerplate, signatures
+            return LOW_VALUE
+    
+    # ... similar rules for policy, documentation, etc.
+```
+
+### Value Tier Definitions
+
+| Tier | Code | Legal | Policy | Documentation |
+|------|------|-------|--------|---------------|
+| **HIGH** | Class/function defs | Definitions, liability | Core requirements | API endpoints |
+| **MEDIUM** | Docstrings, comments | Terms, conditions | Guidelines | Examples, explanations |
+| **LOW** | Imports, TODOs | Boilerplate, signatures | Formatting | Metadata, headers |
+
+### Retrieval Weighting
+
+During retrieval, we apply multiplicative weights:
+
+$$\text{score}(c) = \text{similarity}(q, c) \times w_{\text{tier}}(c)$$
+
+Where $w_{\text{HIGH}} = 1.5$, $w_{\text{MEDIUM}} = 1.0$, $w_{\text{LOW}} = 0.5$.
+
+## Metadata Injection
+
+### Problem
+
+When chunks are extracted from documents, they lose context. "It increased by 5%" is meaningless without knowing the document path: `Q3 Earnings → Revenue → North America`.
+
+### Solution: Contextual Breadcrumbs
+
+We automatically inject metadata into each chunk:
+
+```python
+@dataclass
+class EnrichedChunk:
+    content: str
+    metadata: ChunkMetadata
+
+@dataclass  
+class ChunkMetadata:
+    document_path: str      # "Q3_Earnings.pdf"
+    section_hierarchy: List[str]  # ["Revenue", "North America"]
+    created_at: datetime
+    updated_at: datetime
+    source_type: str        # "official" | "informal"
+    confidence: float       # 0.0 - 1.0
+```
+
+The metadata is prepended to the chunk content before sending to the LLM:
+
+```
+[Source: Q3_Earnings.pdf > Revenue > North America | Updated: 2026-01-15]
+Revenue increased by 5% compared to Q2, driven primarily by...
+```
+
+## Time-Based Decay
+
+### Problem
+
+Semantic similarity ignores temporal relevance. A 2021 answer to "How to restart the server" may match perfectly but be dangerously outdated.
+
+### Solution: Exponential Decay
+
+We apply time-based decay using an exponential function inspired by radioactive decay:
+
+$$\text{decay}(t) = e^{-\lambda t}$$
+
+Where:
+- $t$ = time since document creation/update (days)
+- $\lambda = \ln(2) / T_{1/2}$ (decay constant)
+- $T_{1/2}$ = half-life parameter (configurable per domain)
+
+**Algorithm 2: Time-Aware Scoring**
+
+```python
+def time_adjusted_score(chunk, query, half_life_days=90):
+    base_score = semantic_similarity(query, chunk.content)
+    
+    age_days = (now() - chunk.metadata.updated_at).days
+    decay_factor = exp(-log(2) * age_days / half_life_days)
+    
+    return base_score * decay_factor
+```
+
+### Domain-Specific Half-Lives
+
+| Domain | Half-Life | Rationale |
+|--------|-----------|-----------|
+| Code/Engineering | 90 days | APIs change frequently |
+| Policy/HR | 365 days | Policies updated annually |
+| Legal | 730 days | Contracts have longer validity |
+| Incidents | 30 days | Recent incidents most relevant |
+
+## Context Triad
+
+### Problem
+
+Traditional systems stuff context into the LLM window with no priority distinction. A user's current question, their preferences, and historical archives from years ago compete equally for space.
+
+### Solution: Hot/Warm/Cold Classification
+
+We organize context into three intimacy-based tiers:
+
+| Tier | Content | Token Budget | Priority |
+|------|---------|--------------|----------|
+| **Hot** 🔥 | Current conversation, last 10 turns | 2,000 | Highest |
+| **Warm** 🌡️ | User preferences, recent documents | 1,000 | Medium |
+| **Cold** ❄️ | Historical archives, reference docs | 5,000 | Lowest |
+
+**Algorithm 3: Context Assembly**
+
+```python
+def assemble_context(query, conversation, user_profile, retrieved_docs):
+    context = ContextTriad()
+    
+    # Hot: Preserve recent turns exactly (FIFO, no summarization)
+    context.hot = conversation.get_last_n_turns(10)
+    context.hot.truncate_to_tokens(2000)
+    
+    # Warm: User context and recent activity
+    context.warm = user_profile.preferences + user_profile.recent_docs
+    context.warm.truncate_to_tokens(1000)
+    
+    # Cold: Retrieved documents, time-decayed and ranked
+    context.cold = rank_by_relevance_and_time(retrieved_docs, query)
+    context.cold.truncate_to_tokens(5000)
+    
+    return context.assemble()  # Total: 8,000 tokens
+```
+
+### FIFO vs. Summarization
+
+We explicitly reject summarization for conversation history:
+
+| Approach | Pros | Cons |
+|----------|------|------|
+| **Summarization** | Compresses more history | Loses nuance, costs tokens to generate |
+| **FIFO (Ours)** | Preserves exact recent content | Loses older context |
+
+Our philosophy: **"Chopping > Summarizing"**. Users rarely reference content from 20 minutes ago but frequently reference the exact code snippet from 30 seconds ago.
+
+## Heuristic Router
+
+### Problem
+
+ML-based routers add latency (15-50ms). LLM-based routers are slower still (100-500ms). For high-volume enterprise deployments, this latency compounds.
+
+### Solution: Deterministic Rules
+
+We use a rule-based router with **zero model inference**:
+
+**Algorithm 4: Heuristic Routing**
+
+```python
+def route_query(query):
+    query_lower = query.lower()
+    
+    # Keyword-based routing
+    if any(kw in query_lower for kw in ["error", "bug", "crash", "fail"]):
+        return RouteType.TROUBLESHOOTING
+    
+    if any(kw in query_lower for kw in ["how to", "steps", "guide"]):
+        return RouteType.PROCEDURAL
+    
+    if any(kw in query_lower for kw in ["policy", "rule", "allowed"]):
+        return RouteType.POLICY
+    
+    if any(kw in query_lower for kw in ["api", "endpoint", "request"]):
+        return RouteType.TECHNICAL
+    
+    # Default: general retrieval
+    return RouteType.GENERAL
+```
+
+### Routing Performance
+
+| Router | Mean Latency | Accuracy |
+|--------|--------------|----------|
+| LLM-based | 450ms | 95% |
+| ML-based | 15ms | 92% |
+| **Heuristic (Ours)** | **0.003ms** | **89%** |
+
+We trade 3-6% accuracy for **5,000-150,000x speedup**. For most enterprise queries, deterministic rules suffice.
+
+## Pragmatic Truth
+
+### Problem
+
+Official documentation often contains theoretical or aspirational information. The actual truth lives in Slack logs, incident reports, and team notes.
+
+### Solution: Dual-Source Tracking
+
+We maintain parallel indices for official and informal sources:
+
+```python
+@dataclass
+class PragmaticTruthResult:
+    official_answer: str
+    official_source: str
+    informal_answer: Optional[str]
+    informal_source: Optional[str]
+    conflict_detected: bool
+    conflict_explanation: Optional[str]
+```
+
+**Algorithm 5: Conflict Detection**
+
+```python
+def detect_conflict(official_chunks, informal_chunks, query):
+    official_answer = synthesize(official_chunks)
+    informal_answer = synthesize(informal_chunks)
+    
+    # Semantic similarity between answers
+    similarity = cosine_similarity(
+        embed(official_answer), 
+        embed(informal_answer)
+    )
+    
+    if similarity < CONFLICT_THRESHOLD:  # e.g., 0.7
+        return Conflict(
+            official=official_answer,
+            informal=informal_answer,
+            explanation=generate_conflict_explanation(
+                official_answer, informal_answer
+            )
+        )
+    
+    return NoConflict(answer=official_answer)
+```
+
+### Example Output
+
+**Query**: "What's the API rate limit?"
+
+| Source Type | Answer | Source |
+|-------------|--------|--------|
+| Official | "100 requests/minute" | api_docs.md |
+| Informal | "Crashes around 50; the docs lie" | #engineering Slack |
+| **Conflict** | ⚠️ Yes | |
+
+**CaaS Response**: "The official documentation states 100 requests/minute, but engineering discussions indicate the practical limit is closer to 50 requests/minute before performance degradation."
+
+## Trust Gateway
+
+### Problem
+
+Third-party routing services require sending proprietary data through external APIs. No enterprise CISO accepts this data leakage risk.
+
+### Solution: On-Premises Deployment
+
+The Trust Gateway is designed for deployment behind the enterprise firewall:
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    ENTERPRISE NETWORK                        │
+│  ┌─────────────┐     ┌─────────────────┐     ┌───────────┐  │
+│  │  Internal   │ ──▶ │  Trust Gateway  │ ──▶ │  LLM API  │  │
+│  │  Services   │     │  (On-Prem)      │     │ (External)│  │
+│  └─────────────┘     └─────────────────┘     └───────────┘  │
+│                             │                               │
+│                      No PII/proprietary                     │
+│                      data leaves network                    │
+│                      until sanitized                        │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### Security Properties
+
+1. **Data Sovereignty**: All processing happens within enterprise boundaries
+2. **Audit Logging**: Complete trace of all context assembly decisions
+3. **PII Filtering**: Optional sanitization before external API calls
+4. **Model Agnostic**: Route to any LLM provider (OpenAI, Anthropic, local)
+
+---
+
+## Implementation
+
+CaaS is implemented in Python 3.8+ with the following dependencies:
+
+- **FastAPI**: REST API server
+- **Pydantic**: Data validation and serialization
+- **NumPy/scikit-learn**: Vector operations
+- **tiktoken**: Token counting
+
+The complete implementation is open-source: https://github.com/imran-siddique/context-as-a-service

modules/caas/paper/outline.md

@@ -0,0 +1,123 @@
+# Paper Outline
+
+**Working Title:** Context-as-a-Service: A Principled Architecture for Enterprise RAG Systems
+
+---
+
+## 1. Abstract (~250 words)
+- Problem: Seven fallacies in production RAG
+- Solution: CaaS framework with 5 novel components
+- Results: +28% Precision@5, sub-ms routing, enterprise-ready
+- See [abstract.md](abstract.md) for current draft
+
+## 2. Introduction (1.5 pages)
+- Motivation: RAG is ubiquitous but broken at scale
+- The Seven Fallacies (brief enumeration)
+- Contributions (numbered list):
+  1. Taxonomy of RAG pitfalls
+  2. Structure-aware indexing
+  3. Context Triad (Hot/Warm/Cold)
+  4. Pragmatic Truth tracking
+  5. Trust Gateway architecture
+  6. Heuristic Router
+  7. Open benchmark corpus
+
+## 3. Related Work (1 page)
+- See [../docs/RELATED_WORK.md](../docs/RELATED_WORK.md)
+- RAG frameworks (LlamaIndex, LangChain, Haystack)
+- Context management (MemGPT, Reflexion)
+- Enterprise AI deployment challenges
+- Temporal/decay-based retrieval
+
+## 4. The Seven Fallacies (1 page)
+- 4.1 Flat Chunk Fallacy (Structure)
+- 4.2 Context Amnesia (Metadata)
+- 4.3 Time-Blind Retrieval (Temporal)
+- 4.4 Flat Context Fallacy (Priority)
+- 4.5 Official Truth Fallacy (Source)
+- 4.6 Brutal Squeeze (Summarization)
+- 4.7 Middleware Gap (Trust)
+
+## 5. Method: CaaS Architecture (2 pages)
+- 5.1 System Overview (Figure 1: Architecture diagram)
+- 5.2 Structure-Aware Indexing
+  - Three-tier value hierarchy (High/Medium/Low)
+  - Algorithm 1: Structure detection
+- 5.3 Context Triad
+  - Hot: Current conversation
+  - Warm: User preferences, recent docs
+  - Cold: Historical archives
+  - Figure 2: Triad visualization
+- 5.4 Pragmatic Truth
+  - Official vs. practical knowledge
+  - Conflict detection algorithm
+- 5.5 Heuristic Router
+  - Deterministic routing rules
+  - Zero-latency design
+- 5.6 Trust Gateway
+  - On-premises deployment
+  - Security properties
+
+## 6. Experiments (2 pages)
+- 6.1 Benchmark Corpus
+  - 16 enterprise documents
+  - Domain distribution (Table 1)
+  - Available on Hugging Face
+- 6.2 Baselines
+  - Naive chunking (500 tokens)
+  - LlamaIndex default
+  - LangChain default
+- 6.3 Metrics
+  - Precision@K, NDCG@K
+  - Routing latency
+  - Token efficiency
+- 6.4 Results
+  - Table 2: Main results (+28.1% P@5)
+  - Table 3: Ablation study
+  - Table 4: Latency comparison (0.003ms routing)
+- 6.5 Statistical Significance
+  - Paired t-tests (p < 0.001)
+  - Cohen's d = 3.36 (large effect)
+
+## 7. Discussion (0.5 pages)
+- Limitations
+  - Small benchmark corpus (16 docs)
+  - Synthetic documents
+  - No end-to-end LLM evaluation
+- Broader Impact
+  - Enterprise adoption considerations
+  - Privacy implications of Trust Gateway
+- Future Work
+  - Larger evaluation corpora
+  - Integration with more LLM providers
+  - Learned routing (optional hybrid)
+
+## 8. Conclusion (0.5 pages)
+- Summary of contributions
+- Call to action: open-source, reproducible
+
+## 9. References
+- ~30-40 citations
+- RAG papers, enterprise AI, context management
+
+---
+
+## Appendices (Supplementary)
+- A. Full hyperparameter tables
+- B. Additional qualitative examples
+- C. Pseudocode for all algorithms
+- D. Dataset card
+
+---
+
+## Figures Needed
+- [ ] Fig 1: System architecture
+- [ ] Fig 2: Context Triad diagram
+- [ ] Fig 3: Structure-aware indexing example
+- [ ] Fig 4: Results bar chart
+
+## Tables Needed
+- [x] Table 1: Corpus statistics (in dataset card)
+- [x] Table 2: Main results (from run_evaluation.py)
+- [x] Table 3: Ablation study (from run_evaluation.py)
+- [x] Table 4: Statistical tests (from statistical_tests.py)

modules/caas/paper/related_work.md

@@ -0,0 +1,101 @@
+# Related Work
+
+*Adapted from [docs/RELATED_WORK.md](../docs/RELATED_WORK.md)*
+
+## Retrieval-Augmented Generation
+
+The foundation of modern RAG systems traces to Lewis et al. [1], who introduced the paradigm of combining retrieval with generation for knowledge-intensive NLP tasks. Subsequent work by Guu et al. [2] demonstrated the benefits of retrieval-augmented pre-training, while Izacard & Grave [3] developed the Fusion-in-Decoder architecture for open-domain QA.
+
+CaaS differs from these foundational approaches by focusing on the **serving-time context management** problem rather than the retrieval mechanism itself. We assume any retriever (dense, sparse, or hybrid) and instead optimize how retrieved context is organized, prioritized, and presented to the LLM.
+
+## Document Structure and Hierarchical Indexing
+
+Hierarchical document understanding has been explored in summarization [4, 5] and document-level NLP [6]. These works demonstrate that respecting document structure improves downstream performance. CaaS applies this insight to RAG through our **three-tier value hierarchy** (High/Medium/Low), which explicitly encodes structural importance into the retrieval ranking.
+
+Unlike learned hierarchical representations, CaaS uses **deterministic heuristics** based on document type detection (code, legal, policy, etc.), enabling zero-latency decisions without model inference.
+
+## Temporal Information Retrieval
+
+The importance of time in retrieval has been studied extensively in web search [7] and more recently in LLM contexts [8, 9]. Kasai et al. [10] introduced RealTime QA, demonstrating that time-sensitive questions require time-aware retrieval. Lazaridou et al. [11] showed that language models struggle with temporal knowledge degradation.
+
+CaaS implements **explicit time-based decay** with configurable half-life parameters, inspired by radioactive decay models. Unlike implicit temporal signals in embeddings, our approach provides transparent, explainable temporal weighting.
+
+## Source Attribution and Provenance
+
+Recent work on attribution [12, 13, 14] addresses the challenge of tracing generated content to sources. Menick et al. [12] trained models to support answers with verified quotes, while Rashkin et al. [14] developed metrics for attribution quality.
+
+CaaS's **Pragmatic Truth** module extends attribution by explicitly tracking **conflicts between sources**—surfacing when official documentation disagrees with informal sources (Slack, tickets, incident reports). This addresses a gap in current attribution systems that assume source consistency.
+
+## The Accumulation Paradox and Long-Context Degradation
+
+A growing body of work reveals a counterintuitive phenomenon we term the **Accumulation Paradox**: adding more context to LLMs can paradoxically *degrade* rather than improve performance. Liu et al. [21] demonstrated this empirically in their landmark "Lost in the Middle" study, showing that model performance follows a U-shaped curve where information in the middle of long contexts is systematically ignored. They found that "performance can degrade significantly when changing the position of relevant information, indicating that current language models do not robustly make use of information in long input contexts."
+
+This degradation extends to streaming and agentic settings. Xiao et al. [22] showed that window attention mechanisms fail entirely when context length exceeds cache size, introducing the "attention sink" phenomenon where initial tokens receive disproportionate attention regardless of semantic relevance. Li et al. [23] further demonstrated that even purpose-built long-context LLMs struggle with accumulated context, revealing biases toward later-presented information and degraded reasoning over multiple context pieces.
+
+For agentic AI systems with extended interactions, Packer et al. [24] (MemGPT) showed that raw context accumulation cannot sustain long-running agents, proposing virtual context management inspired by operating system memory hierarchies. This work directly motivates CaaS's approach: rather than assuming more context is better, we implement **intelligent context decay and prioritization** that acknowledges the Accumulation Paradox.
+
+CaaS addresses these challenges through: (1) **time-based decay** that naturally deprioritizes older context before it causes degradation, (2) **the Context Triad** (Hot/Warm/Cold) that ensures the most relevant context occupies attention-friendly positions, and (3) **structure-aware indexing** that prevents low-value content from diluting the context window.
+
+## Context Window Management
+
+Managing long conversations and context windows is a growing challenge as LLMs are deployed in production [15, 16]. Common approaches include summarization [17] and compression [18], but these introduce lossy transformations that can discard critical details.
+
+CaaS takes a different approach with **FIFO sliding window management**: rather than summarizing poorly, we truncate precisely. Our philosophy—"Chopping > Summarizing"—preserves recent turns losslessly while accepting that older context is simply dropped. This design choice reflects the empirical observation that users rarely reference content from many turns ago, but frequently reference the exact code or error message from seconds ago.
+
+## Enterprise AI Deployment
+
+The enterprise deployment of LLMs introduces unique challenges around security, compliance, and data sovereignty [19, 20]. While cloud-based routing services offer cost optimization through model selection, they create unacceptable data leakage risks for sensitive enterprise data.
+
+CaaS's **Trust Gateway** addresses this through an on-premises deployment model. Rather than competing on routing intelligence, we compete on trust: enterprises deploy the gateway behind their firewall, maintaining complete data sovereignty while still benefiting from intelligent context serving.
+
+---
+
+## References
+
+[1] Lewis, P., et al. (2020). "Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks." *NeurIPS 2020*. https://arxiv.org/abs/2005.11401
+
+[2] Guu, K., et al. (2020). "REALM: Retrieval-Augmented Language Model Pre-Training." *ICML 2020*. https://arxiv.org/abs/2002.08909
+
+[3] Izacard, G., & Grave, E. (2021). "Leveraging Passage Retrieval with Generative Models for Open Domain Question Answering." *EACL 2021*. https://arxiv.org/abs/2007.01282
+
+[4] Cohan, A., et al. (2018). "A Discourse-Aware Attention Model for Abstractive Summarization of Long Documents." *NAACL 2018*. https://arxiv.org/abs/1804.05685
+
+[5] Liu, Y., & Lapata, M. (2019). "Hierarchical Transformers for Multi-Document Summarization." *ACL 2019*. https://arxiv.org/abs/1905.13164
+
+[6] Xiao, W., & Carenini, G. (2019). "Extractive Summarization of Long Documents by Combining Global and Local Context." *EMNLP 2019*. https://arxiv.org/abs/1909.08089
+
+[7] Campos, R., et al. (2014). "Survey of Temporal Information Retrieval and Scoping Methods." *WWW Journal*. DOI: 10.1007/s11280-013-0230-y
+
+[8] Dai, Z., & Callan, J. (2019). "Deeper Text Understanding for IR with Contextual Neural Language Modeling." *SIGIR 2019*. https://arxiv.org/abs/1905.09217
+
+[9] Nguyen, T., et al. (2016). "A Neural Network Approach to Context-Sensitive Generation of Conversational Responses." *NAACL 2016*. https://arxiv.org/abs/1506.06714
+
+[10] Kasai, J., et al. (2022). "RealTime QA: What's the Answer Right Now?" *NeurIPS 2022*. https://arxiv.org/abs/2207.13332
+
+[11] Lazaridou, A., et al. (2021). "Mind the Gap: Assessing Temporal Generalization in Neural Language Models." *NeurIPS 2021*. https://arxiv.org/abs/2102.01951
+
+[12] Menick, J., et al. (2022). "Teaching Language Models to Support Answers with Verified Quotes." *NeurIPS 2022*. https://arxiv.org/abs/2203.11147
+
+[13] Gao, L., et al. (2022). "Rarr: Researching and Revising What Language Models Say, Using Language Models." *ACL 2023*. https://arxiv.org/abs/2210.08726
+
+[14] Rashkin, H., et al. (2021). "Measuring Attribution in Natural Language Generation Models." *Computational Linguistics 2021*. https://arxiv.org/abs/2112.12870
+
+[15] Dinan, E., et al. (2019). "Wizard of Wikipedia: Knowledge-Powered Conversational Agents." *ICLR 2019*. https://arxiv.org/abs/1811.01241
+
+[16] Zhang, S., et al. (2020). "DialoGPT: Large-Scale Generative Pre-training for Conversational Response Generation." *ACL 2020*. https://arxiv.org/abs/1911.00536
+
+[17] Chevalier, A., et al. (2023). "Adapting Language Models to Compress Contexts." *EMNLP 2023*. https://arxiv.org/abs/2305.14788
+
+[18] Gekhman, Z., et al. (2023). "Does Fine-Tuning LLMs on New Knowledge Encourage Hallucinations?" *arXiv*. https://arxiv.org/abs/2405.05904
+
+[19] Wang, L., et al. (2023). "Self-RAG: Learning to Retrieve, Generate, and Critique through Self-Reflection." *arXiv*. https://arxiv.org/abs/2310.11511
+
+[20] Khattab, O., et al. (2021). "Baleen: Robust Multi-Hop Reasoning at Scale via Condensed Retrieval." *NeurIPS 2021*. https://arxiv.org/abs/2101.00436
+
+[21] Liu, N. F., Lin, K., Hewitt, J., Paranjape, A., Bevilacqua, M., Petroni, F., & Liang, P. (2023). "Lost in the Middle: How Language Models Use Long Contexts." *Transactions of the Association for Computational Linguistics (TACL)*. https://arxiv.org/abs/2307.03172
+
+[22] Xiao, G., Tian, Y., Chen, B., Han, S., & Lewis, M. (2024). "Efficient Streaming Language Models with Attention Sinks." *ICLR 2024*. https://arxiv.org/abs/2309.17453
+
+[23] Li, T., Zhang, G., Do, Q. D., Yue, X., & Chen, W. (2024). "Long-context LLMs Struggle with Long In-context Learning." *arXiv*. https://arxiv.org/abs/2404.02060
+
+[24] Packer, C., Wooders, S., Lin, K., Fang, V., Patil, S. G., Stoica, I., & Gonzalez, J. E. (2023). "MemGPT: Towards LLMs as Operating Systems." *arXiv*. https://arxiv.org/abs/2310.08560

modules/caas/paper/tables/results_tables.md

@@ -0,0 +1,50 @@
+# Results Tables for Paper
+
+## Table 1: Corpus Statistics
+
+| Property | Value |
+|----------|-------|
+| Documents | 16 |
+| Lines | 2,935 |
+| Characters | 100,562 |
+| Tokens (est.) | 16,286 |
+| Formats | 5 (MD, PY, HTML, SQL, YAML) |
+| Domains | 6 (Eng, Docs, HR, Legal, Security, Business) |
+
+## Table 2: Main Results
+
+| Method | P@5 | NDCG@10 | Latency |
+|--------|-----|---------|---------|
+| Baseline | 0.640 ± 0.057 | 0.610 ± 0.048 | 38ms |
+| **CaaS** | **0.820 ± 0.045** | **0.780 ± 0.042** | 45ms |
+| Δ | **+28.1%** | **+27.9%** | +18.4% |
+
+## Table 3: Ablation Study
+
+| Config | P@5 | NDCG@10 | Δ P@5 vs Base |
+|--------|-----|---------|---------------|
+| Baseline | 0.640 | 0.610 | — |
+| + Structure-Aware | 0.740 | 0.700 | +15.6% |
+| + Time Decay | 0.700 | 0.670 | +9.4% |
+| + Metadata | 0.720 | 0.690 | +12.5% |
+| + Pragmatic Truth | 0.680 | 0.650 | +6.3% |
+| **Full CaaS** | **0.820** | **0.780** | **+28.1%** |
+
+## Table 4: Statistical Significance
+
+| Metric | t-stat | p-value | Cohen's d |
+|--------|--------|---------|-----------|
+| P@5 | 22.31 | < 0.001 | 3.36 (large) |
+| NDCG@10 | 19.87 | < 0.001 | 2.98 (large) |
+
+## Table 5: Routing Latency
+
+| Router Type | Mean | p95 | p99 |
+|-------------|------|-----|-----|
+| Heuristic (Ours) | **0.003ms** | 0.005ms | 0.008ms |
+| ML-based | 15.2ms | 28.4ms | 45.1ms |
+| LLM-based | 450ms | 890ms | 1,200ms |
+
+---
+
+*Data source: benchmarks/results/evaluation_2026-01-20.json, statistical_results.json*