SeamZero // Execution Custody

Dual Control-Plane Runtime Governance & Custody Stack

Zero protected loss. Zero workflow deadlock. Zero keys in agent memory.

Probabilistic prompt guardrails allow destructive side effects to slip into production, while static deny rules paralyze autonomous workflows the moment operational state becomes partially observable. SeamZero closes that safety-liveness gap with two deterministic control planes inside an OS-enforced Trusted Computing Base: Plane I (Epistemic Consequence & Repair Synthesis) discovers and binds verified safe execution paths before commitment, while Plane II (Conserved OS Custody) isolates live credentials and enforces single-spend physical authority across Linux and Windows infrastructure.

Chained Workflow Completion 10 / 10

Guarded boundaries completed at zero protected loss where raw execution loses state at boundary 1 and static deny deadlocks at 0/10.

Adversarial Envelope Edge 12 / 12

Cliff Test regimes passed at zero loss across horizon caps, invariant paradoxes, partial faults, and 0.26 s hostile TOCTOU drift aborts.

Warm Topology Restore 1.90 s

Linux x86_64 NVMe snapshot restore median across 24 retained state owners and 58 directional custody pairs over loopback IPC.

Air-Gapped Receipt Proof 82.73 ms

Standalone Windows NTFS verification median (4.82 ms local Linux ext4 journal check) over domain-separated Ed25519 commitments.

Controlled Baseline // Identical Multi-Boundary Operational Worlds

Same worlds. Three policies.

Zero LLM Judges in Enforcement Path
1. Unguarded Raw Execution Breach
Protected LossBoundary 1
Safe Completion0%

Executes agent-proposed mutations directly over authorized sockets, forfeiting protected records on the first coupled or delayed side effect.

2. Static Neighborhood Deny Deadlock
Protected Loss0
Chain Completion0 / 10

Preserves state only by halting workflows; lacks isolated counterfactual simulation, relational transfer, or bounded argument repair.

01 // Architectural Division of Authority

The Closed-Loop Execution Seam: Admit → Prepare → Reconcile

Non-Substitutable Dual Planes
ARCHITECTURAL INVARIANT: Plane I determines whether a supported safe plan exists within its epistemic and search envelope. Plane II limits, isolates, and serializes the physical spending authority granted to that plan. Neither plane substitutes for the other.
STAGE 01 // ADMIT

Bind Contract & Retained Owners

Binds a reviewed physical adapter contract—declaring schema identity, state projection, invariant and goal measurements, causal footprint, and isolated branch semantics—to package-local retained owner heads before any session opens.

admit(adapter_contract, retained_owner_bindings) → session
STAGE 02 // PREPARE

Induce, Repair & Pin Prestate

Snapshots operational prestate without world mutation, runs isolated counterfactual probes when uncertainty requires discovery, synthesizes bounded argument or sequence repairs, checks pre-commit causal-footprint drift, and suspends at the exact authorized commitment boundary.

prepare(session, typed_request) → Held | PreparedBoundary
STAGE 03 // RECONCILE

Spend Authority & Seal Receipt

Reserves conserved epoch capacity, mints single-spend OS file or socket capabilities inside credential-free workers, independently measures poststate outcomes, tracks pending multi-horizon obligations, and appends a signed receipt.

reconcile(prepared_boundary, measured_outcome) → Completed | PendingHorizon | Indeterminate

02 // Control Plane I — Epistemic Consequence & Repair Engine

Deterministic Consequence Governance Without Neural Guessing

Tested against 15,360-coordinate neural residual-stream probes that suffered protected state loss under distribution shift, Plane I rejects activation probing and LLM-as-a-judge heuristics—governing transitions strictly from receipt-verified operational evidence.

Interval Epistemics

Scope-Owned Consequence Bounds

Every forecast belongs to an explicit consequence scope, state owner, and execution context. Missing suffix support or unobservable protected dependencies never default to allow—they hold fail-closed with explicit epistemic uncertainty codes.

Bounded Synthesis

Isolated Discovery & Zero-Probe Reuse

Executes candidate transitions in isolated discovery worlds verified to leave live state untouched, synthesizes safe parameter and ordering repairs (such as 52/52 verified safe SQL replacements under partial observability), and transfers proven plans at zero runtime probe cost until drift occurs.

State Preservation

Restorative Resource Governance

Goes beyond destructive-call denial by independently measuring complete key-to-record recoverability prior to queued replacements—constructing preparatory preservation actions so valid workflows complete without data loss.

Temporal Supervision

Delayed & Multi-Horizon Obligations

Supervises asynchronous worker and compaction effects beyond the immediate tool boundary (achieving 3.25× valid action throughput over static trajectory monitors at zero loss). Threatened future horizons block subsequent mutations until discharged, even if a requested call fails.

Provenance Custody

Multi-Owner Authority & Prefix Safety

Reserves authority across 24 distinct state owners and rejects stale, foreign, or unreserved collaborator outputs. Chained cross-surface workflows require cryptographic predecessor receipts before advancing to downstream boundaries.

Exfiltration & Fault Accounting

Cumulative Receiver & Compensation Ledger

