v0.3.0 — Structured Execution Runtime

From inference proxy to deterministic execution runtime.

Runtime Correctness

• Canonical JSON — recursive key-sort for deterministic cache keys. \ and \ produce identical hashes.
• Dependency graph — execution→artifact edges with dirty propagation (lazy O(affected) invalidation)
• Artifact versioning — content-hash-based, not path-based. mtime alone is unreliable.
• Provenance lineage — typed edges: DerivedFrom, DependsOn, InvalidatedBy, SuggestedBy, CorrectedBy

Structured Execution

• ExecutionUnit — structured \ + \
• ReasoningKind — Assumption, Hypothesis, Validation, Failure, Resolution
• Reasoning normalization — whitespace-collapse + lowercase for deterministic dedup

Protocol Layer

• Canonical IR — provider-neutral protocol layer with Chat Completions + Responses API adapters
• ProviderKind enum — OpenAI, DeepSeek, Anthropic, Unknown
• Granular capabilities — ToolStreamingMode, ReasoningMode, StructuredOutputMode with centralized CapabilityAdapter
• StreamEvent lifecycle — MessageStart, ToolCallStart→ArgsDelta→ToolCallEnd, MessageEnd
• Stream assembler — buffers partial events, emits complete calls only

Cache

• L1 hot cache — true LRU with reverse dependency index
• Automatic population — pipeline extracts from message history, no agent hooks needed
• Section-level hashing — TOML \ hashed independently

v0.2→0.3

122 tests, clippy clean. All DB migrations are additive (backward compatible).

v0.2.0 — Inference-aware Coding Runtime

Turns repeated inference into reusable execution state.

Core

• Runtime Policy — 5 configurable profiles (Minimal/Efficient/Exploratory/Autonomous/Custom), advisory decisions with confidence scores
• Tool Result Cache — Deterministic hash(tool + args) with partial file-based invalidation
• Failure Memory — Stores why_failed + invalidated_assumptions, prevents error loop token waste
• Plan Persistence — Execution state (goal, steps, assumptions), not plan text

Memory

• Semantic DAG — True shared graph, embedding-based dedup (cosine ≥0.85 auto-merge), sentence-level provenance
• Tree-sitter AST — 8 languages: Rust, Python, TypeScript, JavaScript, Java, C/C++, C#, Go
• Execution Units — think → act → observe → reflect cycles with outcome inference
• Code Diff Memory — Stores what changed, not full code blocks

Runtime

• Entropy-aware Compaction — Trigram novelty scoring adjusts thresholds
• Decay-based GC — 3-tier retention with memory scoring
• Streaming DAG — SSE incremental context delivery
• Event Sourcing — Append-only audit log

Benchmark

Simulated 3-conversation, 20-turn, 8-language session: 7440 → 4500 tokens (-40%)

109 tests. CI: check → clippy → test → doc.

v0.1.0 — Proof of concept

Lossless Context Management proxy for DeepSeek API.

Features

• Transparent proxy — forwards /v1/chat/completions with SSE streaming passthrough
• DAG engine — hierarchical conversation summarization with 3-level escalation (L1 LLM → L2 LLM → L3 deterministic)
• SQLite persistence — WAL mode, auto-checkpoint every 100 writes
• Snippet extraction — preserves code blocks, paths, numbers, percentages, proper nouns, and error messages before compression
• FTS5 full-text search — with LIKE fallback for CJK/English mixed content
• Context-ReAct operations — compress, delete, and rollback HTTP endpoints
• Structured context panel — <lcm_context> with per-node summaries, snippets, and available operations
• Session tracking — SHA-256 fingerprint for multi-turn conversations

Install

cargo install --git https://github.com/gordonlu/deeplossless

Quick start

DEEPSEEK_API_KEY=sk-... deeplossless
# Point deepseek-tui to the proxy:
deepseek config set base_url http://127.0.0.1:8080/v1

Notes

• v0.1.0 status: Proof of concept. Not recommended for production use without review.
• DAG compression requires an LLM API call (uses the configured upstream model).
• 48 tests, clippy -D warnings clean.