self-healing-orchestrator
Proposes patches for F2 (local-logic) and F3 (local-design) failures. NEVER applies without user approval. Confidence ≥0.7 to propose; below that, escalates raw findings. Counts toward replan_budget. Per-task: max 1; per-session: max 5.
Best use case
self-healing-orchestrator is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Proposes patches for F2 (local-logic) and F3 (local-design) failures. NEVER applies without user approval. Confidence ≥0.7 to propose; below that, escalates raw findings. Counts toward replan_budget. Per-task: max 1; per-session: max 5.
Teams using self-healing-orchestrator should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/self-healing-orchestrator/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How self-healing-orchestrator Compares
| Feature / Agent | self-healing-orchestrator | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Proposes patches for F2 (local-logic) and F3 (local-design) failures. NEVER applies without user approval. Confidence ≥0.7 to propose; below that, escalates raw findings. Counts toward replan_budget. Per-task: max 1; per-session: max 5.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
> **AI-consumed reference.** Optimized for Claude to read during execution.
> Human-readable explanation: see [docs/architecture/HIERARCHICAL_PLANNING.md](../../../docs/architecture/HIERARCHICAL_PLANNING.md)
> or [docs/getting-started/](../../../docs/getting-started/) depending on topic.
# Self-Healing Orchestrator
**STATUS — v3.7.0-rc.1.** Per-spec safety gates strictly enforced.
## Core Principle
**Self-healing PROPOSES; the user APPLIES.** A proposal goes through the same approval gate as a manual replan — there is no autonomous patch. If you find this skill applying patches without a user yes, that's a bug.
## Hard constraints (per spec §22.1)
```toon
constraints[6]{rule,enforcement}:
"ONLY F2 (local-logic) or F3 (local-design)","Refuse if classifier returns F1/F4/F5/F6 — those need different paths"
"ONLY proposes; NEVER applies","Output is always a proposal artifact; user runs /aura-frog:heal accept <id> to apply"
"Confidence < 0.7 → don't propose","Surface raw findings only; user decides if a fix is even reachable"
"Counts toward replan_budget","Same node-level budget enforcement as replanner (per replan-thresholds.md)"
"Max 1 self-heal per task","Once a task accepts a self-heal patch, no further auto-proposals for that task"
"Session cap: 5 proposals total","Anti-fatigue + anti-loop; after 5, defer to manual /aura-frog:plan-replan"
```
## Disable mechanisms (per spec §22.3, §31.3)
- **Per-session:** `/aura-frog:heal disable` — sets `.claude/logs/.self-heal-disabled` flag
- **Permanent:** `AF_SELF_HEAL_DISABLED=true` in `.envrc`
- Hook integration ignores any proposal when disabled
## Flow (per spec §22.2)
```
Failure detected (F2 or F3)
↓
self-healing-orchestrator activated (only if budget remaining)
↓
Step 1: Parse error log → error class, library, line numbers
Step 2: Query context7 for known library patterns (NOT random web sources)
Step 3: Cross-reference permanent_memory.md "Gotchas discovered"
Step 4: Generate PROPOSED patch as draft (diff format, not applied)
Step 5: Score confidence: refuse if < 0.7
Step 6: Master-planner presents user prompt with diff + reasoning + confidence
Step 7: On user yes → apply as a NEW T4 task with its own approval flow
Step 8: On user no → log as `event: self_heal_declined`, increment session counter
```
## Cross-check sources (allowlist)
```toon
allowed_sources[3]{source,why}:
context7 MCP,"Library documentation; trusted technical reference"
permanent_memory.md,"Project's own learned wisdom; trust:file"
recent traces (.claude/plans/traces/),"Same-project context for the failure"
```
**Forbidden sources:** Stack Overflow, blog posts, web search results — too noisy, too easy to hallucinate from.
## Output schema (proposal artifact)
```yaml
proposal_id: HEAL-<TASK_ID>-<NNN>
task_id: TASK-00101
classification: F3
confidence: 0.84
reasoning: "Test fails because async/await missing on JWT issuance call. Library docs (context7) confirm the API is async. Memory (DEC-001) decided on httpOnly cookie storage (unaffected)."
patch:
- file: src/auth/jwt.ts
start_line: 42
end_line: 42
before: "const token = issueToken(claims);"
after: "const token = await issueToken(claims);"
acceptance_test: "jest tests/auth.test.ts → tests/auth.test.ts::should_issue_token"
risks:
- "Caller chain may need awaiting too — check src/auth/middleware.ts callers"
- "Latency increase ~10ms (negligible)"
budget_decrement: 1
session_proposal_count: 2 of 5
```
The proposal lives at `.claude/plans/proposals/HEAL-<TASK_ID>-<NNN>.yaml` until accepted/declined.
## Anti-patterns (each is a hard refusal)
- **Auto-applying a high-confidence proposal** — confidence is just signal; user approval is non-negotiable
- **Proposing for F4/F5** — wrong scope; F4 needs Story replan, F5 needs Feature replan, both via replanner
- **Pulling fixes from random web search** — hallucination risk; cite only context7 + permanent_memory + traces
- **Bypassing budget** — same as replanner; if budget exhausted, escalate
- **Emitting a proposal with confidence ≥0.7 but evidence < confidence** — sanity check: if you can't cite ≥2 grounded sources, drop confidence below 0.7
## Tie-Ins
- **Spec:** §22 (self-healing), §15.1 (F-class boundaries), §22.3 (disable), §31.3 (env vars)
- **Skill:** `failure-classifier` — sole producer of F2/F3 inputs
- **Agent:** `master-planner` — sole consumer of proposals (presents to user)
- **Agent:** `replanner` — alternative path for F4/F5 (this skill never trespasses)
- **Rule:** `rules/workflow/replan-thresholds.md` — shared budget semantics
- **Rule:** `rules/workflow/checkpoint-discipline.md` — pre-mutation snapshot before applying accepted proposals
- **Command:** `/aura-frog:heal diagnose|status|disable|accept`
- **MCP:** `context7` — sole external knowledge source (rate-limited via mcp-call-gate)
- **File:** `.claude/plans/proposals/HEAL-*.yaml` — proposal artifacts
- **File:** `.claude/memory/permanent_memory.md` — Gotchas / Anti-patterns sections cross-referencedRelated Skills
self-improve
Apply learned improvements to the Aura Frog plugin. Updates rules, adjusts agent routing, modifies workflow configurations, and generates knowledge base entries.
self-consistency
Generate N independent reasoning paths and vote on the answer. Use for architectural trade-offs, ambiguous design decisions, or when single-path reasoning risks locking onto the first plausible answer. Paper: Wang et al. 2022.
run-orchestrator
Execute 5-phase TDD workflow for complex features. Use when the user invokes /run, asks to build/create/implement a feature, requests a complex multi-file change, or types 'fasttrack:'. Enforces phase gates, sprint contracts, and builder!=reviewer discipline.
plan-orchestrator
Route hierarchical-planning intents to the correct backing script. Use when the user invokes /aura-frog:plan (with or without subcommand), mentions plan verbs (expand/next/replan/promote/archive/freeze/thaw/undo/status/conflicts), or types a plan-vocabulary bare word with .claude/plans/active.json present. Owns verb table, intent classifier, and 3-stage routing pipeline.
vue-expert
Vue 3 gotchas and decision criteria. Covers reactivity traps, Composition API pitfalls, and Pinia patterns.
typescript-expert
TypeScript gotchas and decision criteria covering nullish coalescing pitfalls (|| vs ??), strict tsconfig settings (noUncheckedIndexedAccess, exactOptionalPropertyTypes), type guard patterns, discriminated unions, and as const vs enum. Use when writing TypeScript, configuring tsconfig, implementing type guards, or debugging null/undefined errors.
tree-of-thoughts
Branch, evaluate, prune, expand — structured search over solution space. Use for architecture with multi-step decisions, refactor planning, or complex debug hypothesis trees. Paper: Yao et al. 2023.
test-writer
Write tests with TDD following structured patterns. Ensures consistent AAA structure, proper coverage targets, and framework-specific conventions. Without this skill, tests lack consistent naming, miss coverage targets, and skip anti-pattern checks.
stitch-design
Generate UI designs using Google Stitch AI with optimized prompts
session-continuation
Manage workflow state across sessions with handoff and resume. TOON-based state persistence.
sequential-thinking
Structured thinking process for complex analysis. Supports revision, branching, and dynamic adjustment.
scalable-thinking
Design for scale while keeping implementation simple (KISS).