ciris-server 0.2.0__tar.gz → 0.2.2__tar.gz

{ciris_server-0.2.0 → ciris_server-0.2.2}/.github/workflows/publish-pypi.yml

@@ -115,13 +115,13 @@ jobs:
   android:
     name: wheel android-${{ matrix.abi }}
     runs-on: ubuntu-latest
-    continue-on-error: true
+    # Green as of 0.2.1 (arm64-v8a + armeabi-v7a both package). A required gate now.
     strategy:
       fail-fast: false
       matrix:
         include:
-          - { abi: armeabi-v7a, target: armv7-linux-androideabi, clang: armv7a-linux-androideabi24, pw: 32 }
-          - { abi: arm64-v8a,   target: aarch64-linux-android,   clang: aarch64-linux-android24,    pw: 64 }
+          - { abi: armeabi-v7a, target: armv7-linux-androideabi, clang: armv7a-linux-androideabi24, legacy: arm-linux-androideabi,  pw: 32 }
+          - { abi: arm64-v8a,   target: aarch64-linux-android,   clang: aarch64-linux-android24,    legacy: aarch64-linux-android, pw: 64 }
     steps:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@stable
@@ -155,8 +155,29 @@ jobs:
       - name: Build wheel (maturin, Android NDK)
         env:
           ANDROID_NDK_HOME: ${{ steps.ndk.outputs.ndk-path }}
-          RUSTFLAGS: "-L ${{ runner.temp }}/python-stub -C link-arg=-Wl,--no-as-needed -C link-arg=-lpython3.10"
+          ANDROID_API_LEVEL: "24" # maturin can't infer the API level for armv7 (it can for arm64)
         run: |
+          # cc-rs guesses the wrong NDK clang name (arm-linux-androideabi-clang);
+          # point CC/CXX/AR + the cargo linker at the real r26b tools (what
+          # cargo-ndk would set). Var names use the underscore/SCREAMING target.
+          TC="${ANDROID_NDK_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin"
+          CLANG="${TC}/${{ matrix.clang }}-clang"
+          TUS="$(echo '${{ matrix.target }}' | tr - _)"
+          TSC="$(echo "$TUS" | tr a-z A-Z)"
+          export "CC_${TUS}=${CLANG}"
+          export "CXX_${TUS}=${CLANG}++"
+          export "AR_${TUS}=${TC}/llvm-ar"
+          export "RANLIB_${TUS}=${TC}/llvm-ranlib"
+          export "CARGO_TARGET_${TSC}_LINKER=${CLANG}"
+          # openssl-src (pulled by persist on android) hardcodes the LEGACY NDK
+          # tool names that r26b dropped; shim them → the r26b llvm tools.
+          export ANDROID_NDK_ROOT="${ANDROID_NDK_HOME}"
+          ln -sf "${TC}/llvm-ar"     "${TC}/${{ matrix.legacy }}-ar"
+          ln -sf "${TC}/llvm-ranlib" "${TC}/${{ matrix.legacy }}-ranlib"
+          ln -sf "${CLANG}"          "${TC}/${{ matrix.legacy }}-clang"
+          ln -sf "${CLANG}++"        "${TC}/${{ matrix.legacy }}-clang++"
+          export PATH="${TC}:${PATH}"
+          export RUSTFLAGS="-L ${RUNNER_TEMP}/python-stub -C link-arg=-Wl,--no-as-needed -C link-arg=-lpython3.10"
           python -m pip install --upgrade pip
           pip install "maturin>=1.7,<2"
           maturin build --release --out dist --target ${{ matrix.target }}

{ciris_server-0.2.0 → ciris_server-0.2.2}/CHANGELOG.md

