@event4u/agent-config 1.38.0 → 1.40.0

package/scripts/install.sh

@@ -37,10 +37,26 @@ DRY_RUN=false
 VERBOSE=false
 QUIET=false
 SKIP_GITIGNORE=false
+# Comma-separated tool IDs (default: all). Set by --tools or the
+# orchestrator (scripts/install). The .augment/ substrate is always
+# synced because every other tool symlinks back into it.
+TOOLS="all"
 # Resolved from <TARGET>/.agent-settings.yml in resolve_settings(); when
 # true, .augment/rules/ files are symlinked instead of copied.
 USE_RULES_SYMLINKS=false
 
+# Return 0 if a tool ID is enabled by the current --tools selection.
+# "all" matches everything; otherwise match the comma list exactly.
+is_tool_enabled() {
+    local id="$1"
+    [[ "$TOOLS" == "all" ]] && return 0
+    case ",$TOOLS," in
+        *,"$id",*) return 0 ;;
+        *,all,*)   return 0 ;;
+    esac
+    return 1
+}
+
 # --- Logging ---
 log_info()    { $QUIET || echo "  ✅  $*"; }
 log_warn()    { $QUIET || echo "  ⚠️  $*" >&2; }
@@ -57,11 +73,15 @@ parse_args() {
             --verbose) VERBOSE=true; shift ;;
             --quiet)   QUIET=true; shift ;;
             --skip-gitignore) SKIP_GITIGNORE=true; shift ;;
+            --tools)   TOOLS="$2"; shift 2 ;;
+            --tools=*) TOOLS="${1#*=}"; shift ;;
             --help|-h) show_help; exit 0 ;;
             *) log_error "Unknown argument: $1"; show_help; exit 1 ;;
         esac
     done
 
+    [[ -z "$TOOLS" ]] && TOOLS="all"
+
     # Auto-detect source: directory where this script lives (../  = package root)
     if [[ -z "$SOURCE_DIR" ]]; then
         SOURCE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
@@ -106,6 +126,10 @@ Syncs agent-config to target project. Copies rules, symlinks everything else.
 Options:
   --source <dir>   Package source directory (default: auto-detect from script location)
   --target <dir>   Target project root (default: $PROJECT_ROOT or cwd)
+  --tools <list>   Comma-separated tool IDs (default: all). Filters tool-specific
+                   payload (.claude/, .cursor/, .clinerules/, .windsurfrules,
+                   GEMINI.md, copilot-instructions.md). The .augment/ substrate
+                   and AGENTS.md are always written.
   --dry-run        Show what would happen without making changes
   --verbose        Show detailed output
   --quiet          Suppress all output except errors
@@ -409,15 +433,25 @@ clean_stale() {
 }
 
 
