v3.32.28

# Ruflo v3.32.28: Agents That Know the Whole System

Ruflo has grown into a large agentic runtime, but its old MCP guidance catalog
only knew about 61 of the 353 tools available in a fully equipped process. That
made powerful features hard to discover and made agents more likely to guess
at stale tool names.

v3.32.28 introduces the Ruflo Capability Brain: a live, machine-readable map of
the MCP registry, CLI commands, agents, skills, packages, plugins, authority
boundaries, risk, and the end-to-end implementation loop. Agents can now ask
Ruflo which capabilities fit a task and automatically choose from tools that
are actually registered in the current process.

## What you can use it for

- Discover every MCP tool registered in your running Ruflo server.
- Route a task to suitable tools, agents, skills, and a swarm topology.
- Find capabilities across `.claude`, `.agents`, installed packages, and Ruflo
  plugins.
- Keep optional or remote integrations honest: registered, configured,
  reachable, healthy, and authorized are reported as different facts.
- Guide autonomous development through recall, inspection, planning,
  implementation, testing, validation, benchmarking, optimization, evidence,
  handoff, and authorized publication.
- Distinguish policy authorization, exclusive work claims, content-safety
  evidence, memory learning, consensus, and release authority.
- Route Cognitum identity through the implemented PKCE/OOB profile lifecycle,
  while reporting RFC 8628 polling and server-side logout revocation as
  unavailable instead of guessing.

## Try the Capability Brain

In Codex, Claude Code, or another MCP client, ask the agent:

> Use Ruflo `guidance_brain` to recommend the best workflow for implementing
> this task, then follow the returned implementation loop.

Or call the MCP tool directly:

```json
{
  "name": "guidance_brain",
  "arguments": {
    "mode": "recommend",
    "task": "Implement a secure API change with concurrent agents, tests, benchmarks, and a release"
  }
}
```

Useful modes:

```json
{"name":"guidance_brain","arguments":{"mode":"overview"}}
{"name":"guidance_brain","arguments":{"mode":"capabilities","domain":"memory-knowledge"}}
{"name":"guidance_brain","arguments":{"mode":"coverage"}}
{"name":"guidance_brain","arguments":{"mode":"ecosystem"}}
{"name":"guidance_brain","arguments":{"mode":"implementation-loop"}}
```

The existing `guidance_capabilities`, `guidance_recommend`,
`guidance_discover`, `guidance_workflow`, and `guidance_quickref` tools remain
compatible. Their old string catalog is now labeled compatibility-only, and
stale references are never presented as live recommendations.

## The implementation loop

Generated Codex `AGENTS.md` guidance and capability recommendations now use one
complete loop:

1. Recall relevant memory and ADR constraints.
2. Inspect source, runtime, dependencies, policy, and health.
3. Route to the smallest capable topology and tool set.
4. Plan acceptance criteria, safety, ownership, and validation.
5. Execute in isolated scopes; Ruflo coordinates while the coding agent works.
6. Test focused, regression, and failure paths.
7. Validate types, security, policy, compatibility, and artifacts.
8. Benchmark a source-bound candidate against a source-bound baseline.
9. Optimize measured bottlenecks without weakening safety.
10. Bind claims and evidence to exact source/build inputs.
11. Reconcile concurrent handoffs and disclose limitations.
12. Publish only through a separately authorized release gate.

Learning and optimization remain proposal/evidence capabilities. They cannot
promote themselves or expand network, secrets, spending, concurrency, or
policy authority.

## Federation and Cognitum foundations

This release also adds opt-in foundations for policy-governed federation and
Cognitum product actions:

- Upgraded federation peers advertise recursive JCS/Ed25519 signatures by
  default. JCS is negotiated only when the join includes a signature-verified
  peer manifest; endpoint-only joins stay untrusted.
- Legacy federation signatures are restricted to `heartbeat` and
  `status-broadcast`; consequential legacy messages are rejected on ingress
  and fail closed on egress to legacy-only peers.
- Inbound federation authorization runs after signature verification and
  before acceptance, replay marking, or event delivery.
- The Security SDK adds a closed 31-action product vocabulary for the
  Cognitum dashboard, Meta-LLM, Comms, Cog Studio, RuView, and validated
  learning.
- Product envelopes enforce audience, tenant, freshness, capability, policy,
  Ed25519 signature, action-specific obligations, and atomic replay-store
  hooks.
- RuView exports are constrained to registered, privacy-minimized semantic
  observations rather than raw sensor payloads.

## Concurrent development foundations

The Codex package now exposes:

- content-addressed Git-visible source-state capture;
- separately declared and recomputable build-input/toolchain evidence;
- portable path/case ambiguity refusal;
- in-memory reference implementations for fenced leases, acknowledged inbox
  semantics, and content-addressed run receipts.

These references are deliberately observe-only, unsigned, non-persistent, and
single-process. They help adapter authors test semantics; they are not
distributed release authorities.

## Install or upgrade

```bash
npm install --global ruflo@3.32.28
ruflo doctor
```

Or run it without a global install:

```bash
npx ruflo@3.32.28 --help
```

Package train:

- `ruflo@3.32.28`
- `claude-flow@3.32.28`
- `@claude-flow/cli@3.32.28`
- `@claude-flow/codex@3.0.3`
- `@claude-flow/security@3.0.0-alpha.14`
- `@claude-flow/plugin-agent-federation@1.0.0-alpha.17`

## Compatibility

- Existing guidance MCP tools remain available.
- Existing projects stay in their current policy compatibility mode.
- JCS federation signing is negotiated; no downgrade occurs after a failed JCS
  verification.
- Older installations continue local workflows when optional packages are
  absent.
- The new Codex harness and Cognitum product-plane APIs are additive exports.

## Local validation and benchmarks

Validated on Node.js 22/Linux:

- Capability Brain: all 353 observed live tools assigned exactly once; zero
  duplicate or fallback classifications.
- CLI focused brain/guardrail tests: 12 passing.
- Codex: 229 tests passing.
- Security: 559 tests passing.
- Federation: 638 tests passing.
- Capability Brain build for a 353-tool registry: p99 about 0.44 ms in the
  latest local run; recommendation p99 about 0.04 ms.
- 1.5 KiB federation JCS canonicalization: p50 8.47 µs, p99 8.83 µs,
  approximately 118,087 operations/second.
- 1.0 KiB signed Cognitum action verification: p50 71.97 µs, p99 81.93 µs,
  approximately 13,894 verifications/second.
- Source-state capture over a clean 200-file Git fixture averaged 15.77 ms;
  the dirty-patch plus 25-file manifest fixture averaged 27.09 ms.

These are local microbenchmarks, not cross-platform service SLOs.

## Important limitations

These APIs are an opt-in foundation, not a declaration that distributed claim
federation is production-ready. Persistent control-plane leases, durable
inbox/outbox storage, signed receipt ledgers, release-decision composition,
cross-service identity links, and Cognitum production adapters still require
deployment-specific implementation and acceptance testing.

A lease, signature, claim, score, memory, consensus result, or passing test is
evidence. None grants product or release authority by itself.

## Architecture

- ADR-325: zero-trust claim federation and work ownership
- ADR-326: Cognitum product-plane federation profile
- ADR-327: federated concurrent development harness
- ADR-328: Cognitum-assisted agent learning
- ADR-329: Ruflo Capability Brain for MCP guidance