monomind 2.7.11 → 2.7.13

package/packages/@monomind/cli/.claude/skills/mastermind-workspaces/SKILL.md

@@ -1,261 +0,0 @@
----
-name: mastermind-workspaces
-description: Mastermind workspaces — manage isolated git worktree workspaces per project. List, attach, detach, stop, and prune workspaces. Grouped by project with running service counts and agent assignments.
-type: domain-skill
-default_mode: confirm
----
-
-# Mastermind Workspaces
-
-This skill is invoked by `mastermind:workspaces` or directly via `/mastermind:workspaces`.
-
----
-
-## Inputs
-
-- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
-- `org_name`: org to manage workspaces for (required)
-- `action`: list | status | attach | detach | stop | prune
-- `workspace_id`: workspace id (required for status/detach/stop)
-- `project_id`: project to filter by (optional for list)
-- `agent_id`: agent to assign to workspace (required for attach)
-- `worktree_path`: filesystem path of the worktree (required for attach)
-- `caller`: command | master
-
----
-
-## Workspace Model
-
-A workspace is a git worktree assigned to a project, optionally running services and assigned to an agent.
-
-```json
-{
-  "id": "ws-abc123",
-  "project_id": "project-slug",
-  "agent_id": "backend-dev",
-  "worktree_path": "/tmp/monomind/worktrees/project-slug-abc123",
-  "branch": "feat/my-feature",
-  "status": "active",
-  "services": ["dev-server", "db-watcher"],
-  "createdAt": "2026-01-01T00:00:00Z",
-  "lastActiveAt": "2026-01-02T00:00:00Z"
-}
-```
-
----
-
-## Step 0 — Brain Load (standalone only)
-
-If `caller` is not "command", load brain context following mastermind-protocol/SKILL.md Brain Load Procedure with namespace: `ops`.
-
----
-
-## Step 1 — Load Workspace Data
-
-```bash
-orgFile=".monomind/orgs/${org_name}.json"
-[ ! -f "$orgFile" ] && { echo "ERROR: Org '${org_name}' not found."; exit 1; }
-
-wsFile=".monomind/orgs/${org_name}-workspaces.json"
-[ ! -f "$wsFile" ] && echo '{"workspaces":[]}' > "$wsFile"
-
-projectsFile=".monomind/orgs/${org_name}-projects.json"
-worktreeRegistry=".monomind/orgs/${org_name}-worktrees.json"
-```
-
----
-
-## Step 2 — Execute Action
-
-### list (default)
-
-```bash
-echo "WORKSPACES — org: $org_name"
-[ -n "$project_id" ] && echo "(filtered by project: $project_id)"
-echo "────────────────────────────────────────────────────────"
-
-total=$(jq '.workspaces | length' "$wsFile")
-
-if [ "$total" -eq 0 ]; then
-  echo "  No workspaces. Use --action attach to register one."
-else
-  # Group by project
-  projects=$(jq -r --arg pid "${project_id:-}" '
-    .workspaces |
-    if $pid != "" then map(select(.project_id == $pid)) else . end |
-    [.[].project_id] | unique[]
-  ' "$wsFile")
-
-  while IFS= read -r proj; do
-    [ -z "$proj" ] && continue
-    projName=$([ -f "$projectsFile" ] && jq -r --arg pid "$proj" '(.projects // [])[] | select(.id == $pid) | .name // $pid' "$projectsFile" || echo "$proj")
-    echo ""
-    echo "  PROJECT: $projName"
-    echo "  ──────────────────────────────────────────────────"
-    printf "  %-18s %-14s %-18s %-12s %-6s %s\n" "ID" "STATUS" "AGENT" "BRANCH" "SVCS" "PATH"
-
-    jq -r --arg pid "$proj" '(.workspaces // [])[] | select(.project_id == $pid) |
-      [.id, (.status // "unknown"), (.agent_id // "(none)"),
-       (.branch // "?"), ((.services // []) | length | tostring),
-       (.worktree_path // "-")]
-      | @tsv' "$wsFile" | while IFS=$'\t' read -r id st ag br svc path; do
-      printf "  %-18s %-14s %-18s %-12s %-6s %s\n" "$id" "$st" "$ag" "$br" "$svc" "$path"
-    done
-  done <<< "$projects"
-fi
-
-echo ""
-echo "Total: $total workspace(s)"
-```
-
-### status
-
-```bash
-[ -z "$workspace_id" ] && { echo "ERROR: --workspace-id required."; exit 1; }
-wsDef=$(jq -r --arg id "$workspace_id" '(.workspaces // [])[] | select(.id == $id)' "$wsFile")
-[ -z "$wsDef" ] && { echo "ERROR: Workspace '$workspace_id' not found."; exit 1; }
-
-echo "WORKSPACE STATUS — $workspace_id"
-echo "────────────────────────────────────────────────────────"
-echo "$wsDef" | jq -r '
-  "  ID:           \(.id)",
-  "  Project:      \(.project_id // "-")",
-  "  Agent:        \(.agent_id // "(unassigned)")",
-  "  Branch:       \(.branch // "?")",
-  "  Status:       \(.status // "unknown")",
-  "  Created:      \(.createdAt // "-")",
-  "  Last active:  \(.lastActiveAt // "-")",
-  "  Path:         \(.worktree_path // "-")"
-'
-
-# Check if worktree path exists
-path=$(echo "$wsDef" | jq -r '.worktree_path // ""')
-if [ -n "$path" ]; then
-  if [ -d "$path" ]; then
-    echo ""
-    echo "  Worktree: EXISTS at $path"
-    branch=$(git -C "$path" rev-parse --abbrev-ref HEAD 2>/dev/null || echo "?")
-    echo "  Git branch: $branch"
-    dirty=$(git -C "$path" status --porcelain 2>/dev/null | wc -l | tr -d ' ')
-    [ "$dirty" -gt 0 ] && echo "  Uncommitted changes: $dirty file(s)"
-  else
-    echo "  WARNING: Worktree path does not exist: $path"
-  fi
-fi
-
-echo ""
-echo "Services:"
-echo "$wsDef" | jq -r '(.services // [])[] | "  · \(.)"' || echo "  (none)"
-```
-
-### attach
-
-```bash
-[ -z "$project_id" ] && { echo "ERROR: --project-id required."; exit 1; }
-[ -z "$worktree_path" ] && { echo "ERROR: --worktree-path required."; exit 1; }
-
-[ ! -d "$worktree_path" ] && { echo "ERROR: Path does not exist: $worktree_path"; exit 1; }
-
-wsId="ws-$(openssl rand -hex 4 2>/dev/null || python3 -c 'import secrets; print(secrets.token_hex(4))')"
-branch=$(git -C "$worktree_path" rev-parse --abbrev-ref HEAD 2>/dev/null || echo "unknown")
-ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-
-tmp="${wsFile}.tmp"
-jq --arg id "$wsId" \
-   --arg pid "$project_id" \
-   --arg ag "${agent_id:-}" \
-   --arg path "$worktree_path" \
-   --arg branch "$branch" \
-   --arg ts "$ts" \
-  '.workspaces += [{"id":$id,"project_id":$pid,
-    "agent_id":(if $ag != "" then $ag else null end),
-    "worktree_path":$path,"branch":$branch,
-    "status":"active","services":[],"createdAt":$ts,"lastActiveAt":$ts}]' \
-  "$wsFile" > "$tmp" && mv "$tmp" "$wsFile"
-
-echo "Workspace attached: $wsId"
-echo "  Project:  $project_id"
-echo "  Agent:    ${agent_id:-(unassigned)}"
-echo "  Branch:   $branch"
-echo "  Path:     $worktree_path"
-```
-
-### detach
-
-```bash
-[ -z "$workspace_id" ] && { echo "ERROR: --workspace-id required."; exit 1; }
-tmp="${wsFile}.tmp"
-jq --arg id "$workspace_id" \
-  '.workspaces = [(.workspaces // [])[] | if .id == $id then .status = "detached" else . end]' \
-  "$wsFile" > "$tmp" && mv "$tmp" "$wsFile"
-echo "Workspace '$workspace_id' → detached. The worktree is preserved on disk."
-```
-
-### stop
-
-```bash
-[ -z "$workspace_id" ] && { echo "ERROR: --workspace-id required."; exit 1; }
-wsDef=$(jq -r --arg id "$workspace_id" '(.workspaces // [])[] | select(.id == $id)' "$wsFile")
-[ -z "$wsDef" ] && { echo "ERROR: Workspace '$workspace_id' not found."; exit 1; }
-
-services=$(echo "$wsDef" | jq -r '(.services // [])[]')
-if [ -n "$services" ]; then
-  echo "Stopping services for workspace $workspace_id…"
-  while IFS= read -r svc; do
-    echo "  Stopping: $svc"
-  done <<< "$services"
-fi
-
-tmp="${wsFile}.tmp"
-jq --arg id "$workspace_id" --arg ts "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
-  '.workspaces = [(.workspaces // [])[] | if .id == $id then .status = "stopped" | .services = [] | .lastActiveAt = $ts else . end]' \
-  "$wsFile" > "$tmp" && mv "$tmp" "$wsFile"
-
-echo "Workspace '$workspace_id' stopped."
-```
-
-### prune
-
-```bash
-echo "Pruning stopped/detached workspaces for org '$org_name'…"
-
-before=$(jq '.workspaces | length' "$wsFile")
-removed=0
-orphaned=0
-
-tmp="${wsFile}.tmp"
-jq '.workspaces = [(.workspaces // [])[] | select(.status != "stopped" and .status != "detached")]' \
-  "$wsFile" > "$tmp" && mv "$tmp" "$wsFile"
-
-after=$(jq '.workspaces | length' "$wsFile")
-removed=$((before - after))
-
-# Find orphaned worktrees (path gone)
-while IFS= read -r path; do
-  { [ -z "$path" ] || [ "$path" = "null" ]; } && continue
-  [ ! -d "$path" ] && orphaned=$((orphaned + 1))
-done < <(jq -r '(.workspaces // [])[].worktree_path // ""' "$wsFile")
-
-echo "  Removed $removed stopped/detached workspace record(s)."
-[ "$orphaned" -gt 0 ] && echo "  WARNING: $orphaned workspace(s) have missing worktree paths. Run --action status to investigate."
-echo "Done. Active workspaces: $(jq '.workspaces | length' "$wsFile")"
-```
-
----
-
-## Step 3 — Return Output
-
-```yaml
-domain: ops
-status: complete
-action: <action>
-org: <org_name>
-workspace_id: <id if applicable>
-workspaces_total: <N>
-```
-
----
-
-## Step 4 — Brain Write (standalone only)
-
-If `caller` is not "command", follow mastermind-protocol/SKILL.md Brain Write Procedure for domain `ops`.

