@event4u/agent-config 5.10.1 → 6.0.0

package/scripts/migrate_frontmatter_defaults.py

@@ -1,245 +0,0 @@
-#!/usr/bin/env python3
-"""Migrate artefact frontmatter to omit fields equal to their schema default.
-
-Phase 2 of `road-to-abstraction-reduction.md`. For every skill / rule /
-command / persona, drop any frontmatter field whose value equals the
-`default` declared in its `scripts/schemas/*.json` (preflight Decision C:
-value-equals-default, type-safe). Fields without a schema default
-(`skill.execution.type`, `command.type`, `rule.validator_ignore`) are never
-touched.
-
-The loader injects the same defaults at read time
-(`validate_frontmatter.apply_schema_defaults`), so consumers see the field
-present regardless. Idempotent: a second run is a no-op.
-
-CLI:
-  python3 scripts/migrate_frontmatter_defaults.py [--dry-run] [--deltas PATH]
-
-Exit codes: 0 always (reports counts); non-zero only on I/O error.
-"""
-from __future__ import annotations
-
-import argparse
-import sys
-from collections import defaultdict
-from pathlib import Path
-from typing import Any
-
-sys.path.insert(0, str(Path(__file__).resolve().parent))
-from validate_frontmatter import load_schema, parse_frontmatter  # noqa: E402
-from _lib.agent_src import artefact_roots  # noqa: E402
-
-ROOT = Path(__file__).resolve().parents[1]
-DEFAULT_DELTAS = ROOT / "agents" / "evidence" / "analysis" / "abstraction-reduction-deltas.md"
-
-# (subdir, glob, schema name)
-_CATEGORIES = [
-    ("skills", "SKILL.md", "skill"),
-    ("rules", "*.md", "rule"),
-    ("commands", "*.md", "command"),
-    ("personas", "*.md", "persona"),
-]
-
-_FM_RE_OPEN = "---\n"
-
-
-def _same(value: Any, default: Any) -> bool:
-    """Type-safe equality. `True == 1` and `1.0 == 1` must NOT match across
-    types (preflight Decision C). bool is checked first because in Python
-    `isinstance(True, int)` is True."""
-    if isinstance(default, bool):
-        return isinstance(value, bool) and value == default
-    if isinstance(value, bool):
-        return False
-    return type(value) is type(default) and value == default
-
-
-def _plan_drops(fm: dict[str, Any], schema: dict[str, Any]) -> tuple[set[str], set[str], dict[str, set[str]]]:
-    """Return (top_level_drops, full_block_drops, partial_block_drops).
-
-    - top_level_drops: scalar keys whose value == default → drop the line.
-    - full_block_drops: object keys where every *present* sub-key is droppable
-      → drop the whole block.
-    - partial_block_drops: object key → set of droppable sub-keys (block kept).
-    """
-    top: set[str] = set()
-    full: set[str] = set()
-    partial: dict[str, set[str]] = {}
-    props = schema.get("properties", {})
-    for key, prop in props.items():
-        if not isinstance(prop, dict):
-            continue
-        if "default" in prop:
-            if key in fm and _same(fm[key], prop["default"]):
-                top.add(key)
-        elif prop.get("type") == "object" and isinstance(fm.get(key), dict):
-            sub_props = prop.get("properties", {})
-            droppable = {
-                sk for sk, sp in sub_props.items()
-                if isinstance(sp, dict) and "default" in sp
-                and sk in fm[key] and _same(fm[key][sk], sp["default"])
-            }
-            if not droppable:
-                continue
-            present = set(fm[key].keys())
-            if present <= droppable:
-                full.add(key)
-            else:
-                partial[key] = droppable
-    return top, full, partial
-
-
-def _indent(line: str) -> int:
-    return len(line) - len(line.lstrip(" "))
-
-
-def _rewrite_fm_body(body: str, top: set[str], full: set[str], partial: dict[str, set[str]]) -> str:
-    """Remove the planned lines from a frontmatter body, preserving everything
-    else byte-for-byte."""
-    lines = body.split("\n")
-    out: list[str] = []
-    skipping_block = False
-    current_block: str | None = None
-    for line in lines:
-        stripped = line.strip()
-        ind = _indent(line)
-        if skipping_block:
-            # Consume the block's indented children (and blank lines) until a
-            # top-level (indent-0, non-blank) line appears.
-            if stripped == "" or ind > 0:
-                continue
-            skipping_block = False
-            current_block = None
-        if ind == 0 and stripped and not stripped.startswith("#"):
-            key = stripped.split(":", 1)[0].strip()
-            if key in top:
-                continue
-            if key in full:
-                skipping_block = True
-                continue
-            current_block = key if key in partial else None
-            out.append(line)
-            continue
-        # Indented line belonging to current_block.
-        if current_block is not None and ind > 0 and ":" in stripped:
-            sub_key = stripped.split(":", 1)[0].strip()
-            if sub_key in partial.get(current_block, set()):
-                continue
-        out.append(line)
-    return "\n".join(out)
-
-
-def _migrate_file(path: Path, schema: dict[str, Any]) -> int:
-    text = path.read_text(encoding="utf-8")
-    fm, _ = parse_frontmatter(text)
-    if not isinstance(fm, dict):
-        return 0
-    top, full, partial = _plan_drops(fm, schema)
-    if not (top or full or partial):
-        return 0
-    # Locate the frontmatter body span (after the opening `---\n`).
-    if not text.startswith(_FM_RE_OPEN):
-        return 0
-    end = text.find("\n---\n", len(_FM_RE_OPEN))
-    if end == -1:
-        return 0
-    body = text[len(_FM_RE_OPEN):end]
-    new_body = _rewrite_fm_body(body, top, full, partial)
-    if new_body == body:
-        return 0
-    new_text = _FM_RE_OPEN + new_body + text[end:]
-    removed = body.count("\n") - new_body.count("\n")
-    path.write_text(new_text, encoding="utf-8")
-    return removed
-
-
-def _iter(category_subdir: str, glob: str):
-    """Mirror `validate_frontmatter._iter_artefacts` exactly: skills / rules /
-    commands recurse; personas are **non-recursive** (`glob`, not `rglob`) so
-    advisor personas (`personas/advisors/*.md`, a different schema) and the
-    `_template-specialist/` scaffold are never migrated."""
-    for root in artefact_roots():
-        base = root / category_subdir
-        if not base.exists():
-            continue
-        paths = base.glob(glob) if category_subdir == "personas" else base.rglob(glob)
-        for p in sorted(paths):
-            if p.is_file() and not p.is_symlink():
-                if category_subdir == "personas" and p.name.lower() == "readme.md":
-                    continue
-                yield p
-
-
-def run(apply: bool, deltas_path: Path) -> int:
-    per_class_lines: dict[str, int] = defaultdict(int)
-    per_class_files: dict[str, int] = defaultdict(int)
-    for subdir, glob, schema_name in _CATEGORIES:
-        schema = load_schema(schema_name)
-        for path in _iter(subdir, glob):
-            if apply:
-                removed = _migrate_file(path, schema)
-            else:
-                # Dry-run: compute the delta without writing.
-                text = path.read_text(encoding="utf-8")
-                fm, _ = parse_frontmatter(text)
-                if not isinstance(fm, dict) or not text.startswith(_FM_RE_OPEN):
-                    continue
-                end = text.find("\n---\n", len(_FM_RE_OPEN))
-                if end == -1:
-                    continue
-                body = text[len(_FM_RE_OPEN):end]
-                top, full, partial = _plan_drops(fm, schema)
-                new_body = _rewrite_fm_body(body, top, full, partial)
-                removed = body.count("\n") - new_body.count("\n")
-            if removed:
-                per_class_lines[schema_name] += removed
-                per_class_files[schema_name] += 1
-
-    total_lines = sum(per_class_lines.values())
-    total_files = sum(per_class_files.values())
-    verb = "would remove" if not apply else "removed"
-    print(f"frontmatter-default migration ({'dry-run' if not apply else 'apply'}):")
-    for schema_name, _glob, _sn in [(c[2], c[1], c[2]) for c in _CATEGORIES]:
-        if per_class_files.get(schema_name):
-            print(f"  {schema_name:8s}: {verb} {per_class_lines[schema_name]:5d} lines "
-                  f"across {per_class_files[schema_name]} files")
-    print(f"  {'TOTAL':8s}: {verb} {total_lines} lines across {total_files} files")
-
-    if not apply:
-        _write_deltas(deltas_path, per_class_lines, per_class_files, total_lines, total_files)
-        print(f"  delta report → {deltas_path.relative_to(ROOT)}")
-    return 0
-
-
-def _write_deltas(path: Path, lines: dict[str, int], files: dict[str, int],
-                  total_lines: int, total_files: int) -> None:
-    rows = "\n".join(
-        f"| {sn} | {files.get(sn, 0)} | {lines.get(sn, 0)} |"
-        for _sd, _g, sn in _CATEGORIES if files.get(sn)
-    )
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(
-        "# Abstraction-reduction — frontmatter line-count delta\n\n"
-        "> Dry-run prediction from `scripts/migrate_frontmatter_defaults.py "
-        "--dry-run` (road-to-abstraction-reduction.md Phase 2 § Step 2). Lines\n"
-        "> are frontmatter lines dropped because their value equalled the\n"
-        "> schema default; the loader re-injects them at read time.\n\n"
-        "| Class | Files touched | Lines removed |\n"
-        "|---|---:|---:|\n"
-        f"{rows}\n"
-        f"| **TOTAL** | **{total_files}** | **{total_lines}** |\n",
-        encoding="utf-8",
-    )
-
-
-def main(argv: list[str] | None = None) -> int:
-    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
-    parser.add_argument("--dry-run", action="store_true", help="report the delta; write nothing.")
-    parser.add_argument("--deltas", type=Path, default=DEFAULT_DELTAS,
-                        help="dry-run delta report output path.")
-    args = parser.parse_args(argv)
-    return run(apply=not args.dry_run, deltas_path=args.deltas)
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/scripts/mine_session.py

