Status & changes

Account status now comes from live usage data. The TUI status and approval surfaces were tightened, and replay-backed checks were added around status behavior.

The visible status line stops drifting from live account state, and replay-backed checks reduce quiet UI regressions.

Truer status only. The product claim is not broader because of that.

• Live account status source
• Status surface truth walkthrough

Triage and exception handling moved onto platform types and ports, then surfaced through first-class views such as exceptions list, explain, and health.

Exception debt becomes visible in one place instead of hiding in scattered YAML.

Visibility improved. Exception debt still exists and still needs judgment.

• Sadave exceptions surface core
• Exceptions inventory schema
• Exceptions surface spec

Introduced `FailureV1` and schema-backed failure/report artifacts so runtime and tool-run failures land in typed records instead of ad-hoc strings.

Stops and tool failures become easier to trace, share, and compare.

Better records, not automatically better policy.

• Platform FailureV1 spec
• Platform failure schema v1
• Subprocess run report v2 schema

Canonicalized config discovery and apply-patch hook wiring, enforced repo-tree invariants on any write, and hardened hook reports to emit stable reason and rule identifiers.

Unsafe repository mutations are blocked earlier and with clearer explanations.

Fast pre-write guardrail only. Broader or heavier checks still belong later.

• Repo-local hook language pack config
• Hook rust-check report mapping

Added deterministic budgets to the Rust crate-graph policy module and wired them into the strict code-gates path.

Architecture weight stops depending only on reviewer memory.

Budget numbers are policy choices.

• Code gates: crate graph budgets module
• Sadave pack: Rust crate graph policy (budgets + layering)

Migrated Sadave infrastructure adapters for state storage, artifact store, and language packs into shared platform adapters.

Shared retained outputs and state handling stop forking across subsystems.

Ownership move only. Acceptance behavior changes only when rules change.

• Platform adapter: SQLite state store (Sadave infra)
• Platform adapter: language packs filesystem store

Canonized the code-gates driver and capability resolution so entrypoints run the same module set and emit stable metadata.

Acceptance decisions stop depending on ad-hoc entrypoint wiring.

Driver unification only. The rule set stays the same.

• Code gates driver (platform_adapter_code_gates_std)
• Code gates capabilities (platform_adapter_code_gates_std)

Hook response parsing now denies unknown fields instead of silently accepting drift.

The enforcement surface either matches the contract or fails closed with a reviewable error.

Contract hardening only.

• fs.write.pre hook response parsing (deny unknown fields)

Refactored the router path to avoid constructing a nested Tokio runtime.

One class of runtime edge cases is removed, and runs stay calmer under stress.

Stability fix only.

• Router path: avoid nested Tokio runtime

The OpenAI Responses adapter now tolerates unknown upstream wire fields while keeping parsing deterministic for the known schema.

Upstream wire drift is less likely to break the boundary.

Boundary hardening only.

• OpenAI Responses adapter: wire parsing (forward-compat)

Canonicalized hook configuration under `.tsqoba/musha/**` and tightened repo-tree invariants against legacy runtime roots.

Runtime state stays quarantined and discoverable in one place.

Repo-shape rule only. It is not a security boundary.

• Musha hook config (language pack hooks, repo-local)
• Repo tree invariant: forbidden runtime roots

Enabled walkthrough budget invariants and added an anti-snapshot rule to keep fixtures and golden diffs out of production code.

Replay materials stay lightweight enough to run, inspect, and ship without quiet fixture bloat.

Budget and hygiene rules only.

• Sadave pack: repo tree invariants (runtime roots + budgets)
• Rust rule: RUST-ANTI-SNAPSHOT-001 (no snapshots in prod code)

Wired the Rust pre-write hook to run the platform code gates engine in-process against an overlay filesystem, emitting a typed hook report.

Fast guardrails run at the moment of change without shelling out into uncontrolled subprocesses.

Quick preflight only. Stricter later checks still matter.

• Tsqoba hook adapter: in-process code gates (QuickFile)
• Tsqoba hook report: in-process code gates mapping

Migrated the typed external tool runner interface into platform ports, with a standard adapter that emits schema-backed tool run reports.

Subprocess execution moves onto one visible path for budgets, output capture, and retained artifacts.

Execution substrate change only.

• Port: platform_typed_tool_runner_ports
• Adapter: typed_tool_runner_std