package/packages/@monomind/cli/.claude/skills/mastermind-worktree/SKILL.md

@@ -1,215 +0,0 @@
----
-name: mastermind-worktree
-description: Use when starting feature work that needs isolation from the current workspace or before executing implementation plans — ensures an isolated workspace exists via native tools or git worktree fallback
----
-
-# Using Git Worktrees
-
-## Overview
-
-Ensure work happens in an isolated workspace. Prefer the platform's native worktree tools. Fall back to manual git worktrees only when no native tool is available.
-
-**Core principle:** Detect existing isolation first. Then use native tools. Then fall back to git. Never fight the harness.
-
-**Announce at start:** "I'm using the mastermind:worktree skill to set up an isolated workspace."
-
-## Step 0: Detect Existing Isolation
-
-**Before creating anything, check if you are already in an isolated workspace.**
-
-```bash
-GIT_DIR=$(cd "$(git rev-parse --git-dir)" 2>/dev/null && pwd -P)
-GIT_COMMON=$(cd "$(git rev-parse --git-common-dir)" 2>/dev/null && pwd -P)
-BRANCH=$(git branch --show-current)
-```
-
-**Submodule guard:** `GIT_DIR != GIT_COMMON` is also true inside git submodules. Before concluding "already in a worktree," verify you are not in a submodule:
-
-```bash
-# If this returns a path, you're in a submodule, not a worktree — treat as normal repo
-git rev-parse --show-superproject-working-tree 2>/dev/null
-```
-
-**If `GIT_DIR != GIT_COMMON` (and not a submodule):** You are already in a linked worktree. Skip to Step 3 (Project Setup). Do NOT create another worktree.
-
-Report with branch state:
-- On a branch: "Already in isolated workspace at `<path>` on branch `<name>`."
-- Detached HEAD: "Already in isolated workspace at `<path>` (detached HEAD, externally managed). Branch creation needed at finish time."
-
-**If `GIT_DIR == GIT_COMMON` (or in a submodule):** You are in a normal repo checkout.
-
-Has the user already indicated their worktree preference? If not, ask for consent before creating a worktree:
-
-> "Would you like me to set up an isolated worktree? It protects your current branch from changes."
-
-Honor any existing declared preference without asking. If the user declines consent, work in place and skip to Step 3.
-
-## Step 1: Create Isolated Workspace
-
-**You have two mechanisms. Try them in this order.**
-
-### 1a. Native Worktree Tools (preferred)
-
-The user has asked for an isolated workspace (Step 0 consent). Is there a native tool to create a worktree? It might be a tool with a name like `EnterWorktree`, `WorktreeCreate`, a `/worktree` command, or a `--worktree` flag. If so, use it and skip to Step 3.
-
-Native tools handle directory placement, branch creation, and cleanup automatically. Using `git worktree add` when you have a native tool creates phantom state the harness can't see or manage.
-
-Only proceed to Step 1b if no native worktree tool is available.
-
-### 1b. Git Worktree Fallback
-
-**Only use this if Step 1a does not apply** — no native worktree tool is available. Create a worktree manually using git.
-
-#### Directory Selection
-
-Follow this priority order. Explicit user preference always beats observed filesystem state.
-
-1. **Check your instructions for a declared worktree directory preference.** If the user has already specified one, use it without asking.
-
-2. **Check for an existing project-local worktree directory:**
-   ```bash
-   ls -d .worktrees 2>/dev/null     # Preferred (hidden)
-   ls -d worktrees 2>/dev/null      # Alternative
-   ```
-   If found, use it. If both exist, `.worktrees` wins.
-
-3. **Check for an existing global directory:**
-   ```bash
-   project=$(basename "$(git rev-parse --show-toplevel)")
-   ls -d ~/.config/monomind/worktrees/$project 2>/dev/null
-   ```
-   If found, use it (backward compatibility with legacy global path).
-
-4. **If there is no other guidance available**, default to `.worktrees/` at the project root.
-
-#### Safety Verification (project-local directories only)
-
-**MUST verify directory is ignored before creating worktree:**
-
-```bash
-git check-ignore -q .worktrees 2>/dev/null || git check-ignore -q worktrees 2>/dev/null
-```
-
-**If NOT ignored:** Add to .gitignore, commit the change, then proceed.
-
-**Why critical:** Prevents accidentally committing worktree contents to repository.
-
-Global directories (`~/.config/monomind/worktrees/`) need no verification.
-
-#### Create the Worktree
-
-```bash
-project=$(basename "$(git rev-parse --show-toplevel)")
-
-# Determine path based on chosen location
-# For project-local: path="$LOCATION/$BRANCH_NAME"
-# For global: path="~/.config/monomind/worktrees/$project/$BRANCH_NAME"
-
-git worktree add "$path" -b "$BRANCH_NAME"
-cd "$path"
-```
-
-**Sandbox fallback:** If `git worktree add` fails with a permission error (sandbox denial), tell the user the sandbox blocked worktree creation and you're working in the current directory instead. Then run setup and baseline tests in place.
-
-## Step 3: Project Setup
-
-Auto-detect and run appropriate setup:
-
-```bash
-# Node.js
-if [ -f package.json ]; then npm install; fi
-
-# Rust
-if [ -f Cargo.toml ]; then cargo build; fi
-
-# Python
-if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
-if [ -f pyproject.toml ]; then poetry install; fi
-
-# Go
-if [ -f go.mod ]; then go mod download; fi
-```
-
-## Step 4: Verify Clean Baseline
-
-Run tests to ensure workspace starts clean:
-
-```bash
-# Use project-appropriate command
-npm test / cargo test / pytest / go test ./...
-```
-
-**If tests fail:** Report failures, ask whether to proceed or investigate.
-
-**If tests pass:** Report ready.
-
-### Report
-
-```
-Worktree ready at <full-path>
-Tests passing (<N> tests, 0 failures)
-Ready to implement <feature-name>
-```
-
-## Quick Reference
-
-| Situation | Action |
-|-----------|--------|
-| Already in linked worktree | Skip creation (Step 0) |
-| In a submodule | Treat as normal repo (Step 0 guard) |
-| Native worktree tool available | Use it (Step 1a) |
-| No native tool | Git worktree fallback (Step 1b) |
-| `.worktrees/` exists | Use it (verify ignored) |
-| `worktrees/` exists | Use it (verify ignored) |
-| Both exist | Use `.worktrees/` |
-| Neither exists | Check instruction file, then default `.worktrees/` |
-| Global path exists | Use it (backward compat) |
-| Directory not ignored | Add to .gitignore + commit |
-| Permission error on create | Sandbox fallback, work in place |
-| Tests fail during baseline | Report failures + ask |
-| No package.json/Cargo.toml | Skip dependency install |
-
-## Common Mistakes
-
-### Fighting the harness
-
-- **Problem:** Using `git worktree add` when the platform already provides isolation
-- **Fix:** Step 0 detects existing isolation. Step 1a defers to native tools.
-
-### Skipping detection
-
-- **Problem:** Creating a nested worktree inside an existing one
-- **Fix:** Always run Step 0 before creating anything
-
-### Skipping ignore verification
-
-- **Problem:** Worktree contents get tracked, pollute git status
-- **Fix:** Always use `git check-ignore` before creating project-local worktree
-
-### Assuming directory location
-
-- **Problem:** Creates inconsistency, violates project conventions
-- **Fix:** Follow priority: existing > global legacy > instruction file > default
-
-### Proceeding with failing tests
-
-- **Problem:** Can't distinguish new bugs from pre-existing issues
-- **Fix:** Report failures, get explicit permission to proceed
-
-## Red Flags
-
-**Never:**
-- Create a worktree when Step 0 detects existing isolation
-- Use `git worktree add` when you have a native worktree tool (e.g., `EnterWorktree`). This is the #1 mistake — if you have it, use it.
-- Skip Step 1a by jumping straight to Step 1b's git commands
-- Create worktree without verifying it's ignored (project-local)
-- Skip baseline test verification
-- Proceed with failing tests without asking
-
-**Always:**
-- Run Step 0 detection first
-- Prefer native tools over git fallback
-- Follow directory priority: existing > global legacy > instruction file > default
-- Verify directory is ignored for project-local
-- Auto-detect and run project setup
-- Verify clean test baseline

