moflo 4.9.12 → 4.9.14

package/.claude/helpers/gate.cjs

@@ -88,7 +88,11 @@ var TASK_RE = /\b(fix|bug|error|implement|add|create|build|write|refactor|debug|
 var TEST_RUNNER_RE = /(?:^|[^a-z])(?:npm|yarn|pnpm|bun)\s+(?:run\s+)?(?:test|t)(?:[:\s]|$)|\b(?:npx|pnpx)\s+(?:vitest|jest|mocha|ava|tap|jasmine|pytest)\b|(?:^|;|&&|\|\|)\s*(?:vitest|jest|pytest|mocha|jasmine|tap|ava)\s|\b(?:cargo|go|deno|dotnet|mvn)\s+test\b|\bgradle\w*\s+test\b/i;
 // Edits to these don't change runtime behaviour, so they don't invalidate prior test/simplify runs.
 // Lock files and .gitignore are tracked but inert; package.json/*.yaml ARE source — they reset.
-var EDIT_RESET_SKIP_RE = /\.(md|markdown|txt|rst|adoc|lock|gitignore)$|(?:^|[\\\/])(CHANGELOG(?:\.md)?|\.env\.example|package-lock\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lockb)$/i;
+var EDIT_RESET_SKIP_BOTH_RE = /\.(md|markdown|txt|rst|adoc|lock|gitignore)$|(?:^|[\\\/])(CHANGELOG(?:\.md)?|\.env\.example|package-lock\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lockb)$/i;
+// Test files: invalidate the testing gate (tests are stale once test code changes)
+// but NOT the simplify gate — /simplify already reviewed the production code; touching
+// a test file or fixture doesn't expose new untested surface for code review (#908).
+var EDIT_RESET_SKIP_SIMPLIFY_ONLY_RE = /(?:^|[\\\/])(__tests__|__mocks__|tests?|spec|specs|cypress|e2e|fixtures?)[\\\/]|\.(test|spec)\.[mc]?[jt]sx?$|\.fixture\.[mc]?[jt]sx?$/i;
 
 switch (command) {
   case 'check-before-agent': {
@@ -180,11 +184,20 @@ switch (command) {
   }
   case 'reset-edit-gates': {
     var fp = process.env.TOOL_INPUT_file_path || '';
-    if (fp && EDIT_RESET_SKIP_RE.test(fp)) break;
+    // Inert files (markdown, lockfiles, CHANGELOG, .env.example): no gate reset.
+    if (fp && EDIT_RESET_SKIP_BOTH_RE.test(fp)) break;
     var s = readState();
-    if (!s.testsRun && !s.simplifyRun) break;
-    s.testsRun = false;
-    s.simplifyRun = false;
+    // Test-only edits invalidate testsRun but preserve simplifyRun (#908).
+    var isTestOnly = fp && EDIT_RESET_SKIP_SIMPLIFY_ONLY_RE.test(fp);
+    var resetTests = s.testsRun;
+    var resetSimplify = s.simplifyRun && !isTestOnly;
+    if (!resetTests && !resetSimplify) break;
+    var gates = [];
+    if (resetTests) { s.testsRun = false; gates.push('tests'); }
+    if (resetSimplify) { s.simplifyRun = false; gates.push('simplify'); }
+    if (fp) {
+      s.lastResetBy = { file: fp, at: new Date().toISOString(), gates: gates };
+    }
     writeState(s);
     break;
   }
@@ -205,6 +218,9 @@ switch (command) {
     for (var i = 0; i < missing.length; i++) {
       process.stderr.write('  - ' + missing[i] + '\n');
     }
+    if (s.lastResetBy && s.lastResetBy.file) {
+      process.stderr.write('Last gate reset: ' + s.lastResetBy.file + ' (' + (s.lastResetBy.gates || []).join(', ') + ')\n');
+    }
     process.stderr.write('Disable per-gate via moflo.yaml:\n');
     process.stderr.write('  gates:\n    testing_gate: false\n    simplify_gate: false\n    learnings_gate: false\n');
     process.exit(2);

package/.claude/skills/eldar/SKILL.md

@@ -0,0 +1,305 @@
+---
+name: eldar
+description: Consult the Eldar — audit a project's moflo + Claude Code setup for portable, high-leverage gaps and guide remediation. Default mode is read-only audit with severity-ranked findings; --fix presents an interactive triage menu and walks the user through each chosen fix (healer, missing CLAUDE.md, sparse guidance, hook/MCP wiring, empty memory namespaces, stack→guidance gaps). Use when starting in a new project, when Claude feels lost or inefficient, when guidance/CLAUDE.md is sparse, or as a periodic health check.
+arguments: "[--fix]"
+---
+
+# /eldar — Consult the Eldar
+
+The Eldar audit a project's moflo + Claude Code setup for portable, high-leverage gaps. **Audit is read-only by default; `--fix` walks through remediation.** The Eldar consult the **Healer** (`flo healer`, the thematic alias for `flo doctor`), they do not replace them.
+
+**Arguments:** $ARGUMENTS
+
+## Modes
+
+| Mode | Trigger | What it does |
+|------|---------|--------------|
+| Audit | no flag (default) | Read-only scan; produces categorized findings + top-3 recommendation |
+| Fix | `--fix` | Audit, then interactive triage menu; user picks findings to address one at a time |
+
+## Step 0 — Memory First
+
+Before any file reads, run:
+
+```
+mcp__moflo__memory_search { query: "guidance rules project conventions stack", namespace: "guidance" }
+```
+
+The memory-first gate blocks reads otherwise. The search also surfaces any project-specific conventions the Eldar should weigh in their findings.
+
+## Step 1 — Run the Audit
+
+Walk the checklist below in order. Each check is a single category in the final report. Be explicit about what you find — both presence and absence. Severities: `error` (blocks productive work), `warn` (degrades quality), `info` (suggestion).
+
+### 1a. Setup Health — call the Healer
+
+```bash
+npx moflo healer --json
+```
+
+Parse the JSON output. Surface every `failed` check as `error`, every `warn` as `warn`. Do **not** invoke `flo doctor` directly — use the `healer` alias for thematic consistency.
+
+### 1b. Index Freshness
+
+Check for `.moflo/moflo.db` (existence + mtime). Query memory namespaces to confirm guidance + code-map are populated:
+
+```
+mcp__moflo__memory_stats — { namespace: "guidance" }
+mcp__moflo__memory_stats — { namespace: "code-map" }
+```
+
+Flag if `entries === 0` (warn) or db missing (error).
+
+### 1c. Version Skew
+
+```bash
+npm view moflo version    # latest published
+node -e "console.log(require('./package.json').devDependencies?.moflo || require('./package.json').dependencies?.moflo || 'not-installed')"
+```
+
+Compute minor-version delta. Warn if behind by ≥3 minors; info if behind by 1–2.
+
+### 1d. Model & Token Routing
+
+```
+mcp__moflo__hooks_model-stats — {}
+```
+
+If recent sonnet→opus escalation rate exceeds ~30%, flag as `info`: "router escalating frequently — see `.claude/guidance/shipped/moflo-claude-swarm-cohesion.md` for tuning". If stats unavailable (no history), skip silently.
+
+### 1e. CLAUDE.md
+
+Check `CLAUDE.md` (and `.claude/CLAUDE.md`) for:
+
+| Check | Threshold | Severity |
+|-------|-----------|----------|
+| Exists | required | error if missing |
+| Line count | 20–500 | warn if outside range |
+| Referenced files exist | every relative path it cites | warn per missing path |
+
+Use `Grep` over the file content for `\.claude/[a-z-]+/[a-z-]+\.md` patterns and verify each path resolves.
+
+### 1f. Guidance Content
+
+Count `.md` files under `.claude/guidance/` (recursive). Severity table:
+
+| File count | Severity |
+|------------|----------|
+| 0 | warn — "no guidance docs; Claude has nothing project-specific to follow" |
+| 1–2 | warn — "very sparse guidance" |
+| 3–10 | info |
+| 11+ | info |
+
+### 1g. Guidance Structure (only if 1f found ≥1 file)
+
+Apply the universal rules from `.claude/guidance/shipped/moflo-guidance-rules.md`. For each `.md` file, check:
+
+- Has `**Purpose:**` line right after H1
+- Has `## See Also` at end
+- Under 500 lines
+- H2 headings are specific (not "Overview", "Configuration", "Examples")
+- No hedged language in rule contexts (`should`, `might`, `consider`)
+
+Do **not** duplicate `/guidance -a`'s logic verbatim — just produce a one-line summary per file (`<file>: <N issues>`). The Eldar surface gaps; `/guidance -a` does the deep audit.
+
+### 1h. Memory Health
+
+For each of the canonical namespaces, check entry count:
+
+```
+mcp__moflo__memory_stats — { namespace: "guidance" }
+mcp__moflo__memory_stats — { namespace: "patterns" }
+mcp__moflo__memory_stats — { namespace: "learnings" }
+```
+
+Flag empty `learnings` as `info` (project hasn't accumulated decisions yet — fine for new projects). Flag empty `guidance` as `warn` (no indexed guidance means semantic search is degraded).
+
+### 1i. Hooks & MCP Wiring
+
+Read `.claude/settings.json`. Check:
+
+| Check | Severity |
+|-------|----------|
+| Session-start hook references the moflo launcher | error if missing |
+| `mcpServers.moflo` is configured | error if missing |
+| `hooks` section exists with at least pre-task/post-task entries | warn if absent |
+
+If settings.json is malformed JSON, surface as `error`.
+
+### 1j. Settings Sanity
+
+Spot-check `.claude/settings.json` for:
+
+- `permissions` block exists (info if absent — every prompt becomes a confirmation)
+- `env` block has at least the moflo entries the launcher writes
+- `statusLine` is configured (info — quality-of-life, not blocking)
+
+### 1k. Spell Inventory
+
+```bash
+npx moflo spell list
+```
+
+Flag `info` if count is 0 (no spells registered — user may not know they exist).
+
+### 1l. Subagent Fleet
+
+```
+Glob — { pattern: ".claude/agents/**/*.md" }
+```
+
+Count the result. `info` if 0 (no project-specific subagents — user is relying entirely on built-ins).
+
+### 1m. Stack → Guidance Cross-Reference (highest leverage)
+
+Detect the project's stack from manifests:
+
+| Manifest | Detected stack |
+|----------|----------------|
+| `package.json` deps | Node — inspect for React, Next, Drizzle, Prisma, Express, NestJS, Vite, etc. |
+| `pyproject.toml` / `requirements.txt` | Python — Django, FastAPI, SQLAlchemy, etc. |
+| `Cargo.toml` | Rust — axum, tokio, sqlx, etc. |
+| `go.mod` | Go — gin, sqlc, gorm, etc. |
+| `Gemfile` | Ruby — Rails, Sidekiq, etc. |
+
+For each detected technology, check whether `.claude/guidance/` mentions it (Grep for the technology name across the directory). Each `(detected stack item, no guidance match)` pair becomes one `info` finding: "uses Drizzle ORM but no DB-conventions guidance — high-leverage gap".
+
+This is the **highest-impact finding** for new adopters. Lead with it in the recommendation.
+
+### 1n. Anti-Pattern from History (best-effort, optional)
+
+If recent transcripts/commits are accessible, scan them for repeated manual work that an existing spell or agent already covers (e.g., 5+ separate `git status`/`git diff`/run-tests sequences in a session that `/simplify` would have handled). Surface as `info`: "consider /simplify for review loops". If unavailable, skip silently — never block the audit on this.
+
+## Step 2 — Render the Report
+
+Output a single table grouped by category, sorted by severity (`error` → `warn` → `info`):
+
+```
+ELDAR AUDIT — <project name>
+─────────────────────────────
+
+Category               Finding                                    Severity
+─────────────────────────────────────────────────────────────────────────
+Setup health           Healer reports 0 errors, 1 warning         warn
+Index freshness        Guidance index empty                       warn
+CLAUDE.md              File missing                               error
+Guidance content       0 docs in .claude/guidance/                warn
+Memory health          guidance namespace empty                   warn
+Stack → guidance       Drizzle ORM in deps; no DB guidance        info
+Stack → guidance       React Native; no mobile guidance           info
+Hooks & MCP wiring     all wired                                  ok
+... (etc) ...
+```
+
+Then list the **top 3 ranked recommendations** in plain English, with rationale and citation:
+
+```
+TOP 3 RECOMMENDATIONS
+─────────────────────
+
+1. Add CLAUDE.md (error)
+   Without it, Claude has no project entry point. Use the Eldar's
+   stack-aware scaffold via `/eldar --fix`.
+
+2. Add Drizzle conventions guidance (info — high leverage)
+   You use Drizzle ORM but have no DB-conventions doc. This is the
+   single highest-leverage gap for getting Claude to write idiomatic
+   queries and migrations in your codebase.
+   See: .claude/guidance/shipped/moflo-guidance-rules.md
+
+3. Run `flo healer --fix` (warn)
+   One auto-fixable warning. Run via `/eldar --fix` and select Healer.
+```
+
+End the audit with a one-line prompt: "Run `/eldar --fix` to address these interactively."
+
+## Step 3 — Fix Mode (`--fix` flag only)
+
+After the report, present a numbered triage menu:
+
+```
+TRIAGE MENU
+───────────
+[1] Add CLAUDE.md
+[2] Add Drizzle conventions guidance
+[3] Run flo healer --fix (1 warning)
+[4] Add empty .claude/guidance/ docs to memory namespaces
+
+Choose: all, none, or comma-separated numbers (e.g., 1,3): _
+```
+
+Drive each chosen finding through its sub-flow. Confirm before any write.
+
+### 3a. CLAUDE.md scaffold
+
+Ask the user 2–4 targeted questions based on detected stack:
+
+1. "What does this project do? (1-2 sentences for Claude's context)"
+2. "Primary tech stack confirmed: <detected list>. Anything missing?"
+3. "Any conventions Claude should follow (testing approach, branch model, etc.)?"
+4. "Any high-blast-radius areas Claude should be careful with?"
+
+Compose a CLAUDE.md draft incorporating their answers + standard moflo memory-first rule. **Show the draft to the user before writing.** Never auto-fill opinionated content.
+
+### 3b. Stack → guidance authoring
+
+For each chosen stack-gap finding:
+
+- Hand off to `/guidance` skill for the heavy lifting — it already enforces the universal rules.
+- Brief the user on what gap will be filled: "drafting Drizzle conventions doc covering query patterns, migrations, schema files".
+- Ask 2–4 targeted questions about *their* conventions (not generic Drizzle tips — Claude should follow how *they* use it).
+- The `/guidance` skill produces the draft and walks the user through the rules check.
+
+### 3c. Healer fixes
+
+```bash
+npx moflo healer --fix
+```
+
+Pass through the output verbatim. If the Healer reports manual-only fixes, surface them as next steps.
+
+### 3d. Hook/MCP wiring repair
+
+Suggest:
+
+```bash
+npx moflo init --upgrade
+```
+
+This is the standard wiring repair path. If the user is wary of running init, surface the specific missing keys from `.claude/settings.json` and offer to write them directly.
+
+### 3e. Empty namespaces
+
+Suggest concrete first entries based on detected stack. Example: "Your project uses Drizzle. Want me to seed `learnings` with the most common Drizzle gotchas as a starting set? You'd review each before storage."
+
+If the user declines, that's fine — empty `learnings` is a valid state for a young project.
+
+### 3f. After each fix
+
+After each chosen fix completes, ask: "Continue to next finding? (y/n)". Don't run them all in a batch — every change is high-leverage and deserves the user's attention.
+
+## Step 4 — Wrap-Up
+
+After audit (or audit + chosen fixes), end with:
+
+- **Audit-only**: One sentence — what was found, what to do next.
+- **Fix mode**: One sentence per applied fix, plus a closing line on what remains.
+
+Never leave the user without a clear next step.
+
+## Important
+
+- **Memory-first is mandatory.** Step 0 runs the search; the gate blocks reads otherwise.
+- **Call the Healer, not the Doctor.** `npx moflo healer` (alias) — never `flo doctor` — for thematic consistency.
+- **No auto-write of opinionated content.** Every guidance doc, every CLAUDE.md draft, every namespace seed gets shown to the user first.
+- **Portable only.** This skill ships to consumers via `.claude/skills/**/*.md` in the package files array. Never assume moflo source paths or moflo-internal state.
+- **No kitchen sink.** The audit checklist is locked at the categories above. New checks require a specific portable benefit and an issue to discuss them.
+- **Read-only by default.** `/eldar` (no flag) never writes. Only `--fix` writes, and only with per-finding confirmation.
+- **Hand off to specialists.** `/guidance` for guidance authoring, `flo healer --fix` for setup repair, `flo init --upgrade` for wiring. The Eldar route, they don't reimplement.
+
+## See Also
+
+- `.claude/guidance/shipped/moflo-guidance-rules.md` — Universal guidance writing rules used by `/guidance` and surfaced in 1g
+- `.claude/skills/guidance/SKILL.md` — The skill `/eldar --fix` hands off to for guidance authoring
+- `.claude/guidance/shipped/moflo-core-guidance.md` — moflo CLI / hooks / memory reference; useful when explaining wiring findings
+- `.claude/guidance/shipped/moflo-claude-swarm-cohesion.md` — Subagent + task coordination reference cited in routing findings

package/.claude/skills/fl/phases.md

@@ -4,11 +4,27 @@ Phase-by-phase notes for the full `/flo <issue>` run. Phase 2 (Ticket) lives in
 
 ## Phase 1: Research (also `-r`)
 
-### 1.1 Fetch the issue
+### 1.1 Fetch the issue + history (cheap, before any file exploration)
+
+Run these BEFORE any `Glob` / `Grep` / `Read` of source files. The goal is to catch "this is already (partially) fixed" in two commands rather than 10K tokens of file scanning.
+
 ```bash
-gh issue view <issue-number> --json number,title,body,labels,state,assignees,comments,milestone
+# Issue + closing PRs (one call, one new field vs. before).
+gh issue view <issue-number> --json number,title,body,labels,state,assignees,comments,milestone,closedByPullRequestsReferences
+
+# Commits that reference the issue. Silently no-ops outside a git work tree —
+# consumers without git, fresh `npx moflo` shells, non-git VCS all skip cleanly.
+if git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+  git log --all --grep="\b<issue-number>\b\|#<issue-number>" --oneline -30 || true
+fi
 ```
 
+**Surface what you find and proceed — never pause to ask.** `/flo` is fire-and-forget; a prompt that blocks for 30 minutes waiting on a yes/no is a worse failure than re-doing already-shipped work. Specifically:
+
+- **Issue is CLOSED with non-empty `closedByPullRequestsReferences`** → read the closing PR body and merge commit as primary context. Treat the run as "look for any remaining work or follow-up" and continue. Do not stop.
+- **Commits reference the issue but it's still open** → those are partial fixes. Summarise them in one line (`partial fix already shipped: <sha> <subject>`), then `git show <sha>` if you need the diff, scope the implementation around what's still missing, and continue. Do not stop.
+- **No history found / scan skipped** → proceed silently to memory + code exploration as before.
+
 ### 1.2 Check ticket status
 Look for the `## Acceptance Criteria` heading in the body.
 - Present → ticket already enhanced; skip ahead to execute.

package/.claude/skills/simplify/SKILL.md

@@ -15,7 +15,30 @@ Treat the union of staged + unstaged + committed-since-base as the diff to revie
 
 Also note: was `/simplify` already run on this branch in this session? If yes, you're in a **validation pass** (Phase 2.5 below) — most of the heavy lifting is done.
 
-## Phase 2: Classify the diff
+## Phase 2: Classify the diff (deterministic — call the classifier)
+
+**Call the classifier first, follow its decision.** Do not eyeball the diff and pick a tier in prose — that's the failure mode that costs ~230K tokens per run on mechanical decompositions (issue #908). The classifier reads the same diff Claude would, applies the rules below, and returns a JSON dispatch decision:
+
+```bash
+node .claude/helpers/simplify-classify.cjs --base main
+```
+
+(In the moflo source repo, equivalent is `node bin/simplify-classify.cjs --base main`. The launcher syncs `bin/simplify-classify.cjs` → `.claude/helpers/simplify-classify.cjs` in consumer projects.)
+
+Output:
+```json
+{
+  "tier": "TRIVIAL" | "SMALL" | "NORMAL",
+  "model": "sonnet",
+  "agentCount": 0 | 1 | 3,
+  "reasoning": ["..."],
+  "stats": { "added": ..., "deleted": ..., "declAdded": ..., "declRemoved": ..., "netDecls": ..., "fileCount": ..., "securityHit": ... }
+}
+```
+
+If `bin/simplify-classify.cjs` is missing (older moflo install), fall back to the prose rules below — but on a current install the classifier IS the source of truth. Default behavior: **single Sonnet agent** unless the diff signals genuinely warrant escalation.
+
+Tier definitions the classifier encodes (for reference, not for re-derivation):
 
 Pick the **smallest tier** the diff genuinely fits. When in doubt, escalate one step (not two).
 
@@ -40,13 +63,14 @@ This is the default tier for **most real diffs**, including changes to critical
 
 Examples that qualify: extracting a constant, inlining a one-liner, swapping a `for` for a `forEach`, adding one early-return, refactoring a single function within a file, adding a cache fast-path inside an existing block.
 
-### NORMAL — three parallel agents
-Reserved for **genuinely cross-cutting** changes. ANY of these triggers NORMAL:
-- 3+ files changed
-- >200 net LOC changed
-- Adds/removes/renames a public API
-- Introduces or removes a dependency
-- Cross-cutting refactor (touches the same pattern in multiple modules)
+### NORMAL — three parallel agents (high bar)
+Reserved for **genuinely cross-cutting** changes that single-agent review can't cover. The classifier escalates to NORMAL only when ANY of:
+- `>500 LOC changed` (real volume, not just "more than 200")
+- `5+ files AND ≥3 net new declarations` (broad new surface, not relocation)
+- `security-sensitive path AND netDecls > 0` (aidefence/, swarm/consensus/, hooks gate, daemon-lock, launcher — only when adding logic, not on a 1-line touch)
+- `3+ new files AND ≥5 new declarations` (genuinely new subsystem)
+
+**Mechanical relocation is NOT NORMAL** even with many files / many lines. If `declAdded` and `declRemoved` are both ≥2 and `netDecls` is small (within 30% of total declarations touched), it's a structural move — SMALL, single agent. This is the #906/#908 case: ~330 LOC across 6 files of pure decomposition was costing 230K tokens via three-agent fan-out when it needed one Sonnet agent.
 
 Three agents exist to cover orthogonal axes (Reuse / Quality / Efficiency) when the change is broad enough that one agent's tool-call budget can't survey it all. For single-file edits, one focused agent always covers all three axes — three is duplication, not coverage.
 
@@ -62,48 +86,11 @@ Escalate one tier (self-review → SMALL agent) only if the fix introduced any o
 
 Do **not** escalate to NORMAL on a validation pass. If the fix is so structural that NORMAL is warranted, treat it as a fresh diff and start over from Phase 1.
 
-## Phase 2.7: Route the model (before any Agent spawn)
-
-For every tier that spawns an Agent (SMALL / NORMAL — TRIVIAL self-review skips this), call the moflo router to pick the cheapest model that fits the task **before** invoking Agent:
-
-```
-mcp__moflo__hooks_model-route — {
-  task: "<diff summary — see wording rules below>",
-  preferCost: true
-}
-```
+## Phase 2.7: Model selection
 
-### Wording the task description
-
-The router's complexity score is keyword-sensitive. Words like `refactor`, `architect`, `audit`, `system`, `redesign`, `migrate` flip a high-complexity flag and force opus *even when scoring suggests sonnet*. For `/simplify` you are **always doing code review**, never genuine architecture, so frame the task accordingly:
-
-- ✅ Good: `"Review 110-line single-file change in bin/session-start-launcher.mjs for reuse, quality, efficiency."`
-- ❌ Bad: `"Review refactor that adds mtime-cache fast-path and architects new caching layer."`
-
-Drop the trigger words. State LOC count, file count, and "review for reuse, quality, efficiency". That's enough signal.
-
-### Applying the result
-
-The router returns `{ model: 'haiku' | 'sonnet' | 'opus', complexity, reasoning, alternatives, ... }`.
-
-**Hard rule for `/simplify`: opus is never correct.** Code review does not require Opus-tier reasoning even on critical surface. If the router returns `opus`:
-
-1. Look at `alternatives` — if `sonnet` scores higher than the selected model's confidence, downgrade to sonnet.
-2. Otherwise, downgrade to sonnet anyway (treat opus as "router was uncertain — pick the safer middle").
-
-Pass the final model verbatim to the Agent's `model` parameter (Agent accepts `'haiku' | 'sonnet' | 'opus'`). On router failure (MCP call errors), default to `'sonnet'`.
-
-In practice: comment trims and pure formatting → haiku; everything else for `/simplify` → sonnet.
-
-### Feed back the outcome
-
-After the agent completes, record the outcome so the router learns:
-
-```
-mcp__moflo__hooks_model-outcome — { task: "<same wording as route call>", model: "<chosen>", outcome: "success" | "failure" | "escalated" }
-```
+**Use the model the classifier returned** — always `sonnet` for `/simplify`. Opus is never correct here; the classifier enforces this. No router call needed; the classifier IS the router for this skill.
 
-`escalated` = the agent missed something a higher-tier pass would have caught. That signal teaches the router to bias similar tasks upward next time. Don't fake `escalated` to retroactively justify opus — only record it when a *real* miss happened.
+If you fell back to prose rules in Phase 2 (no classifier available), use `sonnet` unconditionally. Pass the model verbatim to Agent's `model` parameter.
 
 ## Phase 3: Run the appropriate review
 

package/README.md

@@ -431,6 +431,18 @@ Inside your AI client, use the `/spell-builder` skill to create, edit, and valid
 /spell-builder                           # Start the spell builder
 ```
 
+### Other AI-client skills shipped with MoFlo
+
+Beyond `/flo`, `/spell-builder`, and `/eldar`, MoFlo ships a handful of focused slash-command skills that work in any consumer project once you `flo init`:
+
+| Skill | Purpose |
+|-------|---------|
+| `/guidance` | Author and audit guidance docs in `.claude/guidance/`. Default mode walks you through one doc; `/guidance -a` audits every doc against the universal guidance rules (Purpose lines, See Also, line counts, hedged language). |
+| `/simplify` | Adaptive code review on the current diff. Tier-based fan-out — trivial edits get a self-review, small diffs get one routed agent, cross-cutting refactors get three parallel agents. Routes through the moflo model router for cost-aware execution. |
+| `/spell-schedule` | Schedule a spell on the local moflo daemon (cron, interval, or one-time) without leaving the chat. For remote Anthropic-cloud agents on a schedule, use Claude Code's built-in `/schedule` instead. |
+
+Run any of them with no arguments to see full usage, or browse the source in `.claude/skills/` (each skill is a single `SKILL.md` file).
+
 ### Epics
 
 Epics are a specialized process for handling GitHub issues that contain multiple child stories. When you pass a GitHub issue to `/flo` and it's detected as an epic, MoFlo processes each child story sequentially through the full `/flo` process (research → implement → test → PR).
@@ -553,6 +565,19 @@ flo healer -c embeddings         # Check only embeddings health
 flo healer --verbose             # Verbose output
 ```
 
+#### `/eldar` — Consult the Eldar (project setup audit + wizard)
+
+Where the Healer checks your moflo install, `/eldar` audits how Claude is set up to *use* the project — guidance, CLAUDE.md, memory namespaces, hook/MCP wiring, model routing, and stack-aware guidance gaps — then walks you through fixing whichever findings you pick. Use it when starting in a new project, when Claude feels lost or inefficient, or as a periodic health check.
+
+```
+/eldar                           # Read-only audit; categorized report + top-3 ranked recommendation
+/eldar --fix                     # Audit, then interactive triage menu — pick which findings to address
+```
+
+The Eldar **consult** the Healer (they call `flo healer --json` as one of the audit checks) — they don't replace it. Categories audited include setup health, index freshness, version skew, model/token routing, CLAUDE.md size + reference integrity, guidance content + structure, memory health, hook/MCP wiring, settings sanity, spell + subagent inventory, **stack → guidance cross-reference** (detects tech from package.json/pyproject.toml/Cargo.toml/go.mod and flags every detected technology with no matching guidance doc — the highest-leverage finding for new adopters), and best-effort anti-pattern detection from history.
+
+In `--fix` mode, each chosen finding drives the appropriate sub-flow: Healer for setup repair, the `/guidance` skill for guidance authoring (wizard, never autogen), a stack-aware scaffold for missing CLAUDE.md, `flo init --upgrade` for hook/MCP wiring. Every write is confirmed before it lands.
+
 #### `flo diagnose` — Integration Tests
 
 While `healer` checks your environment, `diagnose` exercises every subsystem end-to-end: memory CRUD, embedding generation, semantic search, swarm lifecycle, hive-mind consensus, task management, hooks, config, neural patterns, and init idempotency. All test data is cleaned up after each test — nothing is left behind.

package/bin/gate.cjs

@@ -88,7 +88,11 @@ var TASK_RE = /\b(fix|bug|error|implement|add|create|build|write|refactor|debug|
 var TEST_RUNNER_RE = /(?:^|[^a-z])(?:npm|yarn|pnpm|bun)\s+(?:run\s+)?(?:test|t)(?:[:\s]|$)|\b(?:npx|pnpx)\s+(?:vitest|jest|mocha|ava|tap|jasmine|pytest)\b|(?:^|;|&&|\|\|)\s*(?:vitest|jest|pytest|mocha|jasmine|tap|ava)\s|\b(?:cargo|go|deno|dotnet|mvn)\s+test\b|\bgradle\w*\s+test\b/i;
 // Edits to these don't change runtime behaviour, so they don't invalidate prior test/simplify runs.
 // Lock files and .gitignore are tracked but inert; package.json/*.yaml ARE source — they reset.
-var EDIT_RESET_SKIP_RE = /\.(md|markdown|txt|rst|adoc|lock|gitignore)$|(?:^|[\\\/])(CHANGELOG(?:\.md)?|\.env\.example|package-lock\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lockb)$/i;
+var EDIT_RESET_SKIP_BOTH_RE = /\.(md|markdown|txt|rst|adoc|lock|gitignore)$|(?:^|[\\\/])(CHANGELOG(?:\.md)?|\.env\.example|package-lock\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lockb)$/i;
+// Test files: invalidate the testing gate (tests are stale once test code changes)
+// but NOT the simplify gate — /simplify already reviewed the production code; touching
+// a test file or fixture doesn't expose new untested surface for code review (#908).
+var EDIT_RESET_SKIP_SIMPLIFY_ONLY_RE = /(?:^|[\\\/])(__tests__|__mocks__|tests?|spec|specs|cypress|e2e|fixtures?)[\\\/]|\.(test|spec)\.[mc]?[jt]sx?$|\.fixture\.[mc]?[jt]sx?$/i;
 
 switch (command) {
   case 'check-before-agent': {
@@ -180,11 +184,20 @@ switch (command) {
   }
   case 'reset-edit-gates': {
     var fp = process.env.TOOL_INPUT_file_path || '';
-    if (fp && EDIT_RESET_SKIP_RE.test(fp)) break;
+    // Inert files (markdown, lockfiles, CHANGELOG, .env.example): no gate reset.
+    if (fp && EDIT_RESET_SKIP_BOTH_RE.test(fp)) break;
     var s = readState();
-    if (!s.testsRun && !s.simplifyRun) break;
-    s.testsRun = false;
-    s.simplifyRun = false;
+    // Test-only edits invalidate testsRun but preserve simplifyRun (#908).
+    var isTestOnly = fp && EDIT_RESET_SKIP_SIMPLIFY_ONLY_RE.test(fp);
+    var resetTests = s.testsRun;
+    var resetSimplify = s.simplifyRun && !isTestOnly;
+    if (!resetTests && !resetSimplify) break;
+    var gates = [];
+    if (resetTests) { s.testsRun = false; gates.push('tests'); }
+    if (resetSimplify) { s.simplifyRun = false; gates.push('simplify'); }
+    if (fp) {
+      s.lastResetBy = { file: fp, at: new Date().toISOString(), gates: gates };
+    }
     writeState(s);
     break;
   }
@@ -205,6 +218,9 @@ switch (command) {
     for (var i = 0; i < missing.length; i++) {
       process.stderr.write('  - ' + missing[i] + '\n');
     }
+    if (s.lastResetBy && s.lastResetBy.file) {
+      process.stderr.write('Last gate reset: ' + s.lastResetBy.file + ' (' + (s.lastResetBy.gates || []).join(', ') + ')\n');
+    }
     process.stderr.write('Disable per-gate via moflo.yaml:\n');
     process.stderr.write('  gates:\n    testing_gate: false\n    simplify_gate: false\n    learnings_gate: false\n');
     process.exit(2);

package/bin/hooks.mjs

@@ -22,7 +22,7 @@
 import { spawn } from 'child_process';
 import { existsSync, appendFileSync, readFileSync, writeFileSync, mkdirSync, statSync } from 'fs';
 import { resolve, dirname } from 'path';
-import { fileURLToPath } from 'url';
+import { fileURLToPath, pathToFileURL } from 'url';
 import { createProcessManager } from './lib/process-manager.mjs';
 import { shouldDaemonAutoStart } from './lib/daemon-config.mjs';
 import { resolveMofloBin } from './lib/resolve-bin.mjs';
@@ -520,7 +520,7 @@ let _getDaemonLockHolder = null;
 try {
   const daemonLockPath = resolve(__dirname, '..', 'src', '@claude-flow', 'cli', 'dist', 'src', 'services', 'daemon-lock.js');
   if (existsSync(daemonLockPath)) {
-    const mod = await import('file://' + daemonLockPath.replace(/\\/g, '/'));
+    const mod = await import(pathToFileURL(daemonLockPath).href);
     _getDaemonLockHolder = mod.getDaemonLockHolder;
   }
 } catch { /* fallback below */ }

package/bin/index-guidance.mjs

@@ -28,6 +28,7 @@ import { fileURLToPath } from 'url';
 import { mofloResolveURL } from './lib/moflo-resolve.mjs';
 import { memoryDbPath } from './lib/moflo-paths.mjs';
 import { resolveMofloBin } from './lib/resolve-bin.mjs';
+import { createProcessManager } from './lib/process-manager.mjs';
 const initSqlJs = (await import(mofloResolveURL('sql.js'))).default;
 
 
@@ -872,36 +873,25 @@ if (!skipEmbeddings && needsEmbeddings) {
   console.log('');
   log('Spawning embedding generation in background...');
 
-  const { spawn } = await import('child_process');
-
   const embeddingScript = resolveMofloBin(
     projectRoot, 'flo-embeddings', 'build-embeddings.mjs', { includeDevFallback: true },
   );
 
   if (embeddingScript) {
-    const embeddingArgs = ['--namespace', NAMESPACE];
-
-    // Create log file for background process output
-    const logDir = resolve(projectRoot, '.moflo/logs');
-    if (!existsSync(logDir)) {
-      mkdirSync(logDir, { recursive: true });
+    // Register the spawn with the shared ProcessManager (#886). Stdout/stderr
+    // route through `.swarm/background.log` (pm.spawn default) instead of the
+    // bespoke `.moflo/logs/embeddings.log` so the registry, dedup, and
+    // session-end drain stay consistent with every other tracked spawn.
+    const pm = createProcessManager(projectRoot);
+    const result = pm.spawn('node', [embeddingScript, '--namespace', NAMESPACE], `build-embeddings-${NAMESPACE}`);
+    if (result.skipped) {
+      log(`Background embedding already running (PID: ${result.pid})`);
+    } else if (result.pid) {
+      log(`Background embedding started (PID: ${result.pid})`);
+      log(`Log file: .swarm/background.log`);
+    } else {
+      log('⚠️  Failed to spawn background embedding');
     }
-    const logFile = resolve(logDir, 'embeddings.log');
-    const { openSync } = await import('fs');
-    const out = openSync(logFile, 'a');
-    const err = openSync(logFile, 'a');
-
-    // Spawn in background - don't wait for completion
-    const proc = spawn('node', [embeddingScript, ...embeddingArgs], {
-      stdio: ['ignore', out, err],
-      cwd: projectRoot,
-      detached: true,
-      windowsHide: true  // Suppress command windows on Windows
-    });
-    proc.unref();  // Allow parent to exit independently
-
-    log(`Background embedding started (PID: ${proc.pid})`);
-    log(`Log file: .moflo/logs/embeddings.log`);
   } else {
     log('⚠️  Embedding script not found, skipping embedding generation');
   }