feat: retain Community SPI compatibility slice

Author: openai0229

.github/workflows/ci.yml

@@ -69,6 +69,8 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.2.2
+        with:
+          submodules: recursive
       - name: Install Linux keyring dependencies
         run: sudo apt-get update && sudo apt-get install -y libdbus-1-dev pkg-config
       - uses: dtolnay/rust-toolchain@4cda84d5c5c54efe2404f9d843567869ab1699d4
@@ -83,6 +85,10 @@ jobs:
           cache-dependency-path: |
             java/pom.xml
             java/compat-runtime/pom.xml
+            third_party/chat2db-community/chat2db-community-server/chat2db-community-bom/pom.xml
+            third_party/chat2db-community/chat2db-community-server/chat2db-community-spi/pom.xml
+            third_party/chat2db-community/chat2db-community-server/chat2db-community-plugins/chat2db-community-mysql/pom.xml
+            third_party/chat2db-community/chat2db-community-server/chat2db-community-plugins/chat2db-community-h2/pom.xml
       - name: Package Java engine
         working-directory: java
         run: ./mvnw -B -DskipTests package
@@ -96,6 +102,14 @@ jobs:
           CHAT2DB_JAVA_ENGINE_JAR: "${{ github.workspace }}/java/compat-runtime/target/chat2db-compat-runtime-0.1.0-SNAPSHOT.jar"
           CHAT2DB_H2_DRIVER_JAR: "${{ github.workspace }}/java/compat-runtime/target/test-drivers/h2-2.3.232.jar"
         run: cargo test -p chat2db-java-bridge --features java-integration --test java_jdbc_h2 --locked
+      - name: Verify fixed Community H2 classpath reproducibility
+        run: ./scripts/verify-community-h2-reproducibility.sh
+      - name: Verify real Community H2 SPI vertical slice
+        env:
+          CHAT2DB_JAVA_ENGINE_JAR: "${{ github.workspace }}/java/compat-runtime/target/chat2db-compat-runtime-0.1.0-SNAPSHOT.jar"
+          CHAT2DB_H2_DRIVER_JAR: "${{ github.workspace }}/java/compat-runtime/target/test-drivers/h2-2.3.232.jar"
+          CHAT2DB_COMMUNITY_CLASSPATH_DIR: "${{ github.workspace }}/target/community-h2-classpath"
+        run: cargo test -p chat2db-java-bridge --features java-integration --test java_community_h2 --locked
       - name: Verify product H2 vertical slice
         env:
           CHAT2DB_JAVA_ENGINE_JAR: "${{ github.workspace }}/java/compat-runtime/target/chat2db-compat-runtime-0.1.0-SNAPSHOT.jar"
@@ -179,6 +193,9 @@ jobs:
       - name: Test Windows Java bridge path contracts
         if: runner.os == 'Windows'
         run: cargo test -p chat2db-java-bridge --lib --locked
+      - name: Initialize fixed Community source on Windows
+        if: runner.os == 'Windows'
+        run: git submodule update --init --recursive third_party/chat2db-community
       - uses: actions/setup-java@c1e323688fd81a25caa38c78aa6df2d33d3e20d9 # v4.7.1
         if: runner.os == 'Windows'
         with:
@@ -188,6 +205,10 @@ jobs:
           cache-dependency-path: |
             java/pom.xml
             java/compat-runtime/pom.xml
+            third_party/chat2db-community/chat2db-community-server/chat2db-community-bom/pom.xml
+            third_party/chat2db-community/chat2db-community-server/chat2db-community-spi/pom.xml
+            third_party/chat2db-community/chat2db-community-server/chat2db-community-plugins/chat2db-community-mysql/pom.xml
+            third_party/chat2db-community/chat2db-community-server/chat2db-community-plugins/chat2db-community-h2/pom.xml
       - name: Package Java engine for Windows managed-driver test
         if: runner.os == 'Windows'
         working-directory: java
@@ -201,6 +222,20 @@ jobs:
         run: >-
           cargo test -p chat2db-core --features java-integration
           --test java_h2_product --locked
+      - name: Build fixed Community H2 compatibility classpath on Windows
+        if: runner.os == 'Windows'
+        shell: bash
+        run: ./scripts/build-community-h2-classpath.sh
+      - name: Verify Windows real Community H2 SPI vertical slice
+        if: runner.os == 'Windows'
+        shell: pwsh
+        env:
+          CHAT2DB_JAVA_ENGINE_JAR: "${{ github.workspace }}/java/compat-runtime/target/chat2db-compat-runtime-0.1.0-SNAPSHOT.jar"
+          CHAT2DB_H2_DRIVER_JAR: "${{ github.workspace }}/java/compat-runtime/target/test-drivers/h2-2.3.232.jar"
+          CHAT2DB_COMMUNITY_CLASSPATH_DIR: "${{ github.workspace }}/target/community-h2-classpath"
+        run: >-
+          cargo test -p chat2db-java-bridge --features java-integration
+          --test java_community_h2 --locked
       - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
         with:
           node-version: "22.22.2"

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "third_party/chat2db-community"]
+	path = third_party/chat2db-community
+	url = https://github.com/OtterMind/Chat2DB.git