package/packages/@monomind/cli/.claude/skills/monolean/SKILL.md

@@ -1,118 +0,0 @@
----
-name: monolean
-description: >
-  Forces the laziest solution that actually works, simplest, shortest, most
-  minimal. Channels a senior dev who has seen everything: question whether the
-  task needs to exist at all (YAGNI), reach for the standard library before
-  custom code, native platform features before dependencies, one line before
-  fifty. Supports intensity levels: lite, full (default), ultra. Use whenever
-  the user says "monolean", "be lean", "lean mode", "simplest solution",
-  "minimal solution", "yagni", "do less", or "shortest path", and whenever
-  they complain about over-engineering, bloat, boilerplate, or unnecessary
-  dependencies.
-argument-hint: "[lite|full|ultra]"
-license: MIT
----
-
-# Monolean
-
-You are a lazy senior developer. Lazy means efficient, not careless. You have
-seen every over-engineered codebase and been paged at 3am for one. The best
-code is the code never written.
-
-## Persistence
-
-ACTIVE EVERY RESPONSE. No drift back to over-building. Still active if
-unsure. Off only: "stop monolean" / "normal mode". Default: **full**.
-Switch: `/monolean lite|full|ultra`.
-
-## The ladder
-
-Stop at the first rung that holds:
-
-1. **Does this need to exist at all?** Speculative need = skip it, say so in one line. (YAGNI)
-2. **Already in this codebase?** A helper, util, type, or pattern that already lives here → reuse it. Look before you write; re-implementing what's a few files over is the most common slop.
-3. **Stdlib does it?** Use it.
-4. **Native platform feature covers it?** `<input type="date">` over a picker lib, CSS over JS, DB constraint over app code.
-5. **Already-installed dependency solves it?** Use it. Never add a new one for what a few lines can do.
-6. **Can it be one line?** One line.
-7. **Only then:** the minimum code that works.
-
-The ladder is a reflex, not a research project — but it runs *after* you
-understand the problem, not instead of it. Read the task and the code it
-touches first, trace the real flow end to end, then climb. Two rungs work →
-take the higher one and move on. The first lazy solution that works is the
-right one — once you actually know what the change has to touch.
-
-**Bug fix = root cause, not symptom.** A report names a symptom. Before you
-edit, find every caller of the function you're about to touch (use `monograph_neighbors` or `monograph_impact` first; fall back to grep only if monograph returns 0 results). The lazy fix IS
-the root-cause fix: one guard in the shared function is a smaller diff than a
-guard in every caller — and patching only the path the ticket names leaves
-every sibling caller still broken. Fix it once, where all callers route through.
-
-In monomind projects: rung 2 is assisted by the knowledge graph (run monograph_query for the symbol you think already exists before writing); rung 5 is assisted by monograph_query with the package name to confirm it is imported somewhere.
-
-## Rules
-
-- No unrequested abstractions: no interface with one implementation, no factory for one product, no config for a value that never changes.
-- No boilerplate, no scaffolding "for later", later can scaffold for itself.
-- Deletion over addition. Boring over clever, clever is what someone decodes at 3am.
-- Fewest files possible. Shortest working diff wins — but only once you understand the problem. The smallest change in the wrong place isn't lazy, it's a second bug.
-- Complex request? Ship the lazy version and question it in the same response, "Did X; Y covers it. Need full X? Say so." Never stall on an answer you can default.
-- Two stdlib options, same size? Take the one that's correct on edge cases. Lazy means writing less code, not picking the flimsier algorithm.
-- Mark deliberate simplifications with a `monolean:` comment (`// monolean: this exists`), simple reads as intent, not ignorance. Shortcut with a known ceiling (global lock, O(n²) scan, naive heuristic)? The comment names the ceiling and the upgrade path: `# monolean: global lock, per-account locks if throughput matters`.
-
-## Output
-
-Code first. Then at most three short lines: what was skipped, when to add it.
-No essays, no feature tours, no design notes. If the explanation is longer
-than the code, delete the explanation, every paragraph defending a
-simplification is complexity smuggled back in as prose. Explanation the user
-explicitly asked for (a report, a walkthrough, per-phase notes) is not debt,
-give it in full, the rule is only against unrequested prose.
-
-Pattern: `[code] → skipped: [X], add when [Y].`
-
-## Intensity
-
-| Level | What change |
-|-------|------------|
-| **lite** | Build what's asked, but name the lazier alternative in one line. User picks. |
-| **full** | The ladder enforced. Stdlib and native first. Shortest diff, shortest explanation. Default. |
-| **ultra** | YAGNI extremist. Deletion before addition. Ship the one-liner and challenge the rest of the requirement in the same breath. |
-
-Example: "Add a cache for these API responses."
-- lite: "Done, cache added. FYI: `functools.lru_cache` covers this in one line if you'd rather not own a cache class."
-- full: "`@lru_cache(maxsize=1000)` on the fetch function. Skipped custom cache class, add when lru_cache measurably falls short."
-- ultra: "No cache until a profiler says so. When it does: `@lru_cache`. A hand-rolled TTL cache class is a bug farm with a hit rate."
-
-## When NOT to be lazy
-
-Never simplify away: input validation at trust boundaries, error handling
-that prevents data loss, security measures, accessibility basics, anything
-explicitly requested. User insists on the full version → build it, no
-re-arguing.
-
-Never lazy about understanding the problem. The ladder shortens the
-solution, never the reading. Trace the whole thing first — every file the
-change touches, the actual flow — before picking a rung. Laziness that skips
-comprehension to ship a small diff is the dangerous kind: it dresses up as
-efficiency and ships a confident wrong fix. Read fully, then be lean.
-
-Hardware is never the ideal on paper: a real clock drifts, a real sensor
-reads off, a PCA9685 runs a few percent fast. Leave the calibration knob, not
-just less code, the physical world needs tuning a minimal model can't see.
-
-Lean code without its check is unfinished. Non-trivial logic (a branch, a
-loop, a parser, a money/security path) leaves ONE runnable check behind, the
-smallest thing that fails if the logic breaks: an `assert`-based
-`demo()`/`__main__` self-check or one small `test_*.py`. No frameworks, no
-fixtures, no per-function suites unless asked. Trivial one-liners need no
-test, YAGNI applies to tests too.
-
-## Boundaries
-
-Monolean governs what you build, not how you talk. "stop monolean" / "normal mode": revert. Level persists until
-changed or session end.
-
-The shortest path to done is the right path.

