@softspark/ai-toolkit 4.12.0 → 4.13.0

package/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "4.12.0",
+  "version": "4.13.0",
   "components": {
     "agents": {
       "description": "44 specialized agents (orchestrator, backend, frontend, security, devops, etc.)",
@@ -9,14 +9,14 @@
       "tags": ["core", "agents"]
     },
     "skills": {
-      "description": "107 skills (32 task + 30 hybrid + 45 knowledge)",
+      "description": "108 skills (32 task + 30 hybrid + 46 knowledge)",
       "path": "app/skills",
       "target": ".claude/skills",
       "type": "symlink",
       "tags": ["core", "skills", "commands"]
     },
     "hooks": {
-      "description": "28 hook entries across 14 lifecycle events",
+      "description": "28 hook entries across 14 lifecycle events plus statusLine",
       "path": "app/hooks.json + app/hooks/*.sh",
       "target": "~/.claude/settings.json (merge) + ~/.softspark/ai-toolkit/hooks/ (copy)",
       "type": "merge+copy",
@@ -30,7 +30,7 @@
       "tags": ["plugins", "packs", "experimental"]
     },
     "constitution": {
-      "description": "6-article machine-enforced safety constitution",
+      "description": "7-article machine-enforced safety constitution",
       "path": "app/constitution.md",
       "target": ".claude/constitution.md",
       "type": "symlink",
@@ -51,10 +51,10 @@
       "tags": ["core", "output-styles"]
     },
     "rules": {
-      "description": "Auto-injected rules for CLAUDE.md (jira, quality-gates, etc.)",
+      "description": "Rules synced to Claude Code rule files and exported as a Claude app plugin skill",
       "path": "app/rules",
-      "target": "CLAUDE.md (injected)",
-      "type": "injection",
+      "target": "~/.claude/rules + .claude/rules + Claude app plugin skill",
+      "type": "sync+plugin",
       "tags": ["core", "rules"]
     }
   },
