reactive-agents-ts

Agentic harness diagnostic + improvement loop. Probes the framework with real model runs, uses the rax-diagnose CLI to root-cause failures from structured trace data, ships ONE coordinated architectural fix, verifies via before/after diff, commits with empirical evidence. Use at the start of any harness improvement session — replaces ad-hoc grep + log-spelunking with a deterministic feedback loop.

Use when the architecture may have drifted from documentation, packages have grown complex, dead code or disabled systems are suspected, or before planning a major refactor — scoped to the reactive-agents-ts 22-package monorepo.

Reactive Agents framework architecture — layer stack, dependency graph, build order, and package structure. Use when planning work, understanding package relationships, or determining build dependencies.

Use when analyzing the Reactive Agents codebase for architectural improvements, abstraction opportunities, composability gaps, or Effect-TS engineering quality — before proposing refactors, during design reviews, or when codebase complexity is growing.

LLMService API contract — the correct signatures for complete(), stream(), embed(), and response types. Use when calling LLMService from any layer, writing reasoning strategies, or building LLM-dependent features.

LLM provider streaming patterns and per-provider quirks. Use when adding a new provider, implementing adapter hooks, or debugging streaming tool call behavior in packages/llm-provider.

Configure a ReactiveAgentBuilder with the correct layer composition for any agent use case.

Orient to the Reactive Agents framework, understand the builder API shape, and select the right capability skills for your task.

Enable and configure the sandboxed shell execution tool with command allowlists, Docker isolation, and audit logging for agents that run terminal commands.

Create custom tools with defineTool() or tool(), register them with the agent, and configure required-tools gates and per-tool call budgets.

Expose agents as A2A JSON-RPC servers discoverable via Agent Cards, and connect agents to remote A2A agents using the client discovery and capability-matching APIs.

Enable prompt injection detection, PII masking, behavioral contracts, kill switch controls, and audit logging for safe production deployments.

Control agent autonomy with durable human-in-the-loop approval gates, agent-initiated user-input pauses, and runtime pause/resume/stop controls.

Compose multiple agents as callable tools, spawn dynamic sub-agents at runtime, and wire remote A2A agents into a coordinated pipeline.

Configure per-provider behavior, understand streaming quirks, and use the 5-hook adapter system for optimal performance across LLM providers.

Full recipe for a 3-agent pipeline (researcher → writer → reviewer) coordinated by a lead orchestrator agent using withAgentTool().

Full recipe for a production-ready SaaS agent with guardrails, per-user cost isolation, rate limiting, A2A exposure, audit logging, and graceful error handling.

Coordinate cross-cutting changes, incremental features, and multi-package modifications across the Reactive Agents monorepo. Defines team structure, task assignment, parallelization strategy, and inter-package dependency gates.

Add a new package to the Reactive Agents monorepo. Covers scaffolding, package.json, tsconfig, layer wiring, and index exports. Use when creating a net-new @reactive-agents/* package.

Audit project memory (.agents/MEMORY.md and ~/.claude/.../memory/MEMORY.md) against current code and remove stale claims to prevent bad signals in future sessions

Complete feature development workflow for Reactive Agents. Orchestrates the correct sequence of skills for any feature type. Use at the start of any non-trivial implementation task to route to the right skills and follow the right order.

Review code changes for Effect-TS pattern compliance in the Reactive Agents framework. Use when reviewing PRs, completed packages, or any code changes to enforce project conventions.

Validate a completed package against its spec. Checks patterns, types, exports, dependencies, and test coverage after building a package.

Debug agent reasoning failures using the composable kernel phase map. Maps symptoms to specific files and grep commands. Use when an agent is not calling tools, looping, producing wrong output, or failing silently.

Add new behavior to the composable kernel — new Phase, Guard, MetaTool, or custom kernel variant. Use when extending agent reasoning, adding tool call filtering, or building a custom kernel for a new strategy.

Use when ready to attack the GitHub issue backlog with discipline. Scans open issues, bundles related work into an efficient execution plan, executes the bundle with verification, then closes issues + writes a retrospective that includes self-improvement notes for this skill. Trigger phrases — "execute backlog", "work the backlog", "knock down P1 issues", "ship a bundle", "/execute-backlog".

Compose a MissionBrief YAML block to prepend to any Agent dispatch during the team-ownership dev-contract pilot (2026-05-23 → 2026-06-15). Use BEFORE spawning kernel-warden or any future warden. Fails if missing end-state, why, authority-bounds, or success-criteria.

Mandatory output contract for warden agents during the team-ownership dev-contract pilot. Warden agents append a YAML upward-report block as the last content of their response. Parent (main thread) parses and routes via dispatcher FSM. Use when you are a warden agent finishing a task, OR when you are the parent consuming a warden's output.

Use when the codebase may have accumulated bugs, failing tests, type errors, dead code, inefficiencies, or drift from known quality standards — before a release, after a large feature merge, or on a recurring maintenance cadence. Also triggers when build is red, `bun test` has unexpected failures, or TypeScript errors spiked after refactors.

Use when cutting, tagging, or publishing a new Reactive Agents version, or when a release/publish run fails and needs resuming. Covers the tag-driven lockstep flow (scripts/release.ts + .github/workflows/publish.yml).

Synchronize all documentation (Starlight docs, README, AGENTS, skills, memory) after code changes. Use after completing a feature, fixing bugs, or changing public APIs.

Set per-request, per-session, daily, and monthly spend limits, configure rate limiting and circuit breakers, and isolate costs per user or tenant.

Configure the 4-layer memory system with SQLite/FTS5/vec storage for persistent agent knowledge that survives sessions.

Enable output verification (hallucination detection, semantic entropy, self-consistency), add post-run verification steps, and run LLM-scored evals across 5 quality dimensions.

Use when working in a monorepo or large codebase and session token budget is constrained; baseline utilities (grep, cat, git, find) waste 60-90% of tokens vs. optimized alternatives

Build always-on agents with heartbeats, cron scheduling, webhook triggers, and a persistent policy engine using the Gateway layer.

Generate structured session recap and auto-extract high-confidence learnings into project memory

Full recipe for a web research agent with memory, semantic search, hallucination verification, and source-cited synthesis.

Connect agents to MCP servers using stdio or HTTP transport, with automatic Docker lifecycle management and transport auto-detection.

Manage context pressure, configure message windowing, and use checkpoint tools to preserve critical findings across context compaction.