feat(transcription): Phase A — engine protocol + registry + orchestrator (clean-room)

Introduces the architectural spine for the Wyrdnote engine layer per
the spec at outputs/wyrdnote/2026-05-10-engine-architecture-spec.md
in the CORBEL-Main workspace, Codex-reviewed 2026/05/10.

Clean-room derivative of VoiceInk's TranscriptionService /
TranscriptionServiceRegistry / TranscriptionPipeline shape. Built from
the architectural pattern only; no GPL-3.0 code, comments, or
identifiers lifted. Wyrdnote names, control flow, and trait signatures
are original.

What this lands:

crates/cloud-providers/src/provider.rs (new, 184 lines)
  TranscriptionProvider async trait. Object-safe via async_trait so
  Arc<dyn TranscriptionProvider> is the canonical shape. Lives in
  cloud-providers (not transcription) per D7 so an OEM licensee
  implementing the trait depends only on this crate plus magnotia-core
  (no transcription internals leaked through the trait surface).
  Surrounding types: ProviderId (lower-kebab-case), ProviderKind,
  NetworkRequirement, CostClass, ProviderCapabilities, EngineProfile,
  ProviderTranscript. Compile-time object-safety witness in tests.

crates/cloud-providers/Cargo.toml (modified)
  Adds async-trait + serde dependencies.

crates/cloud-providers/src/lib.rs (modified)
  Re-exports the provider surface.

crates/transcription/src/registry.rs (new, 183 lines)
  EngineRegistry: catalogue of providers keyed by ProviderId. Push-style
  registration, default-provider id captured at construction. Read-only
  after boot. Full unit-test coverage: empty default, register/get
  round-trip, default-resolves-after-registration, re-register replaces,
  ids enumeration.

crates/transcription/src/orchestrator.rs (new, 286 lines)
  LocalProviderAdapter wraps Arc<LocalEngine>, presents async
  TranscriptionProvider upward via tokio::task::spawn_blocking. Per D7
  the adapter lives in the orchestrator, NOT as impl TranscriptionProvider
  for LocalEngine — this keeps the dependency edge one-directional and
  avoids leaking async-runtime requirements onto the synchronous
  Transcriber trait.

  Orchestrator: single transcribe() entry point; resolves a provider
  from the registry, derives TranscriptionOptions from the EngineProfile,
  dispatches. Returns a clear error when an unregistered provider is
  named. Unit tests use a mock CannedProvider to validate dispatch,
  error handling, and option routing without booting a real model.

crates/transcription/Cargo.toml (modified)
  Depends on magnotia-cloud-providers + async-trait. Dev-dep tokio
  gains macros + rt-multi-thread features for #[tokio::test].

crates/transcription/src/lib.rs (modified)
  Exports Orchestrator, EngineRegistry, LocalProviderAdapter, and
  re-exports the provider trait surface so downstream crates depend
  only on magnotia-transcription for both local engines and the trait.

KNOWN-ISSUES.md (modified)
  Adds KI-06: existing dictation, live, and meeting commands still call
  LocalEngine::transcribe_sync directly via pick_engine. The orchestrator
  path is dormant until a Phase A.1 follow-up commit migrates the call
  sites. Cloud providers (Phase G) cannot be exercised end-to-end until
  the rewire lands. Phasing rationale: this commit lands the abstractions
  cleanly with full test coverage; the rewire is a separate diff so the
  chunking + post-processing logic in transcribe_file moves without
  inflating this commit beyond review fidelity.

Test results: 9 new tests pass (orchestrator: dispatches, errors-on-
unregistered, routes-initial-prompt, object-safe; registry: empty-default,
round-trip, default-resolves, re-register, ids-list). Pre-existing
59 transcription tests + 5 cloud-providers tests still green.
cargo check --workspace clean.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

crates/transcription/src/registry.rs

