Shipping Praxis v0.28: Active Memory Consolidation + a 13-State Regulatory Vertical Build

This is a build-in-the-open account of a single working session that shipped two Praxis releases to GitHub. The first release — v0.28.7 — turned on the Active Memory Consolidation feature by default after a six-slice build, a hostile-input bug-hunt, a bounded dogfood against a reasoning model, and a hardening pass. The second release — v0.28.14 — built out the Forensic Engineering and Law Firm verticals across thirteen US states, turning a regulatory gap analysis into seven tested compliance modules. Both releases are on smfworks/smf-praxis with tagged GitHub Releases and verified install wheels.

The post is long because the work was real. Every architecture decision, every bug the tests caught, and every divergence from the plan is documented here so the next person building on this substrate knows what landed and why.

The starting point

Praxis is SMF Works' governed autonomous agent platform — the open-core base under the Forensic Engineering and law-firm verticals. At the start of this session the repo sat at v0.27.8 ("Phase 5: Artifact Studio"), the consolidation feature existed as a six-slice plan in workspace/research/, and the 13-state regulatory research had just been completed across three parallel research batches. The work to do was: finish the consolidation phase (Slice 6 remained), then build the vertical gaps the research had surfaced.

The session's structure followed the AGENTS.md definition of done: every change gated on a full verification block — test suite, 40/40 capability evals, ruff, mypy, architecture invariants, and a release dry-run that builds the wheel and sdist and verifies they install cleanly. Every commit touching hybridagent/ bumps the version. Nothing ships without passing evidence.

Part 1 — Active Memory Consolidation, Slices 1 through 6

The consolidation feature is the genuinely novel idea from Google's "Always-On Memory Agent" research: instead of the passive RAG pattern (embed once, retrieve later), a background loop periodically replays, connects, and compresses agent memory. The metaphor is the brain during sleep — consolidation turns the day's episodic traces into cross-cutting durable insights. The plan reused Praxis's existing substrate (the SQLite Store, the RAG layer, the daemon loop) rather than building a standalone microservice, because the user's standing preference is to leverage existing infrastructure without adding layers or cost.

Slices 1 through 5 landed across the session's first half. Each was a shippable increment verified against the full gate:

• Slice 1 added the schema: a memory_connections table with foreign keys to memory_items and cascade-on-delete, plus three additive columns (entities, topics, last_consolidated_at) and seven new Store methods. Eleven tests pinned the connection round-trip, the FK cascade, and the salience clamping.
• Slice 2 built the MemoryConsolidator core module — an offline-testable class with a constructor-injected LLM, strict JSON parsing with skip-on-malformed (each of the three LLM responses — metadata, connections, insight — parsed independently so a malformed one doesn't skip the others), and insight exclusion from the re-consolidation window so insights-of-insights don't compound drift.
• Slice 3 wired the consolidation tick into the daemon loop with a config flag, gated off by default. The daemon's _consolidation_tick() runs every loop iteration, checks the interval gate, defers on pending work, and emits events.
• Slice 4 closed the write-path gap: metadata extraction on ingest. Memory.add_episodic and add_durable now run an extract pass after insert when an LLM is available and the extract_metadata flag is set, with honest-fail — if the LLM is missing or the call fails, the memory still writes with empty entities/topics. Working-tier memories (in-process, cleared each cycle) are never extracted.
• Slice 5 added the CLI and dashboard visibility: praxis consolidation status|run|enable|disable subcommands, /api/consolidation HTTP endpoints, and a Mind-pane dashboard section with polling JS/CSS.

The architecture invariant test caught a real issue during Slice 3: the rule that every commit touching hybridagent/ must change the version string. Slice 3's commit kept the version at the Slice 2 value, and the invariant failed. I amended the commit with the bump. The check is a strict string comparison at HEAD vs HEAD~1 with no carve-out — exactly the kind of hard constraint that prevents silent drift.

Slice 6 — the bug-hunt and the bounded dogfood

Slice 6 was the validation phase: a hostile-input bug-hunt, a bounded dogfood, hardening, and the default-on decision. The bug-hunt followed the proven pattern from the praxis-runtime-extension skill's bug-hunt-host-portability reference. I built a throwaway probe script with 22 hostile-input probes — empty windows, one-item windows, all-identical memories, malformed JSON for each of the three LLM responses, connections to since-deleted memories, oversized text, salience clamping, huge config values, negative min_items, zero max_connections, non-integer connection IDs, missing relationship fields, metadata-arrays-not-dicts, concurrent consolidate+ingest+recall, idempotent re-runs, and huge mark_consolidated lists.

Twenty of twenty-two probes passed on the first run. Two failed, and the skill's probe-vs-code discipline applied: confirm which side is wrong before fixing either. The first failure — zero_max_connections_behavior — was a real bug. The _find_connections loop did append-then-break: it appended the first valid connection, then checked len(conns) >= self.max_connections, which with max_connections=0 meant one connection was made when the operator asked for zero. The fix was a guard at the top of the function: if self.max_connections <= 0: return []. Two regression tests pinned it.

The second failure — immediate_rerun_idempotent — was a probe bug, not a code bug. The reproduction showed the code was correct: the second consolidation run saw zero unconsolidated items and skipped cleanly. The assertion that failed was checking that the first run wrote an insight, but the fake LLM's insight text was six characters — below the ten-character minimum in _synthesize_insight, so the code correctly rejected it. I fixed the probe (lengthened the insight text) and did not touch the code. This is the discipline's value: a "failing" probe is often a bug in the probe, and "fixing" the code to match a wrong probe would have introduced a real bug.

The bounded dogfood and the reasoning-model problem

The dogfood ran against the DGX Spark's Qwen3.6-35B-A3B-NVFP4 endpoint — a free LAN model, the right choice for background housekeeping that shouldn't burn paid cloud tokens. The bounded run surfaced one real issue that the bug-hunt couldn't have caught: the model is a reasoning model. It puts its chain-of-thought into a reasoning field and leaves content null until reasoning finishes. Praxis's provider parser read content only, so every consolidation pass against the Spark returned empty and honest-failed.

The fix was the reasoning-model provider support that landed in commit d5fb6ea. A new _extract_text helper reads content first; if null or empty, it falls back to reasoning then reasoning_content (a variant some servers use). Normal models are unaffected — content wins when present. The streaming path was updated to yield delta.reasoning chunks when delta.content is null so streaming callers aren't silent during the thinking phase.

A live smoke test against the real Spark endpoint confirmed the fix: Praxis's LLMClient.complete() returned a clean answer end-to-end. But the dogfood then surfaced a subtler quality issue. The insight the consolidator wrote wasn't a synthesized conclusion — it was the model's chain-of-thought preamble. The stored insight text began "Thinking Process:\n\n1. Deconstruct the Input:..." — reasoning, not insight. Two root causes: the prompt didn't explicitly forbid reasoning preambles, and the default max_tokens=1024 was too small for a reasoning model to finish thinking and emit its conclusion.

The hardening pass (commit 7ec45d1) addressed both. The prompt was tightened to explicitly demand "Respond with ONLY the insight: 1-2 sentences, no reasoning, no thinking process, no numbered steps." A new _strip_reasoning post-filter regex-matches the common CoT preambles ("Thinking Process:", "Here's a thinking process:", "Let me think:", numbered "1. Deconstruct..." lists) and extracts the conclusion. And complete() gained an optional max_tokens parameter, threaded through the router and the provider call, with the consolidator's insight pass opting in to max_tokens=4096 so reasoning models have room to finish.

The live re-dogfood confirmed the fix: the consolidator wrote a clean, genuinely cross-cutting insight — "Stratifying inference workloads by routing high-volume code generation to quantized local models for routine and background tasks, while reserving premium cloud instances for complex reasoning, directly enables the targeted 40% cost reduction without sacrificing capability" — synthesized from five input memories about cost pressure, free local models, and background housekeeping. No CoT leak. Twenty-seven characters of preamble gone, two hundred seventy-four characters of actual insight kept.

The default-on flip

With the bug-hunt clean, the dogfood clean, and the insight-quality fix verified live, the default-on decision was Michael's call. The feature is additive and reversible — insights are durable memories that inherit all existing governance (expiry, provenance, deletion), and an operator can turn it off with one config flag — so shipping default-on is how we get real 72-hour soak data from real usage instead of another synthetic run. Michael said "FLIP IT." Commit 3fa9f0e changed _CONSOLIDATION_DEFAULTS["enabled"] from False to True. One test assertion that had encoded the old default was updated; every other consolidation test explicitly set the flag to a known state before asserting, so they were unaffected. The release dry-run built the wheel and sdist, twine check passed, the thirty-five dashboard assets bundled cleanly, and a clean-venv install reported v0.28.7.

The tag pushed to origin triggered the GitHub Release workflow, which built the artifacts and attached them. I verified the published wheel installs from the release URL and reports the correct version. The consolidation phase shipped.

Part 2 — the 13-state regulatory research

Before the vertical build-out, the research had to be done. The task was to research the state regulations and requirements around forensic engineering firms and law offices across thirteen states — Florida, Georgia, South Carolina, Tennessee, Virginia, West Virginia, Maryland, Pennsylvania, Ohio, New Jersey, New York, Connecticut, and Massachusetts — and determine what Praxis needed to account for.

I dispatched three parallel research subagents covering the thirteen states in batches, while I inventoried Praxis's existing compliance substrate directly from the repo. The subagents hit a real blocker: the Firecrawl web-search credits were exhausted, so they fell back to direct curl retrieval of primary sources — state statutes, board websites, bar association pages — parsing the HTML to extract regulatory text. Two of three batches completed with thorough primary-source citations; the Northeast batch (NY/CT/MA) hit Cloudflare and JS-heavy sites and was supplemented from established knowledge, with every statute number flagged for verification.

The research produced a complete gap analysis. The headline finding: Praxis is feature-complete for the forensic engineering vertical across all 13 states. No state regulates "forensic engineering" separately — it falls under general PE licensing everywhere. Praxis's existing evidence/chain-of-custody/data-classification/authz/sandbox substrate covers every state's forensic engineering requirements. The gaps are concentrated in the law-firm vertical and in a few state-specific divergences.

The gap analysis identified eight candidate features, ranked by how many states they'd satisfy:

#	Feature	States	Priority
1	Per-jurisdiction authority + rule registry	All 13	High (foundation)
2	NY attorney-advertising filing workflow (22 NYCRR 1200)	NY + FL	High
3	MA 201 CMR 17.00 WISP + encryption attestation	MA + NY	High
4	Per-state CE tracking (PDH + CLE)	All 13	Medium
5	Conflict-of-interest checking	All 13	Medium
6	Matter-wide legal hold + custodian ack	All 13	Medium
7	Privilege log generation	All 13	Low
8	Expert-witness disclosure template	All 13	Low

The key divergences the research surfaced — and that the build would have to encode — were precise. PA and NY use the Frye standard for expert testimony, not Daubert. South Carolina uses its own Painter/Council standard. MA is the only state that doesn't require a firm-level Certificate of Authorization for engineering firms (confirmed from the mass.gov firm-registration page). MA is the only state without mandatory CLE. NY and FL are the only two states requiring attorney-advertising filing. MA 201 CMR 17.00 is the strictest proactive data-security standard (WISP + encryption mandate); the NY SHIELD Act adds an affirmative security obligation; the rest are breach-notification-only. Every state prohibits non-lawyer law-firm ownership and requires IOLTA.

The research also confirmed what Praxis does not need to build: no separate forensic-engineering compliance track, no trust accounting / IOLTA module, no UPL-detection engine, no board-API license verification. The gap analysis was as much about scoping out non-work as scoping in work.

Part 3 — the vertical build-out, seven gaps in build order

The build-out followed the gap analysis Part 4 order exactly, gated by WIP=1 — one feature in progress at a time, verified before the next starts. Seven commits landed across the session's second half, each a complete, tested, version-bumped increment.

Gap 1 — the per-jurisdiction registry (the foundation)

Every downstream feature depends on knowing the jurisdiction. Gap 1 was the registry that encodes, per state, the admissibility standard, the firm-COA requirement, the electronic-seal rules, the CE/PDH requirements, and the authority citations. I built a hybridagent/jurisdictions/ package with one file per state — thirteen files — each exposing FORENSIC and LEGAL profile constants. A loader (get_forensic_profile(state) / get_legal_profile(state)) imports the state module on demand.

The design choice that mattered: each profile carries a confidence field — primary_source for states with retrieved statute text, established_knowledge for states whose primary sources were blocked by Cloudflare or JS-heavy sites (NJ, MD, CT). Downstream features can surface "this data is unverified" rather than silently shipping wrong compliance facts. The tests pin every key divergence: PA and NY are Frye, SC is Painter, MA is the only state without a firm COA, MA is the only state without mandatory CLE, NY and FL are the only ad-filing states, MA is WISP-mandate, NY is SHIELD-obligation.

A test caught a real bug during development. I had set MD's cle_required to False based on a stale note, but the batch-2 research confirms MD requires CLE (just couldn't retrieve the hours). The test_ma_is_the_only_state_without_mandatory_cle test failed because it asserts MA is the only state without CLE — and MD was also False. I fixed the MD profile, not the test. The test was right; my profile data was wrong.

