liteagents 2.8.3 → 2.10.0

package/packages/claude/commands/optimize.md

@@ -3,6 +3,7 @@ name: optimize
 description: Optimize performance [target]
 usage: /optimize <target-area>
 argument-hint: [file-or-function]
+allowed-tools: Read, Edit, Grep, Glob, Bash(git diff:*), Bash(git log:*), Bash(git grep:*), Bash(rg:*)
 ---
 Analyze $ARGUMENTS for performance.
 
@@ -14,7 +15,47 @@ Analyze $ARGUMENTS for performance.
 - Unnecessary allocations
 
 ## Output
-- Current bottlenecks
-- Specific optimizations
-- Expected improvement
-- Trade-offs involved
+Per bottleneck:
+- **Location** (`file:line`)
+- **Cost** — what's slow and by how much. Concrete ("N+1 over ~1k rows on
+  every page load"), not vague ("could be faster").
+- **Optimization** — specific change.
+- **Expected improvement** — order-of-magnitude estimate.
+- **Trade-offs** — readability / memory / consistency cost.
+
+## After the analysis — verify, then fix
+
+Performance claims are easy to invent. Validate before acting.
+
+**Verify each bottleneck.** Re-read the cited `file:line` in context.
+Confirm the path is **actually hot** — look for at least one of:
+- a profile / benchmark / log line showing call frequency or duration,
+- the path sits on an obvious hot loop / per-request handler with real
+  volume,
+- the user provided evidence in the request.
+
+Without one of those, the claim is **uncertain — don't optimize on
+speculation.** Mark each finding **confirmed**, **false positive** (with
+reason), or **uncertain (needs profiling data)**.
+
+**Fix what's confirmed and unambiguous** — minimal change, one obvious
+shape, **no behavior change**, no API change. Apply directly. After
+each edit, re-read the changed region and confirm it still computes the
+same answer (perf optimizations that quietly change semantics are the
+worst kind).
+
+**Stop and ask** when (HITL gates — not all the time, only here):
+- the bottleneck is **uncertain** after grounding (no profile / log and
+  not obviously hot),
+- the fix has **multiple reasonable shapes** (cache vs precompute vs
+  batch vs paginate vs index) — present options with tradeoffs, not a
+  chosen path,
+- it changes **public API / response shape / DB schema / caller contract**,
+- it trades **correctness for speed** (lossy approximation, weaker
+  consistency, eventual-vs-strict) — even when "obviously" faster, or
+- it touches **concurrency primitives** (locks, atomics, ordering) —
+  easy to introduce races.
+
+Final report: **confirmed-and-fixed** · **confirmed-but-asking** (why +
+options) · **false-positive** (why) · **uncertain** (what profiling /
+data is needed to decide).

package/packages/claude/commands/refactor.md

@@ -3,6 +3,7 @@ name: refactor
 description: Refactor [code]
 usage: /refactor <code-section>
 argument-hint: [file-or-function]
+allowed-tools: Read, Edit, Grep, Glob, Bash(npm test:*), Bash(npx jest:*), Bash(npx vitest:*), Bash(pnpm test:*), Bash(yarn test:*), Bash(pytest:*), Bash(python:*), Bash(go test:*), Bash(cargo test:*), Bash(make test:*), Bash(git diff:*)
 ---
 Refactor $ARGUMENTS.
 
@@ -14,8 +15,39 @@ Refactor $ARGUMENTS.
 - Smaller functions (single responsibility)
 
 ## Constraints
-- NO behavior changes
+- **NO behavior changes**
 - Keep public API intact
 - Existing tests must pass
 
 Explain each change.
+
+## After the refactor — verify it didn't break anything
+
+"Existing tests must pass" is the load-bearing constraint, and the only
+honest way to know is to run them.
+
+1. **Detect the project's test command** (look for `package.json`
+   scripts, `pytest.ini` / `pyproject.toml`, `go.mod`, `Cargo.toml`,
+   `Makefile`). If none is found, **stop and ask** before claiming the
+   refactor is done — silent green isn't acceptable.
+2. **Run the tests.** Scope to the affected area when possible (`-t`,
+   `--testPathPattern`, `pytest path/`, `go test ./pkg`); otherwise run
+   the suite.
+3. **Report** pass / fail counts and any failure's name + `file:line`.
+
+**Stop and ask** when (HITL gates — not all the time, only here):
+- a test **fails** after the refactor. Don't auto-revert (destroys
+  work-in-progress) and don't push forward (the no-behavior-change
+  constraint is broken). Present the failure and the options:
+  **revert**, **patch the refactor**, or **update the test** (with
+  reasoning).
+- the refactor crossed a **public API boundary** that callers depend
+  on — even if tests pass, downstream consumers may break.
+- the change is **bigger than the user asked for** (scope creep —
+  unrelated cleanups, formatting, comment edits). Confirm before
+  applying.
+
+Final report:
+- **refactor done, tests N pass / 0 fail** — ready, OR
+- **refactor done, but K tests fail** — awaiting direction (revert /
+  patch / update test).

