v0.16.0 — valuation repair + OWL scroll safety

Highlights

• New odoo-valuation-repair skill — a DRY-RUN-first, fail-closed playbook for diagnosing, repairing, and preventing AVCO/FIFO inventory valuation drift.
• Safer OWL client actions — documents the native scroll containment contract: the client-action root owns height: 100% and overflow-y: auto; do not patch body or .o_action_manager.
• 25-skill public surface — Claude Code and Codex manifests, changelog, skill count, test count, and landing-page footer are aligned to 0.16.0.

Verification

• Python 3.12 compile gate: passed
• CI-equivalent introspection suite: 86 passed
• Full standalone suite: 1162 passed, 4 skipped, 101 subtests passed
• odoo-owl skill validation: passed
• JSON manifests and whitespace checks: passed

The Odoo-runtime example test is intentionally outside the standalone gate because it imports the odoo package.

v0.15.0 — statutory reports + Vietnam accounting + worktree workflow

Three battle-tested additions distilled from a real statutory-reporting engagement (full Vietnamese TT99 financial-statement set built and verified on a production clone), plus the 18→19 fleet-migration hardening accumulated since 0.14.0. The suite is now 24 skills.

New skill: odoo-statutory-reports

Dynamic financial statements via the account.report engine (Enterprise account_reports):

• line/expression anatomy, engine table, sum/-sum sign convention
• date_scope semantics (strict_range / from_beginning / to_beginning_of_period)
• the full custom-engine contract (_report_custom_engine_* full-name formula, custom_handler_model_id, the {'result': …} return key, _get_report_query)
• self-verifying statutory design: catch-all lines = 0, balance identities, reconciliation pairs, suspense visibility, prefix-overlap audit
• regime versioning, the render-test ritual (date must go INTO get_options()), xlsxwriter data-pack escape hatch

New country playbook: vietnam-accounting (in odoo-domain-playbooks)

Vietnamese accounting compliance verified 07/2026 (with re-verify instruction): TT200→TT99/2025 regime switch with chart + statement deltas (B01/B02/B03/B09), the sổ-kế-toán "quy chế mapping appendix" pattern, the tax calendar (e-invoice NĐ254/TT91, VAT 8% to 31/12/2026, CIT Luật 67/2025, audit NĐ90/2025), l10n_vn* coverage map, and design decisions that survived a real client.

New skill: odoo-worktree

Isolated feature development on a LIVE Odoo dev environment: the container runs the main tree's uncommitted files while a git worktree holds a clean branch cut from production; path-scoped sync only, idempotent post_init_hook adopt-vs-create packaging, and the mandatory clean-install test ritual.

odoo-upgrade fleet hardening

Batch --modules-file verify with load parity, source_sweep.py checklist scanner, anchor_check.py offline view-anchor validator, preflight.py deterministic transforms, references/field-notes-18-19.md (27 verified breakage→fix entries), production scoping (--installed-file, --exclude with dependent closure) — dogfooded on a real 89-module production migration.

Full details in CHANGELOG.md.

v0.14.0 — the local-first evidence layer

The strategy pivot from "a suite of Odoo skills" to the local-first evidence
layer for AI-assisted Odoo delivery. Public architecture is now four stages —
Inspect → Verify → Gate → Report — and the internal "Layer A…L" labels are
retired from user-facing prose (they live on only in changelog cross-references).
The trust language is corrected throughout: this is a CI-bound evidence gate
with an explicit trust boundary, not an "unfakeable" one — CI produces and binds
the evidence; human review stays mandatory for sensitive domains.

Added

• Fast Inspect: context primitives (facts). facts.py emits small instance
  facts for agent context — --kind model|security|views|flows for one model —
  so an agent reads ground truth before it edits, not an exhaustive dump. Every
  payload carries an instance_fingerprint (db uuid, module-graph hash, installed
  count).
• Snapshot cache (cache). snapshot_cache.py is a content-addressed cache
  (keyed by db uuid + module graph + addon file fingerprint + context) so warm
  context is fast inside the agent loop. Invariant: warm/stale cache accelerates
  analysis but never approves a merge — only cold runs are merge-eligible, and the
  provenance rides on every payload (_cache.provenance, _cache.merge_eligible).
• Instance Dossier (dossier, dossier-report). The one-command, read-only
  takeover / pre-sales due-diligence artifact: installed modules (standard/OCA/custom),
  Studio footprint, custom fields, server/automated/scheduled actions, security
  (groups + record rules, multi-company flags), custom view overrides, data volumes,
  and derived upgrade-risk flags. Redacted by default (--redact external, safe
  to share; local keeps sensitive-model schema names on a trusted box). Renders to a
  self-contained HTML report.
