robot.wtf dev wiki
Changelog
Documentation
About An Otter Wiki
Toggle dark mode
Settings
Home
A - Z
Page Index
Design
Agent Workflow
Async Embedding Pipeline
Auth
CDN Read Path
Data Model
E-3 Encryption Spike
Frontend
Implementation Phases
Lambda Library Mode
Landing Page
MCP Server
Note Schema
Operations
P2-Username Summary
Phase Gates
Platform Overview
REST API
Research Wiki
Semantic Search
VPS Architecture
Dev
E-1 Cold Start Benchmarks
P1-8 E2E Test
P2-10 Summary
P2-1 Summary
P2-2 Summary
P2-3 Summary
P2-4 Summary
P2-5a Summary
P2-5b-7 Summary
P2-6 Summary
P2-8 Summary
P2-9 Summary
Phase 0 EFS Benchmarks
Phase 1 Deployment
Phase 1 Gate Results
Phase 1 Progress
Proxmox CPU Type
Underscore Filenames
V1-3 Deployment Summary
V1 SQLite Port Summary
V3 ATProto Auth Summary
V3 V5 Risk Research
V6-1 Landing Page Summary
VPS Deployment Progress
VS-1 ATProto Spike
VS-2 MCP OAuth Summary
DiagTestPage
E2ETestPage
Home
Meta
Wiki Usage Guide
Tasks
E-2 CDN Read Path
E-2 CDN Read Path ClientSide
Emergent
Launch Checklist
P1-9 MCP OAuth Discovery Routing
P1-9 MCP OAuth Routing
Phase 0
Phase 1
Phase 2
Phase 3
Phase 4
Prerequisites
VPS Phases
UserBPage
Design
Page Index
Toggle page headings
A
Agent Workflow
Roles
Proceed Workflow (per task)
Parallelization Guide for Managers
Orchestrator Responsibilities
Question Relay Protocol
Manager Prompt Template
Invoking the Workflow
Async Embedding Pipeline
Design goals
Why not Bedrock
Architecture
Key properties
Search path
Trigger mechanism: why DynamoDB Streams over SQS
Reindex queue table
Cost model
Migration from current deployment
Open questions
Auth
User registration and login
Auth provider: WorkOS AuthKit
Wiki-level auth
MCP auth
ACL model
AAA Model (Authentication, Authorization, Accounting)
Authentication (who are you?)
Authorization (what can you do?)
Public wiki access
Per-wiki Otterwiki configuration
Otterwiki Admin Panel — Section Disposition
Accounting (resource tracking and tier enforcement)
C
CDN Read Path
Problem
Constraints
Fragment Model (common to all options below)
Open question for Claude Code
Option A: Thin Assembly Lambda (Recommended)
Architecture
Auth
Performance
Advantages
Disadvantages
Variant: S3 as direct CloudFront origin
Option B: Hybrid Static Content + Async Sidebar
Architecture
Auth
Performance
Advantages
Disadvantages
Open question for Claude Code
Option C: Pre-Rendered Full Pages (Static Site Generator)
Architecture
Auth
Performance
Scaling problem
Advantages
Disadvantages
Option D: Client-Side SPA Assembly
Architecture
Advantages
Disadvantages
Comparison
Recommendation
Cost Impact
D
Data Model
Users
Wikis
ACLs
Storage layout (EFS)
Git Storage Mechanics
EFS-backed git repos
Fallback: S3 clone-on-demand
Semantic Search
Embedding pipeline (summary)
FAISS details
Cost estimate
URL Structure
Custom slugs (paid wikis)
Usernames
Username squatting
E
E-3 Encryption Spike
Problem
Storage Layers
Approaches Evaluated
1. EFS Encryption at Rest (Single KMS Key)
2. Per-Tenant SSE-KMS on S3 Fragments
3. Separate EFS Filesystems Per Tenant
4. Application-Level Encryption on EFS
5. Full Client-Side Encryption (Zero-Knowledge)
CDN Caching Interaction
KMS Cost Model at Scale
Recommendation
For Launch
Per-User KMS Becomes Viable When
Full Zero-Knowledge: Conditions for Revisiting
Precedents Referenced
F
Frontend
What the frontend actually is
URL Scheme
Namespace implications
Impact on existing design documents
Authentication
Cross-subdomain auth via parent-domain cookie
OAuth flow
JWT details
How the SPA knows if you're logged in
Framework
Recommendation: Svelte (not SvelteKit)
Build tooling
Bundle budget
Screens
Dashboard (/app/)
Create wiki (/app/new)
Wiki settings (/app/{slug})
Collaborators (/app/{slug}/collaborators)
MCP connection instructions (/app/{slug}/connect)
Account settings (/app/account)
Otterwiki Admin Panel Boundary
Error Handling
Static Hosting and Routing
Build and Deploy
Mobile
Upstream Contributions
Open Questions
I
Implementation Phases
Phase 0: EFS + Lambda + Auth proof of concept
FREE TIER (Phases 1–4)
Phase 1: Single-user serverless wiki
Phase 2: Multi-tenancy and auth
Phase 3: Frontend
Phase 4: Git remote access and launch prep
PREMIUM TIER (Phases 5+)
Phase 5: Stripe integration and premium gating
Phase 6: Semantic search
Phase 7: Deferred features (build when there's demand)
Frontend
Technology
Screens
MVP scope
API Surface
Management API (new)
Wiki API (existing, adapted)
MCP endpoint (existing, adapted)
Freemium Tiers
Deferred features (build when there's demand)
Pricing (undecided — two options)
Paid wiki perks
Lapse policy
Enforcement
L
Lambda Library Mode
Problem
Key Insight
Architecture: sys.modules Injection
The Replacement Module
Export Surface
Upstream Contributions
1. Lazy imports in views.py (highest value)
2. Lazy imports in wiki.py
3. Extract plugin entrypoint scan
4. Remove duplicate renderer instance
5. App factory pattern (longer-term)
Estimated Init Timeline
Current
With library mode + upstream lazy imports (PRs 1-4)
With library mode only (no upstream changes)
Breakdown of savings
Tracking Upstream Compatibility
Relationship to CDN Read Path
Open Questions
Landing Page
Design principles
Technical requirements
System font stack suggestion
Logo
Page structure
1. Header / nav
2. Hero
3. "What is this?" section
4. "How it works" section
5. FAQ section
6. Footer
Color and styling notes
What to deliver
Out of scope for initial build
M
MCP Server
Component 3: MCP Server
Goal
Implementation
Tools
Configuration
Tool return format and error handling
SSE endpoint
N
Note Schema
Note Schema
Field definitions
Cross-references: WikiLinks are the single source of truth
Page organization
Cross-referencing
Page size guidance
Complete example page
Master Index Convention
Purpose
Structure
Example
Size budget
Orphan detection
Session start protocol
Gardening sessions
Open Questions
O
Operations
Wiki Bootstrap Template
Initial pages
Customization
Custom template repos (premium)
Implementation
Attachment Storage
MVP approach
Future optimization: S3-backed attachment serving
Git Remote Access
Hosted Git remote
Implementation
External Git sync (premium, future)
Platform: AWS Lambda + EFS
Why AWS + EFS
Key properties
VPC networking
Known trade-offs
S3 fallback
Alternatives considered
Phase 0 validates this decision
Infrastructure as Code
Tool: Pulumi (Python)
What's managed by IaC
What's NOT managed by IaC
Repository structure
Otterwiki Fork Management
Merge strategy
Upstream relationship
Backup and Disaster Recovery
What we're protecting
Backup strategy
Recovery scenarios
Design principle
CI/CD
Pipeline
Environment strategy
Account Lifecycle
Data retention
Account deletion
GDPR
MCP Discoverability
Rate Limiting and Abuse Prevention
Open Questions
P
P2-Username Summary
Summary
Changes
Infrastructure (infra/components/dynamodb.py)
User Model (app/models/user.py)
Auth Middleware (app/auth/middleware.py)
Management API (app/management/routes.py)
CLI (app/cli/main.py)
Resolver (app/otterwiki/resolver.py)
Test Coverage
Branch
Phase Gates
How phase gates work
Phase 0 Gate: Proof of Concept
Exit criteria
Validation steps
Known risks to evaluate
Go/no-go decision
Phase 1 Gate: Single-User Serverless Wiki
Exit criteria
Validation steps
Known risks to evaluate
Go/no-go decision
Phase 2 Gate: Multi-Tenancy and Auth
Exit criteria
Validation steps
Known risks to evaluate
Go/no-go decision
Phase 3 Gate: Frontend
Exit criteria
Validation steps
Known risks to evaluate
Go/no-go decision
Phase 4 Gate: Launch Readiness
Exit criteria
Validation steps
Final checklist before launch
Go/no-go decision
Platform Overview
Overview
Context
Why this exists
Key users
Prior art
Architecture
Component inventory
R
REST API
Component 1: REST API Plugin
Goal
Implementation approach
Authentication
Commit authorship and message conventions
Endpoints
Pages
Search
Links (WikiLink graph)
Changelog
WikiLink parsing and link graph
Error responses
Example requests and responses
List pages: GET /api/v1/pages?prefix=Trends/
Read page: GET /api/v1/pages/Trends/Iran Attrition Strategy
Write page: PUT /api/v1/pages/Events/2026-03-09 Day 10
Full-text search: GET /api/v1/search?q=ballistic+missile+rationing
Semantic search: GET /api/v1/semantic-search?q=strategy+for+depleting+Gulf+air+defenses&n=3
Research Wiki
Overview
Context
What is Otterwiki?
Why this system?
Key users
Architecture
Deployment
Docker Compose
Implementation Sequence
Phase 1: Investigate plugin system (30 min)
Phase 2: REST API (core deliverable)
Phase 3: Chroma integration
Phase 4: MCP server
Phase 5: Docker compose and deployment
Success Criteria
S
Semantic Search
Component 2: Chroma Semantic Search Plugin
Goal
Implementation approach
ChromaDB configuration
Chunking strategy
Search result deduplication
API endpoints (added to the REST API)
Index maintenance
Fallback: periodic sync
V
VPS Architecture
Why this exists
Service model
Infrastructure
Server
Process model
Caddy
Why not Nginx
Authentication
Identity model
Username defaulting
ATProto OAuth (browser login)
Reference implementation
MCP OAuth (Claude.ai)
MCP protected resource metadata
Bearer tokens (Claude Code / API)
Cross-subdomain auth
Auth convergence
Migration off ATProto
Data Model
SQLite replaces DynamoDB
Tables
Storage layout
Compute
Otterwiki (WSGI)
MCP sidecar (FastMCP)
Platform API (Flask)
Auth service (Flask)
Semantic Search
Write path
Search path
Model loading strategy
Backup and Disaster Recovery
What we're protecting
Backup strategy
Recovery
Deployment
Application deployment
Initial setup
Monitoring
URL Structure
Namespace rules
What changes vs. what stays the same
Stays the same
Changes
What can be reused from existing implementation
Open Questions
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9