liteagents 3.0.0 → 3.6.0

package/packages/claude/{commands/remember.md → skills/remember/SKILL.md}

@@ -1,7 +1,8 @@
 ---
 name: remember
 description: Consolidate stashes + friction into project memory
-usage: /remember
+allowed-tools: Read, Grep, Glob
+disable-model-invocation: true
 ---
 
 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. A docs reconcile check runs at the end, detect-only.
@@ -44,7 +45,7 @@ Reads all raw material (`.claude/stash/*.md` + `.claude/remember/friction/antige
      not this package, so a cwd-relative path fails everywhere except the liteagents repo
      itself.
      ```bash
-     node ~/.claude/commands/remember/version-check.cjs
+     node ~/.claude/skills/remember/version-check.cjs
      ```
      **If that path does not exist, use the directory you just resolved for
      `friction.cjs`** — the two ship side by side, so that directory is correct for a
@@ -62,6 +63,7 @@ Reads all raw material (`.claude/stash/*.md` + `.claude/remember/friction/antige
      exists and contains `.jsonl` files directly, or one level down in per-project
      subdirectories (friction.cjs scans exactly those two levels, not a deep recursive walk).
      **Never prompt the user.**
+     <!-- mirror:literal:start — every tool's real path, identical in all four kits -->
      ```
      # ── Add your own global sessions root at the TOP so it is checked first ──
      ~/.claude/projects/                 # Claude Code
@@ -71,6 +73,7 @@ Reads all raw material (`.claude/stash/*.md` + `.claude/remember/friction/antige
      ~/.codex/sessions/                  # Codex CLI  (use $CODEX_HOME/sessions/ if set)
      ~/.gemini/antigravity-cli/brain/    # Antigravity
      ```
+     <!-- mirror:literal:end -->
      > Note: `friction.cjs` 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
@@ -96,7 +99,7 @@ Reads all raw material (`.claude/stash/*.md` + `.claude/remember/friction/antige
      does the whole decision itself. Call it by **absolute path**, for the same reason as
      `version-check.cjs` in step 0: the cwd is the target repo, not this package.
      ```bash
-     node ~/.claude/commands/remember/sync-rules.cjs
+     node ~/.claude/skills/remember/sync-rules.cjs
      ```
      It compares `.claude/remember/AGENT_RULES.md` against the template shipped beside it
      and takes one of three actions: **absent** — copies it in; **identical** — does
@@ -436,7 +439,7 @@ Reads all raw material (`.claude/stash/*.md` + `.claude/remember/friction/antige
    - **Then assert the stub SHAPE mechanically** — run the bundled script by **absolute
      path**, for the same reason as steps 0 and 1:
      ```bash
-     node ~/.claude/commands/remember/stub-check.cjs
+     node ~/.claude/skills/remember/stub-check.cjs
      ```
      It edits only *inside* the marker pairs, and only the mechanism: a MEMORY include that
      is not `@.claude/remember/MEMORY.md` is repaired, and an `@`-include of
@@ -512,8 +515,10 @@ Reads all raw material (`.claude/stash/*.md` + `.claude/remember/friction/antige
    `index-flat` script `/docs-builder` already uses, never a model call. Wrapped so any
    failure here can never block the memory write that already happened in steps 3-6.
 
-   - **Locate `docs-builder.cjs`** — bundled next to this command at
-     `docs-builder/docs-builder.cjs` (same convention as `remember/friction.cjs`). Call it by
+   - **Locate `docs-builder.cjs`** — it ships in the `docs-builder/` directory
+     that sits beside this one (under `skills/` on Claude Code and Amp, under
+     `commands/` on Droid and opencode), exactly as `friction.cjs` ships beside
+     this file. Call it by
      its **absolute path** in the command below — the cwd here is the target repo, not this
      package, so a cwd-relative path fails everywhere except the liteagents repo itself.
    - **Not applicable, stay silent:** if the project has no `docs/` directory, skip without

package/packages/claude/{commands → skills}/remember/stub-check.cjs

@@ -60,31 +60,40 @@ function lexists(p) {
  * "the file is absent" and is still followed on write — or any parent
  * directory may be a link pointing elsewhere. This runs across a whole fleet
  * of repos, so a relative link only has to reach a sibling checkout.
+ *
+ * A link that stays INSIDE the repo is not an escape: a repo that keeps its
+ * rules or its config behind an in-repo symlink is an ordinary setup, and
+ * refusing it would strand that repo forever. So the leaf is followed by hand
+ * with readlink — which works on a dangling link, where realpath cannot — and
+ * each hop re-resolves the parents, because the file a link points at can sit
+ * behind a linked directory of its own.
  */
 function escapesRepo(repo, target) {
   let root;
   try { root = fs.realpathSync(repo); } catch (e) { return true; }
 
-  // Walk up to the deepest ancestor that exists; anything below it cannot be
-  // a link yet, so only the existing part needs resolving.
-  const tail = [];
-  let dir = path.dirname(target);
-  while (!lexists(dir)) {
-    tail.unshift(path.basename(dir));
-    const up = path.dirname(dir);
-    if (up === dir) return true;                  // walked off the filesystem root
-    dir = up;
-  }
-
-  let resolved;
-  try { resolved = path.join(fs.realpathSync(dir), ...tail, path.basename(target)); }
-  catch (e) { return true; }                      // an ancestor is a dangling link
-
-  // The last component can be a link even when every directory above it is
-  // clean — that is the dangling-file case.
-  try { if (fs.lstatSync(resolved).isSymbolicLink()) return true; } catch (e) { /* absent: fine */ }
+  let p = path.resolve(target);
+  for (let hop = 0; hop < 40; hop++) {
+    // Resolve the existing part of the path. Walk up to the deepest ancestor
+    // that exists; anything below it cannot be a link yet.
+    const tail = [];
+    let dir = path.dirname(p);
+    while (!lexists(dir)) {
+      tail.unshift(path.basename(dir));
+      const up = path.dirname(dir);
+      if (up === dir) return true;                  // walked off the filesystem root
+      dir = up;
+    }
+    try { p = path.join(fs.realpathSync(dir), ...tail, path.basename(p)); }
+    catch (e) { return true; }                      // an ancestor is a dangling link
 
-  return resolved !== root && !resolved.startsWith(root + path.sep);
+    let to;
+    try { to = fs.readlinkSync(p); } catch (e) {
+      return p !== root && !p.startsWith(root + path.sep);   // not a link: decide here
+    }
+    p = path.resolve(path.dirname(p), to);
+  }
+  return true;                                      // a link cycle: refuse
 }
 
 /** Index range of the lines strictly between a marker pair, or null. */

package/packages/claude/{commands → skills}/remember/sync-rules.cjs

@@ -50,31 +50,40 @@ function lexists(p) {
  * "the file is absent" and is still followed on write — or any parent
  * directory may be a link pointing elsewhere. This runs across a whole fleet
  * of repos, so a relative link only has to reach a sibling checkout.
+ *
+ * A link that stays INSIDE the repo is not an escape: a repo that keeps its
+ * rules or its config behind an in-repo symlink is an ordinary setup, and
+ * refusing it would strand that repo forever. So the leaf is followed by hand
+ * with readlink — which works on a dangling link, where realpath cannot — and
+ * each hop re-resolves the parents, because the file a link points at can sit
+ * behind a linked directory of its own.
  */
 function escapesRepo(repo, target) {
   let root;
   try { root = fs.realpathSync(repo); } catch (e) { return true; }
 
-  // Walk up to the deepest ancestor that exists; anything below it cannot be
-  // a link yet, so only the existing part needs resolving.
-  const tail = [];
-  let dir = path.dirname(target);
-  while (!lexists(dir)) {
-    tail.unshift(path.basename(dir));
-    const up = path.dirname(dir);
-    if (up === dir) return true;                  // walked off the filesystem root
-    dir = up;
-  }
-
-  let resolved;
-  try { resolved = path.join(fs.realpathSync(dir), ...tail, path.basename(target)); }
-  catch (e) { return true; }                      // an ancestor is a dangling link
-
-  // The last component can be a link even when every directory above it is
-  // clean — that is the dangling-file case.
-  try { if (fs.lstatSync(resolved).isSymbolicLink()) return true; } catch (e) { /* absent: fine */ }
+  let p = path.resolve(target);
+  for (let hop = 0; hop < 40; hop++) {
+    // Resolve the existing part of the path. Walk up to the deepest ancestor
+    // that exists; anything below it cannot be a link yet.
+    const tail = [];
+    let dir = path.dirname(p);
+    while (!lexists(dir)) {
+      tail.unshift(path.basename(dir));
+      const up = path.dirname(dir);
+      if (up === dir) return true;                  // walked off the filesystem root
+      dir = up;
+    }
+    try { p = path.join(fs.realpathSync(dir), ...tail, path.basename(p)); }
+    catch (e) { return true; }                      // an ancestor is a dangling link
 
-  return resolved !== root && !resolved.startsWith(root + path.sep);
+    let to;
+    try { to = fs.readlinkSync(p); } catch (e) {
+      return p !== root && !p.startsWith(root + path.sep);   // not a link: decide here
+    }
+    p = path.resolve(path.dirname(p), to);
+  }
+  return true;                                      // a link cycle: refuse
 }
 
 function templatePath() {

package/packages/{ampcode/commands → claude/skills}/remember/version-check.cjs

@@ -35,7 +35,7 @@ const path = require('path');
 
 const PKG = 'liteagents';
 // Per-kit config dir. This is the ONE line that differs across packages.
-const CONFIG_DIR = '.config/amp';
+const CONFIG_DIR = '.claude';
 const TTL_MS = 24 * 60 * 60 * 1000;
 const DEADLINE_MS = 2000;
 const NPM_LOOKUP_MS = 3000;
@@ -62,7 +62,7 @@ function isNewer(a, b) {
 // --- installed version ---------------------------------------------------
 
 // Walk up from this file looking for our own package.json. Finds it when
-// running from a checkout; finds nothing when installed into ~/.config/amp, which
+// running from a checkout; finds nothing when installed into ~/.claude, which
 // is why the npm fallback exists.
 function versionFromPackageJson() {
   let dir = __dirname;
@@ -79,7 +79,7 @@ function versionFromPackageJson() {
 }
 
 // The installer stamps the release it wrote into <install root>/manifest.json.
-// version-check.cjs sits at <root>/<commands|command>/remember/, so the root is
+// version-check.cjs sits at <root>/<skills|commands|command>/remember/, so the root
 // two levels up. This is the fast path: reading a file beats spawning npm.
 function versionFromManifest() {
   try {

package/packages/claude/skills/root-cause/SKILL.md

@@ -0,0 +1,220 @@
+---
+name: root-cause
+description: Use when any test fails, bug appears, or behaviour surprises you, before proposing a fix - find the cause and prove it, by reading real evidence, tracing bad values back to their origin, comparing against a working case, and testing one hypothesis at a time
+allowed-tools: Read, Grep, Glob
+---
+
+# Root Cause
+
+**Find the cause before you change any code.**
+
+## The Law
+
+```
+NO FIX WITHOUT A CAUSE YOU CAN POINT AT
+```
+
+A fix at the place the error *appeared* is a symptom fix. It is a failure even when
+the symptom goes away, because the real cause is still there and will surface
+somewhere else, later, with less context.
+
+You cannot propose a fix until Phase 1 is done.
+
+## When to Use
+
+Any technical issue: a failing test, a production bug, unexpected behaviour, a
+performance problem, a broken build, an integration that will not talk.
+
+**Especially when it feels like overkill:**
+- Under time pressure — emergencies are exactly when guessing is most tempting and most expensive
+- "Just one quick fix" looks obvious
+- You have already tried a fix and it did not work
+- You do not fully understand the issue
+
+Simple bugs have root causes too, and finding one takes minutes. Guess-and-check
+takes hours and leaves damage behind.
+
+---
+
+## Phase 1 — Gather Evidence
+
+Do all of this **before** forming any opinion about the fix.
+
+### 1. Read the error completely
+
+Do not skim past it. Read the whole message, the whole stack trace, every warning
+above it. Note line numbers, file paths, error codes. The answer is often written
+there in full.
+
+### 2. Reproduce it consistently
+
+Can you trigger it on demand? What are the exact steps? Does it happen every time?
+
+If it is not reproducible, gather more data. Do not start guessing — an
+intermittent bug you cannot trigger is a bug you cannot prove you fixed.
+
+### 3. Check what changed
+
+Recent commits, the working diff, new dependencies, config edits, environment
+differences between the place it works and the place it does not.
+
+Be careful here: the most recent change is the most *available* suspect, not the
+most likely one. Recency is a lead to test, never a conclusion.
+
+### 4. Instrument the boundaries (multi-component systems)
+
+When the path crosses components — CI → build → sign, API → service → database,
+workflow → script → tool — do not reason about where it breaks. Measure it.
+
+For each boundary, log what goes **in** and what comes **out**, and confirm
+configuration and environment actually propagated across it.
+
+```bash
+echo "=== layer 1: is the secret present in the workflow? ==="
+echo "IDENTITY: ${IDENTITY:+SET}${IDENTITY:-UNSET}"
+
+echo "=== layer 2: did it survive into the build script? ==="
+env | grep IDENTITY || echo "IDENTITY not in environment"
+
+echo "=== layer 3: what does the tool actually see? ==="
+security find-identity -v
+```
+
+Run it **once** to find which boundary fails, then investigate only that
+component. This turns "somewhere in the pipeline" into a named layer.
+
+### 5. Trace the bad value back to where it was born
+
+When the error surfaces deep in the call stack, the place it exploded is almost
+never the place it went wrong. Walk backwards.
+
+**The chain:**
+
+1. **Observe the symptom** — `git init` ran in the source directory
+2. **Find the immediate cause** — the code that directly did it:
+   `execFileAsync('git', ['init'], { cwd: projectDir })`
+3. **Ask what called this, and with what value** — `projectDir` was `''`, and an
+   empty `cwd` silently resolves to the process's own directory
+4. **Keep going up** — who passed the empty string? and who gave it to *them*?
+5. **Stop at the origin** — the point where a correct value first became wrong
+
+Fix it **there**. Then, if the value is dangerous, validate it at each layer on
+the way down as well, so the same mistake cannot recur through a different path.
+
+**When you cannot trace it by reading, instrument it:**
+
+```typescript
+async function gitInit(directory: string) {
+  console.error('DEBUG git init:', {
+    directory,
+    cwd: process.cwd(),
+    stack: new Error().stack,
+  });
+  await execFileAsync('git', ['init'], { cwd: directory });
+}
+```
+
+- Capture the **stack**, not just the value — it names the caller you are looking for
+- Log **before** the dangerous operation, not in its failure handler
+- Include surrounding context: the directory, the working directory, relevant environment
+- In tests, write to standard error directly; a project logger may be suppressed
+
+**When something pollutes a test run but you cannot tell which test:** bisect.
+Run the tests one at a time and stop at the first one that leaves the mess behind.
+`find-polluter.sh` in this skill's directory does exactly that.
+
+---
+
+## Phase 2 — Compare Against Something That Works
+
+You are looking for a difference, and the fastest way to see one is a side-by-side.
+
+- **Find a working example** — similar code in the same codebase that behaves correctly
+- **Read the reference completely** if you are following a pattern. Every line. Skimming a
+  reference and adapting "the idea" is how half-understood patterns ship
+- **List every difference**, however small. Do not filter by "that can't matter" — that
+  judgement is exactly what you do not have yet
+- **Check the dependencies**: what config, what environment, what other components does
+  the working one have that the broken one does not?
+
+---
+
+## Phase 3 — One Hypothesis, One Variable
+
+- **State it in writing:** "I think X is the cause, because Y." Specific, not vague.
+- **Test it with the smallest possible change.** One variable. A controlled test that
+  isolates your suspect beats a plausible story about the most recent commit.
+- **Read the result honestly.** Confirmed → Phase 4. Not confirmed → form a *new*
+  hypothesis. Never stack a second fix on top of an unconfirmed first one.
+- **Say when you do not know.** "I don't understand why X happens" is a real state and a
+  useful thing to report. Pretending to know produces confident wrong fixes.
+
+---
+
+## Phase 4 — Fix at the Source
+
+### 1. Write the failing test first
+
+The simplest reproduction you can manage — an automated test if there is a suite, a
+throwaway script if there is not.
+
+**Run it against the unfixed code and watch it fail, for the reason you expect.** A
+test written after the fix, or one that passes both before and after, proves nothing.
+This is the step that converts your hypothesis into evidence.
+
+### 2. Make one change
+
+Fix the cause you identified. One change. No "while I'm here" improvements, no bundled
+refactoring — those make it impossible to tell what actually worked.
+
+### 3. Verify
+
+Does the new test pass? Does the rest of the suite still pass? Is the original symptom
+actually gone — checked, not assumed?
+
+### 4. If the fix did not work, stop and count
+
+Under three attempts: return to Phase 1 with what you just learned. The failed attempt
+is evidence.
+
+**Three or more failed fixes means you have the wrong model of the problem.** Do not
+attempt a fourth. The pattern to watch for: each fix uncovers a new problem somewhere
+else, or each one needs "just a bit of refactoring" to land.
+
+That is an architecture question, not a hypothesis question. Stop and raise it.
+
+---
+
+## Red Flags — Stop and Return to Phase 1
+
+- "Quick fix now, investigate later"
+- "Just try changing X and see"
+- Several changes at once, then run the tests
+- "Skip the test, I'll check it by hand"
+- "It's probably X" — probably is not a cause
+- "I don't fully understand this, but this might work"
+- Listing fixes before tracing where the bad value came from
+- "One more attempt" when two have already failed
+- Each fix revealing a new problem somewhere else
+
+## Quick Reference
+
+| Phase | You do | Done when |
+|---|---|---|
+| **1. Evidence** | Read the error, reproduce, check changes, instrument boundaries, trace the value back | You can say what happened and where it started |
+| **2. Compare** | Find a working case, read it fully, list every difference | You know what is different |
+| **3. Hypothesis** | State one cause, test one variable | Confirmed, or you have a new hypothesis |
+| **4. Fix** | Failing test first, one change, verify | The test that failed now passes, and nothing else broke |
+
+## When There Really Is No Root Cause
+
+It happens — a genuine race, an upstream bug, a hardware fault. But roughly nineteen
+times in twenty, "no root cause" means the investigation stopped early.
+
+Before you conclude it: can you reproduce it? Did you instrument every boundary? Did
+you trace the value to its origin, or only to the last function you recognised?
+
+## Related
+
+- **AGENT_RULES.md → Testing Standards** — what makes the Phase 4 test a real one
+- **`/test-generate`** — build out the suite once the cause is fixed

package/packages/{ampcode/commands/security.md → claude/skills/security/SKILL.md}

@@ -1,9 +1,9 @@
 ---
 name: security
 description: Security audit — recurring six, injection, auth, trust boundaries
-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, Grep, Glob, Bash(git log:*), Bash(git grep:*), Bash(rg:*)
+disable-model-invocation: true
 ---
 Audit $ARGUMENTS for security vulnerabilities. **Reports, never edits** — it
 verifies every claim, then hands the findings to whoever asked.

package/packages/{ampcode/commands/ship.md → claude/skills/ship/SKILL.md}

@@ -1,8 +1,8 @@
 ---
 name: ship
 description: Mechanical pre-deploy gate — tests, build, tree state
-usage: /ship
-allowed-tools: Read, Grep, Glob, Bash(git *), Bash(npm *), Bash(pnpm *), Bash(yarn *), Bash(pytest *), Bash(python *), Bash(go *), Bash(cargo *), Bash(make *)
+allowed-tools: Read, Grep, Glob, Bash(git:*), Bash(npm:*), Bash(pnpm:*), Bash(yarn:*), Bash(pytest:*), Bash(python:*), Bash(go:*), Bash(cargo:*), Bash(make:*)
+disable-model-invocation: true
 ---
 Mechanical pre-deploy / pre-merge gate. Every item here is answerable by
 **running a command** and reading its exit code — no code judgment. Code

package/packages/claude/skills/skill-creator/SKILL.md

@@ -1,9 +1,8 @@
 ---
 name: skill-creator
 description: Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.
-usage: /skill-creator <skill-type> <skill-description>
-auto_trigger: false
 license: Complete terms in LICENSE.txt
+allowed-tools: Read, Grep, Glob
 ---
 
 # Skill Creator

package/packages/claude/{commands/stash.md → skills/stash/SKILL.md}

@@ -1,8 +1,9 @@
 ---
 name: stash
 description: Stash session context [name]
-usage: /stash ["optional-name"]
 argument-hint: [optional stash name]
+allowed-tools: Read, Grep, Glob
+disable-model-invocation: true
 ---
 
 Save session context for compaction recovery or handoffs.

package/packages/{ampcode/commands/test-generate.md → claude/skills/test-generate/SKILL.md}

@@ -1,9 +1,9 @@
 ---
 name: test-generate
 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 *)
+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:*)
+disable-model-invocation: true
 ---
 Generate tests for $ARGUMENTS, then run them. This is a generate → run →
 verify loop, not just file generation.
@@ -28,7 +28,7 @@ Match existing patterns:
   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).
+  expose, stop and ask.
 
 ## 3. Run
 Execute the project's real test command, scoped to just the new tests

package/packages/claude/variants.json

@@ -1,10 +1,9 @@
 {
   "pro": {
     "name": "Pro",
-    "description": "Complete installation with all agents, skills, and commands",
+    "description": "Complete installation with all agents and skills",
     "agents": "*",
     "skills": "*",
-    "commands": "*",
     "plugins": "*"
   }
 }

package/packages/droid/AGENTS.md

@@ -21,28 +21,23 @@ These subagents are available when using Claude Code CLI. Droid can reference th
 | system-architect | Architect | Use for system design, architecture documents, technology selection, API design, and infrastructure planning |
 | ui-designer | UX Expert | Use for UI/UX design, wireframes, prototypes, front-end specifications, and user experience optimization |
 
-## Droid Commands (18 total)
-
-| ID | Description | Usage | Auto |
-|---|---|---|---|
-| brainstorming | Refines rough ideas into fully-formed designs through collaborative questioning | /brainstorming <session-type> <topic> | false |
-| docs-builder | Reorg a docs corpus, split an oversized doc, search it, keep pages current, index them | /docs-builder [reorg \| cleanup <file.md>] | false |
-| live-canvas | Design UI variations and collect click-to-annotate feedback from the browser (batch mode only on Droid) | /live-canvas | false |
-| optimize | Analyze and optimize performance issues | /optimize <target-area> | - |
-| refactor | Refactor code while maintaining behavior and tests | /refactor <code-section> | - |
+## Droid Commands (13 total)
+
+| ID | Description | Usage |
+|---|---|---|
+| brainstorming | Refines rough ideas into fully-formed designs through collaborative questioning | /brainstorming <session-type> <topic> |
+| docs-builder | Reorg a docs corpus, split an oversized doc, search it, keep pages current, index them | /docs-builder [reorg \| cleanup <file.md>] |
+| live-canvas | Design UI variations and collect click-to-annotate feedback from the browser (batch mode only on Droid) | /live-canvas |
+| refactor | Refactor and optimize code while maintaining behavior and tests | /refactor <code-section> | - |
 | remember | Consolidate stashes + friction into project memory | /remember | - |
 | branch-review | Pre-merge review: general review + full security audit, verify pass, no fixes | /branch-review [target] [level] | - |
-| trace-back | Systematically traces bugs backward through call stack to identify source | /trace-back <issue-description> | false |
+| root-cause | Find the cause before changing code - evidence, backward trace, one hypothesis, fix at the source | /root-cause <bug-or-error-description> |
 | security | Security audit — recurring six, injection, auth, trust boundaries; reports, never fixes | /security [target] | - |
 | ship | Mechanical pre-deploy gate — tests, build, tree state | /ship | - |
 | release | Verify, sweep docs, cut a version — then hand back the merge/tag/publish sequence | /release | - |
-| skill-creator | Guide for creating effective skills and extending Claude capabilities | /skill-creator <skill-type> <skill-description> | false |
+| skill-creator | Guide for creating effective skills and extending Claude capabilities | /skill-creator <skill-type> <skill-description> |
 | stash | Save session context for compaction recovery or handoffs | /stash ["optional-name"] | - |
-| debug-method | Four-phase debugging framework - investigate root cause before any fixes | /debug-method <bug-or-error-description> | false |
-| tdd-flow | Write test first, watch it fail, write minimal code to pass | /tdd-flow <feature-or-behavior-to-test> | true |
 | test-generate | Generate tests, run them, verify each one actually exercises the code | /test-generate <file> | - |
-| test-traps | Prevents testing mock behavior and production pollution with test-only methods | /test-traps <testing-scenario> | true |
-| verify-done | Requires running verification commands before making any success claims | /verify-done <work-to-verify> | true |
 
 All resources are auto-discovered from frontmatter in their respective directories:
 - **Agents**: `./droids/*.md`

package/packages/droid/commands/brainstorming.md

@@ -1,8 +1,5 @@
 ---
-name: brainstorming
 description: Use when creating or developing, before writing code or implementation plans - refines rough ideas into fully-formed designs through collaborative questioning, alternative exploration, and incremental validation. Don't use during clear 'mechanical' processes
-usage: /brainstorming <session-type> <topic>
-auto_trigger: false
 ---
 
 # Brainstorming Ideas Into Designs
@@ -43,7 +40,7 @@ Start by understanding the current project context, then ask questions one at a
 
 **Implementation (if continuing):**
 - Ask: "Ready to set up for implementation?"
-- Create isolated workspace (use git worktrees if needed)
+- Create isolated workspace for implementation
 - Create detailed implementation plan
 
 ## Key Principles