[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M75962RN0F4A7HTF00FJ9SXK":3,"skill-same:01M75962RN0F4A7HTF00FJ9SXK":66},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":43,"commitSha":44,"skillDirectory":45,"forksCount":46,"repositoryHtmlUrl":47,"repositoryHomepageUrl":48,"ownerHtmlUrl":49,"ownerBlogUrl":6,"ownerDescription":50,"updatedAt":51,"install":52,"resources":65},"01M75962RN0F4A7HTF00FJ9SXK","root-cause-debugging",null,"6-phase root cause debugging: feedback loop, reproduce, pattern, hypothesise + instrument, fix, cleanup. Understand bugs before fixing.","lukemcqueen\u002Fsteadfaste-fleet","lukemcqueen","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F405240?v=4","01M757MHPAGRXTJAT46SKZP98R","Luke McQueen","01M757MHPZ573KP8DT9GB8SBQ7",4,"MIT","https:\u002F\u002Fgithub.com\u002Flukemcqueen\u002Fsteadfaste-fleet\u002Fblob\u002Fmain\u002Fskills\u002Fsoftware-development\u002Froot-cause-debugging\u002FSKILL.md",[],[],"2026-11-12 13:55:43",false,"---\nname: root-cause-debugging\ndescription: \"6-phase root cause debugging: feedback loop, reproduce, pattern, hypothesise + instrument, fix, cleanup. Understand bugs before fixing.\"\nversion: 2.0.0\nauthor: Steadfaste Fleet\nlicense: MIT\nplatforms: [linux, macos, windows]\nmetadata:\n  hermes:\n    tags: [debugging, troubleshooting, problem-solving, root-cause, investigation]\n    related_skills: [change-test-loop, plan, subagent-driven-development, codebase-design]\n---\n\n# Root Cause Debugging\n\n## Overview\n\nRandom fixes waste time and create new bugs. Quick patches mask underlying issues.\n\n**Core principle:** ALWAYS build a tight feedback loop before theorizing. ALWAYS find root cause before attempting fixes. Symptom fixes are failure.\n\n**Violating the letter of this process is violating the spirit of debugging.**\n\n## The Iron Law\n\n```\nNO FIXES WITHOUT FEEDBACK LOOP FIRST\n```\n\nIf you haven't completed Phase 0 (built a tight pass\u002Ffail signal for the bug), you cannot propose fixes.\n\n## When to Use\n\nUse for ANY technical issue:\n- Test failures\n- Bugs in production\n- Unexpected behavior\n- Performance problems\n- Build failures\n- Integration issues\n\n**Use this ESPECIALLY when:**\n- Under time pressure (emergencies make guessing tempting)\n- \"Just one quick fix\" seems obvious\n- You've already tried multiple fixes\n- Previous fix didn't work\n- You don't fully understand the issue\n\n**Don't skip when:**\n- Issue seems simple (simple bugs have root causes too)\n- You're in a hurry (rushing guarantees rework)\n- Someone wants it fixed NOW (systematic is faster than thrashing)\n\n## When There Is More Than One Failure — Triage First\n\nPhases 0-5 fix ONE bug. Before picking *which* bug, triage the whole failing set:\nrun each failing file once, capture the FIRST failure reason each produces, and\ngroup by **signature** — the named cause, not the file path. **Count each group**\n— a count is evidence; \"roughly N\" is a guess that hides where the leverage is.\n\nPick the next fix as the largest group whose members share ONE cause: N files\nunder a single named cause is leverage (one fix, N greens). A group whose members\nare independent artifacts — same symptom, different causes — is a checklist, not\none fix; name it as such rather than claiming a shared root.\n\nRecord files that already PASS at the tip as their own explicit group. A file\nthat fails in a report but passes at the tip is flaky or fixed-in-range — a live\nrisk to own, not silence.\n\n## The Six Phases\n\nYou MUST complete each phase before proceeding to the next.\n\n---\n\n## Phase 0: Build a Feedback Loop\n\n**This is the skill.** Everything else is mechanical.\n\nIf you have a **tight** pass\u002Ffail signal for the bug — one that goes red on *this* bug — you will find the cause; bisection, hypothesis-testing, and instrumentation all just consume it. If you don't have one, no amount of staring at code will save you.\n\nSpend disproportionate effort here. **Be aggressive. Be creative. Refuse to give up.**\n\n### Ways to construct one — try in roughly this order\n\n1. **Failing test** at whatever seam reaches the bug — unit, integration, e2e.\n2. **Curl \u002F HTTP script** against a running dev server.\n3. **CLI invocation** with a fixture input, diffing stdout against a known-good snapshot.\n4. **Headless browser script** (Playwright \u002F Puppeteer) — drives the UI, asserts on DOM\u002Fconsole\u002Fnetwork.\n5. **Replay a captured trace.** Save a real network request \u002F payload \u002F event log to disk; replay it through the code path in isolation.\n6. **Throwaway harness.** Spin up a minimal subset of the system (one service, mocked deps) that exercises the bug code path with a single function call.\n7. **Property \u002F fuzz loop.** If the bug is \"sometimes wrong output\", run 1000 random inputs and look for the failure mode.\n8. **Bisection harness.** If the bug appeared between two known states (commit, dataset, version), automate \"boot at state X, check, repeat\" so you can `git bisect run` it.\n9. **Differential loop.** Run the same input through old-version vs new-version (or two configs) and diff outputs.\n10. **HITL bash script.** Last resort. If a human must click, drive *them* with a structured loop script so the loop is still repeatable. Captured output feeds back to you.\n\nBuild the right feedback loop, and the bug is 90% fixed.\n\n### Tighten the loop\n\nTreat the loop as a product. Once you have *a* loop, **tighten** it:\n\n- Can I make it faster? (Cache setup, skip unrelated init, narrow the test scope.)\n- Can I make the signal sharper? (Assert on the specific symptom, not \"didn't crash\".)\n- Can I make it more deterministic? (Pin time, seed RNG, isolate filesystem, freeze network.)\n\nA 30-second flaky loop is barely better than no loop; a 2-second deterministic one is a debugging superpower.\n\n### Non-deterministic bugs\n\nThe goal is not a clean repro but a **higher reproduction rate**. Loop the trigger 100×, parallelise, add stress, narrow timing windows, inject sleeps. A 50%-flake bug is debuggable; 1% is not — keep raising the rate until it's debuggable.\n\n**Determinism is the DEFAULT — do not label a bug \"non-deterministic\" until you have\nproven it.** Before reaching for flakiness as the explanation, rule out the\ndeterministic causes: pin the seed (`PYTHONHASHSEED=0`), the timezone, the clock,\nand the iteration order, then re-run. A failure that reproduces identically on every\nrun is deterministic even when the *output* looks random; calling it nondeterminism\nsends the investigation toward flake-hunting and away from the real, findable cause.\nYou cannot call a bug intermittent without a measured reproduction rate.\n\n### When you genuinely cannot build a loop\n\nStop and say so explicitly. List what you tried. Ask the user for: (a) access to whatever environment reproduces it, (b) a captured artifact (HAR file, log dump, core dump, screen recording with timestamps), or (c) permission to add temporary production instrumentation. Do **not** proceed to hypothesise without a loop.\n\n### Phase 0 Completion Checklist\n\n- [ ] A tight, deterministic pass\u002Ffail signal exists\n- [ ] The signal goes red on *this specific bug* (proven by running it)\n- [ ] The loop is fast enough to iterate on (seconds, not minutes)\n- [ ] It can be run unattended (or HITL script exists for manual steps)\n\n**STOP:** Do not proceed to Phase 1 without a tight feedback loop.\n\n---\n\n## Phase 1: Reproduce + Minimise\n\n**Before anything else:** confirm the bug.\n\nRun the loop from Phase 0. Watch it go red.\n\nConfirm:\n- [ ] The loop produces the failure mode the **user** described — not a different failure that happens to be nearby. Wrong bug = wrong fix.\n- [ ] The failure is reproducible across multiple runs (or, for non-deterministic bugs, reproducible at a high enough rate to debug against).\n- [ ] You have captured the exact symptom (error message, wrong output, timing) so later phases can verify the fix actually addresses it.\n\n### Minimise\n\nOnce it's red, shrink the repro to the **smallest scenario that still goes red**. Cut inputs, callers, config, data, and steps **one at a time**, re-running the loop after each cut — keep only what's load-bearing for the failure.\n\nWhy bother: a minimal repro shrinks the hypothesis space (fewer moving parts left to suspect) and becomes the clean regression test in Phase 4.\n\nDone when **every remaining element is load-bearing** — removing any one of them makes the loop go green.\n\n### Evidence Gathering\n\nNow that you have a minimised repro, gather evidence systematically:\n\n1. **Read Error Messages Carefully** — stack traces, line numbers, error codes\n2. **Check Recent Changes** — `git log --oneline -10`, `git diff`\n3. **Trace Data Flow** — where does the bad value originate? Trace upstream to find the source\n\n**A reported diagnosis is a hypothesis, not a fact.** A handoff, a summary, or a\nprior pass that says *\"the cause is X\"* is a claim to VERIFY against the\nunderlying data — the rows, the query, the log — never a premise to act on. A\nconfident report can be confidently wrong; in practice a triage report can name\nthe wrong cause for every symptom and send the fix the wrong way. Read the\nartifact the diagnosis rests on and confirm it yourself before writing any fix.\n\n**An absent CALLER is not an absent WRITER.** When you cannot find what produces a value,\ngrepping for the file's name — or for the helper that constructs its path — finds only the\nREADERS. A writer that builds the same path inline, or writes from another module entirely,\nis invisible to that search, and the empty result reads as \"nothing writes this\". Measured:\na per-session state file whose only references were its constructor's `def` and two read\nsites, so the hunt ended in a confident and WRONG claim, committed, that no writer existed —\nthe writer had been building that path inline all along, inside the very function being\ninvestigated. Search for what WRITES the artifact (`write_text` \u002F `write` \u002F `>` over the same\nexpression, or the state directory itself), not for callers of the path's constructor; and\nnever let a negative grep become a stated fact without a second, differently-shaped method\nthat could have found the positive.\n\n**Action:** Use `read_file` on relevant source files. Use `search_files` to trace references:\n\n```python\n# Find where the function is called\nsearch_files(\"function_name(\", path=\"src\u002F\", file_glob=\"*.py\")\n\n# Find where the variable is set\nsearch_files(r\"variable_name\\s*=\", path=\"src\u002F\", file_glob=\"*.py\")\n```\n\n4. **Multi-Component Systems** — for each component boundary, log what enters and exits. Find WHERE it breaks before investigating the specific component.\n\n### Phase 1 Completion Checklist\n\n- [ ] Bug reproduced and confirmed as the *correct* bug\n- [ ] Repro minimised to smallest load-bearing scenario\n- [ ] Error messages fully read and understood\n- [ ] Recent changes identified and reviewed\n- [ ] Evidence gathered (logs, state, data flow)\n- [ ] Problem isolated to specific component\u002Fcode\n\n---\n\n## Phase 2: Pattern Analysis\n\n**Find the pattern before hypothesising:**\n\n### 1. Find Working Examples\n\n- Locate similar working code in the same codebase\n- What works that's similar to what's broken?\n\n**Action:** Use `search_files` to find comparable patterns:\n\n```python\nsearch_files(\"similar_pattern\", path=\"src\u002F\", file_glob=\"*.py\")\n```\n\n### 2. Compare Against References\n\n- If implementing a pattern, read the reference implementation COMPLETELY\n- Don't skim — read every line\n- Understand the pattern fully before applying\n\n### 3. Identify Differences\n\n- What's different between working and broken?\n- List every difference, however small\n- Don't assume \"that can't matter\"\n\n### 4. Understand Dependencies\n\n- What other components does this need?\n- What settings, config, environment?\n- What assumptions does it make?\n\n### Phase 2 Completion\n\n- [ ] Working examples found and compared\n- [ ] Differences identified between working and broken\n\n---\n\n## Phase 3: Hypothesise + Instrument\n\n### Generate 3-5 Ranked Hypotheses\n\nGenerate **3-5 ranked hypotheses** before testing any of them. Single-hypothesis generation anchors on the first plausible idea.\n\nEach hypothesis must be **falsifiable**: state the prediction it makes.\n\n> Format: \"If \u003CX> is the cause, then \u003Cchanging Y> will make the bug disappear \u002F \u003Cchanging Z> will make it worse.\"\n\nIf you cannot state the prediction, the hypothesis is a vibe — discard or sharpen it.\n\n**Show the ranked list to the user before testing.** They often have domain knowledge that re-ranks instantly (\"we just deployed a change to #3\"), or know hypotheses they've already ruled out. Cheap checkpoint, big time saver. Don't block on it — proceed with your ranking if the user is AFK.\n\n### Instrument — One Variable at a Time\n\nEach probe must map to a specific prediction from Phase 3. **Change one variable at a time.**\n\n**Tool preference:**\n1. **Debugger \u002F REPL inspection** if the env supports it. One breakpoint beats ten logs.\n2. **Targeted logs** at the boundaries that distinguish hypotheses.\n3. Never \"log everything and grep\".\n\n**Tag every debug log** with a unique prefix, e.g. `[DEBUG-a4f2]`. Cleanup at the end becomes a single grep. Untagged logs survive; tagged logs die.\n\n**Perf branch.** For performance regressions, logs are usually wrong. Instead: establish a baseline measurement (timing harness, `performance.now()`, profiler, query plan), then bisect. Measure first, fix second.\n\n**When You Don't Know**\n- Say \"I don't understand X\"\n- Don't pretend to know\n- Ask the user for help\n- Research more\n\n**Decision table — which probe to use:**\n\n| Situation | Probe |\n|-----------|-------|\n| Debugger\u002FREPL available for the runtime | Breakpoint at the boundary — one breakpoint beats ten logs |\n| No debugger, deterministic repro | Tagged log (`[DEBUG-xxxx]`) at the boundary that distinguishes hypotheses #1 vs #2 |\n| Bug is a wrong value | Log the value's origin and each transform (`search_files` on `variable\\s*=` first) |\n| Bug is performance | NO logs — baseline measurement (profiler, query plan, `performance.now()`), then bisect |\n| Bug is intermittent | Raise repro rate first (see Phase 0) before probing — 1% flakes can't be probed |\n| Bug spans components | Log inputs AND outputs at each component boundary before opening any single component |\n\n### Phase 3 Completion Checklist\n\n- [ ] 3-5 ranked hypotheses generated (shown to user if present)\n- [ ] Each hypothesis is falsifiable with a prediction\n- [ ] Instrumentation probes one variable at a time\n- [ ] Debug logs tagged with unique prefix\n- [ ] Perf bugs: baseline measurement established before fix\n\n---\n\n## Phase 4: Fix + Regression Test\n\n**Fix the root cause, not the symptom:**\n\n### 1. Check for a Correct Test Seam\n\nWrite the regression test **before the fix** — but only if there is a **correct seam** for it.\n\nA correct seam is one where the test exercises the **real bug pattern** as it occurs at the call site. If the only available seam is too shallow (unit test that can't replicate the chain that triggered the bug), a regression test there gives false confidence.\n\n**If no correct seam exists, that itself is the finding.** Note it. The codebase architecture is preventing the bug from being locked down. This is a candidate for the `codebase-design` skill — the module needs deepening to create a testable seam.\n\n**Rollback:** every fix must be reversible. Before applying the fix, note the baseline: `git status` clean + `git rev-parse HEAD`. If the fix goes wrong mid-way: `git checkout -- \u003Cfiles-touched>` restores the pre-fix state (or `git stash` if you want to keep partial work). Never push a fix you cannot undo.\n\n### 2. If a Correct Seam Exists\n\n1. Turn the minimised repro into a failing test at that seam (RED)\n2. Watch it fail for the correct reason\n3. Apply the fix — ONE change at a time\n4. Watch it pass (GREEN)\n5. Re-run the Phase 0 feedback loop against the **original (un-minimised)** scenario\n\n```bash\n# Run the specific regression test\npytest tests\u002Ftest_module.py::test_regression -v\n\n# Run full suite — no regressions\npytest tests\u002F -q\n```\n\n### 3. If Fix Doesn't Work — The Rule of Three\n\n- **STOP.**\n- Count: How many fixes have you tried?\n- If \u003C 3: Return to Phase 1, re-analyse with new information\n- **If ≥ 3: STOP and question the architecture (step 4 below)**\n- DON'T attempt Fix #4 without architectural discussion\n\n### 4. If 3+ Fixes Failed: Question Architecture\n\n**Pattern indicating an architectural problem:**\n- Each fix reveals new shared state\u002Fcoupling in a different place\n- Fixes require \"massive refactoring\" to implement\n- Each fix creates new symptoms elsewhere\n\n**STOP and question fundamentals.** Discuss with the user before attempting more fixes. This is NOT a failed hypothesis — this is a wrong architecture. Use the `codebase-design` skill to evaluate module depth, seam placement, and adapter strategy.\n\n### Phase 4 Completion Checklist\n\n- [ ] Correct seam identified (or absence documented)\n- [ ] Regression test passes at the seam\n- [ ] Original Phase 0 loop goes green\n- [ ] Full test suite passes\n- [ ] No regressions introduced\n\n---\n\n## Phase 5: Cleanup + Post-mortem\n\n**Required before declaring done:**\n\n- [ ] Original repro no longer reproduces (re-run the Phase 0 loop)\n- [ ] Regression test passes (or absence of seam is documented)\n- [ ] All `[DEBUG-...]` instrumentation removed (`grep` the prefix)\n- [ ] Throwaway prototypes deleted (or moved to a clearly-marked debug location)\n- [ ] The hypothesis that turned out correct is stated in the commit \u002F PR message — so the next debugger learns\n\n**Then ask: what would have prevented this bug?** If the answer involves architectural change (no good test seam, tangled callers, hidden coupling), hand off to the `codebase-design` skill with the specifics. Make the recommendation **after** the fix is in, not before — you have more information now than when you started.\n\n---\n\n## Red Flags — STOP and Follow Process\n\nIf you catch yourself thinking:\n- \"Quick fix for now, investigate later\"\n- \"Just try changing X and see if it works\"\n- \"Add multiple changes, run tests\"\n- \"Skip the test, I'll manually verify\"\n- \"It's probably X, let me fix that\"\n- \"I don't fully understand but this might work\"\n- \"Pattern says X but I'll adapt it differently\"\n- \"Here are the main problems: [lists fixes without investigation]\"\n- Proposing solutions before a tight feedback loop exists\n- **\"One more fix attempt\" (when already tried 2+)**\n- **Each fix reveals a new problem in a different place**\n\n**ALL of these mean: STOP. Return to Phase 0.**\n\n**If 3+ fixes failed:** Question the architecture (Phase 4 step 4).\n\n## Common Rationalizations\n\n| Excuse | Reality |\n|--------|---------|\n| \"Issue is simple, don't need process\" | Simple issues have root causes too. Process is fast for simple bugs. |\n| \"Emergency, no time for process\" | Systematic debugging is FASTER than guess-and-check thrashing. |\n| \"Just try this first, then investigate\" | Without a feedback loop, you can't tell if the fix worked. Build the loop first. |\n| \"I'll write test after confirming fix works\" | Untested fixes don't stick. Test first proves it. |\n| \"Multiple fixes at once saves time\" | Can't isolate what worked. Causes new bugs. |\n| \"Reference too long, I'll adapt the pattern\" | Partial understanding guarantees bugs. Read it completely. |\n| \"I see the problem, let me fix it\" | Seeing symptoms ≠ understanding root cause. |\n| \"One more fix attempt\" (after 2+ failures) | 3+ failures = architectural problem. Question the pattern, don't fix again. |\n\n## Quick Reference\n\n| Phase | Key Activities | Success Criteria |\n|-------|---------------|------------------|\n| **0. Feedback Loop** | Build tight pass\u002Ffail signal; 10 construction methods; tighten loop | One command that goes red on *this bug* |\n| **1. Reproduce + Minimise** | Run the loop, confirm correct bug, minimise, gather evidence | Minimal repro; bug understood |\n| **2. Pattern Analysis** | Find working examples, compare, identify differences | Know what's different |\n| **3. Hypothesise + Instrument** | 3-5 ranked hypotheses, tagged debug logs, one variable at a time | Confirmed hypothesis; root cause identified |\n| **4. Fix + Regression Test** | Check seam, RED-GREEN, verify original loop goes green | Bug resolved, all tests pass |\n| **5. Cleanup + Post-mortem** | Remove instrumentation, document hypothesis, ask \"what would prevent this?\" | Clean commit; architecture note if applicable |\n\n## Hermes Agent Integration\n\n### Investigation Tools\n\nUse these Hermes tools during debugging:\n\n- **`search_files`** — Find error strings, trace function calls, locate patterns\n- **`read_file`** — Read source code with line numbers for precise analysis\n- **`terminal`** — Run tests, check git history, reproduce bugs\n\n### With delegate_task\n\nFor complex multi-component debugging, dispatch investigation subagents:\n\n```python\ndelegate_task(\n    goal=\"Investigate why [specific test\u002Fbehavior] fails\",\n    context=\"\"\"\n    Follow root-cause-debugging skill:\n    0. Build a tight feedback loop first\n    1. Reproduce and minimise\n    2. Find pattern differences\n    3. Generate ranked hypotheses\n    4. Report findings — do NOT fix yet\n\n    Error: [paste full error]\n    File: [path to failing code]\n    Test command: [exact command]\n    \"\"\",\n    toolsets=['terminal', 'file']\n)\n```\n\n### With change-test-loop\n\nWhen fixing bugs:\n1. Phase 0 → build the feedback loop that proves the bug\n2. Write a test that reproduces the bug (RED)\n3. Debug systematically to find root cause\n4. Fix the root cause (GREEN)\n5. The test proves the fix and prevents regression\n\n### With codebase-design\n\nWhen a bug resists fixing because no good test seam exists, use the `codebase-design` skill:\n- Evaluate whether the module is deep or shallow\n- Identify whether a seam can be introduced\n- Design the deepened module before attempting the fix\n\n## Real-World Impact\n\nFrom debugging sessions:\n- Systematic approach: 15-30 minutes to fix\n- Random fixes approach: 2-3 hours of thrashing\n- First-time fix rate: 95% vs 40%\n- New bugs introduced: Near zero vs common\n\n**No shortcuts. No guessing. Systematic always wins.**\n","# Root Cause Debugging\n\n## Overview\n\nRandom fixes waste time and create new bugs. Quick patches mask underlying issues.\n\n**Core principle:** ALWAYS build a tight feedback loop before theorizing. ALWAYS find root cause before attempting fixes. Symptom fixes are failure.\n\n**Violating the letter of this process is violating the spirit of debugging.**\n\n## The Iron Law\n\n```\nNO FIXES WITHOUT FEEDBACK LOOP FIRST\n```\n\nIf you haven't completed Phase 0 (built a tight pass\u002Ffail signal for the bug), you cannot propose fixes.\n\n## When to Use\n\nUse for ANY technical issue:\n- Test failures\n- Bugs in production\n- Unexpected behavior\n- Performance problems\n- Build failures\n- Integration issues\n\n**Use this ESPECIALLY when:**\n- Under time pressure (emergencies make guessing tempting)\n- \"Just one quick fix\" seems obvious\n- You've already tried multiple fixes\n- Previous fix didn't work\n- You don't fully understand the issue\n\n**Don't skip when:**\n- Issue seems simple (simple bugs have root causes too)\n- You're in a hurry (rushing guarantees rework)\n- Someone wants it fixed NOW (systematic is faster than thrashing)\n\n## When There Is More Than One Failure — Triage First\n\nPhases 0-5 fix ONE bug. Before picking *which* bug, triage the whole failing set:\nrun each failing file once, capture the FIRST failure reason each produces, and\ngroup by **signature** — the named cause, not the file path. **Count each group**\n— a count is evidence; \"roughly N\" is a guess that hides where the leverage is.\n\nPick the next fix as the largest group whose members share ONE cause: N files\nunder a single named cause is leverage (one fix, N greens). A group whose members\nare independent artifacts — same symptom, different causes — is a checklist, not\none fix; name it as such rather than claiming a shared root.\n\nRecord files that already PASS at the tip as their own explicit group. A file\nthat fails in a report but passes at the tip is flaky or fixed-in-range — a live\nrisk to own, not silence.\n\n## The Six Phases\n\nYou MUST complete each phase before proceeding to the next.\n\n---\n\n## Phase 0: Build a Feedback Loop\n\n**This is the skill.** Everything else is mechanical.\n\nIf you have a **tight** pass\u002Ffail signal for the bug — one that goes red on *this* bug — you will find the cause; bisection, hypothesis-testing, and instrumentation all just consume it. If you don't have one, no amount of staring at code will save you.\n\nSpend disproportionate effort here. **Be aggressive. Be creative. Refuse to give up.**\n\n### Ways to construct one — try in roughly this order\n\n1. **Failing test** at whatever seam reaches the bug — unit, integration, e2e.\n2. **Curl \u002F HTTP script** against a running dev server.\n3. **CLI invocation** with a fixture input, diffing stdout against a known-good snapshot.\n4. **Headless browser script** (Playwright \u002F Puppeteer) — drives the UI, asserts on DOM\u002Fconsole\u002Fnetwork.\n5. **Replay a captured trace.** Save a real network request \u002F payload \u002F event log to disk; replay it through the code path in isolation.\n6. **Throwaway harness.** Spin up a minimal subset of the system (one service, mocked deps) that exercises the bug code path with a single function call.\n7. **Property \u002F fuzz loop.** If the bug is \"sometimes wrong output\", run 1000 random inputs and look for the failure mode.\n8. **Bisection harness.** If the bug appeared between two known states (commit, dataset, version), automate \"boot at state X, check, repeat\" so you can `git bisect run` it.\n9. **Differential loop.** Run the same input through old-version vs new-version (or two configs) and diff outputs.\n10. **HITL bash script.** Last resort. If a human must click, drive *them* with a structured loop script so the loop is still repeatable. Captured output feeds back to you.\n\nBuild the right feedback loop, and the bug is 90% fixed.\n\n### Tighten the loop\n\nTreat the loop as a product. Once you have *a* loop, **tighten** it:\n\n- Can I make it faster? (Cache setup, skip unrelated init, narrow the test scope.)\n- Can I make the signal sharper? (Assert on the specific symptom, not \"didn't crash\".)\n- Can I make it more deterministic? (Pin time, seed RNG, isolate filesystem, freeze network.)\n\nA 30-second flaky loop is barely better than no loop; a 2-second deterministic one is a debugging superpower.\n\n### Non-deterministic bugs\n\nThe goal is not a clean repro but a **higher reproduction rate**. Loop the trigger 100×, parallelise, add stress, narrow timing windows, inject sleeps. A 50%-flake bug is debuggable; 1% is not — keep raising the rate until it's debuggable.\n\n**Determinism is the DEFAULT — do not label a bug \"non-deterministic\" until you have\nproven it.** Before reaching for flakiness as the explanation, rule out the\ndeterministic causes: pin the seed (`PYTHONHASHSEED=0`), the timezone, the clock,\nand the iteration order, then re-run. A failure that reproduces identically on every\nrun is deterministic even when the *output* looks random; calling it nondeterminism\nsends the investigation toward flake-hunting and away from the real, findable cause.\nYou cannot call a bug intermittent without a measured reproduction rate.\n\n### When you genuinely cannot build a loop\n\nStop and say so explicitly. List what you tried. Ask the user for: (a) access to whatever environment reproduces it, (b) a captured artifact (HAR file, log dump, core dump, screen recording with timestamps), or (c) permission to add temporary production instrumentation. Do **not** proceed to hypothesise without a loop.\n\n### Phase 0 Completion Checklist\n\n- [ ] A tight, deterministic pass\u002Ffail signal exists\n- [ ] The signal goes red on *this specific bug* (proven by running it)\n- [ ] The loop is fast enough to iterate on (seconds, not minutes)\n- [ ] It can be run unattended (or HITL script exists for manual steps)\n\n**STOP:** Do not proceed to Phase 1 without a tight feedback loop.\n\n---\n\n## Phase 1: Reproduce + Minimise\n\n**Before anything else:** confirm the bug.\n\nRun the loop from Phase 0. Watch it go red.\n\nConfirm:\n- [ ] The loop produces the failure mode the **user** described — not a different failure that happens to be nearby. Wrong bug = wrong fix.\n- [ ] The failure is reproducible across multiple runs (or, for non-deterministic bugs, reproducible at a high enough rate to debug against).\n- [ ] You have captured the exact symptom (error message, wrong output, timing) so later phases can verify the fix actually addresses it.\n\n### Minimise\n\nOnce it's red, shrink the repro to the **smallest scenario that still goes red**. Cut inputs, callers, config, data, and steps **one at a time**, re-running the loop after each cut — keep only what's load-bearing for the failure.\n\nWhy bother: a minimal repro shrinks the hypothesis space (fewer moving parts left to suspect) and becomes the clean regression test in Phase 4.\n\nDone when **every remaining element is load-bearing** — removing any one of them makes the loop go green.\n\n### Evidence Gathering\n\nNow that you have a minimised repro, gather evidence systematically:\n\n1. **Read Error Messages Carefully** — stack traces, line numbers, error codes\n2. **Check Recent Changes** — `git log --oneline -10`, `git diff`\n3. **Trace Data Flow** — where does the bad value originate? Trace upstream to find the source\n\n**A reported diagnosis is a hypothesis, not a fact.** A handoff, a summary, or a\nprior pass that says *\"the cause is X\"* is a claim to VERIFY against the\nunderlying data — the rows, the query, the log — never a premise to act on. A\nconfident report can be confidently wrong; in practice a triage report can name\nthe wrong cause for every symptom and send the fix the wrong way. Read the\nartifact the diagnosis rests on and confirm it yourself before writing any fix.\n\n**An absent CALLER is not an absent WRITER.** When you cannot find what produces a value,\ngrepping for the file's name — or for the helper that constructs its path — finds only the\nREADERS. A writer that builds the same path inline, or writes from another module entirely,\nis invisible to that search, and the empty result reads as \"nothing writes this\". Measured:\na per-session state file whose only references were its constructor's `def` and two read\nsites, so the hunt ended in a confident and WRONG claim, committed, that no writer existed —\nthe writer had been building that path inline all along, inside the very function being\ninvestigated. Search for what WRITES the artifact (`write_text` \u002F `write` \u002F `>` over the same\nexpression, or the state directory itself), not for callers of the path's constructor; and\nnever let a negative grep become a stated fact without a second, differently-shaped method\nthat could have found the positive.\n\n**Action:** Use `read_file` on relevant source files. Use `search_files` to trace references:\n\n```python\n# Find where the function is called\nsearch_files(\"function_name(\", path=\"src\u002F\", file_glob=\"*.py\")\n\n# Find where the variable is set\nsearch_files(r\"variable_name\\s*=\", path=\"src\u002F\", file_glob=\"*.py\")\n```\n\n4. **Multi-Component Systems** — for each component boundary, log what enters and exits. Find WHERE it breaks before investigating the specific component.\n\n### Phase 1 Completion Checklist\n\n- [ ] Bug reproduced and confirmed as the *correct* bug\n- [ ] Repro minimised to smallest load-bearing scenario\n- [ ] Error messages fully read and understood\n- [ ] Recent changes identified and reviewed\n- [ ] Evidence gathered (logs, state, data flow)\n- [ ] Problem isolated to specific component\u002Fcode\n\n---\n\n## Phase 2: Pattern Analysis\n\n**Find the pattern before hypothesising:**\n\n### 1. Find Working Examples\n\n- Locate similar working code in the same codebase\n- What works that's similar to what's broken?\n\n**Action:** Use `search_files` to find comparable patterns:\n\n```python\nsearch_files(\"similar_pattern\", path=\"src\u002F\", file_glob=\"*.py\")\n```\n\n### 2. Compare Against References\n\n- If implementing a pattern, read the reference implementation COMPLETELY\n- Don't skim — read every line\n- Understand the pattern fully before applying\n\n### 3. Identify Differences\n\n- What's different between working and broken?\n- List every difference, however small\n- Don't assume \"that can't matter\"\n\n### 4. Understand Dependencies\n\n- What other components does this need?\n- What settings, config, environment?\n- What assumptions does it make?\n\n### Phase 2 Completion\n\n- [ ] Working examples found and compared\n- [ ] Differences identified between working and broken\n\n---\n\n## Phase 3: Hypothesise + Instrument\n\n### Generate 3-5 Ranked Hypotheses\n\nGenerate **3-5 ranked hypotheses** before testing any of them. Single-hypothesis generation anchors on the first plausible idea.\n\nEach hypothesis must be **falsifiable**: state the prediction it makes.\n\n> Format: \"If \u003CX> is the cause, then \u003Cchanging Y> will make the bug disappear \u002F \u003Cchanging Z> will make it worse.\"\n\nIf you cannot state the prediction, the hypothesis is a vibe — discard or sharpen it.\n\n**Show the ranked list to the user before testing.** They often have domain knowledge that re-ranks instantly (\"we just deployed a change to #3\"), or know hypotheses they've already ruled out. Cheap checkpoint, big time saver. Don't block on it — proceed with your ranking if the user is AFK.\n\n### Instrument — One Variable at a Time\n\nEach probe must map to a specific prediction from Phase 3. **Change one variable at a time.**\n\n**Tool preference:**\n1. **Debugger \u002F REPL inspection** if the env supports it. One breakpoint beats ten logs.\n2. **Targeted logs** at the boundaries that distinguish hypotheses.\n3. Never \"log everything and grep\".\n\n**Tag every debug log** with a unique prefix, e.g. `[DEBUG-a4f2]`. Cleanup at the end becomes a single grep. Untagged logs survive; tagged logs die.\n\n**Perf branch.** For performance regressions, logs are usually wrong. Instead: establish a baseline measurement (timing harness, `performance.now()`, profiler, query plan), then bisect. Measure first, fix second.\n\n**When You Don't Know**\n- Say \"I don't understand X\"\n- Don't pretend to know\n- Ask the user for help\n- Research more\n\n**Decision table — which probe to use:**\n\n| Situation | Probe |\n|-----------|-------|\n| Debugger\u002FREPL available for the runtime | Breakpoint at the boundary — one breakpoint beats ten logs |\n| No debugger, deterministic repro | Tagged log (`[DEBUG-xxxx]`) at the boundary that distinguishes hypotheses #1 vs #2 |\n| Bug is a wrong value | Log the value's origin and each transform (`search_files` on `variable\\s*=` first) |\n| Bug is performance | NO logs — baseline measurement (profiler, query plan, `performance.now()`), then bisect |\n| Bug is intermittent | Raise repro rate first (see Phase 0) before probing — 1% flakes can't be probed |\n| Bug spans components | Log inputs AND outputs at each component boundary before opening any single component |\n\n### Phase 3 Completion Checklist\n\n- [ ] 3-5 ranked hypotheses generated (shown to user if present)\n- [ ] Each hypothesis is falsifiable with a prediction\n- [ ] Instrumentation probes one variable at a time\n- [ ] Debug logs tagged with unique prefix\n- [ ] Perf bugs: baseline measurement established before fix\n\n---\n\n## Phase 4: Fix + Regression Test\n\n**Fix the root cause, not the symptom:**\n\n### 1. Check for a Correct Test Seam\n\nWrite the regression test **before the fix** — but only if there is a **correct seam** for it.\n\nA correct seam is one where the test exercises the **real bug pattern** as it occurs at the call site. If the only available seam is too shallow (unit test that can't replicate the chain that triggered the bug), a regression test there gives false confidence.\n\n**If no correct seam exists, that itself is the finding.** Note it. The codebase architecture is preventing the bug from being locked down. This is a candidate for the `codebase-design` skill — the module needs deepening to create a testable seam.\n\n**Rollback:** every fix must be reversible. Before applying the fix, note the baseline: `git status` clean + `git rev-parse HEAD`. If the fix goes wrong mid-way: `git checkout -- \u003Cfiles-touched>` restores the pre-fix state (or `git stash` if you want to keep partial work). Never push a fix you cannot undo.\n\n### 2. If a Correct Seam Exists\n\n1. Turn the minimised repro into a failing test at that seam (RED)\n2. Watch it fail for the correct reason\n3. Apply the fix — ONE change at a time\n4. Watch it pass (GREEN)\n5. Re-run the Phase 0 feedback loop against the **original (un-minimised)** scenario\n\n```bash\n# Run the specific regression test\npytest tests\u002Ftest_module.py::test_regression -v\n\n# Run full suite — no regressions\npytest tests\u002F -q\n```\n\n### 3. If Fix Doesn't Work — The Rule of Three\n\n- **STOP.**\n- Count: How many fixes have you tried?\n- If \u003C 3: Return to Phase 1, re-analyse with new information\n- **If ≥ 3: STOP and question the architecture (step 4 below)**\n- DON'T attempt Fix #4 without architectural discussion\n\n### 4. If 3+ Fixes Failed: Question Architecture\n\n**Pattern indicating an architectural problem:**\n- Each fix reveals new shared state\u002Fcoupling in a different place\n- Fixes require \"massive refactoring\" to implement\n- Each fix creates new symptoms elsewhere\n\n**STOP and question fundamentals.** Discuss with the user before attempting more fixes. This is NOT a failed hypothesis — this is a wrong architecture. Use the `codebase-design` skill to evaluate module depth, seam placement, and adapter strategy.\n\n### Phase 4 Completion Checklist\n\n- [ ] Correct seam identified (or absence documented)\n- [ ] Regression test passes at the seam\n- [ ] Original Phase 0 loop goes green\n- [ ] Full test suite passes\n- [ ] No regressions introduced\n\n---\n\n## Phase 5: Cleanup + Post-mortem\n\n**Required before declaring done:**\n\n- [ ] Original repro no longer reproduces (re-run the Phase 0 loop)\n- [ ] Regression test passes (or absence of seam is documented)\n- [ ] All `[DEBUG-...]` instrumentation removed (`grep` the prefix)\n- [ ] Throwaway prototypes deleted (or moved to a clearly-marked debug location)\n- [ ] The hypothesis that turned out correct is stated in the commit \u002F PR message — so the next debugger learns\n\n**Then ask: what would have prevented this bug?** If the answer involves architectural change (no good test seam, tangled callers, hidden coupling), hand off to the `codebase-design` skill with the specifics. Make the recommendation **after** the fix is in, not before — you have more information now than when you started.\n\n---\n\n## Red Flags — STOP and Follow Process\n\nIf you catch yourself thinking:\n- \"Quick fix for now, investigate later\"\n- \"Just try changing X and see if it works\"\n- \"Add multiple changes, run tests\"\n- \"Skip the test, I'll manually verify\"\n- \"It's probably X, let me fix that\"\n- \"I don't fully understand but this might work\"\n- \"Pattern says X but I'll adapt it differently\"\n- \"Here are the main problems: [lists fixes without investigation]\"\n- Proposing solutions before a tight feedback loop exists\n- **\"One more fix attempt\" (when already tried 2+)**\n- **Each fix reveals a new problem in a different place**\n\n**ALL of these mean: STOP. Return to Phase 0.**\n\n**If 3+ fixes failed:** Question the architecture (Phase 4 step 4).\n\n## Common Rationalizations\n\n| Excuse | Reality |\n|--------|---------|\n| \"Issue is simple, don't need process\" | Simple issues have root causes too. Process is fast for simple bugs. |\n| \"Emergency, no time for process\" | Systematic debugging is FASTER than guess-and-check thrashing. |\n| \"Just try this first, then investigate\" | Without a feedback loop, you can't tell if the fix worked. Build the loop first. |\n| \"I'll write test after confirming fix works\" | Untested fixes don't stick. Test first proves it. |\n| \"Multiple fixes at once saves time\" | Can't isolate what worked. Causes new bugs. |\n| \"Reference too long, I'll adapt the pattern\" | Partial understanding guarantees bugs. Read it completely. |\n| \"I see the problem, let me fix it\" | Seeing symptoms ≠ understanding root cause. |\n| \"One more fix attempt\" (after 2+ failures) | 3+ failures = architectural problem. Question the pattern, don't fix again. |\n\n## Quick Reference\n\n| Phase | Key Activities | Success Criteria |\n|-------|---------------|------------------|\n| **0. Feedback Loop** | Build tight pass\u002Ffail signal; 10 construction methods; tighten loop | One command that goes red on *this bug* |\n| **1. Reproduce + Minimise** | Run the loop, confirm correct bug, minimise, gather evidence | Minimal repro; bug understood |\n| **2. Pattern Analysis** | Find working examples, compare, identify differences | Know what's different |\n| **3. Hypothesise + Instrument** | 3-5 ranked hypotheses, tagged debug logs, one variable at a time | Confirmed hypothesis; root cause identified |\n| **4. Fix + Regression Test** | Check seam, RED-GREEN, verify original loop goes green | Bug resolved, all tests pass |\n| **5. Cleanup + Post-mortem** | Remove instrumentation, document hypothesis, ask \"what would prevent this?\" | Clean commit; architecture note if applicable |\n\n## Hermes Agent Integration\n\n### Investigation Tools\n\nUse these Hermes tools during debugging:\n\n- **`search_files`** — Find error strings, trace function calls, locate patterns\n- **`read_file`** — Read source code with line numbers for precise analysis\n- **`terminal`** — Run tests, check git history, reproduce bugs\n\n### With delegate_task\n\nFor complex multi-component debugging, dispatch investigation subagents:\n\n```python\ndelegate_task(\n    goal=\"Investigate why [specific test\u002Fbehavior] fails\",\n    context=\"\"\"\n    Follow root-cause-debugging skill:\n    0. Build a tight feedback loop first\n    1. Reproduce and minimise\n    2. Find pattern differences\n    3. Generate ranked hypotheses\n    4. Report findings — do NOT fix yet\n\n    Error: [paste full error]\n    File: [path to failing code]\n    Test command: [exact command]\n    \"\"\",\n    toolsets=['terminal', 'file']\n)\n```\n\n### With change-test-loop\n\nWhen fixing bugs:\n1. Phase 0 → build the feedback loop that proves the bug\n2. Write a test that reproduces the bug (RED)\n3. Debug systematically to find root cause\n4. Fix the root cause (GREEN)\n5. The test proves the fix and prevents regression\n\n### With codebase-design\n\nWhen a bug resists fixing because no good test seam exists, use the `codebase-design` skill:\n- Evaluate whether the module is deep or shallow\n- Identify whether a seam can be introduced\n- Design the deepened module before attempting the fix\n\n## Real-World Impact\n\nFrom debugging sessions:\n- Systematic approach: 15-30 minutes to fix\n- Random fixes approach: 2-3 hours of thrashing\n- First-time fix rate: 95% vs 40%\n- New bugs introduced: Near zero vs common\n\n**No shortcuts. No guessing. Systematic always wins.**\n",{"name":5,"author":24,"license":15,"version":25,"metadata":26,"platforms":39,"description":7},"Steadfaste Fleet","2.0.0",{"hermes":27},{"tags":28,"related_skills":34},[29,30,31,32,33],"debugging","troubleshooting","problem-solving","root-cause","investigation",[35,36,37,38],"change-test-loop","plan","subagent-driven-development","codebase-design",[40,41,42],"linux","macos","windows","main","2e6aa8d15ab0a366c90be54f61bf9c6e97015e83","skills\u002Fsoftware-development\u002Froot-cause-debugging",1,"https:\u002F\u002Fgithub.com\u002Flukemcqueen\u002Fsteadfaste-fleet","steadfaste.com","https:\u002F\u002Fgithub.com\u002Flukemcqueen","AI Architect | Building Hermes Cortex: governed multi-agent AI for autonomous software engineering | Enterprise Tech Consultant","2026-11-14 22:33:34",{"source":8,"skillName":5,"commands":53,"prompt":63,"zipAvailable":64},[54,57,60],{"tool":55,"command":56},"npx","npx skills add lukemcqueen\u002Fsteadfaste-fleet --skill root-cause-debugging",{"tool":58,"command":59},"bunx","bunx skills add lukemcqueen\u002Fsteadfaste-fleet --skill root-cause-debugging",{"tool":61,"command":62},"pnpm","pnpm dlx skills add lukemcqueen\u002Fsteadfaste-fleet --skill root-cause-debugging","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Flukemcqueen\u002Fsteadfaste-fleet\u002Fblob\u002Fmain\u002Fskills\u002Fsoftware-development\u002Froot-cause-debugging\u002FSKILL.md",true,[],[67,75,82,89,96,103],{"skillNo":68,"name":69,"nameZh":6,"description":70,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":71,"categories":72,"keywords":73,"publishedAt":74},"01M7DXY4G8NSVB59K8B6S2AQNP","macbook-linux-maintenance","Legacy MacBook Linux fixes: GPU wedge, reboot hang, thermal.","https:\u002F\u002Fgithub.com\u002Flukemcqueen\u002Fsteadfaste-fleet\u002Fblob\u002Fmain\u002Fskills\u002Fdevops\u002Fmacbook-linux-maintenance\u002FSKILL.md",[],[],"2026-11-15 14:19:17",{"skillNo":76,"name":77,"nameZh":6,"description":78,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":79,"categories":80,"keywords":81,"publishedAt":74},"01M7DXXYJCXFJ3TGB84ZQ8KFE6","governance-regression-triage","Triage a host's governance issues: what changed.","https:\u002F\u002Fgithub.com\u002Flukemcqueen\u002Fsteadfaste-fleet\u002Fblob\u002Fmain\u002Fskills\u002Fdevops\u002Fgovernance-regression-triage\u002FSKILL.md",[],[],{"skillNo":83,"name":84,"nameZh":6,"description":85,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":86,"categories":87,"keywords":88,"publishedAt":74},"01M7DXXSAP1G8FDRJAMXQGBBMK","enforcement-immutability","Use when enforcement files lose their immutable flag.","https:\u002F\u002Fgithub.com\u002Flukemcqueen\u002Fsteadfaste-fleet\u002Fblob\u002Fmain\u002Fskills\u002Fdevops\u002Fenforcement-immutability\u002FSKILL.md",[],[],{"skillNo":90,"name":91,"nameZh":6,"description":92,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":93,"categories":94,"keywords":95,"publishedAt":74},"01M78SSDQVRYX64Y16X32TC0NS","steadfaste-fleet-repo-deploy","Use when committing to the steadfaste-fleet repo.","https:\u002F\u002Fgithub.com\u002Flukemcqueen\u002Fsteadfaste-fleet\u002Fblob\u002Fmain\u002Fskills\u002Fdevops\u002Fsteadfaste-fleet-repo-deploy\u002FSKILL.md",[],[],{"skillNo":97,"name":98,"nameZh":6,"description":99,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":100,"categories":101,"keywords":102,"publishedAt":74},"01M78SS928F3R2RJAYVW4E30CE","steadfaste-fleet-maintenance","Maintain an installed Steadfaste Fleet instance — update both the upstream Hermes Agent and the fleet repo layer, merge diverged histories, sync skills safely, and troubleshoot common issues. Covers the dual-update workflow (hermes update + fleet-update.sh), encrypted brain data backup, mycortex import, and recovery techniques.","https:\u002F\u002Fgithub.com\u002Flukemcqueen\u002Fsteadfaste-fleet\u002Fblob\u002Fmain\u002Fskills\u002Fdevops\u002Fsteadfaste-fleet-maintenance\u002FSKILL.md",[],[],{"skillNo":104,"name":105,"nameZh":6,"description":106,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":107,"categories":108,"keywords":109,"publishedAt":74},"01M78SP1CHW0T0BWE5ZT6JBPX8","fleet-preflight","DEPRECATED alias — merged into survey-before-action (2026-08-20). Load survey-before-action instead; its \"Repo-Specific Pre-Flight\" section covers git search, Hermes boundary, and deployment verification.","https:\u002F\u002Fgithub.com\u002Flukemcqueen\u002Fsteadfaste-fleet\u002Fblob\u002Fmain\u002Fskills\u002Fdevops\u002Ffleet-preflight\u002FSKILL.md",[],[]]