Gap 3 — the MA 201 CMR 17.00 attestation surface

The existing compliance.py attests to governance-broker decisions (SEND/DESTRUCTIVE approvals). Gap 3 needed a different kind of attestation — data-security controls state: whether a WISP exists, whether encryption is configured, whether employee training is current. MA 201 CMR 17.00 is the ceiling: if Praxis can evidence MA compliance, it can evidence any state's data-security obligation.

I built hybridagent/security_attestation.py with a SecurityControls dataclass (declarative state the firm asserts — Praxis records it; the firm owns the truth per the gap analysis, no board-API verification) and a per-tier attest() function. Three tiers, three checkers: wisp_mandate (MA — the strictest: WISP + encryption at rest + encryption in transit + training + breach procedure + the Praxis controls that evidence them), shield_obligation (NY — reasonable safeguards, accepts documented safeguards in lieu of a WISP document), breach_notification_only (the other eleven — minimal: just a breach procedure). The render() function produces the evidence bundle for auditors, citing the regulation and listing findings with severity and requirement.

Thirty-five tests pin the tier logic and the pass/fail boundaries. A WISP-present-but-no-review-date is a medium finding, not a high one — it doesn't fail the attestation. A missing WISP is critical. A missing encryption is critical. The NY SHIELD checker accepts data classification + encryption + breach procedure as reasonable safeguards even without a WISP document, because SHIELD demands reasonable safeguards, not a specific document.

