pi-rolecast 0.2.0

package/scripts/scaffolder.py

@@ -0,0 +1,289 @@
+#!/usr/bin/env python3
+"""scaffolder.py — init / diff / validate CLI for project profiles.
+
+Subcommands:
+- init [--template LANG] [--blank] [--dry-run] [--force]
+- diff (spec §9.4)
+- validate (spec §9.5)
+
+Init flow: auto-detect language → load template → walk user through
+sections → write profile + custom-role README.
+"""
+from __future__ import annotations
+import argparse
+import os
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from profile_loader import ProfileError, load_profile
+
+
+# ─────────────────────────────────────────────────────────────────────
+# Language auto-detect (spec §9.2)
+# ─────────────────────────────────────────────────────────────────────
+
+LANGUAGE_MARKERS: list[tuple[str, list[str]]] = [
+    # (language, list of files; all required)
+    ("rust",       ["Cargo.toml"]),
+    ("python",     ["pyproject.toml"]),
+    ("python",     ["setup.py"]),
+    ("typescript", ["package.json", "tsconfig.json"]),
+    ("go",         ["go.mod"]),
+]
+
+
+def auto_detect_languages(project_root: str | Path) -> list[str]:
+    """Return ALL detected languages for a project (multi-lang aware).
+
+    Spec §9.2: package.json alone is ambiguous — caller must prompt user.
+    Both "typescript" and "javascript" are surfaced so the prompt can offer
+    both choices. detect_language() returns None in that case.
+    """
+    root = Path(project_root)
+    detected: list[str] = []
+    # package.json alone is ambiguous — handled separately.
+    if (root / "package.json").exists() and not (root / "tsconfig.json").exists():
+        detected.extend(["typescript", "javascript"])
+    for lang, files in LANGUAGE_MARKERS:
+        if all((root / f).exists() for f in files) and lang not in detected:
+            detected.append(lang)
+    return detected
+
+
+def detect_language(project_root: str | Path) -> str | None:
+    """Return the single best-guess language (spec §9.2 priority order),
+    or None if ambiguous / unknown.
+
+    Ambiguity is narrow: detected == ["typescript", "javascript"]
+    (package.json-only). Other languages override the ambiguity — e.g.
+    Cargo.toml + package.json still yields "rust" via priority order.
+    """
+    detected = auto_detect_languages(project_root)
+    if detected == ["typescript", "javascript"]:
+        # Spec §9.2 row 4 — caller must prompt.
+        return None
+    confident = [l for l in detected if l != "javascript"]
+    if len(confident) == 1:
+        return confident[0]
+    if len(confident) == 0:
+        return None
+    # Multiple confident matches — return first by priority order
+    priority = ["rust", "python", "typescript", "go"]
+    for p in priority:
+        if p in confident:
+            return p
+    return confident[0]
+
+
+# ─────────────────────────────────────────────────────────────────────
+# init subcommand (partial — template + profile generation in T9)
+# ─────────────────────────────────────────────────────────────────────
+
+def cmd_init(args: argparse.Namespace) -> int:
+    project_root = Path(args.project_root).resolve()
+    framework_root = Path(args.framework_root).resolve()
+    templates_dir = framework_root / "templates"
+    # v0.2.0: prefer new filename; fall back to legacy if --legacy-name is passed.
+    profile_dir = project_root / ".pi"
+    if getattr(args, "legacy_name", False):
+        profile_path = profile_dir / "agent-workflow.yaml"
+    else:
+        profile_path = profile_dir / "rolecast.yaml"
+
+    if args.template:
+        lang = args.template
+    elif args.blank:
+        lang = None
+    else:
+        lang = _prompt_language(project_root)
+
+    if args.dry_run:
+        print(f"DRY RUN — would create: {profile_path}")
+        print(f"template: {lang or '(blank)'}")
+        return 0
+
+    template_data = _load_template(templates_dir, lang) if lang else _blank_template()
+
+    if profile_path.exists() and not args.force:
+        print(f"profile already exists at {profile_path}; pass --force to overwrite",
+              file=sys.stderr)
+        return 1
+
+    profile_path.parent.mkdir(parents=True, exist_ok=True)
+    _write_profile(profile_path, template_data)
+    print(f"wrote {profile_path}")
+    print("next steps:")
+    print(f"  python3 {framework_root}/scripts/scaffolder.py validate --profile {profile_path}")
+    print(f"  python3 {framework_root}/scripts/gate_runner.py --profile {profile_path} --phase all")
+    return 0
+
+
+def _prompt_language(project_root: Path) -> str | None:
+    detected = auto_detect_languages(project_root)
+    if detected == ["typescript", "javascript"]:
+        # Spec §9.2 row 4 — caller must specify typescript or javascript.
+        print(
+            "Detected package.json without tsconfig.json.",
+            file=sys.stderr,
+        )
+        print(
+            "Specify --template typescript or --template javascript.",
+            file=sys.stderr,
+        )
+        return None
+    confident = [l for l in detected if l != "javascript"]
+    if not confident:
+        print("could not auto-detect language.", file=sys.stderr)
+        return None
+    if len(confident) > 1:
+        print(f"multiple languages detected: {confident}", file=sys.stderr)
+        print("use --template to pick one", file=sys.stderr)
+        return None
+    return confident[0]
+
+
+def _load_template(templates_dir: Path, lang: str) -> dict:
+    p = templates_dir / f"{lang}.yaml"
+    if not p.exists():
+        raise FileNotFoundError(f"no template for language '{lang}': {p}")
+    import yaml
+    return yaml.safe_load(p.read_text())
+
+
+def _blank_template() -> dict:
+    return {
+        "framework_version": "0.2.0",
+        "name": "",
+        "description": "",
+        "workflow": {"role_groups": []},
+        "gates": {},
+        "bindings": {},
+    }
+
+
+def _write_profile(path: Path, data: dict) -> None:
+    import yaml
+    path.write_text(yaml.safe_dump(data, sort_keys=False))
+
+
+# ─────────────────────────────────────────────────────────────────────
+# CLI dispatcher
+# ─────────────────────────────────────────────────────────────────────
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="scaffolder")
+    sub = p.add_subparsers(dest="command", required=True)
+
+    init = sub.add_parser("init", help="generate a profile for the current project")
+    init.add_argument("--template", help="language template to use (rust, typescript, python, go, blank)")
+    init.add_argument("--blank", action="store_true", help="emit a profile with no fields pre-filled")
+    init.add_argument("--dry-run", action="store_true", help="print what would be created, do not write")
+    init.add_argument("--force", action="store_true", help="overwrite existing profile")
+    init.add_argument("--project-root", default=".", help="project root (default: cwd)")
+    init.add_argument("--framework-root", default=str(Path(__file__).resolve().parent.parent))
+    init.add_argument("--interactive", action="store_true",
+                      help="walk through each profile section interactively (v2; v1 is a no-op)")
+    init.add_argument("--legacy-name", action="store_true",
+                      help="write to .pi/agent-workflow.yaml instead of .pi/rolecast.yaml")
+    init.set_defaults(func=cmd_init)
+
+    diff = sub.add_parser("diff", help="report schema differences vs current framework")
+    diff.add_argument("--profile", required=True, help="path to rolecast.yaml (or legacy agent-workflow.yaml)")
+    diff.add_argument("--framework-root", default=str(Path(__file__).resolve().parent.parent))
+    diff.set_defaults(func=cmd_diff)
+
+    validate = sub.add_parser("validate", help="validate a profile against current schema")
+    validate.add_argument("--profile", required=True, help="path to rolecast.yaml (or legacy agent-workflow.yaml)")
+    validate.add_argument("--framework-root", default=str(Path(__file__).resolve().parent.parent))
+    validate.set_defaults(func=cmd_validate)
+
+    return p
+
+
+# Stub implementations for diff + validate — filled in T10/T11.
+def cmd_diff(args) -> int:
+    """Report schema drift between profile.framework_version and the
+    current framework. Reads `added-fields.yaml` and `removed-fields.yaml`
+    from framework root for schema evolution metadata."""
+    import yaml
+    profile_path = Path(args.profile).resolve()
+    fw_root = Path(args.framework_root).resolve()
+    if not profile_path.exists():
+        print(f"profile not found: {profile_path}", file=sys.stderr)
+        return 1
+    raw = yaml.safe_load(profile_path.read_text())
+    if not isinstance(raw, dict):
+        print("profile is not a YAML mapping", file=sys.stderr)
+        return 1
+    profile_version = raw.get("framework_version")
+    if not profile_version:
+        print("profile.framework_version is required for diff", file=sys.stderr)
+        return 1
+
+    added_file = fw_root / "added-fields.yaml"
+    removed_file = fw_root / "removed-fields.yaml"
+    profile_fields = set(_flatten_keys(raw))
+
+    missing = []
+    if added_file.exists():
+        added_data = yaml.safe_load(added_file.read_text()) or {}
+        for f in added_data.get("added", []):
+            if f not in profile_fields:
+                missing.append(f)
+
+    print(f"profile framework_version: {profile_version}")
+    if missing:
+        print("fields missing from profile (added in newer framework):")
+        for f in missing:
+            print(f"  - {f}")
+    else:
+        print("no missing fields")
+
+    deprecated = []
+    if removed_file.exists():
+        removed_data = yaml.safe_load(removed_file.read_text()) or {}
+        for f in removed_data.get("removed", []):
+            if f in profile_fields:
+                deprecated.append(f)
+    if deprecated:
+        print("fields deprecated in newer framework:")
+        for f in deprecated:
+            print(f"  - {f}")
+
+    print("no auto-merge. apply changes manually.")
+    return 0
+
+
+def _flatten_keys(d: dict, prefix: str = "") -> list[str]:
+    out: list[str] = []
+    for k, v in d.items():
+        path = f"{prefix}.{k}" if prefix else k
+        if isinstance(v, dict):
+            out.extend(_flatten_keys(v, path))
+        else:
+            out.append(path)
+    return out
+
+
+def cmd_validate(args) -> int:
+    try:
+        profile = load_profile(args.profile, framework_root=args.framework_root)
+    except ProfileError as e:
+        print(f"INVALID: {e}", file=sys.stderr)
+        return 1
+    print(f"profile '{profile.name}' is valid (framework {profile.framework_version})")
+    print(f"  bindings resolved: {len(profile.resolved_bindings)}")
+    for role, rb in profile.resolved_bindings.items():
+        warn = f" [WARN: {rb.warning}]" if rb.warning else ""
+        print(f"    {role}: {rb.alias} -> {rb.model_id} on {rb.channel_id}{warn}")
+    return 0
+
+
+def main() -> int:
+    args = build_parser().parse_args()
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/sync_settings.py

