@amsterdamdatalabs/enact-extensions 0.1.42 → 0.1.47

package/extensions/enact-factory/skills/cmux-leader/SKILL.md

@@ -1,74 +0,0 @@
----
-name: cmux-leader
-description: "Become the cmux LEADER — spawn, root-per-repo, brief, poll, unblock, and verify parallel claude follower terminals from a neutral leader. Use when orchestrating multi-session work across sibling terminals. Followers reply via the cmux-send skill."
----
-
-# cmux-leader — you are the LEADER
-
-You run inside a cmux workspace and orchestrate **follower** claude sessions in sibling terminals.
-You coordinate; followers do the hands-on work. Keep your own context for the plan and the gates.
-
-## Hard rules (learned the hard way)
-
-- **One surface per directory.** A working tree cannot have two drivers — two followers, or leader +
-  a follower, in the same repo causes git collisions and duplicate PRs. If two must touch one repo,
-  give each its own `git worktree`.
-- **Verify cwd BEFORE launching claude.** `new-split`/`new-surface` do NOT take a working-directory
-  flag — a new pane inherits the parent's cwd. Always `cd <repo>` then confirm `pwd` *before* you run
-  `claude`, or the follower boots in the wrong repo.
-- **Lead from a NEUTRAL dir** (the common parent of all repos). The enact-loop Stop hook resolves the
-  active loop by SHELL cwd — if you `cd` into a follower's repo you inherit its Stop boulder and it
-  blocks your exit. Inspect a follower's repo with `git -C <path> …`, never a persistent `cd`.
-- **Spawn on demand.** Don't pre-create followers for ungreenlit work — idle sessions burn tokens.
-  Create one only when a concrete task is ready; `close-surface` it when its work is done.
-- **Before opening a PR, check no follower already opened one** for that branch (avoid duplicate PRs).
-- **Don't accept self-reported green** — verify against real output (tests, build, PR state).
-- **Max 5 claude sessions**, horizontal splits, one workspace.
-
-## Commands I use
-
-```bash
-# Orient (re-discover every turn; surface numbers renumber)
-cmux list-panes
-cmux list-pane-surfaces [--pane pane:N]      # name each surface
-cmux tree                                    # process/Surface tree (optional)
-
-# Read a follower
-cmux read-screen --surface surface:N [--lines 40] [--scrollback]
-
-# Drive a follower  (send → 2×Enter → ctrl+b → verify EMPTY box)
-cmux send --surface surface:N "text\n"
-cmux send-key --surface surface:N enter      # Enter #1
-cmux send-key --surface surface:N enter      # Enter #2 — one Enter often does NOT land
-cmux send-key --surface surface:N ctrl+b     # flush a QUEUED msg — no-op while only thinking
-cmux read-screen --surface surface:N --lines 6   # confirm the ❯ box is EMPTY (it landed)
-cmux send-key --surface surface:N ctrl+c     # interrupt a runaway
-
-# Spawn a follower (root it correctly, THEN launch claude)
-cmux new-split right --focus false                 # -> surface:N
-cmux send --surface surface:N "cd /abs/repo && pwd\n"
-cmux read-screen --surface surface:N --lines 5     # CONFIRM pwd == the repo
-cmux send --surface surface:N "claude\n"
-
-# Close a finished/dead follower
-cmux close-surface --surface surface:N
-```
-
-## Messaging — always use the cmux-send skill
-
-Every follower briefing must tell the follower to use the **cmux-send** skill. Each message: prefix
-`[LEADER] to [FOLLOWER-<name>] `, end with `Respond back once you are done with using prefix
-"[FOLLOWER-<name>] to [LEADER] "`. After every `send`, fire **two** `send-key … enter` (one Enter
-often does not land) + one `ctrl+b`, then `read-screen` and confirm the `❯` box is **empty** — an
-empty inbox is the only proof it submitted.
-
-## Leader loop
-
-1. **Shard** the goal into independent slices, one repo per follower.
-2. **Spawn & brief** — split → `cd <repo>` (verify pwd) → `claude` → self-contained briefing (role,
-   scope, exit criteria, "use cmux-send to reply, report in one line").
-3. **Poll on a ~15-min cadence** — never go idle while followers run. Re-discover topology, `read-screen`
-   each, classify (working / idle-done / parked / blocked / ctx≥80%), and act: parked → `send-key enter`
-   ×2 + `ctrl+b`, then verify the `❯` box is empty; ctx≥80% → tell it to `/compact`; blocked → answer;
-   idle-done → assign next or `close-surface`.
-4. **Verify & gate** — confirm real output before treating a slice as green; drive merges from the leader.

