<!-- AUTO-GENERATED from SKILL.md.tmpl — do not edit directly --> <!-- Regenerate: bun run gen:skill-docs -->

Telemetry (run last)

After workflow completion, log telemetry with ONE command. OUTCOME is success/error/abort/unknown; SESSION_ID and TEL_START are the values the preamble's skill-start output echoed. It also drains the artifacts-sync queue (the former skill-end sync step — do not run gstack-brain-sync separately).

PLAN MODE EXCEPTION — ALWAYS RUN: This writes telemetry to $GSTACK_STATE_ROOT/analytics/, matching preamble analytics writes.

~/.claude/skills/gstack/bin/gstack-skill-end --skill "investigate" --outcome OUTCOME \
  --session-id "SESSION_ID" --tel-start "TEL_START" --used-browse USED_BROWSE \
  --error-message "ERROR_MESSAGE" --failed-step "FAILED_STEP" 2>/dev/null || true

Replace OUTCOME and USED_BROWSE (yes/no) before running; substitute SESSION_ID/TEL_START from the skill-start echoes. ERROR_MESSAGE/FAILED_STEP are "" unless outcome is error. If the command is missing (stale install), skip telemetry — it never blocks the workflow.

Systematic Debugging

Iron Law

NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST.

Fixing symptoms creates whack-a-mole debugging. Every fix that doesn't address root cause makes the next bug harder to find. Find the root cause, then fix it.

Arguments

Section index — Read each section when its situation applies

This skill is a decision-tree skeleton. The steps below point to on-demand sections. Read a section in full before doing its step; do not work from memory.

Phase 1: Root Cause Investigation

Gather context before forming any hypothesis.

1. Collect symptoms: Read the error messages, stack traces, and reproduction steps. If the user hasn't provided enough context, ask ONE question at a time via AskUserQuestion.

1. Read the code: Trace the code path from the symptom back to potential causes. Use Grep to find all references, Read to understand the logic. Before calling two queries, helpers or code paths duplicates, read their call sites: what looks identical usually differs in a caller's guard, transaction or scope, and the "duplicate" is the one that is right.

1. Check recent changes: ``bash git log --oneline -20 -- <affected-files> `` Was this working before? What changed? A regression means the root cause is in the diff.

1. Reproduce: Can you trigger the bug deterministically? If not, gather more evidence before proceeding. Before timing anything that spawns git in a benchmark or bisect worktree, run git update-index --refresh there: a stale index makes the first git status/git diff pay a full refresh and the measurement lies.

1. Check investigation history: Search prior learnings for investigations on the same files. Recurring bugs in the same area are an architectural smell. If prior investigations exist, note patterns and check if the root cause was structural.

Prior Learnings

Search for relevant learnings from previous sessions:

_CROSS_PROJ=$(~/.claude/skills/gstack/bin/gstack-config get cross_project_learnings 2>/dev/null || echo "unset")
echo "CROSS_PROJECT: $_CROSS_PROJ"
if [ "$_CROSS_PROJ" = "true" ]; then
  { _LE=$(~/.claude/skills/gstack/bin/gstack-learnings-search --limit 10 --query "debug investigation root cause hypothesis bug fix" --cross-project 2>&1 >&3 3>&-); _LR=$?; } 3>&1
else
  { _LE=$(~/.claude/skills/gstack/bin/gstack-learnings-search --limit 10 --query "debug investigation root cause hypothesis bug fix" 2>&1 >&3 3>&-); _LR=$?; } 3>&1
fi
[ "$_LR" = 0 ] || { _LE=${_LE%%$'\n'*}; echo "LEARNINGS: unavailable (${_LE:-exit $_LR})"; }

If CROSS_PROJECT is unset (first time): Use AskUserQuestion:

gstack can search learnings from your other projects on this machine to find patterns that might apply here. This stays local (no data leaves your machine). Recommended for solo developers. Skip if you work on multiple client codebases where cross-contamination would be a concern.

Options:

