Phase 1 foundation: Tauri shell, Python sidecar, SQLite database

Tauri v2 + Svelte + TypeScript frontend:
- App shell with workspace layout (waveform, transcript, speakers, AI chat)
- Placeholder components for all major UI areas
- Typed stores (project, transcript, playback, AI)
- TypeScript interfaces matching the database schema
- Tauri bridge service with typed invoke wrappers
- svelte-check passes with 0 errors

Rust backend:
- Tauri v2 app entry point with command registration
- SQLite database layer (rusqlite with bundled SQLite)
  - Full schema: projects, media_files, speakers, segments, words,
    ai_outputs, annotations (with indexes)
  - Model structs with serde serialization
  - CRUD queries for projects, speakers, segments, words
  - Segment text editing preserves original text
  - Schema versioning for future migrations
  - 6 tests passing
- Command stubs for project, transcribe, export, AI, settings, system
- App state management

Python sidecar:
- JSON-line IPC protocol (stdin/stdout)
- Message types: IPCMessage, progress, error, ready
- Handler registry with routing and error handling
- Ping/pong handler for connectivity testing
- Service stubs: transcribe, diarize, pipeline, AI, export
- Provider stubs: local (llama-server), OpenAI, Anthropic, LiteLLM
- Hardware detection stubs
- 14 tests passing, ruff clean

Also adds:
- Testing strategy document (docs/TESTING.md)
- Validation script (scripts/validate.sh)
- Updated .gitignore for Svelte, Rust, Python artifacts

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

python/voice_to_notes/main.py

@@ -0,0 +1,52 @@
+"""Main entry point for the Voice to Notes Python sidecar."""
+
+from __future__ import annotations
+
+import signal
+import sys
+
+from voice_to_notes.ipc.handlers import HandlerRegistry, ping_handler
+from voice_to_notes.ipc.messages import ready_message
+from voice_to_notes.ipc.protocol import read_message, write_message
+
+
+def create_registry() -> HandlerRegistry:
+    """Set up the message handler registry."""
+    registry = HandlerRegistry()
+    registry.register("ping", ping_handler)
+    # TODO: Register transcribe, diarize, pipeline, ai, export handlers
+    return registry
+
+
+def main() -> None:
+    """Main loop: read messages from stdin, dispatch to handlers, write responses to stdout."""
+
+    # Handle clean shutdown
+    def shutdown(signum: int, frame: object) -> None:
+        print("[sidecar] Shutting down...", file=sys.stderr, flush=True)
+        sys.exit(0)
+
+    signal.signal(signal.SIGTERM, shutdown)
+    signal.signal(signal.SIGINT, shutdown)
+
+    registry = create_registry()
+
+    # Signal to Rust that we're ready
+    write_message(ready_message())
+    print("[sidecar] Ready and waiting for messages", file=sys.stderr, flush=True)
+
+    # Message loop
+    while True:
+        msg = read_message()
+        if msg is None:
+            # EOF — parent closed stdin, time to exit
+            print("[sidecar] EOF on stdin, exiting", file=sys.stderr, flush=True)
+            break
+
+        response = registry.handle(msg)
+        if response is not None:
+            write_message(response)
+
+
+if __name__ == "__main__":
+    main()