package/extensions/enact-factory/skills/cmux-send/SKILL.md

@@ -1,50 +0,0 @@
----
-name: cmux-send
-description: "How to correctly message a cmux surface — the send→verify→enter protocol and the [from] to [to] envelope. Use whenever messaging a cmux session (leader→follower or follower→leader)."
----
-
-# cmux-send — message a cmux surface correctly
-
-Two parts are easy to get wrong: **submitting** the message and **wrapping** it.
-
-## 1. Submit protocol (send → 2×Enter → ctrl+b → verify empty box)
-
-```bash
-cmux send --surface surface:N "<one-line message>\n"   # \n = Enter (often not enough alone)
-cmux send-key --surface surface:N enter                 # Enter #1
-cmux send-key --surface surface:N enter                 # Enter #2 — one Enter frequently does NOT land
-cmux send-key --surface surface:N ctrl+b                 # flush if a bash command is running
-cmux read-screen --surface surface:N --lines 6          # VERIFY: the ❯ box is EMPTY (message left)
-```
-
-- **Send TWO Enter keys, not one.** A single `send-key … enter` (or the trailing `\n`) frequently
-  fails to submit while the follower is booting or thinking — the text parks in the `❯` box. Two
-  Enters is the reliable default; a leftover empty Enter is harmless.
-- **Then one `ctrl+b`.** It flushes a *queued* message only when the follower has a **running bash
-  command** to background; while it is purely thinking `ctrl+b` is a harmless no-op. Sending it
-  unconditionally costs nothing and frees the queue the moment a command is running.
-- **Always confirm an EMPTY inbox.** `read-screen` after submitting and check the `❯` box is clear
-  (no parked text, no "Press up to edit queued messages"). An empty box is the only proof it landed —
-  do not assume submission, verify it.
-- **To submit a parked message, `send-key … enter` (×2), NOT `ctrl+b` alone.** `ctrl+b` does nothing
-  while the follower is only thinking.
-- **One line only.** Every literal `\n` submits, so a multi-line prompt fires early and fragments.
-- `read-screen` takes `--surface`, not `--pane`.
-
-## 2. Message envelope (every message)
-
-- **Start with:** `[<from-surface-name>] to [<to-surface-name>] `
-- **End with:** `Respond back once you are done with using prefix "[<to-surface-name>] to [<from-surface-name>] "`
-
-Surface names are the human labels (e.g. `LEADER`, `FOLLOWER-enact-wiki`), not `surface:N`. Map them
-with `cmux list-pane-surfaces [--pane pane:N]`.
-
-### Example (leader → follower)
-
-```bash
-cmux send --surface surface:3 "[LEADER] to [FOLLOWER-enact-wiki] <instruction on one line>. Respond back once you are done with using prefix \"[FOLLOWER-enact-wiki] to [LEADER] \"\n"
-cmux send-key --surface surface:3 enter      # ×2 — one Enter often does not land
-cmux send-key --surface surface:3 enter
-cmux send-key --surface surface:3 ctrl+b      # flush if a command is running (no-op while thinking)
-cmux read-screen --surface surface:3 --lines 6   # confirm the ❯ box is EMPTY
-```

package/extensions/enact-factory/skills/committee/SKILL.md