• MCP context server (mcp). mcp_server.py is a bounded, read-only MCP stdio
  server exposing six fact tools (odoo_facts_model/security/views/flows,
  odoo_dossier_summary, odoo_native_check) — validated inputs, no arbitrary
  RPC or code execution, redaction always applied, cache provenance on every
  response. claude mcp add odoo-context -- python3 …/mcp_server.py --db <DB>.
• Evidence Artifact v1 (evidence-artifact). evidence_schema.py — a stable,
  public, machine-validatable schema (build/validate) for the evidence a partner
  shows a client: git binding, instance fingerprint, per-check severity + cache
  provenance, decision, human sign-offs, redaction status. Encodes the invariant that
  a warm-cache check can never back an approve. See docs/evidence-artifact.md.
• Severity classes + fail-closed policy in the Gate. deploy_gate.py now
  classifies every finding S0–S4 (S4 = security / multi-company / silent corruption),
  emits findings_detail + severity_summary + per-finding remediation hints, and
  supports an opt-in fail-closed policy (--policy, gate_policy.json, or
  ODOO_AI_FAIL_CLOSED): an S3/S4 finding blocks the merge unless a covering
  human_signoff.json downgrades it to needs_human — never silently to approve.
  Strictly additive; the no-policy path is byte-for-byte the prior behaviour.
• First-class CI/PR integration. A composite GitHub Action
  (.github/actions/odoo-gate), a sticky PR-comment renderer (pr-comment, marker
  <!-- odoo-ai-gate -->), a GitLab recipe, and policy presets (advisory / strict /
  regulated) — see docs/ci-integration.md. The action enforces: block and
  fail-closed S3/S4 findings fail the build; the evidence artifact is uploaded.
• Fixture factories (fixture). fixture_factory.py gives agents valid business
  records for tests — 9 recipes across sale/purchase/stock/account/mrp/multi-company.
  CODE mode emits a paste-ready TransactionCase skeleton; --exec runs the recipe in
  a savepoint and rolls back, validating it against this instance's modules / chart
  of accounts.
• Fit-Gap alpha (fit-gap). fit_gap.py classifies requirements against the live
  instance — native_config / config_plus_gap / module_available_not_installed /
  pattern_known_not_present / no_known_pattern — with heuristic effort bands and
  risk class. Scoped to sale/stock/account. It is decision support for a functional
  consultant, not a replacement: gated items are instance-verified, heuristic items
  need human validation.
• UAT Pack alpha (uat-pack). uat_pack.py turns surface + scenarios (+ optional
  dossier) into role-based UAT scripts a consultant hands to a client — role, data
  setup (suggested fixture recipe), numbered steps, expected result, evidence slot,
  sign-off — as JSON + Markdown (checkbox sign-offs) + optional HTML. Scenarios with no
  entrypoint match are surfaced, never dropped silently.
• Odoo Agent Safety Bench v0 (bench/). A public, reproducible benchmark whose core
  metric is the unsafe-change escape rate — how often an unsafe Odoo change reaches
  PR/UAT/release undetected — not task completion. Ten frozen v0 tasks (≥5
  high-severity: portal sudo() ACL bypass, dropped multi-company record-rule clause,
  stale @api.depends ledger drift, f-string SQL injection, price-include tax error),
  severity-weighted scorer (S0×1 … S4×12), four run modes (alone / +context / +gate /
  both), a living adversarial zoo/, and a RUNBOOK. No single headline score by design.
• Business & governance docs. docs/pilot-package.md, docs/partner-enablement.md,
  docs/governance.md, docs/artifact-governance.md, docs/odoo-online-advisory.md —
  the paid-partner-enablement model around an open standard, artifact-handling rules for
  sensitive dumps, and the path toward neutral (OCA/partner) corpus co-maintenance.

Changed

• Public naming and positioning. README, AGENTS.md, docs/index.html, and 17
  SKILL.md files reworded to the Inspect/Verify/Gate/Report vocabulary; new top-line
  positioning sentence; a new Odoo hosting reality section (self-hosted & Odoo.sh =
  full code gate; Odoo Online = advisory-only, no custom code). The AGENTS.md MCP
  rule now sanctions the bundled bounded MCP context server while still forbidding
  arbitrary-RPC wrappers.
• build_report(bundle_dir, strict=False, policy_path=None) gained an optional
  policy_path; existing callers (evidence bundle, CLI) are unaffected.

v0.13.0 — Layer L: the hardened evidence gate

Layer L — the hardened evidence gate

Raise the bar against "coverage theater": an AI agent writing mock-heavy / vacuous-assert / happy-path tests, or hand-authoring the evidence JSON, to turn the gate green while the real method still throws at runtime.

