agent-toolkit-cli 1.0.10__tar.gz → 1.2.0__tar.gz

{agent_toolkit_cli-1.0.10 → agent_toolkit_cli-1.2.0}/.gitignore

@@ -23,3 +23,9 @@ build/
 # Editor
 .idea/
 .vscode/settings.json
+# Loop run artifacts (machine-specific state)
+loops/*/runs/
+loops/*/STATE.md
+
+# Git worktrees
+.worktrees/

{agent_toolkit_cli-1.0.10 → agent_toolkit_cli-1.2.0}/CHANGELOG.md

@@ -84,6 +84,107 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   (`agent-toolkit-server`, `agent-toolkit-mcp`, etc.)
 - Root `pyproject.toml` with `[tool.uv.workspace]` and shared dev tooling
 
+## [1.1.0] — 2026-08-04
+
+### Added — Full workspace capability
+
+agent-toolkit is now a complete workspace toolkit. Every capability from
+~/.ai-workspace and agentic-harness is available as a CLI subcommand:
+
+**`agent-toolkit workspace`** — Workspace scaffolding and session context
+- `workspace init [--dir PATH]` — scaffold harness workspace (AGENTS.md, knowledge/, packs/, personas/, loops/, projects/, repos/)
+- `workspace context` — session state snapshot for AI session start
+- `workspace sync` — sync loop escalations into knowledge todos
+
+**`agent-toolkit memory`** — Persistent knowledge base (replaces bin/assistant-memory)
+- `memory add --type <learning|process|todo> "content"` — add to knowledge base
+- `memory search "query"` — search all knowledge files
+- `memory inject` — output full knowledge context block for AI session
+- `memory review` — show stale entries
+- `memory todo` — list pending todos
+
+**`agent-toolkit project`** — Project clone and symlink manager (replaces bin/project-indexer)
+- `project clone owner/repo` — clone + symlink into projects/
+- `project list` — list indexed projects
+- `project add <path>` — symlink existing repo
+- `project remove <name>` — remove symlink
+- `project scan` — consistency check
+
+**`agent-toolkit devcompanion`** — Background job queue (replaces bin/devcompanion)
+- `devcompanion queue <project> [--request "..."] [--template NAME]` — queue a job
+- `devcompanion run-once [--no-llm]` — execute oldest pending job
+- `devcompanion status` — show all jobs
+- `devcompanion done <job-id>` — mark job complete
+- `devcompanion sync-todos` — sync plan.md todos to knowledge
+
+**`agent-toolkit insights`** — AI tool usage analytics (replaces bin/tool-insights)
+- `insights opencode` — OpenCode sessions from SQLite DB
+- `insights cursor` — Cursor agent transcripts
+- `insights claude` — Claude Code sessions
+- `insights all` — aggregate across all tools
+
+**Templates** — workspace scaffold templates bundled in the wheel
+- 12 CLI modules, 42 template files (AGENTS.md, personas, knowledge, etc.)
+- `agent-toolkit workspace init` = what agentic-harness now scaffolds from
+
+**Profile updates** — Claude Code, Cursor, OpenCode, Windsurf profiles updated with
+agent-toolkit CLI reference and session-start protocol
+
+### Changed
+- agentic-harness: bin/workspace-context and bin/assistant-memory are now
+  thin wrappers that delegate to agent-toolkit CLI
+
+## [1.2.0] — 2026-08-04
+
+### Added — Native multi-runtime compiler platform (Phases 3-7)
+
+The canonical compiler pipeline now generates native artifacts for 9 AI coding targets:
+
+**Compiler targets:**
+- Claude Code (plugin — .claude-plugin/) — stable GA
+- Cursor IDE/CLI (plugin — .cursor-plugin/) — stable GA
+- GitHub Copilot CLI (plugin — plugin.json) — stable GA
+- GitHub Copilot Repository (.github/ assets) — stable GA
+- Gemini CLI (extension — gemini-extension.json + commands.toml) — stable GA
+- OpenCode (companion-assets — .opencode/) — stable
+- Pi Coding Agent (companion-assets — pi-package.json) — stable
+- Windsurf/Devin (customization-bundle — rules + AGENTS.md) — accurately labeled (no marketplace)
+- OpenAI Codex (plugin — .codex-plugin/) — experimental
+
+**Canonical compiler pipeline:**
+- `distributions/products.yaml` — declarative product catalog
+- `src/agent_toolkit/compiler/` — model, loader, targets/
+- `agent-toolkit build` — compile to any target
+- `agent-toolkit diff` — show changes vs installed
+- `agent-toolkit inventory` — list all capabilities
+- `agent-toolkit matrix` — platform capability matrix
+- `agent-toolkit release --dry-run` — generate dist/ artifacts + checksums
+
+**MCP and hooks:**
+- `mcp/registry/` — canonical registry for 6 providers (github, slack, notion, linear, figma, clickup)
+- `capabilities/hooks/` — canonical hook definitions with platform parity matrix
+- `schemas/hook.schema.yaml` — JSON Schema for hook definitions
+
+**Testing (418 tests):**
+- Contract tests for all 9 compiler adapters
+- Golden/snapshot tests for deterministic output
+- Security tests: path traversal, secret redaction
+- Installer receipt tests
+- MCP registry tests
+- Hook registry tests
+- Provenance/diff tests
+
+**Docs:**
+- `docs/TARGETS.md` — honest capability matrix for all 9 targets
+- `docs/research/` — platform capability matrix, source ledger, audit
+- `docs/adrs/` — ADR-001 (canonical IR), ADR-002 (Windsurf bundle)
+- `docs/security/` — threat model
+
+### Security
+- Removed `skipDangerousModePermissionPrompt` from Claude Code profile
+- Replaced private LAN URLs in OpenCode profile with portable defaults
+- Updated schema `$id` to remove stale agentic-workstation references
+
 ## [Unreleased]
 
 ### Added

