feat: close all neurosymbolic feedback loops — PanLL is now a complete eNSAID

Add GovernanceEngine orchestrator (M1), OrbitalSync consumer (M2), Jaccard
divergence (M3/S3), Anti-Crash→Vexometer feedback (M4), Panel Bus dispatch (M5),
Tentacles OODA progression (S1), 7 Tauri event subscriptions (S2), ECHIDNA→OODA
feedback (S4), Hypatia confidence propagation (S5). Also adds MyLang, TypeLL,
and ProtocolSquisher panels with engines, models, and commands.

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

Author: hyperpolymath

.gitignore

@@ -51,6 +51,9 @@ npm-debug.log*
 runtime/.env
 runtime/.env.*
 
+# Hypatia scanning artifacts
+.hypatia/
+
 # IDE and OS files
 .idea/
 .vscode/

src-tauri/src/main.rs

@@ -1706,6 +1706,157 @@ mod echidna_tests {
     }
 }
 
+// ===========================================================================
+// Protocol-Squisher CLI Bridge
+// ===========================================================================
+
+const DEFAULT_PROTOCOL_SQUISHER_BIN: &str = "protocol-squisher";
+
+/// Resolve the protocol-squisher binary path from environment or default.
+fn protocol_squisher_bin() -> String {
+    std::env::var("PROTOCOL_SQUISHER_BIN")
+        .unwrap_or_else(|_| DEFAULT_PROTOCOL_SQUISHER_BIN.to_string())
+}
+
+/// Check whether the protocol-squisher CLI binary is available.
+#[tauri::command]
+fn protocol_squisher_check() -> Result<String, String> {
+    let output = std::process::Command::new(protocol_squisher_bin())
+        .arg("--version")
+        .output()
+        .map_err(|e| format!("CLI not found: {}", e))?;
+
+    if output.status.success() {
+        let version = String::from_utf8_lossy(&output.stdout).trim().to_string();
+        Ok(format!("{{\"available\":true,\"version\":\"{}\"}}", version))
+    } else {
+        Err("protocol-squisher CLI not available".to_string())
+    }
+}
+
+/// Analyse a schema file using `protocol-squisher analyze`.
+/// Returns JSON analysis result.
+#[tauri::command]
+fn protocol_squisher_analyze(file_path: String) -> Result<String, String> {
+    let output = std::process::Command::new(protocol_squisher_bin())
+        .args(["analyze", &file_path, "--format", "json"])
+        .output()
+        .map_err(|e| format!("Analysis failed: {}", e))?;
+
+    if output.status.success() {
+        Ok(String::from_utf8_lossy(&output.stdout).to_string())
+    } else {
+        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+        Err(format!("Analysis error: {}", stderr))
+    }
+}
+
+/// Compare two schema files using `protocol-squisher compare`.
+/// Returns JSON compatibility result.
+#[tauri::command]
+fn protocol_squisher_compare(left_path: String, right_path: String) -> Result<String, String> {
+    let output = std::process::Command::new(protocol_squisher_bin())
+        .args(["compare", &left_path, &right_path, "--format", "json"])
+        .output()
+        .map_err(|e| format!("Comparison failed: {}", e))?;
+
+    if output.status.success() {
+        Ok(String::from_utf8_lossy(&output.stdout).to_string())
+    } else {
+        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+        Err(format!("Comparison error: {}", stderr))
+    }
+}
+
+// ===========================================================================
+// My-Lang CLI Bridge
+// ===========================================================================
+
+const DEFAULT_MYLANG_BIN: &str = "my";
+
+/// Resolve the my-lang binary path from environment or default.
+fn mylang_bin() -> String {
+    std::env::var("MYLANG_BIN").unwrap_or_else(|_| DEFAULT_MYLANG_BIN.to_string())
+}
+
+/// Check whether the my-lang CLI binary is available.
+#[tauri::command]
+fn mylang_check() -> Result<String, String> {
+    let output = std::process::Command::new(mylang_bin())
+        .arg("--version")
+        .output()
+        .map_err(|e| format!("CLI not found: {}", e))?;
+
+    if output.status.success() {
+        let version = String::from_utf8_lossy(&output.stdout).trim().to_string();
+        Ok(format!("{{\"available\":true,\"version\":\"{}\"}}", version))
+    } else {
+        Err("my-lang CLI not available".to_string())
+    }
+}
+
+/// Compile source code in a given dialect.
+/// Writes source to a temp file, runs `my compile`, returns JSON result.
+#[tauri::command]
+fn mylang_compile(source: String, dialect: String) -> Result<String, String> {
+    use std::io::Write;
+
+    let ext = match dialect.to_lowercase().as_str() {
+        "solo" => "solo",
+        "duet" => "duet",
+        "ensemble" => "ens",
+        "me" => "me",
+        _ => "solo",
+    };
+
+    let tmp_dir = std::env::temp_dir().join("panll-mylang");
+    std::fs::create_dir_all(&tmp_dir)
+        .map_err(|e| format!("Failed to create temp dir: {}", e))?;
+
+    let tmp_file = tmp_dir.join(format!("input.{}", ext));
+    let mut f = std::fs::File::create(&tmp_file)
+        .map_err(|e| format!("Failed to create temp file: {}", e))?;
+    f.write_all(source.as_bytes())
+        .map_err(|e| format!("Failed to write source: {}", e))?;
+
+    let start = std::time::Instant::now();
+    let output = std::process::Command::new(mylang_bin())
+        .args(["compile", tmp_file.to_str().unwrap_or("input"), "--format", "json"])
+        .output()
+        .map_err(|e| format!("Compilation failed: {}", e))?;
+    let elapsed_ms = start.elapsed().as_millis();
+
+    let stdout = String::from_utf8_lossy(&output.stdout).to_string();
+    let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+
+    // Construct a JSON result
+    let success = output.status.success();
+    Ok(format!(
+        "{{\"success\":{},\"output\":{},\"diagnostics\":{},\"error_count\":0,\"warning_count\":0,\"compile_time_ms\":{}}}",
+        success,
+        serde_json::to_string(&stdout).unwrap_or_else(|_| "\"\"".to_string()),
+        serde_json::to_string(&stderr).unwrap_or_else(|_| "\"\"".to_string()),
+        elapsed_ms
+    ))
+}
+
+/// Evaluate a REPL input line.
+/// Runs `my repl --eval` with the given input and dialect.
+#[tauri::command]
+fn mylang_repl(input: String, dialect: String) -> Result<String, String> {
+    let output = std::process::Command::new(mylang_bin())
+        .args(["repl", "--eval", &input, "--dialect", &dialect.to_lowercase()])
+        .output()
+        .map_err(|e| format!("REPL eval failed: {}", e))?;
+
+    if output.status.success() {
+        Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
+    } else {
+        let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
+        Err(if stderr.is_empty() { "Evaluation error".to_string() } else { stderr })
+    }
+}
+
 fn main() {
     tauri::Builder::default()
         .plugin(tauri_plugin_shell::init())
@@ -1851,6 +2002,14 @@ fn main() {
             typell::commands::typell_compute,
             typell::commands::typell_list_signatures,
             typell::commands::typell_universes,
+            // Protocol-Squisher — 13-format schema analysis CLI bridge
+            protocol_squisher_check,
+            protocol_squisher_analyze,
+            protocol_squisher_compare,
+            // My-Lang — AI-native language CLI bridge
+            mylang_check,
+            mylang_compile,
+            mylang_repl,
         ])
         .setup(|_app| {
             Ok(())

src/Model.res

@@ -248,6 +248,9 @@ include CladeBrowserModel
 /// tentaclesState) for the 7-Tentacles compiler agent panel — seven colour-coded
 /// agents representing compiler subsystems with progressive cephalopod staging.
 include TentaclesModel
+include ProtocolSquisherModel
+include MyLangModel
+include TypeLLModel
 
 /// The complete Model — composes all domain slices into a single record.
 /// This is the "Gravitational Centre" of the Binary Star system.
@@ -404,6 +407,15 @@ type model = {
   // Tentacles — 7-Tentacles compiler agent panel (within/without ECHIDNA)
   tentacles: tentaclesState,
 
+  // Protocol-Squisher — 13-format schema analysis and compatibility
+  protocolSquisher: protocolSquisherState,
+
+  // My-Lang — AI-native language workbench (Solo/Duet/Ensemble/Me dialects)
+  myLang: myLangState,
+
+  // TypeLL — Verification kernel (cross-panel type intelligence)
+  typell: typellState,
+
   // ENSAID_CONFIG — cross-panel config generation state
   ensaidConfigPreview: option<string>,
   ensaidConfigError: option<string>,
@@ -670,6 +682,9 @@ let init = (): model => {
     clades: CladeBrowserEngine.builtinClades,
   },
   tentacles: TentaclesEngine.init(),
+  protocolSquisher: ProtocolSquisherEngine.defaultState,
+  myLang: MyLangEngine.defaultState,
+  typell: TypeLLEngine.defaultState,
   ensaidConfigPreview: None,
   ensaidConfigError: None,
   undoStack: [],

src/Msg.res

@@ -1562,6 +1562,93 @@ type keybindingsMsg =
   /// Reset all bindings to defaults.
   | ResetAllBindings
 
+/// Protocol-Squisher format analysis messages.
+type protocolSquisherMsg =
+  /// Set the active category tab.
+  | SetPsCategory(protocolSquisherCategory)
+  /// Check whether CLI binary is available.
+  | CheckPsCli
+  /// CLI check result.
+  | PsCliResult(result<string, string>)
+  /// Update the analyse file path input.
+  | SetAnalyseInput(string)
+  /// Run analysis on the current input path.
+  | RunAnalysis
+  /// Analysis result from Tauri backend.
+  | AnalysisResult(result<string, string>)
+  /// Update the left comparison input.
+  | SetCompareLeft(string)
+  /// Update the right comparison input.
+  | SetCompareRight(string)
+  /// Run comparison between left and right schemas.
+  | RunComparison
+  /// Comparison result from Tauri backend.
+  | ComparisonResult(result<string, string>)
+
+/// My-Lang AI-native language messages.
+type myLangMsg =
+  /// Set the active category tab.
+  | SetMlCategory(myLangCategory)
+  /// Switch the active dialect.
+  | SetDialect(myLangDialect)
+  /// Check whether CLI binary is available.
+  | CheckMlCli
+  /// CLI check result.
+  | MlCliResult(result<string, string>)
+  /// Update editor content.
+  | UpdateEditor(string)
+  /// Compile the current editor content.
+  | Compile
+  /// Compilation result from Tauri backend.
+  | CompileResult(result<string, string>)
+  /// Update REPL input.
+  | UpdateReplInput(string)
+  /// Evaluate the current REPL input.
+  | EvalRepl
+  /// REPL evaluation result from Tauri backend.
+  | ReplResult(result<string, string>)
+
+/// TypeLL verification kernel messages.
+type typellMsg =
+  /// Set the active category tab.
+  | SetTlCategory(typellCategory)
+  /// Set the view layer (progressive disclosure level).
+  | SetViewLayer(viewLayer)
+  /// Check TypeLL server health.
+  | CheckTlHealth
+  /// Health check result.
+  | TlHealthResult(result<string, string>)
+  /// Update checker input.
+  | UpdateCheckerInput(string)
+  /// Run type check on current input.
+  | RunCheck
+  /// Type check result.
+  | CheckResult(result<string, string>)
+  /// Run type inference on current input.
+  | RunInfer
+  /// Type inference result.
+  | InferResult(result<string, string>)
+  /// Load signatures from server.
+  | LoadSignatures
+  /// Signatures loaded.
+  | SignaturesLoaded(result<string, string>)
+  /// Load universe hierarchy.
+  | LoadUniverses
+  /// Universes loaded.
+  | UniversesLoaded(result<string, string>)
+  /// Set signature search filter.
+  | SetSignatureFilter(string)
+  /// Set tier filter.
+  | SetTierFilter(option<typeTier>)
+  /// Update refinement spec.
+  | UpdateRefinementSpec(string)
+  /// Update refinement constraints.
+  | UpdateRefinementConstraints(string)
+  /// Run refinement.
+  | RunRefine
+  /// Refinement result.
+  | RefineResult(result<string, string>)
+
 /// The unified message type
 type msg =
   | PaneL(paneLMsg)
@@ -1615,6 +1702,9 @@ type msg =
   | Boj(bojMsg) // Bundle of Joy cartridge server
   | CladeBrowser(cladeBrowserMsg) // Clade taxonomy browser
   | Tentacles(tentaclesMsg) // 7-Tentacles compiler agent orchestra
+  | ProtocolSquisher(protocolSquisherMsg) // Format analysis and compatibility
+  | MyLang(myLangMsg) // AI-native language workbench
+  | TypeLL(typellMsg) // Verification kernel (cross-panel type intelligence)
   | EnsaidConfig(ensaidConfigMsg) // Cross-panel ENSAID_CONFIG generation and I/O
   | Undo // Undo last significant action
   | Redo // Redo last undone action

src/SubscriptionsFixed.res

@@ -95,7 +95,73 @@ let inferenceSubscriptions = (model: model): Tea_Sub.t<msg> => {
   }
 }
 
+/// S2: Tauri backend event subscriptions — real-time neurosymbolic streaming.
+/// These fire when the Rust backend receives events from ECHIDNA, Tentacles,
+/// VeriSimDB, or Hypatia. Only active when the relevant panel is connected.
+let neurosymbolicSubscriptions = (_model: model): Tea_Sub.t<msg> => {
+  Tea_Sub.batch(list{
+    // ECHIDNA proof progress → feed into proof session state.
+    TauriEvents.onEchidnaProgress(payload =>
+      Echidna(ProofResult(Ok(payload)))
+    ),
+    // ECHIDNA tactic suggestions → populate suggestion ribbon.
+    TauriEvents.onEchidnaTactics(payload =>
+      Echidna(TacticSuggestionsLoaded(Ok(payload)))
+    ),
+    // Tentacles agent phase changes → advance OODA indicators.
+    // Payload expected as "agentId:phaseId" string from FFI.
+    TauriEvents.onTentaclesPhaseChange(payload => {
+      // Parse "0:2" as agent Red, phase Decide — graceful fallback.
+      let parts = String.split(payload, ":")
+      let agentIdx = parts[0]->Option.getOr("0")->Int.fromString->Option.getOr(0)
+      let agentId = switch agentIdx {
+      | 0 => TentaclesModel.Red
+      | 1 => TentaclesModel.Orange
+      | 2 => TentaclesModel.Yellow
+      | 3 => TentaclesModel.Green
+      | 4 => TentaclesModel.Blue
+      | 5 => TentaclesModel.Indigo
+      | _ => TentaclesModel.Violet
+      }
+      let phaseIdx = parts[1]->Option.getOr("0")->Int.fromString->Option.getOr(0)
+      let phase = switch phaseIdx {
+      | 0 => PaneModel.Observe
+      | 1 => PaneModel.Orient
+      | 2 => PaneModel.Decide
+      | _ => PaneModel.Act
+      }
+      Tentacles(AgentPhaseAdvanced(agentId, phase))
+    }),
+    // Tentacles agent broadcasts → deliver as reasoning share.
+    TauriEvents.onTentaclesBroadcast(payload =>
+      Tentacles(BroadcastFromAgent(Red, ReasoningShare({
+        agent: Red,
+        phase: Observe,
+        summary: payload,
+        detail: None,
+        timestamp: 0.0,
+      })))
+    ),
+    // VeriSimDB drift alerts → refresh drift display.
+    TauriEvents.onVeriSimDBDrift(payload =>
+      VeriSimDB(DriftLoaded(Ok(payload)))
+    ),
+    // Hypatia neural network status → refresh network grid.
+    TauriEvents.onHypatiaStatus(payload =>
+      Hypatia(ScansLoaded(Ok(payload)))
+    ),
+    // Governance signals → Anti-Crash intervention request.
+    TauriEvents.onGovernanceSignal(payload =>
+      AntiCrash(RequestOperatorIntervention(payload))
+    ),
+  })
+}
+
 /// Combined subscriptions.
 let all = (model: model): Tea_Sub.t<msg> => {
-  Tea_Sub.batch(list{subscriptions(model), inferenceSubscriptions(model)})
+  Tea_Sub.batch(list{
+    subscriptions(model),
+    inferenceSubscriptions(model),
+    neurosymbolicSubscriptions(model),
+  })
 }