@@ -90,7 +90,7 @@
       "default": true
     },
     "skills": {
-      "description": "107 skills (task, hybrid, knowledge)",
+      "description": "108 skills (task, hybrid, knowledge)",
       "default": true
     },
     "rules-common": {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@softspark/ai-toolkit",
-  "version": "4.12.0",
-  "description": "AI coding toolkit: 108 skills, 44 agents, 12-editor write-through (Claude, Cursor, Windsurf, Copilot, Gemini, Cline, Roo, Aider, Augment, Antigravity, Codex, opencode), machine-enforced safety constitution, SARIF audit, signed npm provenance.",
+  "version": "4.13.0",
+  "description": "AI coding toolkit: 108 skills, 44 agents, 12 developer-tool integrations plus Claude Chat/Cowork plugin export, machine-enforced safety constitution, SARIF audit, signed npm provenance.",
   "keywords": [
     "claude",
     "claude-code",
@@ -66,7 +66,8 @@
     "generate:windsurf-rules": "python3 scripts/generate_windsurf_rules.py .",
     "generate:roo-rules": "python3 scripts/generate_roo_rules.py .",
     "generate:augment-rules": "python3 scripts/generate_augment_rules.py .",
-    "generate:all": "npm run generate:language-rules && npm run generate:agents && npm run generate:opencode-agents && npm run generate:opencode-commands && npm run generate:cursor && npm run generate:cursor-mdc && npm run generate:windsurf && npm run generate:windsurf-rules && npm run generate:copilot && npm run generate:gemini && npm run generate:cline && npm run generate:roo && npm run generate:roo-rules && npm run generate:aider && npm run generate:augment-rules && npm run generate:llms"
+    "generate:claude-app": "python3 scripts/claude_app.py sync",
+    "generate:all": "npm run generate:language-rules && npm run generate:claude-app && npm run generate:agents && npm run generate:opencode-agents && npm run generate:opencode-commands && npm run generate:cursor && npm run generate:cursor-mdc && npm run generate:windsurf && npm run generate:windsurf-rules && npm run generate:copilot && npm run generate:gemini && npm run generate:cline && npm run generate:roo && npm run generate:roo-rules && npm run generate:aider && npm run generate:augment-rules && npm run generate:llms"
   },
   "files": [
     "bin/",

package/scripts/claude_app.py

@@ -0,0 +1,347 @@
+#!/usr/bin/env python3
+"""Build and verify the uploadable ai-toolkit plugin for the Claude app.
+
+Claude Code reads ``~/.claude`` directly. Claude Chat and Cowork do not: they
+load customizations through the Claude app plugin/skill UI. This command turns
+the canonical ``app/`` sources into a self-contained plugin archive that can be
+uploaded from Customize > Plugins.
+
+Usage:
+    claude_app.py sync
+    claude_app.py export [--output FILE] [--no-custom-rules] [--verify]
+    claude_app.py verify
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+import stat
+import subprocess
+import sys
+import tempfile
+import zipfile
+from pathlib import Path
+
+
+TOOLKIT_DIR = Path(__file__).resolve().parent.parent
+APP_DIR = TOOLKIT_DIR / "app"
+CLAUDE_APP_DIR = APP_DIR / "claude-app"
+PLUGIN_HOOKS_PATH = CLAUDE_APP_DIR / "hooks" / "hooks.json"
+PLUGIN_RULES_SKILL_PATH = CLAUDE_APP_DIR / "skills" / "ai-toolkit-rules" / "SKILL.md"
+GLOBAL_INSTRUCTIONS_PATH = CLAUDE_APP_DIR / "global-instructions.md"
+REGISTERED_RULES_DIR = Path.home() / ".softspark" / "ai-toolkit" / "rules"
+
+PLUGIN_SCRIPT_FILES = (
+    "paths.py",
+    "session_state.py",
+    "test_cohesion.py",
+    "version_check.py",
+)
+RULE_FILES = tuple(sorted((APP_DIR / "rules").glob("*.md"))) + tuple(
+    sorted((APP_DIR / "rules" / "common").glob("*.md"))
+)
+SKIP_NAMES = {"__pycache__", ".DS_Store"}
+FIXED_ZIP_TIME = (2026, 1, 1, 0, 0, 0)
+
+
+def _write_text(path: Path, content: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content.rstrip() + "\n", encoding="utf-8")
+
+
+def _strip_frontmatter(content: str) -> str:
+    lines = content.splitlines()
+    if not lines or lines[0].strip() != "---":
+        return content.strip()
+    for index in range(1, len(lines)):
+        if lines[index].strip() == "---":
+            return "\n".join(lines[index + 1 :]).strip()
+    return content.strip()
+
+
+def render_plugin_hooks() -> str:
+    """Render plugin-owned hooks from the global-install hook manifest."""
+    source = json.loads((APP_DIR / "hooks.json").read_text(encoding="utf-8"))
+    hooks = source.get("hooks", {})
+
+    def adapt(value):
+        if isinstance(value, dict):
+            return {
+                key: adapt(item)
+                for key, item in value.items()
+                if key != "_source"
+            }
+        if isinstance(value, list):
+            return [adapt(item) for item in value]
+        if isinstance(value, str):
+            adapted = value.replace(
+                "$HOME/.softspark/ai-toolkit/hooks/",
+                "${CLAUDE_PLUGIN_ROOT}/hooks/",
+            )
+            if "${CLAUDE_PLUGIN_ROOT}/hooks/" in adapted:
+                adapted = f'AI_TOOLKIT_DIR="${{CLAUDE_PLUGIN_ROOT}}" {adapted}'
+            return adapted
+        return value
+
+    return json.dumps({"hooks": adapt(hooks)}, indent=2, ensure_ascii=False) + "\n"
+
+
+def render_rules_skill(extra_rules: tuple[Path, ...] = ()) -> str:
+    """Render always-relevant engineering rules as a Claude app skill."""
+    parts = [
+        "---",
+        "name: ai-toolkit-rules",
+        'description: "Mandatory engineering, security, testing, git, performance, quality, and response rules. Claude MUST load this skill for every technical, coding, debugging, review, architecture, DevOps, data, or file-editing task in Chat or Cowork."',
+        "user-invocable: true",
+        "---",
+        "",
+        "# AI Toolkit Rules",
+        "",
+        "Apply every relevant rule below before acting. Treat MUST/NEVER language as mandatory.",
+    ]
+    for rule_file in (*RULE_FILES, *extra_rules):
+        try:
+            label = rule_file.relative_to(TOOLKIT_DIR)
+        except ValueError:
+            label = Path("registered") / rule_file.name
+        body = _strip_frontmatter(rule_file.read_text(encoding="utf-8"))
+        parts.extend(("", f"## Source: `{label}`", "", body))
+    return "\n".join(parts).rstrip() + "\n"
+
+
+def render_global_instructions() -> str:
+    return """# AI Toolkit — Claude app global instructions
+
+For every technical, coding, debugging, review, architecture, DevOps, data,
+or file-editing task, load and follow the installed `ai-toolkit-rules` skill
+before acting. Load the relevant language-rule and workflow skills as needed.
+Use ai-toolkit sub-agents for specialist work in Cowork. Before claiming a
+task is complete, run fresh verification and report the evidence.
+
+In regular Chat, hooks and sub-agents are unavailable; skills remain the
+authoritative customization surface. In Cowork, also honor the plugin hooks.
+"""
+
+
+def sync_generated() -> None:
+    """Refresh committed Claude app plugin assets from canonical sources."""
+    _write_text(PLUGIN_HOOKS_PATH, render_plugin_hooks())
+    _write_text(PLUGIN_RULES_SKILL_PATH, render_rules_skill())
+    _write_text(GLOBAL_INSTRUCTIONS_PATH, render_global_instructions())
+    print("Synced: app/claude-app/hooks/hooks.json")
+    print("Synced: app/claude-app/skills/ai-toolkit-rules/SKILL.md")
+    print("Synced: app/claude-app/global-instructions.md")
+
+
+def _copy_tree(source: Path, destination: Path) -> None:
+    for path in sorted(source.rglob("*")):
+        relative = path.relative_to(source)
+        if any(part in SKIP_NAMES or part.endswith(".pyc") for part in relative.parts):
+            continue
+        target = destination / relative
+        if path.is_dir():
+            target.mkdir(parents=True, exist_ok=True)
+        elif path.is_file():
+            target.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(path, target)
+
+
+def stage_plugin(destination: Path, include_custom_rules: bool = True) -> int:
+    """Create a clean plugin tree and return the registered-rule count."""
+    destination.mkdir(parents=True, exist_ok=True)
+    (destination / ".claude-plugin").mkdir(parents=True, exist_ok=True)
+    shutil.copy2(
+        APP_DIR / ".claude-plugin" / "plugin.json",
+        destination / ".claude-plugin" / "plugin.json",
+    )
+
+    for dirname in ("skills", "hooks", "output-styles"):
+        _copy_tree(APP_DIR / dirname, destination / dirname)
+
+    agents_dir = destination / "agents"
+    agents_dir.mkdir(parents=True, exist_ok=True)
+    for agent in sorted((APP_DIR / "agents").glob("*.md")):
+        shutil.copy2(agent, agents_dir / agent.name)
+
+    app_assets = destination / "claude-app"
+    _write_text(app_assets / "hooks" / "hooks.json", render_plugin_hooks())
+    _write_text(
+        app_assets / "skills" / "ai-toolkit-rules" / "SKILL.md",
+        render_rules_skill(),
+    )
+    _write_text(app_assets / "global-instructions.md", render_global_instructions())
+
+    scripts_dir = destination / "scripts"
+    scripts_dir.mkdir(parents=True, exist_ok=True)
+    for filename in PLUGIN_SCRIPT_FILES:
+        shutil.copy2(TOOLKIT_DIR / "scripts" / filename, scripts_dir / filename)
+    shutil.copy2(TOOLKIT_DIR / "package.json", destination / "package.json")
+    shutil.copy2(TOOLKIT_DIR / "LICENSE", destination / "LICENSE")
+
+    registered = ()
+    if include_custom_rules and REGISTERED_RULES_DIR.is_dir():
+        registered = tuple(sorted(REGISTERED_RULES_DIR.glob("*.md")))
+    if registered:
+        _write_text(
+            app_assets / "skills" / "registered-rules" / "SKILL.md",
+            render_registered_rules_skill(registered),
+        )
+    return len(registered)
+
+
+def render_registered_rules_skill(rules: tuple[Path, ...]) -> str:
+    parts = [
+        "---",
+        "name: registered-rules",
+        'description: "User-registered ai-toolkit rules. Claude MUST load this skill for technical work when the installed bundle contains organization or personal standards."',
+        "user-invocable: true",
+        "---",
+        "",
+        "# Registered AI Toolkit Rules",
+    ]
+    for rule_file in rules:
+        parts.extend(
+            (
+                "",
+                f"## `{rule_file.name}`",
+                "",
+                _strip_frontmatter(rule_file.read_text(encoding="utf-8")),
+            )
+        )
+    return "\n".join(parts).rstrip() + "\n"
+
+
+def _validate_staged_plugin(plugin_dir: Path) -> list[str]:
+    errors: list[str] = []
+    manifest_path = plugin_dir / ".claude-plugin" / "plugin.json"
+    try:
+        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        return [f"invalid plugin manifest: {exc}"]
+
+    if not isinstance(manifest.get("repository"), str):
+        errors.append("plugin manifest repository must be a URL string")
+    for field in ("npm", "install", "marketplace", "claude-code"):
+        if field in manifest:
+            errors.append(f"plugin manifest contains ignored field: {field}")
+
+    hooks_path = plugin_dir / str(manifest.get("hooks", "")).removeprefix("./")
+    skills_path = plugin_dir / str(manifest.get("skills", "")).removeprefix("./")
+    if not hooks_path.is_file():
+        errors.append(f"plugin hook config missing: {hooks_path.relative_to(plugin_dir)}")
+    if not skills_path.is_dir():
+        errors.append(f"plugin skill path missing: {skills_path.relative_to(plugin_dir)}")
+
+    if hooks_path.is_file():
+        hooks_text = hooks_path.read_text(encoding="utf-8")
+        if "$HOME/.softspark/ai-toolkit/hooks/" in hooks_text:
+            errors.append("plugin hooks still reference the Claude Code global install")
+        if "${CLAUDE_PLUGIN_ROOT}/hooks/" not in hooks_text:
+            errors.append("plugin hooks do not reference CLAUDE_PLUGIN_ROOT")
+        try:
+            json.loads(hooks_text)
+        except json.JSONDecodeError as exc:
+            errors.append(f"invalid plugin hooks JSON: {exc}")
+
+    for agent in (plugin_dir / "agents").glob("*.md"):
+        if not agent.read_text(encoding="utf-8").startswith("---\n"):
+            errors.append(f"agent lacks frontmatter: {agent.name}")
+    return errors
+
+
+def _run_claude_validator(plugin_dir: Path) -> bool:
+    claude = shutil.which("claude")
+    if not claude:
+        print("ERROR: claude CLI not found; cannot run official plugin validator", file=sys.stderr)
+        return False
+    result = subprocess.run(
+        [claude, "plugin", "validate", str(plugin_dir), "--strict"]
+    )
+    return result.returncode == 0
+
+
+def verify_plugin() -> bool:
+    with tempfile.TemporaryDirectory(prefix="ai-toolkit-claude-app-") as tmp:
+        staged = Path(tmp) / "ai-toolkit"
+        stage_plugin(staged, include_custom_rules=False)
+        errors = _validate_staged_plugin(staged)
+        for error in errors:
+            print(f"ERROR: {error}", file=sys.stderr)
+        if errors:
+            return False
+        if not _run_claude_validator(staged):
+            return False
+    print("Claude app plugin validation passed")
+    return True
+
+
+def _archive_file(zip_file: zipfile.ZipFile, path: Path, arcname: str) -> None:
+    data = path.read_bytes()
+    mode = path.stat().st_mode
+    permissions = 0o755 if mode & stat.S_IXUSR else 0o644
+    info = zipfile.ZipInfo(arcname, FIXED_ZIP_TIME)
+    info.compress_type = zipfile.ZIP_DEFLATED
+    info.external_attr = (stat.S_IFREG | permissions) << 16
+    zip_file.writestr(info, data)
+
+
+def export_plugin(output: Path, include_custom_rules: bool, verify: bool) -> bool:
+    output = output.expanduser().resolve()
+    output.parent.mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryDirectory(prefix="ai-toolkit-claude-app-") as tmp:
+        staged = Path(tmp) / "ai-toolkit"
+        registered_count = stage_plugin(staged, include_custom_rules=include_custom_rules)
+        errors = _validate_staged_plugin(staged)
+        if errors:
+            for error in errors:
+                print(f"ERROR: {error}", file=sys.stderr)
+            return False
+        if verify and not _run_claude_validator(staged):
+            return False
+        with zipfile.ZipFile(output, "w") as archive:
+            for path in sorted(staged.rglob("*")):
+                if path.is_file():
+                    _archive_file(archive, path, path.relative_to(staged).as_posix())
+
+    instructions = output.with_name(f"{output.stem}-global-instructions.md")
+    _write_text(instructions, render_global_instructions())
+    print(f"Created: {output}")
+    print(f"Created: {instructions}")
+    if registered_count:
+        print(f"Included registered rules: {registered_count} (local bundle; review before sharing)")
+    print("Next: Claude > Customize > Plugins > + > Upload plugin")
+    print("Then paste the instructions file into Settings > Cowork > Global instructions")
+    return True
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    subparsers = parser.add_subparsers(dest="action", required=True)
+    subparsers.add_parser("sync", help="refresh committed Claude app plugin assets")
+    subparsers.add_parser("verify", help="run structural and official plugin validation")
+    export = subparsers.add_parser("export", help="build an uploadable Claude app plugin ZIP")
+    export.add_argument("--output", default="ai-toolkit-claude-app.zip")
+    export.add_argument("--no-custom-rules", action="store_true")
+    export.add_argument("--verify", action="store_true")
+    return parser.parse_args(argv)
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parse_args(argv)
+    if args.action == "sync":
+        sync_generated()
+        return 0
+    if args.action == "verify":
+        return 0 if verify_plugin() else 1
+    if args.action == "export":
+        return 0 if export_plugin(
+            Path(args.output),
+            include_custom_rules=not args.no_custom_rules,
+            verify=args.verify,
+        ) else 1
+    return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/doctor.py

@@ -79,6 +79,10 @@ EXPECTED_HOOKS = [
 
 PLANNED_ASSETS = [
     toolkit_dir / "app" / ".claude-plugin" / "plugin.json",
+    toolkit_dir / "app" / "claude-app" / "hooks" / "hooks.json",
+    toolkit_dir / "app" / "claude-app" / "skills" / "ai-toolkit-rules" / "SKILL.md",
+    toolkit_dir / "app" / "claude-app" / "global-instructions.md",
+    toolkit_dir / "scripts" / "claude_app.py",
     toolkit_dir / "scripts" / "benchmark_ecosystem.py",
     toolkit_dir / "scripts" / "harvest_ecosystem.py",
     toolkit_dir / "kb" / "reference" / "claude-ecosystem-benchmark-snapshot.md",
@@ -218,14 +222,91 @@ def _check_symlinks(dr: DiagResult, fix_mode: bool, directory: Path,
         dr.fail(f"{label}: no symlinks found")
 
 
+def _without_source_tags(value: object) -> object:
+    """Return a JSON-compatible hook value without private source markers."""
+    if isinstance(value, dict):
+        return {
+            key: _without_source_tags(item)
+            for key, item in value.items()
+            if key != "_source"
+        }
+    if isinstance(value, list):
+        return [_without_source_tags(item) for item in value]
+    return value
+
+
+def _hook_signature(entry: dict) -> str:
+    """Build a stable behavior signature for tagged or legacy hook entries."""
+    return json.dumps(
+        _without_source_tags(entry),
+        ensure_ascii=False,
+        sort_keys=True,
+        separators=(",", ":"),
+    )
+
+
+def _has_toolkit_source(entry: dict) -> bool:
+    if entry.get("_source") == "ai-toolkit":
+        return True
+    return any(
+        isinstance(handler, dict) and handler.get("_source") == "ai-toolkit"
+        for handler in entry.get("hooks", [])
+    )
+
+
+def _installed_toolkit_hook_count(settings: dict) -> tuple[int, int]:
+    """Count canonical hooks even if Claude removed private `_source` tags."""
+    source_path = toolkit_dir / "app" / "hooks.json"
+    try:
+        source_hooks = json.loads(source_path.read_text(encoding="utf-8")).get(
+            "hooks", {}
+        )
+    except (OSError, json.JSONDecodeError):
+        return 0, 0
+
+    expected = sum(
+        len(entries) for entries in source_hooks.values() if isinstance(entries, list)
+    )
+    signatures = {
+        event: {
+            _hook_signature(entry)
+            for entry in entries
+            if isinstance(entry, dict)
+        }
+        for event, entries in source_hooks.items()
+        if isinstance(entries, list)
+    }
+    installed = 0
+    for event, entries in settings.get("hooks", {}).items():
+        if not isinstance(entries, list):
+            continue
+        for entry in entries:
+            if not isinstance(entry, dict):
+                continue
+            if _has_toolkit_source(entry) or _hook_signature(entry) in signatures.get(
+                event, set()
+            ):
+                installed += 1
+    return installed, expected
+
+
 def _check_settings_json(dr: DiagResult) -> None:
     """Check settings.json hooks and legacy hooks.json."""
     settings_json = CLAUDE_DIR / "settings.json"
     if settings_json.is_file():
-        content = settings_json.read_text(encoding="utf-8")
-        if '"_source"' in content and '"ai-toolkit"' in content:
-            hook_count = content.count('"ai-toolkit"')
-            dr.ok(f"settings.json: {hook_count} toolkit hook entries")
+        try:
+            settings = json.loads(settings_json.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            dr.fail("settings.json is not valid JSON")
+            settings = {}
+        hook_count, expected_count = _installed_toolkit_hook_count(settings)
+        if expected_count and hook_count == expected_count:
+            dr.ok(f"settings.json: {hook_count}/{expected_count} toolkit hook entries")
+        elif hook_count:
+            dr.warn(
+                f"settings.json has {hook_count}/{expected_count} toolkit hook entries "
+                "(run: ai-toolkit update --only hooks)"
+            )
         else:
             dr.warn("settings.json exists but has no toolkit hooks")
     else:

package/scripts/ecosystem_tools.json

@@ -1,7 +1,7 @@
 {
   "schema_version": 1,
   "description": "Authoritative registry of tools ai-toolkit integrates with. Consumed by scripts/ecosystem_doctor.py to detect upstream doc/version drift.",
-  "last_updated": "2026-06-30",
+  "last_updated": "2026-07-10",
   "tools": [
     {
       "id": "claude-code",
@@ -70,6 +70,37 @@
         "command": "claude --version"
       }
     },
+    {
+      "id": "claude-app",
+      "display_name": "Claude Chat / Cowork",
+      "kind": "app",
+      "urls": {
+        "docs": "https://support.claude.com/en/articles/13345190-get-started-with-claude-cowork",
+        "release_notes": "https://support.claude.com/en/articles/13837440-use-plugins-in-claude",
+        "changelog": null
+      },
+      "config_paths": [
+        "UI: Settings > Cowork > Global instructions",
+        "UI: Cowork folder instructions",
+        "UI: Customize > Skills",
+        "UI: Customize > Plugins",
+        ".claude-plugin/plugin.json",
+        "claude-app/hooks/hooks.json",
+        "claude-app/skills/*/SKILL.md"
+      ],
+      "our_generators": [
+        "scripts/claude_app.py"
+      ],
+      "status_note": "Claude Chat/Desktop/Cowork does not scan ~/.claude/rules, CLAUDE.md, or Claude Code's user settings. ai-toolkit exports an uploadable plugin ZIP plus Cowork global instructions. Skills work in Chat and Cowork; plugin hooks and sub-agents run only in Cowork.",
+      "capability_markers": [
+        "Global instructions",
+        "Folder instructions",
+        "plugins",
+        "skills",
+        "sub-agents"
+      ],
+      "version_probe": null
+    },
     {
       "id": "cursor",
       "display_name": "Cursor",
@@ -134,7 +165,6 @@
       "config_paths": [
         ".devin/rules/*.md",
         ".devin/workflows/*.md",
-        ".devin/skills/*/SKILL.md",
         ".devin/hooks.v1.json",
         ".devin/config.json",
         ".devin/config.local.json",
@@ -153,10 +183,9 @@
         "scripts/generate_windsurf.py",
         "scripts/generate_windsurf_rules.py",
         "scripts/generate_windsurf_skills.py",
-        "scripts/generate_windsurf_hooks.py",
         "scripts/generate_devin_hooks.py"
       ],
-      "status_note": "Windsurf rebranded to Devin Desktop on 2026-06-02. .devin/ is the primary read+write workspace tree; .windsurfrules, .windsurf/* and ~/.codeium/windsurf/* are legacy read-only fallbacks. Our generators dual-emit .devin/* + .windsurf/*. HOOKS MIGRATION (done): Cascade agent is available only through 2026-07-01 (Devin Local default since 2026-06-02), and the Cascade-scoped .windsurf/hooks.json (generate_windsurf_hooks.py, agent_action_name/tool_info format) dies with it — Devin CLI/Local do NOT read it as a fallback. generate_devin_hooks.py now emits .devin/hooks.v1.json in the Claude-compatible hook format Devin CLI uses (docs.devin.ai/cli/extensibility/hooks): Claude-style events (PreToolUse/PostToolUse/UserPromptSubmit/Stop/SessionStart) with matchers on Devin tool names (read/edit/exec/mcp__*), flat {decision,reason} block contract + exit 2. Globally-installed users ALSO inherit ~/.claude/settings.json hooks automatically (Devin read_config_from.claude defaults on). Both hook generators run at profile=full; drop generate_windsurf_hooks.py in the first release after 2026-07-01. Devin CLI ('Devin for Terminal', launched 2026-04-29) shares the Devin Local harness, reads AGENTS.md and the same SKILL.md standard; not yet tracked as a separate registry entry.",
+      "status_note": "Windsurf rebranded to Devin Desktop on 2026-06-02. .devin/ is the primary rules/workflows/hooks tree; legacy .windsurf rules remain a read fallback. Cascade and its .windsurf/hooks.json format ended on 2026-07-01, so ai-toolkit now emits only .devin/hooks.v1.json. Current Devin skill docs list eight scanned paths (.agents/skills recommended, plus .devin/skills, .github/skills, .claude/skills, .cursor/skills, .codex/skills, .cognition/skills, .windsurf/skills); ai-toolkit emits a single canonical pointer under .windsurf/skills and no longer also writes .devin/skills. Devin CLI also imports ~/.claude/settings.json hooks when read_config_from.claude is enabled.",
       "capability_markers": [
         "Cascade",
         "windsurfrules",
@@ -469,7 +498,6 @@
       ],
       "status_note": "Antigravity CLI (GA 2026-05-19) reads workspace skills from .agents/skills/ (plural); the IDE still uses .agent/skills/ (singular) — our generator dual-emits the skill pointer to both. CLI hooks live in .agents/hooks.json with Claude-style event names (PreToolUse, not BeforeTool) and a JSON stdin/stdout decision contract. CLI MCP config is .agents/mcp_config.json with a required serverUrl field (url/httpUrl rejected silently); the GLOBAL MCP config path is reported inconsistently across sources (~/.gemini/antigravity-cli/ vs ~/.gemini/config/), so only the workspace path is registered until verified via agy inspect. Official docs are fully JS-rendered — the doctor is blind to them; verify changes manually each sync.",
       "capability_markers": [
-        "Antigravity",
         "agent manager",
         "artifacts",
         "MCP",

package/scripts/generate_devin_hooks.py

@@ -3,10 +3,9 @@
 
 Devin CLI uses a hook format **compatible with Claude Code hooks**
 (docs.devin.ai/cli/extensibility/hooks/overview). This generator is the
-replacement for the deprecated Cascade ``.windsurf/hooks.json`` surface,
-which stops working when Cascade sunsets on 2026-07-01. Devin Local / Devin
-CLI do NOT read ``.windsurf/hooks.json`` as a fallback, so the hooks must be
-regenerated onto this new file.
+replacement for the removed Cascade ``.windsurf/hooks.json`` surface, which
+stopped working on 2026-07-01. Devin Local and the standalone Devin CLI do not
+read that legacy file as a fallback, so hooks are emitted here.
 
 Output file: ``<target>/.devin/hooks.v1.json``. Per the Devin docs the
 standalone ``hooks.v1.json`` file's entire contents ARE the hooks object —

package/scripts/generate_windsurf_skills.py

@@ -1,10 +1,9 @@
 #!/usr/bin/env python3
-"""Generate a Devin Desktop (formerly Windsurf) skill pointer.
+"""Generate a Devin/Windsurf skill pointer.
 
-Dual-emits under ``.devin/skills/`` (primary since the 2026-06-02 rebrand)
-and ``.windsurf/skills/`` (legacy fallback). Pass an explicit ``skill_root``
-to emit a single location instead (used for the ``~/.codeium/windsurf/``
-global install path).
+Current Devin docs list ``.windsurf/skills/`` as a supported cross-tool skill
+path and do not list ``.devin/skills/``. Pass an explicit ``skill_root`` for a
+single alternate location (used by the legacy HOME-scoped Windsurf install).
 """
 from __future__ import annotations
 
@@ -14,7 +13,7 @@ from pathlib import Path
 sys.path.insert(0, str(Path(__file__).resolve().parent))
 from skill_pointer import POINTER_SKILL_NAME, write_pointer_skill
 
-DEFAULT_SKILL_ROOTS: tuple[str, ...] = (".devin/skills", ".windsurf/skills")
+DEFAULT_SKILL_ROOTS: tuple[str, ...] = (".windsurf/skills",)
 
 
 def generate(target_dir: Path, *, emit_skill_pointer: bool = True,