Cargo.lock

@@ -1,12 +1,14 @@
 .PHONY: verify rust rust-process-tests java ipc-integration jdbc-h2-integration \
-	product-h2-integration frontend-deps frontend desktop generate-contracts \
-	check-contracts
+	community-h2-classpath community-h2-reproducibility community-h2-integration \
+	product-h2-integration \
+	frontend-deps frontend desktop generate-contracts check-contracts
 
 JAVA_ENGINE_JAR := $(CURDIR)/java/compat-runtime/target/chat2db-compat-runtime-0.1.0-SNAPSHOT.jar
 H2_DRIVER_JAR := $(CURDIR)/java/compat-runtime/target/test-drivers/h2-2.3.232.jar
+COMMUNITY_CLASSPATH_DIR := $(CURDIR)/target/community-h2-classpath
 
 verify: rust rust-process-tests java ipc-integration jdbc-h2-integration \
-	product-h2-integration frontend desktop
+	community-h2-integration product-h2-integration frontend desktop
 
 rust:
 	cargo fmt --all --check
@@ -25,6 +27,15 @@ ipc-integration: java
 jdbc-h2-integration: java
 	CHAT2DB_JAVA_ENGINE_JAR="$(JAVA_ENGINE_JAR)" CHAT2DB_H2_DRIVER_JAR="$(H2_DRIVER_JAR)" cargo test -p chat2db-java-bridge --features java-integration --test java_jdbc_h2 --locked
 
+community-h2-classpath:
+	./scripts/build-community-h2-classpath.sh
+
+community-h2-reproducibility:
+	./scripts/verify-community-h2-reproducibility.sh
+
+community-h2-integration: java community-h2-classpath
+	CHAT2DB_JAVA_ENGINE_JAR="$(JAVA_ENGINE_JAR)" CHAT2DB_H2_DRIVER_JAR="$(H2_DRIVER_JAR)" CHAT2DB_COMMUNITY_CLASSPATH_DIR="$(COMMUNITY_CLASSPATH_DIR)" cargo test -p chat2db-java-bridge --features java-integration --test java_community_h2 --locked
+
 product-h2-integration: java
 	CHAT2DB_JAVA_ENGINE_JAR="$(JAVA_ENGINE_JAR)" CHAT2DB_H2_DRIVER_JAR="$(H2_DRIVER_JAR)" cargo test -p chat2db-core --features java-integration --test java_h2_product --locked
 

Makefile

@@ -4,7 +4,8 @@ Private implementation of the Chat2DB Community hybrid runtime.
 
 ## Current state
 
-The repository has completed the first six buildable stages:
+The repository has completed Stages 1 through 6 and the first two independently
+buildable Stage 7 slices:
 
 - canonical Rust API contracts;
 - a transport-neutral Rust application service root;
@@ -50,16 +51,24 @@ The repository has completed the first six buildable stages:
   plus a JSON CLI for datasource discovery, forced-read-only query lifecycle,
   cancellation, and retained-result paging; and
 - an `rmcp` 2.2 stdio server with five bounded datasource/query tools backed by
-  that same running `Application`.
+  that same running `Application`;
+- strict local JDBC driver-pack discovery, hash verification, startup preload,
+  and immutable Core/Axum/Tauri inventory; and
+- a fixed Community 5.3.0 compatibility classpath that discovers real
+  `IPlugin` implementations and exposes H2 plugin catalog, schema metadata,
+  `CREATE SCHEMA` builder, and retained ANTLR parser operations over Protobuf,
+  with every one of its 148 JARs bound to the source commit by a checked-in
+  filename, byte-length, and SHA-256 lock.
 
 Stage 6 is complete. Web and desktop own the product runtime and publish its
 owner-only local endpoint; CLI and MCP attach to that host and never contact
 Java directly. The current MCP surface is deliberately read-only and does not
 accept JDBC bind parameters. A complete end-user Agent workspace and
-CLI-started headless host remain follow-on product work. The first Stage 7
-slice adds strict local driver-pack manifests, bounded hash verification,
-startup preload, and Core/Axum/Tauri inventory. Signing, downloading, updating,
-rollback, and the existing Chat2DB plugin/ANTLR estate remain Stage 7 work.
+CLI-started headless host remain follow-on product work. Stage 7A implements
+strict local driver packs. Stage 7B pins Community source, loads its runtime in
+an isolated Java classloader, and proves one real H2 SPI/ANTLR vertical slice.
+Signing, downloading, updating, rollback, product wiring for Community
+metadata, and full per-dialect compatibility remain Stage 7 work.
 
 ## Architecture
 