@@ -4,6 +4,34 @@ All notable changes to CIRISServer. Format follows [Keep a Changelog](https://ke
 this project uses [Semantic Versioning](https://semver.org/). The minor line tracks
 the fabric-node scope (0.1 lens · 0.5 +registry · 1.0 +node), paced by the CIRISAgent train.
 
+## [0.2.2] — 2026-06-15
+
+### Added
+- **`import-traces` on the wheel** (pip-only bridge): the abi3 wheel now exposes
+  `ciris_server.import_traces(dump_dir)`, and the `ciris-server` console script
+  accepts `ciris-server import-traces <dump-dir>` (same CLI as the binary). The
+  legacy CIRISLens dump → persist-corpus-as-CEG import no longer needs the
+  source-built binary. Verified from the installed wheel against the prod dump:
+  all 12,165 traces, errored=0.
+
+## [0.2.1] — 2026-06-15
+
+Android wheels (incl. arm32) now publish; legacy-trace importer.
+
+### Added
+- **`ciris-server import-traces <dump-dir>`** — imports the legacy CIRISLens
+  TimescaleDB dump into the persist corpus as CEG objects. Reconstructs flat
+  1.9.x lens rows → `CompleteTrace`/`BatchEnvelope` (reasoning columns →
+  components; original schema + signature in a provenance component); stamped
+  `2.7.legacy`; imported pre-verified; idempotent. A salvage pass repairs the
+  dump's systematic `\\"`→`\"` export mis-escaping and flags those rows
+  `_salvaged: true`. Validated on the prod dump: **all 12,165 traces →
+  20,959 trace-events, errored=0** (3,635 salvaged).
+- **Android wheels** (armeabi-v7a + arm64-v8a) now build & publish (NDK r26b
+  cross-compile: explicit `CC`/`AR`/linker for the toolchain, legacy-NDK
+  tool-name shims for openssl-src, `ANDROID_API_LEVEL`). Promoted from
+  continue-on-error to a required publish lane.
+
 ## [0.2.0] — 2026-06-15
 
 All-platforms-green CI, **full hybrid post-quantum federation signatures**, and a

{ciris_server-0.2.0 → ciris_server-0.2.2}/Cargo.lock

@@ -2,6 +2,12 @@
 # It is not intended for manual editing.
 version = 4
 
+[[package]]
+name = "adler2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
+
 [[package]]
 name = "aead"
 version = "0.5.2"
@@ -982,7 +988,7 @@ dependencies = [
 
 [[package]]
 name = "ciris-server"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "anyhow",
  "axum",
@@ -996,6 +1002,7 @@ dependencies = [
  "ciris-verify-core",
  "criterion",
  "ed25519-dalek",
+ "flate2",
  "fs2",
  "getrandom 0.3.4",
  "pyo3",
@@ -1196,6 +1203,15 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "crc32fast"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
+dependencies = [
+ "cfg-if",
+]
+
 [[package]]
 name = "criterion"
 version = "0.5.1"
@@ -1740,6 +1756,16 @@ version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
+[[package]]
+name = "flate2"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+]
+
 [[package]]
 name = "float_eq"
 version = "1.0.1"
@@ -3047,6 +3073,16 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
 
+[[package]]
+name = "miniz_oxide"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
+dependencies = [
+ "adler2",
+ "simd-adler32",
+]
+
 [[package]]
 name = "mio"
 version = "1.2.1"
@@ -5031,6 +5067,12 @@ dependencies = [
  "rand_core 0.10.1",
 ]
 
+[[package]]
+name = "simd-adler32"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "703d5c7ef118737c72f1af64ad2f6f8c5e1921f818cdcb97b8fe6fc69bf66214"
+
 [[package]]
 name = "siphasher"
 version = "1.0.3"

{ciris_server-0.2.0 → ciris_server-0.2.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ciris-server"
-version = "0.2.0"   # 0.1 = lens-only (agent ~2.9.7); 0.5 = +registry (~2.9.8); 1.0 = +node (~2.9.10). Patch forward (0.1.1) on breakage.
+version = "0.2.2"   # 0.1 = lens-only (agent ~2.9.7); 0.5 = +registry (~2.9.8); 1.0 = +node (~2.9.10). Patch forward (0.1.1) on breakage.
 edition = "2021"
 # MSRV floor is set by the substrate: ciris-verify v5.2.0 requires 1.86
 # (persist v6.0.1 is 1.83). Build with the higher of the two.
@@ -110,6 +110,7 @@ axum       = "0.8"
 base64     = "0.22"
 serde_json = "1"
 getrandom  = "0.3"   # mint the ML-DSA-65 federation seed on first boot (hybrid PQC)
+flate2     = "1"     # read the gz'd legacy-trace dump (import-traces subcommand)
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter", "json"] }
 

{ciris_server-0.2.0 → ciris_server-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ciris-server
-Version: 0.2.0
+Version: 0.2.2
 License-File: LICENSE
 Summary: The fabric node — the federation's headless cohabitation runtime (registry + lens [+ node] over one shared substrate), as the abi3 wheel CIRISAgent consumes. agent = fabric node + brain.
 Author-email: Eric Moore <eric@ciris.ai>

{ciris_server-0.2.0 → ciris_server-0.2.2}/pyproject.toml

@@ -12,7 +12,7 @@ build-backend = "maturin"
 [project]
 name = "ciris-server"
 # Mirrors Cargo.toml; bump in lockstep.
-version = "0.2.0"   # matches the Cargo crate. 0.1 = lens-only; patch forward (0.1.1) on breakage
+version = "0.2.2"   # matches the Cargo crate. 0.1 = lens-only; patch forward (0.1.1) on breakage
 description = "The fabric node — the federation's headless cohabitation runtime (registry + lens [+ node] over one shared substrate), as the abi3 wheel CIRISAgent consumes. agent = fabric node + brain."
 authors = [{ name = "Eric Moore", email = "eric@ciris.ai" }]
 license = { text = "AGPL-3.0-or-later" }

{ciris_server-0.2.0 → ciris_server-0.2.2}/src/compose.rs

@@ -250,7 +250,7 @@ fn federation_pqc_signer(cfg: &ServerConfig) -> Result<Arc<dyn PqcSigner>> {
 /// already-sealed seed is loaded, or a fresh one is generated + sealed
 /// (`get_platform_ed25519_signer`). Either way the seed is TPM/SE/StrongBox-sealed
 /// at rest with software-encrypted fallback; the pubkey stays 32-byte Ed25519.
-fn federation_signer(cfg: &ServerConfig) -> Result<Box<dyn HardwareSigner>> {
+pub(crate) fn federation_signer(cfg: &ServerConfig) -> Result<Box<dyn HardwareSigner>> {
     let seed_path = cfg.seed_path(); // identity_dir/ed25519.seed — the takeover source
     if seed_path.exists() {
         let bytes =

ciris_server-0.2.2/src/import.rs

@@ -0,0 +1,266 @@
+//! `ciris-server import-traces <dump-dir>` — import the legacy CIRISLens
+//! TimescaleDB trace dump into the persist-v7 corpus as **CEG objects**
+//! (`CompleteTrace` / `BatchEnvelope`), for posterity + to show the ragged edge.
+//!
+//! The dump's `accord_traces.jsonl.gz` is the **flat** lens row (schema 1.9.x,
+//! ~90 denormalized columns), NOT CEG wire. This maps each row → a
+//! `CompleteTrace`: the seven reasoning dict-columns become `TraceComponent`s
+//! (thought_start→Observation/ThoughtStart, dma_results→Rationale/DmaResults,
+//! conscience_result→Conscience/ConscienceResult, action_result→Action/
+//! ActionResult, …). The original `signature` + `signature_key_id` are preserved
+//! as provenance; the trace is imported **pre-verified** (the legacy signature
+//! signed the 1.9.x bytes, not the reconstructed trace, so it is not
+//! re-verifiable — `receive_and_persist_pre_verified`). Content-addressed dedup
+//! makes re-runs idempotent.
+//!
+//! Robust to the ragged edge: a streaming JSON-value reader (not line-split)
+//! recovers rows with embedded newlines, and persist's `#[serde(other)]`
+//! component fallbacks keep odd rows from hard-failing.
+
+use std::path::Path;
+use std::sync::Arc;
+
+use anyhow::{Context, Result};
+use ciris_persist::prelude::Engine;
+use ciris_persist::scrub::NullScrubber;
+use flate2::read::GzDecoder;
+use serde_json::{json, Map, Value};
+
+use crate::compose::federation_signer;
+use crate::config::ServerConfig;
+
+/// (flat column, component_type, event_type, timestamp column) — the mapping.
+const COMPONENTS: &[(&str, &str, &str, &str)] = &[
+    (
+        "thought_start",
+        "observation",
+        "thought_start",
+        "thought_start_at",
+    ),
+    (
+        "snapshot_and_context",
+        "context",
+        "snapshot_and_context",
+        "snapshot_at",
+    ),
+    ("dma_results", "rationale", "dma_results", "dma_results_at"),
+    ("idma_result", "rationale", "idma_result", "idma_at"),
+    ("aspdma_result", "rationale", "aspdma_result", "aspdma_at"),
+    (
+        "conscience_result",
+        "conscience",
+        "conscience_result",
+        "conscience_at",
+    ),
+    (
+        "action_result",
+        "action",
+        "action_result",
+        "action_result_at",
+    ),
+];
+
+/// Entry point for the `import-traces` subcommand.
+pub async fn run(dump_dir: &str) -> Result<()> {
+    let cfg = ServerConfig::from_env()?;
+    cfg.ensure_dirs()?;
+    let signer: Arc<dyn ciris_keyring::HardwareSigner> = Arc::from(federation_signer(&cfg)?);
+    let engine = Engine::with_hardware_signer(signer, &cfg.dsn())
+        .await
+        .context("open persist Engine for import")?;
+
+    let path = Path::new(dump_dir).join("accord_traces.jsonl.gz");
+    let path = if path.exists() {
+        path
+    } else {
+        Path::new(dump_dir).join("accord_traces.jsonl") // accept a pre-gunzipped dump too
+    };
+    tracing::info!(dump = %path.display(), dsn = %cfg.dsn(), "importing legacy traces as CEG objects");
+
+    let file = std::fs::File::open(&path).with_context(|| format!("open {}", path.display()))?;
+    let reader: Box<dyn std::io::Read> = if path.extension().is_some_and(|e| e == "gz") {
+        Box::new(GzDecoder::new(file))
+    } else {
+        Box::new(file)
+    };
+    // Tolerant JSONL reader: accumulate lines until a complete JSON value parses
+    // (recovers multi-line records — the ragged ~30%), and skip a genuinely
+    // corrupt record by resyncing at the next line (serde's streaming reader
+    // can't — it halts at the first bad value).
+    use std::io::BufRead;
+    let lines = std::io::BufReader::new(reader).lines();
+    let mut buf = String::new();
+
+    let (mut seen, mut inserted, mut conflicted, mut errored, mut unparsed, mut salvaged) =
+        (0u64, 0u64, 0u64, 0u64, 0u64, 0u64);
+    for line in lines {
+        let line = line.context("read dump line")?;
+        if buf.is_empty() {
+            buf.push_str(&line);
+        } else {
+            buf.push('\n');
+            buf.push_str(&line);
+        }
+        let mut was_salvaged = false;
+        let row: Value = match serde_json::from_str(&buf) {
+            Ok(v) => {
+                buf.clear();
+                v
+            }
+            Err(e) if e.is_eof() => continue, // incomplete multi-line record — keep accumulating
+            Err(_) => {
+                // Complete but malformed: the dump's systematic export bug —
+                // stringified-JSON fields escape inner quotes as `\\"` (escaped
+                // backslash + bare quote, which closes the string early) instead
+                // of `\"`. Salvage by un-doubling `\\"` → `\"` and retrying
+                // (a few passes for multi-level nesting).
+                let mut repaired = buf.clone();
+                buf.clear();
+                let mut got: Option<Value> = None;
+                for _ in 0..4 {
+                    let next = repaired.replace("\\\\\"", "\\\"");
+                    if next == repaired {
+                        break;
+                    }
+                    repaired = next;
+                    if let Ok(v) = serde_json::from_str::<Value>(&repaired) {
+                        got = Some(v);
+                        break;
+                    }
+                }
+                match got {
+                    Some(v) => {
+                        salvaged += 1;
+                        was_salvaged = true;
+                        v
+                    }
+                    None => {
+                        unparsed += 1;
+                        if unparsed <= 5 {
+                            tracing::warn!("skipping unparseable dump record (unrepairable)");
+                        }
+                        continue;
+                    }
+                }
+            }
+        };
+        seen += 1;
+        let bytes = match reconstruct_batch(&row, was_salvaged) {
+            Some(b) => b,
+            None => {
+                errored += 1;
+                continue;
+            }
+        };
+        match engine
+            .receive_and_persist_pre_verified(&bytes, &NullScrubber)
+            .await
+        {
+            Ok(s) => {
+                inserted += s.trace_events_inserted as u64;
+                conflicted += s.trace_events_conflicted as u64;
+            }
+            Err(e) => {
+                errored += 1;
+                if errored <= 10 {
+                    let tid = row.get("trace_id").and_then(Value::as_str).unwrap_or("?");
+                    tracing::warn!(trace_id = %tid, error = %e, "import: row rejected");
+                }
+            }
+        }
+        if seen % 1000 == 0 {
+            tracing::info!(seen, inserted, conflicted, errored, "import progress");
+        }
+    }
+    tracing::info!(
+        seen,
+        inserted,
+        conflicted,
+        errored,
+        unparsed,
+        salvaged,
+        "legacy trace import complete"
+    );
+    Ok(())
+}
+
+/// Reconstruct one flat 1.9.x lens row into a CEG `BatchEnvelope` JSON (bytes).
+/// Returns `None` if the row lacks the minimum identity fields.
+fn reconstruct_batch(row: &Value, salvaged: bool) -> Option<Vec<u8>> {
+    let s = |k: &str| row.get(k).and_then(Value::as_str);
+    let trace_id = s("trace_id")?;
+    let thought_id = s("thought_id")?;
+    let started_at = s("started_at")?;
+    let completed_at = s("completed_at").unwrap_or(started_at);
+    let level = s("trace_level").unwrap_or("generic");
+    // persist accepts a CLOSED schema set; "2.7.legacy" is its designated bucket
+    // for pre-2.7.8.9 traces. The original lens schema (e.g. 1.9.3) + signature
+    // are preserved in a provenance component below — the auditable ragged edge.
+    let orig_schema = s("schema_version").unwrap_or("(absent)");
+    let schema_version = "2.7.legacy";
+
+    let mut components = Vec::new();
+    for (col, ctype, etype, ts_col) in COMPONENTS {
+        if let Some(data) = row.get(*col).filter(|v| v.is_object()) {
+            let ts = s(ts_col).unwrap_or(started_at);
+            components.push(json!({
+                "component_type": ctype,
+                "event_type": etype,
+                "timestamp": ts,
+                "data": data,
+            }));
+        }
+    }
+    // Provenance component — the ragged edge, made auditable: original lens
+    // schema + the legacy signature that signed the 1.9.x bytes (not re-verifiable
+    // against this reconstruction). `unknown` event_type rides persist's
+    // serde(other) fallback.
+    components.push(json!({
+        "component_type": "observation",
+        "event_type": "unknown",
+        "timestamp": started_at,
+        "data": {
+            "_imported_from": "cirislens-timescaledb",
+            "legacy_schema_version": orig_schema,
+            "legacy_signature": s("signature").unwrap_or(""),
+            "legacy_signature_key_id": s("signature_key_id").unwrap_or(""),
+            // The raggedest edge: this record's JSON was repaired (the export's
+            // `\\"`→`\"` mis-escaping in stringified-JSON fields) before import.
+            "_salvaged": salvaged,
+        },
+    }));
+
+    let mut trace = Map::new();
+    trace.insert("trace_id".into(), json!(trace_id));
+    trace.insert("thought_id".into(), json!(thought_id));
+    if let Some(t) = s("task_id") {
+        trace.insert("task_id".into(), json!(t));
+    }
+    trace.insert(
+        "agent_id_hash".into(),
+        json!(s("agent_id_hash").unwrap_or("legacy")),
+    );
+    trace.insert("started_at".into(), json!(started_at));
+    trace.insert("completed_at".into(), json!(completed_at));
+    trace.insert("trace_level".into(), json!(level));
+    trace.insert("trace_schema_version".into(), json!(schema_version));
+    trace.insert("components".into(), json!(components));
+    trace.insert("cohort_scope".into(), json!("federation"));
+    // Provenance: the legacy signature signed the 1.9.x payload, not this
+    // reconstruction — preserved, not re-verified (imported pre-verified).
+    trace.insert("signature".into(), json!(s("signature").unwrap_or("")));
+    trace.insert(
+        "signature_key_id".into(),
+        json!(s("signature_key_id").unwrap_or("imported:legacy")),
+    );
+
+    let consent = s("consent_timestamp").unwrap_or(started_at);
+    let envelope = json!({
+        "events": [{ "event_type": "complete_trace", "trace_level": level, "trace": Value::Object(trace) }],
+        "batch_timestamp": started_at,
+        "consent_timestamp": consent,
+        "trace_level": level,
+        "trace_schema_version": schema_version,
+    });
+    Some(envelope.to_string().into_bytes())
+}

{ciris_server-0.2.0 → ciris_server-0.2.2}/src/lib.rs

@@ -26,6 +26,7 @@
 
 mod compose;
 mod config;
+mod import;
 /// The `ciris-canonical` founder-quorum (steward-key replacement) — shared with
 /// the registry slice at Server 0.5 (CIRISServer#1; FSD/REGISTRY_FOLD_DERISK.md).
 pub mod quorum;
@@ -46,6 +47,12 @@ pub async fn run() -> Result<()> {
     compose::serve(cfg).await
 }
 
+/// Import the legacy CIRISLens TimescaleDB trace dump into the persist corpus as
+/// CEG objects (the `import-traces <dump-dir>` subcommand). See `src/import.rs`.
+pub async fn import_traces(dump_dir: &str) -> Result<()> {
+    import::run(dump_dir).await
+}
+
 /// Initialize tracing (shared by the binary and the wheel entry point).
 pub fn init_tracing() {
     use tracing_subscriber::{fmt, prelude::*, EnvFilter};
@@ -61,25 +68,52 @@ pub fn init_tracing() {
 mod python {
     use pyo3::prelude::*;
 
+    fn rt_block_on<F: std::future::Future<Output = anyhow::Result<()>>>(fut: F) -> PyResult<()> {
+        // ONE multi-thread runtime; the node spawns onto it (never a second
+        // runtime around the Engine — the persist dual-runtime-deadlock rule).
+        let rt = tokio::runtime::Runtime::new()
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(e.to_string()))?;
+        rt.block_on(fut)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(e.to_string()))
+    }
+
     /// Console entry point: `pip install ciris-server` → the `ciris-server`
-    /// command (pyproject `[project.scripts]`). Boots a node with zero-setup
-    /// defaults — mode = server, trusting `ciris-canonical` — no wizard.
+    /// command (pyproject `[project.scripts]`). Mirrors the binary's CLI:
+    /// `ciris-server import-traces <dump-dir>` runs the legacy-trace import;
+    /// otherwise boots a zero-setup node (mode = server, trusts `ciris-canonical`).
     #[pyfunction]
     #[pyo3(name = "main")]
     fn py_main() -> PyResult<()> {
         crate::init_tracing();
-        // ONE multi-thread runtime; the lens node spawns onto it (never a second
-        // runtime around the Engine — the persist dual-runtime-deadlock rule).
-        let rt = tokio::runtime::Runtime::new()
-            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(e.to_string()))?;
-        rt.block_on(crate::run())
-            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(e.to_string()))
+        let mut args = std::env::args().skip(1);
+        match args.next().as_deref() {
+            Some("import-traces") => {
+                let dir = args.next().ok_or_else(|| {
+                    pyo3::exceptions::PyRuntimeError::new_err(
+                        "usage: ciris-server import-traces <dump-dir>",
+                    )
+                })?;
+                rt_block_on(crate::import_traces(&dir))
+            }
+            _ => rt_block_on(crate::run()),
+        }
+    }
+
+    /// `ciris_server.import_traces(dump_dir)` — programmatic legacy-trace import
+    /// for a pip-only bridge (the CIRISLens TimescaleDB dump → persist corpus as
+    /// CEG objects). Reads `CIRIS_HOME`/DSN from the environment, same as the node.
+    #[pyfunction]
+    #[pyo3(name = "import_traces")]
+    fn py_import_traces(dump_dir: String) -> PyResult<()> {
+        crate::init_tracing();
+        rt_block_on(crate::import_traces(&dump_dir))
     }
 
     /// `import ciris_server` — the composition CIRISAgent embeds.
     #[pymodule]
     fn ciris_server(_py: Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()> {
         m.add_function(wrap_pyfunction!(py_main, m)?)?;
+        m.add_function(wrap_pyfunction!(py_import_traces, m)?)?;
         // Re-export lens-core's Python surface so CIRISAgent can swap
         // `from ciris_lens_core import LensClient` → `from ciris_server import
         // LensClient` (drop-in). One wheel bundles the lens slice; registry +

ciris_server-0.2.2/src/main.rs

@@ -0,0 +1,26 @@
+//! CIRISServer binary — the headless fabric node entry point.
+//!
+//! Thin shell: all composition lives in the `ciris_server` library
+//! (src/lib.rs), which is ALSO built as a PyO3 abi3 wheel that CIRISAgent
+//! consumes. `agent = fabric node + brain` — one cohabitation composition, two
+//! shapes (MISSION.md §1.2/§6). See lib.rs and MISSION.md.
+
+use anyhow::Result;
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    ciris_server::init_tracing();
+    let mut args = std::env::args().skip(1);
+    match args.next().as_deref() {
+        // `ciris-server import-traces <dump-dir>` — one-shot legacy-trace import
+        // (CIRISLens TimescaleDB dump → persist corpus as CEG objects).
+        Some("import-traces") => {
+            let dump_dir = args
+                .next()
+                .ok_or_else(|| anyhow::anyhow!("usage: ciris-server import-traces <dump-dir>"))?;
+            ciris_server::import_traces(&dump_dir).await
+        }
+        // Default: boot the fabric node.
+        _ => ciris_server::run().await,
+    }
+}

ciris_server-0.2.0/src/main.rs

@@ -1,14 +0,0 @@
-//! CIRISServer binary — the headless fabric node entry point.
-//!
-//! Thin shell: all composition lives in the `ciris_server` library
-//! (src/lib.rs), which is ALSO built as a PyO3 abi3 wheel that CIRISAgent
-//! consumes. `agent = fabric node + brain` — one cohabitation composition, two
-//! shapes (MISSION.md §1.2/§6). See lib.rs and MISSION.md.
-
-use anyhow::Result;
-
-#[tokio::main]
-async fn main() -> Result<()> {
-    ciris_server::init_tracing();
-    ciris_server::run().await
-}