• A) Enable cross-project learnings (recommended)
• B) Keep learnings project-scoped only

If A: run ~/.claude/skills/gstack/bin/gstack-config set cross_project_learnings true If B: run ~/.claude/skills/gstack/bin/gstack-config set cross_project_learnings false

Then re-run the search with the appropriate flag.

If learnings are found, incorporate them into your analysis. When a review finding matches a past learning, display:

"Prior learning applied: [key] (confidence N/10, from [date])"

This makes the compounding visible. The user should see that gstack is getting smarter on their codebase over time.

Output: "Root cause hypothesis: ..." — a specific, testable claim about what is wrong and why.

Refresh learnings for the hypothesis you just named

The top-of-skill learnings pull above is keyed to "debug investigation" broadly. Now that you have a specific hypothesis, re-pull learnings keyed to that hypothesis so prior fixes for the same problem-shape surface.

Pick ONE keyword from the hypothesis. The keyword should be a noun: the failing component name, the basename of the file you suspect (without extension), or the bug noun. The keyword MUST be alphanumeric or hyphen only — no quotes, slashes, dots, colons, or whitespace. If your candidate has any of those, simplify to just the alphanumeric stem.

Worked examples (investigate-specific): good keywords are auth-cookie, session-expiry, redirect-loop. Bad: auth.ts:47, fix the auth bug, <hypothesis-keyword>.

{ _LE=$(~/.claude/skills/gstack/bin/gstack-learnings-search --query "<your-keyword>" --limit 5 2>&1 >&3 3>&-); _LR=$?; } 3>&1
[ "$_LR" = 0 ] || { _LE=${_LE%%$'\n'*}; echo "LEARNINGS: unavailable (${_LE:-exit $_LR})"; }

If any learnings come back, name which one applies to your investigation in one sentence. If none come back, continue without reference — the absence of a matching prior learning is itself useful information.

Scope Lock

After forming your root cause hypothesis, lock edits to the affected module to prevent scope creep.

# $HOME-anchored like the careful/freeze frontmatter hooks: early skill bash runs
# before CLAUDE_SKILL_DIR exists, so a relative path would never resolve.
_FREEZE_SCRIPT="$HOME/.claude/skills/gstack/freeze/bin/check-freeze.sh"
[ -x "$_FREEZE_SCRIPT" ] && echo "FREEZE_AVAILABLE" || echo "FREEZE_UNAVAILABLE"

If FREEZE_AVAILABLE: Identify the narrowest directory containing the affected files. Acquire a run-owned boundary; the helper resolves its physical absolute path and leaves any pre-existing user or other-run boundary untouched:

bash "$HOME/.claude/skills/gstack/freeze/bin/freeze-state.sh" acquire "<detected-directory>"

Substitute <detected-directory> with the actual path (e.g., src/auth/). Retain the exact returned FREEZE_OWNER token in this run's context (including any checkpoint); never reconstruct it from the current state file. Only a returned token means this run owns a new lock. FREEZE_PRESERVED means keep the existing boundary and do not clean it up. On acquisition error, pause before edits and report it; never claim a lock was acquired. Relative legacy state is ambiguous: ask the user to re-establish an absolute boundary via /freeze, rather than guessing its original cwd.

Tell the user the boundary and its owner disposition. Hooks enforce Edit/Write/NotebookEdit restrictions only on hosts supporting those callbacks; on Capy they are advisory. Bash remains outside hook enforcement.

Terminal cleanup: On completion, explicit abort, or any known error that ends this investigation, run the following with this run's retained token, before the final response. Skip it when this run acquired no token:

bash "$HOME/.claude/skills/gstack/freeze/bin/freeze-state.sh" release "<retained-owner-token>"

The helper compares ownership and removes state under the same mutation lock used by /freeze, /guard, and /unfreeze; a replacement boundary is preserved, even at the same path. Report cleanup errors or FREEZE_PRESERVED, never retry by deleting state directly. A hard-killed session cannot run this cleanup: recovery is explicit /unfreeze (user-requested removal) or /freeze (user-selected replacement). If a mutation lock was abandoned, inspect it with the user after confirming no writer is active; never automatically delete an ambiguous lock.