@@ -100,9 +109,25 @@ Java verification downloads H2 `2.3.232` into
 `java/compat-runtime/target/test-drivers/` as an external Stage 3 test fixture.
 H2 is not a runtime dependency of the compatibility engine, and the packaged
 JAR integration test rejects any build that embeds `org/h2/Driver.class`.
-The H2 gates cover both the Stage 3 bridge and the Stage 5 product path from a
-vault-backed datasource through Java streaming into retained-result paging and
-cancellation. H2 is a test fixture rather than a bundled product driver.
+The H2 gates cover the Stage 3 JDBC bridge, the Stage 5 product path from a
+vault-backed datasource through retained-result paging and cancellation, and
+the Stage 7B Community path through real `IPlugin`, `IDbMetaData`,
+`ISqlBuilder`, and ANTLR parser implementations. H2 remains an external test
+driver rather than a runtime dependency of either Java classpath.
+
+Build and run only the fixed Community H2 compatibility gate with:
+
+```bash
+make community-h2-integration
+```
+
+That target requires a clean submodule at the fixed commit, builds through the
+checked-in Maven Wrapper and a repository-local Maven cache, derives archive
+timestamps from the commit, excludes the H2 JDBC driver, and deterministically
+removes dependency-manifest `Class-Path` entries before rejecting any JAR set
+that differs from `third_party/community-h2-classpath.lock`. Run
+`make community-h2-reproducibility` to compare every artifact byte across two
+consecutive clean builds.
 
 Generate or verify the external contracts:
 

README.md

@@ -484,6 +484,7 @@ impl From<BridgeError> for AppError {
             | BridgeError::Spawn(_)
             | BridgeError::MissingPipe(_)
             | BridgeError::DriverArtifact { .. }
+            | BridgeError::CommunityArtifact { .. }
             | BridgeError::DriverSnapshotDirectory { .. }
             | BridgeError::NonUtf8DriverArtifact(_)
             | BridgeError::StaleHandle(_)
@@ -493,6 +494,8 @@ impl From<BridgeError> for AppError {
             | BridgeError::InvalidHandshake(_)
             | BridgeError::UnexpectedResponse(_)
             | BridgeError::SupervisorTask(_)
+            | BridgeError::ProcessCleanup { .. }
+            | BridgeError::CleanupAfterFailure { .. }
             | BridgeError::Frame(_) => Self::internal(),
         }
     }
@@ -504,6 +507,7 @@ mod tests {
         AgentError, ConfigError, ExecutionOutcome, ProviderError, ProviderKind, ToolExecutionError,
     };
     use chat2db_contract::ApiErrorDetails;
+    use chat2db_java_bridge::BridgeError;
     use chat2db_storage::StorageError;
 
     use super::{AppError, AppErrorKind};
@@ -570,6 +574,42 @@ mod tests {
         assert_no_sentinel(&mapped);
     }
 