@@ -1,279 +0,0 @@
-#!/usr/bin/env python3
-"""Mine session transcripts for memory signals — Phase-1 single-host.
-
-Implements the GATHER SIGNAL phase of the `memory-consolidation` skill
-against Claude-Code-format JSONL transcripts. Default behaviour is
-``--preview`` (stdout only). ``--commit-intake`` appends one JSONL line
-per fact to ``agents/memory/intake/<primary-tag>.jsonl`` per the
-agent-memory contract.
-
-Strict gates: opt-in transcript access (``--confirm-transcript-access``
-required per invocation), ≤ 5 normalised facts per cycle, redaction
-applied to every yielded text. See
-``.agent-src.uncondensed/commands/memory/mine-session.md`` for the
-authored spec.
-"""
-
-from __future__ import annotations
-
-import argparse
-import datetime as dt
-import hashlib
-import json
-import os
-import re
-import sys
-from pathlib import Path
-from typing import Any, Iterable
-
-ROOT = Path(__file__).resolve().parent.parent
-INTAKE_ROOT = Path("agents/memory/intake")
-DEFAULT_WINDOW_DAYS = 14
-MAX_FACTS = 5
-
-SIGNAL_FAMILIES: dict[str, re.Pattern[str]] = {
-    # Correction first — explicit redirects beat ambient preference matches.
-    "gotcha": re.compile(
-        r"(?i)\b(actually|wrong|stop doing|don't do|that's not what|nicht so)\b"),
-    # Decision next — narrowest family.
-    "invariant": re.compile(
-        r"(?i)\b(let's go with|decided|we'll use|entschieden)\b"),
-    # Preference last — widest, must not eat correction/decision turns.
-    "convention": re.compile(
-        r"(?i)\b(prefer|always|never|standard|i want|ich will)\b"),
-}
-PATTERN_MIN_REPEATS = 3
-PATTERN_WINDOW_HOURS = 24
-
-NAME_REDACT = re.compile(r"\b(Matze|Mathias)\b")
-PRONOUN_STRIP = re.compile(r"(?i)\b(I|me|my|mein|ich)\b\s*")
-PATH_TOKEN = re.compile(r"\b[a-zA-Z][\w/.-]*/[\w./-]+\b")
-SYMBOL_TOKEN = re.compile(r"\b[A-Z][a-zA-Z0-9]+(?:::|\.)[a-zA-Z_][\w]*\b")
-
-
-def _redact(text: str, extra_patterns: list[re.Pattern[str]]) -> str:
-    out = NAME_REDACT.sub("<user>", text)
-    for p in extra_patterns:
-        out = p.sub("<redacted>", out)
-    return out.strip()
-
-
-def _normalise(text: str, extra_patterns: list[re.Pattern[str]]) -> str | None:
-    """Strip pronouns and chrome; require a project-scoped key token."""
-    cleaned = _redact(text, extra_patterns)
-    cleaned = PRONOUN_STRIP.sub("", cleaned).strip()
-    if not (PATH_TOKEN.search(cleaned) or SYMBOL_TOKEN.search(cleaned)):
-        return None  # user-scoped, drop
-    return re.sub(r"\s+", " ", cleaned)[:240]
-
-
-def _key_of(text: str) -> str:
-    m = PATH_TOKEN.search(text) or SYMBOL_TOKEN.search(text)
-    return m.group(0) if m else "unknown"
-
-
-def _iter_claude_code_jsonl(path: Path) -> Iterable[dict[str, Any]]:
-    with path.open(encoding="utf-8") as f:
-        for line in f:
-            line = line.strip()
-            if not line:
-                continue
-            try:
-                yield json.loads(line)
-            except json.JSONDecodeError:
-                continue
-
-
-def _turn_text(turn: dict[str, Any]) -> str:
-    msg = turn.get("message") or {}
-    content = msg.get("content")
-    if isinstance(content, str):
-        return content
-    if isinstance(content, list):
-        return " ".join(c.get("text", "") for c in content
-                        if isinstance(c, dict) and c.get("type") == "text")
-    return ""
-
-
-def _turn_ts(turn: dict[str, Any]) -> str:
-    return turn.get("timestamp") or turn.get("ts") or ""
-
-
-def _within_window(ts_str: str, since: dt.datetime) -> bool:
-    if not ts_str:
-        return True
-    try:
-        ts = dt.datetime.fromisoformat(ts_str.replace("Z", "+00:00"))
-    except ValueError:
-        return True
-    if ts.tzinfo is None:
-        ts = ts.replace(tzinfo=dt.timezone.utc)
-    return ts >= since
-
-
-def _detect_pattern(turns: list[dict[str, Any]]) -> list[tuple[str, str, str]]:
-    """Return [(key, observation, ts)] for paths/symbols seen ≥ 3× / 24h."""
-    seen: dict[str, list[tuple[dt.datetime, str]]] = {}
-    for t in turns:
-        text = _turn_text(t)
-        ts_str = _turn_ts(t)
-        try:
-            ts = dt.datetime.fromisoformat(ts_str.replace("Z", "+00:00"))
-        except ValueError:
-            continue
-        if ts.tzinfo is None:
-            ts = ts.replace(tzinfo=dt.timezone.utc)
-        for m in PATH_TOKEN.findall(text) + SYMBOL_TOKEN.findall(text):
-            seen.setdefault(m, []).append((ts, ts_str))
-    out: list[tuple[str, str, str]] = []
-    window = dt.timedelta(hours=PATTERN_WINDOW_HOURS)
-    for key, hits in seen.items():
-        hits.sort()
-        for i in range(len(hits) - PATTERN_MIN_REPEATS + 1):
-            if hits[i + PATTERN_MIN_REPEATS - 1][0] - hits[i][0] <= window:
-                out.append((key, f"recurring reference to {key}",
-                            hits[i + PATTERN_MIN_REPEATS - 1][1]))
-                break
-    return out
-
-
-def _session_id(transcript: Path) -> str:
-    h = hashlib.sha256(str(transcript.resolve()).encode()).hexdigest()
-    return h[:16]
-
-
-def mine(transcript: Path, since: dt.datetime,
-         extra_patterns: list[re.Pattern[str]]) -> list[dict[str, Any]]:
-    """Return up to MAX_FACTS normalised facts (preview shape)."""
-    turns_in_window = [t for t in _iter_claude_code_jsonl(transcript)
-                       if _within_window(_turn_ts(t), since)]
-    facts: list[dict[str, Any]] = []
-    session_id = _session_id(transcript)
-    for turn in turns_in_window:
-        text = _turn_text(turn)
-        if not text:
-            continue
-        for tag, family in SIGNAL_FAMILIES.items():
-            if not family.search(text):
-                continue
-            obs = _normalise(text, extra_patterns)
-            if obs is None:
-                continue
-            facts.append({
-                "ts": _turn_ts(turn) or dt.datetime.now(
-                    dt.timezone.utc).isoformat(timespec="seconds"),
-                "type": tag,
-                "key": _key_of(text),
-                "observation": obs,
-                "source": "agent",
-                "session_id": session_id,
-                "tags": [tag],
-            })
-            break
-    for key, obs, ts in _detect_pattern(turns_in_window):
-        facts.append({
-            "ts": ts, "type": "pattern", "key": key,
-            "observation": obs, "source": "agent",
-            "session_id": session_id, "tags": ["pattern"],
-        })
-    return facts[:MAX_FACTS]
-
-
-def render_preview(facts: list[dict[str, Any]],
-                   project: str, window: str, host: str) -> str:
-    if not facts:
-        return (f"## Mining preview — {project} · {window} · host={host}\n\n"
-                "_No signals matched. Tighten patterns or widen --since._\n")
-    lines = [f"## Mining preview — {project} · {window} · host={host}", "",
-             "| # | Tag | Key | Observation | Source turn |",
-             "|---|---|---|---|---|"]
-    for i, f in enumerate(facts, 1):
-        lines.append(f"| {i} | {f['type']} | {f['key']} | "
-                     f"{f['observation']} | {f['ts']} |")
-    schemas = sorted({f["type"] for f in facts})
-    lines.append("")
-    lines.append(f"Schemas touched: {', '.join(schemas)}")
-    return "\n".join(lines) + "\n"
-
-
-def commit_intake(facts: list[dict[str, Any]], intake_root: Path) -> int:
-    intake_root.mkdir(parents=True, exist_ok=True)
-    written = 0
-    for f in facts:
-        dest = intake_root / f"{f['type']}.jsonl"
-        with dest.open("a", encoding="utf-8") as fh:
-            fh.write(json.dumps(f, ensure_ascii=False) + "\n")
-        written += 1
-    return written
-
-
-def _resolve_transcript(host: str, override: str | None) -> Path | None:
-    if override:
-        return Path(override)
-    if host != "claude-code":
-        return None
-    home = Path(os.path.expanduser("~/.claude/projects"))
-    if not home.exists():
-        return None
-    candidates = sorted(home.rglob("*.jsonl"),
-                        key=lambda p: p.stat().st_mtime, reverse=True)
-    return candidates[0] if candidates else None
-
-
-def main(argv: list[str] | None = None) -> int:
-    ap = argparse.ArgumentParser(description=__doc__)
-    ap.add_argument("--since", default=None,
-                    help="ISO date; default 14 days ago")
-    ap.add_argument("--confirm-transcript-access", action="store_true")
-    ap.add_argument("--preview", action="store_true", default=True)
-    ap.add_argument("--commit-intake", action="store_true")
-    ap.add_argument("--host", default="claude-code")
-    ap.add_argument("--transcript", default=None,
-                    help="Override transcript path (testing)")
-    ap.add_argument("--intake-root", default=str(INTAKE_ROOT))
-    ap.add_argument("--project", default=Path.cwd().name)
-    ns = ap.parse_args(argv)
-
-    if ns.commit_intake and not ns.preview:
-        ns.preview = False
-    if ns.commit_intake and ns.preview:
-        ns.preview = False  # commit-intake wins
-
-    if not ns.confirm_transcript_access:
-        print("> Mining reads your session transcript files. Re-run with\n"
-              "> --confirm-transcript-access to proceed. The flag is "
-              "per-invocation\n> and not persisted.")
-        return 0
-
-    if ns.host != "claude-code":
-        print(f"> No TranscriptAdapter for host={ns.host}. Phase 1 supports: "
-              "claude-code.\n> Use /memory propose to record signals "
-              "manually.")
-        return 0
-
-    transcript = _resolve_transcript(ns.host, ns.transcript)
-    if transcript is None or not transcript.exists():
-        print("> No transcript found for host=claude-code. "
-              "Use /memory propose.")
-        return 0
-
-    since = (dt.datetime.fromisoformat(ns.since)
-             .replace(tzinfo=dt.timezone.utc) if ns.since
-             else dt.datetime.now(dt.timezone.utc)
-             - dt.timedelta(days=DEFAULT_WINDOW_DAYS))
-    facts = mine(transcript, since, extra_patterns=[])
-    window = f"since {since.date().isoformat()}"
-
-    if not ns.commit_intake:
-        print(render_preview(facts, ns.project, window, ns.host), end="")
-        return 0
-
-    written = commit_intake(facts, Path(ns.intake_root))
-    files_touched = len({f["type"] for f in facts})
-    print(f"✅ Appended {written} intake lines across {files_touched} files.\n"
-          "   Next: /memory promote to lift validated lines into curated YAML.")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/scripts/move_artefact.py