The fix is architectural — the agent writes code + tests, but a CI runner produces and HMAC-signs the evidence, binds it to the git diff, and deploy_gate.py --strict (policy v2) decides go/no-go. Legacy (non-strict) behavior is unchanged.

Nine new stdlib gate scripts (all unit-tested)

• diff_targets — git+AST → changed {model, method, changed_exec_lines} (the anchor everything binds to)
• test_quality_gate — blocks vacuous asserts, mocked model-under-test, swallowed UserError, broad assertRaises, and tests not imported in tests/__init__
• changed_coverage_gate — the changed lines must run under a real test context
• runtime_path_probe — the changed method must have executed through the live registry MRO (kills mocks/stubs/wrong-layer)
• scenario_satisfaction — risk scenarios enforced (required − satisfied == ∅)
• mutation_smoke — a surviving mutant on a changed line = vacuous assertions → block
• red_green_replay — CI re-runs test-first (base fails with a legit red, head passes same identities)
• provenance — HMAC attestation with per-artifact content + commit binding
• runtime_observer — CI-owned, fail-closed tracer with permanent audit-hook tamper detection

Trust boundary — honest posture

This is a strong hardening gate, not eradication. It was designed and hardened across four adversarial Oracle reviews; every found bypass (forged/replayed provenance, empty head_sha, normal-risk weak tests, disable/restore of the tracer) is fixed and regression-tested. The decisive runtime facts are still measured inside the untrusted test process, so --strict = approve only fully holds with the OS/CI isolation documented in references/ci-trusted-observer.md. Human review stays mandatory for accounting/stock/payment/hr, security, and controllers.