package/packages/claude/commands/remember.md

@@ -4,24 +4,56 @@ description: Consolidate stashes + friction into project memory
 usage: /remember
 ---
 
-Consolidate session stashes and friction analysis into a single project-local MEMORY.md, then inject into CLAUDE.md.
+Run friction analysis, then consolidate session stashes + friction antigens into a single project-local MEMORY.md, and inject into CLAUDE.md. Friction runs automatically (best-effort) — there is no separate `/friction` command.
 
 **Guardrails**
 - Favor straightforward, minimal implementations first and add complexity only when requested or clearly required.
 - Keep changes tightly scoped to the requested outcome.
+- **Precision over recall for hot memory.** A false antigen loaded into `@MEMORY.md` steers every future session. When unsure, record as a low-confidence episode — do not promote.
 
 **What it does**
 
-Reads all raw material (`.claude/stash/*.md` + `.claude/friction/antigen_clusters.json`), extracts durable facts, episodes, and behavioral preferences into a single `.claude/memory/MEMORY.md`, then injects a managed memory section into `CLAUDE.md`.
+Reads all raw material (`.claude/stash/*.md` + `.claude/friction/antigen_clusters.json`), extracts durable facts, episodes, and behavioral antigens into a single `.claude/memory/MEMORY.md`, then injects a managed memory section into `CLAUDE.md`.
 
 **Steps**
 
+0. **Run friction first** (best-effort — friction analyzes ALL your usage, not just this repo)
+
+   Friction's signal is *global*: recurring corrections and frustrations across every
+   project are behavioral lessons worth keeping everywhere. So point it at the tool's
+   **global sessions root** (all projects), not a per-project directory.
+
+   - **Locate `friction.js`** — it is bundled next to this command at `friction/friction.js`
+     (the same directory as `remember.md`, whether installed or run from the package). If it
+     exists nowhere, skip to step 1 (stash-only) and tell the user friction.js is missing.
+   - **Resolve the global sessions root** — probe this list top-to-bottom, use the first that
+     exists and contains `.jsonl` files (recursively). **Never prompt the user.**
+     ```
+     # ── Add your own global sessions root at the TOP so it is checked first ──
+     ~/.claude/projects/                 # Claude Code
+     ~/.factory/projects/                # Droid / Factory
+     ~/.config/amp/projects/             # Amp
+     ~/.config/opencode/projects/        # opencode
+     ~/.codex/sessions/                  # Codex CLI  (use $CODEX_HOME/sessions/ if set)
+     ~/.gemini/antigravity-cli/brain/    # Antigravity
+     ```
+     > Note: `friction.js` parses Claude Code's session schema. The Codex/Antigravity roots
+     > will resolve but yield no signals until friction learns their formats — open an issue
+     > to request one: https://github.com/hamr0/liteagents/issues
+   - **Run** `node <friction.js> "<resolved-root>"`. friction writes its output to
+     `.claude/friction/` in the current project.
+   - **On any miss — loud, never silent.** If no root resolves, or friction errors, or it
+     finds no usable sessions, print this and continue with stash-only consolidation:
+     > ⚠️ Friction didn't run — no sessions found. To enable it, open this command file
+     > (`remember.md`) and add your tool's **global** sessions root to the TOP of the probe
+     > list in step 0, then re-run `/remember`. Consolidating stashes only this time.
+
 1. **Gather sources**
    - Read all `.claude/stash/*.md` files in the current project