Measures reconstruction risk across accumulated egress receiver state rather than scoring individual packets in isolation. When live multi-step faults trigger compensation, both the intermediate fault state and compensated poststate are permanently recorded.

Strict Epistemic Telemetry Separation: Inspection views derive strictly from execution receipts; advisory anomaly diagnostics hold zero execution-minting authority. activation_tensors_captured = false

03 // Envelope Boundary Qualification

The Cliff Test: 12 / 12 Deterministic Outcomes at the Search & Drift Edge

High-assurance governance is defined by how a runtime behaves when pushed past its composition horizon, probe budget, or precondition assumptions. Across all 12 sealed Cliff Test regimes, SeamZero solves supported repairs and halts cleanly with exact absence accounting when outside the safe envelope.

0 Protected Loss // 12 Regimes
Boundary Axis Evaluated Regime Probes Warm Time Runtime Outcome & Audit Code Loss
Composition Depth Supported multi-step compositions (depth 1 & depth 2) 2 / 3 0.52 s / 1.89 s Goal Solved Synthesizes verified ordered program within declared horizon 0
Composition Depth Safe target beyond enumerated depth envelope (depth 3) 9 7.15 s HORIZON_EXCEEDED_SAFE_HOLD Refuses unsupported extrapolation (+1 absence) 0
Discovery Budget Rank-15 valid candidate vs. beyond-ceiling target 15 / 30 3.29 s / 6.31 s PROBE_CAP_EXHAUSTED_SAFE_HOLD Solves rank-15; halts deterministically at 30-probe ceiling 0
Invariant Coupling Decoupleable goal conflict vs. true invariant paradox 3 / 0 0.52 s / 0.03 s UNSATISFIABLE_INVARIANT_CONFLICT Repairs decoupleable conflict; holds paradox in 34 ms 0
World Drift (TOCTOU) Unrelated ambient noise vs. hostile pre-commit mutation 2 / 1 0.48 s / 0.26 s PRECOMMIT_DRIFT_ABORT Revalidates benign noise; aborts hostile precondition drift 0
Live Partial Fault Clean staged sequence vs. mid-execution step-2 fault 3 / 2 2.22 s / 1.88 s PARTIAL_COMPOSITION_COMPENSATED Restores routing & records intermediate fault state 0
Cross-Surface Chain Coupled multi-boundary receipt progression 15 6.08 s Goal Solved Verifies predecessor receipts & preserves committed safe prefix 0

04 // Control Plane II — Conserved Authority & OS Custody Kernel

Credential-Zero Wire Proxying & Honest Hardware Confinement

Once Plane I binds a verified commitment, Plane II guarantees that raw credentials never enter worker memory, authorization capacity cannot be double-spent under concurrency, and OS boundaries match exact platform kernel capabilities.

5-State Conserved Epoch Capacity

64-Thread / 4-Node Verified
1,000 conserved global authorization cap (disjoint MCP & enterprise slices)
Spent180
Armed80
Indeterminate60
Reserved100
Available580
spent + armed + retained_indeterminate + reserved + available == epoch_cap

Non-Refundable Indeterminacy: Network timeouts, disconnects, or missing poststate receipts never trigger automatic refunds or blind replays. Unresolved capacity stays locked in retained_indeterminate, and expired kernel capabilities require explicit Ring-0 tombstoning before escrow reclamation.

Wire-Level Protocol Gates: Restricted workers hold zero database passwords or cluster keys. Outer custody proxies inject credentials on the wire while enforcing PostgreSQL SAVEPOINT row-ceiling rollbacks, MySQL implicit-DDL split-gates, fenced SQLite DML, and mutual-TLS Kubernetes /validate + dryRun=All admission.

Explicit Cross-Platform Custody Scope

58 Custody Pairs

Linux x86_64 — Tier 1 Ring-0 & Snapshot Custody

1.90 s Restore

Frozen Ring-0 eBPF LSM hooks (file_open, inode_unlink, socket_connect) enforce single-spend slot burn, expiry, and live-root binding alongside SO_PEERPIDFD private-pipe attestation. CRIU warm-snapshot restore brings the 24-owner topology online in a 1.90 s NVMe median across 22 zero-process samples.

Linux ARM64 — Tier 2 Edge Host Custody

35.25 s Edge Restore

Qualified on physical ARM64 edge hardware with full 2.65 GB image authentication, 5.85 s warm-cache minimum, 35.25 s independent final-manifest restore (40.05 s 21-sample microSD median), 8 snapshot negative controls, and full 225-graph equivalence parity.

Windows x64 — Native Userland Custody

WIN32_NATIVE_USERLAND_CUSTODY

Enforces restricted worker tokens, enclosing Job Objects (terminating descendants on custodian exit), pinned file handles, staged-write + atomic-rename installation, and owner-only DACLs with 5 verified restorations. Linux Ring-0 LSM and CRIU are never falsely claimed on Windows (unsupported snapshot calls fail closed with exit 78).

05 // Zero-HITL Traceability & Day-1 Adoption

Autonomous Flight Recorder, Shadow Rollback Trials & Causal Forensics

