@runfusion/fusion 0.73.0-beta.2 → 0.73.0-beta.4

package/dist/plugins/.fusion-ce-skills/ce-compound/scripts/validate-frontmatter.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+"""Validate ce-compound docs/solutions/ frontmatter for parser-safety issues.
+
+Usage:
+    python3 validate-frontmatter.py <doc-path>
+
+Exit codes:
+    0 — frontmatter passes all checks
+    1 — validation failure (diagnostics on stderr)
+    2 — usage error (bad arguments, missing file)
+
+Scope: this script catches *parser-safety* issues — frontmatter that strict
+YAML parsers will silently misread. It does NOT validate against the
+schema's required-field or enum-value rules; that's a separate concern. The
+intent is to prevent the silent-data-loss bug class where YAML's quoting
+rules truncate or reframe scalar values without raising.
+
+Checks (regex-based, no YAML parser dependency):
+    1. File starts and ends frontmatter with `---` lines (matched as full
+       lines, not substrings — `----` and `---extra` are rejected)
+    2. No top-level scalar value contains ` #` unquoted (silent comment
+       truncation — what Codex caught on PR #695)
+    3. No top-level scalar value contains `: ` unquoted (mapping confusion —
+       what surfaced in a 2026-04-16 plan doc's `title:` field)
+
+The script does NOT flag values starting with YAML reserved indicators
+(`` ` ``, `*`, `&`, `!`, etc.) because those produce loud parser errors
+downstream rather than silent corruption — they're already caught by
+whatever consumes the doc. This validator's purpose is silent-corruption
+prevention, not lint.
+
+Pure-stdlib (no PyYAML or other third-party deps). Runs in <50ms typical.
+Designed to produce concrete, actionable error messages so the calling
+agent can fix and retry without ambiguity.
+"""
+import os
+import re
+import sys
+
+
+def usage_fail(msg: str) -> "NoReturn":
+    sys.stderr.write(f"validate-frontmatter: {msg}\n")
+    sys.exit(2)
+
+
+def main(argv: list[str]) -> int:
+    if len(argv) != 2:
+        usage_fail(f"usage: {os.path.basename(argv[0])} <doc-path>")
+
+    doc_path = argv[1]
+    if not os.path.isfile(doc_path):
+        usage_fail(f"file not found: {doc_path}")
+
+    with open(doc_path) as f:
+        text = f.read()
+
+    issues: list[str] = []
+
+    # Check 1: frontmatter delimiters. Match the delimiter as a complete
+    # line whose stripped content is exactly `---` — substring matching
+    # (e.g. `text.find("\n---", 4)`) would falsely accept `----` or
+    # `---extra` as a terminator and let malformed docs slip through to
+    # downstream parsers that require a strict `---` line.
+    lines = text.split("\n")
+    if not lines or lines[0].rstrip() != "---":
+        sys.stderr.write(
+            f"FAIL: {doc_path}\n"
+            f"  file does not start with '---' frontmatter delimiter line\n"
+        )
+        return 1
+
+    end_idx: int | None = None
+    for i in range(1, len(lines)):
+        if lines[i].rstrip() == "---":
+            end_idx = i
+            break
+
+    if end_idx is None:
+        sys.stderr.write(
+            f"FAIL: {doc_path}\n"
+            f"  frontmatter not closed (no '---' line after the opening delimiter)\n"
+        )
+        return 1
+
+    fm_text = "\n".join(lines[1:end_idx])
+
+    # Checks 2 & 3: silent-corruption quoting risks on top-level scalar
+    # fields. We scan line-by-line and only flag top-level mapping entries
+    # (no leading whitespace) whose value isn't already quoted/structured.
+    for lineno, line in enumerate(fm_text.split("\n"), start=2):
+        stripped = line.lstrip()
+        if not stripped or stripped.startswith("#"):
+            continue
+        if ":" not in line:
+            continue
+        # Top-level mapping keys only — skip nested values, array items
+        if line.startswith((" ", "\t")):
+            continue
+        # Skip pure list-marker lines like "- item" (these can't be top-level
+        # in our frontmatter convention, but be defensive)
+        if stripped.startswith("- "):
+            continue
+
+        key, _, val = line.partition(":")
+        val_stripped = val.strip()
+        if not val_stripped:
+            # Key with no value on this line — likely a parent of a nested
+            # block (`tags:` followed by `- foo`). Nothing to validate here.
+            continue
+        # Already quoted or structured (block scalar, flow collection)
+        if val_stripped[0] in '"\'[{|>':
+            continue
+
+        if re.search(r"\s#", val_stripped):
+            issues.append(
+                f"line {lineno}: '{key.strip()}' value contains ' #' — quote it. "
+                "YAML treats space-then-# as a comment delimiter and silently "
+                "drops the rest of the value."
+            )
+        if re.search(r":\s", val_stripped):
+            issues.append(
+                f"line {lineno}: '{key.strip()}' value contains ': ' — quote it. "
+                "Strict YAML parsers may treat this as a nested mapping."
+            )
+
+    if issues:
+        sys.stderr.write(f"FAIL: {doc_path}\n")
+        for issue in issues:
+            sys.stderr.write(f"  {issue}\n")
+        return 1
+
+    print(f"OK: {doc_path}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))

package/dist/plugins/.fusion-ce-skills/ce-debug/SKILL.md

@@ -0,0 +1,257 @@
+---
+name: ce-debug
+description: 'Diagnosis loop for bugs and failing behavior. Use for errors, stack traces, regressions, failed tests, issue-tracker bugs, stuck investigations after failed fixes, or asks to debug/fix a bug.'
+argument-hint: "[issue reference, error message, test path, or description of broken behavior]"
+---
+
+# Debug and Fix
+
+<!--
+FNXC:CompoundEngineering 2026-07-01-13:43:
+When this skill runs inside the Compound Engineering dashboard, the host interactive-session protocol is authoritative. Ask clarifying or handoff questions by returning the host's JSON question object, and finish by returning the host's JSON complete object; do not emit prose-only turns or blocking question tool calls at the dashboard seam.
+-->
+
+Find root causes, then fix them. This skill investigates bugs systematically — tracing the full causal chain before proposing a fix — and optionally implements the fix with test-first discipline.
+
+<bug_description> #$ARGUMENTS </bug_description>
+
+## Core Principles
+
+1. **Investigate before fixing.** Do not propose a fix until you can explain the full causal chain from trigger to symptom with no gaps. "Somehow X leads to Y" is a gap.
+2. **Predictions for uncertain links.** When the causal chain has uncertain or non-obvious links, form a prediction — something in a different code path or scenario that must also be true. If the prediction is wrong but a fix "works," you found a symptom, not the cause. When the chain is obvious (missing import, clear null reference), the chain explanation itself is sufficient.
+3. **One change at a time.** Test one hypothesis, change one thing. If you're changing multiple things to "see if it helps," stop — that is shotgun debugging.
+4. **When stuck, diagnose why — don't just try harder.**
+
+## Execution Flow
+
+| Phase | Name | Purpose |
+|-------|------|---------|
+| 0 | Triage | Parse input, fetch issue if referenced, proceed to investigation |
+| 1 | Investigate | Reproduce the bug, trace the code path |
+| 2 | Root Cause | Form hypotheses with predictions for uncertain links, test them, **causal chain gate**, smart escalation |
+| 3 | Fix | Only if user chose to fix. Test-first fix with workspace safety checks |
+| 4 | Handoff | Structured summary, then prompt the user for the next action |
+
+Beyond the trivial-bug fast-path in Phase 0, no further phase skipping — complex bugs simply spend more time in each phase naturally. No further complexity tiers.
+
+---
+
+### Phase 0: Triage
+
+Parse the input and reach a clear problem statement.
+
+**If the input references an issue tracker**, fetch it:
+- GitHub (`#123`, `org/repo#123`, github.com URL): Parse the issue reference from `<bug_description>` and fetch with `gh issue view <number> --json title,body,comments,labels`. For URLs, pass the URL directly to `gh`.
+- Other trackers (Linear URL/ID, Jira URL/key, any tracker URL): Attempt to fetch using available MCP tools or by fetching the URL content. If the fetch fails — auth, missing tool, non-public page — ask the user to paste the relevant issue content. Ensure the fetch includes the full comment thread, not just the opening description.
+
+Read the full conversation — the original description AND every comment, with particular attention to the latest ones. Comments frequently contain updated reproduction steps, narrowed scope, prior failed attempts, additional stack traces, or a pivot to a different suspected root cause; treating the opening post as the whole picture often sends the investigation in the wrong direction. Extract reported symptoms, expected behavior, reproduction steps, and environment details from the combined thread. Then proceed to Phase 1.
+
+**Everything else** (stack traces, test paths, error messages, descriptions of broken behavior): the problem statement is the input itself.
+
+**Trivial-bug fast-path:** Once the problem is clear, decide whether the framework is needed at all. If the cause is immediately readable from the input (single-file typo, missing import, obvious null deref or off-by-one with a one-line fix) and verification doesn't require deep tracing, present the cause and the proposed one-line fix and run Phase 2's **Fix it now / Diagnosis only** user-choice gate before editing — the fast-path saves investigation ceremony, not the user's choice over whether to apply a fix. If the user picks fix, run Phase 3's **Workspace and branch check** (uncommitted-work confirmation and default-branch branch-creation prompt), apply the fix, leave a one-line note explaining the cause, and skip to Phase 4's structured summary. If diagnosis only, write the summary and stop. When in doubt, run the full framework; getting the wrong root cause costs more than the few minutes of ceremony.
+
+**Otherwise**, proceed to Phase 1.
+
+**Questions:**
+- Do not ask questions by default — investigate first (read code, run tests, trace errors)
+- Only ask when a genuine ambiguity blocks investigation and cannot be resolved by reading code or running tests
+- When asking, ask one specific question
+
+**Prior-attempt awareness:** If the user indicates prior failed attempts ("I've been trying", "keeps failing", "stuck"), ask what they have already tried before investigating. This avoids repeating failed approaches and is one of the few cases where asking first is the right call.
+
+---
+
+### Phase 1: Investigate
+
+#### 1.1 Reproduce the bug
+
+Confirm the bug exists and understand its behavior. Run the test, trigger the error, follow reported reproduction steps — whatever matches the input.
+
+- **Browser bugs:** Prefer `agent-browser` if installed. Otherwise use whatever works — MCP browser tools, direct URL testing, screenshot capture, etc.
+- **Manual setup required:** If reproduction needs specific conditions the agent cannot create alone (data states, user roles, external services, environment config), document the exact setup steps and guide the user through them. Clear step-by-step instructions save significant time even when the process is fully manual.
+- **Does not reproduce after 2-3 attempts:** Read `references/investigation-techniques.md` for intermittent-bug techniques.
+- **Cannot reproduce at all in this environment:** Document what was tried and what conditions appear to be missing.
+- **Writing the reproduction test:** If the project has testing-conventions guidance — a dedicated testing skill, an `AGENTS.md`/`CLAUDE.md` testing section, or a clear style across existing tests — apply it when authoring the failing test. Otherwise write a minimal isolated test that fails on the current bug and passes once the corrected behavior lands; name it descriptively so the failure message itself explains the bug.
+
+#### 1.2 Verify environment sanity
+
+Before deep code tracing, confirm the environment is what you think it is:
+
+- Correct branch checked out; no unintended uncommitted changes
+- Dependencies installed and up to date (`bun install`, `npm install`, `bundle install`, etc.) — stale `node_modules`/`vendor` is a frequent false lead
+- Expected interpreter or runtime version (check `.tool-versions`, `.nvmrc`, `Gemfile`, etc. against what's actually active)
+- Required env vars present and non-empty
+- No stale build artifacts (`dist/`, `.next/`, compiled binaries from an earlier branch)
+- Dependent local services (database, cache, queue) running at expected versions *when the bug plausibly involves them*
+
+#### 1.3 Trace the code path
+
+Trace data flow backward from the symptom to where valid state first became invalid. Read code-shape to form a hypothesis, then verify with observed values — do not theorize from code alone.
+
+Concrete recipe:
+
+1. Read the stack trace bottom-to-top, opening each frame's source. The bottom frame is the symptom; the root cause is somewhere upstream.
+2. Identify the first frame where the input data is already invalid — that's the upper bound on where to look.
+3. Instrument the boundaries around that frame: targeted log/print statements, debugger breakpoints, or test assertions that capture *actual* values at function entry/exit. Assumed values lie; observed values don't.
+4. Walk the boundaries until valid input becomes invalid output. That transition is the root cause site.
+
+Do not stop at the first function that looks wrong — the root cause is where bad state originates, not where it is first observed.
+
+As you trace:
+- Check recent changes in files you are reading: `git log --oneline -10 -- [file]`
+- If the bug looks like a regression ("it worked before"), use `git bisect` (see `references/investigation-techniques.md`)
+- Check the project's observability tools for additional evidence:
+  - Error trackers (Sentry, AppSignal, Datadog, BetterStack, Bugsnag)
+  - Application logs
+  - Browser console output
+  - Database state
+- Each project has different systems available; use whatever gives a more complete picture
+
+---
+
+### Phase 2: Root Cause
+
+*Reminder: investigate before fixing. Do not propose a fix until you can explain the full causal chain from trigger to symptom with no gaps.*
+
+Read `references/anti-patterns.md` before forming hypotheses. As a load-time preview of the rationalizations it covers, stop and re-examine if the internal monologue contains any of these:
+
+- "Quick fix for now, investigate later"
+- "This should work" (without a tested prediction)
+- "Let me just try..." (without a hypothesis)
+
+These phrases mark mode-drift toward symptom patches, not progress on the root cause. ("One more attempt" after a failed fix and "works on my machine" are covered at the points they fire — Phase 3's invalidation step and the Smart Escalation table below.)
+
+**Assumption audit (before hypothesis formation):** List the concrete "this must be true" beliefs your understanding depends on — the framework behaves as expected here, this function returns what its name implies, the config loads before this runs, the caller passes a non-null value, the database is in the state the test implies. For each, mark *verified* (you read the code, checked state, or ran it) or *assumed*. Assumptions are the most common source of stuck debugging. Many "wrong hypotheses" are actually correct hypotheses tested against a wrong assumption.
+
+**Form hypotheses** ranked by likelihood. For each, state:
+- What is wrong and where (file:line)
+- **At least one concrete observation that supports it** — a runtime variable value, a log line, an instrumented boundary capture, a behavior delta against a working comparison case, or a specific code reference. "X seems off" is not evidence; "X equals null at line 42 because Y was never initialized in the constructor path that runs under condition Z" is. Hypotheses without grounding observations are theorizing — go back to Phase 1 and instrument.
+- The causal chain: how the trigger leads to the observed symptom, step by step
+- **For uncertain links in the chain**: a prediction — something in a different code path or scenario that must also be true if this link is correct
+
+When the causal chain is obvious and has no uncertain links (missing import, clear type error, explicit null dereference), the chain explanation itself is the gate — no prediction required. Predictions are a tool for testing uncertain links, not a ritual for every hypothesis.
+
+Before forming a new hypothesis, review what has already been ruled out and why.
+
+**Causal chain gate:** Do not proceed to Phase 3 until you can explain the full causal chain — from the original trigger through every step to the observed symptom — with no gaps. The user can explicitly authorize proceeding with the best-available hypothesis if investigation is stuck.
+
+*Reminder: if a prediction was wrong but the fix appears to work, you found a symptom. The real cause is still active.*
+
+#### Present findings
+
+Once the root cause is confirmed, present:
+- The root cause (causal chain summary with file:line references)
+- The proposed fix and which files would change
+- Which tests to add or modify to prevent recurrence (specific test file, test case description, what the assertion should verify)
+- Whether existing tests should have caught this and why they did not
+
+Then offer next steps.
+
+Use the platform's blocking question tool (`AskUserQuestion` in Claude Code, `request_user_input` in Codex, `ask_question` in Antigravity CLI (`agy`), `ask_user` in Pi (requires the `pi-ask-user` extension)). In Claude Code, call `ToolSearch` with `select:AskUserQuestion` first if its schema isn't loaded — a pending schema load is not a reason to fall back. Fall back to numbered options in chat only when no blocking tool exists in the harness or the call errors (e.g., Codex edit modes). Never silently skip the question.
+
+Options to offer:
+
+1. **Fix it now** — proceed to Phase 3
+2. **Diagnosis only — I'll take it from here** — skip the fix, proceed to Phase 4's summary, and end the skill
+3. **Rethink the design** (`/ce-brainstorm`) — only when the root cause reveals a design problem (see below)
+
+Do not assume the user wants action right now. The test recommendations are part of the diagnosis regardless of which path is chosen.
+
+**When to suggest brainstorm:** Only when investigation reveals the bug cannot be properly fixed within the current design — the design itself needs to change. Concrete signals observable during debugging:
+
+- **The root cause is a wrong responsibility or interface**, not wrong logic. The module should not be doing this at all, or the boundary between components is in the wrong place. (Observable: the fix requires moving responsibility between modules, not correcting code within one.)
+- **The requirements are wrong or incomplete.** The system behaves as designed, but the design does not match what users actually need. The "bug" is really a product gap. (Observable: the code is doing exactly what it was written to do — the spec is the problem.)
+- **Every fix is a workaround.** You can patch the symptom, but cannot articulate a clean fix because the surrounding code was built on an assumption that no longer holds. (Observable: you keep wanting to add special cases or flags rather than a direct correction.)
+
+Do not suggest brainstorm for bugs that are large but have a clear fix — size alone does not make something a design problem.
+
+#### Smart escalation
+
+If 2-3 hypotheses are exhausted without confirmation, diagnose why:
+
+| Pattern | Diagnosis | Next move |
+|---------|-----------|-----------|
+| Hypotheses point to different subsystems | Architecture/design problem, not a localized bug | Present findings, suggest `/ce-brainstorm` |
+| Evidence contradicts itself | Wrong mental model of the code | Step back, re-read the code path without assumptions |
+| Works locally, fails in CI/prod | Environment problem | Focus on env differences, config, dependencies, timing |
+| Fix works but prediction was wrong | Symptom fix, not root cause | The real cause is still active — keep investigating |
+
+**Parallel investigation option:** When hypotheses are evidence-bottlenecked across clearly independent subsystems, dispatch read-only sub-agents in parallel, each with an explicit hypothesis and structured evidence-return format. No code edits by sub-agents, and skip this when hypotheses depend on each other's outcomes. If the platform does not support parallel sub-agent dispatch, run the same hypothesis probes sequentially in ranked-likelihood order instead — the parallelism is a latency optimization, not a correctness requirement.
+
+Present the diagnosis to the user before proceeding.
+
+---
+
+### Phase 3: Fix
+
+*Reminder: one change at a time. If you are changing multiple things, stop.*
+
+If the user chose "Diagnosis only" at the end of Phase 2, skip this phase and go straight to Phase 4 for the summary — the skill's job was the diagnosis. If they chose "Rethink the design", control has transferred to `/ce-brainstorm` and this skill ends.
+
+**Workspace and branch check:** Before editing files:
+
+- Check for uncommitted changes (`git status`). If the user has unstaged work in files that need modification, confirm before editing — do not overwrite in-progress changes.
+- If the current branch is the default branch, ask whether to create a feature branch first using the platform's blocking question tool (see Phase 2 for the per-platform names). To detect the default branch, compare against `main`, `master`, or the value of `git rev-parse --abbrev-ref origin/HEAD` with its `origin/` prefix stripped (the raw output is `origin/<name>`, so an unstripped comparison will never match the local branch name). Default to creating one; derive a name from the bug and run `git checkout -b <name>`. On any other branch, proceed.
+
+**Test-first:**
+1. Write a failing test that captures the bug (or use the existing failing test)
+2. Verify it fails for the right reason — the root cause, not unrelated setup
+3. Implement the minimal fix — address the root cause and nothing else. Do not bundle drive-by refactors, formatting, or unrelated cleanup into a bug-fix change; those belong in separate commits.
+4. Verify the test passes
+5. Run the broader test suite for regressions
+6. Self-review the diff before declaring the fix done: read every changed line and check for style violations, missed edge cases, regressions in adjacent behavior, and missing test coverage for the fix. For non-trivial fixes (multiple files, risky surface area), also run the harness's lightweight review tool (e.g., `/review` in Claude Code; the equivalent in other harnesses) — not the full `ce-code-review` multi-agent flow, which is PR-tier and over-sized for a single bug fix.
+
+**On a failed fix:** return to Phase 2 and *explicitly invalidate the current hypothesis* before forming a new one. State out loud what evidence ruled out the prior hypothesis, then form a new one with its own grounding observation and prediction. Do not retry variants of the same theory ("maybe it was the other branch", "let me also catch this case") — that is the rationalization spiral, not iteration.
+
+**3 failed fix attempts = smart escalation.** Diagnose using the same table from Phase 2. If fixes keep failing, the root cause identification was likely wrong. Return to Phase 2.
+
+**Conditional defense-in-depth** (trigger: grep for the root-cause pattern found it in 3+ other files, OR the bug would have been catastrophic if it reached production): Read `references/defense-in-depth.md` for the four-layer model (entry validation, invariant check, environment guard, diagnostic breadcrumb) and choose which layers apply. Skip when the root cause is a one-off error with no realistic recurrence path.
+
+**Conditional post-mortem** (trigger: the bug was in production, OR the pattern appears in 3+ locations):
+Analyze how this was introduced and what allowed it to survive. Note any systemic gap or repeated pattern found — it informs Phase 4's decision on whether to offer learning capture.
+
+---
+
+### Phase 4: Handoff
+
+**Structured summary** — always write this first:
+
+```
+## Debug Summary
+**Problem**: [What was broken]
+**Root Cause**: [Full causal chain, with file:line references]
+**Recommended Tests**: [Tests to add/modify to prevent recurrence, with specific file and assertion guidance]
+**Fix**: [What was changed — or "diagnosis only" if Phase 3 was skipped]
+**Prevention**: [Test coverage added; defense-in-depth if applicable]
+**Confidence**: [High/Medium/Low]
+```
+
+**If Phase 3 was skipped** (user chose "Diagnosis only" in Phase 2), stop after the summary — the user already told you they were taking it from here. Do not prompt.
+
+**If Phase 3 ran**, the next move depends on whether the skill created the branch in Phase 3.
+
+#### Skill-owned branch (created in Phase 3): default to commit-and-PR without prompting
+
+1. **Check for contextual overrides first.** Look at the user's original prompt, loaded memories, and the project's active instructions already in your context for preferences that conflict with auto commit-and-PR — for example, "always review before pushing", "open PRs as drafts", or "don't open PRs from skills". A signal must be an explicit instruction or a clearly applicable rule, not a vague tonal cue. If any apply, honor them — switch to the pre-existing-branch menu below, or skip the PR step entirely, whichever matches the user's stated preference.
+2. **Briefly preview what will happen** — what will be committed, on what branch, and that a PR will be opened — then proceed without waiting for confirmation. The preview exists so the user can interrupt; it is not a blocking question. Format and length are your call; keep it scannable.
+3. **Run `/ce-commit-push-pr`.** When the entry came from an issue tracker, include the appropriate auto-close syntax for that tracker in the location it requires — most trackers parse PR descriptions (e.g., `Fixes #N` for GitHub, `Closes ABC-123` for Linear), but some only parse commit messages (e.g., Jira Smart Commits) — so the diagnosis and fix flow back to the issue and it closes on merge. Surface the resulting PR URL.
+
+#### Pre-existing branch (skill did not create it): ask the user
+
+Use the platform's blocking question tool (`AskUserQuestion` in Claude Code, `request_user_input` in Codex, `ask_question` in Antigravity CLI (`agy`), `ask_user` in Pi (requires the `pi-ask-user` extension)). In Claude Code, call `ToolSearch` with `select:AskUserQuestion` first if its schema isn't loaded — a pending schema load is not a reason to fall back. Fall back to numbered options in chat only when no blocking tool exists in the harness or the call errors. Never end the phase without collecting a response.
+
+Options:
+
+1. **Commit and open a PR (`/ce-commit-push-pr`)** — default for most cases
+2. **Commit the fix (`/ce-commit`)** — local commit only
+3. **Stop here** — user takes it from there
+
+#### After a PR is open (either path): consider offering learning capture
+
+Most bugs are localized mechanical fixes (typo, missed null check, missing import) where the only "lesson" is the bug itself. Compounding those clutters `docs/solutions/` without adding value. Decide which path applies:
+
+- **Skip silently** when the fix is mechanical and there's no generalizable insight. Default to this when in doubt.
+- **Offer neutrally** when the lesson can be stated in one sentence — e.g., "X.foo() returns T | undefined when Y, not just T", or "the diagnostic path was non-obvious and worth recording." If you cannot articulate the lesson, skip rather than offer.
+- **Lean into the offer** when the pattern appears in 3+ locations OR the root cause reveals a wrong assumption about a shared dependency, framework, or convention that other code is likely to repeat.
+
+When offering, use the blocking question tool described above. If the user accepts, run `/ce-compound`, then commit the resulting learning doc to the same branch and push so the open PR picks up the new commit.

package/dist/plugins/.fusion-ce-skills/ce-debug/references/anti-patterns.md

@@ -0,0 +1,91 @@
+# Debugging Anti-Patterns
+
+Read this before forming hypotheses. These patterns describe the most common ways debugging goes wrong. They feel productive in the moment — that is what makes them dangerous.
+
+---
+
+## Prediction Quality
+
+The prediction requirement exists to prevent symptom-fixing. A prediction tests whether your understanding of the bug is correct, not just whether a fix makes the error go away.
+
+**Bad prediction (restates the hypothesis):**
+> Hypothesis: The null pointer is because `user` is not initialized.
+> Prediction: `user` will be null when I log it.
+
+This just re-describes the symptom. It cannot be wrong if the hypothesis is right — so it cannot catch a wrong hypothesis.
+
+**Good prediction (tests something non-obvious):**
+> Hypothesis: The null pointer is because the auth middleware skips initialization on cached requests.
+> Prediction: Non-cached requests to the same endpoint will NOT produce the null pointer, and the `X-Cache` header will be present on failing requests.
+
+This tests a different code path and a different observable. If the prediction is wrong — cached and non-cached requests both fail — the hypothesis is wrong even if "initializing user earlier" happens to fix the immediate error.
+
+**Rule of thumb:** A good prediction names something you have not looked at yet. If confirming the prediction requires only looking at the same line of code you already identified, the prediction is not adding information.
+
+---
+
+## Shotgun Debugging
+
+Changing multiple things at once to "see if it helps."
+
+**How it feels:** Productive. You're making changes, running tests, making progress.
+
+**What actually happens:** If the bug goes away, you do not know which change fixed it. If it persists, you do not know which changes are relevant. You have introduced variables instead of eliminating them.
+
+**The fix:** One hypothesis, one change, one test. If the first change does not fix it, revert it before trying the next. Changes should be additive to understanding, not cumulative to the codebase.
+
+---
+
+## Confirmation Bias
+
+Interpreting ambiguous evidence as supporting your current hypothesis.
+
+**How it looks:**
+- A log line that *could* support your theory — you treat it as proof
+- A test passes after your change — you declare the bug fixed without checking if the test was actually exercising the failure path
+- The error message changes slightly — you interpret the change as "getting closer" instead of recognizing a different failure mode
+
+**The defense:** Before declaring a hypothesis confirmed, ask: "What evidence would DISPROVE this hypothesis?" If you cannot name something that would change your mind, you are not testing — you are justifying.
+
+---
+
+## "It Works Now, Move On"
+
+The bug stops appearing after a change. The temptation is to declare victory and move on.
+
+**When this is a trap:** If you cannot explain WHY the change fixed the bug — the full causal chain from your change through the system to the symptom — you may have:
+- Fixed a symptom while the root cause remains
+- Introduced a change that masks the bug without resolving it
+- Gotten lucky with timing (especially for intermittent bugs)
+
+**The test:** Can you explain the fix to someone else without using the words "somehow" or "I think"? If not, the root cause is not confirmed.
+
+---
+
+## Thoughts That Signal You Are About to Shortcut
+
+These feel like reasonable next steps. They are warning signs that investigation is being skipped.
+
+**Proposing a fix before explaining the cause.** If the words "I think we should change..." come before "the root cause is...", pause. The fix might be right, but without a confirmed causal chain there is no way to know. Explain the cause first.
+
+**Reaching for another attempt without new information.** After 2-3 failed hypotheses, trying a 4th without learning something new from the failures is not debugging — it is guessing with increasing frustration. Stop and diagnose why previous hypotheses failed (see smart escalation).
+
+**Certainty without evidence.** The feeling of "I know what this is" before reading the relevant code. Experienced developers have strong pattern-matching instincts, and they are right often enough to be dangerous when wrong. Read the code even when you are confident.
+
+**Minimizing the scope.** "It is probably just..." — the word "just" signals an assumption that the problem is small. Small problems do not resist 2-3 fix attempts. If you are still debugging, it is not "just" anything.
+
+**Treating environmental differences as irrelevant.** When something works in one environment and fails in another, the difference between environments IS the investigation. Do not dismiss it — compare them systematically.
+
+---
+
+## Smart Escalation Patterns
+
+When 2-3 hypotheses have been tested and none confirmed, the problem is not "I need hypothesis #4." The problem is usually one of these:
+
+**Different subsystems keep appearing.** Hypothesis 1 pointed to auth, hypothesis 2 to the database, hypothesis 3 to caching. This scatter pattern means the bug is not in any one subsystem — it is in the interaction between them, or in an architectural assumption that cuts across all of them. This is a design problem, not a localized bug.
+
+**Evidence contradicts itself.** The logs say X happened, but the code makes X impossible. The test fails with error A, but the code path that produces error A is unreachable from the test. When evidence contradicts, the mental model is wrong. Step back. Re-read the code from the entry point without any assumptions about what it does.
+
+**Works locally, fails elsewhere.** The most common causes: environment variables, dependency versions, file system differences (case sensitivity, path separators), timing differences (faster/slower machines), and data differences (test fixtures vs production data). Systematically compare the two environments rather than debugging the code.
+
+**Fix works but prediction was wrong.** This is the most dangerous pattern. The bug appears fixed, but the causal chain you identified was incorrect. The real cause is still present and will resurface. Keep investigating — you found a coincidental fix, not the root cause.

package/dist/plugins/.fusion-ce-skills/ce-debug/references/defense-in-depth.md

@@ -0,0 +1,35 @@
+# Defense-in-Depth
+
+When a bug is caused by invalid state reaching a vulnerable code path, fixing just one layer leaves the door open for different code paths, refactors, or mocks to re-introduce the same bug. Defense-in-depth makes the bug structurally harder to re-create by validating at multiple layers.
+
+Not every bug warrants this. Use when:
+
+- The root-cause pattern exists in 3+ other files (grep the fix signature)
+- The bug would have been catastrophic in production
+- The vulnerable operation is dangerous regardless of caller (destructive side effects, security-sensitive, irreversible)
+
+Skip when the root cause is a one-off logic error with no realistic recurrence path.
+
+## The four layers
+
+Pick the layers that apply. Not every bug needs all four.
+
+| Layer | Purpose | Apply when | Example |
+|-------|---------|------------|---------|
+| 1. Entry validation | Reject obviously invalid input at the API boundary | The bug was caused by a caller passing bad data that should have been rejected | Throw if `workingDirectory` is empty or doesn't exist, before any downstream code touches it |
+| 2. Invariant / business-logic check | Enforce that data makes sense for this operation | The operation has preconditions that entry validation cannot express | Assert `user.state === 'verified'` before issuing a password reset |
+| 3. Environment guard | Refuse dangerous operations in contexts where they make no sense | The operation can be catastrophic if run in the wrong environment | In tests (`NODE_ENV === 'test'`), refuse `git init` outside the OS temp dir |
+| 4. Diagnostic breadcrumb | Capture forensic context before the risky operation | Other layers might still be bypassed; future failures need evidence | Log `{ directory, cwd, env, stack }` immediately before `git init` |
+
+## Applying the pattern
+
+1. Trace the data flow from the bad value's origin through every function that passed it along.
+2. Map the checkpoints: at which of those points could validation have rejected the bad value earlier?
+3. Add guards at the appropriate layers. Each guard should be as narrow as possible — validating exactly what this layer is responsible for, not duplicating checks from other layers.
+4. Test each guard independently: construct a case that bypasses layer 1 and verify layer 2 still catches it.
+
+## Common mistakes
+
+- **Duplicating the same check at every layer.** Each layer should catch a distinct class of failure. If layer 2 just repeats layer 1, the second one is noise.
+- **Adding guards speculatively without a bug to justify them.** Defense-in-depth is a response to an observed failure mode, not a generic code-hygiene practice.
+- **Leaving layer 4 (diagnostic breadcrumb) out.** When layers 1-3 still get bypassed — they will, eventually — the breadcrumb is what makes the next bug debuggable.