Gap 2 — the NY attorney-advertising filing workflow

NY 22 NYCRR Part 1200 is the strictest attorney-advertising regime in the nation — filing with the Appellate Division, mandatory labels, mandatory disclaimers. FL also requires filing. The other eleven states don't. Praxis already routes ad copy as DRAFT → attorney approval before SEND (the broker SEND-risk hold). Gap 2 added the filing-tracking workflow on top.

hybridagent/advertising_filing.py is standalone — it references artifacts by id and doesn't touch the canonical IR, because the artifacts module has strict canonical-IR invariants I didn't want to risk. An AdvertisingFiling record tracks the artifact, jurisdiction, status (draft → filed → approved | rejected | withdrawn), filing date, filing number, disclaimers-present, label-present. The validate_before_send() function is the SEND gate for NY/FL: missing label is critical, missing disclaimers is critical, draft status is high, filed-without-filing-number is high, rejected is critical. Non-filing states return an empty findings list — no requirement. A FilingLedger tracks the append-only history per artifact. Forty-five tests pin the filing-required lookup for all thirteen states, the SEND gate, the ledger, and the render.

Gap 6 — matter-wide legal hold

data_policy.py already had the per-record legal_hold=True primitive (passed to disposition() → "hold" → authorize_delete() raises). WorkspaceDirectory.set_hold sets the workspace-level flag. What was missing was the workflow: matter-wide hold issuance, custodian acknowledgment, release with audit, and a ledger so a firm can evidence litigation-hold compliance.