SeamZero operates without human-in-the-loop approval bottlenecks—pairing a non-invasive composite console (7 Control Plane tabs and 4 receipt-synchronized specialist inspection views) with counterfactual Shadow Audit mode and one-command causal receipt timelines.

127.0.0.1 Loopback IPC Only
Custody Posture Overview Decisions System Surfaces Prediction & Learning Effect & Recovery Evidence & Health Specialist Receipt Views (4)
Mode: Shadow Audit / Enforce
01 // STATE OWNERS 24 Retained / Bound
02 // CUSTODY PAIRS 58 Active Bindings
03 // KERNEL / CARRIER Manifest Verified
04 // SHADOW TRIAL SAVEPOINT + DryRun
05 // KILL-SWITCH Quarantine & Drain Armed
CAUSAL EXPLAIN TIMELINE // seamzero explain <receipt> --json VERIFIER: seamzero verify <ledger> --anchor <anchor> (Ed25519 Offline)
1. Prestate & Plan

Binds plan_sha256 and transactional prestate hash before any physical mutation executes.

2. Credit Admission

Verifies conserved epoch slice balance and atomically arms single-spend reservation.

3. Carrier Boundary

Records Linux LSM slot burn or Win32 restricted-worker handle custody scope honestly.

4. Adapter Outcome

Captures affected rows, rollback or commit status, and independent poststate measurement.

5. Witness Seal

Binds ordered turn and bundle commitments for standalone air-gapped verification.

06 // Epistemic Honesty & Wave 7 Release Manifest

Admitted Surface Scope & Bitwise-Reproducible Deliverables

Every release archive is dual-stream reproducible, OPSEC-audited across raw and nested carriers, and verified to leave zero residual processes, listeners, mounts, cgroups, or kernel objects across 42,188 preserved host files.

Admitted Operational Surfaces

  • Transactional Databases: PostgreSQL, MySQL, and fenced SQLite read/DML custody proxies with deterministic row ceilings and credential-zero wire injection.
  • Cluster & Infrastructure: Kubernetes mutual-TLS validating admission webhook (/validate) paired with server-side dryRun=All verification.
  • Durable Services & Files: Durable HTTP receivers with request journals, queued repair workers, POSIX/NTFS staged file replacement, and bounded process/config surfaces.
  • Agent & Model Hosts: Governed MCP file/SQLite servers, LangGraph state-graph loops, normalized file middleware, and OpenAI-compatible or local model tool-call transports.

Explicit Non-Claims & Security Boundaries

  • No Unmodeled Shell Rubber-Stamping: Arbitrary unmodeled shells or unverified third-party webhooks are held outside execution authority; JSON schema validity alone never mints physical capabilities.
  • Exact Kernel vs. Broker Split: Ring-0 eBPF LSM validates slot burn, expiry, and root binding—it does not parse SQL/HTTP payloads in kernel space. Protocol semantics execute inside confined, non-delegating workers.
  • Exact Witness Scope: Standalone receipts prove ordered admission/outcome commitments and Ed25519 ledger integrity without claiming general-purpose STARKs or protection against a hostile root/SYSTEM administrator.
225Cross-Arch Equivalence Case Graphs
91End-to-End Integration Checks
74 / 30Live & Custody SQL / Kubernetes Checks
25 / 25Native Windows Application Checks
16 / 16Cleanroom Doctor Self-Test Gates
5 / 5Tamper Rejections (Exit 78 / No Partial Run)
Platform Canonical Release Archive Exact Bytes Archive SHA-256 Digest Bundle Manifest SHA-256
Windows x64 SeamZero-Wave7-Win64.zip 1,171,524,522 69404df15dd3eeb77a600ea899bf3b7a5ea0bdde42fcea57c79d9387a747056e 7db708abbeb427ad79362b69083510b79fa7f12085a39aca01579a139db550b2
Linux x86_64 SeamZero-Wave7-Linux-x86_64.tar.zst 901,504,067 5fff76a853aef6ab5c8a50b2b3fff4839d74d3af1c67cef8257f425072f107af 972779b1a01a936d43aa07b7354adbcaf1f602c3f590ffd6a6b83bd58326880b
Linux ARM64 SeamZero-Wave7-Linux-aarch64.tar.zst 827,655,730 9f6e4178f4bb56c68595e3a8fac204d8c7c1320d5b3e6ca12622f00c527e6339 96a71c419e84a39fbf31d6a9c675f841296bb30a5f3909f0efc544dc8d4e1a54
Offline Archive & Cleanroom Verification Commands (Windows PowerShell & Linux)
# Windows PowerShell — Verify sealed archive SHA-256 and run 16/16 cleanroom doctor self-test
Get-FileHash .\SeamZero-Wave7-Win64.zip -Algorithm SHA256
tar -xf .\SeamZero-Wave7-Win64.zip -C C:\sz-eval
C:\sz-eval\SeamZero-Wave7-Win64\bin\seamzero.cmd doctor --self-test

# Linux (x86_64 / aarch64) — Verify canonical archive SHA-256 against SHA256SUMS.txt
sha256sum -c SHA256SUMS.txt