@@ -0,0 +1,362 @@
+#!/usr/bin/env python3
+"""pi-rolecast/scripts/sync_settings.py
+
+Sync profile model bindings to pi dispatch config.
+
+Two outputs:
+
+1. **settings.json** (`~/.pi/agent/settings.json` or --settings path):
+   writes `subagents.agentOverrides.<full-role-name>` entries for each
+   binding. This is a soft hint used by some third-party extensions.
+
+2. **project-local agent files** (`.pi/agents/<full-role-name>.md` in cwd):
+   copies each role-packs/<group>/<role>.md template and overwrites its
+   `model:` and `thinking:` frontmatter fields with the bound values.
+   This is the authoritative dispatch path: the **pi-subagents**
+   extension reads `.pi/agents/<name>.md` (project) before any global
+   fallback and honours `model:` and `thinking:` frontmatter fields.
+
+v0.2.0 changes:
+  * Walks role-packs/<group>/<role>.md instead of hardcoded CORE_ROLES.
+  * Only emits roles for groups listed in `profile.workflow.role_groups`.
+  * Role names written to .pi/agents/ are the full prefixed names
+    (e.g. `coding-architect.md`) so they match the `<group>-<role>`
+    binding keys.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from profile_loader import (  # noqa: E402
+    ProfileError,
+    available_roles,
+    discover_role_packs,
+    load_profile,
+    load_registry,
+    resolve_bindings,
+)
+
+
+DEFAULT_SETTINGS = Path.home() / ".pi" / "agent" / "settings.json"
+
+
+# pi uses different provider keys than our registry's `vendor` field.
+VENDOR_TO_PROVIDER = {
+    "minimax": "minimax-cn",
+    "deepseek": "deepseek",
+    "openai": "openai-codex",
+    "anthropic": "anthropic",
+    "moonshotai": "kimi-coding",
+    "kimi-coding": "kimi-coding",
+    "typesafe": "typesafe",
+}
+
+
+def _provider_for_model(model_id: str, registry) -> str:
+    """Look up pi provider for a model id. Returns "" if unknown.
+
+    Resolution order:
+    1. explicit `provider` attribute on the model (registry-overrides.yaml)
+    2. vendor -> VENDOR_TO_PROVIDER mapping
+    3. vendor itself
+    4. "" (caller should fall back to plain modelId)
+    """
+    if registry is None:
+        return ""
+    if hasattr(registry, "_models"):
+        model = registry._models.get(model_id)
+        if model is not None:
+            if hasattr(model, "provider") and model.provider:
+                return model.provider
+            vendor = getattr(model, "vendor", "") or ""
+            if vendor in VENDOR_TO_PROVIDER:
+                return VENDOR_TO_PROVIDER[vendor]
+            if vendor:
+                return vendor
+        return ""
+    for m in registry.get("models", []) or []:
+        if m.get("id") == model_id:
+            if m.get("provider"):
+                return m["provider"]
+            vendor = m.get("vendor", "")
+            if vendor in VENDOR_TO_PROVIDER:
+                return VENDOR_TO_PROVIDER[vendor]
+            if vendor:
+                return vendor
+            break
+    return ""
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Sync profile bindings to pi dispatch config + project-local agent files."
+    )
+    parser.add_argument("--profile", type=Path, default=None,
+                        help="profile path (default: .pi/rolecast.yaml in cwd; "
+                             "falls back to legacy .pi/agent-workflow.yaml)")
+    parser.add_argument("--settings", type=Path, default=DEFAULT_SETTINGS)
+    parser.add_argument("--framework-root", type=Path, default=None)
+    parser.add_argument("--agents-dir", type=Path,
+                        default=Path.cwd() / ".pi" / "agents",
+                        help="project-local agent directory (default: .pi/agents)")
+    parser.add_argument("--clear", action="store_true",
+                        help="remove framework role entries from settings.json and delete "
+                             "project-local agent files written by sync")
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--no-agents", action="store_true",
+                        help="skip writing project-local agent files (settings.json only)")
+    parser.add_argument("--no-settings", action="store_true",
+                        help="skip writing settings.json (agent files only)")
+    parser.add_argument("--status", action="store_true",
+                        help="show current sync state vs profile bindings (no changes)")
+    parser.add_argument("--list-groups", action="store_true",
+                        help="list available role groups from role-packs/ and exit")
+    args = parser.parse_args()
+
+    if args.framework_root is None:
+        args.framework_root = Path(__file__).resolve().parent.parent
+
+    if args.list_groups:
+        packs = discover_role_packs(args.framework_root)
+        if not packs:
+            print("(no role-packs/* directories found under framework root)")
+            return 0
+        for g, roles in packs.items():
+            print(f"{g}/ ({len(roles)} roles): " + ", ".join(r.full_name for r in roles))
+        return 0
+
+    if args.clear:
+        # --clear is a standalone cleanup operation — does NOT need a profile.
+        rc1 = _clear_settings(args.settings, args.dry_run)
+        rc2 = _clear_agents(args.agents_dir, args.framework_root, args.dry_run)
+        return rc1 or rc2
+
+    if args.profile is None:
+        from profile_loader import find_profile
+        discovered = find_profile(Path.cwd())
+        if discovered is None:
+            print("error: no profile found (looked for .pi/rolecast.yaml "
+                  "and legacy .pi/agent-workflow.yaml in cwd)", file=sys.stderr)
+            return 2
+        args.profile = discovered
+
+    if not args.profile.exists():
+        print("error: profile not found: " + str(args.profile), file=sys.stderr)
+        return 2
+    try:
+        profile = load_profile(args.profile, framework_root=args.framework_root)
+    except ProfileError as e:
+        print("error: profile invalid: " + str(e), file=sys.stderr)
+        return 2
+
+    registry = try_load_registry(args.framework_root)
+    resolved = resolve_bindings(profile, registry)
+
+    # Build new_overrides using FULL role names (e.g. coding-architect).
+    new_overrides = {}
+    for role, binding in resolved.items():
+        new_overrides[role] = {"model": binding.model_id, "channel": binding.channel_id}
+
+    if args.status:
+        return _show_status(args.profile, args.settings, args.agents_dir,
+                            args.framework_root, new_overrides)
+
+    rc1 = rc2 = 0
+    if not args.no_settings:
+        rc1 = _merge_and_write(args.settings, new_overrides, args.dry_run)
+    if not args.no_agents:
+        rc2 = _write_agents(args.agents_dir, args.framework_root, profile.workflow.role_groups,
+                            new_overrides, args.dry_run, registry)
+    return rc1 or rc2
+
+
+def _merge_and_write(settings_path: Path, new_overrides: dict, dry_run: bool) -> int:
+    settings = _read_settings(settings_path)
+    subagents = settings.get("subagents", {})
+    existing_overrides = subagents.get("agentOverrides", {}) or {}
+    merged = dict(existing_overrides)
+    for role, override in new_overrides.items():
+        merged[role] = override
+    subagents["agentOverrides"] = merged
+    settings["subagents"] = subagents
+    return _write_settings(settings_path, settings, dry_run,
+                           "synced " + str(len(new_overrides)) + " roles in settings.json")
+
+
+def _clear_settings(settings_path: Path, dry_run: bool) -> int:
+    """Remove ALL agentOverrides entries — we can't tell which are framework
+    ones without the profile, so --clear drops everything. Users with custom
+    overrides should re-merge manually."""
+    settings = _read_settings(settings_path)
+    subagents = settings.get("subagents", {})
+    existing = subagents.get("agentOverrides", {}) or {}
+    removed = list(existing.keys())
+    subagents["agentOverrides"] = {}
+    settings["subagents"] = subagents
+    return _write_settings(settings_path, settings, dry_run,
+                           "removed " + str(len(removed)) + " agent overrides from settings.json")
+
+
+def _show_status(profile_path: Path, settings_path: Path, agents_dir: Path,
+                 framework_root: Path, expected_overrides: dict) -> int:
+    """Show diff between profile bindings and currently-synced state."""
+    import re
+    fm_re = re.compile(r"^model:\s*(.+?)\s*$", re.MULTILINE)
+    print("=" * 70)
+    print(" pi-rolecast sync status")
+    print("=" * 70)
+
+    # Profile bindings
+    print("\nProfile bindings (" + str(profile_path) + "):")
+    if not expected_overrides:
+        print("  (no bindings)")
+    for role in sorted(expected_overrides):
+        ov = expected_overrides[role]
+        print("  " + role.ljust(22) + " model=" + ov["model"].ljust(26) +
+              " channel=" + ov["channel"])
+
+    # Project-local agent files
+    print("\nProject-local agent files (" + str(agents_dir) + "):")
+    if not expected_overrides:
+        print("  (nothing to check — no profile bindings)")
+    for role in sorted(expected_overrides):
+        path = agents_dir / (role + ".md")
+        if not path.exists():
+            print("  " + role.ljust(22) + " (missing)")
+            continue
+        text = path.read_text()
+        m = fm_re.search(text)
+        actual = m.group(1) if m else "(no model)"
+        expected = expected_overrides[role]["model"]
+        match = "OK" if actual == expected else "DRIFT"
+        print("  " + role.ljust(22) + " model=" + actual.ljust(26) + " " + match)
+
+    # Settings.json
+    settings = _read_settings(settings_path)
+    subagents = settings.get("subagents", {})
+    overrides = subagents.get("agentOverrides", {}) or {}
+    expected_set = set(expected_overrides.keys())
+    framework_overrides = {r: v for r, v in overrides.items() if r in expected_set}
+    print("\nsettings.json: " + str(settings_path))
+    print("  framework overrides: " + str(len(framework_overrides)) + "/" + str(len(expected_set)))
+    return 0
+
+
+def _write_agents(agents_dir: Path, framework_root: Path,
+                  enabled_groups: list[str], new_overrides: dict,
+                  dry_run: bool, registry) -> int:
+    """Write project-local copies of role-packs/<group>/<role>.md for every
+    bound role. Uses full role name (`<group>-<role>`) as the filename so
+    pi-subagents can find it via @<full-name> mention syntax."""
+    roles = available_roles(framework_root, groups=enabled_groups or None)
+    if dry_run:
+        for role_full_name, rd in sorted(roles.items()):
+            if role_full_name not in new_overrides:
+                continue
+            model_id = new_overrides[role_full_name]["model"]
+            provider = _provider_for_model(model_id, registry)
+            full = (provider + "/" + model_id) if provider else model_id
+            print("would write " + str(agents_dir / (role_full_name + ".md")) +
+                  " model=" + full)
+        return 0
+    agents_dir.mkdir(parents=True, exist_ok=True)
+    written = 0
+    for role_full_name, rd in sorted(roles.items()):
+        if role_full_name not in new_overrides:
+            continue
+        src = rd.file_path
+        if src is None or not src.exists():
+            print("warning: role-packs file not found: " + str(rd.file_path),
+                  file=sys.stderr)
+            continue
+        dst = agents_dir / (role_full_name + ".md")
+        body = src.read_text()
+        model_id = new_overrides[role_full_name]["model"]
+        provider = _provider_for_model(model_id, registry)
+        full = (provider + "/" + model_id) if provider else model_id
+        updated = _set_frontmatter_field(body, "model", full)
+        dst.write_text(updated)
+        written += 1
+    print("wrote " + str(written) + " project-local agent files to " + str(agents_dir))
+    return 0
+
+
+def _clear_agents(agents_dir: Path, framework_root: Path, dry_run: bool) -> int:
+    """Remove all project-local agent files (any *.md). Custom files outside
+    the role pack should be backed up first — we don't try to detect
+    framework vs user here because v0.2.0 always uses prefixed names."""
+    if not agents_dir.exists():
+        print("no project-local agent dir at " + str(agents_dir))
+        return 0
+    removed = 0
+    for path in sorted(agents_dir.glob("*.md")):
+        if path.is_symlink():
+            continue
+        if dry_run:
+            print("would remove " + str(path))
+            removed += 1
+            continue
+        path.unlink()
+        removed += 1
+    print("removed " + str(removed) + " project-local agent files")
+    return 0
+
+
+def _set_frontmatter_field(body: str, field: str, value: str) -> str:
+    """Replace or insert `field: value` in the file's frontmatter block."""
+    lines = body.splitlines()
+    if not lines or lines[0].strip() != "---":
+        new_front = ["---", field + ": " + value, "---", ""]
+        return "\n".join(new_front) + body
+    try:
+        end = lines.index("---", 1)
+    except ValueError:
+        return body
+    prefix = field + ":"
+    new_lines = []
+    replaced = False
+    for ln in lines[1:end]:
+        if ln.startswith(prefix) and not replaced:
+            new_lines.append(field + ": " + value)
+            replaced = True
+        else:
+            new_lines.append(ln)
+    if not replaced:
+        new_lines.append(field + ": " + value)
+    return "\n".join(lines[:1] + new_lines + lines[end:])
+
+
+def _write_settings(path: Path, settings: dict, dry_run: bool, summary: str) -> int:
+    if dry_run:
+        print(json.dumps(settings, indent=2, sort_keys=True))
+        return 0
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(settings, indent=2, sort_keys=True) + "\n")
+    print(summary + ": " + str(path))
+    return 0
+
+
+def _read_settings(path: Path) -> dict:
+    if not path.exists():
+        return {}
+    text = path.read_text()
+    if not text.strip():
+        return {}
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        return {}
+
+
+def try_load_registry(framework_root: Path):
+    """Wrapper for tests to monkey-patch."""
+    return load_registry(framework_root)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/templates/blank.yaml

@@ -0,0 +1,13 @@
+framework_version: 0.2.0
+name: my-project
+description: |
+  (describe your workflow here)
+
+workflow:
+  # Enable groups as the framework ships them. Example for future video group:
+  #   role_groups: [coding, video]
+  role_groups: []
+
+gates: {}
+
+bindings: {}