package/packages/@monomind/cli/.claude/skills/monolean-audit/SKILL.md

@@ -1,41 +0,0 @@
----
-name: monolean-audit
-description: >
-  Whole-repo audit for over-engineering. Like monolean-review, but scans the
-  entire codebase instead of a diff: a ranked list of what to delete, simplify,
-  or replace with stdlib/native equivalents. Use when the user says "audit this
-  codebase", "audit for over-engineering", "what can I delete from this repo",
-  "find bloat", "monolean-audit", or "/monolean-audit". One-shot report, does
-  not apply fixes.
----
-
-monolean-review, repo-wide. Scan the whole tree instead of a diff. Rank
-findings biggest cut first.
-
-## Tags
-
-Same as monolean-review:
-
-- `delete:` dead code, unused flexibility, speculative feature. Replacement: nothing.
-- `stdlib:` hand-rolled thing the standard library ships. Name the function.
-- `native:` dependency or code doing what the platform already does. Name the feature.
-- `yagni:` abstraction with one implementation, config nobody sets, layer with one caller.
-- `shrink:` same logic, fewer lines. Show the shorter form.
-
-## Hunt
-
-Deps the stdlib or platform already ships, single-implementation interfaces,
-factories with one product, wrappers that only delegate, files exporting one
-thing, dead flags and config, hand-rolled stdlib.
-
-## Output
-
-One line per finding, ranked: `<tag> <what to cut>. <replacement>. [path]`.
-End with `net: -<N> lines, -<M> deps possible.` Nothing to cut: `Lean already. Ship.`
-
-## Boundaries
-
-Scope: over-engineering and complexity only. Correctness bugs, security holes,
-and performance are explicitly out of scope. Route them to a normal review
-pass. Lists findings, applies nothing. One-shot.
-"stop monolean-audit" or "normal mode" to revert.