+    #[test]
+    fn community_artifact_errors_are_internal_and_hide_local_paths() {
+        let mapped = AppError::from(BridgeError::CommunityArtifact {
+            operation: "snapshot",
+            path: SENTINEL.into(),
+            source: std::io::Error::other(SENTINEL),
+        });
+
+        assert_eq!(mapped.kind(), AppErrorKind::Internal);
+        assert_eq!(mapped.api_error().code, "internal_error");
+        assert_no_sentinel(&mapped);
+    }
+
+    #[test]
+    fn process_cleanup_errors_are_internal_and_hide_retained_snapshot_paths() {
+        let errors = [
+            BridgeError::ProcessCleanup {
+                retained_snapshot: SENTINEL.into(),
+                message: SENTINEL.to_owned(),
+            },
+            BridgeError::CleanupAfterFailure {
+                primary: Box::new(BridgeError::ShutdownTimeout),
+                cleanup: Box::new(BridgeError::ProcessCleanup {
+                    retained_snapshot: SENTINEL.into(),
+                    message: SENTINEL.to_owned(),
+                }),
+            },
+        ];
+        for error in errors {
+            let mapped = AppError::from(error);
+            assert_eq!(mapped.kind(), AppErrorKind::Internal);
+            assert_eq!(mapped.api_error().code, "internal_error");
+            assert_no_sentinel(&mapped);
+        }
+    }
+
     #[test]
     fn cancellations_are_non_retryable_conflicts() {
         for mapped in [

crates/chat2db-core/src/error.rs

@@ -6,15 +6,20 @@ fn main() -> Result<(), Box<dyn Error>> {
     let proto_directory = repository_root.join("proto");
     let compatibility_protocol = proto_directory.join("chat2db/compat/v1/compat.proto");
     let jdbc_protocol = proto_directory.join("chat2db/compat/v1/jdbc.proto");
+    let community_protocol = proto_directory.join("chat2db/compat/v1/community.proto");
 
     println!(
         "cargo:rerun-if-changed={}",
         compatibility_protocol.display()
     );
     println!("cargo:rerun-if-changed={}", jdbc_protocol.display());
+    println!("cargo:rerun-if-changed={}", community_protocol.display());
 
     let mut config = prost_build::Config::new();
     config.protoc_executable(protoc_bin_vendored::protoc_bin_path()?);
-    config.compile_protos(&[compatibility_protocol, jdbc_protocol], &[proto_directory])?;
+    config.compile_protos(
+        &[compatibility_protocol, jdbc_protocol, community_protocol],
+        &[proto_directory],
+    )?;
     Ok(())
 }

crates/chat2db-engine-protocol/build.rs

@@ -79,6 +79,29 @@ pub async fn read_frame_with_limit<R, M>(
 where
     R: AsyncRead + Unpin,
     M: Message + Default,
+{
+    let Some(payload) = read_frame_payload_with_limit(reader, local_maximum).await? else {
+        return Ok(None);
+    };
+    Ok(Some(M::decode(payload.as_slice())?))
+}
+
+/// Reads one frame and returns its undecoded Protobuf payload.
+///
+/// This is intended for callers that must inspect the original wire data
+/// before decoding can discard unknown or duplicate fields. The configured
+/// limit is always capped by [`MAX_FRAME_BYTES`].
+///
+/// # Errors
+///
+/// Returns [`FrameError`] when the pipe fails, the length violates either
+/// receive limit, or the frame is truncated.
+pub async fn read_frame_payload_with_limit<R>(
+    reader: &mut R,
+    local_maximum: usize,
+) -> Result<Option<Vec<u8>>, FrameError>
+where
+    R: AsyncRead + Unpin,
 {
     let mut header = [0_u8; 4];
     let bytes_read = reader.read(&mut header[..1]).await?;
@@ -92,7 +115,7 @@ where
 
     let mut payload = vec![0_u8; payload_length];
     reader.read_exact(&mut payload).await?;
-    Ok(Some(M::decode(payload.as_slice())?))
+    Ok(Some(payload))
 }
 
 /// Writes one four-byte big-endian length-prefixed Protobuf frame.
@@ -164,8 +187,8 @@ mod tests {
     use tokio::io::{AsyncWriteExt, duplex};
 
     use super::{
-        FrameError, MAX_FRAME_BYTES, current_version, read_frame, read_frame_with_limit, wire,
-        write_frame, write_frame_with_limit,
+        FrameError, MAX_FRAME_BYTES, current_version, read_frame, read_frame_payload_with_limit,
+        read_frame_with_limit, wire, write_frame, write_frame_with_limit,
     };
 
     #[tokio::test]
@@ -251,6 +274,40 @@ mod tests {
         ));
     }
 
+    #[tokio::test]
+    async fn raw_frame_reader_preserves_the_exact_protobuf_payload() {
+        let payload = wire::ClientEnvelope {
+            meta: Some(wire::RequestMeta {
+                request_id: "raw-frame".to_owned(),
+                trace_id: "raw-frame".to_owned(),
+                ..Default::default()
+            }),
+            payload: Some(wire::client_envelope::Payload::Ping(wire::Ping {
+                nonce: 9,
+            })),
+        }
+        .encode_to_vec();
+        let (mut writer, mut reader) = duplex(256);
+        writer
+            .write_all(
+                &u32::try_from(payload.len())
+                    .expect("test payload length must fit u32")
+                    .to_be_bytes(),
+            )
+            .await
+            .expect("header must write");
+        writer
+            .write_all(&payload)
+            .await
+            .expect("payload must write");
+
+        let raw = read_frame_payload_with_limit(&mut reader, MAX_FRAME_BYTES)
+            .await
+            .expect("raw frame must read")
+            .expect("raw frame must be present");
+        assert_eq!(raw, payload);
+    }
+
     #[tokio::test]
     async fn negotiated_peer_limit_is_enforced_before_writing() {
         let (mut writer, _reader) = duplex(256);

crates/chat2db-engine-protocol/src/lib.rs

@@ -12,6 +12,7 @@ publish = false
 [dependencies]
 chat2db-engine-protocol = { path = "../chat2db-engine-protocol" }
 prost.workspace = true
+rustix.workspace = true
 sha2 = "0.10"
 tempfile = "3"
 thiserror.workspace = true
@@ -37,6 +38,11 @@ name = "java_jdbc_h2"
 path = "tests/java_jdbc_h2.rs"
 required-features = ["java-integration"]
 
+[[test]]
+name = "java_community_h2"
+path = "tests/java_community_h2.rs"
+required-features = ["java-integration"]
+
 [features]
 default = []
 java-integration = []