@@ -1,143 +0,0 @@
-#!/usr/bin/env python3
-"""Move a single artefact between packs via ``git mv`` (history-preserving).
-
-Phase 4.5 of the monorepo migration (ADR-017). Locates the artefact by
-slug or logical path, computes its destination under the requested
-pack, runs ``git mv`` for the artefact directory (skills/commands) or
-the single file (rules), and rewrites the ``packs:`` frontmatter so the
-discovery manifest stays in sync.
-
-CLI:
-  --id ID            artefact slug (skill/command name or rule stem)
-  --type TYPE        skill | rule | command (required when --id ambiguous)
-  --to PACK          target pack id (e.g. ``laravel``, ``core``)
-  --dry-run          print the planned move and frontmatter edit, no FS changes
-"""
-from __future__ import annotations
-
-import argparse
-import subprocess
-import sys
-from pathlib import Path
-
-import yaml
-
-ROOT = Path(__file__).resolve().parents[1]
-PACKAGES = ROOT / "packages"
-PACKS_VOCAB = ROOT / "config" / "discovery" / "packs.yml"
-
-
-def _list_pack_ids() -> set[str]:
-    data = yaml.safe_load(PACKS_VOCAB.read_text(encoding="utf-8")) or []
-    return {p["id"] for p in data} | {"core"}
-
-
-def _pack_dir(pack_id: str) -> Path:
-    return PACKAGES / ("core" if pack_id == "core" else f"pack-{pack_id}")
-
-
-def _find_artefact(slug: str, kind: str | None) -> tuple[Path, str, str]:
-    """Return (physical_path, detected_kind, current_pack_id)."""
-    hits: list[tuple[Path, str, str]] = []
-    for pkg in sorted(PACKAGES.iterdir()):
-        src = pkg / ".agent-src.uncondensed"
-        if not src.is_dir():
-            continue
-        pid = "core" if pkg.name == "core" else pkg.name.removeprefix("pack-")
-        for k, rel in (("skill", f"skills/{slug}/SKILL.md"),
-                        ("rule", f"rules/{slug}.md"),
-                        ("command", f"commands/{slug}.md")):
-            p = src / rel
-            if p.exists() and (kind is None or kind == k):
-                hits.append((p, k, pid))
-    if not hits:
-        raise SystemExit(f"error: artefact '{slug}' not found under any pack")
-    if len(hits) > 1 and kind is None:
-        kinds = ", ".join(sorted({h[1] for h in hits}))
-        raise SystemExit(f"error: '{slug}' ambiguous (found as: {kinds}); pass --type")
-    return hits[0]
-
-
-def _move_root(path: Path, kind: str) -> Path:
-    """Return the path to git-mv (directory for skills, file for rule/command)."""
-    return path.parent if kind == "skill" else path
-
-
-def _rewrite_packs(md_path: Path, new_pack: str, dry_run: bool) -> bool:
-    text = md_path.read_text(encoding="utf-8")
-    if not text.startswith("---"):
-        return False
-    end = text.find("\n---", 4)
-    if end == -1:
-        return False
-    head = text[4:end]
-    body = text[end:]
-    fm = yaml.safe_load(head) or {}
-    if not isinstance(fm, dict):
-        return False
-    current = fm.get("packs") or []
-    desired = [] if new_pack == "core" else [new_pack]
-    if current == desired:
-        return False
-    if desired:
-        fm["packs"] = desired
-    else:
-        fm.pop("packs", None)
-    new_text = "---\n" + yaml.safe_dump(fm, sort_keys=False, allow_unicode=True) + body[1:]
-    if dry_run:
-        print(f"  would rewrite frontmatter packs: {current} -> {desired}")
-    else:
-        md_path.write_text(new_text, encoding="utf-8")
-        print(f"  rewrote frontmatter packs: {current} -> {desired}")
-    return True
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser(description=__doc__)
-    ap.add_argument("--id", required=True, help="artefact slug")
-    ap.add_argument("--to", required=True, help="target pack id")
-    ap.add_argument("--type", choices=["skill", "rule", "command"])
-    ap.add_argument("--dry-run", action="store_true")
-    args = ap.parse_args()
-
-    vocab = _list_pack_ids()
-    if args.to not in vocab:
-        print(f"error: target pack '{args.to}' not in {sorted(vocab)}", file=sys.stderr)
-        return 2
-
-    src_md, kind, current_pack = _find_artefact(args.id, args.type)
-    if current_pack == args.to:
-        print(f"no-op: '{args.id}' already lives in pack '{args.to}'")
-        return 0
-
-    src_root = _move_root(src_md, kind)
-    dest_pkg_src = _pack_dir(args.to) / ".agent-src.uncondensed"
-    rel_under_pack = src_root.relative_to(_pack_dir(current_pack) / ".agent-src.uncondensed")
-    dest_root = dest_pkg_src / rel_under_pack
-
-    print(f"plan: {kind} '{args.id}' : {current_pack} -> {args.to}")
-    print(f"  git mv {src_root.relative_to(ROOT)} {dest_root.relative_to(ROOT)}")
-
-    # Frontmatter must be rewritten BEFORE the move so the new physical
-    # location matches the declared pack. Discovery scanner cross-checks.
-    _rewrite_packs(src_md, args.to, args.dry_run)
-
-    if args.dry_run:
-        print("dry-run: no FS changes")
-        return 0
-
-    dest_root.parent.mkdir(parents=True, exist_ok=True)
-    result = subprocess.run(
-        ["git", "mv", str(src_root.relative_to(ROOT)), str(dest_root.relative_to(ROOT))],
-        cwd=ROOT, capture_output=True, text=True,
-    )
-    if result.returncode != 0:
-        print(f"git mv failed: {result.stderr}", file=sys.stderr)
-        return result.returncode
-    print(f"moved: {src_root.relative_to(ROOT)} -> {dest_root.relative_to(ROOT)}")
-    print("next: run `task sync` and `task lint-pack-boundaries`")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())