@@ -1,80 +0,0 @@
----
-name: committee
-description: >-
-  Two contrasting-vendor agents root-cause a stuck, blocked, or looping WorkItem
-  and produce a plan. Use when asked to "convene a committee", "root-cause this",
-  "the item is stuck/looping", "debate the approach", or when the driver's loop
-  stalls and needs a way forward. Produces a plan that feeds `plan` / `drive-loop`;
-  may propose a different approach. Read + plan only — no implementation.
-metadata:
-  author: Amsterdam Data Labs
-  version: 1.0.0
----
-
-# committee
-
-> **Storage is GLOBAL — never write to a repo-local `.enact` dir.** Resolve the project's global dir:
-> 1. `ROOT="$(git rev-parse --show-toplevel)"`
-> 2. In `~/.enact/workspaces.json` → `workspaces`, find the entry whose `.root` == `$ROOT`; its object key is `<name>-<id>`.
-> 3. Factory planning artifacts go under `~/.enact/factory/projects/<key>/…`.
-
-Two **contrasting-vendor** agents independently diagnose a stuck WorkItem, then
-their findings are reconciled into a single forward plan. Heavier than
-[`advisor`](../advisor/SKILL.md) (one strong opinion); this is the **strong escalation** for
-architecture decisions and risky or irreversible changes. Use when an item is **stalled, blocked,
-or looping** and the path is unclear, OR when a risky migration / architecture decision requires
-two independent strong perspectives before proceeding.
-
-## When to escalate to committee
-
-- Architecture decisions (interface shape, system redesign, approach selection)
-- Risky or irreversible migrations (data, schema, breaking API changes)
-- Items blocked at the loop level where `advisor`'s single opinion is insufficient
-- Branch policy / CI strategy changes with wide blast radius
-
-## Model selection
-
-Committee always uses **opus 4.8 + gpt-5.6-terra** — the two strongest available models from different
-vendors. This pairing provides genuine diversity: one OpenAI-lineage, one Anthropic-lineage.
-
-## Boundaries (hard)
-
-- **Diagnose + plan only.** No code changes, no commits, no board mutation. The
-  output is a plan; implementation happens later via `drive-loop`.
-- **Two distinct vendors: opus 4.8 + gpt-5.6-terra.** Both members run on models that are different
-  from each other and from the executor (genuine diversity). If two distinct models are
-  unavailable, run what you can and STATE the reduced diversity loudly — do not
-  pretend two same-model passes are a committee.
-- **Reconcile honestly.** If the two disagree, surface the disagreement and the
-  decisive evidence; do not paper over it.
-
-## Sequence
-
-1. Assemble the dossier: `factory_workitem_get` (goal, acceptance, current
-   state, `blockedBy`), the loop status / stall reason, recent failing output.
-2. Spawn TWO agents on **opus 4.8 + gpt-5.6-terra**, with contrasting lenses:
-
-   ```
-   Agent({ subagent_type: "critic",    model: "claude-opus-4-8", prompt: "<dossier> — root-cause why this is stuck; what is the real blocker?" })
-   Agent({ subagent_type: "architect", model: "gpt-5.6-terra",         prompt: "<dossier> — is the current approach right? propose the smallest viable path to closure." })
-   ```
-
-3. Reconcile their findings into ONE plan: the root cause, the chosen approach
-   (note if it differs from the original), and ordered next steps mapped to
-   loop stages.
-4. Hand the result to `$plan` so it is persisted as a new timestamped
-   `~/.enact/factory/projects/<key>/plans/<YYMMDDHH>-<phase>.md` artifact rather
-   than left only in chat output.
-
-## Output
-
-`{ rootCause, approach (kept | changed + why), steps[], dissent? , members[] }`
-where `members[]` shows the two distinct models. The `steps[]` are ready to feed
-[`plan`](../plan/SKILL.md) or directly into a [`drive-loop`](../drive-loop/SKILL.md)
-contract.
-
-## Related
-
-- [`advisor`](../advisor/SKILL.md) — when one opinion is enough.
-- [`plan`](../plan/SKILL.md) — turn the committee's steps into an execution plan.
-- [`drive-loop`](../drive-loop/SKILL.md) — execute the chosen path to closure.

package/extensions/enact-factory/skills/deep-interview/SKILL.md

