Release Notes

This page tracks the recent direction of the project.

v0.35.0

Focus:

• Phase C: cross-model 8B ceiling confirmation + format-correction retry null result

New:

• Per-call LLM timeout raised to 900s (_LLM_TIMEOUT_SECONDS) to absorb reasoning-model <think> blocks; separate 60s _LLM_PROBE_TIMEOUT_SECONDS for the startup reachability check so misconfigurations still surface fast (PR #57).
• sanitize_with_reason(patch, slug, *, tree_paths) returning a (cleaned_patch, reason) tuple with 8 machine-readable reason codes in SANITIZE_REASONS: placeholder_hunk, truncated_hunk, overlong_hunk, malformed_metadata, path_not_found, ambiguous_path, empty_extraction (+ empty-string success). The legacy sanitize() is kept as a backward-compat wrapper (PR #58).
• Format-correction retry: _sanitize_for_submission(..., retry_callback=cb) invokes cb(reason, failed_output) -> str on rejection. _build_retry_prompt embeds the reason + failed output + reason-specific guidance. All three runners (run_baseline, run_organism, run_langgraph) accept retry_on_reject: bool = False. _FORMAT_RETRY_MAX = 1 (PR #58).
• New CLI flags: --retry-on-reject (enables retry), --output PATH (preserves artifacts per-model without overwriting; also honored under --rewrite-envelope). Existing callers see zero behavior change (PR #58, review #755 follow-up).

Findings (deepseek-r1:8b with retry, 10 SWE-bench-lite instances per condition):

• baseline / organism / langgraph: 0/10 evaluated each, 0 retry-recovered patches each, 0 runtime errors. Mean latency 18–19 min/call (reasoning models are slow).
• The v0.34.5 gemma4 "single survivor" (django/django-11001 baseline, unresolved) is gemma4-specific. Deepseek-r1 could not produce a git apply-clean diff for that instance under any of the three conditions. The 8B-class format-discipline ceiling is not a single-model artifact.
• Retry-with-reason-code did not break the ceiling. 0 recoveries across 30 submissions. At 8B, diff-format failure is not mistake-that-can-be-corrected but cannot-produce-format-at-all — a sharper negative than v0.34.5's predicted 20–40% recovery band.

Paper updates:

• Paper 5 §6.3 adds subsubsection “Phase C: Cross-Model Check with Format-Correction Retry” with setup, per-condition outcome table, comparison vs gemma4 v0.34.5, and what-Phase-C-does-and-does-not-say.
• Paper 5 Limitations item: “SWE-bench-lite ceiling at 8B, confirmed cross-model.”

v0.34.5

Focus:

• Patch-apply pipeline + grounded SWE-bench Phase 2 v2 rerun — the un-grounded v1 ceiling claim, properly tested

New:

• eval/_patch_sanitizer.py: pre-rejects model output that git apply would refuse — placeholder hunks (@@ -XXX,N +XXX,N @@), path doubling (a/django/django/foo.py), truncated/overlong hunks, malformed rename/copy metadata, bare empty context lines. Count-driven hunk consumption so adversarial body content can’t false-match file headers. 47 unit tests lock the contract.
• eval/_repo_cache.py + eval/_repo_grounding.py: opt-in via --grounding. Shallow-fetches {repo}@{base_commit} into a local cache; ranks candidate files by issue-text heuristics; injects up to 5 file snippets into the task prompt. The sanitizer also gets a tree oracle and fuzzy-corrects near-miss paths to unique basename matches.
• Honest reporting: new EVAL_RUNTIME_ERROR status distinct from sanitizer-rejected empty_patch; mean_latency_ms divides by completed predictions (was deflated when zero-latency timeout rows were included). Schema test pins specific runtime-error rows so silent regressions can’t ship.

Findings (Phase 2 v2 grounded rerun, 10 instances per condition):

• baseline: 0 resolved, 1 unresolved (django-11001), 7 sanitizer-rejected, 2 runtime errors (Ollama API timeouts) — 1/10 evaluated.
• organism: 0 resolved, 0 unresolved, 10 sanitizer-rejected — 0/10 evaluated.
• langgraph: 0 resolved, 0 unresolved, 10 sanitizer-rejected — 0/10 evaluated.
• The original v1 run had 20 error outcomes (patches that failed at git apply); the rerun has zero. Sanitizer pre-rejection ensures no malformed patch reaches the harness, so the failures are now correctly attributed to the model rather than to infrastructure.

Conclusion (Paper 5 §6.3):

• The original Phase 2 result confounded two failure modes: model selecting wrong file paths, and model writing malformed unified diffs. Grounding solves the first — every prompt now contains the actual files at base_commit. The fact that 27 of 28 model-returning submissions are still sanitizer-dropped localizes the bottleneck to the second: at 8B / Q4_K_M, diff-format discipline is the binding constraint, not file selection.
• Section 6.3 retitled “8B Format Discipline Is the Ceiling.”
• Latency cost of grounding: ~doubles per-call wall-clock (baseline 44s → 131s) for zero evaluated-rate gain at this model scale. Cost-benefit changes with stronger models, but at 8B it is overhead.

v0.34.4

Focus:

• SWE-bench Phase 2 — pass/fail evaluation in Docker, initial null result (later reframed in v0.34.5)

New:

• eval/swebench_phase2.py: official swebench.harness.run_evaluation wrapper. Produces eval/results/swebench_phase2.json with per-instance eval_status (resolved, unresolved, error, empty_patch, not_evaluated).
• eval/_patch_extraction.py: unified-diff extractor. Accepts bare diffs, fenced ```diff / ```patch blocks, and git metadata (rename, new file, deleted file, /dev/null add/delete). Rejects hunk-only snippets without file headers.
• Phase 2 separates harness failures from test failures: resolved_rate=None and harness_ran=False are reported explicitly instead of being silently counted as 0%.

Findings (later superseded by v0.34.5 grounded rerun):

• Zero resolved across all three conditions on SWE-bench-lite: baseline 0/10, organism 0/10, LangGraph 0/10. The original write-up framed this as a model-capability ceiling on Gemma 4; the v0.34.5 rerun showed the result was confounded by patch-application failures (most submissions never reached the harness because git apply rejected them), and the actual ceiling is diff-format discipline at the 8B / Q4_K_M scale.
• Organism and LangGraph pipelines degrade patch extraction (6/10 vs baseline’s 10/10) and cost 2× latency — this gap closed in v0.34.5 once the [edit]-stage prompt was tightened to emit a single fenced diff and nothing else.
• Phase 1’s judge-based plausibility scores (baseline=0.808, organism=0.776) do not predict correctness: plausible-looking patches still fail to apply or fail tests.
• Model identifier in this release’s artifact: gemma4:latest (8B Q4_K_M, digest c6eb396dbd59). The original write-up incorrectly described this as “Gemma 4 27B MoE / 4B active”; the model-identity record was added in v0.34.5 to prevent this kind of mis-attribution going forward.

Paper updates:

• Paper 5 adds Section 6.3 (originally titled “Decomposition Does Not Help on Real Bug-Fix Tasks”; retitled in v0.34.5 to “8B Format Discipline Is the Ceiling” once the grounded rerun localized the bottleneck).
• Paper 5 Limitations extended with Phase 2 null-result framing.

v0.34.0 – 0.34.2

Focus:

• Parallel stage execution + speedup theorem validation

New:

• Parallel stage groups: stages=[[s1, s2], [s3]] runs s1 and s2 concurrently, then s3.
• LangGraph fan-out/fan-in via Send API: organism_to_langgraph() compiles parallel groups to fork→stages→join topology.
• Speedup theorem predictor validated against measured wall-clock: rho=1.000 across 6 configs.
• Categorical verification extended to parallel groups (non-interference preserved under compilation).

v0.33.0

Focus:

• Atomic skills catalog + harness-architecture paper updates

New:

• seed_library_from_atomic_skills(): 5 composable coding skill patterns (localize, edit, test, reproduce, review) from Ma et al. (arXiv:2604.05013). Topology derived via shared _shape_to_topology() — parallel review maps to specialist_swarm, sequential skills to skill_organism.
• get_atomic_skill_patterns(): returns deep copies of the built-in catalog
• Paper: new subsection “Harness Engineering as Architecture” mapping Zhou et al.’s four-pillar externalization framework (Memory, Skills, Protocols, Harness) to Operon’s categorical Architecture triple $(G, \mathrm{Know}, \Phi)$
• Paper: cite Zhou et al. (2604.08224) and Ma et al. (2604.05013) in related work with Operon mapping
• All 5 paper PDFs rebuilt

Key insight:

• Structural guarantees are harness-level properties, not model-level ones. The LangGraph functor proves this: wrapping organism.run() transfers all guarantees because they reside in the harness.
• Atomic skills compose without negative interference (Ma et al.) — validates Operon’s operad composition model.

v0.32.0

Focus:

• LangGraph compiler + DeerFlow executor

New:

• organism_to_langgraph(): compile SkillOrganism to a LangGraph StateGraph. Wraps organism.run() as a single node — all structural guarantees (CertificateGate, WatcherComponent, VerifierComponent, halt_on_block) enforced by the organism’s own run loop.
• run_organism_langgraph(): compile + execute in one call with certificate verification
• execute_deerflow(): single-agent execution via DeerFlow’s create_deerflow_agent (LangGraph runtime)
• guarded_graph.py: earlier per-stage approach (superseded by langgraph_compiler but kept for reference)
• Optional dependency: pip install operon-ai[deerflow]

Findings:

• Reimplementing SkillOrganism.run() logic as LangGraph nodes caused 8 rounds of review fixes. Wrapping organism.run() directly eliminated all divergence bugs: 215 lines instead of 520.
• LangGraph’s StateGraph is structurally isomorphic to Operon’s wiring diagram model (nodes = stages, conditional edges = interventions).
• DeerFlow requires Python ≥3.12 and uses LangGraph under the hood — LangGraph is the right compile target.

v0.31.1

Focus:

• Compile/decompile round-trip, capability annotations, RunContext, harder eval

New:

• RunContext: typed dict subclass wrapping shared_state with property accessors for watcher interventions, verifier signals, and telemetry events. Supports custom WatcherConfig.state_key.
• deerflow_to_topology() / swarms_to_topology(): decompilers enabling compile→decompile round-trips with certificate preservation
• ExternalTopology.capabilities: structured per-agent capability annotations with EXTERNAL_CAPABILITY_MAP (27 tool→Capability mappings) for ToolDensity theorem
• TelemetryProbe enrichment: run_start event includes organism config (stage_count, stage_names, mode_assignments, certificate_theorems)
• hard_par_08: subtle bug detection eval task (off-by-one, TOCTOU, float precision, exception handling). 21 benchmark tasks total.
• Sustained immune monitoring: 6 tests at production thresholds (min_observations=10)
• Certificate identity tests: full (theorem, parameters, source) preservation verified across all 4 compilers
• Papers updated: VerifierComponent + CertificateGate documented across all 4 papers + overview article

Findings:

• hard_par_08 discriminates: phi3:mini scores 0.72, gemma4 scores 1.00 (delta = 0.28). Hints in the prompt are for the judge, not the examinee.
• Prop 5.1 round-trip verified: certificates survive DeerFlow and Swarms compile→decompile. Swarms preserves exact graph topology (1:1 compiler).
• All 4 compilers achieve 100% certificate identity preservation.

v0.31.0

Focus:

• Adaptive immune quality evaluation + pre-execution integrity checking

New:

• VerifierComponent: rubric-based quality evaluation for stage outputs (adaptive immune / B-cell analogy). Emits WatcherSignal(source="verifier") that triggers ESCALATE on low quality
• CertificateGateComponent: pre-execution DNARepair.scan() in on_stage_start() — halts before LLM call if genome corruption detected (G1/S DNA damage checkpoint)
• Pre-stage intervention check in SkillOrganism.run() (enables CertificateGate)
• Non-watcher components run before watcher in on_stage_result() for correct signal ordering
• Cross-model judging: --judge-url and --judge-model flags for e2e eval

Findings:

• Quality-based escalation requires cross-model judging — self-judging with weak models inflates scores
• Phi-3 Mini produces quality = 0.95–1.0 code reviews even with Gemma 4 cross-judge — task needs harder bugs to differentiate
• Each structural guarantee layer has a stricter precondition: DNARepair (none) < ImmuneSystem (sustained obs) < EpiplexityMonitor (real embeddings) < VerifierComponent (capable judge)

v0.30.1

Focus:

• End-to-end real agent evaluation — RAW vs GUARDED vs FULL with Gemma 4 27B and Phi-3 Mini

New:

• eval/e2e_real_agent.py: evaluation harness with --model, --max-tokens, --tasks, --repetitions flags
• Three tasks: stagnation escalation, injection blocking, state integrity
• Auto-detect reasoning models for max_tokens (aligned with live evaluator)
• Immune system training on real LLM outputs with per-prompt isolation
• Canary-based Signal 2 for single-prompt immune detection
• Papers 1 and 4 updated with e2e findings (Section 4.5, 5.5)

Findings:

• State integrity: 100% detection, 100% repair (DNARepair — deterministic, model-independent)
• Injection: TP = 20%, FP = 0% (precise behavioral detection, designed for sustained monitoring)
• Stagnation: 0% escalation (measures repetition, not mediocrity — correctly scoped)
• Wrapper tax: +1,300 tokens / +27s on Gemma 4 (model-size-dependent cost floor)
• Phi-3 Mini (quality = 0.63): confirms escalation is a loop-breaker, not a quality gate

v0.28.1

• Certificate preservation through convergence compilers (Swarms, DeerFlow, Ralph, Scion)
• collect_certificates() on SkillOrganism, verify_compiled() for post-compilation verification
• Certificate serialization/deserialization with lazy theorem resolution
• Concrete implementation of Prop 5.1: structural guarantees are functorially stable under compilation

v0.28.0

New:

• Certificate framework: self-verifiable structural guarantees with derivation-replay verify()
• certify() on QuorumSensingBio (no-false-activation), MTORScaler (no-oscillation), ATP_Store (priority gating)
• Sequential pipeline validation harness (run_topology_validation.py)
• Paper 4 Section 4.4: error amplification bound validated (rho=+0.751, p<0.001)
• Role-to-capability mapping for ToolDensity theorem
• Gemma 4 / Ollama support in live evaluator
• Default provider timeout 30s → 120s

v0.27.1

• Worker scaling benchmark: fixed denominator for consistent slot accounting
• Multi-model embedding summary: regenerated from source data
• Docs sync: version bumps, release notes, paper abstract/intro fixes

v0.27.0

Focus:

• Structural guarantee benchmarks — three-variant comparison (biological, ablated, naive) with pathway-grounded scenarios from KEGG/Reactome, 10M+ data points

New:

• QuorumSensingBio: autoinducer signal accumulation with temporal decay (KEGG map02024), auto-calibrated thresholds via categorical certificate (de los Riscos et al. Prop 5.1)
• MTORScaler: AMPK ratio + rate-of-change sensing with hysteresis (KEGG hsa04152), adaptive worker scaling
• Benchmark suite (eval/benchmarks/): metabolism, quorum sensing, epiplexity — all three biological wins
• Real embedding confirmation: false-stagnation discrimination 96% bio vs 2% naive across 3 models; convergence accuracy 96% bio vs 40% naive (all-MiniLM-L6-v2)
• Paper 4, Paper 2 extension (Sections 8-9), blog post

v0.26.0

Focus:

• C8 Phase A: Meta-evolution of organism configurations — the core experiment testing whether biological abstractions generalize to the meta-level
• Rich LLM proposer with filesystem context (Meta-Harness insight)
• Dual stall detection: config novelty + score plateau

New:

• FilesystemOptimizer protocol — distinct from C7's EvolutionaryOptimizer
• EvolutionLoop — meta-harness glue (DesignProblem wrapping, EpiplexityMonitor stall detection)
• CandidateConfig / StageConfig with lossless Genome round-trip
• TournamentMutator + LLMProposer hybrid proposer strategy
• EvolutionStore — candidate-first filesystem persistence with index.jsonl
• DistanceProvider protocol for EpiplexityMonitor (scale-invariant epistemic health)
• ConfigHammingDistance for config-space novelty measurement
• run_meta_evolution.py CLI runner with --llm-proposer gemini support
• Example 108: meta-evolution usage
• 52 C8-specific tests, 20+ roborev review rounds

Findings:

• Gene abstraction covers full configuration space (lossless round-trip)
• Epistemic health monitoring generalizes across scales (pluggable distance)
• Rich context LLM proposer: 3x improvement over compressed (0.49 vs 0.15)
• Config-space evolution: LLM proposer matches but doesn't dominate tournament mutations
• Phase B topology mutations: tournament improved (0.60), LLM degraded (0.36)
• Conclusion: biological abstractions generalize as code structure, not as optimization algorithms

Note: C8 meta-optimization code moved from operon_ai/convergence/ to eval/meta/ — experimental evaluation code, not part of the library. DistanceProvider remains in operon_ai/health/.

v0.25.1

Focus:

• live evaluation with real LLM providers (Gemini API, Claude CLI, Codex CLI)
• C8 roadmap: Meta-Harness integration planning
• documentation and version sync fixes

New:

• LiveEvaluator — runs real LLM calls through SkillOrganism pipelines
• CLI provider evaluation via cli_handler() (Claude Code, Codex)
• LLM-as-judge quality scoring across providers
• Live evaluation finding: +6.2% quality for guided multi-stage pipelines
• C8 roadmap: FilesystemOptimizer, HarnessSearchDP, Pareto convergence, causal diagnosis
• Example 107: live evaluation harness

v0.25.0

Focus:

• evaluation harness, prompt optimization protocols, workflow generation (Phases C6+C7)
• 20 benchmark tasks x 7 configurations with MockEvaluator using real structural analysis
• PromptOptimizer and WorkflowGenerator protocol families

New:

• MockEvaluator — evaluation harness with structural variation and credit assignment
• PromptOptimizer, EvolutionaryOptimizer, NoOpOptimizer — prompt optimization protocols
• attach_optimizer — attach optimizer to SkillStage
• WorkflowGenerator, ReasoningGenerator, HeuristicGenerator — workflow generation protocols
• generate_and_register — generate workflow and register in PatternLibrary
• 20 benchmark tasks across 7 configurations (single, pipeline, fan-out, fan-in, diamond, full, stress)
• Structural variation analysis and credit assignment in evaluation
• Examples 104–106

v0.24.1

Focus:

• production runtime compilers, distributed watcher, LangGraph integration (Phase C5)
• 4 deployment compilers (Swarms, DeerFlow, Ralph, Scion) plus 6 external adapter integrations

New:

• organism_to_swarms(), managed_to_swarms() — compile organism to Swarms workflow config
• organism_to_deerflow(), managed_to_deerflow() — compile organism to DeerFlow session config
• organism_to_ralph(), managed_to_ralph() — compile organism to Ralph event-driven hat config
• organism_to_scion(), managed_to_scion() — compile organism to Scion containerized grove config
• DistributedWatcher with InMemoryTransport and HttpTransport (webhook payload stub) — transport-abstracted convergence detection
• operon_watcher_node() — LangGraph-compatible convergence detection node
• create_watcher_config() — helper for LangGraph watcher configuration
• Examples 99–103

v0.24.0

Focus:

• convergence adapters for Swarms, DeerFlow, and AnimaWorks
• template exchange, DeerFlow skill bridge, hybrid assembly
• PrimingView multi-channel context, memory bridge, HeartbeatDaemon
• AsyncThink Fork/Join execution, TLA+ formal verification, co-design theory

New:

• operon_ai.convergence package with 12 modules
• ExternalTopology, AdapterResult — shared adapter types
• analyze_external_topology() — epistemic theorems as structural linter
• seed_library_from_swarms/deerflow/acg_survey — catalog seeding
• skill_to_template(), template_to_skill() — bidirectional DeerFlow skill bridge
• hybrid_skill_organism() — library-first + LLM generator fallback
• PrimingView — multi-channel SubstrateView subclass (immutable via MappingProxyType)
• HeartbeatDaemon — idle-time consolidation via WatcherComponent extension
• AsyncOrganizer, async_stage_handler() — Fork/Join within stages
• DesignProblem, compose_series/parallel, feedback_fixed_point — Zardini co-design
• 3 TLA+ specifications (TemplateExchange, DevelopmentalGating, ConvergenceDetection)
• prompt_optimizer hook on SkillStage (interface for future DSPy integration)
• parse_ralph_config(), ralph_hats_to_stages() — Ralph adapter
• parse_aevolve_workspace(), aevolve_skills_to_stages() — A-Evolve adapter
• seed_library_from_ralph/aevolve — catalog seeding
• EvolutionGating.tla — TLA+ spec for evolution loop
• Examples 86–98

v0.23.3

Focus:

• CLI stage handler for external tool integration
• Shell out to any CLI tool (Claude Code, Copilot, ruff, custom scripts) as organism stages

New:

• cli_handler() — factory that wraps any CLI command as a SkillStage handler
• cli_organism() — convenience for multi-CLI workflows via managed_organism
• CLIResult — structured output with stdout, stderr, returncode, latency, timed_out
• _action_type convention in handler output for signaling FAILURE to the watcher
• Output parsers: parse_json(), parse_lines()
• examples/83_cli_stage_handler.py

v0.23.2

Focus:

• pattern-first ergonomics pass for the v0.19-0.23 subsystems
• one-call managed_organism() factory wiring the full stack
• top-level consolidate() convenience function

New:

• ManagedOrganism, ManagedRunResult — full-stack organism with run/consolidate/export/scaffold
• managed_organism() — batteries-included factory with sensible defaults
• consolidate() — one-call sleep consolidation
• advise_topology() gains optional library and fingerprint params
• examples/82_managed_organism.py

v0.23.1

Focus:

• release integration and publication polish
• bi-temporal memory adapters (HistoneStore → BiTemporal, EpisodicMemory → BiTemporal)
• cross-subsystem integration tests (5 end-to-end tests)
• article rewrite (abstract, conclusion updated for full v0.19–v0.23 scope)

New:

• histone_to_bitemporal(), episodic_to_bitemporal() — memory bridge adapters
• Integration tests covering substrate+watcher, adaptive+consolidation, social+development, full lifecycle
• Article abstract covering six-layer progression
• Article conclusion with roadmap arc and updated future work

v0.23.0

Focus:

• developmental staging (EMBRYONIC → JUVENILE → ADOLESCENT → MATURE)
• critical periods that close as organisms mature
• capability gating on Plasmid acquisition
• teacher-learner scaffolding

New:

• DevelopmentController, DevelopmentConfig, DevelopmentalStage, DevelopmentStatus
• CriticalPeriod, StageTransition, stage_reached()
• Plasmid.min_stage — developmental gating on tool acquisition
• SocialLearning.scaffold_learner() + ScaffoldingResult
• Watcher developmental signals (SOMATIC/development)
• examples/80_developmental_staging.py — lifecycle progression and gating
• examples/81_critical_periods.py — teacher-learner scaffolding
• Developmental Staging Space
• Article updates: critical periods (§6), developmental staging impl (§8)

v0.22.1

Focus:

• social learning with trust-weighted template exchange across organisms
• epistemic vigilance (TrustRegistry) for peer output trust scoring
• curiosity signals in WatcherComponent for novelty-seeking escalation

New:

• SocialLearning, PeerExchange, TrustRegistry, AdoptionResult, AdoptionOutcome
• Watcher curiosity signals (EPISTEMIC/curiosity) + curiosity_escalation_threshold
• examples/78_social_learning.py — template sharing with trust
• examples/79_curiosity_driven_exploration.py — curiosity-driven escalation
• Social Learning Space
• Article updates: social learning + curiosity (§6, §8)

v0.22.0

Focus:

• cognitive mode annotations (System A/B on SkillStage)
• sleep consolidation cycle (replay, compress, counterfactual, histone promotion)
• counterfactual replay over bi-temporal corrections

New:

• CognitiveMode enum, resolve_cognitive_mode() helper
• SleepConsolidation, ConsolidationResult, CounterfactualResult
• counterfactual_replay() — static analysis of corrected facts
• Watcher mode_balance() for System A/B distribution
• examples/76_cognitive_modes.py — mode annotations and watcher balance
• examples/77_sleep_consolidation.py — full consolidation cycle
• Consolidation Space
• Article updates: cognitive modes (§6, §8), sleep consolidation (§8)

v0.21.1

Focus:

• adaptive assembly loop (fingerprint → template → assemble → run → record)
• experience pool on WatcherComponent for cross-run intervention learning

New:

• AdaptiveSkillOrganism, AdaptiveRunResult — compose-run-record lifecycle wrapper
• adaptive_skill_organism() — public factory for adaptive assembly
• assemble_pattern() — convert PatternTemplate into runnable topology
• ExperienceRecord — cross-run intervention memory on WatcherComponent
• record_experience(), retrieve_similar_experiences(), recommend_intervention()
• examples/74_adaptive_assembly.py — full adaptive loop
• examples/75_experience_driven_watcher.py — experience-driven recommendations
• Adaptive Assembly Space
• Article updates: evo-devo inner loop (§6), adaptive assembly impl (§8)

v0.21.0

Focus:

• pattern repository for reusable collaboration templates
• watcher component with three-category signal taxonomy
• run-loop intervention mechanism (retry, escalate, halt)

New:

• PatternLibrary, TaskFingerprint, PatternTemplate, PatternRunRecord
• WatcherComponent, WatcherConfig, WatcherSignal, SignalCategory
• InterventionKind, WatcherIntervention — run-loop intervention types
• examples/72_pattern_repository.py — register, score, and retrieve templates
• examples/73_watcher_component.py — signal classification and interventions
• Watcher Dashboard Space
• Article updates: adaptive assembly (§2, §6), watcher + pattern library (§8)

v0.20.0

Focus:

• bi-temporal memory integration with SkillOrganism
• three-layer context model (topology, ephemeral, bi-temporal)
• HuggingFace Space for bi-temporal memory explorer

New:

• SubstrateView — frozen read-only envelope for substrate queries
• SkillStage fields: read_query, fact_extractor, emit_output_fact, fact_tags
• SkillOrganism.substrate — optional BiTemporalMemory for auditable shared facts
• examples/71_bitemporal_skill_organism.py — enterprise workflow with substrate
• Bi-Temporal Memory Space
• Article updates: three-layer context model (§6), substrate integration (§8)

v0.19.0

Focus:

• bi-temporal memory (valid time vs record time)
• append-only correction semantics
• belief-state reconstruction for compliance auditing
• article updates: temporal databases, temporal coalgebra, temporal epistemics

New:

• BiTemporalMemory, BiTemporalFact, BiTemporalQuery, FactSnapshot, CorrectionResult
• examples/69_bitemporal_memory.py — core API demo
• examples/70_bitemporal_compliance_audit.py — enterprise audit scenario
• Bi-Temporal Memory docs

v0.18

Focus:

• thinner front door
• pattern-first API
• provider-bound skill organisms
• attachable telemetry

Related writing:

• Medium: Operon v0.18
• Blog: Operon v0.18

v0.17

Focus:

• epistemic topology
• architecture-level analysis
• practical comparison to Kim et al.

Related writing:

• Blog: Operon v0.17