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

$curl -o ~/.claude/skills/self-healing-orchestrator/SKILL.md --create-dirs "https://raw.githubusercontent.com/nguyenthienthanh/aura-frog/main/aura-frog/skills/self-healing-orchestrator/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/self-healing-orchestrator/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How self-healing-orchestrator Compares

Feature / Agentself-healing-orchestratorStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/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-referenced

Related Skills

self-improve

14
from nguyenthienthanh/aura-frog

Apply learned improvements to the Aura Frog plugin. Updates rules, adjusts agent routing, modifies workflow configurations, and generates knowledge base entries.

self-consistency

14
from nguyenthienthanh/aura-frog

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

14
from nguyenthienthanh/aura-frog

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

14
from nguyenthienthanh/aura-frog

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

14
from nguyenthienthanh/aura-frog

Vue 3 gotchas and decision criteria. Covers reactivity traps, Composition API pitfalls, and Pinia patterns.

typescript-expert

14
from nguyenthienthanh/aura-frog

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

14
from nguyenthienthanh/aura-frog

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

14
from nguyenthienthanh/aura-frog

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

14
from nguyenthienthanh/aura-frog

Generate UI designs using Google Stitch AI with optimized prompts

session-continuation

14
from nguyenthienthanh/aura-frog

Manage workflow state across sessions with handoff and resume. TOON-based state persistence.

sequential-thinking

14
from nguyenthienthanh/aura-frog

Structured thinking process for complex analysis. Supports revision, branching, and dynamic adjustment.

scalable-thinking

14
from nguyenthienthanh/aura-frog

Design for scale while keeping implementation simple (KISS).