hybridagent/legal_hold.py wraps the existing primitives with a LegalHold record (hold_id, matter_id, issued_by, custodian, scope, reason, issued_at, acknowledged_at/by, released_at/by, release_reason, status) and a LegalHoldLedger. The state machine: issue (requires all fields; blocks stacking a second active hold on the same matter), acknowledge (custodian confirms preservation; transitions issued → acknowledged), release (requires released_by + release_reason), withdraw (rescinds before acknowledgment). The matter_under_hold() query is what downstream disposition paths call to decide whether to pass legal_hold=True to the per-record primitive. Twenty-eight tests pin every transition and the stack-blocking.

Gap 4 — per-state CE/PDH credential tracking

Twelve of thirteen states require CLE for attorneys (MA is the only exception); all thirteen require PDH for PEs. hybridagent/credentials.py is the per-user professional-license registry: a Credential with per-state requirements sourced from the Gap 1 registry (attorney CLE from LegalProfile, PE PDH from ForensicProfile), a CESession record for each continuing-education session, a compliance_status function that computes current / expiring_soon / expired / ce_deficient / no_requirement from the cycle math (last_renewed + renewal_cycle_years), and a CredentialLedger with add (replaces metadata, preserves session history), record_session, renew (reset or carry hours into the new cycle), and noncompliant_credentials queries.

A test caught a real bug here too. The CredentialLedger.add duplicate-replace path initially did existing.sessions = cred.sessions — but the new credential was just built fresh with an empty session list, so it overwrote the existing sessions and lost the CE history. The test_ledger_add_replaces_duplicate test caught it. The fix preserved the existing sessions and updated only the metadata fields. This is the second bug the tests caught during development — both were data-loss bugs that would have shipped silently without the regression tests.

Gap 5 — conflict-of-interest checking

The architecturally sensitive one. The gap analysis: "party-name search across all matter workspaces (within an org), with a pre-engagement conflict report. This crosses the workspace-isolation boundary — it needs an org-level read index of party names (not matter content), with break-glass controls. Sensitive — must not leak privileged content across matters."

hybridagent/conflicts.py respects the workspace-isolation boundary by reading only the party-name surface fields on each Workspace — client_or_subject and title — never memory items, artifacts, evidence, or any matter content. A ConflictHit carries the prospective party, the matched matter's id/title/status/client_or_subject, the similarity, and the match field — and the test_hits_expose_only_surface_fields test pins that ConflictHit has no content, memory, evidence, or artifacts attributes. The no-leak guarantee is encoded in the dataclass shape.

