deepstrike 0.2.63__tar.gz → 0.2.64__tar.gz

{deepstrike-0.2.63 → deepstrike-0.2.64}/Cargo.lock

@@ -254,7 +254,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-core"
-version = "0.2.63"
+version = "0.2.64"
 dependencies = [
  "compact_str",
  "deepstrike-tokenizer",
@@ -268,7 +268,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-node"
-version = "0.2.63"
+version = "0.2.64"
 dependencies = [
  "compact_str",
  "deepstrike-core",
@@ -280,7 +280,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-py"
-version = "0.2.63"
+version = "0.2.64"
 dependencies = [
  "compact_str",
  "deepstrike-core",
@@ -291,7 +291,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-sdk"
-version = "0.2.63"
+version = "0.2.64"
 dependencies = [
  "async-stream",
  "async-trait",
@@ -327,7 +327,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-tokenizer"
-version = "0.2.63"
+version = "0.2.64"
 dependencies = [
  "pretty_assertions",
  "tiktoken-rs",
@@ -335,7 +335,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-wasm"
-version = "0.2.63"
+version = "0.2.64"
 dependencies = [
  "compact_str",
  "deepstrike-core",

{deepstrike-0.2.63 → deepstrike-0.2.64}/Cargo.toml

@@ -3,13 +3,13 @@ resolver = "2"
 members = ["crates/deepstrike-core", "crates/deepstrike-tokenizer", "crates/deepstrike-py"]
 
 [workspace.package]
-version = "0.2.63"
+version = "0.2.64"
 edition = "2024"
 repository = "https://github.com/kongusen/deepstrike"
 
 [workspace.dependencies]
-deepstrike-core = { path = "crates/deepstrike-core", version = "0.2.63" }
-deepstrike-tokenizer = { path = "crates/deepstrike-tokenizer", version = "0.2.63" }
+deepstrike-core = { path = "crates/deepstrike-core", version = "0.2.64" }
+deepstrike-tokenizer = { path = "crates/deepstrike-tokenizer", version = "0.2.64" }
 notify = "6"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"

{deepstrike-0.2.63 → deepstrike-0.2.64}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepstrike
-Version: 0.2.63
+Version: 0.2.64
 Requires-Dist: httpx>=0.27
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: anyio>=4.0

{deepstrike-0.2.63 → deepstrike-0.2.64}/crates/deepstrike-core/src/bin/ds-chain-validator.rs

@@ -14,29 +14,41 @@
 //! - a file holding one JSON object: one record;
 //! - a file holding a JSON array: its elements, one record each;
 //! - anything else: JSON Lines — one record per non-empty line.
+//!
+//! SessionLog input forms (batch 3), per `--session-log` path:
+//! - a directory: every `*.json`/`*.jsonl` file inside (name-sorted), each file one session
+//!   stream — events keep the file's append order, and streams never cross-join;
+//! - a file: one stream — a JSON object (one event), a JSON array (one event per element), or
+//!   JSON Lines (one event per non-empty line).
 
 use std::path::{Path, PathBuf};
 use std::process::ExitCode;
 
-use deepstrike_core::runtime::chain_validator::{ValidationReport, Verdict, validate_journal};
+use deepstrike_core::runtime::chain_validator::{
+    ValidationReport, Verdict, validate_journal, validate_with_session_log,
+};
 
 const USAGE: &str = "Usage: ds-chain-validator --journal <path> [--journal <path>...] \
-                     [--format human|json]\n\
+                     [--session-log <path>...] [--format human|json]\n\
                      \n\
-                     Validates a kernel journal prefix against P2 §5 rules C1–C4 (batch 1), \
-                     marking degraded evidence per C7.\n\
+                     Validates a kernel journal prefix against P2 §5 rules C1–C4, marking\n\
+                     degraded evidence per C7. With --session-log, the batch-3 cross-checks\n\
+                     (C6/C8) join the SessionLog evidence plane against the journal.\n\
                      Exit codes: 0 = all green, 1 = violation proven, 2 = evidence insufficient.\n\
                      \n\
-                     --journal <path>   record source: directory of *.json records, a JSON\n\
-                     \x20                   object/array file, or a JSONL file (repeatable)\n\
-                     --format <mode>    human (default) or json\n\
+                     --journal <path>     record source: directory of *.json records, a JSON\n\
+                     \x20                    object/array file, or a JSONL file (repeatable)\n\
+                     --session-log <path> session-log source: a directory (each *.json/*.jsonl\n\
+                     \x20                    file is one append-ordered stream) or a single\n\
+                     \x20                    stream file — object/array/JSONL (repeatable)\n\
+                     --format <mode>      human (default) or json\n\
                      \n\
-                     Batch 1 does not consume checkpoint or SessionLog inputs; the C5\n\
-                     checkpoint self-consistency rule and the launch-token ledger arrive with\n\
-                     batch 2.";
+                     Batch 3 does not consume checkpoint inputs; the C5 checkpoint\n\
+                     self-consistency rule and the launch-token ledger arrive with batch 2.";
 
 fn main() -> ExitCode {
     let mut journals: Vec<PathBuf> = Vec::new();
+    let mut session_logs: Vec<PathBuf> = Vec::new();
     let mut format = "human".to_string();
     let mut args = std::env::args().skip(1);
     while let Some(arg) = args.next() {
@@ -47,6 +59,12 @@ fn main() -> ExitCode {
                 };
                 journals.push(PathBuf::from(path));
             }
+            "--session-log" => {
+                let Some(path) = args.next() else {
+                    return usage("--session-log requires a path");
+                };
+                session_logs.push(PathBuf::from(path));
+            }
             "--format" => {
                 let Some(mode) = args.next() else {
                     return usage("--format requires human or json");
@@ -56,10 +74,10 @@ fn main() -> ExitCode {
                 }
                 format = mode;
             }
-            "--checkpoint" | "--session-log" => {
-                return usage(&format!(
-                    "{arg} is consumed by batch-2 rules; batch-1 rules C1–C4+C7 do not read it"
-                ));
+            "--checkpoint" => {
+                return usage(
+                    "--checkpoint is consumed by batch-2 rules; batch-1/batch-3 rules do not read it",
+                );
             }
             "--help" | "-h" => {
                 println!("{USAGE}");
@@ -83,7 +101,27 @@ fn main() -> ExitCode {
         }
     }
 
-    let report = validate_journal(&blobs);
+    let mut streams: Vec<Vec<Vec<u8>>> = Vec::new();
+    for path in &session_logs {
+        let streams_before = streams.len();
+        match read_session_log(path, &mut streams) {
+            Ok(count) => eprintln!(
+                "read {count} session event(s) in {} stream(s) from {}",
+                streams.len() - streams_before,
+                path.display()
+            ),
+            Err(message) => {
+                eprintln!("ds-chain-validator: {message}");
+                return ExitCode::from(2);
+            }
+        }
+    }
+
+    let report = if session_logs.is_empty() {
+        validate_journal(&blobs)
+    } else {
+        validate_with_session_log(&blobs, &streams)
+    };
     match format.as_str() {
         "json" => match serde_json::to_string_pretty(&report) {
             Ok(json) => println!("{json}"),
@@ -130,14 +168,59 @@ fn read_journal(path: &Path, blobs: &mut Vec<Vec<u8>>) -> Result<usize, String>
     }
     let bytes =
         std::fs::read(path).map_err(|error| format!("cannot read {}: {error}", path.display()))?;
-    match serde_json::from_slice::<serde_json::Value>(&bytes) {
+    split_blob_file(&bytes, blobs);
+    Ok(blobs.len() - before)
+}
+
+/// Collect SessionLog event streams from one session-log source. Unlike the journal plane,
+/// append order within one file is meaningful, so **each file becomes one stream** — for a
+/// directory, every `*.json`/`*.jsonl` file inside (name-sorted); for a single path, the file
+/// itself. Event blobs within a stream preserve the file's order.
+fn read_session_log(path: &Path, streams: &mut Vec<Vec<Vec<u8>>>) -> Result<usize, String> {
+    let mut added = 0usize;
+    if path.is_dir() {
+        let mut entries: Vec<PathBuf> = std::fs::read_dir(path)
+            .map_err(|error| format!("cannot read directory {}: {error}", path.display()))?
+            .filter_map(|entry| entry.ok().map(|entry| entry.path()))
+            .filter(|entry| {
+                entry.extension().is_some_and(|extension| {
+                    extension == "json" || extension == "jsonl"
+                })
+            })
+            .collect();
+        entries.sort();
+        for entry in entries {
+            let bytes = std::fs::read(&entry)
+                .map_err(|error| format!("cannot read {}: {error}", entry.display()))?;
+            let mut stream = Vec::new();
+            split_blob_file(&bytes, &mut stream);
+            added += stream.len();
+            streams.push(stream);
+        }
+        return Ok(added);
+    }
+    let bytes =
+        std::fs::read(path).map_err(|error| format!("cannot read {}: {error}", path.display()))?;
+    let mut stream = Vec::new();
+    split_blob_file(&bytes, &mut stream);
+    added += stream.len();
+    streams.push(stream);
+    Ok(added)
+}
+
+/// Split one file's bytes into blobs: a JSON array yields one blob per element, a single JSON
+/// value yields one blob, anything else parses as JSON Lines. Array elements are re-emitted
+/// compactly — safe for journal records because the record's self-digest is computed from its
+/// decoded fields, not its input byte layout, and safe for SessionLog events because the
+/// session plane is opaque JSON throughout.
+fn split_blob_file(bytes: &[u8], blobs: &mut Vec<Vec<u8>>) {
+    match serde_json::from_slice::<serde_json::Value>(bytes) {
         Ok(serde_json::Value::Array(records)) => {
             for record in records {
                 blobs.push(serde_json::to_vec(&record).unwrap_or_default());
             }
         }
-        Ok(serde_json::Value::Object(_)) => blobs.push(bytes),
-        Ok(_) => blobs.push(bytes), // a scalar/array-of-scalars: the validator marks it unparseable
+        Ok(_) => blobs.push(bytes.to_vec()),
         Err(_) => {
             for line in bytes.split(|byte| *byte == b'\n') {
                 let line = trim_ascii(line);
@@ -147,7 +230,6 @@ fn read_journal(path: &Path, blobs: &mut Vec<Vec<u8>>) -> Result<usize, String>
             }
         }
     }
-    Ok(blobs.len() - before)
 }
 
 fn trim_ascii(bytes: &[u8]) -> &[u8] {
@@ -188,6 +270,23 @@ fn print_human(report: &ValidationReport) {
             report.unparseable_records
         );
     }
+    if let Some(events) = report.session_events {
+        println!("session-log plane: {events} parseable event(s)");
+    }
+    if report.unparseable_events > 0 {
+        println!(
+            "unparseable session event blob(s): {} (evidence insufficient, not a violation)",
+            report.unparseable_events
+        );
+    }
+    for rule in &report.cross_checks {
+        let label = match rule.verdict {
+            Verdict::Pass => "pass",
+            Verdict::Fail => "FAIL",
+            Verdict::Degraded => "degraded",
+        };
+        println!("cross-check {} {label}: {}", rule.rule, rule.detail);
+    }
     for deferred in &report.deferred {
         println!("deferred: {deferred}");
     }