agent_toolkit_cli-1.2.0/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: agent-toolkit-cli
+Version: 1.2.0
+Summary: Composable AI agent toolkit — loops, skills, profiles, and MCP for Claude Code, Cursor, OpenCode, Windsurf, and more
+Project-URL: Homepage, https://github.com/ulises-jeremias/agent-toolkit
+Project-URL: Repository, https://github.com/ulises-jeremias/agent-toolkit.git
+Project-URL: Issues, https://github.com/ulises-jeremias/agent-toolkit/issues
+Project-URL: Changelog, https://github.com/ulises-jeremias/agent-toolkit/blob/main/CHANGELOG.md
+License: MIT License
+        
+        Copyright (c) 2026 Ulises Jeremias
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: agent-toolkit,agent-toolkit-cli,ai-agents,claude-code,cursor,github-copilot,loops,mcp,opencode,skills,windsurf
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.10
+Provides-Extra: all
+Requires-Dist: pyyaml>=6.0; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: yaml
+Requires-Dist: pyyaml>=6.0; extra == 'yaml'
+Description-Content-Type: text/markdown
+
+# agent-toolkit-cli
+
+Published Python package for [agent-toolkit](https://github.com/ulises-jeremias/agent-toolkit).
+
+Install:
+
+```bash
+uvx agent-toolkit-cli version
+# or
+uv tool install agent-toolkit-cli
+```
+
+Canonical sources and docs live in the monorepo root.

agent_toolkit_cli-1.2.0/README.md

@@ -0,0 +1,13 @@
+# agent-toolkit-cli
+
+Published Python package for [agent-toolkit](https://github.com/ulises-jeremias/agent-toolkit).
+
+Install:
+
+```bash
+uvx agent-toolkit-cli version
+# or
+uv tool install agent-toolkit-cli
+```
+
+Canonical sources and docs live in the monorepo root.

{agent_toolkit_cli-1.0.10 → agent_toolkit_cli-1.2.0}/pyproject.toml

@@ -11,7 +11,7 @@ license = { file = "LICENSE" }
 requires-python = ">=3.10"
 keywords = [
     "ai-agents", "claude-code", "cursor", "opencode", "windsurf",
-    "github-copilot", "skills", "loops", "mcp", "agent-toolkit", "agent-toolkit-cli"
+    "github-copilot", "skills", "loops", "mcp", "agent-toolkit", "agent-toolkit-cli",
 ]
 classifiers = [
     "Development Status :: 4 - Beta",
@@ -26,11 +26,11 @@ classifiers = [
     "Topic :: Software Development :: Libraries :: Application Frameworks",
     "Topic :: Scientific/Engineering :: Artificial Intelligence",
 ]
-dependencies = []  # Zero external dependencies — stdlib only
+dependencies = []
 
 [project.optional-dependencies]
 dev = ["pytest>=7.0", "ruff>=0.1.0"]
-yaml = ["pyyaml>=6.0"]      # Better YAML parsing (fallback: built-in mini-parser)
+yaml = ["pyyaml>=6.0"]
 all = ["pyyaml>=6.0"]
 
 [project.scripts]
@@ -43,58 +43,20 @@ Repository = "https://github.com/ulises-jeremias/agent-toolkit.git"
 Issues = "https://github.com/ulises-jeremias/agent-toolkit/issues"
 Changelog = "https://github.com/ulises-jeremias/agent-toolkit/blob/main/CHANGELOG.md"
 
+[tool.hatch.version]
+path = "src/agent_toolkit/__init__.py"
+
 [tool.hatch.build.targets.wheel]
 packages = ["src/agent_toolkit"]
 
+# Capability trees are copied into src/agent_toolkit/data/ by
+# scripts/prepare-package-data.sh before sdist/wheel builds. Editable
+# installs resolve monorepo root via agent_toolkit._paths (no packed data).
 [tool.hatch.build.targets.sdist]
 include = [
     "src/",
-    "skills/",
-    "agents/",
-    "loops/",
-    "profiles/",
-    "mcp/",
-    "plugins/",
-    "catalogs/",
-    "schemas/",
-    "scripts/",
-    "examples/",
-    "docs/",
-    "LICENSE",
     "README.md",
+    "LICENSE",
     "CHANGELOG.md",
-    "AGENTS.md",
+    "pyproject.toml",
 ]
-
-[tool.ruff]
-line-length = 100
-target-version = "py310"
-
-[tool.ruff.lint]
-select = ["E", "F", "I"]
-ignore = ["E501"]
-
-[tool.pytest.ini_options]
-testpaths = ["tests"]
-addopts = "-v --tb=short"
-
-[tool.hatch.version]
-path = "src/agent_toolkit/__init__.py"
-
-[tool.hatch.build.targets.wheel.shared-data]
-# Include non-Python data directories so they are accessible at runtime
-# via importlib.resources or the bundled data path.
-"skills/" = "agent_toolkit/data/skills"
-"loops/" = "agent_toolkit/data/loops"
-"profiles/" = "agent_toolkit/data/profiles"
-"mcp/" = "agent_toolkit/data/mcp"
-"agents/" = "agent_toolkit/data/agents"
-"catalogs/" = "agent_toolkit/data/catalogs"
-
-[tool.hatch.build.targets.wheel.force-include]
-"profiles" = "agent_toolkit/data/profiles"
-"loops" = "agent_toolkit/data/loops"
-"skills" = "agent_toolkit/data/skills"
-"mcp" = "agent_toolkit/data/mcp"
-"agents" = "agent_toolkit/data/agents"
-"catalogs" = "agent_toolkit/data/catalogs"

{agent_toolkit_cli-1.0.10/packages/agent-toolkit-cli → agent_toolkit_cli-1.2.0}/src/agent_toolkit/__init__.py

@@ -1,4 +1,4 @@
 """agent-toolkit: Composable AI agent capabilities for all major AI coding tools."""
 
-__version__ = "1.0.10"
+__version__ = "1.2.0"
 __author__ = "ulises-jeremias"

agent_toolkit_cli-1.2.0/src/agent_toolkit/_paths.py

@@ -0,0 +1,144 @@
+"""Shared toolkit path resolution — works in both editable and wheel installs."""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+def _offline_mode() -> bool:
+    return os.environ.get("AGENT_TOOLKIT_OFFLINE", "").strip().lower() in ("1", "true", "yes")
+
+
+def _bundled_data_paths() -> list[Path]:
+    paths: list[Path] = []
+    try:
+        import importlib.resources as _ir
+
+        paths.append(Path(str(_ir.files("agent_toolkit").joinpath("data"))))
+    except (ImportError, TypeError, ModuleNotFoundError, FileNotFoundError):
+        pass
+
+    pkg_dir = Path(__file__).resolve().parent
+    paths.append(pkg_dir / "data")
+    return paths
+
+
+def _is_data_root(path: Path) -> bool:
+    return path.is_dir() and (path / "profiles").is_dir()
+
+
+def find_toolkit_root(*, offline: bool | None = None) -> Path:
+    """
+    Locate the agent-toolkit root directory (where skills/, loops/, profiles/ live).
+
+    Resolution order:
+    1. AGENT_TOOLKIT_ROOT / AI_WORKSPACE env var (user override)
+    2. importlib.resources / package data (wheel install)
+    3. XDG cache (~/.local/share/agent-toolkit/data) or first-run GitHub download
+    4. Walk up from module file (editable install)
+    5. CWD fallback
+
+    Raises EnvironmentError if no root can be found with required subdirs.
+    """
+    offline = _offline_mode() if offline is None else offline
+
+    for env in ("AGENT_TOOLKIT_ROOT", "AI_WORKSPACE"):
+        val = os.environ.get(env, "").strip()
+        if val:
+            p = Path(val)
+            if (p / "skills").is_dir() or (p / "loops").is_dir() or _is_data_root(p):
+                return p
+
+    for data_path in _bundled_data_paths():
+        if _is_data_root(data_path):
+            return data_path
+
+    # 2b. XDG cache (GitHub Release download on first run — see data_cache.py)
+    if os.environ.get("AGENT_TOOLKIT_OFFLINE", "").strip() not in ("1", "true", "yes"):
+        try:
+            from agent_toolkit.data_cache import ensure_cached_data
+
+            cached = ensure_cached_data(offline=False)
+            if cached and (cached / "profiles").is_dir():
+                return cached
+        except Exception:
+            pass
+    else:
+        cache_home = Path(os.environ.get("XDG_CACHE_HOME", str(Path.home() / ".cache")))
+        cached_data = cache_home / "agent-toolkit"
+        if (cached_data / "profiles").is_dir():
+            return cached_data
+
+    # 2c. Direct path relative to the package (uvx / pip installs)
+    pkg_dir = Path(__file__).resolve().parent  # .../site-packages/agent_toolkit/
+    data_dir = pkg_dir / "data"
+    if data_dir.is_dir() and (data_dir / "profiles").is_dir():
+        return data_dir
+
+    here = Path(__file__).resolve()
+    for parent in here.parents:
+        if (parent / "skills").is_dir() and (parent / "loops").is_dir():
+            return parent
+
+    cwd = Path.cwd()
+    if (cwd / "skills").is_dir() or (cwd / "loops").is_dir():
+        return cwd
+
+    hint = (
+        "Set AGENT_TOOLKIT_ROOT to your agent-toolkit checkout, "
+        "or run without --offline to download data on first use."
+    )
+    if offline:
+        hint = (
+            "Offline mode: bundled/cache data missing. "
+            "Install the full wheel or populate ~/.local/share/agent-toolkit/data."
+        )
+    raise EnvironmentError(f"Cannot locate agent-toolkit data directory.\n{hint}")
+
+
+_root: Path | None = None
+
+
+def reset_toolkit_root() -> None:
+    """Clear cached toolkit root (e.g. after toggling offline mode)."""
+    global _root
+    _root = None
+
+
+def toolkit_root(*, offline: bool | None = None) -> Path:
+    """Cached toolkit root."""
+    global _root
+    if _root is None or offline is not None:
+        resolved = find_toolkit_root(offline=offline)
+        if offline is None:
+            _root = resolved
+        return resolved
+    return _root
+
+
+def find_workspace_root(*, override: str | None = None) -> Path | None:
+    """Locate the user harness / AI workspace root (not toolkit package data).
+
+    Resolution order (#207):
+    1. Explicit override (CLI ``--workspace``)
+    2. ``AGENT_TOOLKIT_WORKSPACE``
+    3. ``HARNESS_DIR`` (agentic-harness compatibility)
+    4. Walk up from CWD for ``AGENTS.md`` or ``knowledge/``
+    """
+    if override:
+        p = Path(override).expanduser().resolve()
+        return p if p.is_dir() else None
+
+    for env in ("AGENT_TOOLKIT_WORKSPACE", "HARNESS_DIR"):
+        val = os.environ.get(env, "").strip()
+        if val:
+            p = Path(val).expanduser().resolve()
+            if p.is_dir():
+                return p
+
+    current = Path.cwd()
+    for candidate in [current, *current.parents]:
+        if (candidate / "AGENTS.md").exists() or (candidate / "knowledge").is_dir():
+            return candidate
+
+    return None

agent_toolkit_cli-1.2.0/src/agent_toolkit/cli/build.py

@@ -0,0 +1,246 @@
+"""
+build — Compile canonical capabilities into target-specific artifacts.
+
+Usage:
+    agent-toolkit build [--target TARGET] [--product PRODUCT] [--check] [--output DIR]
+
+Options:
+    --target TARGET    Target platform (claude-code, cursor, etc.)
+    --product PRODUCT  Product ID to compile (agent-toolkit-core, etc.)
+    --check            Dry-run: validate without writing files
+    --output DIR       Output directory (default: plugins/)
+    --json             Output results as JSON
+    --help             Show this help
+
+Examples:
+    agent-toolkit build --target claude-code --product agent-toolkit-core
+    agent-toolkit build --check
+    agent-toolkit inventory
+    agent-toolkit matrix
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+from agent_toolkit._paths import toolkit_root
+
+import sys as _sys
+if _sys.platform == 'win32':
+    try:
+        _sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+        _sys.stderr.reconfigure(encoding='utf-8', errors='replace')
+    except Exception:
+        pass
+
+
+def _find_repo_root() -> Path:
+    """Find the repo root (where distributions/ lives)."""
+    root = toolkit_root()
+    # Prefer root with distributions/ directory
+    if (root / "distributions").is_dir():
+        return root
+    # Try package data parent
+    if (root.parent / "distributions").is_dir():
+        return root.parent
+    return root
+
+
+def cmd_build(args: list[str]) -> int:
+    """Build canonical capabilities into target-native artifacts."""
+    import argparse
+
+    parser = argparse.ArgumentParser(prog="agent-toolkit build", add_help=False)
+    parser.add_argument("--target", default=None)
+    parser.add_argument("--product", default=None)
+    parser.add_argument("--check", action="store_true")
+    parser.add_argument("--output", default=None)
+    parser.add_argument("--json", dest="json_out", action="store_true")
+    parser.add_argument("--help", "-h", action="store_true")
+
+    parsed, _ = parser.parse_known_args(args)
+
+    if parsed.help:
+        print(__doc__)
+        return 0
+
+    repo_root = _find_repo_root()
+    json_mode = parsed.json_out
+
+    def _say(*args, **kwargs):
+        if not json_mode:
+            print(*args, **kwargs)
+
+    try:
+        from agent_toolkit.compiler.loader import load_graph
+    except ImportError as e:
+        print(f"  ✗  Compiler not available: {e}", file=sys.stderr)
+        return 1
+
+    _say("\nLoading canonical graph...")
+    graph = load_graph(repo_root)
+
+    if graph.errors:
+        print(f"  ✗  {len(graph.errors)} error(s) loading canonical sources:", file=sys.stderr)
+        for err in graph.errors:
+            print(f"     {err}", file=sys.stderr)
+        return 1
+
+    if graph.warnings:
+        for w in graph.warnings:
+            _say(f"  ⚠  {w}")
+
+    _say(f"  ✓  {len(graph.skills)} skills, {len(graph.agents)} agents, "
+         f"{len(graph.products)} products loaded")
+
+    # Select products to build
+    products_to_build = list(graph.products.values())
+    if parsed.product:
+        if parsed.product not in graph.products:
+            print(f"  ✗  Product '{parsed.product}' not found", file=sys.stderr)
+            print(f"     Available: {', '.join(graph.products)}", file=sys.stderr)
+            return 1
+        products_to_build = [graph.products[parsed.product]]
+
+    # Select targets
+    available_targets = {"claude-code", "cursor", "opencode", "gemini-cli", "copilot-cli", "copilot-repository", "pi", "windsurf", "codex"}  # expand as adapters are added
+    targets_to_build = [parsed.target] if parsed.target else list(available_targets)
+
+    for t in targets_to_build:
+        if t not in available_targets:
+            print(f"  ✗  Unknown target '{t}'. Available: {', '.join(sorted(available_targets))}", file=sys.stderr)
+            return 1
+
+    output_dir = Path(parsed.output) if parsed.output else repo_root / "plugins"
+    mode = "check" if parsed.check else "build"
+    _say(f"\nMode: {mode}  Output: {output_dir}\n")
+
+    all_results = []
+    exit_code = 0
+
+    for target_id in targets_to_build:
+        adapter = _get_adapter(target_id, output_dir, repo_root)
+        if adapter is None:
+            _say(f"  ⚠  No adapter for target '{target_id}' — skipping")
+            continue
+
+        for product in products_to_build:
+            _say(f"  Building {product.id} → {target_id}...")
+            adapter._provenance_records = []
+            if parsed.check:
+                result = adapter.check(graph, product)
+            else:
+                result = adapter.compile(graph, product)
+                if hasattr(adapter, "_finalize_provenance"):
+                    adapter._finalize_provenance(product, result)
+
+            all_results.append(result)
+            _say(result.report())
+            _say()
+
+            if not result.is_valid:
+                exit_code = 1
+
+    if json_mode:
+        out = [
+            {
+                "target": r.target,
+                "product": r.product,
+                "emitted": r.emitted,
+                "transformed": r.transformed,
+                "omitted": r.omitted,
+                "unsupported": r.unsupported,
+                "warnings": r.warnings,
+                "errors": r.errors,
+                "artifacts": [str(a) for a in r.artifacts],
+            }
+            for r in all_results
+        ]
+        print(json.dumps(out, indent=2))
+
+    return exit_code
+
+
+def cmd_inventory(args: list[str]) -> int:
+    """List all canonical capabilities."""
+    repo_root = _find_repo_root()
+    from agent_toolkit.compiler.loader import load_graph
+
+    graph = load_graph(repo_root)
+
+    print("\n═══ agent-toolkit Inventory ═══\n")
+
+    # Skills by domain
+    by_domain: dict[str, list] = {}
+    for skill in sorted(graph.skills.values(), key=lambda s: s.id):
+        by_domain.setdefault(skill.domain, []).append(skill)
+
+    print(f"Skills: {len(graph.skills)} across {len(by_domain)} domains\n")
+    for domain, skills in sorted(by_domain.items()):
+        print(f"  {domain}/ ({len(skills)})")
+        for s in skills:
+            desc = s.description[:60] + "…" if len(s.description) > 60 else s.description
+            print(f"    ✓  {s.name:<40} {desc}")
+
+    print(f"\nAgents: {len(graph.agents)}")
+    for agent in sorted(graph.agents.values(), key=lambda a: a.name):
+        desc = agent.description[:60] + "…" if len(agent.description) > 60 else agent.description
+        print(f"  ✓  {agent.name:<40} {desc}")
+
+    print(f"\nProducts: {len(graph.products)}")
+    for product in sorted(graph.products.values(), key=lambda p: p.id):
+        print(f"  ✓  {product.id}")
+        print(f"     skills: {len(product.included_skills)}  "
+              f"agents: {len(product.included_agents)}")
+
+    if graph.errors:
+        print(f"\nErrors: {len(graph.errors)}")
+        for e in graph.errors:
+            print(f"  ✗ {e}")
+
+    return 0
+
+
+def cmd_matrix(args: list[str]) -> int:
+    """Show platform capability matrix from research docs."""
+    AT = _find_repo_root()
+    matrix_path = AT / "docs" / "research" / "platform-capability-matrix.md"
+    if matrix_path.exists():
+        print(matrix_path.read_text())
+    else:
+        print("Matrix not found. Run the research pipeline first.")
+        print(f"Expected at: {matrix_path}")
+    return 0
+
+
+def _get_adapter(target_id: str, output_dir: Path, repo_root: Path):
+    """Return the adapter for a given target ID."""
+    if target_id == "claude-code":
+        from agent_toolkit.compiler.targets.claude_code import ClaudeCodeAdapter
+        return ClaudeCodeAdapter(output_dir, repo_root)
+    if target_id == "cursor":
+        from agent_toolkit.compiler.targets.cursor import CursorAdapter
+        return CursorAdapter(output_dir, repo_root)
+    if target_id in ("gemini-cli", "gemini"):
+        from agent_toolkit.compiler.targets.gemini_cli import GeminiCLIAdapter
+        return GeminiCLIAdapter(output_dir, repo_root)
+    if target_id in ("copilot-cli", "copilot"):
+        from agent_toolkit.compiler.targets.copilot import CopilotCLIAdapter
+        return CopilotCLIAdapter(output_dir, repo_root)
+    if target_id == "copilot-repository":
+        from agent_toolkit.compiler.targets.copilot import CopilotRepositoryAdapter
+        return CopilotRepositoryAdapter(output_dir, repo_root)
+    if target_id == "pi":
+        from agent_toolkit.compiler.targets.pi import PiAdapter
+        return PiAdapter(output_dir, repo_root)
+    if target_id == "windsurf":
+        from agent_toolkit.compiler.targets.windsurf import WindsurfAdapter
+        return WindsurfAdapter(output_dir, repo_root)
+    if target_id == "codex":
+        from agent_toolkit.compiler.targets.codex import CodexAdapter
+        return CodexAdapter(output_dir, repo_root)
+    if target_id == "opencode":
+        from agent_toolkit.compiler.targets.opencode import OpenCodeAdapter
+        return OpenCodeAdapter(output_dir, repo_root)
+    return None