-# Create tool-specific rule symlinks
+# Create tool-specific rule symlinks (filtered by --tools selection).
+# Map: tool ID → (target dir, relative prefix from target → .augment/rules).
 create_tool_symlinks() {
     local project_root="$1"
     local rules_dir="$project_root/.augment/rules"
 
     [[ -d "$rules_dir" ]] || return
 
-    local -a tool_dirs=(".claude/rules" ".cursor/rules" ".clinerules")
-    local -a rel_prefixes=("../../.augment/rules" "../../.augment/rules" "../.augment/rules")
+    local -a tool_ids=()
+    local -a tool_dirs=()
+    local -a rel_prefixes=()
+    is_tool_enabled "claude-code" && { tool_ids+=("claude-code"); tool_dirs+=(".claude/rules");  rel_prefixes+=("../../.augment/rules"); }
+    is_tool_enabled "cursor"      && { tool_ids+=("cursor");      tool_dirs+=(".cursor/rules");  rel_prefixes+=("../../.augment/rules"); }
+    is_tool_enabled "cline"       && { tool_ids+=("cline");       tool_dirs+=(".clinerules");    rel_prefixes+=("../.augment/rules"); }
+
+    if [[ ${#tool_dirs[@]} -eq 0 ]]; then
+        log_verbose "no tool rule directories selected (--tools=$TOOLS)"
+        return 0
+    fi
 
     local count=0
     for i in "${!tool_dirs[@]}"; do
@@ -467,15 +501,16 @@ create_tool_symlinks() {
         done
     done
 
-    log_info "Created $count rule symlinks across ${#tool_dirs[@]} tool directories"
+    log_info "Created $count rule symlinks across ${#tool_dirs[@]} tool directories (${tool_ids[*]})"
 }
 
-# Create .claude/skills/ directory symlinks
+# Create .claude/skills/ directory symlinks (claude-code only).
 create_skill_symlinks() {
     local project_root="$1"
     local skills_dir="$project_root/.augment/skills"
 
     [[ -d "$skills_dir" ]] || return
+    is_tool_enabled "claude-code" || { log_verbose "skip .claude/skills/ (claude-code not selected)"; return 0; }
 
     local target_dir="$project_root/.claude/skills"
     mkdir -p "$target_dir"
@@ -528,6 +563,7 @@ generate_windsurfrules() {
     local rules_dir="$project_root/.augment/rules"
 
     [[ -d "$rules_dir" ]] || return
+    is_tool_enabled "windsurf" || { log_verbose "skip .windsurfrules (windsurf not selected)"; return 0; }
 
     local output="$project_root/.windsurfrules"
     local count=0
@@ -561,11 +597,13 @@ generate_windsurfrules() {
 }
 
 
-# Create GEMINI.md symlink
+# Create GEMINI.md symlink (gemini-cli only).
 create_gemini_md() {
     local project_root="$1"
     local link="$project_root/GEMINI.md"
 
+    is_tool_enabled "gemini-cli" || { log_verbose "skip GEMINI.md (gemini-cli not selected)"; return 0; }
+
     if [[ -L "$link" ]] || [[ -f "$link" ]]; then
         return  # Don't overwrite
     fi
@@ -726,8 +764,15 @@ main() {
     #    own root AGENTS.md / copilot-instructions.md — those are meta docs
     #    about the package itself and would leak package-specific content
     #    into consumer projects.
+    #    AGENTS.md is the universal cross-tool contract (aider, codex, claude,
+    #    etc.) and is always written. copilot-instructions.md is gated on the
+    #    copilot tool selection.
     copy_if_missing "$SOURCE_PAYLOAD/templates/AGENTS.md" "$TARGET_DIR/AGENTS.md"
-    copy_if_missing "$SOURCE_PAYLOAD/templates/copilot-instructions.md" "$TARGET_DIR/.github/copilot-instructions.md"
+    if is_tool_enabled "copilot"; then
+        copy_if_missing "$SOURCE_PAYLOAD/templates/copilot-instructions.md" "$TARGET_DIR/.github/copilot-instructions.md"
+    else
+        log_verbose "skip .github/copilot-instructions.md (copilot not selected)"
+    fi
 
     # 3. Create tool-specific symlinks
     create_tool_symlinks "$TARGET_DIR"

package/scripts/lint_orchestration_dsl.py

@@ -0,0 +1,214 @@
+#!/usr/bin/env python3
+"""Lint `.agent-config/orchestrations/*.yaml` pipeline files.
+
+CI gate for the orchestration DSL contract
+(`docs/contracts/orchestration-dsl-v1.md`). Hard-fails on:
+
+- missing or malformed top-level keys
+  (`schema_version`, `name`, `description`, `steps`)
+- `schema_version != 1`
+- `name` not matching `[a-z][a-z0-9-]*` or not matching the filename
+- duplicate `steps[].id`
+- `steps[].kind` outside the enum (`skill` / `command` / `persona` /
+  `subagent`)
+- `steps[].ref` pointing at a non-existent target on disk
+- `${{ ... }}` reference to an unknown input or step id
+- `steps[]` length outside [1, 32]
+- `outputs` referencing an unknown step
+
+Exit codes mirror `lint_hook_manifest.py`:
+  0 — clean
+  1 — at least one hard failure
+  2 — file or schema-load error
+
+Invocation:
+
+    python3 scripts/lint_orchestration_dsl.py [--dir PATH] [--file PATH]
+"""
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+DEFAULT_DIR = REPO_ROOT / ".agent-config" / "orchestrations"
+
+NAME_RE = re.compile(r"^[a-z][a-z0-9-]*$")
+STEP_ID_RE = re.compile(r"^[a-z][a-z0-9_]*$")
+INTERP_RE = re.compile(r"\$\{\{\s*(inputs|steps)\.([a-z0-9_-]+)(?:\.output)?\s*\}\}")
+
+VALID_KINDS = {"skill", "command", "persona", "subagent"}
+MAX_STEPS = 32
+MIN_STEPS = 1
+
+# Subagent-orchestration modes — kept in lock-step with
+# .agent-src.uncompressed/skills/subagent-orchestration/SKILL.md.
+SUBAGENT_MODES = {
+    "do-and-judge", "do-and-judge-two-stage",
+    "do-in-steps", "do-in-parallel", "do-in-worktrees",
+    "do-competitively", "judge-with-debate",
+}
+
+
+def _load_yaml(path: Path) -> object:
+    """Reuse the dispatcher's loader so the linter sees what the
+    runtime sees — fallback parser when PyYAML is not installed."""
+    sys.path.insert(0, str(REPO_ROOT / "scripts"))
+    from hooks.dispatch_hook import _load_yaml as _load  # noqa: E402
+    return _load(path)
+
+
+def _ref_exists(kind: str, ref: str) -> bool:
+    if kind == "skill":
+        return (REPO_ROOT / ".agent-src.uncompressed" / "skills" / ref / "SKILL.md").is_file()
+    if kind == "command":
+        return (REPO_ROOT / ".agent-src.uncompressed" / "commands" / f"{ref}.md").is_file()
+    if kind == "persona":
+        return (REPO_ROOT / ".agent-src.uncompressed" / "personas" / f"{ref}.md").is_file()
+    if kind == "subagent":
+        return ref in SUBAGENT_MODES
+    return False
+
+
+def _walk_interpolations(value: object):
+    """Yield (namespace, ident) tuples for every ${{ ns.ident }} in the
+    nested value (dict / list / str)."""
+    if isinstance(value, str):
+        for match in INTERP_RE.finditer(value):
+            yield match.group(1), match.group(2)
+    elif isinstance(value, dict):
+        for v in value.values():
+            yield from _walk_interpolations(v)
+    elif isinstance(value, list):
+        for v in value:
+            yield from _walk_interpolations(v)
+
+
+def _check_unknown_namespaces(value: object, path: str, errors: list[str]) -> None:
+    if isinstance(value, str):
+        for match in re.finditer(r"\$\{\{\s*([a-z]+)\.", value):
+            if match.group(1) not in ("inputs", "steps"):
+                errors.append(f"{path}: unknown interpolation namespace '{match.group(1)}'")
+    elif isinstance(value, dict):
+        for k, v in value.items():
+            _check_unknown_namespaces(v, f"{path}.{k}", errors)
+    elif isinstance(value, list):
+        for i, v in enumerate(value):
+            _check_unknown_namespaces(v, f"{path}[{i}]", errors)
+
+
+def _check_steps(doc: dict, input_ids: set[str], errors: list[str]) -> set[str]:
+    steps = doc.get("steps")
+    if not isinstance(steps, list) or not (MIN_STEPS <= len(steps) <= MAX_STEPS):
+        errors.append(f"steps: must be a list of {MIN_STEPS}–{MAX_STEPS} entries")
+        return set()
+    step_ids: set[str] = set()
+    for i, step in enumerate(steps):
+        if not isinstance(step, dict):
+            errors.append(f"steps[{i}]: must be a mapping")
+            continue
+        sid = step.get("id")
+        if not isinstance(sid, str) or not STEP_ID_RE.match(sid):
+            errors.append(f"steps[{i}].id: must be snake-case identifier")
+            continue
+        if sid in step_ids:
+            errors.append(f"steps[{i}].id: duplicate id '{sid}'")
+            continue
+        step_ids.add(sid)
+        kind = step.get("kind")
+        ref = step.get("ref")
+        if kind not in VALID_KINDS:
+            errors.append(f"steps.{sid}.kind: must be one of {sorted(VALID_KINDS)}")
+            continue
+        if not isinstance(ref, str) or not _ref_exists(kind, ref):
+            errors.append(f"steps.{sid}.ref: {kind} '{ref}' not found on disk")
+        _check_unknown_namespaces(step.get("with"), f"steps.{sid}.with", errors)
+        for ns, ident in _walk_interpolations(step.get("with") or {}):
+            if ns == "inputs" and ident not in input_ids:
+                errors.append(f"steps.{sid}.with: unknown input '{ident}'")
+            if ns == "steps" and ident not in step_ids - {sid}:
+                errors.append(f"steps.{sid}.with: unknown step '{ident}' (forward ref or self)")
+    return step_ids
+
+
+
+def _check_outputs(doc: dict, step_ids: set[str], input_ids: set[str], errors: list[str]) -> None:
+    outputs = doc.get("outputs")
+    if outputs is None:
+        return
+    if not isinstance(outputs, dict):
+        errors.append("outputs: must be a mapping")
+        return
+    for name, value in outputs.items():
+        for ns, ident in _walk_interpolations(value):
+            if ns == "steps" and ident not in step_ids:
+                errors.append(f"outputs.{name}: unknown step '{ident}'")
+            if ns == "inputs" and ident not in input_ids:
+                errors.append(f"outputs.{name}: unknown input '{ident}'")
+
+
+def _check_inputs(doc: dict, errors: list[str]) -> set[str]:
+    inputs = doc.get("inputs") or []
+    if not isinstance(inputs, list):
+        errors.append("inputs: must be a list")
+        return set()
+    ids: set[str] = set()
+    for i, inp in enumerate(inputs):
+        if not isinstance(inp, dict) or not isinstance(inp.get("id"), str):
+            errors.append(f"inputs[{i}]: must be a mapping with string 'id'")
+            continue
+        if inp["id"] in ids:
+            errors.append(f"inputs[{i}].id: duplicate id '{inp['id']}'")
+        ids.add(inp["id"])
+    return ids
+
+
+def lint(path: Path) -> int:
+    try:
+        doc = _load_yaml(path)
+    except Exception as exc:
+        sys.stderr.write(f"lint_orchestration_dsl: load error: {exc}\n")
+        return 2
+    if not isinstance(doc, dict):
+        sys.stderr.write(f"{path}: top-level must be a mapping\n")
+        return 1
+
+    errors: list[str] = []
+    if doc.get("schema_version") != 1:
+        errors.append("schema_version: must be 1")
+    name = doc.get("name")
+    if not isinstance(name, str) or not NAME_RE.match(name):
+        errors.append("name: must be kebab-case starting with a letter")
+    elif name != path.stem:
+        errors.append(f"name: '{name}' must match filename stem '{path.stem}'")
+    if not isinstance(doc.get("description"), str) or not doc["description"].strip():
+        errors.append("description: must be a non-empty string")
+
+    input_ids = _check_inputs(doc, errors)
+    step_ids = _check_steps(doc, input_ids, errors)
+    _check_outputs(doc, step_ids, input_ids, errors)
+
+    for e in errors:
+        sys.stderr.write(f"error: {path}: {e}\n")
+    return 1 if errors else 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--dir", type=Path, default=DEFAULT_DIR)
+    parser.add_argument("--file", type=Path, default=None)
+    args = parser.parse_args(argv)
+    if args.file is not None:
+        return lint(args.file)
+    if not args.dir.is_dir():
+        return 0  # opt-in directory; absence is not a failure
+    rc = 0
+    for path in sorted(args.dir.glob("*.yaml")):
+        rc = max(rc, lint(path))
+    return rc
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/skill_linter.py

@@ -1605,6 +1605,15 @@ def gather_changed_candidate_files(root: Path) -> list[Path]:
             if path.is_symlink():
                 continue
             norm = raw.replace("\\", "/")
+            # Only lint source-of-truth and source-mirror dirs. Projection
+            # dirs (.windsurf/, .cursor/, .clinerules/, .claude/) use
+            # tool-native frontmatter (e.g. Windsurf's trigger/globs) that
+            # the linter does not validate — they regenerate from source.
+            if not (
+                norm.startswith(".agent-src.uncompressed/")
+                or norm.startswith(".agent-src/")
+            ):
+                continue
             if path.name == "SKILL.md" or "/rules/" in norm or "/commands/" in norm:
                 files.append(path)
         return sorted(set(files))

package/scripts/sync_gitignore.py

@@ -14,7 +14,13 @@ are preserved). Call with `--replace` for a destructive full rewrite.
 
 Usage:
     python3 scripts/sync_gitignore.py [--path .gitignore] [--template config/gitignore-block.txt]
-                                      [--dry-run] [--replace] [--quiet]
+                                      [--dry-run] [--replace] [--cleanup-legacy] [--quiet]
+
+`--cleanup-legacy` additionally scrubs legacy patterns (pre-/agents/ layout
+runtime artefacts) from anywhere in the target file — inside the managed
+block and outside, where older installers or hand-edits dropped them.
+Runs before the regular sync, so a single invocation removes garbage and
+re-adds the current canonical entries.
 
 Exit codes:
     0 — no changes needed (or --dry-run ran successfully)
@@ -34,6 +40,20 @@ SECTION_FOOTER = "# event4u/agent-config — END"
 DEFAULT_GITIGNORE = ".gitignore"
 DEFAULT_TEMPLATE = Path(__file__).resolve().parent.parent / "config" / "gitignore-block.txt"
 
+# Legacy patterns that lived in older versions of config/gitignore-block.txt
+# before runtime artefacts moved under /agents/ (May 2026). They get stripped
+# wherever they appear in the consumer's .gitignore — inside the managed block
+# or outside (older installers / hand-edits). Current canonical equivalents
+# (e.g. /agents/.agent-chat-history) come from the template and are NOT
+# affected. Leading-slash variants are matched defensively.
+LEGACY_PATTERNS: tuple[str, ...] = (
+    ".agent-chat-history",
+    ".agent-chat-history.bak",
+    ".agent-chat-history.*.bak",
+    ".agent-prices.md",
+    ".council-tmp/",
+)
+
 
 def _strip(ln: str) -> str:
     return ln.rstrip("\n").rstrip()
@@ -149,6 +169,26 @@ def sync_block(existing_lines: list[str],
     return head + new_block + tail, missing
 
 
+def cleanup_legacy(lines: list[str]) -> tuple[list[str], list[str]]:
+    """Strip legacy entries from anywhere in the file.
+
+    A line is legacy when its stripped, leading-whitespace-trimmed content
+    matches a `LEGACY_PATTERNS` entry — with or without a leading slash.
+    Comments and blank lines are untouched; current managed entries (e.g.
+    `/agents/.agent-chat-history`) are not in the legacy set and survive.
+    """
+    legacy = set(LEGACY_PATTERNS)
+    kept: list[str] = []
+    removed: list[str] = []
+    for ln in lines:
+        s = _strip(ln).lstrip()
+        if s in legacy or (s.startswith("/") and s[1:] in legacy):
+            removed.append(s)
+            continue
+        kept.append(ln)
+    return kept, removed
+
+
 def format_file(lines: list[str]) -> str:
     """Join lines with newlines and enforce exactly one trailing newline."""
     text = "\n".join(lines)
@@ -174,6 +214,9 @@ def main(argv: list[str] | None = None) -> int:
     ap.add_argument("--replace", action="store_true",
                     help="rewrite the block in full (discards user-added "
                          "lines inside the block)")
+    ap.add_argument("--cleanup-legacy", action="store_true",
+                    help="strip legacy patterns (pre-/agents/ layout) from "
+                         "anywhere in the file before syncing the block")
     ap.add_argument("--quiet", action="store_true",
                     help="suppress summary on success")
     args = ap.parse_args(argv)
@@ -193,6 +236,10 @@ def main(argv: list[str] | None = None) -> int:
         existing_text = ""
         existing_lines = []
 
+    removed_legacy: list[str] = []
+    if args.cleanup_legacy:
+        existing_lines, removed_legacy = cleanup_legacy(existing_lines)
+
     new_lines, added = sync_block(
         existing_lines, template_lines, replace=args.replace,
     )
@@ -211,6 +258,10 @@ def main(argv: list[str] | None = None) -> int:
             print(f"\n(dry-run) would add {len(added)} entr"
                   f"{'y' if len(added) == 1 else 'ies'} to {target}",
                   file=sys.stderr)
+            if removed_legacy:
+                print(f"(dry-run) would remove {len(removed_legacy)} legacy "
+                      f"entr{'y' if len(removed_legacy) == 1 else 'ies'}: "
+                      f"{', '.join(removed_legacy)}", file=sys.stderr)
         return 0
 
     target.parent.mkdir(parents=True, exist_ok=True)
@@ -219,6 +270,10 @@ def main(argv: list[str] | None = None) -> int:
         action = "replaced" if args.replace else "updated"
         print(f"✅  {target}: {action} block "
               f"({len(added)} entr{'y' if len(added) == 1 else 'ies'} added)")
+        if removed_legacy:
+            print(f"   removed {len(removed_legacy)} legacy "
+                  f"entr{'y' if len(removed_legacy) == 1 else 'ies'}: "
+                  f"{', '.join(removed_legacy)}")
     return 0
 
 

package/templates/claude_desktop_config.json.template

@@ -0,0 +1,21 @@
+{
+  "//": "Claude Desktop config template — agent-config",
+  "//1": "Copy this to one of:",
+  "//2": "  macOS   ~/Library/Application Support/Claude/claude_desktop_config.json",
+  "//3": "  Windows %APPDATA%\\Claude\\claude_desktop_config.json",
+  "//4": "  Linux   ~/.config/Claude/claude_desktop_config.json",
+  "//5": "Strip the leading '_disabled_' prefix on the mcpServers entry below to enable the MCP connector.",
+  "//6": "Hosted endpoint is read-only and identity-stable per release; full client setup details in docs/setup/mcp-client-config.md.",
+  "//7": "Restart Claude Desktop fully (Cmd+Q on macOS) after editing — the menubar process keeps the old config cached otherwise.",
+
+  "_disabled_mcpServers": {
+    "agent-config": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "mcp-remote",
+        "https://agent-config-mcp.event4u.workers.dev"
+      ]
+    }
+  }
+}

package/templates/cursor-rule.mdc.j2

@@ -0,0 +1,7 @@
+---
+description: {{ description }}
+globs: {{ globs | default("") }}
+alwaysApply: {{ "true" if always_apply else "false" }}
+---
+
+{{ body }}

package/templates/global-install-manifest.yml

@@ -0,0 +1,91 @@
+# Global Install Manifest — road-to-simplicity-and-everywhere Phase 3
+#
+# Curated subset of rules + skills shipped to user-scope directories
+# (~/.claude/, ~/.cursor/, ~/.codeium/windsurf/, ~/.config/agent-config/)
+# by `scripts/install --global`. Without curation we'd dump 200+ skills
+# into user dirs — that is the failure mode anthropics/claude-code#53950
+# flagged.
+#
+# Schema (v1):
+#   kernel_rules: list[str]   — rule IDs from router.json's `kernel`.
+#                               Always shipped to every enabled surface.
+#   top_skills:   list[entry] — curated universal skills.
+#     entry.id        : skill directory under .agent-src/skills/
+#     entry.surfaces  : subset of [claude-code, cursor, windsurf, fallback]
+#                       — fallback is always written.
+#
+# Source: kernel_rules mirrors router.json; top_skills is a 15-pick
+# distilled from .agent-src/skills/ — universal coding-loop helpers
+# (work, commit, PR, review, quality, analyze, handoff). Per-stack
+# skills (laravel, react-shadcn-ui, php-coder) stay project-local.
+#
+# Per-tool target paths (handled by scripts/install.py global subcommand):
+#   claude-code  : ~/.claude/skills/event4u/<id>/SKILL.md
+#                  ~/.claude/rules/event4u/<rule>.md
+#   cursor       : ~/.cursor/rules/imported/event4u/<rule>.mdc
+#                  ~/.cursor/skills/event4u/<id>/  (skills surface; mirrors agent-os)
+#   windsurf     : ~/.codeium/windsurf/global_workflows/event4u/<id>.md
+#   fallback     : ~/.config/agent-config/{rules,skills}/event4u/
+#
+# All writes are namespaced under `event4u/` so `--global --uninstall`
+# can `rm -rf` the namespace dir without touching user-added files.
+
+schema_version: 1
+
+# Always-loaded rules — mirrors router.json's `kernel` array.
+# Symlinked / copied into every enabled surface's rules dir.
+kernel_rules:
+  - agent-authority
+  - ask-when-uncertain
+  - commit-policy
+  - direct-answers
+  - language-and-tone
+  - no-cheap-questions
+  - non-destructive-by-default
+  - scope-control
+  - verify-before-complete
+
+# Top-N curated skills. The 15 picks below are coding-loop universals:
+# the agent reaches for them on almost any task, regardless of stack.
+# Per-stack and domain skills are deliberately omitted — they belong in
+# project-local installs where the stack signal is unambiguous.
+top_skills:
+  # --- Workflow drivers (most-touched commands) ---
+  - id: work
+    surfaces: [claude-code, cursor, windsurf, fallback]
+  - id: commit
+    surfaces: [claude-code, cursor, windsurf, fallback]
+  - id: create-pr
+    surfaces: [claude-code, cursor, windsurf, fallback]
+  - id: review-changes
+    surfaces: [claude-code, cursor, windsurf, fallback]
+  - id: quality-fix
+    surfaces: [claude-code, cursor, windsurf, fallback]
+
+  # --- Session / context management ---
+  - id: agent-handoff
+    surfaces: [claude-code, cursor, windsurf, fallback]
+  - id: agent-status
+    surfaces: [claude-code, cursor, windsurf, fallback]
+  - id: project-analyze
+    surfaces: [claude-code, cursor, windsurf, fallback]
+  - id: project-health
+    surfaces: [claude-code, cursor, windsurf, fallback]
+
+  # --- Investigation / debugging ---
+  - id: bug-investigate
+    surfaces: [claude-code, cursor, windsurf, fallback]
+  - id: bug-fix
+    surfaces: [claude-code, cursor, windsurf, fallback]
+  - id: systematic-debugging
+    surfaces: [claude-code, cursor, windsurf, fallback]
+
+  # --- Ticket / PR drivers ---
+  - id: implement-ticket
+    surfaces: [claude-code, cursor, windsurf, fallback]
+  - id: prepare-for-review
+    surfaces: [claude-code, cursor, windsurf, fallback]
+
+  # --- Onboarding (single command, surfaces a project) ---
+  - id: onboard
+    surfaces: [claude-code, cursor, windsurf, fallback]

package/templates/marketing-copy.yml

@@ -0,0 +1,64 @@
+# marketing-copy.yml — single source of truth for all marketplace
+# listings, GitHub repo metadata, npm package descriptions, and
+# README taglines. Edit here once; downstream surfaces sync on
+# `task generate-tools` (Phase 7 / S38 of road-to-simplicity-and-everywhere).
+
+tagline: >-
+  Shared agent configuration — skills, rules, and slash commands for
+  AI coding tools (Claude Code, Cursor, Windsurf, Cline, Aider,
+  Codex, Gemini CLI, Copilot, Augment).
+
+short_description: >-
+  Project-installable + global agent skill suite — works across
+  every major AI coding tool. One install, every editor.
+
+# GitHub repo topics (set via `gh repo edit --add-topic ...`).
+# Keep this list short and high-signal; GitHub caps display at ~6.
+github_topics:
+  - agent
+  - claude-code
+  - cursor
+  - windsurf
+  - cline
+  - mcp
+  - agents-md
+  - skill-files
+  - copilot
+  - aider
+
+# Marketplace listings (Anthropic, Cursor, Smithery) read these.
+listing:
+  name: event4u/agent-config
+  category: agent-tooling
+  primary_surface: claude-code
+  also_supports:
+    - claude-desktop
+    - cursor
+    - windsurf
+    - cline
+    - aider
+    - codex
+    - gemini-cli
+    - copilot
+    - augment
+
+# npm package metadata (synced into packages/create-agent-config/package.json
+# and any future @event4u/agent-config packages).
+npm:
+  package: "@event4u/create-agent-config"
+  description: >-
+    Zero-config installer for event4u/agent-config — picks tools,
+    runs the install, works in any directory.
+  keywords:
+    - agent
+    - claude
+    - cursor
+    - windsurf
+    - skills
+    - mcp
+
+# Authoritative URLs.
+urls:
+  homepage: https://github.com/event4u-app/agent-config
+  bugs: https://github.com/event4u-app/agent-config/issues
+  docs: https://github.com/event4u-app/agent-config/blob/main/docs/installation.md

package/templates/windsurf-rule.md.j2

@@ -0,0 +1,7 @@
+---
+trigger: {{ trigger }}
+description: {{ description }}
+globs: {{ globs | default("") }}
+---
+
+{{ body }}