@@ -0,0 +1,183 @@
+//! `EngineRegistry` is the catalogue of available providers, built
+//! once at app boot and dependency-injected into the orchestrator.
+//!
+//! Registration is push-style: the boot code constructs each provider
+//! (a `LocalProviderAdapter` wrapping a `LocalEngine`, or a cloud
+//! provider implementing `TranscriptionProvider` directly) and calls
+//! `register`. The default provider is set at construction time and
+//! used when a profile does not specify one.
+//!
+//! The registry is read-only after boot; mutation requires a fresh
+//! registry instance. Providers are held behind `Arc<dyn
+//! TranscriptionProvider>` so the orchestrator can clone the handle
+//! cheaply across tokio tasks.
+
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use magnotia_cloud_providers::{ProviderId, TranscriptionProvider};
+
+/// Catalogue of providers known to the orchestrator.
+pub struct EngineRegistry {
+    providers: HashMap<ProviderId, Arc<dyn TranscriptionProvider>>,
+    default_provider: ProviderId,
+}
+
+impl EngineRegistry {
+    /// Construct an empty registry with the given default provider id.
+    /// The default need not exist at construction time; callers are
+    /// expected to register it before the registry is queried.
+    pub fn new(default_provider: ProviderId) -> Self {
+        Self {
+            providers: HashMap::new(),
+            default_provider,
+        }
+    }
+
+    /// Register a provider. If a provider with the same id is already
+    /// registered, it is replaced. The provider's id is read once via
+    /// `provider.provider_id()` and used as the registry key.
+    pub fn register(&mut self, provider: Arc<dyn TranscriptionProvider>) {
+        let id = provider.provider_id();
+        self.providers.insert(id, provider);
+    }
+
+    /// Fetch a provider by id. Returns `None` when the id is not in the
+    /// registry; the orchestrator surfaces this as a clear error so the
+    /// UI can prompt the user to pick a different engine.
+    pub fn get(&self, id: &ProviderId) -> Option<Arc<dyn TranscriptionProvider>> {
+        self.providers.get(id).cloned()
+    }
+
+    /// Fetch the default provider. Returns `None` if the default has
+    /// not been registered.
+    pub fn default(&self) -> Option<Arc<dyn TranscriptionProvider>> {
+        self.providers.get(&self.default_provider).cloned()
+    }
+
+    /// The id of the default provider. Always returns; the provider
+    /// itself may not be registered.
+    pub fn default_id(&self) -> &ProviderId {
+        &self.default_provider
+    }
+
+    /// All registered provider ids. The order is unspecified; the UI
+    /// is responsible for any sorting it wants to present.
+    pub fn ids(&self) -> Vec<ProviderId> {
+        self.providers.keys().cloned().collect()
+    }
+
+    /// Number of registered providers.
+    pub fn len(&self) -> usize {
+        self.providers.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.providers.is_empty()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use async_trait::async_trait;
+    use magnotia_cloud_providers::{
+        CostClass, EngineProfile, ProviderCapabilities, ProviderKind, ProviderTranscript,
+    };
+    use magnotia_core::error::Result;
+    use magnotia_core::types::{AudioSamples, Transcript, TranscriptionOptions};
+
+    struct DummyProvider {
+        id: ProviderId,
+    }
+
+    #[async_trait]
+    impl TranscriptionProvider for DummyProvider {
+        fn provider_id(&self) -> ProviderId {
+            self.id.clone()
+        }
+        fn kind(&self) -> ProviderKind {
+            ProviderKind::Local
+        }
+        fn capabilities(&self) -> ProviderCapabilities {
+            ProviderCapabilities {
+                sample_rate: 16_000,
+                channels: 1,
+                initial_prompt_supported: false,
+                language_hint_supported: true,
+                streaming_supported: false,
+                cost_class: CostClass::Free,
+            }
+        }
+        async fn prepare(&self, _profile: &EngineProfile) -> Result<()> {
+            Ok(())
+        }
+        async fn transcribe(
+            &self,
+            audio: AudioSamples,
+            _options: TranscriptionOptions,
+        ) -> Result<ProviderTranscript> {
+            Ok(ProviderTranscript {
+                transcript: Transcript::new(Vec::new(), "en".to_string(), audio.duration_secs()),
+                inference_ms: 0,
+            })
+        }
+    }
+
+    fn dummy(id: &str) -> Arc<dyn TranscriptionProvider> {
+        Arc::new(DummyProvider {
+            id: ProviderId::new(id),
+        })
+    }
+
+    #[test]
+    fn empty_registry_returns_none_for_default() {
+        let registry = EngineRegistry::new(ProviderId::new("local-whisper"));
+        assert!(registry.default().is_none());
+        assert_eq!(registry.default_id().as_str(), "local-whisper");
+        assert!(registry.is_empty());
+    }
+
+    #[test]
+    fn register_and_get_round_trip() {
+        let mut registry = EngineRegistry::new(ProviderId::new("local-whisper"));
+        registry.register(dummy("local-whisper"));
+        registry.register(dummy("local-parakeet"));
+
+        assert_eq!(registry.len(), 2);
+        assert!(registry.get(&ProviderId::new("local-whisper")).is_some());
+        assert!(registry.get(&ProviderId::new("local-parakeet")).is_some());
+        assert!(registry.get(&ProviderId::new("nonexistent")).is_none());
+    }
+
+    #[test]
+    fn default_resolves_after_registration() {
+        let mut registry = EngineRegistry::new(ProviderId::new("local-whisper"));
+        registry.register(dummy("local-whisper"));
+        let default = registry.default().expect("default provider registered");
+        assert_eq!(default.provider_id().as_str(), "local-whisper");
+    }
+
+    #[test]
+    fn re_register_replaces() {
+        let mut registry = EngineRegistry::new(ProviderId::new("local-whisper"));
+        registry.register(dummy("local-whisper"));
+        registry.register(dummy("local-whisper"));
+        assert_eq!(registry.len(), 1);
+    }
+
+    #[test]
+    fn ids_lists_all_registered() {
+        let mut registry = EngineRegistry::new(ProviderId::new("local-whisper"));
+        registry.register(dummy("local-whisper"));
+        registry.register(dummy("local-parakeet"));
+        let mut ids: Vec<String> = registry
+            .ids()
+            .into_iter()
+            .map(|id| id.as_str().to_string())
+            .collect();
+        ids.sort();
+        assert_eq!(ids, vec!["local-parakeet", "local-whisper"]);
+    }
+}