@event4u/agent-config 2.4.0 → 2.6.0

package/.claude-plugin/marketplace.json

@@ -6,7 +6,7 @@
   },
   "metadata": {
     "description": "Shared agent configuration \u2014 skills for AI coding tools (Claude Code, Augment, Cursor, Cline, Windsurf, Gemini CLI).",
-    "version": "2.4.0",
+    "version": "2.6.0",
     "keywords": [
       "agent-config",
       "skills",

package/CHANGELOG.md

@@ -343,6 +343,35 @@ our recommendation order, not its support status.
   users" tension without removing any path that an existing user
   might rely on.
 
+## [2.6.0](https://github.com/event4u-app/agent-config/compare/2.4.1...2.6.0) (2026-05-13)
+
+### Features
+
+* **claude-desktop:** bundle commands as desktop skills ([50cd319](https://github.com/event4u-app/agent-config/commit/50cd31988ac571ecdf883c5d2c6d62c209820ebc))
+
+### Other
+
+* 2.5.0 ([1da0e10](https://github.com/event4u-app/agent-config/commit/1da0e1014b9cf24cf41d820795f96f2668ce738c))
+
+Tests: 3530 (+9 since 2.4.1)
+
+## [2.5.0](https://github.com/event4u-app/agent-config/compare/2.4.1...2.5.0) (2026-05-13)
+
+### Features
+
+* **claude-desktop:** bundle commands as desktop skills ([50cd319](https://github.com/event4u-app/agent-config/commit/50cd31988ac571ecdf883c5d2c6d62c209820ebc))
+
+Tests: 3530 (+9 since 2.4.1)
+
+## [2.4.1](https://github.com/event4u-app/agent-config/compare/2.4.0...2.4.1) (2026-05-13)
+
+### Bug Fixes
+
+* **install:** write lockfile to canonical event4u namespace ([ca57607](https://github.com/event4u-app/agent-config/commit/ca5760785f150903bcad74e278b59e534f83634d))
+* **install:** source global deploy from .agent-src/ subdirectories ([f151caf](https://github.com/event4u-app/agent-config/commit/f151caf854d9ce8519bc244d441a7c8bf73e7fde))
+
+Tests: 3521 (+0 since 2.4.0)
+
 ## [2.4.0](https://github.com/event4u-app/agent-config/compare/2.3.0...2.4.0) (2026-05-13)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@event4u/agent-config",
-    "version": "2.4.0",
+    "version": "2.6.0",
     "description": "Shared agent configuration \u2014 skills, rules, commands, guidelines, and templates for AI coding tools",
     "license": "MIT",
     "private": false,

package/scripts/_cli/cmd_uninstall.py

@@ -422,6 +422,7 @@ def _uninstall_project(opts: argparse.Namespace) -> int:
 
 def _uninstall_global(opts: argparse.Namespace) -> int:
     lock_path = installed_lock.lockfile_path()
+    write_path = installed_lock.lockfile_write_path()
     lock = installed_lock.read_lockfile(lock_path)
     if lock is None and not opts.force:
         print(f"❌  no global lockfile at {lock_path}", file=sys.stderr)
@@ -442,15 +443,24 @@ def _uninstall_global(opts: argparse.Namespace) -> int:
             removed_names.append(tool)
     if lock is not None and not opts.dry_run:
         remaining = [t for t in lock.get("tools", []) if t not in tools]
+        version = lock.get("agent_config_version", "")
         if remaining:
-            installed_lock.write_lockfile(remaining, version=lock.get("agent_config_version", ""))
+            installed_lock.write_lockfile(version, remaining, path=write_path)
+            # Drop the legacy file if it differs from the canonical write
+            # target so the namespace migration completes on uninstall.
+            if lock_path != write_path:
+                try:
+                    lock_path.unlink()
+                except OSError:
+                    pass
             print(f"✅  lockfile updated ({len(tools)} entries removed, {len(remaining)} kept)")
         else:
-            try:
-                lock_path.unlink()
-                print(f"✅  lockfile deleted ({lock_path})")
-            except OSError as exc:
-                print(f"⚠️   could not delete lockfile: {exc}")
+            for target in {lock_path, write_path}:
+                try:
+                    target.unlink()
+                except OSError:
+                    pass
+            print(f"✅  lockfile deleted ({write_path})")
     return 0
 
 

package/scripts/_cli/cmd_update.py

@@ -243,17 +243,18 @@ def _refresh_global_lockfile(version: str, *, out=sys.stdout) -> None:
     when ``update`` flips the pin. Atomic write goes through
     ``installed_lock.write_lockfile``.
     """
-    lock_path = installed_lock.lockfile_path()
-    existing = installed_lock.read_lockfile(path=lock_path)
+    read_path = installed_lock.lockfile_path()
+    write_path = installed_lock.lockfile_write_path()
+    existing = installed_lock.read_lockfile(path=read_path)
     if existing is None:
         return
     recorded = existing.get("agent_config_version")
     tools = list(existing.get("tools", []))
-    if recorded == version:
-        print(f"ℹ️  {lock_path} already records {version}.", file=out)
+    if recorded == version and read_path == write_path:
+        print(f"ℹ️  {write_path} already records {version}.", file=out)
         return
-    installed_lock.write_lockfile(version, tools, path=lock_path)
-    print(f"✅  Refreshed global lockfile at {lock_path}.", file=out)
+    installed_lock.write_lockfile(version, tools, path=write_path)
+    print(f"✅  Refreshed global lockfile at {write_path}.", file=out)
 
 
 def _detect_installed_version() -> str:

package/scripts/_lib/claude_desktop_bundler.py

@@ -2,21 +2,33 @@
 
 Claude Desktop has no filesystem convention for skills; the Customize →
 Skills UI accepts a ZIP per skill via the Upload button. This module
-walks ``<package_root>/.claude/skills/*`` and produces one
-``<skill-name>.zip`` per directory into ``dest_dir``.
+walks ``<package_root>/.agent-src/skills/*`` and produces one
+``<skill-name>.zip`` per directory into ``dest_dir``. It additionally
+walks ``<package_root>/.agent-src/commands/`` and produces one
+``<command-slug>.zip`` per command ``.md`` file so Claude Desktop sees
+the same surface that Claude Code exposes via the ``.claude/skills/``
+symlink wrapper layer.
 
 Contract:
 
 - Each ZIP contains ``SKILL.md`` plus every sibling file under the same
   directory (recursive). Symlinks are dereferenced so the ZIP is
   self-contained.
+- Command bundles wrap a single ``.agent-src/commands/<path>.md`` file
+  as ``SKILL.md`` inside the ZIP. Nested commands flatten to
+  ``<cluster>-<leaf>`` slugs (e.g. ``council/default.md`` →
+  ``council-default.zip``) to mirror ``compress.py``.
 - Exclusions: ``.git*``, ``__pycache__``, ``*.pyc`` — matched on the
   basename of any path component.
 - A skill folder without a ``SKILL.md`` is skipped (defensive: avoids
   shipping Claude-Code orchestrator stubs that don't follow the
   Anthropic skill schema).
+- Command files named ``AGENTS.md`` are skipped (cluster authoring docs,
+  not invocable commands).
+- A command slug that collides with an existing skill name is skipped —
+  the real skill bundle wins, matching ``compress.generate_claude_commands``.
 - Writes are atomic via tempfile → ``os.replace``.
-- Idempotent: each ZIP gets a sibling ``<skill-name>.sha256`` recording
+- Idempotent: each ZIP gets a sibling ``<slug>.sha256`` recording
   the manifest digest. If the recomputed digest matches the recorded
   one, the existing ZIP is left untouched (unless ``force=True``).
 """
@@ -51,8 +63,8 @@ def _walk_skill_files(skill_dir: Path) -> list[tuple[Path, tuple[str, ...]]]:
     """Return ``[(abs_path, rel_parts), ...]`` for every file in the skill.
 
     Symlinks are followed (``os.walk(..., followlinks=True)``) so a
-    bundle from a symlinked entry under ``.claude/skills/`` contains the
-    actual target content, not a dangling symlink.
+    bundle from a symlinked entry under ``.agent-src/skills/`` contains
+    the actual target content, not a dangling symlink.
     """
     out: list[tuple[Path, tuple[str, ...]]] = []
     resolved = skill_dir.resolve()
@@ -121,7 +133,7 @@ def build_skill_bundles(
     ``curation`` optionally restricts the build to the given skill
     names; ``None`` bundles every skill folder containing ``SKILL.md``.
     """
-    skills_root = package_root / ".claude" / "skills"
+    skills_root = package_root / ".agent-src" / "skills"
     if not skills_root.is_dir():
         return []
     dest_dir.mkdir(parents=True, exist_ok=True)
@@ -148,3 +160,79 @@ def build_skill_bundles(
         digest_path.write_text(digest + "\n", encoding="utf-8")
         written.append(zip_path)
     return written
+
+
+def _command_slug(source_file: Path, commands_root: Path) -> str:
+    """Return the flat slug for a command source file.
+
+    Mirrors ``scripts/compress.py::_command_slug``: top-level commands
+    keep their stem (``commit.md`` → ``commit``); nested commands flatten
+    the relative path with ``-`` (``council/default.md`` →
+    ``council-default``).
+    """
+    rel = source_file.relative_to(commands_root)
+    return "-".join(rel.with_suffix("").parts)
+
+
+def _iter_command_files(commands_root: Path) -> Iterable[Path]:
+    """Yield every command ``.md`` file under ``commands_root`` (recursive).
+
+    Skips ``AGENTS.md`` cluster authoring docs, matching
+    ``scripts/compress.py::_iter_commands``.
+    """
+    for source_file in sorted(commands_root.rglob("*.md")):
+        if source_file.name == "AGENTS.md":
+            continue
+        yield source_file
+
+
+def build_command_bundles(
+    package_root: Path,
+    dest_dir: Path,
+    force: bool = False,
+    curation: Optional[list[str]] = None,
+) -> list[Path]:
+    """Build per-command ZIPs under ``dest_dir``.
+
+    Each ZIP contains a single ``SKILL.md`` whose bytes are the source
+    command ``.md`` file — same wrapping pattern that
+    ``compress.generate_claude_commands`` uses for Claude Code via
+    ``.claude/skills/<slug>/SKILL.md`` symlinks.
+
+    Slugs that collide with an existing skill folder under
+    ``<package_root>/.agent-src/skills/`` are skipped so the real skill
+    bundle wins.
+
+    Returns the list of ZIP paths that were (re-)written this call. ZIPs
+    skipped because their content digest matched the existing sidecar
+    are not in the returned list (but remain on disk).
+
+    ``curation`` optionally restricts the build to the given command
+    slugs; ``None`` bundles every command file.
+    """
+    commands_root = package_root / ".agent-src" / "commands"
+    if not commands_root.is_dir():
+        return []
+    skills_root = package_root / ".agent-src" / "skills"
+    skill_names: set[str] = set()
+    if skills_root.is_dir():
+        skill_names = {entry.name for entry in skills_root.iterdir() if entry.is_dir()}
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    written: list[Path] = []
+    for source_file in _iter_command_files(commands_root):
+        slug = _command_slug(source_file, commands_root)
+        if slug in skill_names:
+            continue
+        if curation is not None and slug not in curation:
+            continue
+        files = [(source_file.resolve(), ("SKILL.md",))]
+        digest = _manifest_digest(files)
+        zip_path = dest_dir / f"{slug}.zip"
+        digest_path = dest_dir / f"{slug}.sha256"
+        recorded = digest_path.read_text(encoding="utf-8").strip() if digest_path.exists() else ""
+        if not force and recorded == digest and zip_path.exists():
+            continue
+        _atomic_write_zip(zip_path, files)
+        digest_path.write_text(digest + "\n", encoding="utf-8")
+        written.append(zip_path)
+    return written

package/scripts/_lib/installed_lock.py

@@ -50,7 +50,7 @@ _TOOL_RE = re.compile(r"^\s*-\s*([A-Za-z0-9_\-.]+)\s*$")
 
 
 def lockfile_path(env: Optional[dict] = None) -> Path:
-    """Return the active lockfile path, honoring the env override.
+    """Return the active lockfile path for **reads**, honoring overrides.
 
     Resolution order:
 
@@ -59,9 +59,10 @@ def lockfile_path(env: Optional[dict] = None) -> Path:
     3. ``~/.config/agent-config/installed.lock``  (legacy fallback, read-only).
     4. Canonical write target under the new namespace (Step 2 fallthrough).
 
-    Writers always end up at (4) when no lockfile exists yet; readers
-    benefit from (3) so pre-2.4 installs keep working while the
-    migration shim has not yet run.
+    Readers benefit from (3) so pre-2.4 installs keep working while the
+    migration shim has not yet run. Writers must use
+    :func:`lockfile_write_path` so a stale legacy file does not anchor
+    subsequent writes to the deprecated location.
     """
     env = env if env is not None else os.environ
     override = env.get(LOCKFILE_ENV)
@@ -73,6 +74,24 @@ def lockfile_path(env: Optional[dict] = None) -> Path:
     return user_global_paths.write_target("installed.lock", env=env)
 
 
+def lockfile_write_path(env: Optional[dict] = None) -> Path:
+    """Return the canonical write target for the lockfile.
+
+    Unlike :func:`lockfile_path`, this never falls back to the legacy
+    ``~/.config/agent-config/`` location. Honors the
+    ``$AGENT_CONFIG_INSTALLED_LOCK`` override for tests, otherwise pins
+    to ``~/.event4u/agent-config/installed.lock``. Callers in
+    ``init``, ``update``, and ``uninstall`` use this so writes always
+    land in the new namespace regardless of whether a stale legacy
+    lockfile is still present.
+    """
+    env = env if env is not None else os.environ
+    override = env.get(LOCKFILE_ENV)
+    if override:
+        return Path(override).expanduser()
+    return user_global_paths.write_target("installed.lock", env=env)
+
+
 def read_lockfile(path: Optional[Path] = None) -> Optional[dict]:
     """Parse ``path`` (or the default) into a dict; return ``None`` if absent.
 

package/scripts/install.py

@@ -2092,36 +2092,41 @@ PROJECT_BRIDGE_MARKERS = {
 #   ``_write_claude_desktop_marker`` rather than via this map.
 #
 # Tools that follow the markdown-skills convention (anchors lifted from
-# nextlevelbuilder/ui-ux-pro-max-skill) deploy ``.claude/skills`` —
-# the universal Anthropic-shaped skill bundle — into ``<anchor>/skills/``
-# (or ``<anchor>/steering/`` for kiro). ``.claude/rules`` is also copied
+# nextlevelbuilder/ui-ux-pro-max-skill) deploy the universal Anthropic-
+# shaped skill bundle — sourced from ``.agent-src/`` (the npm-shipped
+# canonical asset tree) — into ``<anchor>/skills/`` (or
+# ``<anchor>/steering/`` for kiro). ``.agent-src/rules`` is also copied
 # where the destination is a true rules-aware tool root.
+#
+# All source paths reference ``.agent-src/<subdir>`` because that is the
+# only asset tree included in the npm tarball (see ``package.json#files``).
+# The legacy ``.augment/``, ``.claude/``, ``.cursor/`` projections only
+# exist in the development checkout — they are not shipped.
 _CLAUDE_SKILL_BUNDLE: list[tuple[str, str]] = [
-    (".claude/rules",    "rules"),
-    (".claude/skills",   "skills"),
-    (".claude/personas", "personas"),
+    (".agent-src/rules",    "rules"),
+    (".agent-src/skills",   "skills"),
+    (".agent-src/personas", "personas"),
 ]
 GLOBAL_DEPLOY_SOURCES: dict[str, list[tuple[str, str]]] = {
     "claude-code": _CLAUDE_SKILL_BUNDLE,
     "augment": [
-        (".augment/rules",     "rules"),
-        (".augment/skills",    "skills"),
-        (".augment/commands",  "commands"),
-        (".augment/contexts",  "contexts"),
-        (".augment/personas",  "personas"),
-        (".augment/templates", "templates"),
+        (".agent-src/rules",     "rules"),
+        (".agent-src/skills",    "skills"),
+        (".agent-src/commands",  "commands"),
+        (".agent-src/contexts",  "contexts"),
+        (".agent-src/personas",  "personas"),
+        (".agent-src/templates", "templates"),
     ],
     "cursor": [
-        (".cursor/rules",    "rules"),
-        (".cursor/commands", "commands"),
-        (".cursor/personas", "personas"),
+        (".agent-src/rules",    "rules"),
+        (".agent-src/commands", "commands"),
+        (".agent-src/personas", "personas"),
     ],
     "windsurf": [
-        (".windsurf/rules",     "rules"),
-        (".windsurf/workflows", "workflows"),
+        (".agent-src/rules", "rules"),
     ],
     "cline": [
-        (".clinerules", ""),
+        (".agent-src/rules", ""),
     ],
     # Markdown-skills tools — mirror the universal skill bundle into the
     # tool-specific anchor. Subpath matches the reference repo's
@@ -2142,9 +2147,9 @@ GLOBAL_DEPLOY_SOURCES: dict[str, list[tuple[str, str]]] = {
     # Kiro reads from `steering/` not `skills/` (per
     # platforms/kiro.json#folderStructure.skillPath).
     "kiro": [
-        (".claude/rules",    "rules"),
-        (".claude/skills",   "steering"),
-        (".claude/personas", "personas"),
+        (".agent-src/rules",    "rules"),
+        (".agent-src/skills",   "steering"),
+        (".agent-src/personas", "personas"),
     ],
 }
 
@@ -2883,6 +2888,7 @@ def _deploy_claude_desktop(
     bundler = _load_claude_desktop_bundler_module()
     bundles_dir = _claude_desktop_bundles_dir()
     bundler.build_skill_bundles(package_root, bundles_dir, force=force)
+    bundler.build_command_bundles(package_root, bundles_dir, force=force)
     # Count total existing ZIPs (idempotent runs may not rewrite any).
     bundle_count = sum(1 for _ in bundles_dir.glob("*.zip")) if bundles_dir.is_dir() else 0
     _, _, marker_paths = _write_claude_desktop_marker(
@@ -2988,14 +2994,15 @@ def install_global(
 
     lock_mod = _load_installed_lock_module()
     installed_version = lock_mod.current_package_version()
-    lock_path = lock_mod.lockfile_path()
-    ok, recorded = lock_mod.check_version(installed_version, path=lock_path)
+    read_path = lock_mod.lockfile_path()
+    write_path = lock_mod.lockfile_write_path()
+    ok, recorded = lock_mod.check_version(installed_version, path=read_path)
 
     if not ok and not force:
         if not QUIET:
             print()
             warn("Refusing global install: lockfile version mismatch.")
-            info(f"  Lockfile:           {lock_path}")
+            info(f"  Lockfile:           {read_path}")
             info(f"  Recorded version:   {recorded}")
             info(f"  Current package:    {installed_version}")
             info("  Fix:                run `agent-config update`")
@@ -3013,10 +3020,10 @@ def install_global(
                 continue
             print(f"      {tool_id:<15} → {anchor}")
 
-    existing = lock_mod.read_lockfile(path=lock_path) or {}
+    existing = lock_mod.read_lockfile(path=read_path) or {}
     existing_tools = list(existing.get("tools", []))
     merged_tools = sorted(set(existing_tools) | set(tools))
-    written = lock_mod.write_lockfile(installed_version, merged_tools, path=lock_path)
+    written = lock_mod.write_lockfile(installed_version, merged_tools, path=write_path)
 
     if not QUIET:
         print()