4445b0e8d0
- Create comprehensive project structure (29 directories) - Add CLAUDE.md with project context and conventions - Add package.json with dependencies and scripts - Add .gitignore and .env.example - Add README.md with project overview - Configure ports: MongoDB 27017, Application 9000 - Establish Tractatus governance framework baseline - Document Te Tiriti approach and indigenous perspective - Set up infrastructure for Phase 1 implementation Project Status: Development - Phase 1 Foundation Complete Next: MongoDB instance setup and systemd service configuration
2015 lines
61 KiB
Markdown
2015 lines
61 KiB
Markdown
Tractatus-Based LLM Safety Framework Website - Complete Technical Specification
|
|
Project: mysy.digital - Tractatus AI Safety Framework Website
|
|
Platform: Node.js/Express + MongoDB (leveraging family-history stack)
|
|
Hosting: OVHCloud
|
|
Repository: GitHub (primary) + Codeberg/Gitea (mirrors)
|
|
Target Audiences: Academic/Research, Industry/Enterprise, Public Advocacy
|
|
Timeline: 4-phase rollout over 18 months
|
|
|
|
Executive Summary
|
|
Build a comprehensive website for the Tractatus-Based LLM Safety Framework that serves three distinct audiences through differentiated landing paths while maintaining a unified knowledge base. The site will demonstrate the framework's principles by implementing them in its own architecture (dogfooding), use Claude-powered curation with explicit human oversight, and position Aotearoa/New Zealand's leadership in incorporating indigenous perspectives on digital sovereignty within a global context.
|
|
|
|
1. Technical Architecture
|
|
1.1 Core Technology Stack
|
|
Backend (leveraging existing family-history stack):
|
|
javascript// Node.js/Express foundation
|
|
- Express 4.x for routing and middleware
|
|
- MongoDB for content, user data, and framework documentation
|
|
- GridFS for file storage (PDFs, presentations, code examples)
|
|
- JWT authentication for user accounts and admin access
|
|
- WebSocket for real-time updates and notifications
|
|
|
|
// Key services to adapt from family-history:
|
|
- TenantFileService → DocumentService (multi-document management)
|
|
- User authentication system
|
|
- Multi-language support infrastructure (i18n.js)
|
|
- Session management
|
|
Frontend:
|
|
javascript// Progressive enhancement approach
|
|
- Vanilla JavaScript (no framework dependency for core features)
|
|
- Optional React components for interactive demos
|
|
- Tailwind CSS for styling consistency
|
|
- Mobile-first responsive design
|
|
- ARIA compliance for accessibility
|
|
Database Collections (MongoDB):
|
|
javascriptdb.collection('documents') // Technical papers, case studies, appendices
|
|
db.collection('blog_posts') // AI-curated blog with human oversight
|
|
db.collection('media_inquiries') // Press/media contact submissions
|
|
db.collection('case_submissions')// Community case study submissions
|
|
db.collection('resources') // External links, aligned projects
|
|
db.collection('koha_donations') // Donation tracking (Phase 3+)
|
|
db.collection('users') // User accounts
|
|
db.collection('moderation_queue')// Human oversight queue for AI actions
|
|
db.collection('citations') // Academic citation tracking
|
|
db.collection('translations') // Multi-language content
|
|
1.2 Tractatus Framework Implementation (Dogfooding)
|
|
Architecture Demonstration:
|
|
javascript// All AI actions subject to Tractatus validation
|
|
class TractusWebsiteManager {
|
|
constructor() {
|
|
this.instructionClassifier = new InstructionPersistenceClassifier();
|
|
this.boundaryEnforcer = new HumanJudgmentBoundaryEnforcer();
|
|
this.validator = new CrossReferenceValidator();
|
|
}
|
|
|
|
// Example: AI blog post curation
|
|
async curateContent(content, source) {
|
|
// Classify by quadrant
|
|
const classification = this.instructionClassifier.classify({
|
|
action: 'publish_blog_post',
|
|
content: content,
|
|
quadrant: 'OPERATIONAL' // Blog guidelines
|
|
});
|
|
|
|
// Validate against strategic values
|
|
const validation = await this.validator.validate({
|
|
action: 'publish',
|
|
content: content,
|
|
strategic_values: ['sovereignty', 'transparency', 'indigenous_respect']
|
|
});
|
|
|
|
// Enforce boundary: human approval for values-sensitive content
|
|
if (classification.requires_human_judgment) {
|
|
return this.boundaryEnforcer.escalate_to_human({
|
|
item: content,
|
|
reason: 'Values-sensitive content requires strategic review',
|
|
quadrant: 'STRATEGIC'
|
|
});
|
|
}
|
|
|
|
return validation;
|
|
}
|
|
}
|
|
Quadrant Mapping for Website Functions:
|
|
FunctionQuadrantTime HorizonHuman Oversight RequiredMission/values statementsStrategicYearsYes - all changesBlog editorial guidelinesOperationalMonthsYes - quarterly reviewPublish approved blog postTacticalDaysNo - pre-approved by opsTechnical documentationSystemContinuousYes - technical reviewAI content suggestionsStochasticVariableYes - human approval
|
|
|
|
2. Information Architecture
|
|
2.1 Three Audience Landing Paths
|
|
Homepage (mysy.digital):
|
|
┌─────────────────────────────────────────────────────┐
|
|
│ TRACTATUS AI SAFETY FRAMEWORK │
|
|
│ Structural Guarantees for Safe AI Systems │
|
|
│ │
|
|
│ [Choose Your Path] │
|
|
│ │
|
|
│ ┌──────────────┐ ┌──────────────┐ ┌─────────────┐│
|
|
│ │ RESEARCHER │ │ IMPLEMENTER │ │ ADVOCATE ││
|
|
│ │ │ │ │ │ ││
|
|
│ │ Publications │ │ Integration │ │ Democratic ││
|
|
│ │ Theory │ │ Code │ │ Oversight ││
|
|
│ │ Peer Review │ │ Case Studies │ │ Public Good ││
|
|
│ └──────────────┘ └──────────────┘ └─────────────┘│
|
|
│ │
|
|
│ Latest: [Blog Preview] | [News] | [Events] │
|
|
└─────────────────────────────────────────────────────┘
|
|
2.2 Researcher Path
|
|
URL: /research
|
|
Content Structure:
|
|
Research Hub
|
|
├── Publications
|
|
│ ├── Executive Brief (2-page PDF)
|
|
│ ├── Technical Proposal (complete)
|
|
│ ├── Appendices (A-E)
|
|
│ └── Peer-Reviewed Papers (as published)
|
|
│
|
|
├── Theory & Foundations
|
|
│ ├── Tractatus Philosophical Framework
|
|
│ ├── Agentic Organizational Structure
|
|
│ ├── Time-Persistence Metadata
|
|
│ └── Organizational Theory Origins
|
|
│
|
|
├── Research Collaboration
|
|
│ ├── Open Questions
|
|
│ ├── Validation Studies
|
|
│ ├── Academic Partnerships
|
|
│ └── Citation Guidelines
|
|
│
|
|
└── Contribute
|
|
├── Submit Related Research
|
|
├── Peer Review Opportunities
|
|
└── Academic Community Forum
|
|
Key Features:
|
|
|
|
BibTeX citation generator
|
|
arXiv preprint links
|
|
Research collaboration inquiry form
|
|
Academic mailing list signup
|
|
|
|
2.3 Implementer Path
|
|
URL: /implement
|
|
Content Structure:
|
|
Implementation Hub
|
|
├── Getting Started
|
|
│ ├── Quick Start Guide
|
|
│ ├── Integration Patterns
|
|
│ ├── System Requirements
|
|
│ └── Architecture Overview
|
|
│
|
|
├── Code & Documentation
|
|
│ ├── GitHub Repository Links
|
|
│ ├── Code Examples (Appendix A)
|
|
│ ├── API Documentation
|
|
│ └── Implementation Roadmap (Appendix C)
|
|
│
|
|
├── Case Studies
|
|
│ ├── Real-World Failures Prevented
|
|
│ ├── The 27027 Incident (detailed analysis)
|
|
│ ├── Industry Case Studies (Appendix B)
|
|
│ └── Success Metrics
|
|
│
|
|
├── Interactive Demos
|
|
│ ├── Instruction Classification Demo
|
|
│ ├── Cross-Reference Validation Visualizer
|
|
│ ├── Boundary Enforcement Simulator
|
|
│ └── Context Pressure Monitor
|
|
│
|
|
└── Enterprise Support
|
|
├── Pilot Program Application
|
|
├── Integration Consulting
|
|
├── Training Workshops
|
|
└── Technical Support
|
|
Key Features:
|
|
|
|
Live code playground
|
|
Downloadable implementation kits
|
|
Integration assessment tool
|
|
Enterprise inquiry form
|
|
|
|
2.4 Advocate Path
|
|
URL: /advocacy
|
|
Content Structure:
|
|
Advocacy Hub
|
|
├── Why This Matters
|
|
│ ├── AI Safety for Everyone
|
|
│ ├── Democratic AI Governance
|
|
│ ├── Digital Sovereignty Principles
|
|
│ └── Indigenous Perspectives (Te Tiriti context)
|
|
│
|
|
├── Public Resources
|
|
│ ├── Plain-Language Explainers
|
|
│ ├── Infographics & Visualizations
|
|
│ ├── Video Explanations
|
|
│ └── FAQ for Non-Technical Audiences
|
|
│
|
|
├── Media Centre
|
|
│ ├── Press Releases
|
|
│ ├── Media Kit (logos, fact sheets)
|
|
│ ├── Spokesperson Bios
|
|
│ ├── Press Inquiry Form (AI-moderated)
|
|
│ └── Recent Coverage
|
|
│
|
|
├── Take Action
|
|
│ ├── Educational Resources
|
|
│ ├── Community Events
|
|
│ ├── Policy Recommendations
|
|
│ └── Join the Movement
|
|
│
|
|
└── Values & Governance
|
|
├── Our Mission
|
|
├── Te Tiriti Alignment
|
|
├── Aotearoa/NZ Leadership
|
|
└── Transparent Governance Model
|
|
Key Features:
|
|
|
|
Shareable social media content
|
|
Email newsletter signup
|
|
Community forum access
|
|
Event calendar
|
|
|
|
2.5 Unified Components (All Paths)
|
|
Blog (/blog):
|
|
|
|
AI-curated content with human editorial oversight
|
|
Technical updates, research insights, advocacy stories
|
|
Guest posts from aligned organizations
|
|
Multi-language support (starting with English, Te Reo Māori)
|
|
|
|
Documentation Library (/docs):
|
|
|
|
Complete framework documentation
|
|
Searchable, cross-referenced
|
|
Version history
|
|
Download options (PDF, EPUB, HTML)
|
|
|
|
About (/about):
|
|
|
|
Team & Contributors
|
|
History & Development
|
|
Governance Model
|
|
Contact Information
|
|
|
|
Resources (/resources):
|
|
|
|
Aligned Projects Directory
|
|
External Research Links
|
|
Educational Materials
|
|
Tools & Services
|
|
|
|
|
|
3. Content Migration & Integration
|
|
3.1 Existing Documents to Integrate
|
|
From Project Knowledge Base:
|
|
|
|
README.md → /docs/overview
|
|
|
|
Package contents summary
|
|
Reading order recommendations
|
|
Quick start for reviewers
|
|
|
|
|
|
executive-brief.md → /docs/executive-brief + PDF download
|
|
|
|
2-page summary for decision-makers
|
|
The 27027 case study
|
|
Three-layer architecture overview
|
|
|
|
|
|
technical-proposal.md → /docs/technical-proposal + PDF
|
|
|
|
Complete technical specification
|
|
All 7 sections with navigation
|
|
Inline code examples
|
|
Cross-references to appendices
|
|
|
|
|
|
appendix-a-code-examples.md → /docs/code-examples
|
|
|
|
Python implementation examples
|
|
Interactive code playground integration
|
|
Downloadable code packages
|
|
|
|
|
|
appendix-b-case-studies.md → /case-studies
|
|
|
|
Real-world failure analysis
|
|
Success stories
|
|
Industry applications
|
|
|
|
|
|
appendix-c-implementation-roadmap.md → /implement/roadmap
|
|
|
|
Phased deployment plan
|
|
Success metrics
|
|
Timeline visualization
|
|
|
|
|
|
appendix-d-research-review.md → /research/literature-review
|
|
|
|
Scholarly context
|
|
Related research
|
|
Publication recommendations
|
|
|
|
|
|
cover-letter.md → /about/submission-history
|
|
|
|
Anthropic submission context
|
|
Development timeline
|
|
|
|
|
|
SYS-DOC-5000-sydigital-framework-tractatus-v1-0-0.md → /docs/tractatus-framework
|
|
|
|
Philosophical foundation
|
|
Section 12: Limits of the Framework
|
|
Complete Tractatus reference
|
|
|
|
|
|
STO-INN-0002-agentic-organizational-structure-whitepaper-i2.md → /docs/agentic-structure
|
|
|
|
Organizational theory foundations
|
|
Quadrant system detailed specification
|
|
Cross-quadrant coordination
|
|
|
|
|
|
Persistent Agentic Process Architecture.md → /docs/persistent-architecture
|
|
|
|
Service worker roles
|
|
Information flow patterns
|
|
Role stability principles
|
|
|
|
|
|
|
|
3.2 Content Processing Pipeline
|
|
javascript// Document ingestion system
|
|
class DocumentProcessor {
|
|
async processMarkdown(filePath, metadata) {
|
|
// 1. Parse markdown with front matter
|
|
const doc = await parseMarkdownWithMetadata(filePath);
|
|
|
|
// 2. Classify by quadrant
|
|
const quadrant = this.classifyDocument(doc.metadata);
|
|
|
|
// 3. Extract cross-references
|
|
const references = this.extractReferences(doc.content);
|
|
|
|
// 4. Generate navigation
|
|
const toc = this.generateTableOfContents(doc.content);
|
|
|
|
// 5. Convert to HTML with syntax highlighting
|
|
const html = await markdownToHTML(doc.content);
|
|
|
|
// 6. Store in MongoDB with metadata
|
|
await db.collection('documents').insertOne({
|
|
title: doc.metadata.title,
|
|
quadrant: quadrant,
|
|
content: html,
|
|
raw_markdown: doc.content,
|
|
references: references,
|
|
toc: toc,
|
|
created_at: new Date(),
|
|
updated_at: new Date(),
|
|
version: '1.0.0'
|
|
});
|
|
|
|
// 7. Update search index
|
|
await this.updateSearchIndex(doc);
|
|
}
|
|
}
|
|
|
|
4. AI-Powered Features (Tractatus-Governed)
|
|
4.1 Blog Curation System
|
|
Architecture:
|
|
javascriptclass BlogCurationEngine {
|
|
constructor() {
|
|
this.claudeAPI = new ClaudeAPI('claude-sonnet-4-5');
|
|
this.moderationQueue = new ModerationQueue();
|
|
this.boundaryEnforcer = new TractatusBoundaryEnforcer();
|
|
}
|
|
|
|
async suggestBlogPost(topic, sources) {
|
|
// AI generates draft
|
|
const draft = await this.claudeAPI.generateBlogPost({
|
|
topic: topic,
|
|
sources: sources,
|
|
guidelines: await this.loadEditorialGuidelines(),
|
|
strategic_values: await this.loadStrategicValues()
|
|
});
|
|
|
|
// Classify action
|
|
const classification = {
|
|
quadrant: 'OPERATIONAL', // Blog is operational
|
|
persistence: 'MEDIUM',
|
|
requires_human: this.checkValuesContent(draft)
|
|
};
|
|
|
|
// Queue for human review
|
|
await this.moderationQueue.add({
|
|
type: 'blog_post_suggestion',
|
|
draft: draft,
|
|
classification: classification,
|
|
created_at: new Date(),
|
|
status: 'pending_human_review'
|
|
});
|
|
|
|
return { status: 'queued_for_review', id: draft.id };
|
|
}
|
|
|
|
checkValuesContent(draft) {
|
|
// Check for values-sensitive topics requiring strategic review
|
|
const sensitiveTopics = [
|
|
'indigenous_rights',
|
|
'sovereignty_principles',
|
|
'ethical_boundaries',
|
|
'democratic_governance'
|
|
];
|
|
|
|
return sensitiveTopics.some(topic =>
|
|
draft.content.toLowerCase().includes(topic)
|
|
);
|
|
}
|
|
}
|
|
Human Oversight Dashboard:
|
|
Admin Dashboard → Moderation Queue
|
|
├── Pending Blog Posts
|
|
│ ├── [Draft Title]
|
|
│ │ └── [Approve] [Edit] [Reject] [Request Revision]
|
|
│ ├── AI Reasoning: [Display Claude's analysis]
|
|
│ ├── Values Check: [Flagged items]
|
|
│ └── Suggested Improvements: [Claude's suggestions]
|
|
│
|
|
├── Media Inquiry Triage
|
|
│ ├── [Inquiry Subject]
|
|
│ │ └── [Respond] [Forward to Team] [Archive]
|
|
│ ├── AI Summary: [Key points]
|
|
│ └── Suggested Response: [Draft with human editing]
|
|
│
|
|
└── Case Study Submissions
|
|
├── [Submission Title]
|
|
│ └── [Review] [Publish] [Request More Info]
|
|
└── AI Analysis: [Relevance, completeness]
|
|
4.2 Press/Media Inquiry System
|
|
AI-Moderated Intake:
|
|
javascriptclass MediaInquiryHandler {
|
|
async processInquiry(submission) {
|
|
// AI analyzes inquiry
|
|
const analysis = await this.claudeAPI.analyzeMediaInquiry({
|
|
subject: submission.subject,
|
|
message: submission.message,
|
|
outlet: submission.media_outlet,
|
|
deadline: submission.deadline
|
|
});
|
|
|
|
// Classify urgency and sensitivity
|
|
const classification = {
|
|
urgency: analysis.urgency, // high/medium/low
|
|
topic_sensitivity: analysis.sensitivity,
|
|
requires_strategic_review: analysis.involves_values,
|
|
suggested_response_time: analysis.response_window
|
|
};
|
|
|
|
// Route based on classification
|
|
if (classification.requires_strategic_review) {
|
|
// Escalate to strategic quadrant (human decision-makers)
|
|
await this.escalateToStrategic(submission, analysis);
|
|
} else {
|
|
// Queue for operational review
|
|
await this.queueForReview(submission, analysis);
|
|
}
|
|
|
|
// Auto-respond with acknowledgement
|
|
await this.sendAutoResponse(submission, classification);
|
|
}
|
|
}
|
|
4.3 Resource Curation
|
|
AI-Assisted Discovery:
|
|
javascriptclass ResourceCurator {
|
|
async suggestResource(url) {
|
|
// Fetch and analyze resource
|
|
const analysis = await this.claudeAPI.analyzeExternalResource({
|
|
url: url,
|
|
alignment_criteria: await this.loadAlignmentCriteria(),
|
|
quality_standards: await this.loadQualityStandards()
|
|
});
|
|
|
|
// Check alignment with strategic values
|
|
const alignmentScore = this.calculateAlignment(analysis);
|
|
|
|
if (alignmentScore > 0.8) {
|
|
// High alignment - queue for quick review
|
|
return await this.queueForReview(url, analysis, 'fast_track');
|
|
} else if (alignmentScore > 0.5) {
|
|
// Moderate alignment - standard review
|
|
return await this.queueForReview(url, analysis, 'standard');
|
|
} else {
|
|
// Low alignment - detailed human review required
|
|
return await this.queueForReview(url, analysis, 'detailed');
|
|
}
|
|
}
|
|
}
|
|
|
|
5. Te Tiriti & Indigenous Perspective Integration
|
|
5.1 Strategic Values Statement
|
|
Location: /about/values (also footer on all pages)
|
|
Content (example - requires your approval):
|
|
markdown## Our Values & Te Tiriti Commitment
|
|
|
|
The Tractatus AI Safety Framework is developed in Aotearoa New Zealand
|
|
with deep respect for Te Tiriti o Waitangi and the leadership of tangata
|
|
whenua in digital sovereignty.
|
|
|
|
**Digital Sovereignty & Indigenous Rights**
|
|
We recognize that indigenous peoples worldwide have been at the forefront
|
|
of sovereignty struggles for centuries. The principles of data sovereignty,
|
|
self-determination, and cultural protection central to our framework draw
|
|
inspiration from indigenous leadership in asserting rights over digital
|
|
resources and governance systems.
|
|
|
|
**Aotearoa's Contribution**
|
|
Based in Aotearoa New Zealand, this work is informed by Te Tiriti o Waitangi's
|
|
principles of partnership, protection, and participation. We acknowledge the
|
|
pioneering work of Māori scholars and communities in establishing frameworks
|
|
for data sovereignty (including the CARE Principles) that inform our approach
|
|
to AI governance.
|
|
|
|
**Global Application**
|
|
While rooted in Aotearoa context, this framework is designed for global
|
|
application, bringing indigenous-informed sovereignty principles to AI
|
|
safety challenges worldwide.
|
|
Implementation:
|
|
|
|
Subtle footer acknowledgement on every page
|
|
Detailed page in About section
|
|
No dominant visual presence, but clear strategic commitment
|
|
Links to relevant indigenous AI/data sovereignty resources
|
|
|
|
5.2 Resource Directory Inclusion
|
|
Aligned Indigenous Projects (in resources directory):
|
|
|
|
Māori Data Sovereignty Network
|
|
Te Mana Raraunga (Māori Data Sovereignty Network)
|
|
CARE Principles for Indigenous Data Governance
|
|
Indigenous Protocol and AI Working Group
|
|
Other global indigenous digital rights organizations
|
|
|
|
|
|
6. Interactive Demonstrations
|
|
6.1 Instruction Classification Demo
|
|
URL: /demo/classification
|
|
Interactive Tool:
|
|
javascript// User inputs instruction text
|
|
// System shows real-time classification
|
|
|
|
class ClassificationDemo {
|
|
render() {
|
|
return `
|
|
<div class="demo-container">
|
|
<h2>Try Instruction Classification</h2>
|
|
|
|
<textarea id="instruction-input"
|
|
placeholder="Enter an AI instruction...">
|
|
</textarea>
|
|
|
|
<button onclick="classify()">Classify</button>
|
|
|
|
<div id="results">
|
|
<h3>Classification Results:</h3>
|
|
<div class="quadrant-badge">[Quadrant]</div>
|
|
<div class="persistence-level">[Persistence]</div>
|
|
<div class="verification-intensity">[Verification Required]</div>
|
|
<div class="explanation">[Why this classification]</div>
|
|
</div>
|
|
</div>
|
|
`;
|
|
}
|
|
}
|
|
|
|
// Example classifications shown:
|
|
// "Always prioritize privacy" → STRATEGIC, HIGH, ANNUAL_REVIEW
|
|
// "For this project, use React" → OPERATIONAL, MEDIUM, PROJECT_SCOPE
|
|
// "Check database port 27027" → TACTICAL, HIGH, IMMEDIATE
|
|
// "Fix syntax error on line 42" → SYSTEM, LOW, IMMEDIATE
|
|
6.2 The 27027 Incident Visualizer
|
|
URL: /case-studies/27027-incident
|
|
Interactive Timeline:
|
|
javascript// Visual reconstruction of the failure
|
|
class IncidentVisualizer {
|
|
render() {
|
|
return `
|
|
<div class="timeline">
|
|
<div class="step" data-step="1">
|
|
<h4>User Instruction (Explicit)</h4>
|
|
<code>"Check port 27027 for family_history database"</code>
|
|
<span class="metadata">Timestamp: Recent, Explicit, Clear</span>
|
|
</div>
|
|
|
|
<div class="step" data-step="2">
|
|
<h4>Context Pressure Builds</h4>
|
|
<div class="context-meter">107k tokens of conversation</div>
|
|
<span class="warning">⚠️ Pattern matching confidence increasing</span>
|
|
</div>
|
|
|
|
<div class="step" data-step="3">
|
|
<h4>Claude's Action (Incorrect)</h4>
|
|
<code>mongosh mongodb://localhost:27017/family_history</code>
|
|
<span class="error">❌ Used default port 27017, not 27027</span>
|
|
</div>
|
|
|
|
<div class="step" data-step="4">
|
|
<h4>With Tractatus Framework</h4>
|
|
<div class="validation-check">
|
|
<span class="check">✓ Extract parameter: port=27017</span>
|
|
<span class="check">✓ Cross-reference recent instructions</span>
|
|
<span class="error">⚠️ CONFLICT: User said 27027, action uses 27017</span>
|
|
<span class="block">🛑 ACTION BLOCKED - Request clarification</span>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
`;
|
|
}
|
|
}
|
|
6.3 Boundary Enforcement Simulator
|
|
URL: /demo/boundaries
|
|
Interactive Scenarios:
|
|
javascript// Present users with decision scenarios
|
|
// Show which require human judgment
|
|
|
|
const scenarios = [
|
|
{
|
|
id: 1,
|
|
scenario: "Should we prioritize speed or privacy in our AI deployment?",
|
|
correct_answer: "HUMAN_REQUIRED",
|
|
quadrant: "STRATEGIC",
|
|
tractatus_rule: "12.1 - Values cannot be automated, only verified",
|
|
explanation: "Values decisions must always involve human judgment"
|
|
},
|
|
{
|
|
id: 2,
|
|
scenario: "Which Python library is best for data validation?",
|
|
correct_answer: "AI_CAPABLE",
|
|
quadrant: "SYSTEM",
|
|
tractatus_rule: "System decisions can be delegated with verification",
|
|
explanation: "Technical implementation choices can be AI-assisted"
|
|
},
|
|
// ... more scenarios
|
|
];
|
|
|
|
7. Phased Implementation Roadmap
|
|
Phase 1: Foundation & Launch (Months 1-3)
|
|
Milestone: Public launch with core documentation and three audience paths
|
|
Deliverables:
|
|
|
|
Platform setup on OVHCloud
|
|
Domain configuration (mysy.digital)
|
|
Database schema implementation
|
|
Document migration pipeline
|
|
Homepage with three paths
|
|
Complete documentation library
|
|
Basic blog system (human-curated only)
|
|
Media inquiry form
|
|
About/Contact pages
|
|
Te Tiriti values statement
|
|
GitHub repository setup (public)
|
|
Privacy policy, terms of service
|
|
Analytics implementation (privacy-preserving)
|
|
|
|
Technical Tasks:
|
|
bash# Infrastructure setup
|
|
npm init -y
|
|
npm install express mongodb dotenv jsonwebtoken bcrypt
|
|
npm install marked highlight.js # Markdown processing
|
|
npm install i18next # Multi-language support
|
|
|
|
# Database initialization
|
|
node scripts/init-db.js
|
|
node scripts/migrate-documents.js
|
|
|
|
# First deployment
|
|
npm run build
|
|
npm run deploy
|
|
Success Metrics:
|
|
|
|
Site accessible at mysy.digital
|
|
All core documents migrated and formatted
|
|
Three landing paths functional
|
|
Search working across documentation
|
|
Mobile-responsive
|
|
<2s page load time
|
|
|
|
Phase 2: Engagement & Demonstration (Months 4-8)
|
|
Milestone: Interactive features and community engagement
|
|
Deliverables:
|
|
|
|
AI-curated blog (with human oversight dashboard)
|
|
Interactive classification demo
|
|
27027 incident visualizer
|
|
Boundary enforcement simulator
|
|
Case study submission portal
|
|
Resources directory
|
|
Aligned projects catalog
|
|
Newsletter system
|
|
Event calendar
|
|
Community forum (initial)
|
|
Codeberg/Gitea mirrors established
|
|
|
|
AI Features (with Tractatus governance):
|
|
|
|
Blog post suggestion engine
|
|
Media inquiry triage
|
|
Resource recommendation system
|
|
FAQ auto-responses (human-reviewed)
|
|
|
|
Success Metrics:
|
|
|
|
1,000+ unique visitors/month
|
|
50+ blog subscribers
|
|
10+ case study submissions reviewed
|
|
5+ media inquiries handled
|
|
20+ resources cataloged
|
|
Demo tools used 100+ times/month
|
|
|
|
Phase 3: Technical Expansion & Koha (Months 9-14)
|
|
Milestone: Advanced features and community funding
|
|
Deliverables:
|
|
|
|
Stripe Koha integration
|
|
|
|
Monthly supporter tiers ($5, $15, $50/month)
|
|
One-time donations
|
|
Transparency dashboard (donations received/used)
|
|
|
|
|
|
Code playground (live examples)
|
|
API documentation
|
|
Te Reo Māori translations (priority pages)
|
|
Enhanced search (full-text, filtering)
|
|
User accounts (optional, for saved preferences)
|
|
Notification system
|
|
Advanced analytics
|
|
Performance optimization
|
|
|
|
Koha Implementation:
|
|
javascript// Stripe integration with transparency
|
|
class KohaManager {
|
|
async processDonation(amount, frequency, donor) {
|
|
// Process via Stripe
|
|
const payment = await stripe.paymentIntents.create({
|
|
amount: amount,
|
|
currency: 'nzd',
|
|
metadata: {
|
|
purpose: 'tractatus_framework_support',
|
|
frequency: frequency // 'monthly' or 'one_time'
|
|
}
|
|
});
|
|
|
|
// Record with transparency
|
|
await db.collection('koha_donations').insertOne({
|
|
amount: amount,
|
|
frequency: frequency,
|
|
donor_name: donor.name || 'Anonymous',
|
|
donor_email: donor.email, // private
|
|
timestamp: new Date(),
|
|
public_acknowledgement: donor.public_ack || false
|
|
});
|
|
|
|
// Update transparency dashboard
|
|
await this.updateTransparencyMetrics();
|
|
}
|
|
|
|
async getPublicMetrics() {
|
|
// Public transparency data
|
|
return {
|
|
total_received: await this.getTotalDonations(),
|
|
monthly_supporters: await this.getMonthlyCount(),
|
|
allocation: {
|
|
hosting: 0.30,
|
|
development: 0.40,
|
|
research: 0.20,
|
|
community: 0.10
|
|
},
|
|
recent_donors: await this.getPublicAcknowledgements()
|
|
};
|
|
}
|
|
}
|
|
Success Metrics:
|
|
|
|
20+ monthly supporters
|
|
$500+ monthly recurring revenue
|
|
50+ one-time donations
|
|
Code playground: 500+ executions/month
|
|
Multi-language: 10% of traffic uses translations
|
|
|
|
Phase 4: Scaling & Advocacy (Months 15-18)
|
|
Milestone: Full ecosystem with global reach
|
|
Deliverables:
|
|
|
|
Campaign/events module
|
|
Webinar hosting integration
|
|
Advanced forum features
|
|
Federation/interoperability protocols
|
|
Mobile app (PWA)
|
|
Advanced AI features:
|
|
|
|
Personalized content recommendations
|
|
Intelligent FAQ system
|
|
Research paper discovery
|
|
|
|
|
|
Enterprise portal
|
|
Academic partnership tools
|
|
International expansion (EU languages priority)
|
|
|
|
Success Metrics:
|
|
|
|
10,000+ unique visitors/month
|
|
100+ monthly supporters
|
|
5+ academic partnerships
|
|
3+ enterprise pilot programs
|
|
10+ languages supported
|
|
50+ aligned projects in directory
|
|
|
|
|
|
8. Detailed Technical Specifications
|
|
8.1 Database Schema
|
|
javascript// documents collection
|
|
{
|
|
_id: ObjectId,
|
|
title: String,
|
|
slug: String, // URL-friendly
|
|
quadrant: String, // STR/OPS/TAC/SYS/STO
|
|
persistence: String, // HIGH/MEDIUM/LOW/VARIABLE
|
|
content_html: String, // Rendered HTML
|
|
content_markdown: String, // Raw markdown
|
|
toc: Array, // Table of contents
|
|
metadata: {
|
|
author: String,
|
|
date_created: Date,
|
|
date_updated: Date,
|
|
version: String,
|
|
document_code: String, // e.g., SYS-DOC-5000
|
|
related_documents: [ObjectId],
|
|
tags: [String]
|
|
},
|
|
translations: {
|
|
mi: ObjectId, // Te Reo Māori
|
|
de: ObjectId, // German
|
|
fr: ObjectId, // French
|
|
// ... other languages
|
|
},
|
|
search_index: String, // Full-text search
|
|
download_formats: {
|
|
pdf: String, // GridFS file ID
|
|
epub: String,
|
|
docx: String
|
|
}
|
|
}
|
|
|
|
// blog_posts collection
|
|
{
|
|
_id: ObjectId,
|
|
title: String,
|
|
slug: String,
|
|
author: {
|
|
type: String, // 'human' or 'ai_curated'
|
|
name: String,
|
|
claude_version: String // if AI
|
|
},
|
|
content: String,
|
|
excerpt: String,
|
|
featured_image: String,
|
|
status: String, // draft/pending/published/archived
|
|
moderation: {
|
|
ai_analysis: Object, // Claude's assessment
|
|
human_reviewer: ObjectId,
|
|
review_notes: String,
|
|
approved_at: Date
|
|
},
|
|
tractatus_classification: {
|
|
quadrant: String,
|
|
values_sensitive: Boolean,
|
|
requires_strategic_review: Boolean
|
|
},
|
|
published_at: Date,
|
|
tags: [String],
|
|
view_count: Number,
|
|
engagement: {
|
|
shares: Number,
|
|
comments: Number
|
|
}
|
|
}
|
|
|
|
// media_inquiries collection
|
|
{
|
|
_id: ObjectId,
|
|
contact: {
|
|
name: String,
|
|
email: String,
|
|
outlet: String,
|
|
phone: String
|
|
},
|
|
inquiry: {
|
|
subject: String,
|
|
message: String,
|
|
deadline: Date,
|
|
topic_areas: [String]
|
|
},
|
|
ai_triage: {
|
|
urgency: String, // high/medium/low
|
|
topic_sensitivity: String,
|
|
suggested_response_time: Number, // hours
|
|
involves_values: Boolean,
|
|
claude_summary: String,
|
|
suggested_talking_points: [String]
|
|
},
|
|
status: String, // new/triaged/responded/closed
|
|
assigned_to: ObjectId,
|
|
response: {
|
|
sent_at: Date,
|
|
content: String,
|
|
responder: ObjectId
|
|
},
|
|
created_at: Date
|
|
}
|
|
|
|
// case_submissions collection
|
|
{
|
|
_id: ObjectId,
|
|
submitter: {
|
|
name: String,
|
|
email: String,
|
|
organization: String,
|
|
public: Boolean // Can we publish their name?
|
|
},
|
|
case_study: {
|
|
title: String,
|
|
description: String,
|
|
failure_mode: String, // What went wrong
|
|
tractatus_applicability: String, // How framework would help
|
|
evidence: [String], // Links, screenshots
|
|
attachments: [ObjectId] // GridFS file IDs
|
|
},
|
|
ai_review: {
|
|
relevance_score: Number, // 0-1
|
|
completeness_score: Number,
|
|
recommended_category: String,
|
|
suggested_improvements: [String],
|
|
claude_analysis: String
|
|
},
|
|
moderation: {
|
|
status: String, // pending/approved/rejected/needs_info
|
|
reviewer: ObjectId,
|
|
review_notes: String,
|
|
reviewed_at: Date
|
|
},
|
|
published_case_id: ObjectId, // If approved and published
|
|
submitted_at: Date
|
|
}
|
|
|
|
// koha_donations collection (Phase 3)
|
|
{
|
|
_id: ObjectId,
|
|
stripe_payment_id: String,
|
|
amount: Number, // in cents
|
|
currency: String, // 'nzd'
|
|
frequency: String, // 'one_time' or 'monthly'
|
|
donor: {
|
|
email: String, // private
|
|
name: String, // optional
|
|
public_acknowledgement: Boolean,
|
|
anonymous: Boolean
|
|
},
|
|
status: String, // succeeded/pending/failed
|
|
timestamp: Date,
|
|
allocation_note: String, // What funds support
|
|
public_thank_you_sent: Boolean
|
|
}
|
|
|
|
// moderation_queue collection
|
|
{
|
|
_id: ObjectId,
|
|
item_type: String, // blog_post/media_inquiry/case_study/resource
|
|
item_id: ObjectId,
|
|
quadrant: String,
|
|
ai_action: {
|
|
type: String, // suggestion/triage/analysis
|
|
confidence: Number, // 0-1
|
|
reasoning: String,
|
|
claude_version: String
|
|
},
|
|
human_required_reason: String, // Why human oversight needed
|
|
priority: String, // high/medium/low
|
|
assigned_to: ObjectId,
|
|
status: String, // pending/reviewed/approved/rejected
|
|
created_at: Date,
|
|
reviewed_at: Date,
|
|
review_decision: {
|
|
action: String, // approve/reject/modify/escalate
|
|
notes: String,
|
|
reviewer: ObjectId
|
|
}
|
|
}
|
|
8.2 API Routes
|
|
javascript// Core documentation routes
|
|
GET /api/docs // List all documents
|
|
GET /api/docs/:slug // Get specific document
|
|
GET /api/docs/:slug/pdf // Download PDF
|
|
GET /api/docs/search?q=... // Search documents
|
|
|
|
// Blog routes
|
|
GET /api/blog // List published posts
|
|
GET /api/blog/:slug // Get specific post
|
|
POST /api/blog/suggest // AI suggests blog post (admin)
|
|
GET /api/blog/moderation // Moderation queue (admin)
|
|
POST /api/blog/approve/:id // Approve post (admin)
|
|
|
|
// Media inquiry routes
|
|
POST /api/media/inquiry // Submit inquiry (public)
|
|
GET /api/media/queue // Triage queue (admin)
|
|
POST /api/media/respond/:id // Send response (admin)
|
|
|
|
// Case study routes
|
|
POST /api/cases/submit // Submit case study (public)
|
|
GET /api/cases // List published cases
|
|
GET /api/cases/:id // Get specific case
|
|
GET /api/cases/moderation // Review queue (admin)
|
|
|
|
// Resources routes
|
|
GET /api/resources // List all resources
|
|
GET /api/resources/aligned // Aligned projects
|
|
POST /api/resources/suggest // Suggest resource (logged in)
|
|
|
|
// Koha routes (Phase 3)
|
|
POST /api/koha/donate // Process donation
|
|
GET /api/koha/transparency // Public metrics
|
|
GET /api/koha/supporters // Public acknowledgements
|
|
|
|
// Interactive demo routes
|
|
POST /api/demo/classify // Classification demo
|
|
POST /api/demo/validate // Validation demo
|
|
POST /api/demo/boundary // Boundary check demo
|
|
|
|
// Admin/moderation routes (auth required)
|
|
GET /api/admin/dashboard // Overview stats
|
|
GET /api/admin/moderation/pending // All pending items
|
|
POST /api/admin/moderation/action // Take action on item
|
|
GET /api/admin/analytics // Detailed analytics
|
|
8.3 Frontend Components
|
|
javascript// Reusable components (vanilla JS)
|
|
|
|
// Document viewer with TOC
|
|
class DocumentViewer {
|
|
constructor(documentSlug) {
|
|
this.slug = documentSlug;
|
|
this.toc = [];
|
|
}
|
|
|
|
async render() {
|
|
const doc = await fetch(`/api/docs/${this.slug}`).then(r => r.json());
|
|
|
|
return `
|
|
<div class="document-container">
|
|
<aside class="toc">
|
|
${this.renderTOC(doc.toc)}
|
|
</aside>
|
|
<article class="document-content">
|
|
<h1>${doc.title}</h1>
|
|
<div class="metadata">
|
|
<span class="quadrant-badge ${doc.quadrant}">${doc.quadrant}</span>
|
|
<span class="date">Updated: ${doc.metadata.date_updated}</span>
|
|
<span class="version">v${doc.metadata.version}</span>
|
|
</div>
|
|
<div class="content">
|
|
${doc.content_html}
|
|
</div>
|
|
<div class="document-actions">
|
|
<a href="/api/docs/${this.slug}/pdf" class="btn">Download PDF</a>
|
|
<button onclick="copyLink()" class="btn-secondary">Share</button>
|
|
</div>
|
|
</article>
|
|
</div>
|
|
`;
|
|
}
|
|
}
|
|
|
|
// Three-path selector (homepage)
|
|
class AudiencePathSelector {
|
|
render() {
|
|
return `
|
|
<div class="path-selector">
|
|
<div class="path-card researcher">
|
|
<div class="icon">🔬</div>
|
|
<h3>For Researchers</h3>
|
|
<p>Publications, theory, peer review, and academic collaboration</p>
|
|
<ul class="path-features">
|
|
<li>Complete technical documentation</li>
|
|
<li>Peer-reviewed papers</li>
|
|
<li>Research collaboration opportunities</li>
|
|
<li>Citation resources</li>
|
|
</ul>
|
|
<a href="/research" class="btn-primary">Explore Research →</a>
|
|
</div>
|
|
|
|
<div class="path-card implementer">
|
|
<div class="icon">⚙️</div>
|
|
<h3>For Implementers</h3>
|
|
<p>Code, integration guides, case studies, and enterprise support</p>
|
|
<ul class="path-features">
|
|
<li>Production-ready code examples</li>
|
|
<li>Integration patterns</li>
|
|
<li>Real-world case studies</li>
|
|
<li>Enterprise pilot programs</li>
|
|
</ul>
|
|
<a href="/implement" class="btn-primary">Start Building →</a>
|
|
</div>
|
|
|
|
<div class="path-card advocate">
|
|
<div class="icon">📢</div>
|
|
<h3>For Advocates</h3>
|
|
<p>Democratic AI governance, public resources, and community action</p>
|
|
<ul class="path-features">
|
|
<li>Plain-language explainers</li>
|
|
<li>Media resources</li>
|
|
<li>Policy recommendations</li>
|
|
<li>Community engagement</li>
|
|
</ul>
|
|
<a href="/advocacy" class="btn-primary">Join the Movement →</a>
|
|
</div>
|
|
</div>
|
|
`;
|
|
}
|
|
}
|
|
|
|
// Moderation dashboard (admin)
|
|
class ModerationDashboard {
|
|
async render() {
|
|
const pending = await fetch('/api/admin/moderation/pending')
|
|
.then(r => r.json());
|
|
|
|
return `
|
|
<div class="moderation-dashboard">
|
|
<h2>Human Oversight Queue</h2>
|
|
<p class="subtitle">Items requiring human judgment per Tractatus framework</p>
|
|
|
|
${pending.map(item => `
|
|
<div class="moderation-item ${item.priority}">
|
|
<div class="item-header">
|
|
<span class="item-type">${item.item_type}</span>
|
|
<span class="quadrant-badge ${item.quadrant}">${item.quadrant}</span>
|
|
<span class="priority-badge ${item.priority}">${item.priority}</span>
|
|
</div>
|
|
|
|
<div class="ai-analysis">
|
|
<h4>AI Analysis (Claude ${item.ai_action.claude_version})</h4>
|
|
<p class="confidence">Confidence: ${item.ai_action.confidence * 100}%</p>
|
|
<p class="reasoning">${item.ai_action.reasoning}</p>
|
|
</div>
|
|
|
|
<div class="human-required">
|
|
<strong>Why Human Oversight Required:</strong>
|
|
<p>${item.human_required_reason}</p>
|
|
</div>
|
|
|
|
<div class="item-content">
|
|
<!-- Show actual content based on item_type -->
|
|
</div>
|
|
|
|
<div class="actions">
|
|
<button onclick="approve('${item._id}')" class="btn-success">
|
|
Approve
|
|
</button>
|
|
<button onclick="edit('${item._id}')" class="btn-warning">
|
|
Edit & Approve
|
|
</button>
|
|
<button onclick="reject('${item._id}')" class="btn-danger">
|
|
Reject
|
|
</button>
|
|
<button onclick="escalate('${item._id}')" class="btn-secondary">
|
|
Escalate to Strategic Review
|
|
</button>
|
|
</div>
|
|
</div>
|
|
`).join('')}
|
|
</div>
|
|
`;
|
|
}
|
|
}
|
|
|
|
9. Performance & Optimization
|
|
9.1 Performance Targets
|
|
Page Load Times:
|
|
|
|
Homepage: <1.5s
|
|
Documentation pages: <2s
|
|
Interactive demos: <3s
|
|
Search results: <500ms
|
|
|
|
Optimization Strategies:
|
|
javascript// 1. Document caching
|
|
const documentCache = new NodeCache({ stdTTL: 3600 }); // 1 hour
|
|
|
|
app.get('/api/docs/:slug', async (req, res) => {
|
|
const cacheKey = `doc_${req.params.slug}`;
|
|
let doc = documentCache.get(cacheKey);
|
|
|
|
if (!doc) {
|
|
doc = await db.collection('documents').findOne({ slug: req.params.slug });
|
|
documentCache.set(cacheKey, doc);
|
|
}
|
|
|
|
res.json(doc);
|
|
});
|
|
|
|
// 2. CDN for static assets
|
|
// Use OVHCloud CDN for:
|
|
// - Images, logos
|
|
// - CSS/JS bundles
|
|
// - PDF downloads
|
|
|
|
// 3. Database indexing
|
|
db.collection('documents').createIndex({ slug: 1 });
|
|
db.collection('documents').createIndex({ quadrant: 1 });
|
|
db.collection('documents').createIndex({ search_index: 'text' });
|
|
db.collection('blog_posts').createIndex({ published_at: -1 });
|
|
db.collection('blog_posts').createIndex({ status: 1 });
|
|
|
|
// 4. Lazy loading for demos
|
|
// Load interactive components only when needed
|
|
|
|
// 5. Progressive image loading
|
|
// Use responsive images with srcset
|
|
9.2 Monitoring & Analytics
|
|
Privacy-Preserving Analytics:
|
|
javascript// Use Plausible or similar privacy-first analytics
|
|
// No cookies, no personal data collection
|
|
|
|
// Track:
|
|
// - Page views by path
|
|
// - Audience path selection (researcher/implementer/advocate)
|
|
// - Document downloads
|
|
// - Demo usage
|
|
// - Search queries (anonymized)
|
|
// - Geographic distribution (country-level only)
|
|
// - Referral sources
|
|
|
|
// Do NOT track:
|
|
// - Individual users
|
|
// - IP addresses beyond country
|
|
// - Browsing behavior across sessions
|
|
// - Personal information
|
|
|
|
10. Security & Privacy
|
|
10.1 Security Measures
|
|
Authentication (for admin/moderation):
|
|
javascript// JWT-based auth
|
|
const jwt = require('jsonwebtoken');
|
|
|
|
// Admin routes protected
|
|
app.use('/api/admin/*', authenticateAdmin);
|
|
|
|
async function authenticateAdmin(req, res, next) {
|
|
const token = req.headers.authorization?.split(' ')[1];
|
|
|
|
if (!token) {
|
|
return res.status(401).json({ error: 'No token provided' });
|
|
}
|
|
|
|
try {
|
|
const decoded = jwt.verify(token, process.env.JWT_SECRET);
|
|
req.admin = decoded;
|
|
next();
|
|
} catch (error) {
|
|
res.status(401).json({ error: 'Invalid token' });
|
|
}
|
|
}
|
|
Input Validation:
|
|
javascript// Sanitize all user inputs
|
|
const validator = require('validator');
|
|
|
|
app.post('/api/media/inquiry', async (req, res) => {
|
|
// Validate and sanitize
|
|
const inquiry = {
|
|
name: validator.escape(req.body.name),
|
|
email: validator.normalizeEmail(req.body.email),
|
|
subject: validator.escape(req.body.subject),
|
|
message: validator.escape(req.body.message)
|
|
};
|
|
|
|
// Validate email
|
|
if (!validator.isEmail(inquiry.email)) {
|
|
return res.status(400).json({ error: 'Invalid email' });
|
|
}
|
|
|
|
// Rate limiting (prevent spam)
|
|
// ... implementation
|
|
});
|
|
Privacy Policy:
|
|
markdown# Privacy Policy
|
|
|
|
## Data We Collect
|
|
|
|
**Public Interactions**:
|
|
- Media inquiry submissions (name, email, outlet, message)
|
|
- Case study submissions (name, email, organization, case details)
|
|
- Blog comments (if implemented)
|
|
- Newsletter subscriptions (email only)
|
|
|
|
**Analytics** (Privacy-Preserving):
|
|
- Page views (no personal identification)
|
|
- Geographic distribution (country-level only)
|
|
- No cookies, no cross-site tracking
|
|
|
|
**Koha Donations** (Phase 3):
|
|
- Stripe payment information (processed securely by Stripe)
|
|
- Donor name and email (for receipts)
|
|
- Public acknowledgement (only if opted in)
|
|
|
|
## Data We Do NOT Collect
|
|
- IP addresses (beyond country-level analytics)
|
|
- Browsing history
|
|
- Personal browsing behavior
|
|
- Third-party tracking data
|
|
|
|
## Data Usage
|
|
- Media inquiries: Response and relationship management only
|
|
- Case studies: Publication (with consent) and research
|
|
- Donations: Transparency reporting (aggregated/anonymized)
|
|
- Analytics: Site improvement only
|
|
|
|
## Data Retention
|
|
- Active inquiries: Until resolved + 1 year
|
|
- Published content: Indefinite (public record)
|
|
- Analytics: Aggregated only, no personal data stored
|
|
- Donation records: 7 years (legal requirement)
|
|
|
|
## Your Rights
|
|
- Access your data
|
|
- Request deletion (except legal retention requirements)
|
|
- Opt out of communications
|
|
- Update information
|
|
|
|
Contact: privacy@mysy.digital
|
|
|
|
11. Development Workflow
|
|
11.1 Git Repository Structure
|
|
tractatus-website/
|
|
├── .github/
|
|
│ └── workflows/
|
|
│ ├── deploy.yml # Auto-deploy to OVHCloud
|
|
│ └── test.yml # Run tests on PR
|
|
├── public/
|
|
│ ├── css/
|
|
│ ├── js/
|
|
│ ├── images/
|
|
│ └── downloads/ # PDF exports
|
|
├── src/
|
|
│ ├── server.js # Express app
|
|
│ ├── routes/
|
|
│ │ ├── docs.js
|
|
│ │ ├── blog.js
|
|
│ │ ├── media.js
|
|
│ │ ├── cases.js
|
|
│ │ ├── koha.js
|
|
│ │ └── admin.js
|
|
│ ├── controllers/
|
|
│ ├── models/
|
|
│ ├── middleware/
|
|
│ │ ├── auth.js
|
|
│ │ ├── validation.js
|
|
│ │ └── tractatus.js # Framework enforcement
|
|
│ ├── services/
|
|
│ │ ├── ClaudeAPI.js
|
|
│ │ ├── TractusValidator.js
|
|
│ │ ├── DocumentProcessor.js
|
|
│ │ └── StripeService.js
|
|
│ └── utils/
|
|
├── scripts/
|
|
│ ├── migrate-documents.js # Import from knowledge base
|
|
│ ├── generate-pdfs.js # PDF export
|
|
│ └── init-db.js # Database setup
|
|
├── docs/
|
|
│ └── markdown/ # Source markdown files
|
|
├── tests/
|
|
│ ├── unit/
|
|
│ └── integration/
|
|
├── .env.example
|
|
├── package.json
|
|
├── README.md
|
|
└── LICENSE
|
|
11.2 Development Process
|
|
Branch Strategy:
|
|
main # Production (OVHCloud)
|
|
├── develop # Development branch
|
|
│ ├── feature/* # New features
|
|
│ ├── fix/* # Bug fixes
|
|
│ └── content/* # Content updates
|
|
└── release/* # Release candidates
|
|
PR Requirements:
|
|
|
|
Passes all tests
|
|
Code review by at least one maintainer
|
|
Tractatus framework compliance check
|
|
Documentation updated
|
|
No security vulnerabilities
|
|
|
|
Deployment:
|
|
yaml# .github/workflows/deploy.yml
|
|
name: Deploy to OVHCloud
|
|
|
|
on:
|
|
push:
|
|
branches: [ main ]
|
|
|
|
jobs:
|
|
deploy:
|
|
runs-on: ubuntu-latest
|
|
steps:
|
|
- uses: actions/checkout@v2
|
|
|
|
- name: Setup Node.js
|
|
uses: actions/setup-node@v2
|
|
with:
|
|
node-version: '18'
|
|
|
|
- name: Install dependencies
|
|
run: npm ci
|
|
|
|
- name: Run tests
|
|
run: npm test
|
|
|
|
- name: Build
|
|
run: npm run build
|
|
|
|
- name: Deploy to OVHCloud
|
|
env:
|
|
SSH_KEY: ${{ secrets.OVHCLOUD_SSH_KEY }}
|
|
HOST: ${{ secrets.OVHCLOUD_HOST }}
|
|
run: |
|
|
# Deploy script
|
|
./scripts/deploy.sh
|
|
|
|
12. Success Metrics & KPIs
|
|
12.1 Phase-Specific Metrics
|
|
Phase 1 (Foundation):
|
|
|
|
Site uptime: >99.5%
|
|
Page load time: <2s average
|
|
Documentation completeness: 100% of existing docs migrated
|
|
Mobile responsiveness: 100% of pages
|
|
Accessibility score: >90 (Lighthouse)
|
|
|
|
Phase 2 (Engagement):
|
|
|
|
Monthly unique visitors: >1,000
|
|
Avg time on site: >3 minutes
|
|
Bounce rate: <60%
|
|
Blog subscribers: >50
|
|
Demo tool usage: >100 interactions/month
|
|
Media inquiries: >5/month
|
|
|
|
Phase 3 (Growth):
|
|
|
|
Monthly visitors: >5,000
|
|
Monthly supporters (Koha): >20
|
|
Recurring revenue: >$500/month
|
|
Case study submissions: >10 reviewed
|
|
Resource directory: >30 aligned projects
|
|
Multi-language adoption: >10% non-English traffic
|
|
|
|
Phase 4 (Scale):
|
|
|
|
Monthly visitors: >10,000
|
|
Enterprise inquiries: >5/month
|
|
Academic partnerships: >3 active
|
|
Monthly supporters: >100
|
|
Community forum: >500 registered users
|
|
International reach: >20 countries
|
|
|
|
12.2 Tractatus Framework Validation Metrics
|
|
Dogfooding Success:
|
|
|
|
AI actions requiring human oversight: Track frequency
|
|
Escalations to Strategic quadrant: Monitor patterns
|
|
Boundary enforcement effectiveness: 100% of values decisions to humans
|
|
Cross-reference validation catches: Count prevented errors
|
|
Human override rate: % of AI suggestions modified by humans
|
|
|
|
Framework Demonstration:
|
|
|
|
Demo tool usage correlates with framework understanding
|
|
Case study submissions cite framework concepts
|
|
Media coverage references architectural safety approach
|
|
|
|
|
|
13. Content Strategy & Editorial Calendar
|
|
13.1 Blog Content Pillars
|
|
Pillar 1: Technical Deep Dives (Researcher audience)
|
|
|
|
Frequency: 2x/month
|
|
Topics: Implementation details, research insights, theoretical advances
|
|
Length: 1500-2500 words
|
|
Examples:
|
|
|
|
"Time-Persistence Metadata: A Formal Specification"
|
|
"Cross-Reference Validation: Implementation Patterns"
|
|
"Organizational Theory Foundations of Tractatus"
|
|
|
|
|
|
|
|
Pillar 2: Implementation Stories (Implementer audience)
|
|
|
|
Frequency: 2x/month
|
|
Topics: Case studies, integration guides, practical tips
|
|
Length: 1000-1500 words
|
|
Examples:
|
|
|
|
"How We Prevented the 27027 Error Class"
|
|
"Integrating Tractatus with Existing LLM Pipelines"
|
|
"Metrics That Matter: Measuring Framework Effectiveness"
|
|
|
|
|
|
|
|
Pillar 3: Advocacy & Impact (Advocate audience)
|
|
|
|
Frequency: 2x/month
|
|
Topics: Policy implications, public education, community stories
|
|
Length: 800-1200 words
|
|
Examples:
|
|
|
|
"Why AI Safety Needs Structural Guarantees"
|
|
"Democratic Governance for AI Systems"
|
|
"Digital Sovereignty: From Indigenous Leadership to Global AI"
|
|
|
|
|
|
|
|
Pillar 4: News & Updates (All audiences)
|
|
|
|
Frequency: Weekly
|
|
Topics: Project updates, partnerships, events
|
|
Length: 300-600 words
|
|
Examples:
|
|
|
|
"Tractatus Framework v2.0 Released"
|
|
"New Academic Partnership Announced"
|
|
"Webinar Series: AI Safety Fundamentals"
|
|
|
|
|
|
|
|
13.2 AI Curation Workflow
|
|
javascript// Weekly blog curation process
|
|
class WeeklyBlogCuration {
|
|
async process() {
|
|
// 1. AI scans for trending topics
|
|
const trends = await this.claudeAPI.identifyTrends({
|
|
sources: ['ai_safety_papers', 'llm_research', 'sovereignty_news'],
|
|
timeframe: 'past_week'
|
|
});
|
|
|
|
// 2. AI suggests blog topics
|
|
const suggestions = await this.claudeAPI.suggestBlogTopics({
|
|
trends: trends,
|
|
pillars: ['technical', 'implementation', 'advocacy', 'news'],
|
|
strategic_values: await this.loadStrategicValues()
|
|
});
|
|
|
|
// 3. Human editorial review
|
|
// (in moderation queue)
|
|
|
|
// 4. For approved topics, AI drafts post
|
|
for (const topic of approved_topics) {
|
|
const draft = await this.claudeAPI.draftBlogPost({
|
|
topic: topic,
|
|
audience: topic.pillar_audience,
|
|
guidelines: await this.loadEditorialGuidelines()
|
|
});
|
|
|
|
// 5. Queue for human editing
|
|
await this.queueForHumanEdit(draft, topic);
|
|
}
|
|
|
|
// 6. Human edits and approves
|
|
// 7. Schedule publication
|
|
}
|
|
}
|
|
|
|
14. Launch Strategy
|
|
14.1 Pre-Launch (Month 1)
|
|
Week 1-2: Infrastructure
|
|
|
|
Set up OVHCloud hosting
|
|
Configure domain (mysy.digital)
|
|
Deploy base application
|
|
Migrate core documentation
|
|
Test all systems
|
|
|
|
Week 3-4: Content
|
|
|
|
Final review of all migrated docs
|
|
Write homepage copy
|
|
Create about/values pages
|
|
Prepare initial blog posts (3-5 pre-written)
|
|
Media kit preparation
|
|
|
|
Week 4: Testing
|
|
|
|
Full QA testing
|
|
Mobile responsiveness check
|
|
Accessibility audit
|
|
Performance optimization
|
|
Security review
|
|
|
|
14.2 Launch Day (Month 2, Week 1)
|
|
Announcement Strategy:
|
|
|
|
Email (if existing contacts):
|
|
|
|
Anthropic research team
|
|
Academic collaborators
|
|
Aligned organizations
|
|
|
|
|
|
Social Media:
|
|
|
|
LinkedIn (professional network)
|
|
Twitter/X (AI safety community)
|
|
Hacker News (technical audience)
|
|
|
|
|
|
Direct Outreach:
|
|
|
|
AI safety research groups
|
|
University AI departments
|
|
Indigenous data sovereignty organizations
|
|
|
|
|
|
Press Release:
|
|
|
|
NZ tech media
|
|
AI safety publications
|
|
Academic press
|
|
|
|
|
|
|
|
Launch Content:
|
|
markdownSubject: Introducing Tractatus: Structural AI Safety from Aotearoa
|
|
|
|
We're excited to announce the public launch of the Tractatus-Based LLM
|
|
Safety Framework - a comprehensive approach to AI safety through
|
|
architectural guarantees rather than training alone.
|
|
|
|
Developed in Aotearoa New Zealand and informed by indigenous leadership
|
|
in digital sovereignty, Tractatus provides formal mechanisms to preserve
|
|
human agency as AI systems advance toward AGI.
|
|
|
|
🔬 For Researchers: Complete technical documentation, case studies, and
|
|
collaboration opportunities
|
|
⚙️ For Implementers: Production-ready code, integration guides, and
|
|
interactive demos
|
|
📢 For Advocates: Plain-language resources, policy recommendations, and
|
|
community engagement
|
|
|
|
Explore at mysy.digital
|
|
|
|
[Key highlights, link to executive brief, invitation to engage]
|
|
14.3 Post-Launch (Month 2-3)
|
|
Week 1-4: Engagement
|
|
|
|
Respond to all inquiries within 24 hours
|
|
Monitor analytics daily
|
|
Publish 2 blog posts/week
|
|
Engage with community feedback
|
|
Fix bugs quickly
|
|
|
|
Week 5-8: Iteration
|
|
|
|
Analyze user behavior
|
|
Identify most-visited paths
|
|
Optimize underperforming pages
|
|
Expand popular content
|
|
Build email subscriber list
|
|
|
|
Week 9-12: Expansion
|
|
|
|
Launch first interactive demo
|
|
Host first webinar/presentation
|
|
Publish first case study from community
|
|
Begin resource directory curation
|
|
Prepare Phase 2 features
|
|
|
|
|
|
15. Team & Roles
|
|
15.1 Core Team (Start)
|
|
Human PM (You - John Stroh):
|
|
|
|
Strategic direction (STRATEGIC quadrant)
|
|
Values stewardship
|
|
Final approval on all content
|
|
Community relationship building
|
|
Media spokesperson
|
|
|
|
Claude Code (AI Developer):
|
|
|
|
Technical implementation (SYSTEM quadrant)
|
|
Code generation and testing
|
|
Database management
|
|
Infrastructure maintenance
|
|
Following Tractatus framework in development
|
|
|
|
Claude Web (AI Curator):
|
|
|
|
Content suggestions (STOCHASTIC quadrant)
|
|
Blog post drafting (pending human approval)
|
|
Media inquiry triage
|
|
Resource recommendations
|
|
Analytics insights
|
|
Subject to Tractatus boundaries
|
|
|
|
15.2 Governance Structure
|
|
Strategic Quadrant (Human PM):
|
|
|
|
Mission and values decisions
|
|
Te Tiriti alignment
|
|
Strategic partnerships
|
|
Major feature decisions
|
|
Annual planning
|
|
|
|
Operational Quadrant (Human PM + Claude):
|
|
|
|
Editorial guidelines (Human sets, Claude follows)
|
|
Content calendar (Human approves, Claude suggests)
|
|
Moderation policies (Human defines, Claude assists)
|
|
Quality standards (Human establishes)
|
|
|
|
Tactical Quadrant (Primarily Claude, Human oversight):
|
|
|
|
Daily blog suggestions
|
|
Inquiry triage
|
|
Resource curation
|
|
Analytics reporting
|
|
Subject to human approval for values-sensitive items
|
|
|
|
System Quadrant (Primarily Claude Code):
|
|
|
|
Technical implementation
|
|
Database optimization
|
|
Security updates
|
|
Performance monitoring
|
|
Human review for major changes
|
|
|
|
Stochastic Quadrant (Claude + Human):
|
|
|
|
Innovation exploration
|
|
New feature ideas
|
|
Pattern recognition in community needs
|
|
Experimental content formats
|
|
Human approval before implementation
|
|
|
|
|
|
16. Budget Considerations
|
|
16.1 Initial Costs (Phase 1)
|
|
Hosting (OVHCloud):
|
|
|
|
VPS: ~€20-40/month
|
|
Database: Included
|
|
Bandwidth: ~€5-10/month
|
|
Total: €25-50/month ($40-80 NZD)
|
|
|
|
Domain:
|
|
|
|
mysy.digital: Already registered
|
|
|
|
Development Tools:
|
|
|
|
GitHub: Free (public repos)
|
|
Codeberg/Gitea: Free
|
|
Monitoring: Free tier (Plausible Analytics)
|
|
Total: €0/month
|
|
|
|
Claude API (for AI features):
|
|
|
|
Estimated usage: ~$50-100/month (Phase 2+)
|
|
|
|
SSL Certificate:
|
|
|
|
Let's Encrypt: Free
|
|
|
|
Total Phase 1 Operating Costs: ~$40-80/month
|
|
16.2 Phase 3 Costs (with Koha)
|
|
Stripe Fees:
|
|
|
|
2.9% + $0.30 per transaction
|
|
Monthly subscriptions: Same rate
|
|
Estimated: 10-15% of donations
|
|
|
|
Increased Hosting (scaling):
|
|
|
|
Larger VPS: ~€80-120/month
|
|
CDN: ~€10-20/month
|
|
Total: €90-140/month ($150-230 NZD)
|
|
|
|
Revenue Projection (Phase 3):
|
|
|
|
20 monthly supporters @ $15/month = $300
|
|
One-time donations: ~$200/month average
|
|
Gross: ~$500/month
|
|
Net (after Stripe): ~$450/month
|
|
Covers hosting + development costs
|
|
|
|
|
|
17. Risk Management
|
|
17.1 Technical Risks
|
|
RiskLikelihoodImpactMitigationOVHCloud outageLowHighDaily backups, documented recovery processDatabase corruptionLowVery HighHourly backups, MongoDB replica setSecurity breachMediumVery HighRegular security audits, penetration testingPerformance issuesMediumMediumLoad testing, caching, CDNAI API limitsLowMediumRate limiting, fallback to human-only curation
|
|
17.2 Content Risks
|
|
RiskLikelihoodImpactMitigationAI publishes inappropriate contentLowVery HighAll AI content requires human approval (Tractatus)Misinformation in blogLowHighEditorial review, fact-checking processCopyright violationLowHighClear attribution policies, legal reviewValues misalignmentLowVery HighStrategic quadrant review for sensitive content
|
|
17.3 Community Risks
|
|
RiskLikelihoodImpactMitigationLow initial trafficHighMediumTargeted outreach, SEO optimizationNegative feedbackMediumMediumTransparent governance, open to criticismSpam/abuseMediumLowRate limiting, moderation toolsLack of engagementMediumMediumQuality content, community building
|
|
|
|
18. Long-Term Vision (Beyond 18 Months)
|
|
18.1 Institutional Partnerships
|
|
Academic:
|
|
|
|
University research collaborations
|
|
Student internship programs
|
|
Joint publications
|
|
Conference sponsorships
|
|
|
|
Industry:
|
|
|
|
Enterprise pilot programs
|
|
Integration partnerships
|
|
Standards development
|
|
Industry consortium membership
|
|
|
|
Government:
|
|
|
|
Policy advisory roles
|
|
Public sector implementations
|
|
Regulatory consultation
|
|
International cooperation (esp. with NZ govt, Māori data sovereignty bodies)
|
|
|
|
18.2 Platform Evolution
|
|
Technical Maturity:
|
|
|
|
Reference implementation in multiple languages
|
|
Certified integration partners
|
|
Training and certification programs
|
|
Open-source ecosystem development
|
|
|
|
Global Reach:
|
|
|
|
Regional chapters/communities
|
|
International translations (20+ languages)
|
|
Cultural adaptations (respect for local sovereignty contexts)
|
|
Federated governance model
|
|
|
|
18.3 Impact Goals
|
|
By Year 3:
|
|
|
|
10+ major AI organizations using framework
|
|
100+ published implementations
|
|
50+ peer-reviewed papers citing work
|
|
1,000+ monthly supporters
|
|
Recognized as leading AI safety approach
|
|
Strong global community of practitioners
|
|
|
|
By Year 5:
|
|
|
|
Industry standard for AI safety architecture
|
|
Government policy adoption (multiple countries)
|
|
Educational curriculum integration
|
|
Self-sustaining open-source ecosystem
|
|
Demonstrated prevention of major AI failures
|
|
Model for democratic AI governance
|
|
|
|
|
|
19. Getting Started - Immediate Next Steps
|
|
19.1 For Claude Code (This Session)
|
|
Priority 1: Infrastructure Setup
|
|
bash# 1. Initialize project
|
|
mkdir tractatus-website && cd tractatus-website
|
|
npm init -y
|
|
|
|
# 2. Install dependencies
|
|
npm install express mongodb dotenv jsonwebtoken bcrypt
|
|
npm install marked highlight.js sanitize-html
|
|
npm install express-rate-limit helmet cors
|
|
|
|
# 3. Project structure
|
|
mkdir -p src/{routes,controllers,models,middleware,services,utils}
|
|
mkdir -p public/{css,js,images}
|
|
mkdir -p scripts docs/markdown tests
|
|
|
|
# 4. Create base files
|
|
touch src/server.js
|
|
touch .env.example
|
|
touch README.md
|
|
|
|
# 5. Initialize git
|
|
git init
|
|
git remote add origin [GitHub URL]
|
|
Priority 2: Database Setup
|
|
javascript// scripts/init-db.js
|
|
// Create collections, indexes, seed data
|
|
Priority 3: Document Migration
|
|
javascript// scripts/migrate-documents.js
|
|
// Import all markdown files from knowledge base
|
|
// Convert to HTML
|
|
// Store in MongoDB with metadata
|
|
19.2 Immediate Deliverables
|
|
This Week:
|
|
|
|
Project structure created
|
|
Database initialized
|
|
Core documents migrated
|
|
Basic server running
|
|
Homepage template
|
|
|
|
Next Week:
|
|
|
|
All routes implemented
|
|
Three audience paths built
|
|
Documentation viewer working
|
|
Basic styling complete
|
|
|
|
Week 3:
|
|
|
|
Testing complete
|
|
OVHCloud deployment
|
|
Domain connected
|
|
SSL configured
|
|
Ready for soft launch
|
|
|
|
|
|
20. Appendix: Quick Reference
|
|
20.1 Key URLs
|
|
Homepage: mysy.digital
|
|
Research Path: mysy.digital/research
|
|
Implementer Path: mysy.digital/implement
|
|
Advocacy Path: mysy.digital/advocacy
|
|
Blog: mysy.digital/blog
|
|
Documentation: mysy.digital/docs
|
|
About: mysy.digital/about
|
|
Contact: mysy.digital/contact
|
|
Media Kit: mysy.digital/media
|
|
20.2 Technology Stack Summary
|
|
LayerTechnologyPurposeFrontendVanilla JS + Tailwind CSSFast, accessible, no framework dependencyBackendNode.js + ExpressLeverages existing family-history stackDatabaseMongoDB + GridFSDocument storage, file managementAuthJWTAdmin/moderation accessAIClaude APIContent curation, triage, analysisPaymentsStripeKoha donations (Phase 3)HostingOVHCloudSovereignty-aligned hostingCDNOVHCloud CDNStatic asset deliveryRepositoryGitHub + Codeberg/GiteaVersion control, mirrorsAnalyticsPlausiblePrivacy-preserving metrics
|
|
20.3 Project Contacts
|
|
Project Lead: John Stroh (john.stroh.nz@pm.me)
|
|
Technical: via GitHub issues
|
|
Media Inquiries: press@mysy.digital
|
|
General: hello@mysy.digital
|
|
|
|
21. Conclusion
|
|
This specification provides a comprehensive roadmap for building mysy.digital as a world-class platform for the Tractatus-Based LLM Safety Framework. By leveraging the existing family-history technical stack, implementing the framework's own principles (dogfooding), and serving three distinct audiences through differentiated paths, the site will effectively communicate this important AI safety research to researchers, implementers, and advocates worldwide.
|
|
The phased approach ensures sustainable development, the Tractatus governance guarantees alignment with strategic values, and the Te Tiriti acknowledgement positions Aotearoa New Zealand's leadership in indigenous-informed digital sovereignty within a global context.
|
|
Ready to begin implementation with Claude Code.
|
|
|
|
Document Metadata:
|
|
|
|
Created: 2025-10-06
|
|
Version: 1.0.0
|
|
Quadrant: STRATEGIC (with operational specifications)
|
|
Status: Ready for implementation
|
|
Next Action: Claude Code to begin Phase 1 development
|
|
RetrySTR-VAL-0004-transparency-principle-v1-0.md246 linesmdSTR-VAL-0003-values-principles-directory-v1-0.md88 linesmdSTR-VAL-0002-biodiversity-sustainability-principles-v1-0.md125 linesmdSTR-VAL-0001-core-values-principles-v1-0.md127 linesmdSTR-GOV-0003-strategic-versioning-guidelines-v1-0.md263 linesmdSTR-GOV-0002-values-alignment-framework-v1-0.md173 linesmdSTR-GOV-0001-strategic-review-protocol-v1-0.md285 linesmd
|
|
|
|
Summary of Strategic Values Integration
|
|
Created document: /home/claude/tractatus-strategic-values-integration.md
|
|
Key Additions to Website Specification:
|
|
1. Core Values Deeply Embedded (not just mentioned):
|
|
|
|
Sovereignty & Self-Determination: No tracking, user-controlled engagement, open-source everything
|
|
Progressive Implementation: Phased rollout with clear rationale for each stage
|
|
Transparency & Honesty: Public moderation queue, AI reasoning visible, decisions documented
|
|
Harmlessness & Protection: Privacy-first design, no dark patterns, security audits
|
|
Community & Accessibility: Three audience paths, WCAG compliance, economic accessibility
|
|
Biodiversity & Sustainability: Alternative frameworks highlighted, green hosting, ecosystem thinking
|
|
|
|
2. Governance Frameworks Applied:
|
|
|
|
Strategic Review Protocol adapted for website operations
|
|
Values Alignment Framework with specific matrices for website features
|
|
Strategic Versioning applied to all website documentation
|
|
Tension resolution process (when values conflict)
|
|
|
|
3. Te Tiriti Integration Deepened:
|
|
|
|
From acknowledgement to partnership (consultation with Māori data sovereignty experts)
|
|
Protection (CARE principles guide data handling)
|
|
Participation (Te Reo Māori content, Māori leadership pathways)
|
|
Kaitiakitanga (guardianship mindset for future generations)
|
|
|
|
4. Tractatus Framework Self-Applied (Dogfooding):
|
|
|
|
All AI curation subject to human oversight (boundary enforcement)
|
|
AI suggestions validated against values (cross-reference validation)
|
|
AI provides self-assessment before human review (metacognitive verification)
|
|
Values decisions always escalate to humans (architectural guarantee)
|
|
|
|
5. Values-Aligned Metrics:
|
|
|
|
Not just traffic/engagement, but sovereignty metrics, transparency audits, community diversity
|
|
Success measured by embodying values, not arbitrary KPIs
|
|
|
|
6. Practical Implementation:
|
|
|
|
Values alignment checklist for every feature
|
|
Code examples showing values in architecture
|
|
Moderation queue with public transparency
|
|
Human oversight requirements clearly defined
|
|
|
|
What This Changes in Your Specification
|
|
You should integrate this Section 0 before your current Section 1 (Technical Architecture). It establishes the why and how before the what.
|
|
Critical implications:
|
|
|
|
The website isn't just about AI safety—it demonstrates AI safety through values-aligned governance
|
|
Every feature decision now includes a mandatory values alignment check
|
|
AI assistance (blog curation, media triage) follows Tractatus boundaries
|
|
Success = values embodiment, not growth metrics
|