feat(spaces): implement Phase 0-1 of Information Space Service

Phase 0 - Project Organization:
- Create docs/PROJECT_STRUCTURE.md documenting codebase layout
- Create markitect/core/ with parser, serializer, document_manager, workspace
- Create markitect/schema/ consolidating 6 schema_*.py modules
- Create markitect/storage/ with database module
- Maintain backward compatibility via re-exports from original locations
- Add docs/roadmap/information-space-service/ with README and WORKPLAN

Phase 1 - Foundation (Weeks 1-3):
- Week 1: Core domain models (InformationSpace, SpaceDocument, SpaceConfig,
  SpaceMetadata, SpaceVariable, TransclusionReference, SpaceStatus)
- Week 2: Repository layer with interfaces (ISpaceRepository,
  IDocumentAssociationRepository, IVariableRepository, IReferenceRepository)
  and SQLite implementations with foreign key cascade deletes
- Week 3: SpaceService orchestration layer with full CRUD, document,
  variable, and reference tracking operations

Test coverage: 124 tests (25 model + 63 repository + 36 integration)

Capabilities delivered:
- CAP-001: InformationSpace entity with lifecycle management
- CAP-002: SpaceRepository CRUD with SQLite backing
- CAP-003: Document-Space associations with path-based organization
- CAP-004: Space metadata and configuration schemas
- CAP-005: Database schema with migrations

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

markitect/document_manager.py

@@ -1,98 +1,11 @@
 """
-Document manager - Clean implementation.
+Document manager - Backward Compatibility Module.
 
-This module provides the DocumentManager class which is now a wrapper around
-the CleanDocumentManager for backward compatibility.
+This module re-exports from markitect.core.document_manager for backward compatibility.
+New code should import from markitect.core.document_manager directly.
 """
 
-from .clean_document_manager import CleanDocumentManager
+# Re-export from core for backward compatibility
+from markitect.core.document_manager import DocumentManager, CleanDocumentManager
 
-
-class DocumentManager(CleanDocumentManager):
-    """
-    Document manager for backward compatibility.
-
-    This class extends CleanDocumentManager to maintain compatibility
-    with existing code while using the clean implementation.
-    """
-
-    def __init__(self, db_manager=None):
-        super().__init__(db_manager)
-
-    def ingest_file(self, file_path: str):
-        """
-        Ingest a markdown file for processing.
-
-        This method provides compatibility for tests expecting the ingest_file interface.
-        """
-        import time
-        from pathlib import Path
-        from .parser import parse_markdown_to_ast
-        from .frontmatter import FrontMatterParser
-
-        file_path = Path(file_path)
-        if not file_path.exists():
-            raise FileNotFoundError(f"File not found: {file_path}")
-
-        # Read file content
-        content = file_path.read_text(encoding='utf-8')
-
-        # Extract front matter
-        start_time = time.time()
-        parser = FrontMatterParser()
-        front_matter_data, content_without_front_matter = parser.parse(content)
-
-        # Parse to AST
-        ast = parse_markdown_to_ast(content)
-        parse_time = time.time() - start_time
-
-        # Extract title - first try front matter, then first heading, then filename
-        title = "Unknown"
-        if front_matter_data and 'title' in front_matter_data:
-            title = front_matter_data['title']
-        elif isinstance(ast, list):
-            # Look for first H1 heading in AST tokens
-            for token in ast:
-                if token.get('type') == 'heading_open' and token.get('tag') == 'h1':
-                    # Find the next inline token with content
-                    idx = ast.index(token) + 1
-                    if idx < len(ast) and ast[idx].get('type') == 'inline':
-                        title = ast[idx].get('content', 'Unknown')
-                        break
-
-        # Create actual cache file for compatibility
-        cache_dir = Path(file_path.parent) / '.ast_cache'
-        cache_dir.mkdir(exist_ok=True)
-        cache_file = cache_dir / f"{file_path.stem}_ast.json"
-
-        # Write AST to cache file
-        import json
-        with open(cache_file, 'w', encoding='utf-8') as f:
-            json.dump(ast, f, indent=2)
-
-        # Store document in database if db_manager exists
-        if hasattr(self, 'db_manager') and self.db_manager:
-            try:
-                # Store using the clean document manager's method
-                self.store_document(str(file_path), content, ast, front_matter_data)
-            except Exception:
-                # If storage fails, continue without error for test compatibility
-                pass
-
-        return {
-            'ast': ast,
-            'content': content,
-            'metadata': {
-                'filename': file_path.name,
-                'title': title,
-                'size': len(content),
-                'path': str(file_path)
-            },
-            'ast_cache_path': cache_file,
-            'parse_time': parse_time,
-            'cache_time': 0  # Mock cache time for compatibility
-        }
-
-
-# For backward compatibility, also export the clean document manager directly
-__all__ = ['DocumentManager', 'CleanDocumentManager']
+__all__ = ['DocumentManager', 'CleanDocumentManager']