v0.7.0 — The SQLite of Durable Execution

v0.7.0 — The SQLite of Durable Execution

⚡ The SQLite of Durable Execution (Micro-Kernel Architecture)

• Radical Micro-Kernel Consolidation: Amputated 70+ legacy coding-agent files, consolidating letitloop into an ultra-lean in-process persistence engine exporting @durable, step, atomic_marker, supervise, LivenessSupervisor, State, and lock.
• Correctness & Corruption Resilience Patches:
  • Line-0 Torn Tail Recovery: Patched LILWAL02 replay to safely truncate interrupted partial writes at line 0 without crashing.
  • Zero Quadratic Write Amplification: Decoupled full snapshot serialization from hot step() and async_step() loops (periodic snapshot every 50 steps or on clean close), reducing disk I/O overhead by up to 98% in long-running pipelines.
  • Crash-Resilient 2-Phase atomic_marker: Upgraded atomic step markers to a 2-phase commit lifecycle (.pending.<pid> -> .committed) that cleans up uncommitted locks from dead PIDs.
  • Fail-Closed State Verification: Enforced fail-closed corruption handling across state snapshots and WAL journals.
• Unified Lean CLI: Redesigned command-line interface supporting lil watch, lil inspect, lil demo, lil bench, and lil version.
• Zero-Daemon Ecosystem Integration: Turnkey durable workflows and recipes for browser-use, pydantic-ai, and dspy.

v0.6.0 — Browser Use Cookbook, Multi-Framework Adapters & Reliability Hardening

What's Changed in LetItLoop v0.6.0

LetItLoop v0.6.0 brings ecosystem cookbooks, multi-framework persistence adapters, and engine hardening to PyPI while preserving the strict zero-daemon, zero-mandatory-dependency core contract.

🌐 Ecosystem Cookbooks