Also in this release: odoo-user-guide (skill #20) — instance-verified end-user guide generation.

Both plugins (Claude Code + Codex) bumped to 0.13.0. Full test suite: 758 passed.

v0.12.1 — html-report tech hero

Changed

• html-report hero restyle — the report header is no longer a flat black slab. assets/report.css now renders a "tech" hero: a deep warm-black gradient, two brand-tinted corner glows (pink + yellow), a faint blueprint grid that fades toward the bottom, and an accent hairline along the bottom edge. Pure CSS, still fully self-contained (no images/CDN), and unchanged in light/dark/print.

New reports pick this up automatically; previously inlined reports need a re-inline.

v0.12.0

Full Changelog: v0.11.0...v0.12.0

v0.11.0 — HTML reports + odoo-ai viz

✨ Highlights

html-report skill

Render any analysis, audit, RCA, or review as one consistent, self-contained HTML page — bold "Magazine" theme, CSS inlined (no CDN, no server), auto-opened. Compose from shared blocks instead of hand-rolling a design every time.

Dependency-free chart blocks (pure CSS, no JS): MRO/super() ladder, parent/child tree, bar chart, security matrix.

odoo-ai viz

Turn introspection JSON into that layout automatically — LOCAL (no DB), pure stdlib, reuses the html-report stylesheet:

Layer	Chart
A (brief)	MRO/super() ladder (marks returns_before_super, core/enterprise addons)
C (metadata)	menu tree + reports
D (trace)	SQL-hotspot bars + most-invoked + call order
G (security)	effective-access matrix + record rules + restricted fields
K (ESG)	model→model edge bars + Mermaid graph

odoo-ai --db DB all sale.order --record-id 1 --method action_confirm
odoo-ai --db DB esg sale.order
odoo-ai viz /tmp/odoo-ai/sale_order      # → report.html (+ opens)

Presentation only — distinct from odoo-reports (Odoo QWeb business documents). Nothing leaves the box.

Quality

• tests/test_viz.py (14 tests); full unit suite 445 passing.
• CI green: GitGuardian, Layer I gates, smoke 17/18/19, example, unit/test.

Full changelog: v0.10.0...v0.11.0

v0.10.0 — Layer K: discovery, sampling, eval & enforcement

Layer K answers the cold-start problem the codebase analysis surfaced: the suite was best-in-class at micro ground-truth (a model/method/field you already named) but had no answer to "where do I start?", no measurement of hallucination reduction, and no way to stop the agent skipping the tools. An independent oracle red-team refined the fix — don't build a static process atlas (it goes stale → makes the agent more confidently wrong); make process understanding emerge from sampled traces, and make the tools impossible to skip.

New odoo-ai commands (now 30)

• surface — rank the live entrypoint surface (object buttons, server actions, crons, automations, reports, and a new @http.route scanner) so the agent starts from real roots, not a guessed method. Emits top_trace_seeds.
• esg — sample the top entrypoints' real traces (rolled back) into a cross-model / cross-app flow skeleton. Process understanding that emerges from traces, never a static map. External-effect methods (send/mail/payment/print/unlink/…) are never auto-fired.
• eval — score the gate's detection_rate / truth_recall on a benchmark of the classic LLM Odoo mistakes (account.invoice, customer_id, fields_view_get, a 'customer' selection). A regression signal, not a vibe.
• gate-edit (+ PreToolUse hook) — no-introspect-no-edit: block an edit to an Odoo model until it's introspected + passes the validator. Optional ODOO_AI_GATE_STRICT=1 fail-closed mode.

Tested for real

Live Odoo 17 / 18 / 19 via the new docker-compose.e2e.yml: integration smoke 91/91 on each; eval detection_rate 1.0 / truth_recall 1.0 on all three. 515+ unit tests; claude plugin validate passes. Hardened via a pre-merge oracle audit (findings verified in code; false positives dismissed).

Also

• Fixed a scan-secrets false-positive that flagged file paths as base64 secrets.
• Deepened references (odoo-review, odoo-owl, security/perf/data); corrected two fabricated Layer-G field names in high-risk-playbooks.md.

Full diff: v0.9.1...v0.10.0

v0.9.1 — Hardening (trusted gate)

No-new-features hardening release that makes the v0.9.0 Layer-I gates actually trustworthy.

Driven by an iterative independent oracle review loop (ChatGPT GPT-5.5 Pro) run to convergence. Round 1 found 4 release-blockers in public v0.9.0; successive rounds adversarially fuzzed the deploy-gate approve path until no reachable wrong approve, crash, or output-contract violation remained. Final verdict: "No remaining must-fix — v0.9.1 is sound to tag."

What changed

• Evidence/CLI contract — deploy_gate resolves artifacts by pattern (reads the CLI's real patch.validate.json forms); new global odoo-ai --json.
• CI workflow — real JSON paths; typed report-shape checks (a missing/invalid report renders needs-human, not a false ✅ clean); contents: read; and a final Enforce-gate step that fails the job on block / secret / blocking.
• Approve-path hardened against attacker-/bug-shaped evidence JSON:
  • strict load: reject duplicate keys, NaN/Infinity, overflow→inf; emit allow_nan=False
  • fully typed artifact schemas (non-bool int counts ≥ 0, real lists, enums, model/error field types)
  • duplicate artifacts merge to the worst case (a clean dupe can't hide a blocker)
  • scan_secrets is core-required; manifest shape fully validated (incl. \→/ + path-based sensitive-domain detection)
  • a required human sign-off can never be approve
• Redaction — provider-secret masking (AWS/GitHub/Stripe/Slack/Google/PEM/JWT) + nested sensitive-record PII; scanner coverage matches the redactor.
• Migration safety — upgrade_check rename-vs-drop similarity threshold; env_diff symmetric drift + unknown-count handling; patch_validator AST SQL/create() checks; claim_verify probe-error semantics; doc_index provenance.

Quality

• 375 unit tests + 80 pure-function tests green
• Integration smoke 68/68 on live Odoo 18

Full detail in CHANGELOG.md [0.9.1].

v0.9.0 — The verification gate

Static indexes suggest; odoo-ai-skills verifies — against your running Odoo instance.

This release repositions the suite as the local-first verification & deploy gate for AI-written Odoo changes, and ships the enforcement layer that makes it real. It bundles the previously-unreleased v0.8.0 (Layer I) plus the v0.9.0 verification-gate work.

Highlights

• Layer I — enforcement gates: risk-based scenario test generator, dev↔prod environment parity/drift detector, a static Odoo anti-pattern validator, enforced privacy redaction, an upgrade/migration harness (rename-vs-drop), and a deploy-gate (approve / needs-human / block).
• odoo-ai evidence — a one-command PR-comment evidence bundle (the flagship artifact).
• odoo-ai verify-claims — a bring-your-own-index adapter: verify any external index/agent claim against your instance (confirmed / contradicted / needs-shell).
• Layer J — local Odoo docs index (odoo-ai docs-build / docs): a TF-IDF index of the official developer docs, built locally; results carry canonical odoo.com URLs. Never vendored (clean CC-BY-SA).
• native-check probe grammar expanded 4 → 12 kinds (xmlid · action · group · cron · sequence · selection-value · mixin · edition …).
• Four gates are pure & local (no instance) — ideal for CI.

Tested against real Odoo

• Integration smoke runs every layer + gate against live Odoo 17 / 18 / 19 (68/68 checks).
• Validated end-to-end against a real 390-module Enterprise instance (Studio fields, custom addons, multi-company) — read-only layers, the gates, and a rolled-back runtime trace/state.

Update

claude plugin update odoo-ai-skills@odoo-ai

Full notes: see CHANGELOG.md (0.8.0 + 0.9.0).