error-recovery

Diagnose and repair TypeScript development failures across compile, runtime, build, and test phases.

39|6|Updated Jan 12, 2026
One-click install
npx skills add https://github.com/devsforge/orchestrator --skill error-recovery-devsforge
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: error-recovery
Source: https://github.com/devsforge/orchestrator/tree/main/skills/error-recovery
Command: npx skills add https://github.com/devsforge/orchestrator --skill error-recovery-devsforge

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you quickly diagnose failures and recover when TypeScript, build, runtime, or test errors derail an implementation, reducing repeated debugging cycles.

Core Features & Use Cases

  • Error classification: Categorizes Syntax, TypeScript (e.g., TS2322/TS2307), runtime (e.g., ReferenceError/TypeError), build (e.g., module/config/OOM), and test failures (e.g., assertions, timeouts, mock issues) to choose the correct fix path.
  • Recovery strategies: Applies targeted approaches such as auto-fixing lint/format, repairing dependencies, correcting type/null issues, resolving runtime problems with safer access patterns, and fixing test logic or async timing.
  • Verification and retry protocol: Uses a disciplined loop to apply minimal changes, verify with tsc/eslint/npm test, and increment retries up to a maximum before escalating.

Quick Start

Use the error-recovery guidance to classify the error type and apply the smallest targeted fix, then re-run tsc and tests to confirm the recovery.

Frequently Asked Questions about error-recovery

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I fix TypeScript build failures caused by type mismatches and missing modules?

TypeScript build failures from type mismatches or missing modules are fixed by classifying the specific TS error, applying minimal targeted repairs to dependencies or types, and verifying the recovery with tsc. This self-healing approach reduces repeated debugging cycles.

What is the best way to resolve flaky test failures and async timing issues in a TypeScript project?

Resolving flaky test failures and async timing issues involves categorizing the test error, correcting the underlying test logic or mock configuration, and running a verification loop with npm test. The process applies minimal changes and retries up to three times before escalating.

Why does my ESLint configuration cause runtime errors, and how can I auto-fix them?

ESLint configuration causing runtime errors can be auto-fixed by classifying the runtime failure, selecting targeted lint and format corrections, and applying safer access patterns. The workflow verifies the applied minimal changes with ESLint and tsc to ensure full recovery.

Can I use an automated error recovery workflow for compile-time and runtime errors in TypeScript?

Automated error recovery for TypeScript compile-time and runtime errors is supported by classifying failures across build phases, selecting auto-fix or manual repair strategies, and verifying with tsc and test runs. It handles dependency fixes, null issues, and configuration problems.

What should I do when repeated debugging cycles fail to fix TypeScript test failures and build errors?

When repeated debugging fails to fix TypeScript test failures and build errors, a self-healing workflow applies a disciplined retry protocol. It diagnoses the failure, applies the smallest targeted fix, verifies with tsc and npm test, and escalates after three failed retries.

Does automated dependency repair work for module resolution and OOM build failures?

Automated dependency repair works for module resolution and OOM build failures by categorizing them as build errors, applying targeted dependency fixes or configuration adjustments, and verifying the recovery with a strict compile and test verification loop.