package/packages/@monomind/cli/.claude/skills/monolean-debt/SKILL.md

@@ -1,46 +0,0 @@
----
-name: monolean-debt
-description: >
-  Harvest every `monolean:` comment in the codebase into a debt ledger, so the
-  deliberate shortcuts and deferrals monolean leaves behind get tracked instead
-  of rotting into "later means never". Use when the user says "monolean debt",
-  "/monolean-debt", "what did monolean defer", "list the shortcuts", "monolean
-  ledger", or "what did we mark to do later". One-shot report, changes nothing.
----
-
-Every deliberate monolean shortcut is marked with a `monolean:` comment naming
-its ceiling and upgrade path. This collects them into one ledger so a deferral
-can't quietly become permanent.
-
-## Scan
-
-Grep the repo for comment markers, skipping `node_modules`, `.git`, and build
-output:
-
-`grep -rnE '(#|//) ?monolean:' .`  (add other comment prefixes if your stack uses them)
-
-Each hit is one ledger row. The comment prefix keeps prose that merely mentions
-the convention out of the ledger.
-
-## Output
-
-One row per marker, grouped by file:
-
-`<file>:<line>, <what was simplified>. ceiling: <the limit named>. upgrade: <the trigger to revisit>.`
-
-The convention is `monolean: <ceiling>, <upgrade path>`, so pull the ceiling
-and the trigger straight from the comment. Want an owner per row too? add
-`git blame -L<line>,<line>`.
-
-Flag the rot risk: any `monolean:` comment that names no upgrade path or
-trigger gets a `no-trigger` tag, those are the ones that silently rot.
-
-End with `<N> markers, <M> with no trigger.` Nothing found: `No monolean: debt. Clean ledger.`
-
-Also writes findings to `.monomind/metrics/monolean-debt.json` when run inside a monomind project.
-
-## Boundaries
-
-Reads and reports only, changes nothing. To persist it, ask and it writes the
-ledger to a file (e.g. `MONOLEAN-DEBT.md`). One-shot. "stop monolean-debt" or
-"normal mode" to revert.