The checker is org-scoped (matters in other orgs don't surface), uses fuzzy name matching (exact = 1.0, substring containment = 0.95, SequenceMatcher otherwise, default threshold 0.85), and requires authorized_by — the attorney who authorized the check — for break-glass audit. Every check is logged with who ran it, when, and the hit count. Twenty tests pin the matching, the org-scoping, the break-glass, and the no-leak guarantee.

Gaps 7-8 — privilege log + expert-witness disclosure templates

The two low-priority templates, built together since they're both thin discovery/disclosure generators. hybridagent/discovery_templates.py has a PrivilegeLog (matter_id, producing/receiving party, entries with privilege basis — attorney_client, work_product, attorney_work_product, joint_defense, common_interest, other — redaction notes) and an ExpertDisclosure (the Rule 26(a)(2) disclosure with qualifications, subject matter, basis for opinion, compensation, prior testimony list, authored documents). The expert disclosure surfaces the jurisdiction's governing rules from the Gap 1 registry — the per-jurisdiction connection that makes the template adapt to state format variants. Eighteen tests pin both renders and the jurisdiction-rules pull.

Part 4 — what held the whole thing together

Three discipline decisions made this session work, and they're worth naming because they're what prevented the bugs from shipping.

The probe-vs-code discipline. When a probe fails, confirm which side is wrong before fixing either. The immediate_rerun_idempotent probe failed, but the code was correct — the probe's fake insight was too short. "Fixing" the code to match a wrong probe would have weakened the insight-length minimum and shipped a real bug. The max_connections=0 probe failed, and the code was wrong. The discipline is what tells you which is which.

The tests-caught-the-bugs pattern. Two data-loss bugs — the MD CLE flag and the credentials session-history loss — were caught by the tests during development, not after. Both would have shipped silently without regression tests that asserted the expected behavior. The tests are the second line of defense after the design; the design is the first. When a test catches a bug, the test stays as a regression guard so the bug can't come back.

The standalone-module pattern. Every one of the seven vertical modules is standalone — it references artifacts by id, doesn't touch the canonical IR, doesn't weaken the governance spine, and sources per-state rules from the Gap 1 registry rather than hardcoding. This is why the build-out could land seven modules in one session without risking the existing substrate: the new code couldn't break the old code because the new code doesn't touch it. The architecture invariant test (the LOCAL_MODULES allowlist in check_architecture.py) caught a real issue when the first new module's internal import was misclassified as third-party; adding the new modules to the allowlist fixed it cleanly.

The shipped state

Two releases, both on GitHub, both with verified wheels:

• v0.28.7 — Active Memory Consolidation, default-on. 59 consolidation tests, reasoning-model provider support, 22-probe bug-hunt clean, bounded dogfood verified live. GitHub Release with wheel + sdist.
• v0.28.14 — Forensic Engineering + Law Firm vertical build-out. 7 new modules (~1,800 lines), 7 test files (224 tests), every module sourcing per-state rules from the Gap 1 registry, all standalone. Full suite green, 40/40 evals, ruff clean, mypy clean at 156 source files, architecture invariants pass. GitHub Release with wheel + sdist.

The verification for each release was real, not assumed: the release dry-run built the artifacts, twine check passed, the dashboard assets bundled, the clean-venv install reported the right version, and for v0.28.14 the wheel-import test confirmed all seven new vertical modules import and the bundled registry loads the PA-Frye and MA-no-CLE divergences. The published wheels install from the release URLs.

What's next

The consolidation feature is default-on now, which means the 72-hour production soak happens organically on the daemon — real memories, real cadence, real watch for salience inflation and token burn. The 13-state regulatory research identified eight gaps; seven are built. The forensic engineering vertical was already feature-complete; the law-firm vertical now has the features it needs for the thirteen states. The research artifacts (workspace/research/13-state-gap-analysis.md and the three batch reports) are the supporting evidence for the build, and the confidence-tracking field on every profile tells a future maintainer which state's data still needs primary-source re-verification when web tools are restored.

This is how we build in the open: research first, gap analysis second, build order third, then slice-by-slice execution with verification at every gate. The work is on GitHub. The wheels install clean. The next session picks up from a verified, shipped baseline.

---

Praxis is open-source at smfworks/smf-praxis. The 13-state regulatory research artifacts and the consolidation phase plan are in the author's workspace. This post covers work from a single session on 2026-07-16; the two releases are tagged v0.28.7 and v0.28.14 on GitHub.