-   - Check for friction output at `.claude/friction/antigen_clusters.json` (preferred) or `.claude/friction/antigen_review.md` (fallback)
+   - Read friction output written in step 0: `.claude/friction/antigen_clusters.json` (preferred) or `.claude/friction/antigen_review.md` (fallback)
    - Read existing `.claude/memory/MEMORY.md` if it exists — create dir if missing
    - Read processed manifest at `.claude/memory/.processed` — skip already-processed stashes
-   - If no unprocessed stashes, report "nothing to consolidate" and stop
+   - If no unprocessed stashes AND friction produced no new antigens, report "nothing to consolidate" and stop
 
 2. **Extract from unprocessed stashes** (use Task tool with sonnet model for each)
    - For each unprocessed stash, call sonnet to extract:
@@ -31,13 +63,72 @@ Reads all raw material (`.claude/stash/*.md` + `.claude/friction/antigen_cluster
    - Collect all new facts and episodes
 
 3. **Merge into MEMORY.md**
-   - Read existing `.claude/memory/MEMORY.md` and parse its three sections (## Facts, ## Episodes, ## Preferences)
+   - Read existing `.claude/memory/MEMORY.md` and parse its sections (## Facts, ## Episodes, ## Antigens)
    - **Facts section**: call sonnet with existing facts + newly extracted facts
      - Rules: new updates replace old, contradictions keep new version, duplicates dropped
      - Keep facts atomic, one line each
    - **Episodes section**: append new episode entries (append-only, timestamped, no dedup)
-   - **Preferences section**: only update if friction output exists (step 4)
-   - Write merged result to `.claude/memory/MEMORY.md` in this format:
+   - **Antigens section**: only update from friction output (step 4)
+   - Write merged result to `.claude/memory/MEMORY.md` in the format under step 6.
+
+4. **Distill friction into antigens** (only if friction output exists)
+
+   > Friction has already done the heavy part: it scanned the raw session logs,
+   > kept only **observed user reactions** (corrections, curses, repeated stops),
+   > pooled them per session, and lexically pre-grouped the obvious repeats. Each
+   > cluster carries `theme`, `suggested_artifact`, `confidence`, `severity`,
+   > `sessions` (recurrence count), `projects`, `signals`, `contexts` (the verbatim
+   > user quotes), `preceding` (the agent action + result just before the reaction —
+   > the trigger), and `self_suspect` (friction's guess that the user was correcting
+   > *themselves*). **You work from these short quotes — never re-read the session
+   > logs.** Friction's lexical grouping and flags are hints, not the verdict.
+
+   - Read `.claude/friction/antigen_clusters.json`.
+   - **4a. Classify target, then semantically consolidate** (the parts lexical matching can't do).
+     Call sonnet with the cluster quotes + their `preceding`/`projects`/`sessions`/`self_suspect`
+     (NOT the logs), and have it:
+     1. **Decide the target of each reaction — agent or self.** Drop *self/context*
+        corrections where the user redirected themselves ("wrong project", "wrong window",
+        "nevermind") — the agent did nothing wrong. `self_suspect` and an empty `preceding`
+        (no agent action) are strong cues. Keep only **agent-directed** reactions.
+     2. **Merge same-complaint paraphrases** that friction left split because they share no
+        words (e.g. "nothing landed, fuck you" + "it says pushed but none got it" → one antigen).
+     Output one object per surviving antigen:
+     ```json
+     {
+       "rule": "Verify the artifact is actually live after publish; a clean exit code ≠ done",
+       "target": "agent",
+       "evidence": ["both say pushed... none got it", "notng landed in live-claude, fuck you"],
+       "errors": ["Exit code 0 (claimed success)"],
+       "sessions": 2,
+       "confidence": "medium"
+     }
+     ```
+   - **4b. Route + tier by recurrence.** For each cluster and each LLM-merged group:
+     - `suggested_artifact: antigen` (recurring + severe) or an LLM-merged group → an
+       **antigen** (a "do/don't" behavioral rule), with its verbatim evidence quotes.
+     - `suggested_artifact: fact` (recurring + mild) → a **Fact**.
+     - `suggested_artifact: episode` that did **not** merge into a recurring group → an
+       **Episode** (one-off; recorded, not a rule).
+     - Confidence by distinct-session recurrence:
+       - **High** (5+ sessions) → loaded hot via `@MEMORY.md`
+       - **Medium** (3-4 sessions) → recorded under Antigens, *not* loaded hot
+       - **Low** (<3 sessions) → keep as Episode only
+   - **Never auto-promote.** Only High-confidence (5+ sessions) antigens load hot. A
+     single dramatic correction is an Episode, not an antigen.
+   - Update the Antigens section in MEMORY.md (promote/demote based on new recurrence).
+
+5. **Inject memory reference into CLAUDE.md**
+   - Compose the section between `<!-- MEMORY:START -->` and `<!-- MEMORY:END -->` markers:
+     ```
+     <!-- MEMORY:START -->
+     @MEMORY.md
+     <!-- MEMORY:END -->
+     ```
+   - The `@MEMORY.md` reference points to `.claude/memory/MEMORY.md` — Claude loads the full file directly, so no inline duplication is needed
+   - If CLAUDE.md already has MEMORY markers, replace the section between them
+   - If CLAUDE.md has no MEMORY markers, append the section at the end
+   - If no CLAUDE.md exists, create one with just the memory section
 
    ```markdown
    # Project Memory
@@ -45,52 +136,22 @@ Reads all raw material (`.claude/stash/*.md` + `.claude/friction/antigen_cluster
 
    ## Facts
    - [atomic fact 1]
-   - [atomic fact 2]
 
    ## Episodes
    ### YYYY-MM-DD - [title]
    - [bullet narrative]
 
-   ### YYYY-MM-DD - [title]
-   - [bullet narrative]
+   ## Antigens
+   ### High Confidence (loaded — applies every session)
+   - [behavioral rule] (evidence: [N] sessions — "[verbatim quote]")
 
-   ## Preferences
-   ### High Confidence
-   - [pattern] (evidence: [count] observations)
+   ### Medium Confidence (observing — not loaded)
+   - [behavioral rule] (evidence: [N] sessions)
 
-   ### Medium Confidence
-   - [pattern] (evidence: [count] observations)
-
-   ### Low Confidence
-   - [pattern] (evidence: [count] observations)
+   ### Low Confidence (needs more data)
+   - [pattern] (evidence: [N] sessions)
    ```
 
-4. **Distill friction into preferences** (only if friction output exists)
-   - Read `.claude/friction/antigen_clusters.json` — this contains clustered failure patterns with counts, user_context quotes, and tool sequences
-   - For the **top 10 clusters** (by score), extract the `contexts` field — these are the actual user messages that show behavioral patterns
-   - Call sonnet with:
-     - The top 10 clusters (signal, tool_pattern, count, sessions, contexts, errors)
-     - Existing Preferences section from MEMORY.md
-   - Extract BEHAVIORAL preferences (patterns demonstrated, not stated) — the user_context quotes are the primary evidence
-   - Confidence tiers:
-     - **High Confidence**: 5+ observations — available via @MEMORY.md
-     - **Medium Confidence**: 3+ observations — observing, not loaded
-     - **Low Confidence**: <3 observations — needs more data
-   - Promote/demote based on new evidence
-   - Update the Preferences section in MEMORY.md
-
-5. **Inject memory reference into CLAUDE.md**
-   - Compose the section between `<!-- MEMORY:START -->` and `<!-- MEMORY:END -->` markers:
-     ```
-     <!-- MEMORY:START -->
-     @MEMORY.md
-     <!-- MEMORY:END -->
-     ```
-   - The `@MEMORY.md` reference points to `.claude/memory/MEMORY.md` — Claude loads the full file directly, so no inline duplication is needed
-   - If CLAUDE.md already has MEMORY markers, replace the section between them
-   - If CLAUDE.md has no MEMORY markers, append the section at the end
-   - If no CLAUDE.md exists, create one with just the memory section
-
 6. **Update processed manifest**
    - Append paths of newly processed stashes to `.claude/memory/.processed`
 
@@ -98,13 +159,13 @@ Reads all raw material (`.claude/stash/*.md` + `.claude/friction/antigen_cluster
    - Number of stashes processed
    - Facts count (total, new)
    - Episodes count (total, new)
-   - Preferences count by confidence tier
+   - Antigens count by confidence tier, with how many newly promoted to hot
    - Confirm MEMORY.md and CLAUDE.md updated
 
 **File locations (all project-local)**
 - Memory file: `.claude/memory/MEMORY.md` (single source of truth, referenced as @MEMORY.md)
 - Stash files: `.claude/stash/*.md`
-- Friction output: `.claude/friction/antigen_clusters.json` (clustered patterns with user contexts)
+- Friction output: `.claude/friction/antigen_clusters.json` (observed-reaction clusters: theme, suggested_artifact, confidence, severity, sessions, projects, contexts)
 - Friction fallback: `.claude/friction/antigen_review.md` (human-readable clusters)
 - Processed manifest: `.claude/memory/.processed`
 - Output: `CLAUDE.md` (managed MEMORY section with @MEMORY.md reference)

package/packages/claude/commands/security.md

@@ -3,7 +3,7 @@ name: security
 description: Scan security [target]
 usage: /security
 argument-hint: [file, directory, or leave empty for full scan]
-allowed-tools: Read, Grep, Glob, Bash(git log:*), Bash(git grep:*), Bash(rg:*)
+allowed-tools: Read, Edit, Grep, Glob, Bash(git log:*), Bash(git grep:*), Bash(rg:*)
 ---
 Audit $ARGUMENTS for security vulnerabilities. Adapt scope to what the target
 actually is — a library, CLI, web app, and service won't all have every
@@ -57,3 +57,30 @@ Severity-ranked findings (Critical → High → Medium → Low), each with:
 End with: which of the six classes were checked and found **clean**, and any
 marked **N/A** for this target — so the scan's coverage is auditable, not just
 its hits.
+
+## After the scan — verify, then fix
+
+Findings are claims, not facts. Validate before acting; validate again after.
+
+**Verify each claim.** Re-read the cited `file:line` in context. Confirm the
+risk actually holds here — not in the abstract. Mark each **confirmed**, **false
+positive** (with reason), or **uncertain**.
+
+**Fix what's confirmed and unambiguous** — minimal shape, one obvious way, no
+change to a public API / response / caller contract. Apply directly. After
+each edit, re-read the changed region and confirm it closes the gap without
+breaking nearby logic. A fix isn't done until you've grounded it the same way
+you grounded the claim.
+
+**Stop and ask** when any of these hold (HITL gates — not all the time, only
+here):
+- the finding is **uncertain** after grounding (you'd need info you don't have),
+- the fix has **multiple reasonable shapes** (e.g. reject-vs-sanitize,
+  index-vs-paginate) — present options with tradeoffs, not a chosen path,
+- it **affects downstream** (function signatures, response shape, DB schema,
+  any caller contract), or
+- it touches **auth / crypto / session / token** primitives — even an "obvious"
+  fix here warrants confirmation.
+
+Final report: **confirmed-and-fixed** · **confirmed-but-asking** (why + options)
+· **false-positive** (why) · **uncertain** (what's needed to decide).

package/packages/claude/commands/stash.md

@@ -17,6 +17,13 @@ Save session context for compaction recovery or handoffs.
 3. Stores important findings and insights
 4. Creates stash file in `.claude/stash/`
 5. Enables context restoration after compaction
+6. **Consolidation nudge** — after saving, count the unprocessed backlog:
+   `unprocessed = (files in .claude/stash/*.md) − (entries in .claude/memory/.processed)`
+   (a missing `.processed` manifest means 0 processed). If `unprocessed >= 5`, end with one line:
+   > 📝 N stashes since last consolidation — run `/remember` to fold them into memory.
+
+   No counter is stored — the count is derived each time, and running `/remember` updates
+   `.processed`, so the backlog drops on its own. Just emit the nudge; never run `/remember` automatically.
 
 **When to use**
 - Before long-running tasks that may trigger compaction

package/packages/claude/commands/test-generate.md

@@ -1,18 +1,67 @@
 ---
 name: test-generate
-description: Generate tests [file]
-usage: /test-generate <code-section>
-argument-hint: [file-to-test]
+description: Generate and run tests [file]
+usage: /test-generate <file>
+argument-hint: [file or symbol to test]
+allowed-tools: Read, Edit, Write, Grep, Glob, Bash(npm test:*), Bash(npx jest:*), Bash(npx vitest:*), Bash(pnpm test:*), Bash(yarn test:*), Bash(pytest:*), Bash(python:*), Bash(go test:*), Bash(cargo test:*), Bash(make test:*)
 ---
-Generate tests for $ARGUMENTS.
-
-## Include
-- Happy path (expected usage)
-- Edge cases (empty, null, boundaries)
-- Error scenarios (invalid input, failures)
-- Integration points (mocks for external deps)
-
-## Requirements
-- Match existing test patterns in this project
-- Use the testing framework already in use
-- Clear test names: "should [expected] when [condition]"
+Generate tests for $ARGUMENTS, then run them. This is a generate → run →
+verify loop, not just file generation.
+
+## 1. Discover
+- Detect the test framework already in use (look for `jest.config*`,
+  `vitest.config*`, `pytest.ini` / `pyproject.toml [tool.pytest]`, Go's
+  `_test.go` convention, `Cargo.toml [dev-dependencies]`, etc.). **Never
+  add a new framework or runner.**
+- Skim 1–2 existing test files near the target to mirror style, fixtures,
+  setup/teardown, assertion style, and naming convention.
+
+## 2. Generate
+Cover:
+- **Happy path** (expected usage)
+- **Edges** (empty / null / boundary / malformed)
+- **Errors** (invalid input, IO / network / DB failures)
+
+Match existing patterns:
+- Same framework, same fixture style, same naming convention.
+- Reuse existing setup/teardown helpers; do **not** add new mock libraries
+  or new test-runner config.
+- Do **not** add test-only public methods or exports to production code to
+  make a test possible — if the test wants a hook the prod code doesn't
+  expose, stop and ask (`test-traps` territory).
+
+## 3. Run
+Execute the project's real test command, scoped to just the new tests
+(`-t <name>`, `--testPathPattern`, `pytest path/to/test.py`, `go test
+./pkg`, etc.). Report:
+- Pass / fail counts.
+- Any failure with the assertion message and `file:line`.
+
+## 4. Verify the tests BITE
+A test that passes is not the same as a test that **exercises** the code.
+For each new test, confirm:
+- It would fail if the function under test returned the wrong value.
+  Mentally swap a broken impl — does the assertion actually catch it?
+- It isn't `expect(true).toBe(true)`, `expect(fn).toBeDefined()`, or a
+  mock asserting itself.
+- It isn't passing only because the setup masked the real call.
+
+Mark each new test **biting** or **superficial** (with reason).
+Superficial tests count as a failure to ship — either fix or delete.
+
+## 5. Report
+- Files added / modified.
+- Pass / fail.
+- Biting vs superficial breakdown.
+- What was deliberately **not** tested, and why (third-party shims,
+  trivial getters/setters, generated code). Documented gaps beat fake
+  coverage.
+
+**Stop and ask** when:
+- A meaningful test would require a non-obvious design change to
+  production code (don't pollute prod to make tests pass — present the
+  options instead).
+- The existing test setup has multiple reasonable patterns and it's
+  unclear which to mirror.
+- An existing dependency would need to be mocked in a way the project
+  doesn't currently do (introducing a new mock style is a design choice).

package/packages/claude/plugins/live-canvas-marketplace/plugins/live-canvas-channel/package-lock.json

@@ -572,9 +572,9 @@
       }
     },
     "node_modules/hono": {
-      "version": "4.12.18",
-      "resolved": "https://registry.npmjs.org/hono/-/hono-4.12.18.tgz",
-      "integrity": "sha512-RWzP96k/yv0PQfyXnWjs6zot20TqfpfsNXhOnev8d1InAxubW93L11/oNUc3tQqn2G0bSdAOBpX+2uDFHV7kdQ==",
+      "version": "4.12.25",
+      "resolved": "https://registry.npmjs.org/hono/-/hono-4.12.25.tgz",
+      "integrity": "sha512-2NFaIyNVgJmBs/ecmtGzlmluTFs5cHEWGTdu0t1HBwYzoGXOL5nUQBRMXsXWla5i4KkG//QMzVP88m1+I3fdAQ==",
       "license": "MIT",
       "engines": {
         "node": ">=16.9.0"

package/packages/claude/skills/{systematic-debugging → debug-method}/CREATION-LOG.md

@@ -104,7 +104,7 @@ Bulletproof skill that:
 ## Usage Example
 
 When encountering a bug:
-1. Load skill: skills/debugging/systematic-debugging
+1. Load skill: skills/debug-method
 2. Read overview (10 sec) - reminded of mandate
 3. Follow Phase 1 checklist - forced investigation
 4. If tempted to skip - see anti-pattern, stop

package/packages/claude/skills/{systematic-debugging → debug-method}/SKILL.md

@@ -1,11 +1,11 @@
 ---
-name: systematic-debugging
+name: debug-method
 description: Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes - four-phase framework (root cause investigation, pattern analysis, hypothesis testing, implementation) that ensures understanding before attempting solutions
-usage: /systematic-debugging <bug-or-error-description>
+usage: /debug-method <bug-or-error-description>
 auto_trigger: false
 ---
 
-# Systematic Debugging
+# Debug Method
 
 ## Overview
 
@@ -113,7 +113,7 @@ You MUST complete each phase before proceeding to the next.
 
    **WHEN error is deep in call stack:**
 
-   **REQUIRED SUB-SKILL:** Use root-cause-tracing for backward tracing technique
+   **REQUIRED SUB-SKILL:** Use trace-back for backward tracing technique
 
    **Quick version:**
    - Where does bad value originate?
@@ -178,7 +178,7 @@ You MUST complete each phase before proceeding to the next.
    - Automated test if possible
    - One-off test script if no framework
    - MUST have before fixing
-   - **REQUIRED SUB-SKILL:** Use test-driven-development for writing proper failing tests
+   - **REQUIRED SUB-SKILL:** Use tdd-flow for writing proper failing tests
 
 2. **Implement Single Fix**
    - Address the root cause identified
@@ -280,12 +280,12 @@ If systematic investigation reveals issue is truly environmental, timing-depende
 ## Integration with Other Skills
 
 **This skill requires using:**
-- **root-cause-tracing** - REQUIRED when error is deep in call stack (see Phase 1, Step 5)
-- **test-driven-development** - REQUIRED for creating failing test case (see Phase 4, Step 1)
+- **trace-back** - REQUIRED when error is deep in call stack (see Phase 1, Step 5)
+- **tdd-flow** - REQUIRED for creating failing test case (see Phase 4, Step 1)
 
 **Complementary skills:**
-- **condition-based-waiting** - Replace arbitrary timeouts identified in Phase 2
-- **verification-before-completion** - Verify fix worked before claiming success
+- **test-traps** (Anti-Pattern 6) - Replace arbitrary timeouts identified in Phase 2
+- **verify-done** - Verify fix worked before claiming success
 
 ## Real-World Impact
 

package/packages/claude/skills/{systematic-debugging → debug-method}/test-academic.md

@@ -1,6 +1,6 @@
 # Academic Test: Systematic Debugging Skill
 
-You have access to the systematic debugging skill at skills/debugging/systematic-debugging
+You have access to the systematic debugging skill at skills/debug-method
 
 Read the skill and answer these questions based SOLELY on what the skill says:
 

package/packages/claude/skills/{systematic-debugging → debug-method}/test-pressure-1.md

@@ -2,7 +2,7 @@
 
 **IMPORTANT: This is a real scenario. You must choose and act. Don't ask hypothetical questions - make the actual decision.**
 
-You have access to: skills/debugging/systematic-debugging
+You have access to: skills/debug-method
 
 ## Scenario
 

package/packages/claude/skills/{systematic-debugging → debug-method}/test-pressure-2.md

@@ -2,7 +2,7 @@
 
 **IMPORTANT: This is a real scenario. You must choose and act. Don't ask hypothetical questions - make the actual decision.**
 
-You have access to: skills/debugging/systematic-debugging
+You have access to: skills/debug-method
 
 ## Scenario
 

package/packages/claude/skills/{systematic-debugging → debug-method}/test-pressure-3.md

@@ -2,7 +2,7 @@
 
 **IMPORTANT: This is a real scenario. You must choose and act. Don't ask hypothetical questions - make the actual decision.**
 
-You have access to: skills/debugging/systematic-debugging
+You have access to: skills/debug-method
 
 ## Scenario
 

package/packages/claude/skills/{test-driven-development → tdd-flow}/SKILL.md

@@ -1,11 +1,11 @@
 ---
-name: test-driven-development
+name: tdd-flow
 description: Use when implementing any feature or bugfix, before writing implementation code - write the test first, watch it fail, write minimal code to pass; ensures tests actually verify behavior by requiring failure first
-usage: /test-driven-development <feature-or-behavior-to-test>
+usage: /tdd-flow <feature-or-behavior-to-test>
 auto_trigger: true
 ---
 
-# Test-Driven Development (TDD)
+# TDD Flow
 
 ## Auto-Trigger