liteagents 3.0.0 → 3.5.0

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

package/packages/droid/commands/branch-review.md

@@ -1,9 +1,6 @@
 ---
-name: branch-review
 description: Review a branch before merge [target] [level]
-usage: /branch-review [target] [low|medium|high|max]
 argument-hint: [file, branch (e.g. main), range (main..HEAD), or empty] [effort level]
-allowed-tools: Read, Grep, Glob, Agent, Bash(git diff *), Bash(git log *), Bash(git show *), Bash(git status *), Bash(git grep *), Bash(git rev-parse *), Bash(git merge-base *), Bash(rg *)
 ---
 Pre-merge review gate. Two stages — **general review** then a **full security
 audit** — followed by an adversarial verify pass. It **never edits code**: it
@@ -11,7 +8,7 @@ reports findings and hands them back. Fixing is a separate, separately
 authorized action.
 
 Only **Critical** and **High** findings block the merge. Everything else is
-appended to the **fix ledger** (`.claude/remember/fix-ledger.md`) — a local,
+appended to the **fix ledger** (`.factory/remember/fix-ledger.md`) — a local,
 cumulative list, living beside `MEMORY.md`, that `/refactor` (no arguments)
 works through between features. Like its neighbours it is a private working
 artifact, usually gitignored; it persists across reviews, it is not a
@@ -44,17 +41,17 @@ at the current HEAD SHA.
   review of a report. (Same rule `/security` carries inside stage 2.)
 - **No edits — two exceptions.** You have no authorization to change code,
   even for a finding you are certain about. Report it. The only files you may
-  write are `.claude/remember/fix-ledger.md` (append bullets; never rewrite or
-  delete) and `.claude/remember/last-review.md` (overwrite; the review record
+  write are `.factory/remember/fix-ledger.md` (append bullets; never rewrite or
+  delete) and `.factory/remember/last-review.md` (overwrite; the review record
   described at the end of this file).
 - **Prove it with two checks, because neither sees what the other does.**
   `git status --porcelain`, at start and again before you report, proves no
   **tracked** file changed — that is the "never edits code" guarantee, and it
-  is the one that matters. It cannot police your own two writes: `.claude/`
+  is the one that matters. It cannot police your own two writes: `.factory/`
   is normally gitignored, so porcelain stays empty whether you wrote the
   allowed files, wrote nothing, or overwrote `MEMORY.md`. `git status
-  --ignored` does not close it either — it collapses to `!! .claude/`, the
-  directory, not the files. So also take `md5sum .claude/remember/*` before
+  --ignored` does not close it either — it collapses to `!! .factory/`, the
+  directory, not the files. So also take `md5sum .factory/remember/*` before
   you start and again before you report, and show the comparison: only
   `fix-ledger.md` and `last-review.md` may differ.
 
@@ -95,7 +92,7 @@ Record the **HEAD SHA** you reviewed, and **report the target you resolved**
 (the literal range or path) in your output, so the orchestrator can see what
 was actually read rather than assuming.
 
-**Re-review after fixes: read `.claude/remember/last-review.md` first.** Its
+**Re-review after fixes: read `.factory/remember/last-review.md` first.** Its
 `sha:` line is the previously-reviewed commit and its `blockers:` list is what
 you owe an answer on — take both from the file, never from the orchestrator's
 recollection, for the same reason `/release` does. Then:
@@ -231,7 +228,7 @@ check before escalating.
 
 ### Ledger (non-blocking — medium / low)
 Not in the report. **Append** each one as a single bullet to
-`.claude/remember/fix-ledger.md` (create the file with the header below if
+`.factory/remember/fix-ledger.md` (create the file with the header below if
 missing):
 
 ```
@@ -256,7 +253,7 @@ with `UNVERIFIED:` so `/refactor` retests before acting.
 The **snippet is the anchor**: 20–60 verbatim characters from the line,
 unique enough for `git grep -F` to find it after lines shift. No line
 numbers, no TODO comments in code — the ledger is the single writer. Before
-appending, dedupe with **plain `grep -F "<snippet>" .claude/remember/fix-ledger.md`**;
+appending, dedupe with **plain `grep -F "<snippet>" .factory/remember/fix-ledger.md`**;
 if it is already there, skip it. Do not touch existing bullets.
 
 **A bullet you disprove is deleted, not annotated.** If you establish that an
@@ -280,7 +277,7 @@ Then a coverage line: stage 1 at level `<level>`, stage 2 full, stage 3 —
 each `ran ✓/✗` with its evidence. A stage you did not actually run is a **✗**, never an
 assumed pass.
 
-**Write the review record** to `.claude/remember/last-review.md`, overwriting
+**Write the review record** to `.factory/remember/last-review.md`, overwriting
 it. `/release` reads this file; a SHA that lives only in a chat message is
 gone after a compaction or a handover, and the only remaining source is the
 orchestrator — the one party this command already refuses to take a review's
@@ -326,7 +323,7 @@ does not move — which means nothing was fixed, which is the correct outcome.
 
 End with:
 - **Reviewed at HEAD `<sha>` on `<branch>`, target `<resolved range or path>`,
-  tree clean at start; at exit clean or the two `.claude/remember/` paths
+  tree clean at start; at exit clean or the two `.factory/remember/` paths
   only.**
 - **Fix ledger: N open, M added this run** (N = bullet count). When N > 0,
   add: "N fixes waiting — run `/refactor` between features." The ledger is a

package/packages/droid/commands/docs-builder.md

@@ -1,9 +1,6 @@
 ---
-name: docs-builder
 description: Reorg a docs corpus, split an oversized doc, search it, keep pages current, index them
-usage: /docs-builder [reorg | cleanup <file.md> | search <query words...>]
 argument-hint: [reorg | cleanup <file.md> | search <query words...> — empty asks first run vs. drift]
-allowed-tools: Read, Write, Edit, Grep, Glob, Task, AskUserQuestion, Bash(node:*), Bash(git:*), Bash(rg:*)
 ---
 
 # docs-builder