`;
// Render documents in category
docs.forEach(doc => {
- const isHighlighted = categoryId === 'start-here';
+ const isHighlighted = categoryId === 'getting-started' && doc.order === 1;
html += renderDocLink(doc, isHighlighted);
});
@@ -197,6 +186,39 @@ async function loadDocuments() {
`;
});
+ // Add Archives section if there are archived documents
+ if (archivedDocuments.length > 0) {
+ html += `
+
+
+
+ `;
+
+ // Render archived documents
+ archivedDocuments.forEach(doc => {
+ html += renderDocLink(doc, false);
+ // Add archive note if available
+ if (doc.archiveNote) {
+ html += `
${doc.archiveNote}
`;
+ }
+ });
+
+ html += `
+
+
+ `;
+ }
+
listEl.innerHTML = html;
// Add event delegation for document links
@@ -232,13 +254,19 @@ async function loadDocuments() {
}
});
- // Auto-load first document in "Start Here" category
- const startHereDocs = grouped['start-here'] || [];
- if (startHereDocs.length > 0) {
- loadDocument(startHereDocs[0].slug);
+ // Auto-load first document in "Getting Started" category (order: 1)
+ const gettingStartedDocs = grouped['getting-started'] || [];
+ if (gettingStartedDocs.length > 0) {
+ // Load the architectural overview (order: 1) if available
+ const archOverview = gettingStartedDocs.find(d => d.order === 1);
+ if (archOverview) {
+ loadDocument(archOverview.slug);
+ } else {
+ loadDocument(gettingStartedDocs[0].slug);
+ }
} else if (documents.length > 0) {
// Fallback to first available document
- const firstCategory = sortedCategories.find(([_, cat]) => grouped[cat] && grouped[cat].length > 0);
+ const firstCategory = sortedCategories.find(([catId]) => grouped[catId] && grouped[catId].length > 0);
if (firstCategory) {
loadDocument(grouped[firstCategory[0]][0].slug);
}
diff --git a/scripts/archive-all-internal-documents.js b/scripts/archive-all-internal-documents.js
new file mode 100644
index 00000000..a82b3ec1
--- /dev/null
+++ b/scripts/archive-all-internal-documents.js
@@ -0,0 +1,171 @@
+/**
+ * Archive All Internal Documents
+ * Mass archive of project tracking, internal, and confidential documents
+ */
+
+const { MongoClient } = require('mongodb');
+
+// MongoDB connection
+const MONGODB_URI = process.env.MONGODB_URI || 'mongodb://localhost:27017/tractatus_dev';
+const DB_NAME = process.env.MONGODB_DB || 'tractatus_dev';
+
+// Documents to mark as confidential (not archived, just hidden)
+const CONFIDENTIAL_DOCS = [
+ 'security-audit-report',
+ 'koha-stripe-payment-setup-guide',
+ 'koha-production-deployment-guide',
+ 'appendix-e-contact-information',
+ 'cover-letter-for-anthropic-submission'
+];
+
+// Documents to archive (project tracking, internal planning)
+const ARCHIVE_PATTERNS = [
+ 'phase-2-', // All Phase 2 planning docs
+ 'session-handoff', // All session handoffs
+ 'appendix-b-', // Duplicate case studies
+ 'implementation-roadmap', // Outdated planning
+ 'implementation-guide-python', // Outdated code examples
+ 'research-foundations-scholarly', // Academic, not practical
+ 'tractatus-blog-post-outlines', // Internal planning
+ 'tractatus-project-implementation-progress-report', // Project tracking
+ 'tractatus-production-comprehensive-testing-checklist', // Internal testing
+ 'tractatus-production-testing-results', // Test results
+ 'tractatus-governance-framework-test-suite', // Internal testing
+ 'ai-features-implementation-session' // Session tracking
+];
+
+async function main() {
+ console.log('=== Archiving All Internal Documents ===\n');
+
+ let client;
+
+ try {
+ // Connect to MongoDB
+ console.log('Connecting to MongoDB...');
+ client = await MongoClient.connect(MONGODB_URI);
+ const db = client.db(DB_NAME);
+ const collection = db.collection('documents');
+ console.log('✓ Connected\n');
+
+ // 1. Mark confidential documents
+ console.log('=== Marking Confidential Documents ===\n');
+ let confidentialCount = 0;
+
+ for (const slug of CONFIDENTIAL_DOCS) {
+ const result = await collection.updateOne(
+ { slug },
+ {
+ $set: {
+ visibility: 'confidential',
+ category: 'internal',
+ order: 999
+ }
+ }
+ );
+
+ if (result.matchedCount > 0) {
+ console.log(`✓ Marked confidential: ${slug}`);
+ confidentialCount++;
+ }
+ }
+ console.log(`\n✓ Total confidential: ${confidentialCount}\n`);
+
+ // 2. Archive documents matching patterns
+ console.log('=== Archiving Project Tracking Documents ===\n');
+ let archivedCount = 0;
+
+ const allDocs = await collection.find({ visibility: { $ne: 'confidential' } }).toArray();
+
+ for (const doc of allDocs) {
+ const shouldArchive = ARCHIVE_PATTERNS.some(pattern =>
+ doc.slug.includes(pattern)
+ );
+
+ if (shouldArchive && doc.visibility !== 'archived') {
+ const result = await collection.updateOne(
+ { _id: doc._id },
+ {
+ $set: {
+ visibility: 'archived',
+ category: 'project-tracking',
+ order: 999,
+ archiveNote: 'Internal project tracking document. Not relevant for public documentation.'
+ }
+ }
+ );
+
+ if (result.matchedCount > 0) {
+ console.log(`✓ Archived: ${doc.slug}`);
+ archivedCount++;
+ }
+ }
+ }
+ console.log(`\n✓ Total archived: ${archivedCount}\n`);
+
+ // 3. Handle recent case studies (keep but categorize)
+ console.log('=== Categorizing Case Studies ===\n');
+ const caseStudySlugs = [
+ 'our-framework-in-action-detecting-and-correcting-ai-fabrications',
+ 'framework-governance-in-action-pre-publication-security-audit',
+ 'real-world-ai-governance-a-case-study-in-framework-failure-and-recovery',
+ 'when-frameworks-fail-and-why-thats-ok'
+ ];
+
+ let caseStudyCount = 0;
+ for (const [index, slug] of caseStudySlugs.entries()) {
+ const result = await collection.updateOne(
+ { slug },
+ {
+ $set: {
+ visibility: 'public',
+ category: 'practical',
+ audience: 'general',
+ order: 8 + index // Orders 8-11
+ }
+ }
+ );
+
+ if (result.matchedCount > 0) {
+ console.log(`✓ Categorized: ${slug} (order: ${8 + index})`);
+ caseStudyCount++;
+ }
+ }
+ console.log(`\n✓ Total case studies: ${caseStudyCount}\n`);
+
+ // Summary
+ console.log('=== Final Summary ===\n');
+ const publicCount = await collection.countDocuments({ visibility: 'public' });
+ const archivedTotal = await collection.countDocuments({ visibility: 'archived' });
+ const confidentialTotal = await collection.countDocuments({ visibility: 'confidential' });
+
+ console.log(`📖 Public documents: ${publicCount}`);
+ console.log(`📦 Archived documents: ${archivedTotal}`);
+ console.log(`🔒 Confidential documents: ${confidentialTotal}`);
+ console.log(`\nTotal: ${publicCount + archivedTotal + confidentialTotal} documents\n`);
+
+ // Show public documents
+ console.log('=== Public Documents (Final List) ===\n');
+ const publicDocs = await collection.find({ visibility: 'public' })
+ .sort({ order: 1 })
+ .project({ title: 1, order: 1, category: 1 })
+ .toArray();
+
+ publicDocs.forEach(doc => {
+ console.log(` ${doc.order}. ${doc.title} [${doc.category}]`);
+ });
+
+ } catch (error) {
+ console.error('\n✗ Error:', error.message);
+ console.error(error.stack);
+ process.exit(1);
+ } finally {
+ if (client) await client.close();
+ }
+}
+
+// Run if called directly
+if (require.main === module) {
+ main();
+}
+
+module.exports = { main };
diff --git a/scripts/archive-outdated-documents.js b/scripts/archive-outdated-documents.js
new file mode 100644
index 00000000..65701f32
--- /dev/null
+++ b/scripts/archive-outdated-documents.js
@@ -0,0 +1,147 @@
+/**
+ * Archive Outdated Documents
+ * Sets visibility: 'archived' for 10 documents identified in audit
+ */
+
+const { MongoClient } = require('mongodb');
+
+// MongoDB connection
+const MONGODB_URI = process.env.MONGODB_URI || 'mongodb://localhost:27017/tractatus_dev';
+const DB_NAME = process.env.MONGODB_DB || 'tractatus_dev';
+
+// Documents to archive with reasons
+const DOCUMENTS_TO_ARCHIVE = [
+ {
+ slug: 'introduction-to-the-tractatus-framework',
+ category: 'archived',
+ archiveNote: 'Superseded by Architectural Overview & Research Status. References outdated filesystem-only architecture.',
+ reason: 'Outdated architecture (pre-MongoDB)'
+ },
+ {
+ slug: 'tractatus-based-llm-architecture-for-ai-safety',
+ category: 'archived',
+ archiveNote: 'Historical architecture proposal. See Architectural Overview for implemented architecture.',
+ reason: 'Pre-Phase 5 architecture proposal'
+ },
+ {
+ slug: 'executive-brief-tractatus-based-llm-architecture-for-ai-safety',
+ category: 'archived',
+ archiveNote: 'Historical brief based on pre-Phase 5 architecture. See Architectural Overview for current status.',
+ reason: 'Pre-Phase 5 executive brief'
+ },
+ {
+ slug: 'tractatus-framework-enforcement-for-claude-code',
+ category: 'archived',
+ archiveNote: 'Development tool documentation. See Implementation Guide for production deployment.',
+ reason: 'Internal development tool'
+ },
+ {
+ slug: 'organizational-theory-foundations-of-the-tractatus-framework',
+ category: 'archived',
+ archiveNote: 'Academic foundations. See Core Concepts for practical overview.',
+ reason: 'Academic content, not practical'
+ },
+ {
+ slug: 'phase-5-poc-session-1-summary',
+ category: 'project-tracking',
+ archiveNote: 'Project tracking - Phase 5 Session 1. See Architectural Overview for complete project history.',
+ reason: 'Project tracking'
+ },
+ {
+ slug: 'phase-5-poc-session-2-summary',
+ category: 'project-tracking',
+ archiveNote: 'Project tracking - Phase 5 Session 2. See Architectural Overview for complete project history.',
+ reason: 'Project tracking'
+ },
+ {
+ slug: 'research-scope-feasibility-of-llm-integrated-tractatus-framework',
+ category: 'research-proposal',
+ archiveNote: 'Research proposal (not completed work). See Architectural Overview for actual implementation status.',
+ reason: 'Research proposal'
+ },
+ {
+ slug: 'research-topic-concurrent-session-architecture-limitations-in-claude-code-governance',
+ category: 'research-topic',
+ archiveNote: 'Open research question. See Architectural Overview for current architecture limitations.',
+ reason: 'Open research question'
+ },
+ {
+ slug: 'research-topic-rule-proliferation-and-transactional-overhead-in-ai-governance',
+ category: 'research-topic',
+ archiveNote: 'Open research question. See Architectural Overview for current governance approach.',
+ reason: 'Open research question'
+ }
+];
+
+async function main() {
+ console.log('=== Archiving Outdated Documents ===\n');
+
+ let client;
+
+ try {
+ // Connect to MongoDB
+ console.log('Connecting to MongoDB...');
+ client = await MongoClient.connect(MONGODB_URI);
+ const db = client.db(DB_NAME);
+ const collection = db.collection('documents');
+ console.log('✓ Connected\n');
+
+ let archived = 0;
+ let notFound = 0;
+
+ // Archive each document
+ for (const doc of DOCUMENTS_TO_ARCHIVE) {
+ console.log(`Archiving: ${doc.slug}`);
+ console.log(` Reason: ${doc.reason}`);
+
+ const result = await collection.updateOne(
+ { slug: doc.slug },
+ {
+ $set: {
+ visibility: 'archived',
+ category: doc.category,
+ archiveNote: doc.archiveNote,
+ order: 999
+ }
+ }
+ );
+
+ if (result.matchedCount > 0) {
+ console.log(` ✓ Archived\n`);
+ archived++;
+ } else {
+ console.log(` ⚠ Not found in database\n`);
+ notFound++;
+ }
+ }
+
+ // Summary
+ console.log('=== Summary ===\n');
+ console.log(`✓ Archived: ${archived} documents`);
+ if (notFound > 0) {
+ console.log(`⚠ Not found: ${notFound} documents`);
+ }
+ console.log(`\nTotal processed: ${DOCUMENTS_TO_ARCHIVE.length}`);
+
+ // Verify archives
+ console.log('\n=== Verification ===\n');
+ const archivedCount = await collection.countDocuments({ visibility: 'archived' });
+ const publicCount = await collection.countDocuments({ visibility: 'public' });
+ console.log(`Archived documents: ${archivedCount}`);
+ console.log(`Public documents: ${publicCount}`);
+
+ } catch (error) {
+ console.error('\n✗ Error:', error.message);
+ console.error(error.stack);
+ process.exit(1);
+ } finally {
+ if (client) await client.close();
+ }
+}
+
+// Run if called directly
+if (require.main === module) {
+ main();
+}
+
+module.exports = { main };
diff --git a/scripts/update-document-metadata.js b/scripts/update-document-metadata.js
new file mode 100644
index 00000000..70a589b4
--- /dev/null
+++ b/scripts/update-document-metadata.js
@@ -0,0 +1,149 @@
+/**
+ * Update Document Metadata and Ordering
+ * Sets proper order, category, and audience for public documents
+ */
+
+const { MongoClient } = require('mongodb');
+
+// MongoDB connection
+const MONGODB_URI = process.env.MONGODB_URI || 'mongodb://localhost:27017/tractatus_dev';
+const DB_NAME = process.env.MONGODB_DB || 'tractatus_dev';
+
+// Document metadata updates
+const DOCUMENT_UPDATES = [
+ // GETTING STARTED (order: 1-3)
+ {
+ slug: 'architectural-overview-and-research-status',
+ order: 1,
+ category: 'reference',
+ audience: 'general',
+ visibility: 'public'
+ },
+ {
+ slug: 'core-concepts-of-the-tractatus-framework',
+ order: 2,
+ category: 'conceptual',
+ audience: 'general',
+ visibility: 'public'
+ },
+ {
+ slug: 'implementation-guide',
+ order: 3,
+ category: 'practical',
+ audience: 'technical',
+ visibility: 'public'
+ },
+ // FRAMEWORK DETAILS (order: 4-6)
+ {
+ slug: 'tractatus-ai-safety-framework-core-values-and-principles',
+ order: 4,
+ category: 'conceptual',
+ audience: 'general',
+ visibility: 'public'
+ },
+ {
+ slug: 'case-studies-real-world-llm-failure-modes',
+ order: 5,
+ category: 'practical',
+ audience: 'general',
+ visibility: 'public'
+ },
+ {
+ slug: 'ai-governance-business-case-template-tractatus-framework',
+ order: 6,
+ category: 'practical',
+ audience: 'business',
+ visibility: 'public'
+ },
+ // REFERENCE (order: 7)
+ {
+ slug: 'tractatus-agentic-governance-system-glossary-of-terms',
+ order: 7,
+ category: 'reference',
+ audience: 'general',
+ visibility: 'public'
+ }
+];
+
+async function main() {
+ console.log('=== Updating Document Metadata ===\n');
+
+ let client;
+
+ try {
+ // Connect to MongoDB
+ console.log('Connecting to MongoDB...');
+ client = await MongoClient.connect(MONGODB_URI);
+ const db = client.db(DB_NAME);
+ const collection = db.collection('documents');
+ console.log('✓ Connected\n');
+
+ let updated = 0;
+ let notFound = 0;
+
+ // Update each document
+ for (const doc of DOCUMENT_UPDATES) {
+ console.log(`Updating: ${doc.slug}`);
+ console.log(` Order: ${doc.order} | Category: ${doc.category} | Audience: ${doc.audience}`);
+
+ const result = await collection.updateOne(
+ { slug: doc.slug },
+ {
+ $set: {
+ order: doc.order,
+ category: doc.category,
+ audience: doc.audience,
+ visibility: doc.visibility
+ }
+ }
+ );
+
+ if (result.matchedCount > 0) {
+ console.log(` ✓ Updated\n`);
+ updated++;
+ } else {
+ console.log(` ⚠ Not found in database\n`);
+ notFound++;
+ }
+ }
+
+ // Summary
+ console.log('=== Summary ===\n');
+ console.log(`✓ Updated: ${updated} documents`);
+ if (notFound > 0) {
+ console.log(`⚠ Not found: ${notFound} documents`);
+ }
+ console.log(`\nTotal processed: ${DOCUMENT_UPDATES.length}`);
+
+ // Verify organization
+ console.log('\n=== Verification ===\n');
+ const publicDocs = await collection.find({ visibility: 'public' })
+ .sort({ order: 1 })
+ .project({ title: 1, order: 1, category: 1, audience: 1 })
+ .toArray();
+
+ console.log('Public documents (sorted by order):');
+ publicDocs.forEach(doc => {
+ console.log(` ${doc.order}. ${doc.title}`);
+ console.log(` Category: ${doc.category} | Audience: ${doc.audience}\n`);
+ });
+
+ const archivedCount = await collection.countDocuments({ visibility: 'archived' });
+ console.log(`\n📦 Archived: ${archivedCount} documents`);
+ console.log(`📖 Public: ${publicDocs.length} documents`);
+
+ } catch (error) {
+ console.error('\n✗ Error:', error.message);
+ console.error(error.stack);
+ process.exit(1);
+ } finally {
+ if (client) await client.close();
+ }
+}
+
+// Run if called directly
+if (require.main === module) {
+ main();
+}
+
+module.exports = { main };
diff --git a/src/controllers/documents.controller.js b/src/controllers/documents.controller.js
index caef98a1..6b4beaf2 100644
--- a/src/controllers/documents.controller.js
+++ b/src/controllers/documents.controller.js
@@ -280,11 +280,47 @@ async function deleteDocument(req, res) {
}
}
+/**
+ * List archived documents
+ * GET /api/documents/archived
+ */
+async function listArchivedDocuments(req, res) {
+ try {
+ const { limit = 50, skip = 0 } = req.query;
+
+ const documents = await Document.listArchived({
+ limit: parseInt(limit),
+ skip: parseInt(skip)
+ });
+
+ const total = await Document.count({ visibility: 'archived' });
+
+ res.json({
+ success: true,
+ documents,
+ pagination: {
+ total,
+ limit: parseInt(limit),
+ skip: parseInt(skip),
+ hasMore: parseInt(skip) + documents.length < total
+ }
+ });
+
+ } catch (error) {
+ logger.error('List archived documents error:', error);
+ res.status(500).json({
+ error: 'Internal Server Error',
+ message: 'An error occurred'
+ });
+ }
+}
+
module.exports = {
listDocuments,
getDocument,
searchDocuments,
createDocument,
updateDocument,
- deleteDocument
+ deleteDocument,
+ listArchivedDocuments
};
diff --git a/src/models/Document.model.js b/src/models/Document.model.js
index 4c808039..18a9d876 100644
--- a/src/models/Document.model.js
+++ b/src/models/Document.model.js
@@ -18,8 +18,11 @@ class Document {
slug: data.slug,
quadrant: data.quadrant, // STR/OPS/TAC/SYS/STO
persistence: data.persistence, // HIGH/MEDIUM/LOW/VARIABLE
- audience: data.audience || 'general', // technical, general, researcher, implementer, advocate
- visibility: data.visibility || 'public', // public, internal, confidential
+ audience: data.audience || 'general', // technical, general, researcher, implementer, advocate, business, developer
+ visibility: data.visibility || 'public', // public, internal, confidential, archived
+ category: data.category || 'none', // conceptual, practical, reference, archived, project-tracking, research-proposal, research-topic
+ order: data.order || 999, // Display order (1-999, lower = higher priority)
+ archiveNote: data.archiveNote || null, // Explanation for why document was archived
content_html: data.content_html,
content_markdown: data.content_markdown,
toc: data.toc || [],
@@ -161,7 +164,7 @@ class Document {
*/
static async list(options = {}) {
const collection = await getCollection('documents');
- const { limit = 50, skip = 0, sort = { 'metadata.date_created': -1 }, filter = {} } = options;
+ const { limit = 50, skip = 0, sort = { order: 1, 'metadata.date_created': -1 }, filter = {} } = options;
return await collection
.find(filter)
@@ -171,6 +174,21 @@ class Document {
.toArray();
}
+ /**
+ * List archived documents
+ */
+ static async listArchived(options = {}) {
+ const collection = await getCollection('documents');
+ const { limit = 50, skip = 0, sort = { 'metadata.date_created': -1 } } = options;
+
+ return await collection
+ .find({ visibility: 'archived' })
+ .sort(sort)
+ .skip(skip)
+ .limit(limit)
+ .toArray();
+ }
+
/**
* Count documents
*/
diff --git a/src/routes/documents.routes.js b/src/routes/documents.routes.js
index a73f4b95..a159da03 100644
--- a/src/routes/documents.routes.js
+++ b/src/routes/documents.routes.js
@@ -20,6 +20,11 @@ router.get('/search',
asyncHandler(documentsController.searchDocuments)
);
+// GET /api/documents/archived
+router.get('/archived',
+ asyncHandler(documentsController.listArchivedDocuments)
+);
+
// GET /api/documents
router.get('/', (req, res, next) => {
// Redirect browser requests to API documentation