@@ -1,68 +0,0 @@
----
-name: deep-interview
-description: "Intent-first clarification loop for vague, risky, or product-heavy work before planning or execution."
----
-
-# Deep Interview
-
-> **Storage is GLOBAL — never write to a repo-local `.enact` dir.** Resolve the project's global dir:
-> 1. `ROOT="$(git rev-parse --show-toplevel)"`
-> 2. In `~/.enact/workspaces.json` → `workspaces`, find the entry whose `.root` == `$ROOT`; its object key is `<name>-<id>` (e.g. `enact-evolve-a38d1e`).
-> 3. Factory planning artifacts go under `~/.enact/factory/projects/<key>/…`.
-
-## Purpose
-
-Use `$deep-interview` to turn a fuzzy request into an execution-ready spec. This is not generic
-brainstorming. It is a focused clarification loop that removes ambiguity before planning or coding.
-
-## Use When
-
-- the request describes outcomes, not behavior
-- the user is still discovering what they want
-- scope, non-goals, or decision boundaries are unclear
-- a wrong assumption would create expensive rework
-
-## Do Not Use When
-
-- the request already names files, symbols, and acceptance criteria
-- the user explicitly wants immediate execution and the risk is low
-- the only missing work is architectural decomposition, not intent clarity
-
-## Execution Policy
-
-- ask one question at a time
-- ask only the highest-leverage unresolved question
-- use repo facts before asking about codebase internals
-- force clarity on non-goals and decision boundaries before handoff
-- keep the interview moving toward a durable artifact, not an endless conversation
-- **never overwrite a prior requirements file in place** — each durable snapshot gets a fresh `YYMMDDHH` prefix
-
-## Workflow
-
-1. Inspect the repo for brownfield context if relevant.
-2. Capture the current hypothesis in a **new** `~/.enact/factory/projects/<key>/plans/<YYMMDDHH>-<phase>-requirements.md` (e.g. `plans/26062101-auth-requirements.md`). Resolve `<key>` from `~/.enact/workspaces.json`; get the timestamp prefix via `date +%y%m%d%H`.
-3. Run a one-question loop until these are explicit:
-   - goal
-   - in-scope
-   - out-of-scope
-   - acceptance criteria
-   - decision boundaries
-4. During the interview, revise the **same** requirements file for the current pass only. A new interview session or phase restart writes a **new** timestamped file instead of editing an old one.
-5. Hand off to `$plan` when the spec is concrete. `$plan` resolves the latest `*-requirements.md` per its Active Artifact Resolution rules.
-
-## Output Standard
-
-The finished interview should leave behind:
-
-- clear goal
-- explicit non-goals
-- decision boundaries
-- testable acceptance criteria
-- constraints that downstream execution must honor
-
-## Stop Conditions
-
-Do not hand off while either of these is missing:
-
-- non-goals
-- decision boundaries

package/extensions/enact-factory/skills/deslop-handover/SKILL.md