If the bug spans the entire repo or the scope is genuinely unclear, skip the lock and note why.

If FREEZE_UNAVAILABLE: Skip scope lock. Edits are unrestricted.

Phase 2: Pattern Analysis

Check if this bug matches a known pattern:

Also check:

• TODOS.md for related known issues
• git log for prior fixes in the same area — recurring bugs in the same files are an architectural smell, not a coincidence

Recipes

Intermittent or CI-only failures, order-dependent failures, races and regressed judged metrics each have a recipe. Read the matching one before Phase 3; a rerun, a wider timeout or a skip is never a hypothesis.

STOP. Before investigating a test that fails intermittently or only in CI (a flake), before any rerun, timeout or skip, Read ~/.claude/skills/gstack/investigate/sections/flake.md and execute it in full. Do not work from memory — that section is the source of truth for this step.

STOP. Before investigating a test that passes alone and fails in the suite or in one shard (order-dependent), Read ~/.claude/skills/gstack/investigate/sections/polluter.md and execute it in full. Do not work from memory — that section is the source of truth for this step.

STOP. Before investigating a timing-dependent failure or corrupted shared state (a race), before proposing a fix, Read ~/.claude/skills/gstack/investigate/sections/race.md and execute it in full. Do not work from memory — that section is the source of truth for this step.

STOP. Before investigating a judged or scored metric that regressed between two revisions (an eval bisect), Read ~/.claude/skills/gstack/investigate/sections/eval-bisect.md and execute it in full. Do not work from memory — that section is the source of truth for this step.

--backlog runs none of the phases:

STOP. Before running /investigate --backlog (read-only issue triage instead of Phases 1–5), Read ~/.claude/skills/gstack/investigate/sections/backlog.md and execute it in full. Do not work from memory — that section is the source of truth for this step.

External pattern search: If the bug doesn't match a known pattern above, research through Aside (Web research runs in Aside, above). Sanitize first: strip hostnames, IPs, file paths, SQL, customer data. Search the error category, not the raw message:

• "{framework} {generic error type}"
• "{library} {component} known issues"

Prompt file text (create, write and send it with the Web research runs in Aside blocks above): {framework} {generic error type} and {library} {component} known issues. Reply with up to 6 bullets, each with its source URL.

If the Aside check did not print READY, run the same searches with the WebSearch tool when the host provides it; with neither, skip this search and proceed with hypothesis testing. If a documented solution or known dependency bug surfaces, present it as a candidate hypothesis in Phase 3.

Phase 3: Hypothesis Testing

Before writing ANY fix, verify your hypothesis.

1. Confirm the hypothesis: Add a temporary log statement, assertion, or debug output at the suspected root cause. Run the reproduction. Does the evidence match?

1. If the hypothesis is wrong: Before forming the next hypothesis, consider searching for the error through Aside, as in Phase 2. Sanitize first — strip hostnames, IPs, file paths, SQL fragments, customer identifiers, and any internal/proprietary data from the error message. Search only the generic error type and framework context: "{component} {sanitized error type} {framework version}". If the error message is too specific to sanitize safely, skip the search. If the Aside check did not print READY, use the WebSearch tool when the host provides it; with neither, skip and proceed. Then return to Phase 1. Gather more evidence. Do not guess.

1. 3-strike rule: If 3 hypotheses fail, STOP. Use AskUserQuestion: ``` 3 hypotheses tested, none match. This may be an architectural issue rather than a simple bug.

A) Continue investigating — I have a new hypothesis: [describe] B) Escalate for human review — this needs someone who knows the system C) Add logging and wait — instrument the area and catch it next time ```

Red flags — if you see any of these, slow down:

• "Quick fix for now" — there is no "for now." Fix it right or escalate.
• Proposing a fix before tracing data flow — you're guessing.
• Each fix reveals a new problem elsewhere — wrong layer, not wrong code.
• Two fixes that shared one premise failed the same gate — write the premise down in one sentence and test it before a third fix. The evidence already points away from it.

Phase 4: Implementation

Once root cause is confirmed:

STOP. Before fixing a shared helper, library call or data format, or when asked what a change could break, Read ~/.claude/skills/gstack/investigate/sections/blast-radius.md and execute it in full. Do not work from memory — that section is the source of truth for this step.

1. Fix the root cause, not the symptom. The smallest change that eliminates the actual problem.

1. Minimal diff: Fewest files touched, fewest lines changed. Resist the urge to refactor adjacent code.

1. Write a regression test that:
2. Fails without the fix (proves the test is meaningful)
3. Passes with the fix (proves the fix works)

1. Run the full test suite. Paste the output. No regressions allowed.

1. If the fix touches >5 files: Use AskUserQuestion to flag the blast radius: `` This fix touches N files. That's a large blast radius for a bug fix. A) Proceed — the root cause genuinely spans these files B) Split — fix the critical path now, defer the rest C) Rethink — maybe there's a more targeted approach

Phase 5: Verification & Report

Fresh verification: Reproduce the original bug scenario and confirm it's fixed. This is not optional.

Run the test suite and paste the output.

Run the Scope Lock terminal cleanup before reporting completion or an ending error; only use this investigation's retained owner token.

Output a structured debug report:

DEBUG REPORT
════════════════════════════════════════
Symptom:         [what the user observed]
Root cause:      [what was actually wrong]
Fix:             [what was changed, with file:line references]
Evidence:        [test output, reproduction attempt showing fix works]
Regression test: [file:line of the new test]
Related:         [TODOS.md items, prior bugs in same area, architectural notes]
Status:          DONE | DONE_WITH_CONCERNS | BLOCKED
════════════════════════════════════════

Log the investigation as a learning for future sessions. Use type: "investigation" and include the affected files so future investigations on the same area can find this:

~/.claude/skills/gstack/bin/gstack-learnings-log '{"skill":"investigate","type":"investigation","key":"ROOT_CAUSE_KEY","insight":"ROOT_CAUSE_SUMMARY","confidence":9,"source":"observed","files":["affected/file1.ts","affected/file2.ts"]}'

Capture Learnings

If you discovered a non-obvious pattern, pitfall, or architectural insight during this session, log it for future sessions:

~/.claude/skills/gstack/bin/gstack-learnings-log '{"skill":"investigate","type":"TYPE","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":N,"source":"SOURCE","files":["path/to/relevant/file"]}'

Types: pattern (reusable approach), pitfall (what NOT to do), preference (user stated), architecture (structural decision), tool (library/framework insight), operational (project environment/CLI/workflow knowledge).

Sources: observed (you found this in the code), user-stated (user told you), inferred (AI deduction), cross-model (both Claude and Codex agree).

Confidence: 1-10. Be honest. An observed pattern you verified in the code is 8-9. An inference you're not sure about is 4-5. A user preference they explicitly stated is 10.

files: Include the specific file paths this learning references. This enables staleness detection: if those files are later deleted, the learning can be flagged.

Only log genuine discoveries. Don't log obvious things. Don't log things the user already knows. A good test: would this insight save time in a future session? If yes, log it.

Important Rules

• 3+ failed fix attempts → STOP and question the architecture. Wrong architecture, not failed hypothesis.
• Never apply a fix you cannot verify. If you can't reproduce and confirm, don't ship it.
• Never say "this should fix it." Verify and prove it. Run the tests.
• If fix touches >5 files → AskUserQuestion about blast radius before proceeding.
• Completion status:
• DONE — root cause found, fix applied, regression test written, all tests pass
• DONE_WITH_CONCERNS — fixed but cannot fully verify (e.g., intermittent bug, requires staging)
• BLOCKED — root cause unclear after investigation, escalated