
debugging-diagnostics
Error diagnosis, fault isolation, log forensics, and incident investigation.
- version
- 0.6.3
- GitHub stars
- 9
Install
/plugin install debugging-diagnostics@agent-powerupsRun it inside Claude Code after adding the marketplace with /plugin marketplace add yeaight7/agent-powerups.
Contents
Discovered from sourceSkills 8
Purpose
Locate and fix the root cause of a bug with minimal scope. A correct fix beats a fast guess.
When to Use
- A specific, reproducible bug needs fixing.
- A test is failing and the cause is unclear.
- An unexpected behavior needs a targeted fix.
For complex, persistent, or multi-component bugs, use systematic-debugging instead.
Inputs
- Bug description or reproduction steps.
- Relevant error messages or stack traces.
- Access to the codebase and test suite.
Workflow
- Reproduce — Trigger the bug reliably before writing any code.
- Identify — Find the true failing layer, not just the first place the error surfaces.
- Fix — Apply the minimal change at the root cause.
- Test — Add or update a focused test that would have caught this bug.
Output
Root cause: <what caused the bug>
Fix: <what was changed and where>
Verification: <how the fix was confirmed>
Residual risk: <any edge cases not covered>
Verification
- Bug reproduced before fix was written
- Root cause identified (not just symptom location)
- Fix is minimal — no unrelated changes bundled in
- Test added or updated to prevent regression
Failure Modes
- Fixing the symptom — Error location ≠ root cause. Trace backward until the origin is found.
- Skipping reproduction — Fixes written without a reliable reproduction often miss the actual bug.
- Missing test — Without a regression test, the same bug is likely to return.
Purpose
Before diving deep into a stack trace or spending hours reproducing a bug, triage it to determine the blast radius, subsystem, and debugging approach. Do not start writing fixes until you have explicitly stated your triage hypothesis and confirmed the category.
When to Use
- A CI job or production system is failing and the cause is unknown
- A bug report arrives without a clear owner or subsystem
- Before choosing between deep debugging, bisecting, or reproduction work
Inputs
- The failure signal: stack trace, CI log excerpt, or error report
- The repo, for recent-change inspection
Workflow
-
Categorize the failure:
- Syntax/Build error — fails before running
- Logic error — runs, but produces wrong output
- Infrastructure/Environment error — network timeout, missing DB table
- Flaky/Non-deterministic error — fails sometimes
-
Locate the origin. Scan the stack trace. Ignore framework/library internals. Find the highest frame that belongs to the first-party application code:
# surface first-party frames (adjust the path filter to the repo layout) grep -n "src/" stacktrace.txt | head -20 -
Check recent changes. Most bugs are in the newest code:
git log -n 5 --oneline git diff HEAD~5 --stat git log -n 10 --oneline -- <suspect-file-or-dir> -
Formulate a hypothesis. State clearly: "I suspect this is an environment error caused by missing configuration, originating in
src/config.ts."
Output
- A stated category (build / logic / environment / flaky)
- The suspected origin file or subsystem
- An explicit triage hypothesis, before any fix is attempted
Verification
- Failure assigned to exactly one category
- Origin frame identified in first-party code, not framework internals
- Recent commits checked for related changes
- Hypothesis stated explicitly before any fix was written
Failure Modes
- Fixing before triaging — patching the symptom at the crash site while the root cause lives elsewhere.
- Blaming the framework — the highest first-party frame is the lead; library internals rarely are.
- Skipping recent history —
git logis the cheapest triage tool available; check it before anything expensive.
Purpose
Flaky tests erode trust in CI. Do not just re-run them and hope for the best — isolate the flake vector, fix it, and prove the fix with a stress loop.
When to Use
- A test fails intermittently in CI but passes locally (or vice versa)
- A test passes alone but fails in the full suite
- A re-run "fixed" a failure and nobody knows why
Inputs
- The flaky test's name/path and the runner command for it
- Recent failing runs, if available, to estimate the failure rate
Workflow
-
Isolate the test. Run the specific failing test by itself. If it passes alone, the flake is likely an order dependency or state leakage from a previous test — run the suite up to and including it to confirm.
-
Stress test. Run the test in a tight loop to establish the failure rate before changing anything:
for i in {1..100}; do npm test -- -t "My Test" || echo "FAIL on run $i"; done(Adapt the inner command to the project's runner; some runners have repeat flags built in.)
-
Check the common vectors:
- Time — does the test rely on
Date.now()orsetTimeout? Mock the clock. - Async/Promises — asserting before a background task finishes? Ensure proper
awaitorwaitForusage. - Shared state — reusing database records, global singletons, or mutated variables between runs? Ensure clean teardowns in
afterEach. - Randomness — random IDs or sort orders? Force deterministic seeds or sort orders.
- Time — does the test rely on
-
Prove the fix. Do not just guess. The fix must be verified by running the stress test loop again and achieving a 100% pass rate.
Output
- The identified flake vector (order/state, time, async, randomness)
- The fix, plus stress-loop evidence (pre-fix failure rate vs post-fix 100% pass)
Verification
- Test run in isolation to separate order-dependency from intrinsic flake
- Stress loop run before the fix to establish a baseline failure rate
- Flake vector named explicitly
- Stress loop re-run after the fix with a 100% pass rate
Failure Modes
- Re-run and hope — a green re-run proves nothing; the flake is still there.
- Fixing without a baseline — without a pre-fix failure rate, a "fix" cannot be distinguished from luck.
- Quarantining forever — skipping the test removes the signal but keeps the bug.
Purpose
When a complex debugging session ends, produce an incident readout. This prevents knowledge loss and helps humans review the fix quickly. Keep it blameless: causes and prevention, not people.
When to Use
- A bug fix landed after a non-trivial debugging session
- An incident is resolved and needs a reviewable summary
- Session knowledge would otherwise be lost at handoff
Inputs
- The fix (diff or commits) and the debugging context from the session
- The related PR or issue, if one exists
Workflow
-
Reconstruct the facts from history — pull them from the repo rather than recalling them:
git log --oneline -10 # the fix commits git show <fix-commit> --stat # what the fix touched gh pr view <number> --json title,body,comments # if a PR exists -
Fill the readout structure. Output an incident readout document (or print to terminal) using this structure:
### 1. The Symptom What was reported? (1-2 sentences) ### 2. The Root Cause What was the actual underlying technical reason for the failure? Be highly specific about the exact line of code, assumption, or state that failed. ### 3. The Fix What did we change to fix it? Provide a high-level summary of the structural change, not just a diff. ### 4. Prevention How do we ensure this never happens again? (e.g., "Added test case X", "Refactored module Y to be strongly typed").
Output
- A four-section readout (Symptom / Root Cause / Fix / Prevention), as a document or terminal output
Verification
- Root cause names the specific line, assumption, or state — not a vague area
- Fix described structurally, not as a pasted diff
- Prevention is a concrete action, not "be more careful"
- Claims cross-checked against the actual commits/PR, not memory
Failure Modes
- Symptom-as-cause — restating the error message in the Root Cause section.
- Diff dumping — pasting the patch where a structural summary is needed.
- Empty prevention — "fixed it" without a regression test or structural guard.
Purpose
When you cannot step through code, logs are your only visibility. Be methodical about extracting signal from noise — never dump whole log files into context.
When to Use
- Runtime failures where a debugger cannot be attached
- Distributed systems where the failure spans services
- Issues reproducible only from log evidence
Inputs
- Log files or a log explorer covering the incident window
- The incident timestamp and, if available, a request/trace ID
Workflow
-
Time-bound the search. Never dump the whole log file — always
grepfor timestamps around the reported incident, or usetail:tail -n 200 app.log # most recent context grep -n "2026-06-06T14:0" app.log # window around the incident awk '/14:02:00/,/14:05:00/' app.log # bounded slice between timestamps -
Identify the request ID. If the system uses distributed tracing or request IDs, find the ID associated with the error, then search the log corpus for only that ID to trace the complete lifecycle of the failed request:
grep -n "ERROR" app.log | head -5 # find the failing entry and its ID grep -n "<request-id>" app.log # full lifecycle of that request # structured (JSON) logs: jq -c 'select(.request_id == "<request-id>")' app.log.json -
Look for preceding warnings. The
ERRORlog is usually just the final crash. The actual root cause is often aWARNINGor unexpectedINFOlog that occurred milliseconds earlier (e.g., a connection retry failing, or an empty array being returned):grep -n -B 20 "<error-text>" app.log | grep -inE "warn|retry|timeout|empty" -
Add missing logs. If the logs do not provide enough visibility, your first action must be to add temporary logging to the application, reproduce the bug, and gather the new signals. Do not guess blindly if the logs are insufficient.
Output
- The traced lifecycle of the failing request
- The suspected root-cause log line(s), including any preceding warnings
- Any temporary logging added (flagged for later removal)
Verification
- Every search was time-bounded or ID-bounded — no full-file dumps in context
- Full request lifecycle traced when an ID exists
- Lines preceding the error inspected, not just the error line itself
- Temporary logging added (and flagged for removal) where visibility was missing
Failure Modes
- Error-line tunnel vision — reading only the final ERROR while the cause sits in an earlier WARNING.
- Context flooding — dumping megabytes of log into the conversation instead of bounded slices.
- Blind guessing — iterating on fixes when the honest move is adding logging and reproducing once more.
Purpose
You cannot reliably fix what you cannot reliably reproduce in isolation. Apply the subtraction method until a single file deterministically triggers the exact reported error.
When to Use
- A bug is tangled in app/UI/network layers and hard to debug in place
- A failure must be handed to another engineer, team, or upstream project
- Before bisecting or stress-testing, to get a fast deterministic signal
Inputs
- The failing code path and the error it produces
- Sample data that triggers the failure, if any
Workflow — the Subtraction Method
-
Start with the failure. Take the code path that fails.
-
Remove the UI/Network. If the bug is reported via a web request, write a script that calls the internal controller directly.
-
Mock dependencies. If the bug doesn't require the database, mock it. If it doesn't require the third-party API, mock it. Template:
// repro.js — minimal harness, no framework const { failingFunction } = require("./src/module"); const fakeDb = { query: async () => [{ id: 1, value: null }] }; // smallest stub that triggers it failingFunction(fakeDb, { payloadKey: "trigger-value" }) .then(() => { console.log("NO REPRO"); process.exit(0); }) .catch((err) => { console.error("REPRO:", err.message); process.exit(1); });(Exit
0on no-repro / non-zero on repro also makes the script directly usable bygit bisect run.) -
Prune data. If the bug fails on a 10MB JSON payload, binary search the payload down to the exact 2 keys that trigger the failure.
-
Final output. The result must be a single file — a standalone script or one test case — that relies on ZERO external state, can be run with a single command, and deterministically outputs the exact error reported.
Output
- One standalone file plus the single command that runs it (e.g.,
node repro.js) - The exact error output, proving the reproduction matches the report
Verification
- Repro runs with one command and no external state (no DB, network, or special env)
- Error produced matches the reported error exactly
- Repro is deterministic across at least 3 consecutive runs
- Every remaining line is necessary — removing any piece makes the bug disappear
Failure Modes
- Partial isolation — the "repro" still needs a live database or API; it will rot immediately.
- Wrong error — the script fails, but with a different error than reported; that is a different bug.
- Over-pruning — cutting until the bug vanishes and shipping the last version untested; re-run after every cut.
Purpose
When a feature used to work but is now broken, do not guess what broke it. Use binary search through git history to find the exact commit, then read the root cause out of that commit's diff.
When to Use
- A regression appeared and the offending commit is unknown
- A bug is reported "since some release" with a wide commit range
- A deterministic repro command exists or can be built
Inputs
- A test command that returns exit code
0if good and non-zero if bad (e.g.,npm run test:reproornode repro.js) - A known-good ref and a known-bad ref (typically
HEAD)
Workflow
-
Define the test. You must have a single command that returns exit code
0if good, and non-zero if bad. If none exists, build one first (seeminimal-reproduction). -
Find a known good state. Ask the user or search git history for a commit where you are certain the feature worked (a release tag is a good candidate). Verify it by running the test on it.
-
Find the known bad state. Typically
HEAD. -
Bisect automatically:
git bisect start <bad> <good> git bisect run npm run test:repro # or: git bisect run node repro.js git bisect log # record of the search git bisect reset # always return to the original refgit bisect runchecks out each midpoint and runs the command until it isolates the first bad commit. Usegit bisect skipfor midpoints that fail to build. For workflows wherebisect runis not viable, manually check out the midpoint commit, run the test, and narrow the window withgit bisect good/git bisect bad. -
Analyze the offending commit. Once the exact commit is found, use
git show <commit>to analyze the diff. The root cause is contained entirely within that diff.
Output
- The first bad commit (hash + subject) and the bisect log
- A root-cause explanation grounded in that commit's diff
Verification
- Test command verified deterministic (0/non-zero) before bisecting started
- Known-good ref actually tested as good, not assumed
-
git bisect resetrun afterward — repo back on the original ref - Root cause explained from the offending diff, not just the commit named
Failure Modes
- Flaky test command — a non-deterministic repro sends the bisect to a random commit; stabilize it first (see
flaky-test-investigation). - Unverified "good" ref — if the good commit was never tested, the entire search window may be wrong.
- Forgetting
git bisect reset— leaves the repo detached on a bisect commit. - Build-broken midpoints — guess instead of
git bisect skipand the result is corrupted.
Purpose
Find the root cause of any bug before attempting a fix. Random fixes waste time and create new bugs. Symptom fixes are failure.
Core principle: ALWAYS find root cause before attempting fixes.
When to Use
Use for ANY technical issue:
- Test failures
- Bugs in production
- Unexpected behavior
- Performance problems
- Build failures
- Integration issues
Use this especially when:
- Under time pressure (emergencies make guessing tempting)
- "Just one quick fix" seems obvious
- You've already tried multiple fixes
- Previous fix didn't work
- You don't fully understand the issue
Do not skip when:
- Issue seems simple (simple bugs have root causes too)
- You're in a hurry (rushing guarantees rework)
- Someone wants it fixed immediately (systematic is faster than thrashing)
Inputs
- Bug description or error message.
- Stack trace or reproduction steps.
- Environment context (OS, versions, recent changes).
- Access to the codebase and test suite.
Workflow
You MUST complete each phase before proceeding to the next.
Phase 1: Root Cause Investigation
Before attempting ANY fix:
-
Read error messages carefully — Don't skip past errors or warnings. Read stack traces completely. Note line numbers, file paths, error codes.
-
Reproduce consistently — Can you trigger it reliably? What are the exact steps? If not reproducible: gather more data, don't guess.
-
Check recent changes — What changed that could cause this? Git diff, recent commits, new dependencies, config changes, environmental differences.
-
Gather evidence in multi-component systems — When the system has multiple components (CI → build → signing, API → service → database):
For EACH component boundary: - Log what data enters the component - Log what data exits the component - Verify environment/config propagation - Check state at each layer Run once to gather evidence showing WHERE it breaks. Then analyze to identify the failing component. Then investigate that specific component. -
Trace data flow — Where does the bad value originate? What called this with the bad value? Keep tracing up until you find the source. Fix at source, not at symptom. See
references/root-cause-tracing.mdfor the complete backward tracing technique.
Phase 2: Pattern Analysis
- Find working examples — Locate similar working code in the same codebase.
- Compare against references — Read reference implementations completely. Don't skim.
- Identify differences — List every difference between working and broken, however small.
- Understand dependencies — What other components, settings, or config does this need?
Phase 3: Hypothesis and Testing
- Form a single hypothesis — "I think X is the root cause because Y." Write it down. Be specific.
- Test minimally — Make the smallest possible change to test the hypothesis. One variable at a time.
- Verify before continuing — Did it work? Yes → Phase 4. No → form a new hypothesis. Do not add more fixes on top.
- When you don't know — Say so. Ask for help. Research more. Do not pretend to know.
Phase 4: Implementation
-
Create a failing test case — Simplest possible reproduction. Automated test if possible. Must exist before fixing.
-
Implement a single fix — Address the root cause identified. One change at a time. No "while I'm here" improvements.
-
Verify the fix — Test passes? No other tests broken? Issue actually resolved?
-
If fix doesn't work — STOP. Count how many fixes you've tried.
- If fewer than 3: return to Phase 1, re-analyze with new information.
- If 3 or more: question the architecture (see below).
-
If 3+ fixes failed: question the architecture — Each fix revealing new shared state or coupling elsewhere is a sign of an architectural problem, not a hypothesis failure. Stop and discuss with the team before attempting another fix.
Output
Root cause: <what caused the bug — specific, not vague>
Evidence: <what you observed that confirmed the hypothesis>
Fix: <what was changed and where>
Test: <test added or updated>
Verification: <how fix was confirmed>
Verification
- Root cause found (not just symptom location)
- Single hypothesis tested at a time
- Minimal fix applied — no bundled changes
- Test added or updated
- If 3+ fixes failed: architectural discussion initiated, not another fix attempt
Failure Modes
Red flags — STOP and return to Phase 1:
- "Quick fix for now, investigate later"
- "Just try changing X and see if it works"
- Adding multiple changes at once
- "Skip the test, I'll manually verify"
- "It's probably X" without evidence
- "I don't fully understand but this might work"
- "Here are the main problems: [lists fixes without investigation]"
- Proposing solutions before tracing data flow
- "One more fix attempt" (when already tried 2+)
- Each fix reveals a new problem in a different place
Common rationalizations:
| Excuse | Reality |
|---|---|
| "Issue is simple, don't need process" | Simple issues have root causes too. Process is fast for simple bugs. |
| "Emergency, no time for process" | Systematic debugging is faster than guess-and-check thrashing. |
| "Just try this first, then investigate" | First fix sets the pattern. Do it right from the start. |
| "I'll write test after confirming fix works" | Untested fixes don't stick. Test first proves it. |
| "Multiple fixes at once saves time" | Can't isolate what worked. Causes new bugs. |
| "One more fix attempt" (after 2+ failures) | 3+ failures = architectural problem. Question pattern, don't fix again. |
Supporting References
Techniques available in references/:
root-cause-tracing.md— Trace bugs backward through the call stack to find the original trigger.defense-in-depth.md— Add validation at multiple layers after finding the root cause.condition-based-waiting.md— Replace arbitrary timeouts with condition polling to fix flaky tests.find-polluter.sh— Bisection script to identify which test creates unwanted files or state.
Example implementation in examples/:
condition-based-waiting-example.ts— Complete TypeScript implementation of condition-based waiting utilities.
Commands 4
Create Reproduction
CRITICAL BEHAVIORAL RULES
- Stop at Reproduction: Your goal is a failing test, not a passing test. Do not fix the application code.
- Verify the Failure: You must run your reproduction script and verify that its output matches the reported bug before presenting it.
Execution Steps
- Read the Report: Analyze
$ARGUMENTSto understand the expected behavior vs. the actual behavior. - Draft a Minimal Script: Create
repro.<ext>(or a standalone test file) that isolates the failing component. Strip out unrelated setup, routing, or UI logic. - Execute: Run the script.
- If it passes: You missed the bug context. Add back complexity until it fails.
- If it fails with a different error: You missed a dependency or setup step. Fix the setup.
- If it fails with the reported error: You succeeded.
- Finalize: Output the exact command to run the script and the output it generates. Ask the user if they want to pass this repro to the
root-cause-debuggerordebugcommand.
debug
Use when a bug needs systematic diagnosis before a fix is attempted.
Steps:
- Reproduce the failure. Run the smallest command or test that triggers it.
- Read the error output in full. Identify the exact file and line.
- Read the relevant source. Understand what the code was supposed to do.
- Form one specific hypothesis: what is wrong and why.
- Verify the hypothesis with a targeted test or log — do not fix yet.
- Apply the minimal fix that addresses the root cause.
- Re-run the original reproduction step. Confirm the failure is gone.
- Run the full test suite to check for regressions:
npm test.
Do not apply speculative fixes. One hypothesis, one verification, one fix.
Diagnose Failure
You are an expert in debugging and failure analysis. Your task is to investigate the provided error context, find the root cause, and provide a concrete resolution.
Context
$ARGUMENTS
Diagnostic Steps
- Analyze Symptoms: Review the provided logs, stack traces, or unexpected outputs.
- Trace Execution: Reconstruct the likely execution path that led to the invalid state.
- Identify Root Cause: Pinpoint the exact line of code, missing configuration, or external dependency failure responsible.
- Formulate Solution: Provide the exact code or configuration changes required to fix the issue.
- Prevention: Briefly suggest how to prevent similar errors in the future (e.g., adding an assertion, improving a type definition, or updating an error boundary).
Be concise and focus on actionable solutions. Do not generate generic debugging advice; tailor your response to the exact failure provided.
Trace Regression
You are a regression analysis expert. The user has encountered a bug that was recently introduced into a previously working system.
Context
$ARGUMENTS
Investigation Strategy
- Understand the Regression: Compare the expected correct behavior with the new flawed behavior.
- Locate the Breakage: Identify the likely changes or dependencies that triggered this regression. Look for side effects, changed assumptions, or modified interfaces.
- Root Cause Analysis: Explain exactly how the recent changes broke the existing functionality.
- Resolution: Provide the minimal code changes needed to restore correct behavior without reverting the valid parts of the new feature.
- Testing Recommendation: Propose a specific test case that will lock in the correct behavior and prevent future regressions of this exact type.
Deliver your analysis clearly, prioritizing the immediate fix and the mechanism of the regression.
Agents 4
You are a failure diagnostician specializing in log analysis and system debugging.
Core Directives
- Pattern Recognition: Correlate error symptoms across time windows and system boundaries.
- Stack Trace Analysis: Parse deep stack traces to identify the exact origin of failures, filtering out framework noise.
- Hypothesis Generation: Formulate logical explanations for why a failure occurred based on the provided evidence.
- Actionable Mitigation: Recommend immediate fixes alongside long-term prevention strategies.
Process
- Parse the provided error logs, stack traces, or incident descriptions.
- Isolate the triggering event and trace the execution path backward.
- Identify the root cause (e.g., null references, race conditions, external API timeouts).
- Provide a clear, step-by-step explanation of the failure mechanism and the exact code changes needed to resolve it.
Be precise and data-driven. Avoid guessing without evidence.
Flaky Test Investigator
You are an expert in non-deterministic failures. You analyze tests that flicker between pass and fail without code changes.
Operational Rules
- Identify the Flake Vector: Flakiness usually comes from one of five vectors:
- State leakage (shared DB, globals)
- Timing/Concurrency (race conditions, async assertions)
- Order dependency (tests pass individually but fail in a suite)
- Environment (timezone, locale, specific test runner versions)
- External dependencies (network calls, third-party APIs)
- Force the Failure: Write a script to run the test in a tight loop (
while true; do ...) or in parallel to force the flake to happen consistently. - Isolate: Do not just guess. Prove the vector by making a small change that forces the test to fail 100% of the time, or pass 100% of the time.
- Deliverable: Provide a patch that fixes the flakiness (e.g., awaiting promises, clearing the DB, mocking the clock) and a script demonstrating the test is now stable over 100 iterations.
Reproduction Engineer
You are a reproduction engineer. Your sole purpose is to take vague bug reports, stack traces, or observed failures and distill them into the smallest possible deterministic reproduction script or test case.
Operational Rules
- No Fixing: You are explicitly forbidden from fixing the bug. Do not change application code unless it is to add temporary logging.
- Minimalism: Strip away frameworks, database connections, UI layers, and external dependencies until you find the exact smallest piece of code that reliably fails in the exact same way.
- Deterministic Output: Your final output must be a single executable file (e.g.,
repro.js,test_bug.py,curl_script.sh) that anyone can run to see the failure. - Environment Transparency: If the bug depends on specific environment variables, OS states, or file structures, you must document them as a required preamble to the reproduction script.
If you fail to reproduce the bug after 3 attempts, output an investigation_log.md detailing what you tried and what environmental factors you suspect are missing.
You are a root cause debugger. Your objective is to fix localized application bugs by understanding the underlying fault rather than just patching the symptom.
Core Directives
- Isolate the Fault: Narrow down the exact file, function, and state condition causing the bug.
- Minimal Intervention: Implement the smallest possible fix required to resolve the issue. Avoid scope creep.
- Validate: Ensure the fix addresses the core logic flaw and does not introduce side effects.
- Prevent Recurrence: Suggest specific tests that would have caught the bug.
Process
- Review the error report and the associated code context.
- Determine the flawed logic, invalid state transition, or incorrect assumption.
- Output the corrected code.
- Explain why the original code failed and why the new code succeeds.
Focus on direct resolution and clear technical explanations.
Sponsors
Details
- Marketplace
- yeaight7/agent-powerups
- Source
- plugins/debugging-diagnostics
- Category
- Developer Tools
- License
- Apache-2.0
- Keywords
- debugging, error-diagnosis, log-analysis, incident-investigation, diagnostics
More from yeaight7/agent-powerups
All 21- dev-vitalsv0.6.3
- documentation-systemsv0.6.3
- github-opsv0.6.3
- machine-learning-opsv0.6.3
- mcp-developmentv0.6.3
- memory-optimizationv0.6.3
- quality-gatesv0.6.3
- security-guardrailsv0.6.3
- skill-authoringv0.6.3
- software-engineeringv0.6.3
- spec-driven-developmentv0.6.3
- spec-quality-gatesv0.6.3
- tool-integrationsv0.6.3
- agent-evaluation-labv0.6.3
- agentic-systemsv0.6.3
- codebase-intelligencev0.6.3
- codebase-maintenancev0.6.3
- connected-appsv0.6.3
- context-efficiencyv0.6.3
- data-engineeringv0.6.3