@@ -1,97 +0,0 @@
----
-name: deslop-handover
-description: "Strip AI-authoring tells (emoji, marketing tone, over-bolding, edit scars) from handover docs for a no-AI customer, while preserving every number, reference, code block, and finding verbatim."
----
-
-# Deslop Handover
-
-Make a documentation handover read as plain, human-authored engineering notes — for a
-customer that enforces a **strict no-AI policy** — without losing any of the hard-won
-technical substance.
-
-This is sharper than `ai-slop-cleaner` (which targets TODO/placeholder code residue) because
-it adds the two things that matter for prose handovers:
-
-1. **Preserve-rules** — numbers, percentages, file:line refs, code blocks, table data,
-   citations/DOIs stay byte-for-byte. The value is the substance; only the *voice* changes.
-2. **Sanctioned-vs-violation distinction** — the delivered product running on the customer's
-   OWN infrastructure (Azure OpenAI, LLM parser, embeddings, BM25, vector search, ontology,
-   taxonomy) is **architecture, not a violation** — KEEP it. Only AI-*authoring* tells go.
-
-## Use When
-
-- Preparing any markdown/docs bundle for handover to a no-AI / compliance-sensitive customer.
-- After an AI-assisted writing or redaction pass that left tone slop or edit scars.
-- When docs must look human-authored but every finding/number must survive intact.
-
-## What counts as slop (REMOVE / NEUTRALIZE)
-
-- **Emoji & decorative symbols** (✅ ✔ ✓ ❌ ⚠️ 🎯 📊 🚀 ✨ ⭐). Badge labels like `✅ Good` →
-  the plain word (`Good`); decorative ones → delete. (Arrows `→`, dashes `—`, math `≤ ≥ ≠`
-  are notation — keep.)
-- **Marketing / filler**: comprehensive, seamless, robust (only when decorative — keep
-  "robust to X" technical usage), powerful, leverage, elegant, best practices, closes the
-  gap, dive in, it's worth noting, it's important to note, "Note that" openers, "Overall,",
-  "In summary", "In conclusion", game-changer, unlock(s), elevate, supercharge, effortless,
-  cutting-edge.
-- **Rule-of-three flourishes** and hype cadence ("X, Y, and Z — all real") → plain statement.
-- **Over-bolding** — bold used for sentence emphasis; keep bold only on genuine key terms/values.
-- **Self-referential tells** — "generated by an AI", "LLM-authored", "I analyzed", "this
-  session", "as an AI"; template title prefixes like `Learning:` / `Fix:`.
-- **Edit scars** from prior passes — blank-date holes (`as of )`, `On , `, `( run, …)`),
-  empty parens `( )`, leading-comma parens `(, …)`, space-before-colon `Foo :`, dangling
-  heading dashes `# Title —`, duplicated words.
-
-## What to PRESERVE (do not touch)
-
-Every number, percentage, row count, threshold, column name, file path, file:line reference,
-SQL/code block (verbatim), table data cell, citation, DOI, author, journal, year. Every
-finding, root cause, decision, and deferred/open/superseded note. Section structure. The
-sanctioned product-architecture terms listed above.
-
-## Workflow
-
-**Step 1 — mechanical pass (the ~80%).** Run the bundled script in report mode first, then fix:
-
-```bash
-python skills/deslop-handover/deslop.py --report <root-or-globs...>   # see what's there
-python skills/deslop-handover/deslop.py --fix    <root-or-globs...>   # apply mechanical fixes
-```
-
-The script is **code-fence-aware** (never touches fenced ``` blocks, inline `code`, or digits)
-and only does safe structural edits: emoji removal/badge-strip, edit-scar repair, trailing
-whitespace. It does NOT auto-rewrite prose — it **reports** slop phrases, over-bold lines, and
-blank-date holes for the judgment pass.
-
-**Step 2 — judgment pass (the ~20%), fanned out.** Tone, over-bolding ("key term vs emphasis"),
-rule-of-three, and ambiguous scars need a reader. Parallelize:
-
-1. Write a shared rubric file (this SKILL's "What counts as slop" + "PRESERVE" sections).
-2. Group the dirty files into batches of ~6.
-3. Dispatch one sonnet executor per batch: *"Read the rubric at <path>. Deslop these files in
-   place: <list>. Preserve all numbers/refs/code verbatim. Report per file."*
-4. Each executor reports per-file changes and confirms zero numbers/refs/code changed.
-
-**Step 3 — verification gate.** Re-grep the whole bundle; the count must be zero:
-
-```bash
-rg -lP '[\x{1F300}-\x{1FAFF}\x{2600}-\x{26FF}\x{2705}\x{274C}\x{2714}\x{2713}\x{2716}]' <root>   # emoji
-rg -ni -e seamless -e '\bleverage' -e '\bunlock' -e 'best practices' -e 'dive in' <root>          # phrases
-rg -n -e 'as of \)' -e '\( *\)' -e '\(, ' -e ' —$' <root>                                          # scars
-```
-
-A grep hit inside a fenced code block (e.g. `.collect()` matching empty-parens) is a
-false positive — confirm by line before acting.
-
-## State Contract
-
-- Reads: the target docs (and a temp rubric file for the judgment pass).
-- Writes: the same docs, in place. No new files in the handover bundle, no frontmatter added.
-
-## Final Check
-
-- Zero emoji, zero slop phrases, zero edit scars outside fenced code.
-- Every number, file:line ref, code block, table cell, and citation is unchanged (diff to confirm).
-- Product-architecture terms (Azure OpenAI / LLM / embeddings / BM25 / ontology) intact.
-- Protected docs (e.g. a `STRATEGY.md`) excluded unless the user explicitly opts them in.
-- Ambiguous scars (missing words, duplicated phrases, lost dates) surfaced to the user, not guessed.

package/extensions/enact-factory/skills/deslop-handover/deslop.py

@@ -1,181 +0,0 @@
-#!/usr/bin/env python3
-"""deslop-handover — mechanical AI-tone cleanup for markdown handover docs.
-
-Code-fence-aware. Does the safe, deterministic ~80% of a deslop pass:
-  - strips emoji / badge symbols (keeps arrows, dashes, math notation)
-  - repairs edit scars (empty parens, leading-comma parens, space-before-colon,
-    space-before-comma, dangling heading dashes, trailing whitespace)
-  - REPORTS (never auto-rewrites) slop phrases, over-bold lines, and blank-date holes
-    that need the judgment/agent pass.
-
-NEVER touches: fenced ``` code blocks, inline `code` spans, digits, or table data values.
-
-Usage:
-    python deslop.py --report PATH [PATH ...]    # default: show findings, change nothing
-    python deslop.py --fix    PATH [PATH ...]    # apply the mechanical fixes in place
-
-PATH may be a file, a directory (recursed for *.md), or a glob. Vendored dirs
-(.venv/.git/node_modules/dist-info/.pytest_cache) are skipped.
-"""
-from __future__ import annotations
-
-import argparse
-import glob
-import re
-import sys
-from pathlib import Path
-
-_SKIP_DIRS = {".venv", ".git", "node_modules", ".pytest_cache", "__pycache__"}
-
-# Emoji / decorative symbols. Deliberately EXCLUDES arrows (U+2190-21FF, →),
-# dashes (—, –) and math (≤ ≥ ≠) which are technical notation.
-EMOJI = re.compile(
-    "[\U0001F300-\U0001FAFF\U00002600-\U000027BF\U00002B00-\U00002BFF"
-    "✅❌✔✓✖✗✨️]"
-)
-
-SLOP_PHRASES = [
-    "comprehensive", "seamless", "powerful", "leverage", "elegant", "best practices",
-    "closes the gap", "dive in", "worth noting", "important to note", "game-changer",
-    "game changer", "unlock", "elevate", "supercharge", "effortless", "cutting-edge",
-    "in conclusion", "in summary",
-]
-# matches that are technical, not slop — do not flag these
-SLOP_ALLOW = re.compile(r"robust to|robustness|leverage point|highest leverage", re.I)
-
-# Ambiguous scars that imply a lost word/date — REPORT, do not auto-fix.
-HOLE = re.compile(r"as of \)|\( *run\b|On , |Effective ,|\bpre-\s*$")
-
-_INLINE_CODE = re.compile(r"`[^`]*`")
-_FENCE = re.compile(r"^\s*(```|~~~)")
-
-
-def _split_protecting_code(line: str):
-    """Yield (text, is_code) chunks so transforms skip inline `code` spans."""
-    pos = 0
-    for m in _INLINE_CODE.finditer(line):
-        if m.start() > pos:
-            yield line[pos:m.start()], False
-        yield m.group(0), True
-        pos = m.end()
-    if pos < len(line):
-        yield line[pos:], False
-
-
-def _fix_text(text: str, is_heading: bool) -> str:
-    """Apply mechanical fixes to a non-code text chunk."""
-    text = EMOJI.sub("", text)
-    text = text.replace("️", "")
-    text = re.sub(r"\(\s*\)", "", text)          # empty parens
-    text = re.sub(r"\(,\s*", "(", text)          # leading-comma paren
-    text = re.sub(r"\(\s+", "(", text)           # leading space in paren
-    text = re.sub(r"\s+\)", ")", text)           # space before close paren
-    text = re.sub(r"\s+,", ",", text)            # space before comma
-    text = re.sub(r"\s+:\*\*", ":**", text)      # space before bold-closing colon
-    text = re.sub(r"(\*\*[^*\n]+?) :", r"\1:", text)  # "label :" inside bold
-    text = re.sub(r"\s+:\s*$", ":", text)        # space before trailing label colon
-    if is_heading:
-        text = re.sub(r"\s*[—–-]\s*$", "", text)  # dangling heading dash
-    text = re.sub(r"(?<=\S)  +", " ", text)      # collapse runs of inner spaces
-    return text
-
-
-def process(path: Path, fix: bool):
-    lines = path.read_text(encoding="utf-8").splitlines(keepends=False)
-    in_fence = False
-    out, report = [], {"emoji": 0, "scars": 0, "phrases": [], "bold": [], "holes": []}
-    for n, line in enumerate(lines, 1):
-        if _FENCE.match(line):
-            in_fence = not in_fence
-            out.append(line)
-            continue
-        if in_fence:
-            out.append(line)
-            continue
-
-        # ---- report-only signals (computed on the original line) ----
-        for p in SLOP_PHRASES:
-            if p in line.lower() and not SLOP_ALLOW.search(line):
-                report["phrases"].append((n, p))
-        if HOLE.search(line):
-            report["holes"].append((n, line.strip()[:80]))
-        for b in re.findall(r"\*\*([^*\n]+)\*\*", line):
-            if "." in b or len(b.split()) > 6:   # bold wrapping a sentence/clause
-                report["bold"].append((n, b[:60]))
-        report["emoji"] += len(EMOJI.findall(line))
-
-        # ---- mechanical fix ----
-        lead = re.match(r"^\s*", line).group(0)
-        rest = line[len(lead):]
-        is_heading = rest.startswith("#") or rest.startswith(">")
-        rebuilt = "".join(
-            chunk if is_code else _fix_text(chunk, is_heading)
-            for chunk, is_code in _split_protecting_code(rest)
-        )
-        rebuilt = (lead + rebuilt).rstrip()
-        if rebuilt != line:
-            report["scars"] += 1
-        out.append(rebuilt)
-
-    changed = out != lines
-    if fix and changed:
-        path.write_text("\n".join(out) + "\n", encoding="utf-8")
-    return changed, report
-
-
-def collect(paths):
-    files = []
-    for p in paths:
-        for hit in glob.glob(p, recursive=True) if any(c in p for c in "*?[") else [p]:
-            hp = Path(hit)
-            if hp.is_dir():
-                files += [f for f in hp.rglob("*.md")
-                          if not any(part in _SKIP_DIRS for part in f.parts)]
-            elif hp.suffix == ".md":
-                files.append(hp)
-    return sorted(set(files))
-
-
-def main():
-    ap = argparse.ArgumentParser(description="Mechanical deslop for handover markdown.")
-    ap.add_argument("--fix", action="store_true", help="apply fixes (default: report only)")
-    ap.add_argument("--report", action="store_true", help="report only (default; no-op flag for clarity)")
-    ap.add_argument("paths", nargs="+", help="files, dirs, or globs")
-    args = ap.parse_args()
-
-    files = collect(args.paths)
-    if not files:
-        print("no markdown files found", file=sys.stderr)
-        return 1
-
-    total_changed = 0
-    for f in files:
-        changed, r = process(f, args.fix)
-        signal = r["emoji"] or r["scars"] or r["phrases"] or r["bold"] or r["holes"]
-        if not signal:
-            continue
-        total_changed += int(bool(changed))
-        tag = "FIXED " if (args.fix and changed) else "FOUND "
-        print(f"\n{tag}{f}")
-        if r["emoji"]:
-            print(f"  emoji/badges: {r['emoji']}")
-        if r["scars"] and not args.fix:
-            print(f"  mechanical scars: {r['scars']} line(s) (run --fix)")
-        if r["phrases"]:
-            print("  slop phrases (judgment): " +
-                  ", ".join(f"L{n}:{p}" for n, p in r["phrases"][:8]))
-        if r["bold"]:
-            print(f"  over-bold lines (judgment): {len(r['bold'])} "
-                  f"(e.g. L{r['bold'][0][0]})")
-        if r["holes"]:
-            print("  blank-date / lost-word HOLES (needs human): " +
-                  "; ".join(f"L{n}" for n, _ in r["holes"]))
-
-    verb = "fixed" if args.fix else "with findings"
-    print(f"\n{total_changed if args.fix else len(files)} file(s) {verb}. "
-          f"Run the verification grep + judgment pass next (see SKILL.md).")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())