• Browser Use Durable Digest Cookbook (#106): Added read-only release digest cookbook (examples/cookbooks/browser_use_durable.py) contributed by @MagMueller. Demonstrates @durable_async step checkpointing, explicit demo/live modes, and real process kill -9 restart tests skipping finished web page extractions.

🔌 Multi-Framework Durability Adapters

• LangGraph (LetItLoopCheckpointSaver): Native BaseCheckpointSaver powered by embedded SQLite in atomic WAL mode (PRAGMA journal_mode=WAL) with sub-millisecond superstep persistence.
• CrewAI (CrewAIDurabilityHandler): Task lifecycle callback integration with automatic task skipping on resume.
• Hugging Face Smolagents (SmolagentsWALCallback): Step callback integration capturing thoughts, tool calls, and observations into atomic WAL.
• Microsoft AutoGen 0.4 / Magentic-One (AutoGenStateSerializer): State serialization, message history checkpointing, and tool execution persistence.
• Strict Zero-Mandatory-Dependencies: All adapters use lazy optional imports and pure-Python duck-typed fallbacks.

🛡️ Resilience & Engine Hardening

• Fail-Closed Frame Integrity: Strict LILWAL02 CRC32 frame checksum verification on AutoGen adapters.
• Telemetry & NTFS Resilience: Thread locking and exponential backoff retry loops eliminating file-lock race conditions during rapid test runs on Windows NTFS.
• Full Multi-OS & Multi-Python Matrix Green: Tested and verified on Linux, macOS, and Windows across Python 3.10, 3.11, and 3.12.

Full Changelog: v0.4.0...v0.6.0

v2.0.0 — LetItLoop Verification Action (DCP-2.0 Proof Gate)

📢 LetItLoop Verification Action v2.0.0

A zero-dependency, fail-closed GitHub Action that audits Python AST integrity, verifies Write-Ahead Log (WAL v2) transactions, and generates cryptographic durability proof receipts in <2.5s.

🚀 Usage

- name: LetItLoop Proof Verification Gate
  uses: sdageltc/letitloop/letitloop-action@v2.0.0
  with:
    token: ${{ secrets.GITHUB_TOKEN }}
    wal-dir: .bench_wal
    workspace: .

v0.4.0 — 6-Sprint Master Architecture: DCP-2.0 Moat, MCP Server, EU CRA Ed25519/SBOM, Action v2 & Policy Gate

🏆 LetItLoop 6-Sprint Master Architecture Release (v0.4.0)

This landmark release completes the full 6-sprint architectural roadmap, transforming LetItLoop from a standalone WAL prototype into an enterprise-grade crash-resilience kernel, viral public benchmark moat, universal MCP server, and EU CRA compliance gate.

---

📦 Key Highlights & Capabilities

1. 🔧 Real Framework Adapters & Durable Kernel (Sprint 1)

• Zero-Dependency Decorators: @durable\ and @durable_async\ automatically cache step inputs/outputs into Write-Ahead Logs (WAL v2).
• Sub-Millisecond Resume: Crashed pipelines fast-forward past completed steps with 0% duplicate token consumption in <1ms.
• Framework Bridges: Ready-to-use adapters and examples for LangGraph, CrewAI, AutoGen, and raw AsyncIO pipelines.

2. 🏆 DCP-2.0 Conformance Moat & Public Leaderboard (Sprint 2)

• HMAC Anti-Cheat Signatures: Benchmark runs generate non-reproducible, cryptographically signed audit receipts (\ race_id\ + 64-char HMAC).
• Visual Terminal Visualizer: \lil demo\ displays a 10s interactive crash-recovery visualizer with synthetic tasks.
• SVG Badges & HTML Reports: Generates deterministic durability shields (\durability_score.svg) and static leaderboard pages.
• Nightly GitHub Pages: Deploys the latest benchmark rankings automatically to \https://sdageltc.github.io/letitloop/bench\.

3. 📢 Production GitHub Action v2 (Sprint 3)

• Zero Runtime Dependencies: Compiled into a single 24 KB CJS bundle (\dist/index.js) using Node.js built-ins.
• Fail-Closed Verification Gate: Validates AST integrity across all Python files and CRC checksums on WAL frames in <2.5s.
• Automated PR Billboard: Posts cryptographic durability proof receipts as sticky PR comments on every commit.

4. 🔌 Universal MCP Durability Server (Sprint 4)

• Universal IDE Compatibility: Stdio-based MCP server (\python -m letitloop.mcp) for Cursor, Windsurf, Claude Code, and Roo.
• 7 Durable Tools: \checkpoint_state,
  ollback_ast, \�erify_scope, \emit_receipt, \durable_step, \�ench_compare, and \wal_verify.
• Security Jailing & Idempotency: Hard filesystem containment preventing path traversal outside declared workspaces and worktrees.

5. 🛡️ EU Cyber Resilience Act (CRA) Auto-Remediation (Sprint 5)

• Proof-Carrying Patches: \lil remediate\ executes auto-fixes inside isolated Git worktrees with machine-verifiable proof contracts.
• Hardware-Grade Cryptography: Ed25519 detached signatures and Sigstore OIDC attestations for software supply-chain integrity.
• Lightweight SBOM Diffing: Automated CycloneDX SBOM generation comparing dependency trees and code hashes before and after repairs.

6. 🏛️ Enterprise Deterministic Policy Gatekeeper (Sprint 6)

• Token Budget & Scope Enforcement: \lil gate\ blocks CI/CD pipelines if an autonomous agent exceeds LLM token limits or modifies forbidden files.
• Entropy Secret Scrubber: Scans logs and diffs for high-entropy strings and masks API keys (\sk-, \ghp_, \AKIA, private keys) into <secret:REDACTED>.

v0.3.4 — Adapter Bridges, Security Sandbox & CI Durations Gate

What's Changed in LetItLoop v0.3.4

🌉 Adapter Bridges & Honest Conformance

• **_durable_mixin.py**: Native @durable_async\ node/tool wrapping for LangGraph, CrewAI, and AutoGen.
• Honest Archetypes: Verified with
  epo-scan, labeled \is_shim = not is_host_available(...)\ when host libraries are uninstalled, executing real host workflows when installed.

🛡️ Security Sandbox & Path Traversal Hardening

• Path Traversal Shield:
  unner.py, \synthetic_engine.py, and \chaos_fuzzer_v2.py\ strictly reject .., /, and \\\ target paths.
• Scenario Whitelist: Strict \ALLOWED_SCENARIOS\ validation with 4 new sandbox security regression tests.

⚡ Reliability & Zero-Dependency Resilience

• Standard Dataclasses: \schema.py\ converted to standard library dataclasses, eliminating hard runtime dependencies.
• Graceful Process Inspection: \orchestrator/lock.py\ and \injector.py\ gracefully handle missing processes and optional \psutil.

🧪 Remote Verification Evidence

• Pytest: 1,468 passed, 4 skipped, 0 failed.
• Ruff: 0 lint or formatting errors across all 231 files.
• GitHub Actions CI Matrix: 100% Green across Ubuntu, macOS, and Windows on Python 3.11 & 3.12.

v0.3.3 — Conformance Moat, LILWAL02 Checksums & Async Engine

What's Changed in LetItLoop v0.3.3

🛡️ STREAM B — LILWAL02 Checksummed WAL Framing

• CRC32 Framing: Switched to structured framing \nLILWAL02:<len_hex>:<crc32_hex>:\n\ using \zlib.crc32.
• Torn-Tail Auto-Truncation: Byte-accurate
  +b truncate(good_end)\ recovery on crashes, with fail-closed behavior on mid-file corruption.
• Backwards Compatibility: Seamlessly reads legacy JSONL entries and hybrid WAL files.

⚡ STREAM C — Async Durability Engine

• **@durable_async\ & \�wait async_step()**: Native async workflow support with thread-local / context-isolated \contextvars.ContextVar\ and \�syncio.Lock.
• Sub-Millisecond Fast-Forward: Cached steps resolve in <1ms without re-invoking wrapped coroutines.

🏆 STREAM A — DCP-2.0 Conformance Moat

• Conformance Subpackage: Consolidated \letitloop.conformance\ with real benchmark harness, adapters (\letitloop, \langgraph, \crewai, \�utogen, \in_memory,
  aw_python), and scenarios (DCP-001 through DCP-004).
• CLI Commands: \lil bench --compare all\ (16-trial matrix) and \lil bench --scenario \ generating machine-verifiable JSON receipts.

💥 STREAM D — 500-Cycle Chaos Fuzzer v2

• Stress-Tested Recovery: 500 cycles across 20 parallel sync+async workers with random SIGKILL / taskkill injections (129 kills, 0 state losses, 0 corrupted WALs).

🧪 Verification Evidence

• Pytest: 1,464 passed, 4 skipped, 0 failed.
• Ruff: 0 lint or formatting errors.
• GitHub Actions CI Matrix: 100% Green across Ubuntu, macOS, and Windows on Python 3.11 & 3.12.

v0.3.1: The @durable Trojan Decorator, WAL v2 Crash Resilience & DCP-2.0 Conformance

🚀 What's New in LetItLoop v0.3.0

1. The @durable Trojan Decorator (letitloop.durable)

Embed LetItLoop's deterministic crash-recovery kernel directly into your existing Python code without spinning up servers or daemons:

from letitloop import durable, step, atomic_marker

@durable(goal_id="customer_sync")
def main():
    # If killed mid-flight, step 1 is skipped on resume: 0% duplicate token waste
    user = step("fetch_user", fetch_crm_record, user_id=123)
    summary = step("llm_summarize", call_claude, user)
    
    # Side-effect marker guards external mutations against duplicate replay
    with atomic_marker("slack_notification") as should_execute:
        if should_execute:
            step("post_slack", notify_team, summary)

2. WAL v2 Kernel Hardening

• Valid-Prefix Truncation: When interrupted mid-write during SIGKILL, torn-tail EOF entries are automatically truncated to the last valid frame without data loss.
• Snapshot Fallback: load_state() falls back directly to full WAL reconstruction if state.json is corrupted or empty.

3. Lock v2 Auto-Stealing & Heartbeat Daemon

• Dead supervisor locks (.goal.lock) from crashed PIDs are verified and safely adopted.
• Background LockHeartbeatDaemon maintains lock liveness every 30s.

4. DCP-2.0 Conformance Benchmark

• Consolidated benchmark suite into letitloop/conformance/ with 4 deterministic crash windows (DCP-001 through DCP-004).
• Run via lil bench --matrix or python -m conformance.harness.runner.

5. Verified PR Gate

• Seamless pairing with sdageltc/letitloop-action@v1 for zero-dependency AST signature and invariant verification on pull requests.

---

Full Changelog: v0.2.0...v0.3.0

v0.3.0: The @durable Trojan Decorator, WAL v2 Crash Resilience & DCP-2.0 Conformance

🚀 What's New in LetItLoop v0.3.0

1. The @durable Trojan Decorator (letitloop.durable)

Embed LetItLoop's deterministic crash-recovery kernel directly into your existing Python code without spinning up servers or daemons:

from letitloop import durable, step, atomic_marker

@durable(goal_id="customer_sync")
def main():
    # If killed mid-flight, step 1 is skipped on resume: 0% duplicate token waste
    user = step("fetch_user", fetch_crm_record, user_id=123)
    summary = step("llm_summarize", call_claude, user)
    
    # Side-effect marker guards external mutations against duplicate replay
    with atomic_marker("slack_notification") as should_execute:
        if should_execute:
            step("post_slack", notify_team, summary)

2. WAL v2 Kernel Hardening

• Valid-Prefix Truncation: When interrupted mid-write during SIGKILL, torn-tail EOF entries are automatically truncated to the last valid frame without data loss.
• Snapshot Fallback: load_state() falls back directly to full WAL reconstruction if state.json is corrupted or empty.

3. Lock v2 Auto-Stealing & Heartbeat Daemon

• Dead supervisor locks (.goal.lock) from crashed PIDs are verified and safely adopted.
• Background LockHeartbeatDaemon maintains lock liveness every 30s.

4. DCP-2.0 Conformance Benchmark

• Consolidated benchmark suite into letitloop/conformance/ with 4 deterministic crash windows (DCP-001 through DCP-004).
• Run via lil bench --matrix or python -m conformance.harness.runner.

5. Verified PR Gate

• Seamless pairing with sdageltc/letitloop-action@v1 for zero-dependency AST signature and invariant verification on pull requests.

---

Full Changelog: v0.2.0...v0.3.0

v0.2.0 - Verification Engine Batch

letitloop 0.2.0 - the verification-engine batch

13 issues implemented in one batch: sandboxing, resilience, observability, DAG validation, and full core modularization. 1,403 tests passing (up from 1,221), ruff clean, CI green on Python 3.11/3.12.

Highlights

• Docker sandbox adapter (#7) and local LLM tool-calling adapter (#10) - run contracts in containers or fully offline via Ollama/vLLM
• Process-tree orphan guard (#16) - Windows Job Objects + POSIX process groups; grandchildren die with their parents
• Worktree sandboxing (#15) - every attempt in an ephemeral git worktree; merge on PASS, prune on FAIL
• DAG cycle detection (#17) - ASCII cycle traces, enforced at plan creation, dispatch, AND resume
• Webhooks + SSE (#18) - HMAC-signed dispatch, lil serve, 7 lifecycle events
• Prometheus/OTel exporter (#8) - histograms, counters, optional [telemetry] extra
• MCP client manager (#11) - stdio + SSE transports,
  equired_mcp_servers contracts
• Live TUI (#12) - lil dashboard --live with colors, DAG tree, budget gauge
• Risk-tiered provider routing (#19) - escalation ladders with budget-aware fallbacks
• Core modularization (#9) - supervisor + quality_plane decomposed into packages, 100% API-compatible
• Adversarial fault-injection suite (#20) - traversal fuzz, zombie tree-kill, WAL corruption matrix, 3-strike determinism
• Community recipes (#14) - four schema-validated walkthroughs

Hardening

Corrupt WAL quarantine on checkpoint apply; typed StateError on corrupt snapshots; deterministic Job Object handle cleanup; CLI env-scope fix.

Full details: CHANGELOG | Issues: #7-#20 (all closed with evidence)

v0.1.1: Autonomous Macro-Task Orchestration & Verification Control Loop

Highlights of letitloop v0.1.1

• DAG Contract Planning: Automated decomposition of natural language objectives into strongly-typed, cycle-checked execution contracts.
• Fault-Tolerant Supervisor: Crash-resilient state journal with Write-Ahead Logging (WAL) and bounded 3-strike strategy mutations.
• Zero-Trust Verifier Engine: 8 deterministic acceptance check kinds (AST syntax parsers, command exit-code assertions, regex matchers, scope fences).
• Multi-Lens Quality Plane: 5 specialized evaluation lenses (Correctness, Security, Docs, Tests, Architecture) with formal arbitration.
• Universal Model Context Protocol (MCP): 8 stdio JSON-RPC tools connecting Claude Code, Cursor, Antigravity, Hermes Agent, OpenCode, Cline, and Windsurf.
• CLI Diagnostics (lil doctor): System and preflight diagnostic command (contributed by @vaibhavmashal).
• Triple-OS CI Matrix: 1,140+ tests passing 100% green across Linux, macOS, and Windows.

Quickstart

# Zero-install AI agent skill
npx skills add sdageltc/letitloop

# Full Python Engine & CLI
pip install git+https://github.com/sdageltc/letitloop.git