deepstrike 0.2.38__tar.gz → 0.2.40__tar.gz

{deepstrike-0.2.38 → deepstrike-0.2.40}/Cargo.lock

@@ -194,7 +194,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-core"
-version = "0.2.38"
+version = "0.2.40"
 dependencies = [
  "compact_str",
  "pretty_assertions",
@@ -204,9 +204,19 @@ dependencies = [
  "uuid",
 ]
 
+[[package]]
+name = "deepstrike-lab"
+version = "0.2.40"
+dependencies = [
+ "deepstrike-core",
+ "serde",
+ "serde_json",
+ "thiserror",
+]
+
 [[package]]
 name = "deepstrike-node"
-version = "0.2.38"
+version = "0.2.40"
 dependencies = [
  "compact_str",
  "deepstrike-core",
@@ -218,7 +228,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-py"
-version = "0.2.38"
+version = "0.2.40"
 dependencies = [
  "compact_str",
  "deepstrike-core",
@@ -229,7 +239,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-sdk"
-version = "0.2.38"
+version = "0.2.40"
 dependencies = [
  "async-stream",
  "async-trait",
@@ -263,7 +273,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-wasm"
-version = "0.2.38"
+version = "0.2.40"
 dependencies = [
  "compact_str",
  "deepstrike-core",

{deepstrike-0.2.38 → deepstrike-0.2.40}/Cargo.toml

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

{deepstrike-0.2.38 → deepstrike-0.2.40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepstrike
-Version: 0.2.38
+Version: 0.2.40
 Requires-Dist: httpx>=0.27
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: anyio>=4.0
@@ -152,7 +152,7 @@ Tool calls, spawns, compression, and signals pass through one kernel gate with a
 Oversized tool results (> 50 KB) stay in context as a preview plus a `.spool/` reference — the model reads the full payload on demand via ordinary file tools. When pressure triggers semantic eviction, the SDK summarizes archived content into `DreamStore`. Long tasks survive token pressure instead of failing mid-run.
 
 **Safety and governance by default (OS native profile)**  
-Every run loads declarative `governance_policy` (deny / ask_user / rate-limit / param rules) and in-kernel signal routing (`attention_policy`, default queue 64). Dangerous tools, external interrupts, and approval flows are policy — not ad-hoc checks in your handlers.
+Every run loads declarative `governance_policy` (deny / ask_user / rate-limit / param rules) and in-kernel signal routing (`signal_policy`, default queue 64). Dangerous tools, external interrupts, and approval flows are policy — not ad-hoc checks in your handlers.
 
 **Long-term memory as syscalls (Phase-7)**  
 `write_memory` and `query_memory` run outside the main tool loop: kernel validation before `DreamStore.commit`, search → `select_memories` → `memory_retrieval_result` on query. Failed writes emit `memory_validation_failed` for audit; good memory is durable without polluting history.
@@ -166,7 +166,7 @@ Spool, page-out, signals, processes, budgets, and memory events land in `Session
 | You need… | Use… |
 |---|---|
 | Policy before tools run | `governance_policy` (default: allow-all native profile) |
-| External interrupts | `signal_source` + in-kernel `attention_policy` |
+| External interrupts | `signal_source` + in-kernel `signal_policy` |
 | Spawn / memory-write quotas | `resource_quota` (`set_resource_quota`) |
 | Huge tool output | Automatic Layer-1 spool; optional custom `result_spool` |
 | Durable recall across runs | `DreamStore` + semantic `page_out` via `dream_summarizer` |
@@ -290,7 +290,7 @@ from deepstrike import (
     AgentIdentity,
     AgentRunSpec,
 )
-from deepstrike.runtime import DEFAULT_NATIVE_ATTENTION_POLICY
+from deepstrike.runtime import DEFAULT_NATIVE_SIGNAL_POLICY, PromptBudget
 from deepstrike.governance import GovernancePolicy, GovernancePolicyRule
 
 runner = RuntimeRunner(RuntimeOptions(
@@ -305,7 +305,12 @@ runner = RuntimeRunner(RuntimeOptions(
 
     # Agent OS native profile (defaults shown)
     governance_policy=DEFAULT_NATIVE_GOVERNANCE_POLICY,
-    attention_policy=DEFAULT_NATIVE_ATTENTION_POLICY,  # SignalRouter queue size 64
+    signal_policy=DEFAULT_NATIVE_SIGNAL_POLICY,  # SignalRouter queue size 64
+    prompt_budget=PromptBudget(
+        prompt_overhead_tokens=20,
+        output_reserve_tokens=4096,
+        safety_margin_tokens=256,
+    ),
 
     # Host I/O
     extensions={"temperature": 0.1},
@@ -340,7 +345,8 @@ runner = RuntimeRunner(RuntimeOptions(
 | Option | Purpose |
 |--------|---------|
 | `governance_policy` | Declarative deny / ask_user / rate-limit / param rules loaded into the kernel before `start_run` |
-| `attention_policy` | In-kernel signal router queue size (default 64) |
+| `signal_policy` | Versioned in-kernel signal queue/TTL policy (default queue 64) |
+| `prompt_budget` | Provider-envelope overhead, output reserve, and safety margin deducted from the context window |
 | `on_permission_request` | Resolves `tool_gated` + `suspended` → kernel `resume` with approved/denied call IDs |
 | `compression_store` | Writes archived messages on `compressed` observations |
 | `dream_summarizer` | Summarizes `page_out { tier_hint: "semantic" }` into `DreamStore` during a run |
@@ -352,7 +358,7 @@ Validate policies before starting a run:
 ```python
 result = validate_declarative_policy(
     gov_policy=DEFAULT_SANDBOX_POLICY,
-    attention_policy=DEFAULT_NATIVE_ATTENTION_POLICY,
+    signal_policy=DEFAULT_NATIVE_SIGNAL_POLICY,
 )
 assert result["valid"], result["errors"]
 ```
@@ -491,7 +497,7 @@ class MyStore(DreamStore):
     async def load_sessions(self, agent_id): ...
     async def load_memories(self, agent_id): ...
     async def commit(self, agent_id, result, existing): ...
-    async def search(self, agent_id, query, top_k): ...
+    async def search(self, agent_id, query): ...  # -> list[MemoryRecall]
     async def save_session(self, data): ...
 
 runner = RuntimeRunner(RuntimeOptions(
@@ -538,23 +544,27 @@ runner = RuntimeRunner(RuntimeOptions(
 ### Phase-7 memory syscalls (`write_memory` / `query_memory`)
 
 ```python
-await runner.write_memory({
-    "metadata": {
-        "name": "prefers-small-tests",
-        "description": "User prefers focused unit tests",
-        "kind": "feedback",
-        "created_at": 1,
-        "updated_at": 1,
-    },
-    "content": "User prefers focused unit tests for SDK behavior.",
-}, session_id="my-session")
-
-hits = await runner.query_memory({
-    "current_context": "Need testing preferences",
-    "active_tools": [],
-    "already_surfaced": [],
-    "top_k": 5,
-}, session_id="my-session")
+from deepstrike import MemoryProvenance, MemoryQuery, MemoryRecord, MemoryScope
+
+scope = MemoryScope(tenant_id="acme", namespace="assistant")
+await runner.write_memory(MemoryRecord(
+    record_id="prefers-small-tests-v1",
+    scope=scope,
+    name="prefers-small-tests",
+    kind="feedback",
+    content="User prefers focused unit tests for SDK behavior.",
+    description="Testing preference",
+    provenance=MemoryProvenance(author="host", trust="user_asserted"),
+    created_at=1,
+    updated_at=1,
+), session_id="my-session")
+
+hits = await runner.query_memory(MemoryQuery(
+    scope=scope,
+    query="Need testing preferences",
+    top_k=5,
+    kinds=["feedback"],
+), session_id="my-session")
 ```
 
 Session events: `memory_written`, `memory_queried`, `memory_validation_failed`, `memory_retrieval_result`.
@@ -633,7 +643,7 @@ Inbound signals are routed by the in-kernel attention policy (default queue size
 
 ```python
 from deepstrike import SignalGateway, ScheduledPrompt, RuntimeSignal
-from deepstrike.runtime import DEFAULT_NATIVE_ATTENTION_POLICY
+from deepstrike.runtime import DEFAULT_NATIVE_SIGNAL_POLICY
 
 gw = SignalGateway()
 gw.schedule(ScheduledPrompt(goal="standup", run_at_ms=target_time))
@@ -644,14 +654,14 @@ runner = RuntimeRunner(RuntimeOptions(
     session_log=InMemorySessionLog(),
     execution_plane=plane,
     signal_source=gw,
-    attention_policy=DEFAULT_NATIVE_ATTENTION_POLICY,
+    signal_policy=DEFAULT_NATIVE_SIGNAL_POLICY,
 ))
 
 runner.interrupt()  # cooperative abort → kernel timeout path
 gw.destroy()
 ```
 
-Each routed signal produces a `signal_disposed` session event (`category: "ipc"`).
+Each routed signal produces a correlated `signal_delivery_disposed` session event (`category: "ipc"`).
 
 ---
 
@@ -677,23 +687,21 @@ Requires an active parent run (`run()` / `wake()` in progress). The kernel emits
 
 ---
 
-## Harness (evaluation framework)
+## Attempt loop
 
 ```python
 from deepstrike import (
-    SinglePassHarness, EvalLoopHarness, HarnessLoop, HarnessRequest,
-    SubAgentHarnessConfig, QualityGate,
+    AttemptLoop, AttemptRequest, RuntimeAttemptBody, StopPolicy,
+    LlmEvalJudge, SubAgentHarnessConfig,
 )
 
-outcome = await SinglePassHarness(runner).run(HarnessRequest(goal="Say hello"))
-
-class ContainsHello(QualityGate):
-    async def evaluate(self, request, outcome) -> bool:
-        return "hello" in outcome.result.lower()
-
-outcome = await EvalLoopHarness(runner, gate=ContainsHello(), max_attempts=3).run(req)
-
-loop = HarnessLoop(runner, eval_provider=eval_provider, max_attempts=3, skill_dir="./skills")
+loop = AttemptLoop(
+    body=RuntimeAttemptBody(runner),
+    judge=LlmEvalJudge(eval_provider),
+    stop=StopPolicy(max_attempts=3),
+)
+outcome = await loop.run(AttemptRequest(goal="Write a haiku"))
+print(outcome.run_status, outcome.outcome, outcome.verdict)
 
 runner = RuntimeRunner(RuntimeOptions(
     provider=provider,
@@ -701,11 +709,14 @@ runner = RuntimeRunner(RuntimeOptions(
     execution_plane=plane,
     sub_agent_harness=SubAgentHarnessConfig(eval_provider=eval_provider, max_attempts=3),
 ))
-async for event in loop.run_streaming(HarnessRequest(goal="Write a haiku")):
-    if event.type == "done":
-        print(event.verdict.passed, event.verdict.feedback)
+async for event in loop.stream(AttemptRequest(goal="Write a haiku")):
+    if event.type == "completed":
+        print(event.outcome.run_status, event.outcome.verdict)
 ```
 
+The default carry policy keeps one session and injects judge feedback as context. Use
+`fresh_with_feedback` or `fresh_with_digest(...)` only when attempt isolation is intentional.
+
 ---
 
 ## Stream events

{deepstrike-0.2.38 → deepstrike-0.2.40}/README.md

@@ -139,7 +139,7 @@ Tool calls, spawns, compression, and signals pass through one kernel gate with a
 Oversized tool results (> 50 KB) stay in context as a preview plus a `.spool/` reference — the model reads the full payload on demand via ordinary file tools. When pressure triggers semantic eviction, the SDK summarizes archived content into `DreamStore`. Long tasks survive token pressure instead of failing mid-run.
 
 **Safety and governance by default (OS native profile)**  
-Every run loads declarative `governance_policy` (deny / ask_user / rate-limit / param rules) and in-kernel signal routing (`attention_policy`, default queue 64). Dangerous tools, external interrupts, and approval flows are policy — not ad-hoc checks in your handlers.
+Every run loads declarative `governance_policy` (deny / ask_user / rate-limit / param rules) and in-kernel signal routing (`signal_policy`, default queue 64). Dangerous tools, external interrupts, and approval flows are policy — not ad-hoc checks in your handlers.
 
 **Long-term memory as syscalls (Phase-7)**  
 `write_memory` and `query_memory` run outside the main tool loop: kernel validation before `DreamStore.commit`, search → `select_memories` → `memory_retrieval_result` on query. Failed writes emit `memory_validation_failed` for audit; good memory is durable without polluting history.
@@ -153,7 +153,7 @@ Spool, page-out, signals, processes, budgets, and memory events land in `Session
 | You need… | Use… |
 |---|---|
 | Policy before tools run | `governance_policy` (default: allow-all native profile) |
-| External interrupts | `signal_source` + in-kernel `attention_policy` |
+| External interrupts | `signal_source` + in-kernel `signal_policy` |
 | Spawn / memory-write quotas | `resource_quota` (`set_resource_quota`) |
 | Huge tool output | Automatic Layer-1 spool; optional custom `result_spool` |
 | Durable recall across runs | `DreamStore` + semantic `page_out` via `dream_summarizer` |
@@ -277,7 +277,7 @@ from deepstrike import (
     AgentIdentity,
     AgentRunSpec,
 )
-from deepstrike.runtime import DEFAULT_NATIVE_ATTENTION_POLICY
+from deepstrike.runtime import DEFAULT_NATIVE_SIGNAL_POLICY, PromptBudget
 from deepstrike.governance import GovernancePolicy, GovernancePolicyRule
 
 runner = RuntimeRunner(RuntimeOptions(
@@ -292,7 +292,12 @@ runner = RuntimeRunner(RuntimeOptions(
 
     # Agent OS native profile (defaults shown)
     governance_policy=DEFAULT_NATIVE_GOVERNANCE_POLICY,
-    attention_policy=DEFAULT_NATIVE_ATTENTION_POLICY,  # SignalRouter queue size 64
+    signal_policy=DEFAULT_NATIVE_SIGNAL_POLICY,  # SignalRouter queue size 64
+    prompt_budget=PromptBudget(
+        prompt_overhead_tokens=20,
+        output_reserve_tokens=4096,
+        safety_margin_tokens=256,
+    ),
 
     # Host I/O
     extensions={"temperature": 0.1},
@@ -327,7 +332,8 @@ runner = RuntimeRunner(RuntimeOptions(
 | Option | Purpose |
 |--------|---------|
 | `governance_policy` | Declarative deny / ask_user / rate-limit / param rules loaded into the kernel before `start_run` |
-| `attention_policy` | In-kernel signal router queue size (default 64) |
+| `signal_policy` | Versioned in-kernel signal queue/TTL policy (default queue 64) |
+| `prompt_budget` | Provider-envelope overhead, output reserve, and safety margin deducted from the context window |
 | `on_permission_request` | Resolves `tool_gated` + `suspended` → kernel `resume` with approved/denied call IDs |
 | `compression_store` | Writes archived messages on `compressed` observations |
 | `dream_summarizer` | Summarizes `page_out { tier_hint: "semantic" }` into `DreamStore` during a run |
@@ -339,7 +345,7 @@ Validate policies before starting a run:
 ```python
 result = validate_declarative_policy(
     gov_policy=DEFAULT_SANDBOX_POLICY,
-    attention_policy=DEFAULT_NATIVE_ATTENTION_POLICY,
+    signal_policy=DEFAULT_NATIVE_SIGNAL_POLICY,
 )
 assert result["valid"], result["errors"]
 ```
@@ -478,7 +484,7 @@ class MyStore(DreamStore):
     async def load_sessions(self, agent_id): ...
     async def load_memories(self, agent_id): ...
     async def commit(self, agent_id, result, existing): ...
-    async def search(self, agent_id, query, top_k): ...
+    async def search(self, agent_id, query): ...  # -> list[MemoryRecall]
     async def save_session(self, data): ...
 
 runner = RuntimeRunner(RuntimeOptions(
@@ -525,23 +531,27 @@ runner = RuntimeRunner(RuntimeOptions(
 ### Phase-7 memory syscalls (`write_memory` / `query_memory`)
 
 ```python
-await runner.write_memory({
-    "metadata": {
-        "name": "prefers-small-tests",
-        "description": "User prefers focused unit tests",
-        "kind": "feedback",
-        "created_at": 1,
-        "updated_at": 1,
-    },
-    "content": "User prefers focused unit tests for SDK behavior.",
-}, session_id="my-session")
-
-hits = await runner.query_memory({
-    "current_context": "Need testing preferences",
-    "active_tools": [],
-    "already_surfaced": [],
-    "top_k": 5,
-}, session_id="my-session")
+from deepstrike import MemoryProvenance, MemoryQuery, MemoryRecord, MemoryScope
+
+scope = MemoryScope(tenant_id="acme", namespace="assistant")
+await runner.write_memory(MemoryRecord(
+    record_id="prefers-small-tests-v1",
+    scope=scope,
+    name="prefers-small-tests",
+    kind="feedback",
+    content="User prefers focused unit tests for SDK behavior.",
+    description="Testing preference",
+    provenance=MemoryProvenance(author="host", trust="user_asserted"),
+    created_at=1,
+    updated_at=1,
+), session_id="my-session")
+
+hits = await runner.query_memory(MemoryQuery(
+    scope=scope,
+    query="Need testing preferences",
+    top_k=5,
+    kinds=["feedback"],
+), session_id="my-session")
 ```
 
 Session events: `memory_written`, `memory_queried`, `memory_validation_failed`, `memory_retrieval_result`.
@@ -620,7 +630,7 @@ Inbound signals are routed by the in-kernel attention policy (default queue size
 
 ```python
 from deepstrike import SignalGateway, ScheduledPrompt, RuntimeSignal
-from deepstrike.runtime import DEFAULT_NATIVE_ATTENTION_POLICY
+from deepstrike.runtime import DEFAULT_NATIVE_SIGNAL_POLICY
 
 gw = SignalGateway()
 gw.schedule(ScheduledPrompt(goal="standup", run_at_ms=target_time))
@@ -631,14 +641,14 @@ runner = RuntimeRunner(RuntimeOptions(
     session_log=InMemorySessionLog(),
     execution_plane=plane,
     signal_source=gw,
-    attention_policy=DEFAULT_NATIVE_ATTENTION_POLICY,
+    signal_policy=DEFAULT_NATIVE_SIGNAL_POLICY,
 ))
 
 runner.interrupt()  # cooperative abort → kernel timeout path
 gw.destroy()
 ```
 
-Each routed signal produces a `signal_disposed` session event (`category: "ipc"`).
+Each routed signal produces a correlated `signal_delivery_disposed` session event (`category: "ipc"`).
 
 ---
 
@@ -664,23 +674,21 @@ Requires an active parent run (`run()` / `wake()` in progress). The kernel emits
 
 ---
 
-## Harness (evaluation framework)
+## Attempt loop
 
 ```python
 from deepstrike import (
-    SinglePassHarness, EvalLoopHarness, HarnessLoop, HarnessRequest,
-    SubAgentHarnessConfig, QualityGate,
+    AttemptLoop, AttemptRequest, RuntimeAttemptBody, StopPolicy,
+    LlmEvalJudge, SubAgentHarnessConfig,
 )
 
-outcome = await SinglePassHarness(runner).run(HarnessRequest(goal="Say hello"))
-
-class ContainsHello(QualityGate):
-    async def evaluate(self, request, outcome) -> bool:
-        return "hello" in outcome.result.lower()
-
-outcome = await EvalLoopHarness(runner, gate=ContainsHello(), max_attempts=3).run(req)
-
-loop = HarnessLoop(runner, eval_provider=eval_provider, max_attempts=3, skill_dir="./skills")
+loop = AttemptLoop(
+    body=RuntimeAttemptBody(runner),
+    judge=LlmEvalJudge(eval_provider),
+    stop=StopPolicy(max_attempts=3),
+)
+outcome = await loop.run(AttemptRequest(goal="Write a haiku"))
+print(outcome.run_status, outcome.outcome, outcome.verdict)
 
 runner = RuntimeRunner(RuntimeOptions(
     provider=provider,
@@ -688,11 +696,14 @@ runner = RuntimeRunner(RuntimeOptions(
     execution_plane=plane,
     sub_agent_harness=SubAgentHarnessConfig(eval_provider=eval_provider, max_attempts=3),
 ))
-async for event in loop.run_streaming(HarnessRequest(goal="Write a haiku")):
-    if event.type == "done":
-        print(event.verdict.passed, event.verdict.feedback)
+async for event in loop.stream(AttemptRequest(goal="Write a haiku")):
+    if event.type == "completed":
+        print(event.outcome.run_status, event.outcome.verdict)
 ```
 
+The default carry policy keeps one session and injects judge feedback as context. Use
+`fresh_with_feedback` or `fresh_with_digest(...)` only when attempt isolation is intentional.
+
 ---
 
 ## Stream events

{deepstrike-0.2.38 → deepstrike-0.2.40}/crates/deepstrike-core/Cargo.toml

@@ -14,3 +14,7 @@ uuid = { workspace = true }
 
 [dev-dependencies]
 pretty_assertions = "1"
+
+[[bench]]
+name = "kernel_baseline"
+harness = false

deepstrike-0.2.40/crates/deepstrike-core/benches/kernel_baseline.rs

@@ -0,0 +1,202 @@
+use std::alloc::{GlobalAlloc, Layout, System};
+use std::hint::black_box;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::Instant;
+
+use deepstrike_core::orchestration::workflow::{WorkflowNode, WorkflowSpec};
+use deepstrike_core::runtime::kernel::{KernelReliabilityConfig, RunConfig};
+use deepstrike_core::runtime::{KernelInput, KernelInputEvent, KernelRuntime};
+use deepstrike_core::scheduler::policy::SchedulerBudget;
+use deepstrike_core::types::agent::AgentRole;
+use deepstrike_core::types::message::Message;
+use deepstrike_core::types::signal::{RuntimeSignal, SignalSource, SignalType, Urgency};
+use deepstrike_core::types::task::RuntimeTask;
+
+struct CountingAllocator;
+
+static ALLOCATION_COUNT: AtomicU64 = AtomicU64::new(0);
+static ALLOCATED_BYTES: AtomicU64 = AtomicU64::new(0);
+
+unsafe impl GlobalAlloc for CountingAllocator {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        let pointer = unsafe { System.alloc(layout) };
+        if !pointer.is_null() {
+            ALLOCATION_COUNT.fetch_add(1, Ordering::Relaxed);
+            ALLOCATED_BYTES.fetch_add(layout.size() as u64, Ordering::Relaxed);
+        }
+        pointer
+    }
+
+    unsafe fn dealloc(&self, pointer: *mut u8, layout: Layout) {
+        unsafe { System.dealloc(pointer, layout) };
+    }
+
+    unsafe fn realloc(&self, pointer: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+        let replacement = unsafe { System.realloc(pointer, layout, new_size) };
+        if !replacement.is_null() {
+            ALLOCATION_COUNT.fetch_add(1, Ordering::Relaxed);
+            ALLOCATED_BYTES.fetch_add(new_size as u64, Ordering::Relaxed);
+        }
+        replacement
+    }
+}
+
+#[global_allocator]
+static GLOBAL_ALLOCATOR: CountingAllocator = CountingAllocator;
+
+fn begin_measurement() -> Instant {
+    ALLOCATION_COUNT.store(0, Ordering::Relaxed);
+    ALLOCATED_BYTES.store(0, Ordering::Relaxed);
+    Instant::now()
+}
+
+fn elapsed_ms(label: &str, started: Instant, operations: usize) {
+    let elapsed = started.elapsed();
+    let allocations = ALLOCATION_COUNT.load(Ordering::Relaxed);
+    let allocated_bytes = ALLOCATED_BYTES.load(Ordering::Relaxed);
+    println!(
+        "{label}: {:.3} ms total, {:.3} us/op ({operations} ops), {allocations} allocations / {allocated_bytes} bytes",
+        elapsed.as_secs_f64() * 1_000.0,
+        elapsed.as_secs_f64() * 1_000_000.0 / operations.max(1) as f64,
+    );
+}
+
+fn input(operation: &str, index: usize, event: KernelInputEvent) -> KernelInput {
+    KernelInput::correlated(
+        operation,
+        format!("{operation}-event-{index}"),
+        index as u64,
+        event,
+    )
+}
+
+fn main() {
+    let f1 = deepstrike_core::benchmark::f1_critical_path_skew();
+    assert!(f1.policy_makespan < f1.id_order_makespan);
+    let f2 = deepstrike_core::benchmark::f2_loop_fairness();
+    assert_eq!(f2.waiting_rounds, 0);
+    let f3 = deepstrike_core::benchmark::f3_termination_dependency_matrix();
+    assert_eq!(f3.cases_checked, 12);
+    println!("DAG gates: F1={f1:?}, F2={f2:?}, F3={f3:?}");
+
+    let mut step_runtime = KernelRuntime::new(SchedulerBudget::default());
+    let started = begin_measurement();
+    for index in 0..10_000 {
+        black_box(step_runtime.step(input(
+            "step-baseline",
+            index,
+            KernelInputEvent::SetMemoryEnabled {
+                enabled: index % 2 == 0,
+            },
+        )));
+    }
+    elapsed_ms("kernel step", started, 10_000);
+
+    let mut render_runtime = KernelRuntime::new(SchedulerBudget::default());
+    for index in 0..1_000 {
+        render_runtime.step(input(
+            "render-baseline",
+            index,
+            KernelInputEvent::AddHistoryMessage {
+                message: Message::user(format!("history-{index} {}", "x".repeat(256))),
+                tokens: Some(64),
+            },
+        ));
+    }
+    let started = begin_measurement();
+    for _ in 0..100 {
+        black_box(render_runtime.render());
+    }
+    elapsed_ms("large-context render", started, 100);
+
+    let started = begin_measurement();
+    black_box(render_runtime.step(input(
+        "render-baseline",
+        1_001,
+        KernelInputEvent::ForceCompact,
+    )));
+    elapsed_ms("compression", started, 1);
+
+    let nodes = (0..100)
+        .map(|index| {
+            WorkflowNode::new(
+                RuntimeTask::new(format!("node-{index}")),
+                AgentRole::Implement,
+            )
+        })
+        .collect();
+    let mut workflow_runtime = KernelRuntime::new(SchedulerBudget::default());
+    workflow_runtime.step(input(
+        "workflow-baseline",
+        0,
+        KernelInputEvent::StartRun {
+            task: RuntimeTask::new("parent"),
+            run_spec: None,
+        },
+    ));
+    let started = begin_measurement();
+    black_box(workflow_runtime.step(input(
+        "workflow-baseline",
+        1,
+        KernelInputEvent::SubmitWorkflow {
+            spec: WorkflowSpec::new(nodes),
+            parent_session_id: "parent".into(),
+            submitter_agent_id: None,
+        },
+    )));
+    elapsed_ms("large workflow", started, 1);
+
+    let mut signal_runtime = KernelRuntime::new(SchedulerBudget::default());
+    signal_runtime.step(input(
+        "signal-baseline",
+        0,
+        KernelInputEvent::ConfigureRun {
+            config: RunConfig {
+                reliability: Some(KernelReliabilityConfig {
+                    snapshot_input_limit: Some(20_000),
+                    ..KernelReliabilityConfig::default()
+                }),
+                ..RunConfig::default()
+            },
+        },
+    ));
+    signal_runtime.step(input(
+        "signal-baseline",
+        1,
+        KernelInputEvent::StartRun {
+            task: RuntimeTask::new("signals"),
+            run_spec: None,
+        },
+    ));
+    let started = begin_measurement();
+    for index in 2..10_002 {
+        let mut signal = RuntimeSignal::new(
+            SignalSource::Gateway,
+            SignalType::Event,
+            Urgency::Normal,
+            format!("signal-{index}"),
+        );
+        signal.id = uuid::Uuid::from_u128(index as u128);
+        black_box(signal_runtime.step(input(
+            "signal-baseline",
+            index,
+            KernelInputEvent::DeliverSignal {
+                delivery_id: format!("delivery-{index}"),
+                attempt: 1,
+                signal,
+            },
+        )));
+    }
+    elapsed_ms("signal storm", started, 10_000);
+
+    let started = begin_measurement();
+    let encoded = signal_runtime
+        .snapshot_json()
+        .expect("encode 10k-event snapshot");
+    elapsed_ms("snapshot encode", started, 10_002);
+    println!("snapshot size: {} bytes", encoded.len());
+
+    let started = begin_measurement();
+    black_box(KernelRuntime::restore_snapshot_json(&encoded).expect("decode/replay snapshot"));
+    elapsed_ms("10k-event replay + snapshot decode", started, 10_002);
+}